PL/SQL Profiling 2: Hierarchical Profiler

This article describes the use of Oracle’s hierarchical PL/SQL profiler (DBMS_HProf) on two example program structures. The examples are designed to illustrate its behaviour over as many different scenarios as possible, while keeping the examples as simple as possible. It’s based on an article published in March 2013 on the hierarchical profiler and updated shortly thereafter with the inclusion of Oracle’s older flat profiler and of custom code timing. In June 2020 installation and source code were put onto GitHub, and the article was restructured into an overview article with the detail on the three profiling methods as separate articles, of which this is the first. Here are links to the other three articles:

PL/SQL Profiling 1: Overview
PL/SQL Profiling 3: Flat Profiler
PL/SQL Profiling 4: Custom Code Timing

All source code, including installation scripts, is available on GitHub:
GitHub: Oracle PL/SQL Profiling
Tweet with recording attached

Setup

The hierarchical profiler setup and use is described in the Oracle document Using the PL/SQL Hierarchical Profiler. The GitHub project linked to above includes scripts for setup of prerequisites such as grants and tables, and for installation of the custom code used for this demonstration. As described in the overview article, there are two example scripts profiled.

  • Example 1: General. This covers a wide range of scenarios
  • Example 2: Sleep. This covers the particular example of DBMS_Lock.Sleep

PL/SQL Hierarchical Profiler: Data Model

Example 1: General

The example was descibed in PL/SQL Profiling 1: Overview. The driver script is shown below:

SET TIMING ON
PROMPT B1: Start profiling; A_Calls_B 
DECLARE
  l_call_count       PLS_INTEGER := 0;
BEGIN

  HProf_Utils.Start_Profiling;
  Prof_Test.A_Calls_B(l_call_count);

END;
/
PROMPT SQL: Static DB function call
SELECT Prof_Test.DBFunc
  FROM DUAL;

PROMPT B2: Static DB function; dynamic SQL; object constructor
DECLARE
  l_cur              SYS_REFCURSOR;
  l_ret_val          PLS_INTEGER;
  l_tab_count        Table_Count_Type;

BEGIN

  SELECT Prof_Test.DBFunc
    INTO l_ret_val
    FROM DUAL;

  OPEN l_cur FOR 'SELECT Count(*) FROM all_tab_columns'; 
  FETCH l_cur INTO l_ret_val; 
  CLOSE l_cur;

  l_tab_count := Table_Count_Type('EMP');

END;
/
PROMPT B3: R_Calls_R; stop profiling
VAR RUN_ID NUMBER
DECLARE
  l_call_count       PLS_INTEGER := 0;
BEGIN

  Prof_Test.R_Calls_R(l_call_count);

  :RUN_ID := HProf_Utils.Stop_Profiling(
    p_run_comment => 'Profile for small test program with recursion',
    p_filename    => 'hp_example_general.html');
  Utils.W('Run id is ' || :RUN_ID);
END;
/
SET TIMING OFF
@hprof_queries :RUN_ID

The script is structured as an anonymous block, B1, then a stand-alone SQL query, followed by two more anonymous blocks, B2 and B3. Profiling is started by a call to DBMS_Profiler.Start_Profiler in the first block.

The last block includes a call to a custom utility, HProf_Utils.Stop_Profiling, that stops the profiling and analyses the trace file created in two ways:

  • Writing a (standard) HTML report on the results using a DBMS_HProf call
  • Writing the results to standard tables created during installation using a DBMS_HProf call

The custom queries are run at the end from the script hprof_queries.sql, passing in the run identifier that’s been saved in a bind variable.

Results for Example 1: General

The results in this section come from the script hprof_queries.sql that queries the tables populated by the analyse step.

The record produced in the run table, DBMSHP_RUNS, was:

 Run Id Run Time                      Microsecs Seconds Comment
------- ---------------------------- ---------- ------- ------------------------------------------------------------
     12 02-JUN-20 06.30.37.128000 AM     823833   0.820 Profile for small test program with recursion

The records produced in the functions table, DBMSHP_FUNCTION_INFO, were:

Owner Module            Sy Function                  Line# Subtree MicroS Function MicroS Calls
----- ---------------- --- ------------------------- ----- -------------- --------------- -----
APP   HPROF_UTILS        4 STOP_PROFILING               61             26              26     1
APP   PROF_TEST          5 A_CALLS_B                    71         128199            9631     1
APP   PROF_TEST          6 A_CALLS_B@1                  71          87951           27332     1
APP   PROF_TEST          7 B_CALLS_A                    63         118568           30617     1
APP   PROF_TEST          8 B_CALLS_A@1                  63          60619           60619     1
APP   PROF_TEST          9 DBFUNC                      134          62114           62114     2
APP   PROF_TEST         10 R_CALLS_R                   114          27684            9234     1
APP   PROF_TEST         11 R_CALLS_R@1                 114          18428           18426     1
APP   PROF_TEST         12 __pkg_init                    0              3               3     1
APP   TABLE_COUNT_TYPE  13 TABLE_COUNT_TYPE             50         521332              31     1
APP   TABLE_COUNT_TYPE  22 __static_sql_exec_line55     55         521301          521301     1
SYS   DBMS_HPROF        14 STOP_PROFILING              747              0               0     1
SYS   DBMS_HPROF        23 __static_sql_exec_line700   700             67              67     1
SYS   DBMS_OUTPUT       15 GET_LINES                   180             79              79     3
SYS   DBMS_OUTPUT       16 NEW_LINE                    117              0               0     2
SYS   DBMS_OUTPUT       17 PUT                          77             23              23     2
SYS   DBMS_OUTPUT       18 PUT_LINE                    109             24               1     2
                         1 __anonymous_block             0        1818326             590     5
                         2 __plsql_vm                    0        1848468              17     6
                         3 __plsql_vm@1                  0          31993               4     1
                        19 __dyn_sql_exec_line12        12         133537          133537     1
                        20 __sql_fetch_line13           13        1100678         1100678     1
                        21 __static_sql_exec_line8       8          34400            2407     1

23 rows selected.

The “Subtree MicroS” and “Function MicroS” values are the total times in microseconds for the subtree including function, and function-only processing, respectively.

In the “Function” column, as well as procedure and function names in upper case, there are a number of names with a prefix “__”. The meanings of these are outlined in a table in the Oracle document mentioned above and reproduced below:


Notice that some of the function names have a suffix “@1”. These correspond to recursive calls, as will be clear from the network diagram later.

The records produced in the functions parent-child table, DBMSHP_PARENT_CHILD_INFO, (with joins to DBMSHP_FUNCTION_INFO to get parent and child function details) were:

Parent: Module            Sy Function                       Child:  Module            Sy Function                       Subtree MicroS Function MicroS Calls
------- ---------------- --- ------------------------------ ------- ---------------- --- ------------------------------ -------------- --------------- -----
APP     HPROF_UTILS        4 STOP_PROFILING                 SYS     DBMS_HPROF        14 STOP_PROFILING                              0               0     1
APP     PROF_TEST          5 A_CALLS_B                      APP     PROF_TEST          7 B_CALLS_A                              118568           30617     1
APP     PROF_TEST          7 B_CALLS_A                      APP     PROF_TEST          6 A_CALLS_B@1                             87951           27332     1
APP     PROF_TEST         11 R_CALLS_R@1                    SYS     DBMS_OUTPUT       18 PUT_LINE                                    2               0     1
APP     PROF_TEST          6 A_CALLS_B@1                    APP     PROF_TEST          8 B_CALLS_A@1                             60619           60619     1
APP     PROF_TEST         10 R_CALLS_R                      APP     PROF_TEST         11 R_CALLS_R@1                             18428           18426     1
APP     PROF_TEST         10 R_CALLS_R                      SYS     DBMS_OUTPUT       18 PUT_LINE                                   22               1     1
APP     TABLE_COUNT_TYPE  13 TABLE_COUNT_TYPE               APP     TABLE_COUNT_TYPE  22 __static_sql_exec_line55               521301          521301     1
SYS     DBMS_OUTPUT       18 PUT_LINE                       SYS     DBMS_OUTPUT       17 PUT                                        23              23     2
SYS     DBMS_OUTPUT       18 PUT_LINE                       SYS     DBMS_OUTPUT       16 NEW_LINE                                    0               0     2
                           1 __anonymous_block                                        21 __static_sql_exec_line8                 34400            2407     1
                           1 __anonymous_block                                        20 __sql_fetch_line13                    1100678         1100678     1
                           1 __anonymous_block                                        19 __dyn_sql_exec_line12                  133537          133537     1
                           1 __anonymous_block              SYS     DBMS_OUTPUT       15 GET_LINES                                  79              79     3
                           1 __anonymous_block              APP     TABLE_COUNT_TYPE  13 TABLE_COUNT_TYPE                       521332              31     1
                           1 __anonymous_block              APP     PROF_TEST         10 R_CALLS_R                               27684            9234     1
                           3 __plsql_vm@1                   APP     PROF_TEST          9 DBFUNC                                  31989           31989     1
                           2 __plsql_vm                     APP     PROF_TEST          9 DBFUNC                                  30125           30125     1
                           1 __anonymous_block              APP     HPROF_UTILS        4 STOP_PROFILING                             26              26     1
                           2 __plsql_vm                                                1 __anonymous_block                     1818326             590     5
                          21 __static_sql_exec_line8                                   3 __plsql_vm@1                            31993               4     1

21 rows selected.

The “Subtree MicroS” and “Function MicroS” values are the total times in microseconds for the subtree including function, and function-only processing, respectively, for the child function while called from all instances of the parent.

Network Diagrams for Example 1: General

The DBMSHP_PARENT_CHILD_INFO holds parent-child links between functions, while the function detail information is held in DBMSHP_FUNCTION_INFO. The following three columns occur in both tables (descriptions from the Oracle doc):

  • SUBTREE_ELAPSED_TIME – Elapsed time, in microseconds, for subprogram, including time spent in descendant subprograms
  • FUNCTION_ELAPSED_TIME – Elapsed time, in microseconds, for subprogram, excluding time spent in descendant subprograms
  • CALLS – Number of calls to subprogram

In the DBMSHP_FUNCTION_INFO they are aggregates for the subprogram overall, whereas in the DBMSHP_PARENT_CHILD_INFO they are aggregates for the subprogram when called from its parent.

The data in the tables represent a directed network (or ‘digraph’) of nodes and links. A root node is defined as a node that has no parent node, and we may have isolated root nodes that do not appear in the links table. It can sometimes be useful when querying network data to add a dummy node as a parent of all the root nodes, creating a single root for the network and ensuring all the non-dummy nodes appear as child nodes in the adjusted links set. Here is a diagram of the adjusted network for this example, with just the links and the function numbers included:


Notice that there are four (real) root nodes, two of which are isolated. Notice also that there are two loops in the network, whereby nodes (functions) 9 and 18 can be reached by two different paths each. However, there are no cycles since no node is both ancestor and descendant of another.

We can display more of the information the HProf utility produces in extended versions of the network diagram, where we’ll separate the network into its four subnetworks, shown in two diagrams.


This diagram, of the first subnetwork, has the function names and shows the total elapsed times used by the functions within the nodes, and the elapsed times used by the functions when called by their parents within the links.

Loops and Hierarchies

The diagram shows two loops, where there are two routes between the loop start and end points, indicated by different colours. The second loop has two child nodes coming from the end point, and hierarchical queries (both CONNECT BY and recursive subquery factors in Oracle) cause the links to them to be duplicated. We’ll see how to filter out the duplicates in the queries section below.


This diagram is for the other three subnetworks.

Network Query Output for Example 1: General

Function tree                   Sy Owner Module           Inst.  Subtree MicroS Function MicroS Calls Row
------------------------------ --- ----- ---------------- ------ -------------- --------------- ----- ---
__plsql_vm                       2                                      1848468              17     6   1
  __anonymous_block              1                                      1818326             590     5   2
    __sql_fetch_line13          20                                      1100678         1100678     1   3
    TABLE_COUNT_TYPE            13 APP   TABLE_COUNT_TYPE                521332              31     1   4
      __static_sql_exec_line55  22 APP   TABLE_COUNT_TYPE                521301          521301     1   5
    __dyn_sql_exec_line12       19                                       133537          133537     1   6
    __static_sql_exec_line8     21                                        34400            2407     1   7
      __plsql_vm@1               3                                        31993               4     1   8
        DBFUNC                   9 APP   PROF_TEST        1 of 2          31989           31989     1   9
    R_CALLS_R                   10 APP   PROF_TEST                        27684            9234     1  10
      R_CALLS_R@1               11 APP   PROF_TEST                        18428           18426     1  11
        PUT_LINE                18 SYS   DBMS_OUTPUT      1 of 2              2               0     1  12
          PUT                   17 SYS   DBMS_OUTPUT      1 of 2             23              23     2  13
          NEW_LINE              16 SYS   DBMS_OUTPUT      1 of 2              0               0     2  14
      PUT_LINE                  18 SYS   DBMS_OUTPUT      2 of 2             22               1     1  15
    GET_LINES                   15 SYS   DBMS_OUTPUT                         79              79     3  18
    STOP_PROFILING               4 APP   HPROF_UTILS                         26              26     1  19
      STOP_PROFILING            14 SYS   DBMS_HPROF                           0               0     1  20
  DBFUNC                         9 APP   PROF_TEST        2 of 2          30125           30125     1  21
