home *** CD-ROM | disk | FTP | other *** search
/ Winzipper / Winzipper_ISO.iso / programming / oracle7 7.2 / DB / UTIL72 / PRVTSYER.SQL < prev    next >
Encoding:
Text File  |  1995-05-09  |  13.7 KB  |  292 lines
  1. rem 
  2. rem $Header: prvtsyer.sql 7020200.1 95/02/15 18:13:28 cli Generic<base> $ 
  3. rem 
  4. Rem
  5. Rem    NAME
  6. Rem      prvtsyer.sql - PRVT_SYs_ErroR - pl/sql routines for 
  7. Rem                     system error messages for DBMS* routines.
  8. Rem    DESCRIPTION
  9. Rem      These are private functions to be released in PL/SQL binary form.
  10. Rem      The package includes routines for raising erors a la raise_application
  11. Rem      error, but with the error rage dedicated to and allocated among
  12. Rem      DBMS* SQL routines.
  13. Rem      Eventuall, NLS functionality will be provided thougt an interface 
  14. Rem      to kernel error functions.
  15. Rem    RETURNS
  16. Rem 
  17. Rem    NOTES
  18. Rem     Allocate error numbers in error.msg
  19. Rem     Range is 23300 to 24299
  20. Rem     For the time being, this package is used to raise ORA errors only.
  21. Rem     Future extensions might allow other error message files.
  22. Rem     DO NOT GRANT THIS PACKAGE TO PUBLIC
  23. Rem
  24. Rem    MODIFIED   (MM/DD/YY)
  25. Rem     dsdaniel   10/13/94 -  merge changes from branch 1.1.710.4
  26. Rem     dsdaniel   08/09/94 -  fix paramater ordering compatibility
  27. Rem     dsdaniel   07/13/94 -  merge changes from branch 1.1.710.2&3
  28. Rem     dsdaniel   07/13/94 -  icd compartibility problem
  29. Rem     dsdaniel   07/08/94 -  extend functions
  30. Rem     adowning   03/29/94 -  merge changes from branch 1.1.710.1
  31. Rem     adowning   02/04/94 -  Branch_for_patch
  32. Rem     adowning   02/04/94 -  Creation
  33. Rem     adowning   02/02/94 -  split file into public / private binary files
  34. Rem     dsdaniel   10/29/93 -  Creation
  35. Rem     dsdaniel   11/01/93 -  Branch_for_patch
  36. Rem
  37. REM ********************************************************************
  38. REM THESE PACKAGES MUST NOT BE MODIFIED BY THE CUSTOMER.  DOING SO
  39. REM COULD CAUSE INTERNAL ERRORS AND SECURITY VIOLATIONS IN THE
  40. REM RDBMS.  SPECIFICALLY, THE PSD*  ROUTINES MUST NOT BE
  41. REM CALLED DIRECTLY BY ANY CLIENT AND MUST REMAIN PRIVATE TO THE PACKAGE BODY.
  42. REM ********************************************************************
  43.  
  44. CREATE OR REPLACE PACKAGE dbms_sys_error IS
  45.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  46.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  47.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  48.                                arg1           VARCHAR2,
  49.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  50.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  51.                                arg1           VARCHAR2,
  52.                                arg2           VARCHAR2,
  53.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  54.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  55.                                arg1           VARCHAR2,
  56.                                arg2           VARCHAR2,
  57.                                arg3           VARCHAR2,
  58.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  59.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  60.                                arg1           VARCHAR2,
  61.                                arg2           VARCHAR2,
  62.                                arg3           VARCHAR2,
  63.                                arg4           VARCHAR2,
  64.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  65.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  66.                                arg1           VARCHAR2,
  67.                                arg2           VARCHAR2,
  68.                                arg3           VARCHAR2,
  69.                                arg4           VARCHAR2,
  70.                                arg5           VARCHAR2,
  71.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  72.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  73.                                arg1           VARCHAR2,
  74.                                arg2           VARCHAR2,
  75.                                arg3           VARCHAR2,
  76.                                arg4           VARCHAR2,
  77.                                arg5           VARCHAR2,
  78.                                arg6           VARCHAR2,
  79.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  80.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  81.                                arg1           VARCHAR2,
  82.                                arg2           VARCHAR2,
  83.                                arg3           VARCHAR2,
  84.                                arg4           VARCHAR2,
  85.                                arg5           VARCHAR2,
  86.                                arg6           VARCHAR2,
  87.                                arg7           VARCHAR2,
  88.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  89.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  90.                                arg1           VARCHAR2,
  91.                                arg2           VARCHAR2,
  92.                                arg3           VARCHAR2,
  93.                                arg4           VARCHAR2,
  94.                                arg5           VARCHAR2,
  95.                                arg6           VARCHAR2,
  96.                                arg7           VARCHAR2,
  97.                                arg8           VARCHAR2,
  98.                                keeperrorstack BOOLEAN DEFAULT FALSE);
  99.  
  100. -- Raise a system error int the range 23300 to 24299
  101. -- Input parameters:
  102. --   num
  103. --     Error number in the range 23300 to 24299
  104. --     If the error number has a matching entry in error.msg, then the error
  105. --     message for error.msg is used.  If there is no entry, then (but the
  106. --     number is in rang)e, then arg1 (if given) is used as the error message
  107. --     and no argument substitution is made.  This behavior provides 
  108. --     compatibility with earlier versions of this module. 
  109. --   arg[n]
  110. --     string arguments to the error messages that are sprintfed into the error
  111. --     message. 
  112. --   keeerrorstack
  113. --     if True, raised error is added to the top of the current stack,
  114. --     so that any errors that caused this error to be raised are retained.
  115. -- Exception:
  116. --   raises ORA-21000 If error not in range.
  117. END dbms_sys_error;
  118. /
  119.  
  120. CREATE OR REPLACE PACKAGE BODY dbms_sys_error IS
  121. -- Implementation note:  kkxere[n] routines are all implemented by the
  122. -- kkxerse routine.
  123. -- Further note: kkxere1 comes before kkxere0 to allow patch downgrades from
  124. -- 7.1.5 to earlier versions (for callrs of this package with 1 arg).
  125. -- (earlier versions only had kkxere1 (actually its predecessor)).
  126.  
  127.   PROCEDURE kkxere1(num            BINARY_INTEGER,
  128.                     arg1           VARCHAR2,                -- 1 (see kkxe.c)
  129.                     keeperrorstack BOOLEAN DEFAULT FALSE); 
  130.   PRAGMA INTERFACE (c,kkxere1);
  131.   PROCEDURE kkxere0(num            BINARY_INTEGER,
  132.                     keeperrorstack BOOLEAN DEFAULT FALSE); -- 2 (see kkxe.c)
  133.   PRAGMA INTERFACE (c,kkxere0);
  134.   PROCEDURE kkxere2(num            BINARY_INTEGER,
  135.                     arg1           VARCHAR2,
  136.                     arg2           VARCHAR2,               -- 3 (see kkxe.c)
  137.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  138.   PRAGMA INTERFACE (c,kkxere2);
  139.   PROCEDURE kkxere3(num            BINARY_INTEGER,
  140.                     arg1           VARCHAR2,
  141.                     arg2           VARCHAR2,
  142.                     arg3           VARCHAR2,                -- 4 (see kkxe.c)
  143.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  144.   PRAGMA INTERFACE (c,kkxere3);
  145.   PROCEDURE kkxere4(num            BINARY_INTEGER,
  146.                     arg1           VARCHAR2,
  147.                     arg2           VARCHAR2,
  148.                     arg3           VARCHAR2,
  149.                     arg4           VARCHAR2,                 -- 5 (see kkxe.c)
  150.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  151.   PRAGMA INTERFACE (c,kkxere4);
  152.   PROCEDURE kkxere5(num            BINARY_INTEGER,
  153.                     arg1           VARCHAR2,
  154.                     arg2           VARCHAR2,
  155.                     arg3           VARCHAR2,
  156.                     arg4           VARCHAR2,
  157.                     arg5           VARCHAR2,                 -- 6 (see kkxe.c)
  158.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  159.   PRAGMA INTERFACE (c,kkxere5);
  160.   PROCEDURE kkxere6(num            BINARY_INTEGER,
  161.                     arg1           VARCHAR2,
  162.                     arg2           VARCHAR2,
  163.                     arg3           VARCHAR2,
  164.                     arg4           VARCHAR2,
  165.                     arg5           VARCHAR2,
  166.                     arg6           VARCHAR2,                 -- 7 (see kkxe.c)
  167.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  168.   PRAGMA INTERFACE (c,kkxere6);
  169.   PROCEDURE kkxere7(num            BINARY_INTEGER,
  170.                     arg1           VARCHAR2,
  171.                     arg2           VARCHAR2,
  172.                     arg3           VARCHAR2,
  173.                     arg4           VARCHAR2,
  174.                     arg5           VARCHAR2,
  175.                     arg6           VARCHAR2,
  176.                     arg7           VARCHAR2,                 -- 8 (see kkxe.c)
  177.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  178.   PRAGMA INTERFACE (c,kkxere7);
  179.   PROCEDURE kkxere8(num            BINARY_INTEGER,
  180.                     arg1           VARCHAR2,
  181.                     arg2           VARCHAR2,
  182.                     arg3           VARCHAR2,
  183.                     arg4           VARCHAR2,
  184.                     arg5           VARCHAR2,
  185.                     arg6           VARCHAR2,
  186.                     arg7           VARCHAR2,
  187.                     arg8           VARCHAR2,                 -- 9 (see kkxe.c)
  188.                     keeperrorstack BOOLEAN DEFAULT FALSE);
  189.   PRAGMA INTERFACE (c,kkxere8);
  190.  
  191.  
  192.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  193.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  194.   BEGIN
  195.     kkxere0(num,keeperrorstack);
  196.   END raise_system_error;
  197.  
  198.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  199.                                arg1           VARCHAR2,
  200.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  201.   BEGIN
  202.     kkxere1(num, arg1,
  203.             keeperrorstack);
  204.   END raise_system_error;
  205.  
  206.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  207.                                arg1           VARCHAR2,
  208.                                arg2           VARCHAR2,
  209.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  210.   BEGIN
  211.     kkxere2(num, arg1,arg2,
  212.             keeperrorstack);
  213.   END raise_system_error;
  214.  
  215.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  216.                                arg1           VARCHAR2,
  217.                                arg2           VARCHAR2,
  218.                                arg3           VARCHAR2,
  219.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  220.   BEGIN
  221.     kkxere3(num, arg1,arg2,arg3,
  222.             keeperrorstack);
  223.   END raise_system_error;
  224.  
  225.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  226.                                arg1           VARCHAR2,
  227.                                arg2           VARCHAR2,
  228.                                arg3           VARCHAR2,
  229.                                arg4           VARCHAR2,
  230.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  231.   BEGIN
  232.     kkxere4(num, arg1,arg2,arg3,arg4,
  233.             keeperrorstack);
  234.   END raise_system_error;
  235.  
  236.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  237.                                arg1           VARCHAR2,
  238.                                arg2           VARCHAR2,
  239.                                arg3           VARCHAR2,
  240.                                arg4           VARCHAR2,
  241.                                arg5           VARCHAR2,
  242.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  243.   BEGIN
  244.     kkxere5(num, arg1,arg2,arg3,arg4,arg5,
  245.             keeperrorstack);
  246.   END raise_system_error;
  247.  
  248.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  249.                                arg1           VARCHAR2,
  250.                                arg2           VARCHAR2,
  251.                                arg3           VARCHAR2,
  252.                                arg4           VARCHAR2,
  253.                                arg5           VARCHAR2,
  254.                                arg6           VARCHAR2,
  255.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  256.   BEGIN
  257.     kkxere6(num, arg1,arg2,arg3,arg4,arg5,arg6,
  258.             keeperrorstack);
  259.   END raise_system_error;
  260.  
  261.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  262.                                arg1           VARCHAR2,
  263.                                arg2           VARCHAR2,
  264.                                arg3           VARCHAR2,
  265.                                arg4           VARCHAR2,
  266.                                arg5           VARCHAR2,
  267.                                arg6           VARCHAR2,
  268.                                arg7           VARCHAR2,
  269.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  270.   BEGIN
  271.     kkxere7(num, arg1,arg2,arg3,arg4,arg5,arg6,arg7,
  272.             keeperrorstack);
  273.   END raise_system_error;
  274.  
  275.   PROCEDURE raise_system_error(num            BINARY_INTEGER,
  276.                                arg1           VARCHAR2,
  277.                                arg2           VARCHAR2,
  278.                                arg3           VARCHAR2,
  279.                                arg4           VARCHAR2,
  280.                                arg5           VARCHAR2,
  281.                                arg6           VARCHAR2,
  282.                                arg7           VARCHAR2,
  283.                                arg8           VARCHAR2,
  284.                                keeperrorstack BOOLEAN DEFAULT FALSE) IS
  285.   BEGIN
  286.     kkxere8(num, arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,
  287.             keeperrorstack);
  288.   END raise_system_error;
  289.  
  290. END dbms_sys_error;
  291. /
  292.