home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / db / rdbms71 / standard.sql < prev    next >
Encoding:
Text File  |  1994-08-04  |  52.8 KB  |  1,603 lines

  1. rem 
  2. rem $Header: standard.sql 7010300.2 94/04/04 03:11:49 snataraj Generic<base> $ 
  3. rem 
  4. Rem  Copyright (c) 1991 by Oracle Corporation 
  5. Rem    NAME
  6. Rem      standard.sql - standard types and functions
  7. Rem                  
  8. Rem    DESCRIPTION
  9. Rem      This is generated in a PLSQL dve from stdspc.pls and stdbdy.pls
  10. Rem      using a PLSQL tool (ps2s.pls). At release times, this file
  11. Rem      should be checked out and the old generated portion below
  12. Rem      should be replaced by the new generated portion.
  13. Rem
  14. Rem    RETURNS
  15. Rem 
  16. Rem    NOTES
  17. Rem      <other useful comments, qualifications, etc.>
  18. Rem
  19. Rem    MODIFIED   (MM/DD/YY)
  20. Rem     usundara   03/18/94 -  revert to the old date (interoperability
  21. Rem                            7.0.15->7.1.3 problem; tkddrp35)
  22. Rem     plsint     02/03/94 -  fix DECODE... Kjensen
  23. Rem     plsint     02/02/94 -  Changes by kjensen
  24. Rem     spuranik   08/24/93 -  for tag k70101
  25. Rem     kaghevli   12/18/92 -  for tag k70012 
  26. Rem     hrizvi     12/06/92 -  for tag i92_12_06 
  27. Rem     hrizvi     12/06/92 -  for tag i92_12_06 
  28. Rem     kaghevli   11/28/92 -  for tag i92_11_28 
  29. Rem     rhari      11/26/92 -  typo 
  30. Rem     rhari      11/26/92 -  add special characters for new tag scheme 
  31. Rem     kaghevli   11/21/92 -  Creation 
  32. Rem 
  33. Rem the following line is not to be changed. It should be the last line
  34. Rem in this rcs header. The portion below it is generated.
  35. Rem ##$$##
  36.  
  37. create or replace package STANDARD -- TIMESTAMP is comment on next line in file stdspc.pls
  38.  timestamp '1992-11-29:00:00:00' -- utility p2s inserts this into .sql file
  39.  is
  40.  
  41.   type BOOLEAN is (FALSE, TRUE);
  42.  
  43.   type DATE is DATE_BASE;
  44.  
  45.   type NUMBER is NUMBER_BASE;
  46.   subtype FLOAT is NUMBER; -- NUMBER(126)
  47.   subtype REAL is FLOAT; -- FLOAT(63)
  48.   subtype "DOUBLE PRECISION" is FLOAT;
  49.  
  50. -- other number subtypes
  51.   subtype INTEGER is NUMBER(38,0);
  52.   subtype INT is INTEGER;
  53.   subtype SMALLINT is NUMBER(38,0);
  54.   subtype DECIMAL is NUMBER(38,0);
  55.   subtype NUMERIC is DECIMAL;
  56.   subtype DEC is DECIMAL;
  57.  
  58.  
  59.   subtype BINARY_INTEGER is INTEGER range '-2147483647'..2147483647;
  60. --                used to be -2147483648 - less than MAXSB4MINVAL
  61.   subtype NATURAL is BINARY_INTEGER range 0..2147483647;
  62.   subtype NATURALN is NATURAL not null;
  63.   subtype POSITIVE is BINARY_INTEGER range 1..2147483647;
  64.   subtype POSITIVEN is POSITIVE not null;
  65.   subtype SIGNTYPE is BINARY_INTEGER range '-1'..1;  -- for SIGN functions
  66.  
  67.   type VARCHAR2 is NEW CHAR_BASE;
  68.   pragma PACK(VARCHAR2);
  69.  
  70.   subtype VARCHAR is VARCHAR2;
  71.   subtype STRING is VARCHAR2;
  72.  
  73.   subtype LONG is VARCHAR2(32760);
  74.  
  75.   subtype RAW is VARCHAR2;
  76.   subtype "LONG RAW" is RAW(32760);
  77.  
  78.   subtype ROWID is VARCHAR2(256);
  79.  
  80.   -- Ansi fixed-length char
  81.   -- Define synonyms for CHAR and CHARN.
  82.   subtype CHAR is VARCHAR2;
  83.   subtype CHARACTER is CHAR;
  84.  
  85.   type MLSLABEL is new CHAR_BASE;
  86. --  subtype MLSLABEL is MLSLABEL_BASE(256); 
  87.  
  88.  
  89. --***************** Predefined exceptions *****************
  90.  
  91.   CURSOR_ALREADY_OPEN exception;
  92.     pragma EXCEPTION_INIT(CURSOR_ALREADY_OPEN, '-6511');
  93.  
  94.   DUP_VAL_ON_INDEX exception;
  95.     pragma EXCEPTION_INIT(DUP_VAL_ON_INDEX, '-0001');
  96.  
  97.   TIMEOUT_ON_RESOURCE exception;
  98.     pragma EXCEPTION_INIT(TIMEOUT_ON_RESOURCE, '-0051');
  99.  
  100. --TRANSACTION_BACKED_OUT exception;
  101. --  pragma EXCEPTION_INIT(TRANSACTION_BACKED_OUT, '-0061');
  102.  
  103.   INVALID_CURSOR exception;
  104.     pragma EXCEPTION_INIT(INVALID_CURSOR, '-1001');
  105.  
  106.   NOT_LOGGED_ON exception;
  107.     pragma EXCEPTION_INIT(NOT_LOGGED_ON, '-1012');
  108.  
  109.   LOGIN_DENIED exception;
  110.     pragma EXCEPTION_INIT(LOGIN_DENIED, '-1017');
  111.  
  112.   NO_DATA_FOUND exception;
  113.     pragma EXCEPTION_INIT(NO_DATA_FOUND, 100);
  114.  
  115.   ZERO_DIVIDE exception;
  116.     pragma EXCEPTION_INIT(ZERO_DIVIDE, '-1476');
  117.  
  118.   INVALID_NUMBER exception;
  119.     pragma EXCEPTION_INIT(INVALID_NUMBER, '-1722');
  120.  
  121.   TOO_MANY_ROWS exception;
  122.     pragma EXCEPTION_INIT(TOO_MANY_ROWS, '-1422');
  123.  
  124.   STORAGE_ERROR exception;
  125.     pragma EXCEPTION_INIT(STORAGE_ERROR, '-6500');
  126.  
  127.   PROGRAM_ERROR exception;
  128.     pragma EXCEPTION_INIT(PROGRAM_ERROR, '-6501');
  129.  
  130.   VALUE_ERROR exception;
  131.     pragma EXCEPTION_INIT(VALUE_ERROR, '-6502');
  132.  
  133.  
  134. --****************************************************************
  135.  
  136.   function "EXISTS" return BOOLEAN;
  137.     pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj
  138.  
  139.   function GREATEST (pattern NUMBER) return NUMBER;
  140.     pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
  141.   function GREATEST (pattern VARCHAR2) return VARCHAR2;
  142.     pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
  143.   function GREATEST (pattern DATE) return DATE;
  144.     pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
  145.  
  146.   function LEAST (pattern NUMBER) return NUMBER;
  147.     pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
  148.   function LEAST (pattern VARCHAR2) return VARCHAR2;
  149.     pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
  150.   function LEAST (pattern DATE) return DATE;
  151.     pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
  152.  
  153.   function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
  154.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  155.   function DECODE (expr NUMBER, pat NUMBER, res VARCHAR2) return VARCHAR2;
  156.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  157.   function DECODE (expr NUMBER, pat NUMBER, res DATE) return DATE;
  158.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  159.  
  160.   function DECODE (expr VARCHAR2, pat VARCHAR2, res NUMBER) return NUMBER;
  161.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  162.   function DECODE (expr VARCHAR2, pat VARCHAR2, res VARCHAR2)
  163.      return VARCHAR2;
  164.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  165.   function DECODE (expr VARCHAR2, pat VARCHAR2, res DATE) return DATE;
  166.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  167.  
  168.   function DECODE (expr DATE, pat DATE, res NUMBER) return NUMBER;
  169.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  170.   function DECODE (expr DATE, pat DATE, res VARCHAR2) return VARCHAR2;
  171.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  172.   function DECODE (expr DATE, pat DATE, res DATE) return DATE;
  173.     pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
  174.  
  175.   function SQLCODE return NUMBER;
  176.     pragma BUILTIN('SQLCODE',45, 10, 0); -- PEMS_DB, DB_SQLCODE
  177.  
  178.   function SQLERRM return varchar2;
  179.     pragma FIPSFLAG('SQLERRM', 1452);    
  180.  
  181.   function SQLERRM (code NUMBER) return varchar2;
  182.     pragma BUILTIN('SQLERRM',46, 10, 1); -- PEMS_DB, DB_SQLERRM
  183.     pragma FIPSFLAG('SQLERRM', 1452);    
  184.  
  185.   function LEVEL return NUMBER;
  186.  
  187.   function ROWNUM return NUMBER;
  188.  
  189.   function '='  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  190.     pragma BUILTIN('=',2, 3, 1); -- PEMS_INTEGER, PEMDCMEQ
  191.     pragma FIPSFLAG('=', 1450);    
  192.   function '!=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN; -- also <> and ~=
  193.     pragma BUILTIN('!=',5, 3, 2); -- PEMS_INTEGER, PEMDCMNE
  194.     pragma FIPSFLAG('!=', 1450);    
  195.   function '<'  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  196.     pragma BUILTIN('<',4, 3, 3);  -- PEMS_INTEGER, PEMDCMLT
  197.     pragma FIPSFLAG('<', 1450);    
  198.   function '<=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  199.     pragma BUILTIN('<=',6, 3, 4); -- PEMS_INTEGER, PEMDCMLE
  200.     pragma FIPSFLAG('<=', 1450);    
  201.   function '>'  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  202.     pragma BUILTIN('>',1, 3, 5); -- PEMS_INTEGER, PEMDCMGT
  203.     pragma FIPSFLAG('>', 1450);    
  204.   function '>=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  205.     pragma BUILTIN('>=',3, 3, 6); -- PEMS_INTEGER, PEMDMGE
  206.     pragma FIPSFLAG('>=', 1450);    
  207.  
  208.   --  Since SQL permits short-circuit evaluation, the 'and' and 'or'
  209.   --  operations will always be interpreted as 'and then' and 'or else'
  210.   --  when they occur in conditional statements.
  211.  
  212.   function XOR (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
  213.     pragma BUILTIN('XOR',8, 3, 9); -- PEMS_INTEGER, INT_XOR
  214.     pragma FIPSFLAG('XOR', 1450);    
  215.  
  216.   function 'NOT' (RIGHT BOOLEAN) return BOOLEAN;
  217.     pragma BUILTIN('NOT',9, 3, 10); -- PEMS_INTEGER, INT_NOT
  218.  
  219.   function 'IS NULL' (B BOOLEAN) return BOOLEAN;
  220.     pragma BUILTIN('IS NULL', 0, 3, 0);  -- PEMS_INTEGER, PEMDNUL
  221.     pragma FIPSFLAG('IS NULL', 1450);    
  222.  
  223.   function 'IS NOT NULL' (B BOOLEAN) return BOOLEAN;
  224.     pragma FIPSFLAG('IS NOT NULL', 1450);    
  225.  
  226.   function NVL (B1 BOOLEAN, B2 BOOLEAN) return BOOLEAN;
  227.     pragma FIPSFLAG('NVL', 1450);    
  228.  
  229. --****************************************************************
  230.  
  231.   function '='  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  232.     pragma BUILTIN('=',2, 1, 14); -- PEMS_CHAR, PEMDCMEQ (VARCHAR2 SEMANTICS)
  233.     pragma FIPSFLAG('=', 1454);    
  234.   function '!=' (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  235.     pragma BUILTIN('!=',5, 1, 15);  -- PEMS_CHAR, PEMDCMNE (VARCHAR2 SEMANTICS)
  236.     pragma FIPSFLAG('!=', 1454);    
  237.   function '<'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  238.     pragma BUILTIN('<',4, 1, 16); -- PEMS_CHAR, PEMDCMLT (VARCHAR2 SEMANTICS)
  239.     pragma FIPSFLAG('<', 1454);    
  240.   function '<=' (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  241.     pragma BUILTIN('<=',6, 1, 17); -- PEMS_CHAR, PEMDCMLE (VARCHAR2 SEMANTICS)
  242.     pragma FIPSFLAG('<=', 1454);    
  243.   function '>'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  244.     pragma BUILTIN('>',1, 1, 18); -- PEMS_CHAR, PEMDCMGT (VARCHAR2 SEMANTICS)
  245.     pragma FIPSFLAG('>', 1454);    
  246.   function '>=' (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  247.     pragma BUILTIN('>=',3, 1, 19); -- PEMS_CHAR, PEMDCMGE (VARCHAR2 SEMANTICS)
  248.     pragma FIPSFLAG('>=', 1454);    
  249.  
  250.   function '||' (LEFT VARCHAR2, RIGHT VARCHAR2) return VARCHAR2;
  251.     pragma BUILTIN('||',25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
  252.     pragma FIPSFLAG('||', 1454);    
  253.  
  254.   function CONCAT(LEFT VARCHAR2, RIGHT VARCHAR2) return varchar2;
  255.     pragma BUILTIN(CONCAT,25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
  256.     pragma FIPSFLAG(CONCAT, 1454);    
  257.  
  258.  
  259.   function LENGTH(ch VARCHAR2) return natural;
  260.     pragma FIPSFLAG('LENGTH', 1452);    
  261.  
  262.   -- In SUBSTR, LEN defaults to remainder of string
  263.   -- In substr and instr, a negative value of parameter POS means to
  264.   -- count from the right end of the string.
  265.   function SUBSTR(STR1 VARCHAR2, POS binary_integer, 
  266.             LEN binary_integer := NULL)
  267.     return varchar2;
  268.     pragma FIPSFLAG('SUBSTR', 1452);    
  269.  
  270.   -- Find nth occurrence of str1 in str2 starting at pos
  271.   function INSTR(STR1 VARCHAR2, STR2 VARCHAR2, POS BINARY_INTEGER := 1,
  272.                  NTH POSITIVE := 1) return BINARY_INTEGER;
  273.     pragma FIPSFLAG('INSTR', 1452);    
  274.  
  275.   function UPPER(ch VARCHAR2) return varchar2;
  276.     pragma FIPSFLAG('UPPER', 1452);    
  277.   function LOWER(ch VARCHAR2) return varchar2;
  278.     pragma FIPSFLAG('LOWER', 1452);    
  279.   function ASCII(ch VARCHAR2) return BINARY_INTEGER; -- should be ASCII.CHRANGE
  280.     pragma FIPSFLAG('ASCII', 1452);    
  281.   function CHR(n BINARY_INTEGER) return varchar2;  -- N should be ASCII.CHRANGE
  282.     pragma FIPSFLAG('CHR', 1452);    
  283.   function INITCAP(ch VARCHAR2) return varchar2;
  284.     pragma FIPSFLAG('INITCAP', 1452);    
  285.   function SOUNDEX(ch VARCHAR2) return varchar2;
  286.     pragma FIPSFLAG('SOUNDEX', 1452);    
  287.  
  288.   function LPAD(STR1 VARCHAR2, LEN binary_integer,
  289.         PAD VARCHAR2 := ' ') return VARCHAR2;
  290.     pragma FIPSFLAG('LPAD', 1452);    
  291.  
  292.   function RPAD(STR1 VARCHAR2, LEN binary_integer,
  293.         PAD VARCHAR2 := ' ') return VARCHAR2;
  294.     pragma FIPSFLAG('RPAD', 1452);     
  295.  
  296.   function TRANSLATE(STR1 VARCHAR2, SRC VARCHAR2, DEST VARCHAR2)
  297.     return VARCHAR2;
  298.     pragma FIPSFLAG('TRANSLATE', 1452);    
  299.  
  300.   function REPLACE(SRCSTR VARCHAR2, OLDSUB VARCHAR2,
  301.            NEWSUB VARCHAR2 := '') return VARCHAR2;
  302.     pragma FIPSFLAG('REPLACE', 1452);
  303.  
  304.   function LTRIM(STR1 VARCHAR2 := ' ',
  305.           TSET VARCHAR2 := ' ') return VARCHAR2;
  306.     pragma FIPSFLAG('LTRIM', 1452);
  307.  
  308.   function RTRIM(STR1 VARCHAR2 := ' ',
  309.           TSET VARCHAR2 := ' ') return VARCHAR2;
  310.     pragma FIPSFLAG('RTRIM', 1452);
  311.  
  312.   function 'LIKE' (str VARCHAR2, pat VARCHAR2) return BOOLEAN;
  313.   function 'NOT_LIKE' (str VARCHAR2, pat VARCHAR2) return BOOLEAN;
  314.   function 'LIKE' (str VARCHAR2, pat VARCHAR2, esc VARCHAR2) return BOOLEAN;
  315.   function 'NOT_LIKE' (str VARCHAR2, pat VARCHAR2, esc VARCHAR2) 
  316.     return BOOLEAN;
  317.   function 'IS NULL' (s VARCHAR2) return BOOLEAN;
  318.     pragma BUILTIN('IS NULL', 0, 1, 20);  -- PEMS_CHAR, PEMDNUL
  319.   function 'IS NOT NULL' (s VARCHAR2) return BOOLEAN;
  320.  
  321.   function NVL(s1 VARCHAR2, s2 VARCHAR2) return VARCHAR2;
  322.     pragma FIPSFLAG('NVL', 1452);
  323.  
  324.  
  325. --****************************************************************
  326.  
  327.   function '='  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  328.     pragma BUILTIN('=',2, 2, 1); -- PEMS_NUMBER, PEMDCMEQ
  329.   function '!=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;  -- also <> and ~=
  330.     pragma BUILTIN('!=',5, 2, 2); -- PEMS_NUMBER, PEMDCMNE
  331.     pragma FIPSFLAG('!=', 1452);
  332.   function '<'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  333.     pragma BUILTIN('<',4, 2, 3); -- PEMS_NUMBER, PEMDCMLT
  334.   function '<=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  335.     pragma BUILTIN('<=',6, 2, 4); -- PEMS_NUMBER, PEMDCMLE
  336.   function '>'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  337.     pragma BUILTIN('>',1, 2, 5); -- PEMS_NUMBER, PEMDCMGT
  338.   function '>=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  339.     pragma BUILTIN('>=',3, 2, 6); -- PEMS_NUMBER, PEMDCMGE
  340.  
  341.   function 'IS NULL' (n NUMBER) return BOOLEAN;
  342.     pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
  343.   function 'IS NOT NULL' (n NUMBER) return BOOLEAN;
  344.   function NVL(n1 NUMBER, n2 NUMBER) return NUMBER;
  345.     pragma FIPSFLAG('NVL', 1452);
  346.  
  347.   function '+' (RIGHT NUMBER) return NUMBER;
  348.     pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
  349.   function '-' (RIGHT NUMBER) return NUMBER;
  350.     pragma BUILTIN('-',15, 2, 7); -- PEMS_NUMBER, NUM_NEG
  351.   function ABS(n NUMBER) return NUMBER;
  352.     pragma FIPSFLAG('ABS', 1452);
  353.  
  354.   function '+' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  355.     pragma BUILTIN('+',14, 2, 8); -- PEMS_NUMBER, NUM_ADD
  356.   function '-' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  357.     pragma BUILTIN('-',15, 2, 9); -- PEMS_NUMBER, NUM_SUB
  358.   function '*' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  359.     pragma BUILTIN('*',17, 2, 10); -- PEMS_NUMBER, NUM_MUL
  360.   function '/' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  361.     pragma BUILTIN('/',18, 2, 11); -- PEMS_NUMBER, NUM_DIV
  362.  
  363.   function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  364.     pragma FIPSFLAG('REM', 1452);
  365.   function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER;
  366.     pragma FIPSFLAG('MOD', 1452);
  367.  
  368.   function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  369.     pragma FIPSFLAG('**', 1452);
  370.  
  371.   function FLOOR(n NUMBER) return NUMBER;
  372.     pragma FIPSFLAG('FLOOR', 1452);
  373.   function CEIL(n NUMBER) return NUMBER;
  374.     pragma FIPSFLAG('CEIL', 1452);
  375.   function SQRT(n NUMBER) return NUMBER;
  376.     pragma FIPSFLAG('SQRT', 1452);
  377.   function SIGN(n NUMBER) return SIGNTYPE;
  378.     pragma FIPSFLAG('SIGN', 1452);
  379.  
  380.   function COS(N NUMBER) return NUMBER;
  381.   function SIN(N NUMBER) return NUMBER;
  382.   function TAN(N NUMBER) return NUMBER;
  383.   function COSH(N NUMBER) return NUMBER;
  384.   function SINH(N NUMBER) return NUMBER;
  385.   function TANH(N NUMBER) return NUMBER;
  386.   function EXP(N NUMBER) return NUMBER;
  387.   function LN(N NUMBER) return NUMBER;
  388.  
  389.   function BITAND (LEFT binary_integer, RIGHT binary_integer)  
  390.     return binary_integer; 
  391.   function LOG (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
  392.  
  393.   function TRUNC (n NUMBER, places binary_integer := 0) return NUMBER;
  394.     pragma FIPSFLAG('TRUNC', 1452);
  395.  
  396.   function ROUND (LEFT NUMBER, RIGHT binary_integer := 0) return NUMBER;
  397.     pragma FIPSFLAG('ROUND', 1452);
  398.  
  399.   function POWER (n NUMBER, e NUMBER) return NUMBER;
  400.     pragma FIPSFLAG('POWER', 1452);
  401.  
  402. --****************************************************************
  403.  
  404.   function '='  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  405.     pragma BUILTIN('=',2, 12, 1); -- PEMS_DATE, PEMDCMEQ
  406.     pragma FIPSFLAG('=', 1450);
  407.   function '!=' (LEFT DATE, RIGHT DATE) return BOOLEAN;  -- also <> and ~=
  408.     pragma BUILTIN('!=',5, 12, 2); -- PEMS_DATE, PEMDCMNE
  409.     pragma FIPSFLAG('!=', 1450);
  410.   function '<'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  411.     pragma BUILTIN('<',4, 12, 3); -- PEMS_DATE, PEMDCMLT
  412.     pragma FIPSFLAG('<', 1450);
  413.   function '<=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
  414.     pragma BUILTIN('<=',6, 12, 4); -- PEMS_DATE, PEMDCMLE
  415.     pragma FIPSFLAG('<=', 1450);
  416.   function '>'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  417.     pragma BUILTIN('>',1, 12, 5);  -- PEMS_DATE, PEMDCMGT
  418.     pragma FIPSFLAG('>', 1450);
  419.   function '>=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
  420.     pragma BUILTIN('>=',3, 12, 6);  -- PEMS_DATE, PEMDCMGE
  421.     pragma FIPSFLAG('>=', 1450);
  422.  
  423.   function '+' (LEFT DATE, RIGHT NUMBER) return DATE;
  424.     pragma BUILTIN('+',14, 12, 7); -- PEMS_DATE, DATE_ADD1
  425.     pragma FIPSFLAG('+', 1450);
  426.   function '+' (LEFT NUMBER, RIGHT DATE) return DATE;
  427.     pragma BUILTIN('+',14, 12, 8); -- PEMS_DATE, DATE_ADD2
  428.     pragma FIPSFLAG('+', 1450);
  429.   function '-' (LEFT DATE, RIGHT NUMBER) return DATE;
  430.     pragma BUILTIN('-',15, 12, 9); -- PEMS_DATE, DATE_SUB1
  431.     pragma FIPSFLAG('-', 1450);
  432.   function '-' (LEFT NUMBER, RIGHT DATE) return DATE;
  433.     pragma BUILTIN('-',15, 12, 10); -- PEMS_DATE, DATE_SUB2
  434.     pragma FIPSFLAG('-', 1450);
  435.   function '-' (LEFT DATE, RIGHT DATE) return NUMBER;
  436.     pragma BUILTIN('-',15, 12, 11); -- PEMS_DATE, DATE_SUB3
  437.     pragma FIPSFLAG('-', 1450);
  438.  
  439.   function LAST_DAY(RIGHT DATE) return DATE;
  440.     pragma BUILTIN('LAST_DAY',38, 12, 12); -- PEMS_DATE, DATE_LAST_DAY
  441.     pragma FIPSFLAG('LAST_DAY', 1450);
  442.   function ADD_MONTHS(LEFT DATE, RIGHT NUMBER) return DATE;
  443.     pragma BUILTIN('ADD_MONTHS',39, 12, 13); -- PEMS_DATE, DATE_ADD_MONTHS1
  444.     pragma FIPSFLAG('ADD_MONTHS', 1450);
  445.   function ADD_MONTHS(LEFT NUMBER, RIGHT DATE) return DATE;
  446.     pragma BUILTIN('ADD_MONTHS',39, 12, 14); -- PEMS_DATE, DATE_ADD_MONTHS2
  447.     pragma FIPSFLAG('ADD_MONTHS', 1450);
  448.  
  449.   function MONTHS_BETWEEN(LEFT DATE, RIGHT DATE) return NUMBER;
  450.     pragma BUILTIN('MONTHS_BETWEEN',42, 12, 15); -- PEMS_DATE, DATE_MONTHS_BET
  451.     pragma FIPSFLAG('MONTHS_BETWEEN', 1450);
  452.   function NEXT_DAY(LEFT DATE, RIGHT VARCHAR2) return DATE;
  453.     pragma BUILTIN('NEXT_DAY',43, 12, 16); -- PEMS_DATE, DATE_NEXT_DAY
  454.     pragma FIPSFLAG('NEXT_DAY', 1450);
  455.   function ROUND(RIGHT DATE) return DATE;
  456.     pragma BUILTIN('ROUND',24, 12, 17); -- PEMS_DATE, DATE_ROUND
  457.     pragma FIPSFLAG('ROUND', 1450);
  458.   function NEW_TIME(RIGHT DATE, MIDDLE VARCHAR2, LEFT VARCHAR2) return DATE;
  459.     pragma FIPSFLAG('NEW_TIME', 1450);
  460.  
  461.   function 'IS NULL' (d DATE) return BOOLEAN;
  462.     pragma BUILTIN('IS NULL', 0, 12, 0);  -- PEMS_DATE, PEMDNUL
  463.     pragma FIPSFLAG('IS NULL', 1450);
  464.   function 'IS NOT NULL' (d DATE) return BOOLEAN;
  465.     pragma FIPSFLAG('IS NOT NULL', 1450);
  466.   function NVL (d1 DATE, d2 DATE) return DATE;
  467.     pragma FIPSFLAG('NVL', 1450);
  468.  
  469. --****************************************************************
  470.  
  471.   function TRUNC(LEFT DATE) return DATE;
  472.     pragma BUILTIN('TRUNC',51, 12, 20); -- PEMS_DATE, DATE_TRUNC1
  473.     pragma FIPSFLAG('TRUNC', 1450);
  474.   function TRUNC(LEFT DATE, RIGHT VARCHAR2) return DATE;
  475.     pragma BUILTIN('TRUNC',51, 12, 21); -- PEMS_DATE, DATE_TRUNC2
  476.     pragma FIPSFLAG('TRUNC', 1450);
  477.   function ROUND(LEFT DATE, RIGHT VARCHAR2) return DATE;
  478.     pragma BUILTIN('ROUND',24, 12, 22); -- PEMS_DATE, DATE_ROUND2
  479.     pragma FIPSFLAG('ROUND', 1450);
  480.  
  481. --****************************************************************
  482. -- basetype conversion routines
  483.  
  484.   function TO_DATE    (RIGHT VARCHAR2)     return DATE;
  485.     pragma BUILTIN('TO_DATE',40, 1, 10); -- PEMS_CHAR, CHR_CNV_DAT
  486.     pragma FIPSFLAG('TO_DATE', 1450);
  487.  
  488.   function TO_DATE (LEFT VARCHAR2, RIGHT VARCHAR2) return DATE;
  489.     pragma BUILTIN('TO_DATE',40, 1, 8); -- PEMS_CHAR, CHR_CNV_DATE
  490.     pragma FIPSFLAG('TO_DATE', 1450);
  491.  
  492.   function TO_DATE (LEFT NUMBER, RIGHT VARCHAR2) return DATE;
  493.     pragma FIPSFLAG('TO_DATE', 1450);
  494.  
  495.   function TO_DATE(left varchar2, format varchar2, parms varchar2) return date;
  496.  
  497.   function TO_CHAR (RIGHT DATE) return VARCHAR2;
  498.     pragma BUILTIN('TO_CHAR',41, 12, 23); -- PEMS_DATE, DAT_CNV_CHR2
  499.  
  500.   function TO_CHAR (LEFT DATE, RIGHT VARCHAR2) return VARCHAR2;
  501.     pragma BUILTIN('TO_CHAR',41, 12, 19); -- PEMS_DATE, DAT_CNV_CHR1
  502.     pragma FIPSFLAG('TO_CHAR', 1450);
  503.  
  504.   function TO_CHAR (LEFT NUMBER, RIGHT VARCHAR2) return VARCHAR2;
  505.     pragma BUILTIN('TO_CHAR',41, 2, 12); -- PEMS_NUMBER, NUM_CNV_CHR
  506.  
  507.   function TO_CHAR (LEFT NUMBER) return VARCHAR2;
  508.  
  509.   function TO_NUMBER (LEFT NUMBER) RETURN NUMBER;
  510.  
  511.   function TO_NUMBER (RIGHT VARCHAR2)      return NUMBER;
  512.     pragma BUILTIN('TO_NUMBER',48, 1, 9); -- PEMS_CHAR, CHR_CNV_NUM
  513.  
  514.   function TO_NUMBER(left varchar2, format varchar2)     return number;
  515.   function TO_NUMBER(left varchar2, format varchar2, parms varchar2) 
  516.     return number;
  517.  
  518. --****************************************************************
  519.  
  520.   -- Note that we really aren't returning an binary_integer.  It returns
  521.   -- whatever the POSth datatype is....  This should COG ok though...
  522.   function  GETBND(POS BINARY_INTEGER)             return BINARY_INTEGER;
  523.     pragma BUILTIN('GETBND',240,202,240);
  524.     pragma FIPSFLAG('GETBND', 1452);
  525.  
  526.   procedure SETBND(POS BINARY_INTEGER, VAL NUMBER);
  527.     pragma BUILTIN('SETBND',240,201,240);
  528.     pragma FIPSFLAG('SETBND', 1453);
  529.  
  530.  
  531. ------------ Define the Pragmas ----------------
  532. -- (most of) these don't really need the argument_id's
  533. -- in fact I think this is unneeded
  534. pragma NEWPRAGMA(interface,language,subprogram);
  535. pragma NEWPRAGMA(interface_C,subprogram,C_routine);
  536. pragma NEWPRAGMA(Environ_Call,Call_Num,Arg);
  537. pragma NEWPRAGMA(Environ_Call1,Call_Num,Arg);
  538.  
  539.  
  540. -- Define SQL predicates.  These don't gen code, so no body is needed.
  541.  
  542. -- PRIOR is WEIRD - For now, it will be treated as a function call.
  543. -- Does the function only take a column name?  how about its use in
  544. -- a predicate?
  545. function 'PRIOR'(colname VARCHAR2) return VARCHAR2;
  546.     pragma FIPSFLAG('PRIOR', 1452);
  547. function 'PRIOR'(colname NUMBER) return NUMBER;
  548.     pragma FIPSFLAG('PRIOR', 1452);
  549. function 'PRIOR'(colname DATE) return DATE;
  550.     pragma FIPSFLAG('PRIOR', 1450);
  551.  
  552. -- Outer Join has same problem as PRIOR
  553. function '(+)'(colname VARCHAR2) return VARCHAR2;
  554. function '(+)'(colname NUMBER) return NUMBER;
  555. function '(+)'(colname DATE) return DATE;
  556.     pragma FIPSFLAG('(+)', 1450);
  557.  
  558. function '=ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  559. function '=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  560.     pragma FIPSFLAG('=ANY', 1450);
  561. function '=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  562.  
  563. function '!=ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  564. function '!=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  565.     pragma FIPSFLAG('!=ANY', 1450);
  566. function '!=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  567.  
  568. function '<ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  569. function '<ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  570.     pragma FIPSFLAG('<ANY', 1450);
  571. function '<ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  572.  
  573. function '<=ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  574. function '<=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  575.     pragma FIPSFLAG('<=ANY', 1450);
  576. function '<=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  577.  
  578. function '>ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  579. function '>ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  580.     pragma FIPSFLAG('>ANY', 1450);
  581. function '>ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  582.  
  583. function '>=ANY'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  584. function '>=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  585.     pragma FIPSFLAG('>=ANY', 1450);
  586. function '>=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  587.  
  588. function '=ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  589. function '=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  590.     pragma FIPSFLAG('=ALL', 1450);
  591. function '=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  592.  
  593. function '!=ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  594. function '!=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  595.     pragma FIPSFLAG('!=ALL', 1450);
  596. function '!=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  597.  
  598. function '<ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  599. function '<ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  600.     pragma FIPSFLAG('<ALL', 1450);
  601. function '<ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  602.  
  603. function '<=ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  604. function '<=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  605.     pragma FIPSFLAG('<=ALL', 1450);
  606. function '<=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  607.  
  608. function '>ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  609. function '>ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  610.     pragma FIPSFLAG('>ALL', 1450);
  611. function '>ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  612.  
  613. function '>=ALL'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  614. function '>=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  615.     pragma FIPSFLAG('>=ALL', 1450);
  616. function '>=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  617.  
  618. function '=SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  619. function '=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  620.     pragma FIPSFLAG('=SOME', 1450);
  621. function '=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  622.  
  623. function '!=SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  624. function '!=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  625.     pragma FIPSFLAG('!=SOME', 1450);
  626. function '!=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  627.  
  628. function '<SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  629. function '<SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  630.     pragma FIPSFLAG('<SOME', 1450);
  631. function '<SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  632.  
  633. function '<=SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  634. function '<=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  635.     pragma FIPSFLAG('<=SOME', 1450);
  636. function '<=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  637.  
  638. function '>SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  639. function '>SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  640.     pragma FIPSFLAG('>SOME', 1450);
  641. function '>SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  642.  
  643. function '>=SOME'  (LEFT VARCHAR2, RIGHT VARCHAR2) return BOOLEAN;
  644. function '>=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
  645.     pragma FIPSFLAG('>=SOME', 1450);
  646. function '>=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
  647.  
  648. function 'BETWEEN' (TESTVAL VARCHAR2, LOW VARCHAR2, HIGH VARCHAR2)
  649.     return BOOLEAN;
  650. function 'BETWEEN' (TESTVAL NUMBER, LOW NUMBER, HIGH NUMBER) return BOOLEAN;
  651. function 'BETWEEN' (TESTVAL BOOLEAN, LOW BOOLEAN, HIGH BOOLEAN) return BOOLEAN;
  652.     pragma FIPSFLAG('BETWEEN', 1450);
  653. function 'BETWEEN' (TESTVAL DATE, LOW DATE, HIGH DATE) return BOOLEAN;
  654.     pragma FIPSFLAG('BETWEEN', 1450);
  655.  
  656.  
  657. --    SQL Transaction routines
  658.  
  659. procedure SET_TRANSACTION_USE(vc VARCHAR2);
  660. procedure COMMIT;
  661. procedure COMMIT_CM(vc VARCHAR2);
  662. procedure ROLLBACK_NR;
  663. procedure ROLLBACK_SV(Save_Point CHAR);
  664. procedure SAVEPOINT(Save_Point CHAR);
  665.  
  666. --    Generic SQL DDL routine
  667.  
  668. --procedure SQL_DDL(Stmt VARCHAR2);
  669.  
  670.  
  671.   function SYSDATE return DATE;
  672.     pragma FIPSFLAG('SYSDATE', 1452);
  673.  
  674.   function UID return NUMBER;
  675.     pragma FIPSFLAG('UID', 1452);
  676.  
  677.   function USER return VARCHAR2;
  678.  
  679.   function USERENV (envstr VARCHAR2) return VARCHAR2;
  680.     pragma FIPSFLAG('USERENV', 1452);
  681.  
  682.  
  683.   -- ROWID: this dreadful identifier is supposed to represent a datatype
  684.   -- outside of SQL and and a pseudo-column (function, to us) when inside
  685.   -- a sql statement.  ADA data model doesn't allow for any
  686.   -- function X return X;
  687.   -- so we must special case this.  Yuk.  There's special-case code in ph2nre
  688.   -- which maps "rowid" to "rowid " if we're inside a SQL stmt.
  689.   function "ROWID " return ROWID;
  690.     pragma builtin('ROWID ', 1, 209, 240);  -- this had better never be called.
  691.  
  692.   function NULLFN (str VARCHAR2) return RAW;
  693.     pragma builtin('NULLFN', 1, 0, 1); 
  694.  
  695.   function HEXTORAW (c VARCHAR2) return RAW;
  696.      pragma builtin('HEXTORAW', 1, 23, 1);
  697.  
  698.   function RAWTOHEX (r RAW) return VARCHAR2;
  699.      pragma builtin('RAWTOHEX', 1, 23, 2);
  700.  
  701.   function CHARTOROWID (str VARCHAR2) return ROWID;
  702.     pragma builtin('CHARTOROWID', 1, 0, 1);
  703.  
  704.   function ROWIDTOCHAR (str ROWID) return VARCHAR2;
  705.     pragma builtin('ROWIDTOCHAR', 1, 0, 1);
  706.  
  707.  
  708. -- Trusted*Oracle additions
  709.  
  710.   Function ROWLABEL return MLSLABEL;               -- pseudo column
  711.  
  712.   Function TO_CHAR(label MLSLABEL) return VARCHAR2;
  713.     pragma BUILTIN('TO_CHAR',90, 4, 1); -- PEMS_CHAR, CHR_CNV_MLS
  714.  
  715.   Function TO_CHAR(label MLSLABEL, format VARCHAR2) return VARCHAR2;
  716.     pragma BUILTIN('TO_CHAR',90, 4, 19); -- PEMS_DATE, MLS_CNV_CHR1
  717.     pragma FIPSFLAG('TO_CHAR', 1450);
  718.  
  719.   Function TO_LABEL(label VARCHAR2, format VARCHAR2 ) return  MLSLABEL;
  720.     pragma BUILTIN('TO_LABEL',90, 4, 8); -- PEMS_CHAR, CHR_CNV_MLS
  721.     pragma FIPSFLAG('TO_LABEL', 1450);
  722.  
  723.   Function TO_LABEL(label VARCHAR2 ) return  MLSLABEL;
  724.     pragma BUILTIN('TO_LABEL',90, 4, 2); -- PEMS_CHAR, CHR_CNV_MLS
  725.     pragma FIPSFLAG('TO_LABEL', 1450);
  726.  
  727. -- vararg routines - icds in stdbdy 
  728.   Function LEAST_UB    (pattern MLSLABEL) return MLSLABEL;
  729.     pragma BUILTIN('LEAST_UB',90, 4, 3); -- PEMS_CHAR, CHR_CNV_MLS
  730.   Function GREATEST_LB (pattern MLSLABEL) return MLSLABEL;
  731.     pragma BUILTIN('GREATEST_LB',90, 4, 4); -- PEMS_CHAR, CHR_CNV_MLS
  732.  
  733.   Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  734.   Function '>'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  735.   Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  736.   Function '<'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  737.   Function '='  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  738.   Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
  739.   function 'IS NULL' (label MLSLABEL) return BOOLEAN;
  740.     pragma BUILTIN('IS NULL', 0, 1,20);   -- same "cod" as IS NULL(varchar2)
  741.   function 'IS NOT NULL' (label MLSLABEL) return BOOLEAN;
  742.  
  743.   function NVL(label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL;
  744.     pragma FIPSFLAG('NVL', 1452);
  745.  
  746. -- group functions 
  747.   Function LUB (label MLSLABEL) return MLSLABEL;
  748.   Function GLB (label MLSLABEL) return MLSLABEL;
  749.  
  750. -- end of Trusted*Oracle additions 
  751.  
  752.  
  753. -- beginning of NLS routines 
  754.  
  755.   function NLSSORT(c VARCHAR2) return RAW;
  756.     pragma FIPSFLAG('NLSSORT', 1452);    
  757.   function NLSSORT(c VARCHAR2, c2 VARCHAR2) return RAW;
  758.     pragma FIPSFLAG('NLSSORT', 1452);    
  759.   function NLS_UPPER(ch VARCHAR2, parms varchar2) return varchar2;
  760.     pragma FIPSFLAG('NLS_UPPER', 1452);    
  761.   function NLS_UPPER(c VARCHAR2) return VARCHAR2;
  762.     pragma FIPSFLAG('NLS_UPPER', 1452);    
  763.   function NLS_LOWER(ch VARCHAR2, parms varchar2) return varchar2;
  764.     pragma FIPSFLAG('NLS_LOWER', 1452);    
  765.   function NLS_LOWER(c VARCHAR2) return VARCHAR2;
  766.     pragma FIPSFLAG('NLS_LOWER', 1452);    
  767.   function NLS_INITCAP(ch VARCHAR2, parms varchar2) return varchar2;
  768.     pragma FIPSFLAG('NLS_INITCAP', 1452);    
  769.   function NLS_INITCAP(c VARCHAR2) return VARCHAR2;
  770.     pragma FIPSFLAG('NLS_INITCAP', 1452);    
  771.  
  772.   function LENGTHB(ch VARCHAR2) return number;
  773.     pragma FIPSFLAG('LENGTHB', 1452);    
  774.   function SUBSTRB(STR1 VARCHAR2, POS binary_integer, 
  775.         LEN binary_integer := NULL)
  776.     return VARCHAR2;
  777.     pragma FIPSFLAG('SUBSTRB', 1452);    
  778.   function INSTRB(STR1 VARCHAR2, STR2 VARCHAR2, POS binary_integer := 1,
  779.                  NTH binary_integer := 1) return NUMBER;
  780.     pragma FIPSFLAG('INSTRB', 1452);    
  781.  
  782.   function TO_SINGLE_BYTE(c VARCHAR2) return VARCHAR2;
  783.     pragma FIPSFLAG('TO_SINGLE_BYTE', 1452);    
  784.   function TO_MULTI_BYTE(c VARCHAR2) return VARCHAR2;
  785.     pragma FIPSFLAG('TO_MULTI_BYTE', 1452);    
  786.  
  787.   -- Next two added for NLS 6/3/92 JEM.
  788.   function TO_CHAR(left date, format varchar2, parms varchar2) return varchar2;
  789.   function TO_CHAR(left number, format varchar2, parms varchar2) 
  790.     return varchar2;
  791.  
  792. -- end of NLS routines 
  793.  
  794. function CONVERT(src VARCHAR2, destcset VARCHAR2) return VARCHAR2;
  795. function CONVERT(src VARCHAR2, destcset VARCHAR2, srccset VARCHAR2) 
  796.     return VARCHAR2;
  797.  
  798. function VSIZE (e number ) return NUMBER;
  799.     pragma builtin('VSIZE', 1, 0, 1);
  800. function VSIZE (e DATE) return NUMBER;
  801.     pragma builtin('VSIZE', 1, 0, 1);
  802. function VSIZE (e VARCHAR2) return NUMBER;
  803.     pragma builtin('VSIZE', 1, 0, 1);
  804.  
  805.  
  806. -- dump 
  807. -- dump( expr [,display_format[,start_pos[,length]]]) return VARCHAR2
  808. function DUMP(e varchar2,df binary_integer := null,sp binary_integer := null,
  809.         len binary_integer := null) return VARCHAR2;
  810.     pragma builtin('DUMP', 1, 0, 1);
  811.  
  812. function DUMP(e number,df binary_integer := null,sp binary_integer := null,
  813.         len binary_integer := null) return VARCHAR2;
  814.     pragma builtin('DUMP', 1, 0, 1);
  815.  
  816. function DUMP(e date,df binary_integer := null,sp binary_integer := null,
  817.         len binary_integer := null) return VARCHAR2;
  818.     pragma builtin('DUMP', 1, 0, 1);
  819.  
  820.  
  821. end STANDARD;
  822. /
  823.  
  824. create or replace package body STANDARD is
  825.  
  826. subtype Cursor_Handle is binary_integer range 0..255;
  827.  
  828. -- icds 
  829.  
  830.   function peslen(ch VARCHAR2) return NATURAL;
  831.     pragma interface (c,peslen);
  832.   function pessub(ch VARCHAR2, pos BINARY_INTEGER, len BINARY_INTEGER) 
  833.     return varchar2;
  834.     pragma interface (c,pessub);
  835.  
  836.   function pesist(text VARCHAR2, substr VARCHAR2, 
  837.         strt BINARY_INTEGER, cnt POSITIVE)
  838.         return BINARY_INTEGER;
  839.     pragma interface (c,pesist);
  840.  
  841.   function pesupp(ch VARCHAR2) return varchar2;
  842.     pragma interface (c,pesupp);
  843.  
  844.   function peslow(ch VARCHAR2) return varchar2;
  845.     pragma interface (c,peslow);
  846.  
  847.   function peslpd(ch VARCHAR2, len BINARY_INTEGER, padchar VARCHAR2) 
  848.         return varchar2;
  849.     pragma interface (c,peslpd);
  850.  
  851.   function pesrpd(ch VARCHAR2, len BINARY_INTEGER, padchar varchar2) 
  852.         return varchar2;
  853.     pragma interface (c,pesrpd);
  854.  
  855.   function pesasc(ch VARCHAR2) return NATURAL;
  856.     pragma interface (c,pesasc);
  857.  
  858.   function peschr(n NATURAL) return varchar2;
  859.     pragma interface (c,peschr);
  860.  
  861.   function pesicp(ch VARCHAR2) return varchar2;
  862.     pragma interface (c,pesicp);
  863.  
  864.   function pesxlt(ch VARCHAR2, cpy VARCHAR2, frm VARCHAR2, too VARCHAR2) 
  865.     return varchar2;
  866.     pragma interface (c,pesxlt);
  867.  
  868.   function pesltr(ch VARCHAR2, trimset VARCHAR2) return varchar2;
  869.     pragma interface (c,pesltr);
  870.  
  871.   function pesrtr(ch VARCHAR2, trimset VARCHAR2) return varchar2;
  872.     pragma interface (c,pesrtr);
  873.  
  874.   function peslik(str varchar2, pat varchar2) return boolean;
  875.     pragma interface (c,peslik);
  876.  
  877.   function pesli2(str varchar2, pat varchar2, esc varchar2) return boolean;
  878.     pragma interface (c,pesli2);
  879.  
  880.   function pesabs(n NUMBER) return NUMBER;
  881.     pragma interface (c,pesabs);
  882.  
  883.   function pesmod(n1 NUMBER, n2 NUMBER) return NUMBER;
  884.     pragma interface (c,pesmod);
  885.  
  886.   function pesflo(n NUMBER) return NUMBER;
  887.     pragma interface (c,pesflo);
  888.  
  889.   function pescei(n NUMBER) return NUMBER;
  890.     pragma interface (c,pescei);
  891.  
  892.   function pessqt(n NUMBER) return NUMBER;
  893.     pragma interface (c,pessqt);
  894.  
  895.   function pessgn(n NUMBER) return SIGNTYPE;
  896.     pragma interface (c,pessgn);
  897.  
  898. -- trig fns 
  899.   function pescos(n number) return number;
  900.     pragma interface (c,pescos);
  901.   function pessin(n number) return number;
  902.     pragma interface (c,pessin);
  903.   function pestan(n number) return number;
  904.     pragma interface (c,pestan);
  905.   function pescsh(n number) return number;
  906.     pragma interface (c,pescsh);
  907.   function pessnh(n number) return number;
  908.     pragma interface (c,pessnh);
  909.   function pestnh(n number) return number;
  910.     pragma interface (c,pestnh);
  911.   function pesexp(n number) return number;
  912.     pragma interface (c,pesexp);
  913.   function pesln(n number) return number;
  914.     pragma interface (c,pesln);
  915.   function peslog(left number,right number) return number;
  916.     pragma interface (c,peslog);
  917.   function pesbtd(left binary_integer,right binary_integer) 
  918.     return binary_integer;
  919.     pragma interface (c,pesbtd);
  920.  
  921.   function pestru(n NUMBER, places BINARY_INTEGER) return NUMBER;
  922.     pragma interface (c,pestru);
  923.  
  924.   function pesrnd(n NUMBER, places BINARY_INTEGER) return NUMBER;
  925.     pragma interface (c,pesrnd);
  926.  
  927.   function pespow(n NUMBER, e NUMBER) return NUMBER;
  928.     pragma interface (c,pespow);
  929.  
  930.   function pesnwt(r date, m varchar2, l varchar2) return date;
  931.     pragma interface (c,pesnwt);
  932.  
  933.   function pessdt return DATE;
  934.     pragma interface (c,pessdt);
  935.  
  936.   function pesxco(c VARCHAR2, format VARCHAR2) return raw;
  937.     pragma interface (c,pesxco);
  938.  
  939.   function pesxup(ch VARCHAR2, format VARCHAR2) return varchar2;
  940.     pragma interface (c,pesxup);
  941.  
  942.   function pesxlo(ch VARCHAR2, format VARCHAR2) return varchar2;
  943.     pragma interface (c,pesxlo);
  944.  
  945.   function pesxcp(ch VARCHAR2, format VARCHAR2) return varchar2;
  946.     pragma interface (c,pesxcp);
  947.  
  948.   function pesxln(ch VARCHAR2) return NATURAL;
  949.     pragma interface (c,pesxln);
  950.  
  951.   function pesxsu(ch VARCHAR2, pos BINARY_INTEGER, len BINARY_INTEGER) 
  952.     return varchar2;
  953.     pragma interface (c,pesxsu);
  954.  
  955.   function pesxis(text VARCHAR2, substr VARCHAR2, strt BINARY_INTEGER, 
  956.     cnt POSITIVE)
  957.         return BINARY_INTEGER;
  958.     pragma interface (c,pesxis);
  959.  
  960.   function pesxsi(ch VARCHAR2) return varchar2;
  961.     pragma interface (c,pesxsi);
  962.  
  963.   function pesxmu(ch VARCHAR2) return varchar2;
  964.     pragma interface (c,pesxmu);
  965.  
  966.   function pesc2d(left varchar2, format varchar2, parms varchar2) return date;
  967.     pragma interface(c, pesc2d);
  968.  
  969.   function pesc2n(left varchar2, format varchar2, parms varchar2) 
  970.     return number;
  971.     pragma interface(c, pesc2n);
  972.  
  973.   function pesd2c(left date, format varchar2, parms varchar2) return varchar2;
  974.     pragma interface(c, pesd2c);
  975.  
  976.   function pesn2c(left number, format varchar2, parms varchar2) 
  977.     return varchar2;
  978.     pragma interface(c, pesn2c);
  979.  
  980. -- end of NLS icds
  981.  
  982. -- begin trusted icds
  983. -- Comparisons
  984.   function peszge(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  985.     pragma interface (c,peszge);
  986.   function peszgt(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  987.     pragma interface (c,peszgt);
  988.   function peszle(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  989.     pragma interface (c,peszle);
  990.   function peszlt(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  991.     pragma interface (c,peszlt);
  992.   function peszeq(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  993.     pragma interface (c,peszeq);
  994.   function peszne(label1 MLSLABEL,label2 MLSLABEL) return BOOLEAN;
  995.     pragma interface (c,peszne);
  996. -- Conversions
  997. --  function peslts(label MLSLABEL,format VARCHAR2) return VARCHAR2;
  998. --    pragma interface (c,peslts);
  999. --  function pesstl(label varchar2,format VARCHAR2) return MLSLABEL;
  1000. --    pragma interface (c,pesstl);
  1001. -- end trusted icds
  1002. -----------------------------------------------------------
  1003.  
  1004.   function 'IS NOT NULL'(b BOOLEAN) return BOOLEAN is
  1005.   begin
  1006.     return (NOT b IS NULL);
  1007.   end 'IS NOT NULL';
  1008.  
  1009.   function NVL (b1 BOOLEAN, b2 BOOLEAN) return BOOLEAN is
  1010.   begin
  1011.     if (b1 IS NULL) then return (b2); else return(b1); end if;
  1012.   end NVL;
  1013.  
  1014.   function sqlerrm return varchar2 is
  1015.     n1 number;
  1016.   begin
  1017.     n1 := sqlcode;
  1018.     return sqlerrm(n1);
  1019.   end sqlerrm;
  1020.  
  1021.   function length (ch varchar2) return natural is
  1022.   begin
  1023.     return peslen(ch);
  1024.   end length;
  1025.  
  1026.   function SUBSTR(STR1 VARCHAR2, POS BINARY_INTEGER, 
  1027.             LEN BINARY_INTEGER := NULL) 
  1028.     return varchar2 is
  1029.   begin
  1030.     return pessub(STR1, POS, LEN);
  1031.   end SUBSTR;
  1032.  
  1033.   function INSTR(STR1 VARCHAR2, STR2 VARCHAR2, POS BINARY_INTEGER := 1,
  1034.                  NTH POSITIVE := 1) return BINARY_INTEGER is
  1035.   begin
  1036.     return pesist(STR1, STR2, POS, NTH);
  1037.   end INSTR;
  1038.  
  1039.   function UPPER(ch VARCHAR2) return varchar2 is
  1040.   begin
  1041.     return pesupp(ch);
  1042.   end UPPER;
  1043.  
  1044.   function LOWER(ch VARCHAR2) return varchar2 is
  1045.   begin
  1046.     return peslow(ch);
  1047.   end LOWER;
  1048.  
  1049.   function ASCII(ch VARCHAR2) return BINARY_INTEGER is
  1050.   begin
  1051.     return pesasc(ch);
  1052.   end ASCII;
  1053.  
  1054.   function CHR(n BINARY_INTEGER) return varchar2 is
  1055.   begin
  1056.     return peschr(n);
  1057.   end CHR;
  1058.  
  1059.   function INITCAP(ch VARCHAR2) return varchar2 is
  1060.   begin
  1061.     return pesicp(ch);
  1062.   end INITCAP;
  1063.  
  1064.   function SOUNDEX(ch VARCHAR2) return varchar2 is
  1065.     c varchar2(2000);
  1066.   begin
  1067.   --return pessdx(ch);
  1068.     select soundex(ch) into c from sys.dual;
  1069.     return c;
  1070.   end SOUNDEX;
  1071.  
  1072. --
  1073. -- This was previously called from LPAD and RPAD. But they now call pes{lr}pd.
  1074. -- 10/14/92 JEM.
  1075. --
  1076. --  function l_r_pad(STR1 VARCHAR2, LEN BINARY_INTEGER, 
  1077. --            PAD VARCHAR2, LEFT BOOLEAN)
  1078. --     return VARCHAR2 is
  1079. --  str1len binary_integer; padlen binary_integer; 
  1080. --  newlen binary_integer; newstr varchar2(32767); len2 binary_integer;
  1081. --  begin
  1082. --    len2 := len;
  1083. --    if str1 IS NULL) or (len2 IS NULL) or (pad IS NULL)
  1084. --      then return(''); end if;
  1085. --    str1len := length(str1);
  1086. --    if (str1len >= len2) then return(substr(str1, 1, len2)); end if;
  1087. --    padlen := length(pad);
  1088. --    newstr := '';
  1089. --    newlen := 0;
  1090. --    len2 := len2 - str1len;
  1091. --    while newlen < len2 loop
  1092. --      newstr := pad || newstr; newlen := newlen + padlen;
  1093. --    end loop;
  1094. --    if left then return(substr(newstr, 1, len2) || str1);
  1095. --        else return(str1 || substr(newstr, 1, len2)); end if;
  1096. --  end l_r_pad;
  1097.  
  1098.   function LPAD(STR1 VARCHAR2, LEN binary_integer, 
  1099.         PAD VARCHAR2 := ' ') return VARCHAR2 is
  1100.   begin
  1101.     return peslpd(STR1, LEN, PAD);
  1102. --    return(l_r_pad(str1, len, pad, true));    replaced 10/14/92 JEM.
  1103.   end LPAD;
  1104.  
  1105.   function RPAD(STR1 VARCHAR2, LEN binary_integer,
  1106.             PAD VARCHAR2 := ' ') return VARCHAR2 is 
  1107.   begin 
  1108.     return pesrpd(STR1, LEN, PAD);
  1109. --    return(l_r_pad(str1, len, pad, false));   replaced 10/14/92 JEM.
  1110.   end RPAD;
  1111.  
  1112.   function TRANSLATE(STR1 VARCHAR2, SRC VARCHAR2, DEST VARCHAR2) 
  1113.     return varchar2 is
  1114.   begin
  1115.     if str1 is null then return str1; else
  1116.     -- The substr and concat in arg list to pesxlt is done to
  1117.     -- allocate a modifiable COPY of the first arg, STR1. This
  1118.     -- operation is a complete cheat, because we pass the copy
  1119.     -- as an IN parm, and modify it on the sly.  
  1120.     return pesxlt(STR1, substr(str1,1,1) || substr(str1,2),
  1121.                SRC, DEST);
  1122.     end if;
  1123.   end TRANSLATE;
  1124.  
  1125.   function REPLACE(SRCSTR VARCHAR2, OLDSUB VARCHAR2,
  1126.             NEWSUB VARCHAR2 := '') RETURN VARCHAR2 
  1127.   is
  1128.   brk binary_integer;
  1129.   begin
  1130.     if srcstr is null then return '';
  1131.     else
  1132.     brk := instr(srcstr, oldsub);
  1133.     if brk > 0
  1134.     then
  1135.       return(substr(srcstr, 1, brk - 1) || newsub 
  1136.          || replace(substr(srcstr, 
  1137.                     brk + length(oldsub)),
  1138.                 oldsub, newsub));
  1139.     else return srcstr; 
  1140.     end if;
  1141.     end if;
  1142.   end;
  1143.  
  1144.   function LTRIM(STR1 VARCHAR2 := ' ',
  1145.          TSET VARCHAR2 := ' ') return varchar2 is
  1146.   begin
  1147.     return pesltr(STR1, TSET);
  1148.   end LTRIM;
  1149.  
  1150.   function RTRIM(STR1 VARCHAR2 := ' ',
  1151.          TSET VARCHAR2 := ' ') return varchar2 is
  1152.   begin
  1153.     return pesrtr(STR1, TSET);
  1154.   end RTRIM; 
  1155.  
  1156.   -- might we want to combine peslik and pesli2? 
  1157.   function 'LIKE' (str varchar2, pat varchar2) return boolean is
  1158.   begin
  1159.     return peslik(str, pat);
  1160.   end;
  1161.   function 'NOT_LIKE' (str varchar2, pat varchar2) return boolean is
  1162.   begin
  1163.     return (not peslik(str, pat));
  1164.   end;
  1165.   function 'LIKE' (str varchar2, pat varchar2, esc varchar2) return boolean is
  1166.   begin
  1167.     return pesli2(str, pat, esc);
  1168.   end;
  1169.   function 'NOT_LIKE' (str varchar2, pat varchar2, esc varchar2) return boolean is
  1170.   begin
  1171.     return (not pesli2(str, pat, esc));
  1172.   end;
  1173.  
  1174.   function 'IS NOT NULL'(s VARCHAR2) return BOOLEAN is
  1175.   begin
  1176.     return (NOT (s IS NULL));
  1177.   end 'IS NOT NULL';
  1178.  
  1179.   function NVL (s1 VARCHAR2, s2 VARCHAR2) return varchar2 is
  1180.   begin
  1181.     if (s1 IS NULL) then return (s2); else return (s1); end if;
  1182.   end NVL;
  1183.  
  1184.   function 'IS NOT NULL'(n NUMBER) return BOOLEAN is
  1185.   begin
  1186.     return (NOT (n IS NULL));
  1187.   end 'IS NOT NULL';
  1188.  
  1189.   function NVL (n1 NUMBER, n2 NUMBER) return NUMBER is
  1190.   begin
  1191.     if (n1 IS NULL) then return (n2); else return(n1); end if;
  1192.   end NVL;
  1193.  
  1194.   function ABS(n NUMBER) return NUMBER is
  1195.   begin
  1196.     return pesabs(n);
  1197.   end ABS;
  1198.  
  1199.   function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER is
  1200.   begin
  1201.     return (LEFT - (trunc(LEFT / RIGHT) * RIGHT));
  1202.   end;
  1203.  
  1204.   function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER is
  1205.   begin
  1206.   --return (n1 - ((floor(n1/n2)) * n2));  
  1207.     return pesmod(n1,n2);
  1208.   end;
  1209.  
  1210.   function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER is
  1211.   begin
  1212.     return (POWER(LEFT, RIGHT));
  1213.   end;
  1214.  
  1215.   function FLOOR(n NUMBER) return NUMBER is
  1216.   begin
  1217.     return pesflo(n);
  1218.   end FLOOR;
  1219.  
  1220.   function CEIL(n NUMBER) return NUMBER is
  1221.   begin
  1222.     return pescei(n);
  1223.   end CEIL;
  1224.  
  1225.   function SQRT(n NUMBER) return NUMBER is
  1226.   begin
  1227.     if (0.0 > n) then raise VALUE_ERROR; end if;
  1228.     return pessqt(n);
  1229.   end SQRT;
  1230.  
  1231.   function SIGN(n NUMBER) return SIGNTYPE is
  1232.   begin
  1233.     return pessgn(n);
  1234.   end SIGN;
  1235.  
  1236.  
  1237.   function COS(N NUMBER) return NUMBER IS
  1238.    begin return(pescos(n)); end;
  1239.   function SIN(N NUMBER) return NUMBER IS
  1240.    begin return(pessin(n)); end;
  1241.   function TAN(N NUMBER) return NUMBER IS
  1242.    begin return(pestan(n)); end;
  1243.   function COSH(N NUMBER) return NUMBER IS
  1244.    begin return(pescsh(n)); end;
  1245.   function SINH(N NUMBER) return NUMBER IS
  1246.    begin return(pessnh(n)); end;
  1247.   function TANH(N NUMBER) return NUMBER IS
  1248.    begin return(pestnh(n)); end;
  1249.   function EXP(N NUMBER) return NUMBER IS
  1250.    begin return(pesexp(n)); end;
  1251.   function LN(N NUMBER) return NUMBER IS
  1252.    begin return(pesln(n)); end;
  1253.   function LOG(LEFT NUMBER, RIGHT NUMBER) return NUMBER IS
  1254.     begin return(peslog(left,right)); end;
  1255.   function BITAND(LEFT binary_integer, RIGHT binary_integer) 
  1256.     return binary_integer IS        
  1257.     begin return(pesbtd(left,right)); END;
  1258.  
  1259.   function TRUNC(n NUMBER, places BINARY_INTEGER := 0) return NUMBER is
  1260.   begin
  1261.     return pestru(n, places);
  1262.   end TRUNC;
  1263.  
  1264.   function ROUND(LEFT NUMBER, RIGHT BINARY_INTEGER := 0) return NUMBER is
  1265.   begin
  1266.     return pesrnd(LEFT, RIGHT);
  1267.   end ROUND;
  1268.  
  1269.   function POWER(n NUMBER, e NUMBER) return NUMBER is
  1270.   begin
  1271.     return pespow(n, e);
  1272.   end POWER;
  1273.  
  1274.   function NEW_TIME(right DATE, middle VARCHAR2, left VARCHAR2) return DATE is
  1275.   begin
  1276.     return pesnwt(right, middle, left);
  1277.   end;
  1278.  
  1279.   function 'IS NOT NULL'(d DATE) return BOOLEAN is
  1280.   begin
  1281.     return(NOT (d IS NULL));
  1282.   end 'IS NOT NULL';
  1283.  
  1284.   function NVL (d1 DATE, d2 DATE) return DATE is
  1285.   begin
  1286.     if (d1 IS NULL) then return(d2); else return(d1); end if;
  1287.   end NVL;
  1288.  
  1289. -- Just call the other to_char with a null format string. 
  1290. -- Perhaps this can be done more intelligently in the future. JEM 3/14/90.
  1291.   function TO_CHAR(LEFT NUMBER)     return varchar2 is
  1292.   begin
  1293.     return TO_CHAR(LEFT, '');
  1294.   end TO_CHAR;
  1295.  
  1296. -- Added 3/16/90 by JEM.
  1297.  function TO_NUMBER(LEFT NUMBER) return NUMBER is
  1298.  begin
  1299.    return(LEFT);
  1300.  end to_number;
  1301.  
  1302. function TO_DATE(LEFT NUMBER, RIGHT VARCHAR2) return DATE IS
  1303. begin
  1304.   return (TO_DATE(TO_char(LEFT), RIGHT));
  1305. end TO_DATE;
  1306.  
  1307. --    SQL 'PSD' routines
  1308.  
  1309. Procedure plzopn(cnum OUT Cursor_Handle, rc OUT Binary_Integer);
  1310.     pragma interface (c,plzopn);
  1311. Function plzosq(cnum Cursor_Handle, stmt VARCHAR2) return Binary_Integer;
  1312.     pragma interface (c,plzosq);
  1313. Function plzexe(cnum Cursor_Handle,chp Binary_Integer,nbnds Binary_Integer) 
  1314.     return Binary_Integer;
  1315.     pragma interface (c,plzexe);
  1316. Function plzexe(cnum Cursor_Handle) return Binary_Integer is
  1317. Begin
  1318.   return(plzexe(cnum,0,0));
  1319. End;
  1320. Function plzcls(cnum Cursor_Handle) return Binary_Integer;
  1321.     pragma interface (c,plzcls);
  1322.  
  1323. --    Generic SQL DDL routine
  1324.  
  1325. procedure SQL_DDL(Stmt VARCHAR2) is
  1326.   rc Binary_Integer;
  1327.   cnum Cursor_Handle;
  1328.   DDL_ERROR exception;
  1329. Begin
  1330.   plzopn(cnum,rc);
  1331.   if ( rc IS NOT NULL ) then
  1332.     RAISE DDL_ERROR;
  1333.   end if;
  1334.   rc := plzosq(cnum,Stmt);
  1335.   if ( rc IS NOT NULL ) then
  1336.     RAISE DDL_ERROR;
  1337.   end if;
  1338.   rc := plzexe(cnum);
  1339.   if ( rc IS NOT NULL ) then
  1340.     RAISE DDL_ERROR;
  1341.   end if;
  1342.   rc := plzcls(cnum);
  1343.   if ( rc IS NOT NULL ) then
  1344.     RAISE DDL_ERROR;
  1345.   end if;
  1346. End;
  1347.  
  1348. --    SQL Transaction routines
  1349.  
  1350. procedure SET_TRANSACTION_USE (vc varchar2) is
  1351. Begin
  1352.   SQL_DDL('SET TRANSACTION USE ROLLBACK SEGMENT ' || vc);
  1353. End;
  1354.  
  1355. procedure COMMIT is
  1356. Begin
  1357.   SQL_DDL('COMMIT');
  1358. End;
  1359.  
  1360. procedure COMMIT_CM (vc varchar2) is
  1361. Begin
  1362.   SQL_DDL('COMMIT work comment ' || '''' || vc || '''');
  1363. End;
  1364.  
  1365. procedure ROLLBACK_NR is
  1366. Begin
  1367.   SQL_DDL('ROLLBACK');
  1368. End;
  1369.  
  1370. procedure ROLLBACK_SV(Save_Point CHAR) is
  1371. Begin
  1372.   SQL_DDL('ROLLBACK TO ' || Save_Point);
  1373. End;
  1374.  
  1375. procedure SAVEPOINT(Save_Point CHAR) is
  1376. begin
  1377.   SQL_DDL('SAVEPOINT ' || Save_Point);
  1378. end;
  1379.  
  1380.   function SYSDATE return DATE is begin return pessdt; end;
  1381.  
  1382.   function UID return NUMBER is
  1383.   n number;
  1384.   begin
  1385.     select uid into n from sys.dual;
  1386.     return n;
  1387.   end;
  1388.  
  1389.   function USER return varchar2 is
  1390.   c varchar2(255);
  1391.   begin
  1392.     select user into c from sys.dual;
  1393.     return c;
  1394.   end;
  1395.  
  1396.   function USERENV (envstr VARCHAR2) return varchar2 is
  1397.   c varchar2(255);
  1398.   begin
  1399.     c := upper(envstr);
  1400.     if c is null then 
  1401.     null;
  1402.     elsif c = 'TERMINAL' then
  1403.     select userenv('TERMINAL') into c from sys.dual;
  1404.     elsif c = 'ENTRYID' then
  1405.     select userenv('ENTRYID') into c from sys.dual;
  1406.     elsif c = 'SESSIONID' then
  1407.     select userenv('SESSIONID') into c from sys.dual;
  1408.     elsif c = 'LANGUAGE' then
  1409.     select userenv('LANGUAGE') into c from sys.dual;
  1410.     elsif c = 'LABEL' then
  1411.     select userenv('LABEL') into c from sys.dual;
  1412.     else raise VALUE_ERROR;
  1413.     end if;
  1414.     return c;
  1415.   end;
  1416.  
  1417. -- Trusted*Oracle additions 
  1418.  
  1419.   Function ROWLABEL return MLSLABEL is
  1420.         begin return null; end;
  1421. -- removed - now builtin's
  1422. /*
  1423.   Function TO_CHAR(label MLSLABEL, format varchar2 := '')
  1424.      return VARCHAR2 is
  1425.     begin return peslts(label,format); end;
  1426.  
  1427.   Function TO_LABEL(label varchar2, format varchar2 := '')
  1428.      return MLSLABEL is
  1429.     begin return pesstl(label,format); end;
  1430. */
  1431. -- Comparison functions 
  1432.   Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1433.     begin return peszge(label1,label2); end;
  1434.   Function '>'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1435.     begin return peszgt(label1,label2); end;
  1436.   Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1437.     begin return peszle(label1,label2); end;
  1438.   Function '<'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1439.     begin return peszlt(label1,label2); end;
  1440.   Function '='  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1441.     begin return peszeq(label1,label2); end;
  1442.   Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN is
  1443.     begin return peszne(label1,label2); end;
  1444.  
  1445.   function 'IS NOT NULL'(label MLSLABEL) return BOOLEAN is
  1446.   begin
  1447.     return (NOT (label IS NULL));
  1448.   end 'IS NOT NULL';
  1449.  
  1450.   function NVL (label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL is
  1451.   begin
  1452.     if (label1 IS NULL) then return (label2); else return (label1); end if;
  1453.   end NVL;
  1454.  
  1455. -- group functions 
  1456.   Function LUB (label MLSLABEL) return MLSLABEL is
  1457.     begin return null; end;
  1458.   Function GLB (label MLSLABEL) return MLSLABEL is
  1459.     begin return null; end;
  1460.  
  1461. -- end of Trusted*Oracle additions 
  1462.  
  1463.     
  1464. -- beginning of NLS routines 
  1465. -- replaced with new versions 6/3/92 JEM 
  1466.  
  1467.   function NLSSORT(c VARCHAR2, c2 varchar2) return raw is
  1468.   begin
  1469.     return pesxco(c, c2);
  1470.   end NLSSORT;
  1471.  
  1472.   function NLSSORT(c VARCHAR2) return raw is
  1473.   begin
  1474.     return pesxco(c,'');
  1475.   end NLSSORT;
  1476.  
  1477.   function NLS_UPPER(ch VARCHAR2, parms varchar2) return varchar2 is
  1478.   begin
  1479.     return pesxup(ch,parms);
  1480.   end NLS_UPPER;
  1481.  
  1482.   function NLS_UPPER(c VARCHAR2) return varchar2 is
  1483.   begin
  1484.     return pesxup(c,'');
  1485.   end NLS_UPPER;
  1486.  
  1487.   function NLS_LOWER(ch VARCHAR2, parms varchar2) return varchar2 is
  1488.   begin
  1489.     return pesxlo(ch,parms);
  1490.   end NLS_LOWER;
  1491.  
  1492.   function NLS_LOWER(c VARCHAR2) return varchar2 is
  1493.   begin
  1494.     return pesxlo(c,'');
  1495.   end NLS_LOWER;
  1496.  
  1497.   function NLS_INITCAP(ch VARCHAR2, parms varchar2) return varchar2 is
  1498.   begin
  1499.     return pesxcp(ch,parms);
  1500.   end NLS_INITCAP;
  1501.  
  1502.   function NLS_INITCAP(c VARCHAR2) return varchar2 is
  1503.   begin
  1504.     return pesxcp(c,'');
  1505.   end NLS_INITCAP;
  1506.  
  1507.   function LENGTHB(ch VARCHAR2) return NUMBER is
  1508.   begin
  1509.     return TO_NUMBER(pesxln(ch));
  1510.   end LENGTHB;
  1511.  
  1512.   function SUBSTRB(STR1 VARCHAR2, POS binary_integer, 
  1513.             LEN binary_integer := NULL) 
  1514.     return varchar2 is
  1515.   begin
  1516.     return pesxsu(str1, pos, len);
  1517.   end SUBSTRB;
  1518.  
  1519.   function INSTRB(STR1 VARCHAR2, STR2 VARCHAR2, POS binary_integer := 1,
  1520.                  NTH binary_integer := 1) return NUMBER is
  1521.   begin
  1522.     return pesxis(STR1, STR2, pos, nth);
  1523.   end INSTRB;
  1524.  
  1525.   function TO_SINGLE_BYTE(c VARCHAR2) return varchar2 is
  1526.   begin
  1527.     return pesxsi(c);
  1528.   end TO_SINGLE_BYTE;
  1529.  
  1530.   function TO_MULTI_BYTE(c VARCHAR2) return varchar2 is
  1531.   begin
  1532.     return pesxmu(c);
  1533.   end TO_MULTI_BYTE;
  1534.  
  1535.   function TO_DATE(left varchar2, format varchar2, parms varchar2) 
  1536.           return date is
  1537.   begin
  1538.     return pesc2d(left, format, parms);
  1539.   end TO_DATE;
  1540.  
  1541.   function TO_NUMBER(left varchar2, format varchar2) return number is
  1542.   begin
  1543.     return pesc2n(left, format, '');
  1544.   end TO_NUMBER;
  1545.  
  1546.   function TO_NUMBER(left varchar2, format varchar2, parms varchar2) 
  1547.     return number is
  1548.   begin
  1549.     return pesc2n(left, format, parms);
  1550.   end TO_NUMBER;
  1551.  
  1552.   function TO_CHAR(left date, format varchar2, parms varchar2) 
  1553.          return varchar2 is
  1554.   begin
  1555.     return pesd2c(left, format, parms);
  1556.   end TO_CHAR;
  1557.  
  1558.   function TO_CHAR(left number, format varchar2, parms varchar2) 
  1559.     return varchar2 is
  1560.   begin
  1561.     return pesn2c(left, format, parms);
  1562.   end TO_CHAR;
  1563.  
  1564. -- end of NLS routines 
  1565.  
  1566.  
  1567. function CONVERT(src varchar2, destcset varchar2) return varchar2
  1568. is
  1569.   v varchar2(2000);
  1570.   begin
  1571.   select convert(src,destcset) into v from sys.dual;
  1572.   return v;
  1573. end;
  1574.  
  1575. function CONVERT(src varchar2, destcset varchar2,srccset varchar2) return varchar2
  1576. is
  1577.   v varchar2(2000);
  1578.   begin
  1579.   select convert(src,destcset,srccset) into v from sys.dual;
  1580.   return v;
  1581. end;
  1582.  
  1583. -- DUMP and VSIZE are now not allowed in non-sql plsql, has code to forbid 
  1584. -- it there, and is defined as a builtin in stdspc. The body will not be 
  1585. -- called in plsql.
  1586. --- CMB
  1587. ----
  1588. -- dump 
  1589. -- dump( expr [,display_format[,start_pos[,length]]]) return varchar2
  1590. -- how large should the plsql varchar2 string be 
  1591. --
  1592.  
  1593. -- why do we need these dummy bodies for LEVEL and ROWNUM?
  1594.  
  1595.   function LEVEL return NUMBER is
  1596.     begin return 0.0; end;
  1597.  
  1598.   function ROWNUM return NUMBER is
  1599.     begin return 0.0; end;
  1600.   
  1601. end STANDARD;
  1602. /
  1603.