A_CALLS_B                        5 APP   PROF_TEST                       128199            9631     1  22
  B_CALLS_A                      7 APP   PROF_TEST                       118568           30617     1  23
    A_CALLS_B@1                  6 APP   PROF_TEST                        87951           27332     1  24
      B_CALLS_A@1                8 APP   PROF_TEST                        60619           60619     1  25
__static_sql_exec_line700       23 SYS   DBMS_HPROF                          67              67     1  26
__pkg_init                      12 APP   PROF_TEST                            3               3     1  27

25 rows selected.

The report query script hprof_queries.sql queries the network in two ways, using Oracle’s proprietary Connect By syntax, and also using the ANSI standard recursive subquery factoring. The output above comes from the recursive subquery factoring query. The query code is discussed in a later section.

Notes on Output

Recursive Calls – “@1” Suffix

The hierarchical profiler appends a suffix “@1” on to functions called recursively, as in A_CALLS_B@1 and B_CALLS_A@1 which is an example of mutual recursion between A_CALLS_B and B_CALLS_A.

Anonymous Block (__anonymous_block)

This function corresponds to invocations of anonymous blocks, obviously enough. However, there is an apparent anomaly in the number of calls listed, 5, because the driving program has only three such blocks, and there are none in the called PL/SQL code. I would surmise that the apparent discrepancy arises from the enabling of SERVEROUTPUT, which appears to result in a secondary block being associated with each explicit SQL*Plus block, that issues a call to GET_LINES to process buffered output.

PL/SQL Engine (__plsql_vm)

This function corresponds to external invocations of PL/SQL such as from a SQL*Plus session. There are 6 calls, 5 of them presumably being linked with the external anonymous blocks, and the 6’th with DBFUNC, where a PL/SQL function is called from a SQL statement from SQL*Plus.

Notice that the SQL statement calling a database function from within PL/SQL generates the recursive call to the engine, __plsql_vm@1

Package Initialization (__pkg_init)

The Prof_Test package has a package variable g_num that is initialized to 0 on first invocation, which gives rise to the __pkg_init function in the output.

Second Root (A_CALLS_B)

The above function does not have the __plsql_vm/__anonymous_block ancestry that might be expected because profiling only started within the enclosing block.

Inlined Procedure (Rest_a_While)

I wrote a small procedure, Rest_a_While, to generate some elapsed time in the recursive procedures, but preceded it with the INLINE pragma, an optimization feature new in 11g. This had the desired effect of removing the calls from the profiling output and including the times in the calling procedures. Rest_a_While does not make the obvious call to DBMS_Lock.Sleep because that procedure cannot be inlined. subprogram inlining in 11g provides some analysis of the inlining feature.

Link Duplication

As mentioned earlier, hierarchical queries cause links to be duplicated below any loops, as the queries follow all paths. However, in the output above we have a single record for each of the links, including the additional root node dummy links. This is achieved by filtering out the duplicates in an additional subquery. The “Inst.” column lists the instance number of a function having more than one instance, and the children of any such function are only listed once with the gaps in the “Row” column indicating where duplicates have been suppressed (rows 13 and 14 are omitted here).

Example 2: Sleep

The example was descibed in PL/SQL Profiling 1: Overview. The driver script is shown below:

SET TIMING ON
VAR RUN_ID NUMBER
BEGIN

  HProf_Utils.Start_Profiling;
  DBMS_Lock.Sleep(3);

  DBMS_Lock.Sleep(6);

  :RUN_ID := HProf_Utils.Stop_Profiling(
    p_run_comment => 'Profile for DBMS_Lock.Sleep',
    p_filename    => 'hp_example_sleep.html');
  Utils.W('Run id is ' || :RUN_ID);
END;
/
SET TIMING OFF
@hprof_queries :RUN_ID

The script runs the start profiling procedure, then makes calls to a system procedure, DBMS_Lock.Sleep, which sleeps without using CPU time, then inserts to a table with a Before Insert trigger that calls a custom sleep procedure, Utils.Sleep, and finally calls a custom utility that stops the profiling and analyses the trace file created. Utils.Sleep itself calls DBMS_Lock.Sleep to do non-CPU sleeping and also runs a mathematical operation in a loop to use CPU time. The trace file is analysed in two ways:

  • Writing a (standard) HTML report on the results using a DBMS_HProf call
  • Writing the results to standard tables created during installation using a DBMS_HProf call

The custom queries are run at the end from the script hprof_queries.sql, passing in the run identifier that’s been saved in a bind variable.

Results for Example 2: Sleep

The results in this section come from the script hprof_queries.sql that queries the tables populated by the analyse step.

The record produced in the run table, DBMSHP_RUNS, was:

 Run Id Run Time                      Microsecs Seconds Comment
------- ---------------------------- ---------- ------- ------------------------------------------------------------
     22 18-JUN-20 12.49.56.816000 PM   10997855  11.000 Profile for DBMS_Lock.Sleep

The records produced in the functions table, DBMSHP_FUNCTION_INFO, were:

Owner Module            Sy Function                  Line# Subtree MicroS Function MicroS Calls
----- ---------------- --- ------------------------- ----- -------------- --------------- -----
APP   HPROF_UTILS        2 STOP_PROFILING               61             87              87     1
APP   SLEEP_BI           3 SLEEP_BI                      0        1999602             327     1
LIB   UTILS              4 SLEEP                       351        1999268          999837     1
LIB   UTILS              5 __pkg_init                    0              2               2     1
LIB   UTILS              6 __pkg_init                    0              5               5     1
SYS   DBMS_HPROF         7 STOP_PROFILING              747              0               0     1
SYS   DBMS_HPROF        11 __static_sql_exec_line700   700             77              77     1
SYS   DBMS_LOCK          8 SLEEP                       207        9997626         9997626     3
SYS   DBMS_LOCK          9 __pkg_init                    0              3               3     1
                         1 __plsql_vm                    0        1999606               4     1
                        10 __static_sql_exec_line6       6        2005266            5660     1

11 rows selected.

The “Subtree MicroS” and “Function MicroS” values are the total times in microseconds for the subtree including function, and function-only processing, respectively.

The records produced in the functions parent-child table, DBMSHP_PARENT_CHILD_INFO, (with joins to DBMSHP_FUNCTION_INFO to get parent and child function details) were:

Parent: Module            Sy Function                       Child:  Module            Sy Function                       Subtree MicroS Function MicroS Calls
------- ---------------- --- ------------------------------ ------- ---------------- --- ------------------------------ -------------- --------------- -----
APP     HPROF_UTILS        2 STOP_PROFILING                 SYS     DBMS_HPROF         7 STOP_PROFILING                              0               0     1
APP     SLEEP_BI           3 SLEEP_BI                       LIB     UTILS              5 __pkg_init                                  2               2     1
APP     SLEEP_BI           3 SLEEP_BI                       LIB     UTILS              6 __pkg_init                                  5               5     1
APP     SLEEP_BI           3 SLEEP_BI                       LIB     UTILS              4 SLEEP                                 1999268          999837     1
LIB     UTILS              4 SLEEP                          SYS     DBMS_LOCK          8 SLEEP                                  999431          999431     1
                          10 __static_sql_exec_line6                                   1 __plsql_vm                            1999606               4     1
                           1 __plsql_vm                     APP     SLEEP_BI           3 SLEEP_BI                              1999602             327     1

7 rows selected.

The “Subtree MicroS” and “Function MicroS” values are the total times in microseconds for the subtree including function, and function-only processing, respectively, for the child function while called from all instances of the parent.

Network Diagrams for Example 2: Sleep



The network diagram shows 5 nodes appearing as (real) roots, of which one (8) is also linked as a child.


The extended network diagram with function names and times included shows 9 seconds of time used by the SLEEP function in two root-level calls
and 1 second in a third call as the child of the custom Utils Sleep function.

Network Query Output for Example 2: Sleep

Function tree                   Sy Owner Module           Inst.  Subtree MicroS Function MicroS Calls Row
------------------------------ --- ----- ---------------- ------ -------------- --------------- ----- ---
SLEEP                            8 SYS   DBMS_LOCK        1 of 2        8998195         8998195     2   1
__static_sql_exec_line6         10                                      2005266            5660     1   2
  __plsql_vm                     1                                      1999606               4     1   3
    SLEEP_BI                     3 APP   SLEEP_BI                       1999602             327     1   4
      SLEEP                      4 LIB   UTILS                          1999268          999837     1   5
        SLEEP                    8 SYS   DBMS_LOCK        2 of 2         999431          999431     1   6
      __pkg_init                 6 LIB   UTILS                                5               5     1   7
      __pkg_init                 5 LIB   UTILS                                2               2     1   8
STOP_PROFILING                   2 APP   HPROF_UTILS                         87              87     1   9
  STOP_PROFILING                 7 SYS   DBMS_HPROF                           0               0     1  10
__static_sql_exec_line700       11 SYS   DBMS_HPROF                          77              77     1  11
__pkg_init                       9 SYS   DBMS_LOCK                            3               3     1  12

12 rows selected.

Oracle HProf HTML Reports

A standard HTML report can be produced after the profiling is stopped, by a call to one of the Analyze methods. The custom procedure below calls this method to write the report to a CLOB field, then calls DBMS_XSLProcessor.CLOB2File to write the contents to file.

The second Analyze call populates the tables read by the custom queries.

FUNCTION Stop_Profiling(
            p_run_comment                  VARCHAR2,                       -- run comment
            p_filename                     VARCHAR2) RETURN PLS_INTEGER IS -- file name for html report
  l_report_clob   CLOB;
BEGIN

  DBMS_HProf.Stop_Profiling;
  DBMS_HProf.Analyze(trace_id => g_trace_id, report_clob => l_report_clob);
  DBMS_XSLProcessor.CLOB2File(cl => l_report_clob, flocation => 'INPUT_DIR', fname => p_filename);
  RETURN DBMS_HProf.Analyze(trace_id => g_trace_id, run_comment => p_run_comment);

END Stop_Profiling;

The driver scripts specify the file name hp_example_general.html and hp_example_sleep.html, and these are written to the folder in the Oracle directory INPUT_DIR. The files for the examples are included in the associated GitHub project. The report starts with a list of the included subreports, as in the screenshot below:


Here is a screenshot for the first of the subreports for the general example:

Network Queries

The queries are in the script hprof_queries.sql, and we discuss the network queries in this section. The script also contains simple queries against the base tables. All queries are for a given RUNID, passed in as a sqlplus parameter.

Connect By Query

WITH links (node_fr, node_to, owner, module, function, sub_t, fun_t, calls) AS (
    SELECT  0, fni.symbolid, fni.owner, fni.module, fni.function, fni.subtree_elapsed_time, fni.function_elapsed_time, fni.calls
      FROM dbmshp_function_info fni
     WHERE fni.runid = &RUN_ID
       AND NOT EXISTS (SELECT 1 FROM dbmshp_parent_child_info pci WHERE pci.childsymid = fni.symbolid AND pci.runid = fni.runid)
     UNION ALL
    SELECT pci.parentsymid,
           pci.childsymid,
           fi.owner,
           fi.module ,
           fi.function,
           pci.subtree_elapsed_time,
           pci.function_elapsed_time,
           pci.calls
      FROM dbmshp_parent_child_info  pci
      JOIN dbmshp_function_info      fi 
        ON pci.runid                 = fi.runid 
       AND pci.childsymid            = fi.symbolid
     WHERE pci.runid                 = &RUN_ID
)
SELECT RPAD(' ', (LEVEL-1)*2, ' ') || function ftree,
       node_to sy,
       owner,
       module,
       sub_t,
       fun_t,
       calls
  FROM links
CONNECT BY PRIOR node_to = node_fr
START WITH node_fr = 0
ORDER SIBLINGS BY sub_t DESC, fun_t DESC, calls DESC, node_to

Notes on Connect By Query

Links Subquery

In the basic network diagrams we added a dummy root node so that all real nodes appear as child nodes, and this is implemented in the links subquery here as a union between new links to the real root nodes and the original links. This allows the main query connecting the revised links set to cover all nodes.

Sibling Ordering

The ORDER SIBLINGS BY clause allows us to order sibling nodes by subtree elapsed time descending, with additional tie-break columns.

Link Duplication

The network for the first example has two loops, and the second loop has two child nodes coming from the end point. Hierarchical queries (both CONNECT BY and recursive subquery factors in Oracle) cause the links below the loop to be duplicated as all paths are followed. This is seen in the output below for the first example, with 28 rows compared with 26 rows for the output displayed earlier, using a query with filtering implemented. The query can be extended to filter out the duplicates using analytic functions, as is implemented for the recursive subquery factoring query.

Function tree                   Sy Owner Module           Subtree MicroS Function MicroS Calls
------------------------------ --- ----- ---------------- -------------- --------------- -----
__plsql_vm                       2                               1848468              17     6
  __anonymous_block              1                               1818326             590     5
    __sql_fetch_line13          20                               1100678         1100678     1
    TABLE_COUNT_TYPE            13 APP   TABLE_COUNT_TYPE         521332              31     1
      __static_sql_exec_line55  22 APP   TABLE_COUNT_TYPE         521301          521301     1
    __dyn_sql_exec_line12       19                                133537          133537     1
    __static_sql_exec_line8     21                                 34400            2407     1
      __plsql_vm@1               3                                 31993               4     1
        DBFUNC                   9 APP   PROF_TEST                 31989           31989     1
    R_CALLS_R                   10 APP   PROF_TEST                 27684            9234     1
      R_CALLS_R@1               11 APP   PROF_TEST                 18428           18426     1
        PUT_LINE                18 SYS   DBMS_OUTPUT                   2               0     1
          PUT                   17 SYS   DBMS_OUTPUT                  23              23     2
          NEW_LINE              16 SYS   DBMS_OUTPUT                   0               0     2
      PUT_LINE                  18 SYS   DBMS_OUTPUT                  22               1     1
        PUT                     17 SYS   DBMS_OUTPUT                  23              23     2
        NEW_LINE                16 SYS   DBMS_OUTPUT                   0               0     2
    GET_LINES                   15 SYS   DBMS_OUTPUT                  79              79     3
    STOP_PROFILING               4 APP   HPROF_UTILS                  26              26     1
      STOP_PROFILING            14 SYS   DBMS_HPROF                    0               0     1
  DBFUNC                         9 APP   PROF_TEST                 30125           30125     1
A_CALLS_B                        5 APP   PROF_TEST                128199            9631     1
  B_CALLS_A                      7 APP   PROF_TEST                118568           30617     1
    A_CALLS_B@1                  6 APP   PROF_TEST                 87951           27332     1
      B_CALLS_A@1                8 APP   PROF_TEST                 60619           60619     1
__static_sql_exec_line700       23 SYS   DBMS_HPROF                   67              67     1
__pkg_init                      12 APP   PROF_TEST                     3               3     1

27 rows selected.

Recursive Subquery Factoring Query

WITH pci_sums (childsymid, subtree_elapsed_time, function_elapsed_time, calls) AS (
    SELECT childsymid, Sum(subtree_elapsed_time), 
                       Sum(function_elapsed_time), 
                       Sum(calls)
      FROM dbmshp_parent_child_info pci
     WHERE runid = &RUN_ID
     GROUP BY childsymid
), full_tree (runid, lev, node_id, sub_t, fun_t, calls, link_id) AS (
    SELECT fni.runid, 0, fni.symbolid,
           fni.subtree_elapsed_time - Nvl(psm.subtree_elapsed_time, 0),
           fni.function_elapsed_time - Nvl(psm.function_elapsed_time, 0),
           fni.calls - Nvl(psm.calls, 0), 'root' || ROWNUM
      FROM dbmshp_function_info fni
      LEFT JOIN pci_sums psm
        ON psm.childsymid = fni.symbolid
     WHERE fni.runid = &RUN_ID
       AND fni.calls - Nvl(psm.calls, 0) > 0
     UNION ALL
    SELECT ftr.runid, 
           ftr.lev + 1, 
           pci.childsymid, 
           pci.subtree_elapsed_time, 
           pci.function_elapsed_time, 
           pci.calls,
           pci.parentsymid || '-' || pci.childsymid
      FROM full_tree ftr
      JOIN dbmshp_parent_child_info pci
        ON pci.parentsymid = ftr.node_id
       AND pci.runid = ftr.runid
) SEARCH DEPTH FIRST BY sub_t DESC, fun_t DESC, calls DESC, node_id SET rn
, tree_ranked AS (
    SELECT runid, node_id, lev, rn, 
           sub_t, fun_t, calls, 
           Row_Number () OVER (PARTITION BY node_id ORDER BY rn) node_rn,
           Count (*) OVER (PARTITION BY node_id) node_cnt,
           Row_Number () OVER (PARTITION BY link_id ORDER BY rn) link_rn
      FROM full_tree
)
SELECT RPad (' ', trr.lev*2, ' ') || fni.function ftree,
       fni.symbolid sy, fni.owner, fni.module,
       CASE WHEN trr.node_cnt > 1 THEN trr.node_rn || ' of ' || trr.node_cnt END "Inst.",
       trr.sub_t, trr.fun_t, trr.calls, 
       trr.rn "Row"
  FROM tree_ranked trr
  JOIN dbmshp_function_info fni
    ON fni.symbolid = trr.node_id
   AND fni.runid = trr.runid
 WHERE trr.link_rn = 1
 ORDER BY trr.rn

Notes on Recursive Subquery Factoring Query

Root Nodes and Child Sums Subquery

A function may be called both as a child of another function, and also at the top level, as the second example showed. We detect this situation by counting the number of calls for the functions in the links table (dbmshp_parent_child_info) and comparing with the number of calls in the functions table (dbmshp_function_info). The difference corresponds to the number of root-level calls, and the root-level timings are the timing differences between the function timings and the sums of the link timings.

Link Duplication

As noted earlier, hierarchical queries (both Connect By and recursive subquery factors in Oracle) cause the links below any loops to be duplicated as all paths are followed. In this query an additional subquery has been added, tree_ranked, that ranks the nodes and links by order of appearance. The node rank is used just for information in the main block, while the link rank is used to eliminate duplicate links. Gaps in the “Row” column indicate where duplicates have been suppressed.

It’s worth remembering this because it’s a general feature of SQL for querying hierarchies, and one that seems not to be widely understood. For larger hierarchies it can cause serious performance problems, and may justify a PL/SQL programmed solution that need not suffer the same problem, such as: PL/SQL Pipelined Function for Network Analysis.

Here is a query structure diagram for the recursive subquery factoring query:


I wrote about query diagramming in August 2012: Query Structure Diagramming

Hierarchical Profiler Feature Summary

We can summarise the features of the Hierarchical Profiler in the following points:

  • Results are organised as lists of measures by program unit and by ‘unit-within-caller’, and can be represented in a call hierarchy
  • Results are reported at the level of program unit call or ‘tracked operation’; all calls to a given program unit within a single parent unit are aggregated
  • Measures reported are elapsed times and numbers of calls, but not CPU times
  • External program units are included in the profiling
  • Profiling is performed, after initial setup, by means of before and after API calls, followed by querying of results in tables, or viewing of HTML reports






 

Analytic and Recursive SQL by Example

In my article A Note on Running Sums and Products in SQL, I used three different SQL techniques to get running products: Analytic Functions, Model Clause and Recursive Subquery Factors. I explained this in a recording on Twitter. I then wondered whether I could explain each of these SQL techniques in general using a single Twitter recording (which has a time limit of 140 seconds) each, and you can see the results in this Twitter thread.

In this article I set out the example queries that I used along with the results. You can get the complete scripts and recordings on GitHub, Oracle SQL Projects.

Analytic Functions

Oracle Doc: SQL for Analysis and Reporting

SQL Analytic Functions in a Tweet

Average by Grouping

SELECT department_id, AVG(salary) avg_salary
  FROM employees
 GROUP BY department_id
 ORDER BY department_id
/
DEPARTMENT_ID AVG_SALARY
------------- ----------
           10       4400
           20       9500
           30       4150
           40       6500
           50 3475.55556
           60       5760
           70      10000
           80 8955.88235
           90 19333.3333
          100 8601.33333
          110      10154
                    7000

Analytic Averages: Overall, running and 3-point moving

SELECT department_id, employee_id, salary,
       AVG(salary) OVER (PARTITION BY department_id) avg_salary,
       AVG(salary) OVER (PARTITION BY department_id ORDER BY employee_id) run_avg_salary,
       AVG(salary) OVER (PARTITION BY department_id ORDER BY employee_id
          ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) moving_avg_salary_3
  FROM employees
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY AVG_SALARY RUN_AVG_SALARY MOVING_AVG_SALARY_3
------------- ----------- ---------- ---------- -------------- -------------------
           10         200       4400       4400           4400                4400
           20         201      13000       9500          13000               13000
                      202       6000       9500           9500                9500
           30         114      11000       4150          11000               11000
                      115       3100       4150           7050                7050
                      116       2900       4150     5666.66667          5666.66667
                      117       2800       4150           4950          2933.33333
                      118       2600       4150           4480          2766.66667
                      119       2500       4150           4150          2633.33333
           40         203       6500       6500           6500                6500
           50         120       8000 3475.55556           8000                8000
                      121       8200 3475.55556           8100                8100
                      122       7900 3475.55556     8033.33333          8033.33333
                      123       6500 3475.55556           7650          7533.33333
                      124       5800 3475.55556           7280          6733.33333
                      125       3200 3475.55556           6600          5166.66667
                      126       2700 3475.55556     6042.85714                3900
                      127       2400 3475.55556         5587.5          2766.66667
                      128       2200 3475.55556     5211.11111          2433.33333
                      129       3300 3475.55556           5020          2633.33333
                      130       2800 3475.55556     4818.18182          2766.66667
                      131       2500 3475.55556           4625          2866.66667
                      132       2100 3475.55556     4430.76923          2466.66667
                      133       3300 3475.55556           4350          2633.33333
                      134       2900 3475.55556     4253.33333          2766.66667
                      135       2400 3475.55556         4137.5          2866.66667
                      136       2200 3475.55556     4023.52941                2500
                      137       3600 3475.55556           4000          2733.33333
                      138       3200 3475.55556     3957.89474                3000
                      139       2700 3475.55556           3895          3166.66667
                      140       2500 3475.55556     3828.57143                2800
                      141       3500 3475.55556     3813.63636                2900
                      142       3100 3475.55556      3782.6087          3033.33333
                      143       2600 3475.55556     3733.33333          3066.66667
                      144       2500 3475.55556           3684          2733.33333
                      180       3200 3475.55556     3665.38462          2766.66667
                      181       3100 3475.55556     3644.44444          2933.33333
                      182       2500 3475.55556     3603.57143          2933.33333
                      183       2800 3475.55556     3575.86207                2800
                      184       4200 3475.55556     3596.66667          3166.66667
                      185       4100 3475.55556     3612.90323                3700
                      186       3400 3475.55556        3606.25                3900
                      187       3000 3475.55556     3587.87879                3500
                      188       3800 3475.55556     3594.11765                3400
                      189       3600 3475.55556     3594.28571          3466.66667
                      190       2900 3475.55556           3575          3433.33333
                      191       2500 3475.55556     3545.94595                3000
                      192       4000 3475.55556     3557.89474          3133.33333
                      193       3900 3475.55556     3566.66667          3466.66667
                      194       3200 3475.55556         3557.5                3700
                      195       2800 3475.55556     3539.02439                3300
                      196       3100 3475.55556     3528.57143          3033.33333
                      197       3000 3475.55556     3516.27907          2966.66667
                      198       2600 3475.55556     3495.45455                2900
                      199       2600 3475.55556     3475.55556          2733.33333
           60         103       9000       5760           9000                9000
                      104       6000       5760           7500                7500
                      105       4800       5760           6600                6600
                      106       4800       5760           6150                5200
                      107       4200       5760           5760                4600
           70         204      10000      10000          10000               10000
           80         145      14000 8955.88235          14000               14000
                      146      13500 8955.88235          13750               13750
                      147      12000 8955.88235     13166.6667          13166.6667
                      148      11000 8955.88235          12625          12166.6667
                      149      10500 8955.88235          12200          11166.6667
                      150      10000 8955.88235     11833.3333               10500
                      151       9500 8955.88235          11500               10000
                      152       9000 8955.88235        11187.5                9500
                      153       8000 8955.88235     10833.3333          8833.33333
                      154       7500 8955.88235          10500          8166.66667
                      155       7000 8955.88235     10181.8182                7500
                      156      10000 8955.88235     10166.6667          8166.66667
                      157       9500 8955.88235     10115.3846          8833.33333
                      158       9000 8955.88235     10035.7143                9500
                      159       8000 8955.88235           9900          8833.33333
                      160       7500 8955.88235           9750          8166.66667
                      161       7000 8955.88235     9588.23529                7500
                      162      10500 8955.88235     9638.88889          8333.33333
                      163       9500 8955.88235     9631.57895                9000
                      164       7200 8955.88235           9510          9066.66667
                      165       6800 8955.88235     9380.95238          7833.33333
                      166       6400 8955.88235     9245.45455                6800
                      167       6200 8955.88235     9113.04348          6466.66667
                      168      11500 8955.88235         9212.5          8033.33333
                      169      10000 8955.88235           9244          9233.33333
                      170       9600 8955.88235     9257.69231          10366.6667
                      171       7400 8955.88235     9188.88889                9000
                      172       7300 8955.88235     9121.42857                8100
                      173       6100 8955.88235     9017.24138          6933.33333
                      174      11000 8955.88235     9083.33333          8133.33333
                      175       8800 8955.88235     9074.19355          8633.33333
                      176       8600 8955.88235       9059.375          9466.66667
                      177       8400 8955.88235     9039.39394                8600
                      179       6200 8955.88235     8955.88235          7733.33333
           90         100      24000 19333.3333          24000               24000
                      101      17000 19333.3333          20500               20500
                      102      17000 19333.3333     19333.3333          19333.3333
          100         108      12008 8601.33333          12008               12008
                      109       9000 8601.33333          10504               10504
                      110       8200 8601.33333           9736                9736
                      111       7700 8601.33333           9227                8300
                      112       7800 8601.33333         8941.6                7900
                      113       6900 8601.33333     8601.33333          7466.66667
          110         205      12008      10154          12008               12008
                      206       8300      10154          10154               10154
                      178       7000       7000           7000                7000

107 rows selected.

Analytics on Grouping: Running sum of the department average salaries

DEPARTMENT_ID AVG_SALARY RUN_SUM_AVG_SALARY
------------- ---------- ------------------
           10       4400               4400
           20       9500              13900
           30       4150              18050
           40       6500              24550
           50 3475.55556         28025.5556
           60       5760         33785.5556
           70      10000         43785.5556
           80 8955.88235         52741.4379
           90 19333.3333         72074.7712
          100 8601.33333         80676.1046
          110      10154         90830.1046
                    7000         97830.1046

Model Clause

Oracle Doc: SQL for Modeling

SQL Model Clause in a Tweet

Running and Final Products: Final first rule, default SEQUENTIAL order

WITH multipliers AS (
SELECT department_id, employee_id, salary, (1 + salary/10000) mult, 
       COUNT(*) OVER (PARTITION BY department_id) n_emps
  FROM employees
)
SELECT department_id, employee_id, salary, mult, running_prod, final_prod
  FROM multipliers
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id 
                                 ORDER BY employee_id) rn)
  MEASURES (employee_id, salary, mult, mult running_prod, mult final_prod, n_emps)
  RULES (
    final_prod[any] = running_prod[n_emps[CV()]],
    running_prod[rn > 1] = mult[CV()] * running_prod[CV() - 1]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY       MULT RUNNING_PROD FINAL_PROD
------------- ----------- ---------- ---------- ------------ ----------
           10         200       4400       1.44         1.44       1.44
           20         201      13000        2.3          2.3        1.6
                      202       6000        1.6         3.68        1.6
           30         114      11000        2.1          2.1       1.25
                      115       3100       1.31        2.751       1.25
                      116       2900       1.29      3.54879       1.25
                      117       2800       1.28    4.5424512       1.25
                      118       2600       1.26   5.72348851       1.25
                      119       2500       1.25   7.15436064       1.25
           40         203       6500       1.65         1.65       1.65
           50         120       8000        1.8          1.8       1.26
                      121       8200       1.82        3.276       1.26
                      122       7900       1.79      5.86404       1.26
                      123       6500       1.65     9.675666       1.26
                      124       5800       1.58   15.2875523       1.26
                      125       3200       1.32    20.179569       1.26
                      126       2700       1.27   25.6280526       1.26
                      127       2400       1.24   31.7787853       1.26
                      128       2200       1.22    38.770118       1.26
                      129       3300       1.33    51.564257       1.26
                      130       2800       1.28   66.0022489       1.26
                      131       2500       1.25   82.5028112       1.26
                      132       2100       1.21   99.8284015       1.26
                      133       3300       1.33   132.771774       1.26
                      134       2900       1.29   171.275589       1.26
                      135       2400       1.24    212.38173       1.26
                      136       2200       1.22    259.10571       1.26
                      137       3600       1.36   352.383766       1.26
                      138       3200       1.32   465.146571       1.26
                      139       2700       1.27   590.736145       1.26
                      140       2500       1.25   738.420182       1.26
                      141       3500       1.35   996.867245       1.26
                      142       3100       1.31   1305.89609       1.26
                      143       2600       1.26   1645.42907       1.26
                      144       2500       1.25   2056.78634       1.26
                      180       3200       1.32   2714.95797       1.26
                      181       3100       1.31   3556.59495       1.26
                      182       2500       1.25   4445.74368       1.26
                      183       2800       1.28   5690.55191       1.26
                      184       4200       1.42   8080.58372       1.26
                      185       4100       1.41    11393.623       1.26
                      186       3400       1.34   15267.4549       1.26
                      187       3000        1.3   19847.6913       1.26
                      188       3800       1.38    27389.814       1.26
                      189       3600       1.36   37250.1471       1.26
                      190       2900       1.29   48052.6898       1.26
                      191       2500       1.25   60065.8622       1.26
                      192       4000        1.4   84092.2071       1.26
                      193       3900       1.39   116888.168       1.26
                      194       3200       1.32   154292.382       1.26
                      195       2800       1.28   197494.248       1.26
                      196       3100       1.31   258717.465       1.26
                      197       3000        1.3   336332.705       1.26
                      198       2600       1.26   423779.208       1.26
                      199       2600       1.26   533961.802       1.26
           60         103       9000        1.9          1.9       1.42
                      104       6000        1.6         3.04       1.42
                      105       4800       1.48       4.4992       1.42
                      106       4800       1.48     6.658816       1.42
                      107       4200       1.42   9.45551872       1.42
           70         204      10000          2            2          2
           80         145      14000        2.4          2.4       1.62
                      146      13500       2.35         5.64       1.62
                      147      12000        2.2       12.408       1.62
                      148      11000        2.1      26.0568       1.62
                      149      10500       2.05     53.41644       1.62
                      150      10000          2    106.83288       1.62
                      151       9500       1.95   208.324116       1.62
                      152       9000        1.9    395.81582       1.62
                      153       8000        1.8   712.468477       1.62
                      154       7500       1.75   1246.81983       1.62
                      155       7000        1.7   2119.59372       1.62
                      156      10000          2   4239.18744       1.62
                      157       9500       1.95    8266.4155       1.62
                      158       9000        1.9   15706.1895       1.62
                      159       8000        1.8    28271.141       1.62
                      160       7500       1.75   49474.4968       1.62
                      161       7000        1.7   84106.6445       1.62
                      162      10500       2.05   172418.621       1.62
                      163       9500       1.95   336216.311       1.62
                      164       7200       1.72   578292.056       1.62
                      165       6800       1.68   971530.654       1.62
                      166       6400       1.64   1593310.27       1.62
                      167       6200       1.62   2581162.64       1.62
                      168      11500       2.15   5549499.68       1.62
                      169      10000          2   11098999.4       1.62
                      170       9600       1.96   21754038.7       1.62
                      171       7400       1.74   37852027.4       1.62
                      172       7300       1.73   65484007.4       1.62
                      173       6100       1.61    105429252       1.62
                      174      11000        2.1    221401429       1.62
                      175       8800       1.88    416234687       1.62
                      176       8600       1.86    774196517       1.62
                      177       8400       1.84   1424521591       1.62
                      179       6200       1.62   2307724978       1.62
           90         100      24000        3.4          3.4        2.7
                      101      17000        2.7         9.18        2.7
                      102      17000        2.7       24.786        2.7
          100         108      12008     2.2008       2.2008       1.69
                      109       9000        1.9      4.18152       1.69
                      110       8200       1.82    7.6103664       1.69
                      111       7700       1.77   13.4703485       1.69
                      112       7800       1.78   23.9772204       1.69
                      113       6900       1.69   40.5215024       1.69
          110         205      12008     2.2008       2.2008       1.83
                      206       8300       1.83     4.027464       1.83
                      178       7000        1.7          1.7        1.7

107 rows selected.

Running and Final Products: Final first rule, AUTOMATIC order

WITH multipliers AS (
SELECT department_id, employee_id, salary, (1 + salary/10000) mult, 
       COUNT(*) OVER (PARTITION BY department_id) n_emps
  FROM employees
)
SELECT department_id, employee_id, salary, mult, running_prod, final_prod
  FROM multipliers
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id 
                                 ORDER BY employee_id) rn)
  MEASURES (employee_id, salary, mult, mult running_prod, mult final_prod, n_emps)
  RULES AUTOMATIC ORDER (
    final_prod[any] = running_prod[n_emps[CV()]],
    running_prod[rn > 1] = mult[CV()] * running_prod[CV() - 1]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY       MULT RUNNING_PROD FINAL_PROD
------------- ----------- ---------- ---------- ------------ ----------
           10         200       4400       1.44         1.44       1.44
           20         201      13000        2.3          2.3       3.68
                      202       6000        1.6         3.68       3.68
           30         114      11000        2.1          2.1 7.15436064
                      115       3100       1.31        2.751 7.15436064
                      116       2900       1.29      3.54879 7.15436064
                      117       2800       1.28    4.5424512 7.15436064
                      118       2600       1.26   5.72348851 7.15436064
                      119       2500       1.25   7.15436064 7.15436064
           40         203       6500       1.65         1.65       1.65
           50         120       8000        1.8          1.8 533961.802
                      121       8200       1.82        3.276 533961.802
                      122       7900       1.79      5.86404 533961.802
                      123       6500       1.65     9.675666 533961.802
                      124       5800       1.58   15.2875523 533961.802
                      125       3200       1.32    20.179569 533961.802
                      126       2700       1.27   25.6280526 533961.802
                      127       2400       1.24   31.7787853 533961.802
                      128       2200       1.22    38.770118 533961.802
                      129       3300       1.33    51.564257 533961.802
                      130       2800       1.28   66.0022489 533961.802
                      131       2500       1.25   82.5028112 533961.802
                      132       2100       1.21   99.8284015 533961.802
                      133       3300       1.33   132.771774 533961.802
                      134       2900       1.29   171.275589 533961.802
                      135       2400       1.24    212.38173 533961.802
                      136       2200       1.22    259.10571 533961.802
                      137       3600       1.36   352.383766 533961.802
                      138       3200       1.32   465.146571 533961.802
                      139       2700       1.27   590.736145 533961.802
                      140       2500       1.25   738.420182 533961.802
                      141       3500       1.35   996.867245 533961.802
                      142       3100       1.31   1305.89609 533961.802
                      143       2600       1.26   1645.42907 533961.802
                      144       2500       1.25   2056.78634 533961.802
                      180       3200       1.32   2714.95797 533961.802
                      181       3100       1.31   3556.59495 533961.802
                      182       2500       1.25   4445.74368 533961.802
                      183       2800       1.28   5690.55191 533961.802
                      184       4200       1.42   8080.58372 533961.802
                      185       4100       1.41    11393.623 533961.802
                      186       3400       1.34   15267.4549 533961.802
                      187       3000        1.3   19847.6913 533961.802
                      188       3800       1.38    27389.814 533961.802
                      189       3600       1.36   37250.1471 533961.802
                      190       2900       1.29   48052.6898 533961.802
                      191       2500       1.25   60065.8622 533961.802
                      192       4000        1.4   84092.2071 533961.802
                      193       3900       1.39   116888.168 533961.802
                      194       3200       1.32   154292.382 533961.802
                      195       2800       1.28   197494.248 533961.802
                      196       3100       1.31   258717.465 533961.802
                      197       3000        1.3   336332.705 533961.802
                      198       2600       1.26   423779.208 533961.802
                      199       2600       1.26   533961.802 533961.802
           60         103       9000        1.9          1.9 9.45551872
                      104       6000        1.6         3.04 9.45551872
                      105       4800       1.48       4.4992 9.45551872
                      106       4800       1.48     6.658816 9.45551872
                      107       4200       1.42   9.45551872 9.45551872
           70         204      10000          2            2          2
           80         145      14000        2.4          2.4 2307724978
                      146      13500       2.35         5.64 2307724978
                      147      12000        2.2       12.408 2307724978
                      148      11000        2.1      26.0568 2307724978
                      149      10500       2.05     53.41644 2307724978
                      150      10000          2    106.83288 2307724978
                      151       9500       1.95   208.324116 2307724978
                      152       9000        1.9    395.81582 2307724978
                      153       8000        1.8   712.468477 2307724978
                      154       7500       1.75   1246.81983 2307724978
                      155       7000        1.7   2119.59372 2307724978
                      156      10000          2   4239.18744 2307724978
                      157       9500       1.95    8266.4155 2307724978
                      158       9000        1.9   15706.1895 2307724978
                      159       8000        1.8    28271.141 2307724978
                      160       7500       1.75   49474.4968 2307724978
                      161       7000        1.7   84106.6445 2307724978
                      162      10500       2.05   172418.621 2307724978
                      163       9500       1.95   336216.311 2307724978
                      164       7200       1.72   578292.056 2307724978
                      165       6800       1.68   971530.654 2307724978
                      166       6400       1.64   1593310.27 2307724978
                      167       6200       1.62   2581162.64 2307724978
                      168      11500       2.15   5549499.68 2307724978
                      169      10000          2   11098999.4 2307724978
                      170       9600       1.96   21754038.7 2307724978
                      171       7400       1.74   37852027.4 2307724978
                      172       7300       1.73   65484007.4 2307724978
                      173       6100       1.61    105429252 2307724978
                      174      11000        2.1    221401429 2307724978
                      175       8800       1.88    416234687 2307724978
                      176       8600       1.86    774196517 2307724978
                      177       8400       1.84   1424521591 2307724978
                      179       6200       1.62   2307724978 2307724978
           90         100      24000        3.4          3.4     24.786
                      101      17000        2.7         9.18     24.786
                      102      17000        2.7       24.786     24.786
          100         108      12008     2.2008       2.2008 40.5215024
                      109       9000        1.9      4.18152 40.5215024
                      110       8200       1.82    7.6103664 40.5215024
                      111       7700       1.77   13.4703485 40.5215024
                      112       7800       1.78   23.9772204 40.5215024
                      113       6900       1.69   40.5215024 40.5215024
          110         205      12008     2.2008       2.2008   4.027464
                      206       8300       1.83     4.027464   4.027464
                      178       7000        1.7          1.7        1.7

107 rows selected.

Average and Moving Average

SELECT department_id, employee_id, salary, avg_salary, moving_avg_salary_3
  FROM employees
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id 
                                 ORDER BY employee_id) rn)
  MEASURES (employee_id, salary, salary avg_salary, salary moving_avg_salary_3)
  RULES (
    avg_salary[ANY] = AVG(salary)[ANY],
    moving_avg_salary_3[ANY] = AVG(salary)[rn BETWEEN CV()-2 AND CV()]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY AVG_SALARY MOVING_AVG_SALARY_3
------------- ----------- ---------- ---------- -------------------
           10         200       4400       4400                4400
           20         201      13000       9500               13000
                      202       6000       9500                9500
           30         114      11000       4150               11000
                      115       3100       4150                7050
                      116       2900       4150          5666.66667
                      117       2800       4150          2933.33333
                      118       2600       4150          2766.66667
                      119       2500       4150          2633.33333
           40         203       6500       6500                6500
           50         120       8000 3475.55556                8000
                      121       8200 3475.55556                8100
                      122       7900 3475.55556          8033.33333
                      123       6500 3475.55556          7533.33333
                      124       5800 3475.55556          6733.33333
                      125       3200 3475.55556          5166.66667
                      126       2700 3475.55556                3900
                      127       2400 3475.55556          2766.66667
                      128       2200 3475.55556          2433.33333
                      129       3300 3475.55556          2633.33333
                      130       2800 3475.55556          2766.66667
                      131       2500 3475.55556          2866.66667
                      132       2100 3475.55556          2466.66667
                      133       3300 3475.55556          2633.33333
                      134       2900 3475.55556          2766.66667
                      135       2400 3475.55556          2866.66667
                      136       2200 3475.55556                2500
                      137       3600 3475.55556          2733.33333
                      138       3200 3475.55556                3000
                      139       2700 3475.55556          3166.66667
                      140       2500 3475.55556                2800
                      141       3500 3475.55556                2900
                      142       3100 3475.55556          3033.33333
                      143       2600 3475.55556          3066.66667
                      144       2500 3475.55556          2733.33333
                      180       3200 3475.55556          2766.66667
                      181       3100 3475.55556          2933.33333
                      182       2500 3475.55556          2933.33333
                      183       2800 3475.55556                2800
                      184       4200 3475.55556          3166.66667
                      185       4100 3475.55556                3700
                      186       3400 3475.55556                3900
                      187       3000 3475.55556                3500
                      188       3800 3475.55556                3400
                      189       3600 3475.55556          3466.66667
                      190       2900 3475.55556          3433.33333
                      191       2500 3475.55556                3000
                      192       4000 3475.55556          3133.33333
                      193       3900 3475.55556          3466.66667
                      194       3200 3475.55556                3700
                      195       2800 3475.55556                3300
                      196       3100 3475.55556          3033.33333
                      197       3000 3475.55556          2966.66667
                      198       2600 3475.55556                2900
                      199       2600 3475.55556          2733.33333
           60         103       9000       5760                9000
                      104       6000       5760                7500
                      105       4800       5760                6600
                      106       4800       5760                5200
                      107       4200       5760                4600
           70         204      10000      10000               10000
           80         145      14000 8955.88235               14000
                      146      13500 8955.88235               13750
                      147      12000 8955.88235          13166.6667
                      148      11000 8955.88235          12166.6667
                      149      10500 8955.88235          11166.6667
                      150      10000 8955.88235               10500
                      151       9500 8955.88235               10000
                      152       9000 8955.88235                9500
                      153       8000 8955.88235          8833.33333
                      154       7500 8955.88235          8166.66667
                      155       7000 8955.88235                7500
                      156      10000 8955.88235          8166.66667
                      157       9500 8955.88235          8833.33333
                      158       9000 8955.88235                9500
                      159       8000 8955.88235          8833.33333
                      160       7500 8955.88235          8166.66667
                      161       7000 8955.88235                7500
                      162      10500 8955.88235          8333.33333
                      163       9500 8955.88235                9000
                      164       7200 8955.88235          9066.66667
                      165       6800 8955.88235          7833.33333
                      166       6400 8955.88235                6800
                      167       6200 8955.88235          6466.66667
                      168      11500 8955.88235          8033.33333
                      169      10000 8955.88235          9233.33333
                      170       9600 8955.88235          10366.6667
                      171       7400 8955.88235                9000
                      172       7300 8955.88235                8100
                      173       6100 8955.88235          6933.33333
                      174      11000 8955.88235          8133.33333
                      175       8800 8955.88235          8633.33333
                      176       8600 8955.88235          9466.66667
                      177       8400 8955.88235                8600
                      179       6200 8955.88235          7733.33333
           90         100      24000 19333.3333               24000
                      101      17000 19333.3333               20500
                      102      17000 19333.3333          19333.3333
          100         108      12008 8601.33333               12008
                      109       9000 8601.33333               10504
                      110       8200 8601.33333                9736
                      111       7700 8601.33333                8300
                      112       7800 8601.33333                7900
                      113       6900 8601.33333          7466.66667
          110         205      12008      10154               12008
                      206       8300      10154               10154
                      178       7000       7000                7000

107 rows selected.

UPSERT with FOR Loop: Split records into two with salary halved

SELECT department_id, employee_id, old_salary, split_salary
  FROM employees
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id 
                                 ORDER BY employee_id) rn)
  MEASURES (employee_id, salary old_salary, salary split_salary, 
          Count(*) OVER (PARTITION BY department_id) as n_emps)
  RULES UPSERT (
    employee_id[FOR rn FROM n_emps[1]+1 TO 2*n_emps[1] INCREMENT 1] = 
       employee_id[CV() - n_emps[1]],
    split_salary[FOR rn FROM n_emps[1]+1 TO 2*n_emps[1] INCREMENT 1] = 
       old_salary[CV() - n_emps[1]],
    split_salary[ANY] = 0.5 * split_salary[CV()]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID OLD_SALARY SPLIT_SALARY
------------- ----------- ---------- ------------
           10         200       4400         2200
                      200                    2200
           20         201      13000         6500
                      201                    6500
                      202                    3000
                      202       6000         3000
           30         114                    5500
                      114      11000         5500
                      115       3100         1550
                      115                    1550
                      116                    1450
                      116       2900         1450
                      117                    1400
                      117       2800         1400
                      118                    1300
                      118       2600         1300
                      119       2500         1250
                      119                    1250
           40         203       6500         3250
                      203                    3250
           50         120       8000         4000
                      120                    4000
                      121                    4100
                      121       8200         4100
                      122                    3950
                      122       7900         3950
                      123       6500         3250
                      123                    3250
                      124                    2900
                      124       5800         2900
                      125                    1600
                      125       3200         1600
                      126       2700         1350
                      126                    1350
                      127       2400         1200
                      127                    1200
                      128                    1100
                      128       2200         1100
                      129                    1650
                      129       3300         1650
                      130                    1400
                      130       2800         1400
                      131                    1250
                      131       2500         1250
                      132                    1050
                      132       2100         1050
                      133       3300         1650
                      133                    1650
                      134       2900         1450
                      134                    1450
                      135                    1200
                      135       2400         1200
                      136       2200         1100
                      136                    1100
                      137       3600         1800
                      137                    1800
                      138                    1600
                      138       3200         1600
                      139                    1350
                      139       2700         1350
                      140                    1250
                      140       2500         1250
                      141                    1750
                      141       3500         1750
                      142                    1550
                      142       3100         1550
                      143                    1300
                      143       2600         1300
                      144                    1250
                      144       2500         1250
                      180       3200         1600
                      180                    1600
                      181       3100         1550
                      181                    1550
                      182       2500         1250
                      182                    1250
                      183       2800         1400
                      183                    1400
                      184       4200         2100
                      184                    2100
                      185       4100         2050
                      185                    2050
                      186                    1700
                      186       3400         1700
                      187                    1500
                      187       3000         1500
                      188       3800         1900
                      188                    1900
                      189       3600         1800
                      189                    1800
                      190                    1450
                      190       2900         1450
                      191                    1250
                      191       2500         1250
                      192       4000         2000
                      192                    2000
                      193                    1950
                      193       3900         1950
                      194                    1600
                      194       3200         1600
                      195       2800         1400
                      195                    1400
                      196                    1550
                      196       3100         1550
                      197       3000         1500
                      197                    1500
                      198       2600         1300
                      198                    1300
                      199       2600         1300
                      199                    1300
           60         103       9000         4500
                      103                    4500
                      104       6000         3000
                      104                    3000
                      105       4800         2400
                      105                    2400
                      106                    2400
                      106       4800         2400
                      107                    2100
                      107       4200         2100
           70         204                    5000
                      204      10000         5000
           80         145                    7000
                      145      14000         7000
                      146      13500         6750
                      146                    6750
                      147      12000         6000
                      147                    6000
                      148      11000         5500
                      148                    5500
                      149      10500         5250
                      149                    5250
                      150      10000         5000
                      150                    5000
                      151       9500         4750
                      151                    4750
                      152       9000         4500
                      152                    4500
                      153                    4000
                      153       8000         4000
                      154                    3750
                      154       7500         3750
                      155                    3500
                      155       7000         3500
                      156                    5000
                      156      10000         5000
                      157                    4750
                      157       9500         4750
                      158                    4500
                      158       9000         4500
                      159       8000         4000
                      159                    4000
                      160                    3750
                      160       7500         3750
                      161                    3500
                      161       7000         3500
                      162      10500         5250
                      162                    5250
                      163                    4750
                      163       9500         4750
                      164                    3600
                      164       7200         3600
                      165                    3400
                      165       6800         3400
                      166       6400         3200
                      166                    3200
                      167       6200         3100
                      167                    3100
                      168      11500         5750
                      168                    5750
                      169      10000         5000
                      169                    5000
                      170       9600         4800
                      170                    4800
                      171       7400         3700
                      171                    3700
                      172                    3650
                      172       7300         3650
                      173       6100         3050
                      173                    3050
                      174      11000         5500
                      174                    5500
                      175       8800         4400
                      175                    4400
                      176       8600         4300
                      176                    4300
                      177       8400         4200
                      177                    4200
                      179       6200         3100
                      179                    3100
           90         100                   12000
                      100      24000        12000
                      101      17000         8500
                      101                    8500
                      102      17000         8500
                      102                    8500
          100         108      12008         6004
                      108                    6004
                      109       9000         4500
                      109                    4500
                      110       8200         4100
                      110                    4100
                      111                    3850
                      111       7700         3850
                      112       7800         3900
                      112                    3900
                      113       6900         3450
                      113                    3450
          110         205      12008         6004
                      205                    6004
                      206       8300         4150
                      206                    4150
                      178                    3500
                      178       7000         3500

214 rows selected.

ITERATE: Take square root of salary iteratively until average < 10

SELECT department_id, employee_id, salary, avg_salary
  FROM employees
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id ORDER BY employee_id) rn)
  MEASURES (employee_id, salary, salary avg_salary, salary moving_avg_salary_3)
  RULES ITERATE (100) UNTIL avg_salary[1] < 10.0 (
        salary[ANY] = SQRT(salary[CV()]),
    avg_salary[ANY] = AVG(salary)[ANY]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY AVG_SALARY
------------- ----------- ---------- ----------
           10         200  8.1444764  8.1444764
           20         201 10.6778997 9.73950855
                      202 8.80111737 9.73950855
           30         114 10.2411369 7.75455528
                      115 7.46174535 7.75455528
                      116 7.33836822 7.75455528
                      117 7.27427153 7.75455528
                      118 7.14074192 7.75455528
                      119 7.07106781 7.75455528
           40         203  8.9790076  8.9790076
           50         120 9.45741609 7.58389021
                      121 9.51597874 7.58389021
                      122 9.42772211 7.58389021
                      123  8.9790076 7.58389021
                      124 8.72683969 7.58389021
                      125 7.52120619 7.58389021
                      126 7.20843424 7.58389021
                      127 6.99927102 7.58389021
                      128 6.84866101 7.58389021
                      129 7.57928931 7.58389021
                      130 7.27427153 7.58389021
                      131 7.07106781 7.58389021
                      132 6.76947243 7.58389021
                      133 7.57928931 7.58389021
                      134 7.33836822 7.58389021
                      135 6.99927102 7.58389021
                      136 6.84866101 7.58389021
                      137 7.74596669 7.58389021
                      138 7.52120619 7.58389021
                      139 7.20843424 7.58389021
                      140 7.07106781 7.58389021
                      141 7.69160567 7.58389021
                      142 7.46174535 7.58389021
                      143 7.14074192 7.58389021
                      144 7.07106781 7.58389021
                      180 7.52120619 7.58389021
                      181 7.46174535 7.58389021
                      182 7.07106781 7.58389021
                      183 7.27427153 7.58389021
                      184 8.05030478 7.58389021
                      185 8.00195241 7.58389021
                      186 7.63606698 7.58389021
                      187 7.40082804 7.58389021
                      188 7.85137822 7.58389021
                      189 7.74596669 7.58389021
                      190 7.33836822 7.58389021
                      191 7.07106781 7.58389021
                      192 7.95270729 7.58389021
                      193 7.90252997 7.58389021
                      194 7.52120619 7.58389021
                      195 7.27427153 7.58389021
                      196 7.46174535 7.58389021
                      197 7.40082804 7.58389021
                      198 7.14074192 7.58389021
                      199 7.14074192 7.58389021
           60         103 9.74003746 8.64772508
                      104 8.80111737 8.64772508
                      105  8.3235829 8.64772508
                      106  8.3235829 8.64772508
                      107 8.05030478 8.64772508
           70         204 3.16227766 3.16227766
           80         145 10.8775731  9.6838805
                      146 10.7791234  9.6838805
                      147 10.4663514  9.6838805
                      148 10.2411369  9.6838805
                      149 10.1227223  9.6838805
                      150         10  9.6838805
                      151 9.87258545  9.6838805
                      152 9.74003746  9.6838805
                      153 9.45741609  9.6838805
                      154 9.30604859  9.6838805
                      155 9.14691219  9.6838805
                      156         10  9.6838805
                      157 9.87258545  9.6838805
                      158 9.74003746  9.6838805
                      159 9.45741609  9.6838805
                      160 9.30604859  9.6838805
                      161 9.14691219  9.6838805
                      162 10.1227223  9.6838805
                      163 9.87258545  9.6838805
                      164  9.2115587  9.6838805
                      165 9.08086519  9.6838805
                      166 8.94427191  9.6838805
                      167 8.87356066  9.6838805
                      168 10.3555808  9.6838805
                      169         10  9.6838805
                      170 9.89846401  9.6838805
                      171 9.27487211  9.6838805
                      172 9.24337803  9.6838805
                      173  8.8375617  9.6838805
                      174 10.2411369  9.6838805
                      175 9.68546928  9.6838805
                      176 9.62996287  9.6838805
                      177 9.57347972  9.6838805
                      179 8.87356066  9.6838805
           90         100 3.52798236 3.42875376
                      101 3.37913945 3.42875376
                      102 3.37913945 3.42875376
          100         108 10.4680953  9.6005671
                      109 9.74003746  9.6005671
                      110 9.51597874  9.6005671
                      111 9.36747799  9.6005671
                      112 9.39774487  9.6005671
                      113 9.11406817  9.6005671
          110         205 3.23544361 3.16245958
                      206 3.08947554 3.16245958
                      178 9.14691219 9.14691219

107 rows selected.

Within-Rule Order Default Ascending: Set salary = previous salary

PROMPT Within-Rule Order Default Ascending: Set salary = previous salary
SELECT department_id, employee_id, old_salary, salary
  FROM employees
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id ORDER BY employee_id) rn)
  MEASURES (employee_id, salary old_salary, salary)
  RULES (
    salary[rn > 1] = salary[CV()-1]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID OLD_SALARY     SALARY
------------- ----------- ---------- ----------
           10         200       4400       4400
           20         201      13000      13000
                      202       6000      13000
           30         114      11000      11000
                      115       3100      11000
                      116       2900      11000
                      117       2800      11000
                      118       2600      11000
                      119       2500      11000
           40         203       6500       6500
           50         120       8000       8000
                      121       8200       8000
                      122       7900       8000
                      123       6500       8000
                      124       5800       8000
                      125       3200       8000
                      126       2700       8000
                      127       2400       8000
                      128       2200       8000
                      129       3300       8000
                      130       2800       8000
                      131       2500       8000
                      132       2100       8000
                      133       3300       8000
                      134       2900       8000
                      135       2400       8000
                      136       2200       8000
                      137       3600       8000
                      138       3200       8000
                      139       2700       8000
                      140       2500       8000
                      141       3500       8000
                      142       3100       8000
                      143       2600       8000
                      144       2500       8000
                      180       3200       8000
                      181       3100       8000
                      182       2500       8000
                      183       2800       8000
                      184       4200       8000
                      185       4100       8000
                      186       3400       8000
                      187       3000       8000
                      188       3800       8000
                      189       3600       8000
                      190       2900       8000
                      191       2500       8000
                      192       4000       8000
                      193       3900       8000
                      194       3200       8000
                      195       2800       8000
                      196       3100       8000
                      197       3000       8000
                      198       2600       8000
                      199       2600       8000
           60         103       9000       9000
                      104       6000       9000
                      105       4800       9000
                      106       4800       9000
                      107       4200       9000
           70         204      10000      10000
           80         145      14000      14000
                      146      13500      14000
                      147      12000      14000
                      148      11000      14000
                      149      10500      14000
                      150      10000      14000
                      151       9500      14000
                      152       9000      14000
                      153       8000      14000
                      154       7500      14000
                      155       7000      14000
                      156      10000      14000
                      157       9500      14000
                      158       9000      14000
                      159       8000      14000
                      160       7500      14000
                      161       7000      14000
                      162      10500      14000
                      163       9500      14000
                      164       7200      14000
                      165       6800      14000
                      166       6400      14000
                      167       6200      14000
                      168      11500      14000
                      169      10000      14000
                      170       9600      14000
                      171       7400      14000
                      172       7300      14000
                      173       6100      14000
                      174      11000      14000
                      175       8800      14000
                      176       8600      14000
                      177       8400      14000
                      179       6200      14000
           90         100      24000      24000
                      101      17000      24000
                      102      17000      24000
          100         108      12008      12008
                      109       9000      12008
                      110       8200      12008
                      111       7700      12008
                      112       7800      12008
                      113       6900      12008
          110         205      12008      12008
                      206       8300      12008
                      178       7000       7000

107 rows selected.

Within-Rule Order Descending: Set salary = previous salary

SELECT department_id, employee_id, old_salary, salary
  FROM employees
 MODEL
  PARTITION BY (department_id)
  DIMENSION BY (Row_Number() OVER (PARTITION BY department_id ORDER BY employee_id) rn)
  MEASURES (employee_id, salary old_salary, salary)
  RULES (
    salary[rn > 1] ORDER BY rn DESC = salary[CV()-1]
  )
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID OLD_SALARY     SALARY
------------- ----------- ---------- ----------
           10         200       4400       4400
           20         201      13000      13000
                      202       6000      13000
           30         114      11000      11000
                      115       3100      11000
                      116       2900       3100
                      117       2800       2900
                      118       2600       2800
                      119       2500       2600
           40         203       6500       6500
           50         120       8000       8000
                      121       8200       8000
                      122       7900       8200
                      123       6500       7900
                      124       5800       6500
                      125       3200       5800
                      126       2700       3200
                      127       2400       2700
                      128       2200       2400
                      129       3300       2200
                      130       2800       3300
                      131       2500       2800
                      132       2100       2500
                      133       3300       2100
                      134       2900       3300
                      135       2400       2900
                      136       2200       2400
                      137       3600       2200
                      138       3200       3600
                      139       2700       3200
                      140       2500       2700
                      141       3500       2500
                      142       3100       3500
                      143       2600       3100
                      144       2500       2600
                      180       3200       2500
                      181       3100       3200
                      182       2500       3100
                      183       2800       2500
                      184       4200       2800
                      185       4100       4200
                      186       3400       4100
                      187       3000       3400
                      188       3800       3000
                      189       3600       3800
                      190       2900       3600
                      191       2500       2900
                      192       4000       2500
                      193       3900       4000
                      194       3200       3900
                      195       2800       3200
                      196       3100       2800
                      197       3000       3100
                      198       2600       3000
                      199       2600       2600
           60         103       9000       9000
                      104       6000       9000
                      105       4800       6000
                      106       4800       4800
                      107       4200       4800
           70         204      10000      10000
           80         145      14000      14000
                      146      13500      14000
                      147      12000      13500
                      148      11000      12000
                      149      10500      11000
                      150      10000      10500
                      151       9500      10000
                      152       9000       9500
                      153       8000       9000
                      154       7500       8000
                      155       7000       7500
                      156      10000       7000
                      157       9500      10000
                      158       9000       9500
                      159       8000       9000
                      160       7500       8000
                      161       7000       7500
                      162      10500       7000
                      163       9500      10500
                      164       7200       9500
                      165       6800       7200
                      166       6400       6800
                      167       6200       6400
                      168      11500       6200
                      169      10000      11500
                      170       9600      10000
                      171       7400       9600
                      172       7300       7400
                      173       6100       7300
                      174      11000       6100
                      175       8800      11000
                      176       8600       8800
                      177       8400       8600
                      179       6200       8400
           90         100      24000      24000
                      101      17000      24000
                      102      17000      17000
          100         108      12008      12008
                      109       9000      12008
                      110       8200       9000
                      111       7700       8200
                      112       7800       7700
                      113       6900       7800
          110         205      12008      12008
                      206       8300      12008
                      178       7000       7000

107 rows selected.

Recursive Subquery Factors

Oracle Doc: Recursive Subquery Factoring

SQL Recursive Subquery Factors in a Tweet

Employee Tree: Connect By

WITH cby AS (
    SELECT last_name, employee_id, manager_id, LEVEL lvl
      FROM employees
     START WITH employee_id = 100
     CONNECT BY PRIOR employee_id = manager_id
     ORDER SIBLINGS BY last_name
)
SELECT employee_id,
       LPad('.', 3*(lvl - 1), '.') || last_name last_name,
       manager_id,
       lvl
  FROM cby
/
EMPLOYEE_ID LAST_NAME            MANAGER_ID        LVL
----------- -------------------- ---------- ----------
        100 King                                     1
        148 ...Cambrault                100          2
        172 ......Bates                 148          3
        169 ......Bloom                 148          3
        170 ......Fox                   148          3
        173 ......Kumar                 148          3
        168 ......Ozer                  148          3
        171 ......Smith                 148          3
        102 ...De Haan                  100          2
        103 ......Hunold                102          3
        105 .........Austin             103          4
        104 .........Ernst              103          4
        107 .........Lorentz            103          4
        106 .........Pataballa          103          4
        147 ...Errazuriz                100          2
        166 ......Ande                  147          3
        167 ......Banda                 147          3
        163 ......Greene                147          3
        165 ......Lee                   147          3
        164 ......Marvins               147          3
        162 ......Vishney               147          3
        121 ...Fripp                    100          2
        130 ......Atkinson              121          3
        129 ......Bissot                121          3
        185 ......Bull                  121          3
        187 ......Cabrio                121          3
        186 ......Dellinger             121          3
        131 ......Marlow                121          3
        132 ......Olson                 121          3
        184 ......Sarchand              121          3
        201 ...Hartstein                100          2
        202 ......Fay                   201          3
        122 ...Kaufling                 100          2
        188 ......Chung                 122          3
        189 ......Dilly                 122          3
        190 ......Gates                 122          3
        135 ......Gee                   122          3
        133 ......Mallin                122          3
        191 ......Perkins               122          3
        136 ......Philtanker            122          3
        134 ......Rogers                122          3
        101 ...Kochhar                  100          2
        204 ......Baer                  101          3
        108 ......Greenberg             101          3
        110 .........Chen               108          4
        109 .........Faviet             108          4
        113 .........Popp               108          4
        111 .........Sciarra            108          4
        112 .........Urman              108          4
        205 ......Higgins               101          3
        206 .........Gietz              205          4
        203 ......Mavris                101          3
        200 ......Whalen                101          3
        124 ...Mourgos                  100          2
        142 ......Davies                124          3
        197 ......Feeney                124          3
        199 ......Grant                 124          3
        143 ......Matos                 124          3
        198 ......OConnell              124          3
        141 ......Rajs                  124          3
        144 ......Vargas                124          3
        196 ......Walsh                 124          3
        146 ...Partners                 100          2
        160 ......Doran                 146          3
        156 ......King                  146          3
        158 ......McEwen                146          3
        161 ......Sewall                146          3
        159 ......Smith                 146          3
        157 ......Sully                 146          3
        114 ...Raphaely                 100          2
        116 ......Baida                 114          3
        119 ......Colmenares            114          3
        118 ......Himuro                114          3
        115 ......Khoo                  114          3
        117 ......Tobias                114          3
        145 ...Russell                  100          2
        151 ......Bernstein             145          3
        154 ......Cambrault             145          3
        152 ......Hall                  145          3
        153 ......Olsen                 145          3
        150 ......Tucker                145          3
        155 ......Tuvault               145          3
        123 ...Vollman                  100          2
        192 ......Bell                  123          3
        193 ......Everett               123          3
        195 ......Jones                 123          3
        137 ......Ladwig                123          3
        194 ......McCain                123          3
        140 ......Patel                 123          3
        139 ......Seo                   123          3
        138 ......Stiles                123          3
        120 ...Weiss                    100          2
        181 ......Fleaur                120          3
        183 ......Geoni                 120          3
        127 ......Landry                120          3
        128 ......Markle                120          3
        126 ......Mikkilineni           120          3
        125 ......Nayer                 120          3
        182 ......Sullivan              120          3
        180 ......Taylor                120          3
        149 ...Zlotkey                  100          2
        174 ......Abel                  149          3
        178 ......Grant                 149          3
        175 ......Hutton                149          3
        179 ......Johnson               149          3
        177 ......Livingston            149          3
        176 ......Taylor                149          3

107 rows selected.

Employee Tree: Recursive subquery factors, depth first

The result for the following query is the same as for the above CONNECT BY query:

WITH rsf(employee_id, last_name, manager_id, lvl) AS (
    SELECT employee_id,
           last_name,
           manager_id,
           1 lvl
      FROM employees
     WHERE manager_id IS NULL
    UNION ALL
    SELECT e.employee_id,
           e.last_name,
           e.manager_id,
           r.lvl + 1
      FROM rsf r
      JOIN employees e ON e.manager_id = r.employee_id
) SEARCH DEPTH FIRST BY last_name SET ord_by
SELECT employee_id,
       LPad('.', 3*(lvl - 1), '.') || last_name last_name,
       manager_id,
       lvl
  FROM rsf
 ORDER BY ord_by
/

Employee Tree: Recursive subquery factors, breadth first

WITH rsf(employee_id, last_name, manager_id, lvl) AS (
    SELECT employee_id,
           last_name,
           manager_id,
           1 lvl
      FROM employees
     WHERE manager_id IS NULL
    UNION ALL
    SELECT e.employee_id,
           e.last_name,
           e.manager_id,
           r.lvl + 1
      FROM rsf r
      JOIN employees e ON e.manager_id = r.employee_id
) SEARCH BREADTH FIRST BY last_name SET ord_by
SELECT employee_id,
       LPad('.', 3*(lvl - 1), '.') || last_name last_name,
       manager_id,
       lvl
  FROM rsf
 ORDER BY ord_by
/
EMPLOYEE_ID LAST_NAME            MANAGER_ID        LVL
----------- -------------------- ---------- ----------
        100 King                                     1
        148 ...Cambrault                100          2
        102 ...De Haan                  100          2
        147 ...Errazuriz                100          2
        121 ...Fripp                    100          2
        201 ...Hartstein                100          2
        122 ...Kaufling                 100          2
        101 ...Kochhar                  100          2
        124 ...Mourgos                  100          2
        146 ...Partners                 100          2
        114 ...Raphaely                 100          2
        145 ...Russell                  100          2
        123 ...Vollman                  100          2
        120 ...Weiss                    100          2
        149 ...Zlotkey                  100          2
        174 ......Abel                  149          3
        166 ......Ande                  147          3
        130 ......Atkinson              121          3
        204 ......Baer                  101          3
        116 ......Baida                 114          3
        167 ......Banda                 147          3
        172 ......Bates                 148          3
        192 ......Bell                  123          3
        151 ......Bernstein             145          3
        129 ......Bissot                121          3
        169 ......Bloom                 148          3
        185 ......Bull                  121          3
        187 ......Cabrio                121          3
        154 ......Cambrault             145          3
        188 ......Chung                 122          3
        119 ......Colmenares            114          3
        142 ......Davies                124          3
        186 ......Dellinger             121          3
        189 ......Dilly                 122          3
        160 ......Doran                 146          3
        193 ......Everett               123          3
        202 ......Fay                   201          3
        197 ......Feeney                124          3
        181 ......Fleaur                120          3
        170 ......Fox                   148          3
        190 ......Gates                 122          3
        135 ......Gee                   122          3
        183 ......Geoni                 120          3
        199 ......Grant                 124          3
        178 ......Grant                 149          3
        108 ......Greenberg             101          3
        163 ......Greene                147          3
        152 ......Hall                  145          3
        205 ......Higgins               101          3
        118 ......Himuro                114          3
        103 ......Hunold                102          3
        175 ......Hutton                149          3
        179 ......Johnson               149          3
        195 ......Jones                 123          3
        115 ......Khoo                  114          3
        156 ......King                  146          3
        173 ......Kumar                 148          3
        137 ......Ladwig                123          3
        127 ......Landry                120          3
        165 ......Lee                   147          3
        177 ......Livingston            149          3
        133 ......Mallin                122          3
        128 ......Markle                120          3
        131 ......Marlow                121          3
        164 ......Marvins               147          3
        143 ......Matos                 124          3
        203 ......Mavris                101          3
        194 ......McCain                123          3
        158 ......McEwen                146          3
        126 ......Mikkilineni           120          3
        125 ......Nayer                 120          3
        198 ......OConnell              124          3
        153 ......Olsen                 145          3
        132 ......Olson                 121          3
        168 ......Ozer                  148          3
        140 ......Patel                 123          3
        191 ......Perkins               122          3
        136 ......Philtanker            122          3
        141 ......Rajs                  124          3
        134 ......Rogers                122          3
        184 ......Sarchand              121          3
        139 ......Seo                   123          3
        161 ......Sewall                146          3
        171 ......Smith                 148          3
        159 ......Smith                 146          3
        138 ......Stiles                123          3
        182 ......Sullivan              120          3
        157 ......Sully                 146          3
        180 ......Taylor                120          3
        176 ......Taylor                149          3
        117 ......Tobias                114          3
        150 ......Tucker                145          3
        155 ......Tuvault               145          3
        144 ......Vargas                124          3
        162 ......Vishney               147          3
        196 ......Walsh                 124          3
        200 ......Whalen                101          3
        105 .........Austin             103          4
        110 .........Chen               108          4
        104 .........Ernst              103          4
        109 .........Faviet             108          4
        206 .........Gietz              205          4
        107 .........Lorentz            103          4
        106 .........Pataballa          103          4
        113 .........Popp               108          4
        111 .........Sciarra            108          4
        112 .........Urman              108          4

107 rows selected.

Products using Recursive Subquery Factors: Passing through expressions

WITH multipliers AS (
SELECT department_id, employee_id, salary, (1 + salary/10000) mult, 
       Row_Number() OVER (PARTITION BY department_id ORDER BY employee_id) rn
  FROM employees
), rsf (department_id, employee_id, rn, salary, mult, running_prod, lvl) AS (
    SELECT department_id, employee_id, rn, salary, mult,
          mult running_prod, 1 lvl
      FROM multipliers
     WHERE rn = 1
    UNION ALL
    SELECT m.department_id, m.employee_id, m.rn, m.salary, m.mult,
           r.running_prod * m.mult, r.lvl + 1
      FROM rsf r
      JOIN multipliers m
        ON m.rn = r.rn + 1
       AND m.department_id = r.department_id
)
SELECT department_id, employee_id, salary, mult, running_prod, lvl
  FROM rsf
 ORDER BY department_id, employee_id
/
DEPARTMENT_ID EMPLOYEE_ID     SALARY       MULT RUNNING_PROD        LVL
------------- ----------- ---------- ---------- ------------ ----------
           10         200       4400       1.44         1.44          1
           20         201      13000        2.3          2.3          1
                      202       6000        1.6         3.68          2
           30         114      11000        2.1          2.1          1
                      115       3100       1.31        2.751          2
                      116       2900       1.29      3.54879          3
                      117       2800       1.28    4.5424512          4
                      118       2600       1.26   5.72348851          5
                      119       2500       1.25   7.15436064          6
           40         203       6500       1.65         1.65          1
           50         120       8000        1.8          1.8          1
                      121       8200       1.82        3.276          2
                      122       7900       1.79      5.86404          3
                      123       6500       1.65     9.675666          4
                      124       5800       1.58   15.2875523          5
                      125       3200       1.32    20.179569          6
                      126       2700       1.27   25.6280526          7
                      127       2400       1.24   31.7787853          8
                      128       2200       1.22    38.770118          9
                      129       3300       1.33    51.564257         10
                      130       2800       1.28   66.0022489         11
                      131       2500       1.25   82.5028112         12
                      132       2100       1.21   99.8284015         13
                      133       3300       1.33   132.771774         14
                      134       2900       1.29   171.275589         15
                      135       2400       1.24    212.38173         16
                      136       2200       1.22    259.10571         17
                      137       3600       1.36   352.383766         18
                      138       3200       1.32   465.146571         19
                      139       2700       1.27   590.736145         20
                      140       2500       1.25   738.420182         21
                      141       3500       1.35   996.867245         22
                      142       3100       1.31   1305.89609         23
                      143       2600       1.26   1645.42907         24
                      144       2500       1.25   2056.78634         25
                      180       3200       1.32   2714.95797         26
                      181       3100       1.31   3556.59495         27
                      182       2500       1.25   4445.74368         28
                      183       2800       1.28   5690.55191         29
                      184       4200       1.42   8080.58372         30
                      185       4100       1.41    11393.623         31
                      186       3400       1.34   15267.4549         32
                      187       3000        1.3   19847.6913         33
                      188       3800       1.38    27389.814         34
                      189       3600       1.36   37250.1471         35
                      190       2900       1.29   48052.6898         36
                      191       2500       1.25   60065.8622         37
                      192       4000        1.4   84092.2071         38
                      193       3900       1.39   116888.168         39
                      194       3200       1.32   154292.382         40
                      195       2800       1.28   197494.248         41
                      196       3100       1.31   258717.465         42
                      197       3000        1.3   336332.705         43
                      198       2600       1.26   423779.208         44
                      199       2600       1.26   533961.802         45
           60         103       9000        1.9          1.9          1
                      104       6000        1.6         3.04          2
                      105       4800       1.48       4.4992          3
                      106       4800       1.48     6.658816          4
                      107       4200       1.42   9.45551872          5
           70         204      10000          2            2          1
           80         145      14000        2.4          2.4          1
                      146      13500       2.35         5.64          2
                      147      12000        2.2       12.408          3
                      148      11000        2.1      26.0568          4
                      149      10500       2.05     53.41644          5
                      150      10000          2    106.83288          6
                      151       9500       1.95   208.324116          7
                      152       9000        1.9    395.81582          8
                      153       8000        1.8   712.468477          9
                      154       7500       1.75   1246.81983         10
                      155       7000        1.7   2119.59372         11
                      156      10000          2   4239.18744         12
                      157       9500       1.95    8266.4155         13
                      158       9000        1.9   15706.1895         14
                      159       8000        1.8    28271.141         15
                      160       7500       1.75   49474.4968         16
                      161       7000        1.7   84106.6445         17
                      162      10500       2.05   172418.621         18
                      163       9500       1.95   336216.311         19
                      164       7200       1.72   578292.056         20
                      165       6800       1.68   971530.654         21
                      166       6400       1.64   1593310.27         22
                      167       6200       1.62   2581162.64         23
                      168      11500       2.15   5549499.68         24
                      169      10000          2   11098999.4         25
                      170       9600       1.96   21754038.7         26
                      171       7400       1.74   37852027.4         27
                      172       7300       1.73   65484007.4         28
                      173       6100       1.61    105429252         29
                      174      11000        2.1    221401429         30
                      175       8800       1.88    416234687         31
                      176       8600       1.86    774196517         32
                      177       8400       1.84   1424521591         33
                      179       6200       1.62   2307724978         34
           90         100      24000        3.4          3.4          1
                      101      17000        2.7         9.18          2
                      102      17000        2.7       24.786          3
          100         108      12008     2.2008       2.2008          1
                      109       9000        1.9      4.18152          2
                      110       8200       1.82    7.6103664          3
                      111       7700       1.77   13.4703485          4
                      112       7800       1.78   23.9772204          5
                      113       6900       1.69   40.5215024          6
          110         205      12008     2.2008       2.2008          1
                      206       8300       1.83     4.027464          2
                      178       7000        1.7          1.7          1

107 rows selected.

Here's a query structure diagram for the query:

and here's a diagram showing partitioning and flow through the iterations:

You can see the scripts and full output on my new GitHub project,
Small SQL projects, in the analytics_and_recursion_explainers folder.

Here's an article from 2017 where you can see recursive SQL techniques used to solve a variety of difficult combinatorial optimization problems: Knapsacks and Networks in SQL.






On RDBMS, SQL and the DRY Principle, and Query Networks

I saw a link a week ago or so on my Twitter feed to an article published by one Lance Gutteridge on 1 June 2018: What I’m Telling Business People About Why Relational Databases Are So Bad. The article is written in a inflammatory style, here’s a sample quote:

Relational databases have been the worst technology to ever poison a field of endeavor

He classifies the ‘badness’ in three main categories:

  • SQL Injection
  • SQL “is a total violation of the DRY principle”
  • Object-Relational Impedance Mismatch

In this article I want to briefly discuss his criticisms under each of these categories, and then move on to discuss some interesting features of SQL queries and joins arising from the fact that SQL plainly does NOT violate the DRY principle. I’ll also discuss how the concept of the network, initially applied to table relationships, can be a very useful design concept in both data modelling and query design.

Part I: Comments on the Lance Gutteridge article
SQL Injection
From Wikipedia, SQL injection:

SQL injection is a code injection technique, used to attack data-driven applications, in which nefarious SQL statements are inserted into an entry field for execution (e.g. to dump the database contents to the attacker).

SQL injection has indeed been a real vulnerability for database systems in the past, but it is an avoidable problem today. As the Wikipedia article puts it:

An SQL injection is a well known attack and easily prevented by simple measures.

SQL “is a total violation of the DRY principle”
Dr. Gutteridge notes that relationships are defined in an RDBMS by foreign keys and primary keys on the tables, and that having to make join relations explicitly in SQL is a repetition of information already known, and hence violates the “Don’t Repeat Yourself” principle.

This criticism is easily dealt with: In general the table relationships do not in fact fully determine the joins in a query. A simple, and very common, example arises in order entry systems. Consider the following simplified 3-table data model:

Here we have an order entity with a foreign key link to a customer, and two foreign key links to the address entity. A customer may have multiple addresses that can serve as shipping or billing addresses on any given order. A particular query may require one or other, or both, or neither of the addresses for the order. The primary key/foreign key relationships cannot determine which tables and links to include without the query specifying them.

The usual way to specify this information in ANSI-standard SQL is to use JOIN/ON-clauses like this:

JOIN addresses add_b ON add_b.address_id = ord.billing_address_id

There are also situations in which joins can be expressed more concisely, and we’ll look at some of them in part II, but it’s clear that these clauses do not in any meaningful way violate the DRY principle.

Object-Relational Impedance Mismatch
In one of the few views on which I am inclined to agree with Dr. Gutteridge, he regards the term as “technobabble”, but it does describe a real phenomenon. Dr. Gutteridge expresses it thus:

…the data in a relational database is stored in ways more in keeping with a 1980s programming language than with a modern, object-oriented language

Though this mismatch does exist, it’s unlikely that dropping the relational model is the answer, because it solves a more fundamental problem. An article from 29 November 2017, Important Papers: Codd and the Relational Model, includes the following:

…Codd motivates the search for a better model by arguing that we need “data independence,” which he defines as “the independence of application programs and terminal activities from growth in data types and changes in data representation.” The relational model, he argues, “appears to be superior in several respects to the graph or network model presently in vogue,” partly because, among other benefits, the relational model “provides a means of describing data with its natural structure only.” By this he meant that programs could safely ignore any artificial structures (like trees) imposed upon the data for storage and retrieval purposes only.

I remember when I started my programming career in 1984 most of the work on any application was spent in writing code simply to store and retrieve data in application-specific formats. Within a few years that effort became largely unnecessary with the introduction of the Oracle RDBMS and SQL. Although modern big data requirements mean other approaches to data storage are also needed, the relational model isn’t going away.

In one of the unwitting ironies in Dr. Gutteridge’s article, he states towards the end that:

there are programmers who have never really seen any other kind of database and believe that all databases are relational

while apparently believing that all modern programming language are object-oriented. They aren’t, and while OOP isn’t going away, it has real deficiencies in modelling the real world that have led to growing interest in other paradigms such as functional programming, as well as old fashioned imperative programming. Here’s an interesting review of some of those deficiencies from 23 July 2016:
Goodbye, Object Oriented Programming

Part II: On SQL and DRY – Joins via NATURAL/USING/ON
In this second part we’ll use two subsets of Oracle’s HR demo schema as examples, and we’ll ignore any links in the tables to tables other than those depicted in the ERDs. Let’s see how, in some cases, we can use ANSI join syntax to avoid explicitly listing all the join column names, but that there are drawbacks to doing so.

Tree Data Model – Department 110, Location, Country, Region – NATURAL JOIN
The ERD below shows a simple linear tree structure.

Let’s start by considering a situation where we don’t need to specify the full join clause with fields on both sides.

 DEPARTMENT_NAME                STREET_ADDRESS                           CITY                           COUNTRY_NAME                             REGION_NAME
------------------------------ ---------------------------------------- ------------------------------ ---------------------------------------- -------------------------
Accounting                     2004 Charade Rd                          Seattle                        United States of America                 Americas

  1  SELECT department_name, street_address, city, country_name, region_name
  2    FROM departments
  3      NATURAL JOIN locations
  4      NATURAL JOIN countries
  5      NATURAL JOIN regions
  6*  WHERE department_id = 110

Here in this simple (linear) tree-structured data model we were able to join the three subsequent tables to the driving table, departments, simply by adding the table names after NATURAL JOIN.

So is this a case of the SQL engine reading the data model and constructing the joins without the need for repetition? No, it isn’t. As the documentation tells you, NATURAL JOIN joins by matching fields with the same names on either side. This can be dangerous as the next example shows.

The second example has only two tables, but there is a loop in the structure.

[In the underlying HR schema from which this is extracted there is also a self-join on employees, which we are excluding]
Department 110 employees: NATURAL JOIN gives wrong answer
There are two employees in department 110:

  COUNT(*)
----------
         2

  1  SELECT COUNT(*)
  2    FROM employees
  3*  WHERE department_id = 110

Let’s try to get the employees using NATURAL JOIN, like this:

DEPARTMENT_NAME                LAST_NAME                 FIRST_NAME           MANAGER_ID
------------------------------ ------------------------- -------------------- ----------
Accounting                     Gietz                     William                     205

  1  SELECT department_name, last_name, first_name, manager_id
  2    FROM departments
  3     NATURAL JOIN employees
  4*  WHERE department_id = 110

This returns only one of the two employees because NATURAL JOIN is matching on both department_id and manager_id as they appear in both tables.

Department 110 employees: USING department_id gives right answer
We can get the right answer by joining with the USING keyword, which assumes the column name to join on is the same on both tables, and mentions it explicitly.

DEPARTMENT_NAME                LAST_NAME                 FIRST_NAME
------------------------------ ------------------------- --------------------
Accounting                     Higgins                   Shelley
Accounting                     Gietz                     William

  1  SELECT department_name, last_name, first_name
  2    FROM departments
  3     JOIN employees USING (department_id)
  4*  WHERE department_id = 110

This example shows how USING resolves the earlier NATURAL JOIN error by specifying the field names in common to be used. The next example shows how this does not always work.

Department 110 manager: USING manager_id gives wrong answer

DEPARTMENT_NAME                LAST_NAME                 FIRST_NAME           MANAGER_ID
------------------------------ ------------------------- -------------------- ----------
Accounting                     Gietz                     William                     205

  1  SELECT department_name, last_name, first_name, manager_id
  2    FROM departments dep
  3     JOIN employees USING (manager_id)
  4*  WHERE dep.department_id = 110

From the first query above we know that the manager of department 110 is Shelley Higgins. It’s reported here instead as William Gietz, because his manager is the same as the department’s manager, but Shirley’s is not.

Department 110 manager: ON mgr.employee_id = dep.manager_id gives right answer

DEPARTMENT_NAME                LAST_NAME                 FIRST_NAME
------------------------------ ------------------------- --------------------
Accounting                     Higgins                   Shelley

  1   SELECT department_name, last_name, first_name
  2     FROM departments dep
  3     JOIN employees mgr ON mgr.employee_id = dep.manager_id
  4*  WHERE dep.department_id = 110

Here we we specify the join with the ON-clause linking the columns explicitly on each side of the join. This is the most usual approach to ANSI joins.

Department 110 manager: NATURAL JOIN subqueries
In a recent article (A tribute to Natural Join, 20 August 2018) Frank Pachot suggested that NATURAL JOIN could be more widely used if tables were replaced by subqueries in which all the columns were aliased in such a way that the join columns only would have the same names in the joined tables. The query above, implemented in this way might be written:

DEPARTMENT_NAME                MGR_LAST_NAME             MGR_FIRST_NAME
------------------------------ ------------------------- --------------------
Accounting                     Higgins                   Shelley

  1  SELECT department_name, mgr_last_name, mgr_first_name
  2    FROM
  3  (SELECT department_id, department_name, manager_id
  4     FROM departments) dep
  5    NATURAL JOIN
  6  (SELECT employee_id manager_id, last_name mgr_last_name, first_name mgr_first_name
  7     FROM employees) mgr
  8*  WHERE dep.department_id = 110

This version is much more verbose and it’s much harder to see which are the join columns by scanning the select lists, compared with specifying them in ON clauses.

Conclusions on Joins via NATURAL/USING/ON

  • Very few people use NATURAL JOIN due to the limitation that the join column names, and only those, in each table or subquery have to be the same
  • USING tends to be used in simple ad hoc queries with small numbers of tables, and improves on NATURAL JOIN by listing the join columns explicitly, but again relies on the join column names being the same
  • The most commonly used join mechanism is the ON clause, with column names specified on each side. This avoids the possible pitfalls of the other mechanisms and for complex, real world queries generally results in more maintainable code

Regarding the DRY principle in SQL more generally, I wrote this,
Modularity in SQL: Patterns, Anti-Patterns and the Kitchen Sink, in September 2013 [tl;dr: Functions and complex views are fine as entry-points but using them as building blocks in SQL is usually a bad idea, and subquery factors (WITH clause) are a better approach to SQL modularity].

Part III: On Data Models and Queries Viewed as Networks
In the examples above we saw that when there are two ways of joining a pair of tables it’s no longer possible for the data model alone to determine the join. An entity relationship structure can be represented as a directed network, with entities as nodes and the relationships between them as links. The second example corresponds to a loop in the network, in which there are two ways of getting from the driving node, departments, to the employees node.

Where the relationships between tables are stored in constraints metadata we can use network analysis PL/SQL to show the network structure and then make diagrams to help in understanding schema structures, as I showed here in May 2015:
PL/SQL Pipelined Function for Network Analysis. This diagram, extracted from that article, shows the structure of Oracle’s demo schemas, with what’s known in graph theory as a spanning tree marked in red, and loop-closing links in blue.

Networks - PLSQL, v1.0 - HR

Queries as Networks
In 2009 I was asked to extend the functionality of an Oracle ERP invoice print report in order to support a move to a multi-org ERP structure. The report had a large number (I think around 30) of small queries in various places, such as format triggers and formula columns as well as in the main data model, and I started by combining most of them into a single, fairly complex query plus one smaller, global data query. The report ran much more quickly and I felt was more maintainable since almost all the logic was in one place, and the query could be tested through tools such as Toad. However, as the query was quite complex I was asked to produce some documentation on how it worked. This got me thinking about how ERDs are used to document data models, and whether we could extend those ideas to document queries too.

My initial thought was that a query can be thought of as a route through the data model network, with looping corresponding to repeated table instances in the query. However, it turns out to be much clearer to represent each table instance as its own node on a new network diagram. After I left the company I wrote my ideas up in a general form in a word document on Scribd in May 2009, A Structured Approach to SQL Query Design. Since then I have extended these ideas to include coverage of query constructs such as unions and subquery factors, and use of annotations for clarity. I wrote another article in August 2012 where I apply these extended ideas to some example queries taken from the OTN forum, Query Structure Diagramming. Here’s a diagram from that article:

You can also find examples in several of the articles on combinatorial SQL referenced in Knapsacks and Networks in SQL from December 2017.

How many tables is too many?
Have you ever heard the view expressed, usually by a DBA, that you should not put more than a small number of tables, say 10, in any query? The reasoning given is that the number of join orders for N tables is N!, which for N=10 is 3,628,800 and the query optimiser (CBO) won’t be able to handle that number of permutations. You will probably know from the discussion above why this reasoning is incorrect: The cost optimization problem is really a network path problem, rather than a permutation problem – you look to join (large) tables that are linked to the current rowset rather than than making cartesian joins, so most permutations are never considered.