오라클 함수

1 Oracle Function[편집]

1.1 function EXISTS[편집]

 function EXISTS" return BOOLEAN;
   pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj

1.2 function GREATEST[편집]

 function GREATEST (pattern NUMBER) return NUMBER;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.3 function GREATEST[편집]

 function GREATEST (pattern VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET pattern%CHARSET;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.4 function GREATEST[편집]

 function GREATEST (pattern DATE) return DATE;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.5 function LEAST[편집]

 function LEAST (pattern NUMBER) return NUMBER;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj

1.6 function LEAST[편집]

 function LEAST (pattern VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET pattern%CHARSET;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj

1.7 function LEAST[편집]

 function LEAST (pattern DATE) return DATE;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj

1.8 function DECODE[편집]

 function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.9 function DECODE[편집]

 function DECODE (expr NUMBER,
                  pat NUMBER,
                  res VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET res%CHARSET;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.10 function DECODE[편집]

 function DECODE (expr NUMBER, pat NUMBER, res DATE) return DATE;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.11 function DECODE[편집]

 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
                  pat VARCHAR2 CHARACTER SET expr%CHARSET,
                  res NUMBER) return NUMBER;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.12 function DECODE[편집]

 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
                  pat VARCHAR2 CHARACTER SET expr%CHARSET,
                  res VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET res%CHARSET;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.13 function DECODE[편집]

 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
                  pat VARCHAR2 CHARACTER SET expr%CHARSET,
                  res DATE) return DATE;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.14 function DECODE[편집]

 function DECODE (expr DATE, pat DATE, res NUMBER) return NUMBER;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.15 function DECODE[편집]

 function DECODE (expr DATE,
                  pat DATE,
                  res VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET res%CHARSET;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.16 function DECODE[편집]

 function DECODE (expr DATE, pat DATE, res DATE) return DATE;
   pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

1.17 function SQLCODE[편집]

 function SQLCODE return PLS_INTEGER;
   pragma BUILTIN('SQLCODE',45, 10, 0); -- PEMS_DB, DB_SQLCODE

1.18 function SQLERRM[편집]

 function SQLERRM return varchar2;
   pragma FIPSFLAG('SQLERRM', 1452);

1.19 function SQLERRM[편집]

 function SQLERRM (code PLS_INTEGER) return varchar2;
   pragma BUILTIN('SQLERRM',46, 10, 1); -- PEMS_DB, DB_SQLERRM
   pragma FIPSFLAG('SQLERRM', 1452);

1.20 function LEVEL[편집]

 function LEVEL return NUMBER;

1.21 function ROWNUM[편집]

 function ROWNUM return NUMBER;

1.22 function '='[편집]

 function '='  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('=',2, 3, 1); -- PEMS_INTEGER, PEMDCMEQ
   pragma FIPSFLAG('=', 1450);

1.23 function '!='[편집]

 function '!=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN; -- also <> and ~=
   pragma BUILTIN('!=',5, 3, 2); -- PEMS_INTEGER, PEMDCMNE
   pragma FIPSFLAG('!=', 1450);

1.24 function '<'[편집]

 function '<'  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('<',4, 3, 3);  -- PEMS_INTEGER, PEMDCMLT
   pragma FIPSFLAG('<', 1450);

1.25 function '<='[편집]

 function '<=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('<=',6, 3, 4); -- PEMS_INTEGER, PEMDCMLE
   pragma FIPSFLAG('<=', 1450);

1.26 function '>[편집]

 function '>'  (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('>',1, 3, 5); -- PEMS_INTEGER, PEMDCMGT
   pragma FIPSFLAG('>', 1450);

1.27 function '>[편집]

 function '>=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('>=',3, 3, 6); -- PEMS_INTEGER, PEMDMGE
   pragma FIPSFLAG('>=', 1450);

 --  Since SQL permits short-circuit evaluation, the 'and' and 'or'
 --  operations will always be interpreted as 'and then' and 'or else'
 --  when they occur in conditional statements.

1.28 function XOR[편집]

 function XOR (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('XOR',8, 3, 9); -- PEMS_INTEGER, INT_XOR
   pragma FIPSFLAG('XOR', 1450);

1.29 function 'NOT[편집]

 function 'NOT' (RIGHT BOOLEAN) return BOOLEAN;
   pragma BUILTIN('NOT',9, 3, 10); -- PEMS_INTEGER, INT_NOT

1.30 function 'IS[편집]

 function 'IS NULL' (B BOOLEAN) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);  -- PEMS_INTEGER, PEMDNUL
   pragma FIPSFLAG('IS NULL', 1450);

1.31 function 'IS[편집]

 function 'IS NOT NULL' (B BOOLEAN) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50); -- PEMS_INTEGER, PEMDNUL
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.32 function NVL[편집]

 function NVL (B1 BOOLEAN, B2 BOOLEAN) return BOOLEAN;
   pragma FIPSFLAG('NVL', 1450);

1.33 function '='[편집]

 function '='  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('=',2, 1, 14); -- PEMS_CHAR, PEMDCMEQ (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('=', 1454);

1.34 function '!='[편집]

 function '!=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('!=',5, 1, 15);  -- PEMS_CHAR, PEMDCMNE (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('!=', 1454);

1.35 function '<'[편집]

 function '<'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('<',4, 1, 16); -- PEMS_CHAR, PEMDCMLT (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('<', 1454);

1.36 function '<='[편집]

 function '<=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('<=',6, 1, 17); -- PEMS_CHAR, PEMDCMLE (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('<=', 1454);

1.37 function '>[편집]

 function '>'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('>',1, 1, 18); -- PEMS_CHAR, PEMDCMGT (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('>', 1454);

1.38 function '>[편집]

 function '>=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('>=',3, 1, 19); -- PEMS_CHAR, PEMDCMGE (VARCHAR2 SEMANTICS)
   pragma FIPSFLAG('>=', 1454);

1.39 function '||'[편집]

 function '||' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET LEFT%CHARSET;
   pragma BUILTIN('||',25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
   pragma FIPSFLAG('||', 1454);

1.40 function CONCAT[편집]

 function CONCAT(LEFT VARCHAR2 CHARACTER SET ANY_CS,
                 RIGHT VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET LEFT%CHARSET;
   pragma BUILTIN(CONCAT,25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
   pragma FIPSFLAG(CONCAT, 1454);

1.41 function LENGTH[편집]

 function LENGTH(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
   pragma FIPSFLAG('LENGTH', 1452);
 -- In SUBSTR, LEN defaults to remainder of string
 -- In substr and instr, a negative value of parameter POS means to
 -- count from the right end of the string.

1.42 function SUBSTR[편집]

 function SUBSTR(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                 POS PLS_INTEGER,
                 LEN PLS_INTEGER := 2147483647)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTR', 1452);

 -- Find nth occurrence of str1 in str2 starting at pos

1.43 function INSTR[편집]

 function INSTR(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
                POS PLS_INTEGER := 1,
                NTH POSITIVE := 1) return PLS_INTEGER;
   pragma FIPSFLAG('INSTR', 1452);

1.44 function UPPER[편집]

 function UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('UPPER', 1452);

1.45 function LOWER[편집]

 function LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('LOWER', 1452);

1.46 function ASCII[편집]

 function ASCII(ch VARCHAR2 CHARACTER SET ANY_CS)
       return INTEGER; -- should be ASCII.CHRANGE
   pragma FIPSFLAG('ASCII', 1452);

1.47 function ASCIISTR[편집]

 function ASCIISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('ASCIISTR', 1452);

1.48 function UNISTR[편집]

 function UNISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
       return NVARCHAR2;
   pragma FIPSFLAG('UNISTR', 1452);

1.49 function CHR[편집]

 function CHR(n INTEGER) return varchar2;  -- N should be ASCII.CHRANGE
   pragma FIPSFLAG('CHR', 1452);

1.50 function[편집]

 function  SYS$STANDARD_CHR"(n INTEGER,csn VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET csn%CHARSET;
   pragma FIPSFLAG(' SYS$STANDARD_CHR', 1452);

1.51 function INITCAP[편집]

 function INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('INITCAP', 1452);

1.52 function SOUNDEX[편집]

 function SOUNDEX(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('SOUNDEX', 1452);

1.53 function LPAD[편집]

 function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
               LEN pls_integer,
               PAD VARCHAR2 CHARACTER SET STR1%CHARSET)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LPAD', 1452);

1.54 function LPAD[편집]

 function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
               LEN pls_integer)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
 pragma FIPSFLAG('LPAD', 1452);

1.55 function RPAD[편집]

 function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
               LEN pls_integer,
               PAD VARCHAR2 CHARACTER SET STR1%CHARSET)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RPAD', 1452);

1.56 function RPAD[편집]

 function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
               LEN pls_integer)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RPAD', 1452);

1.57 function TRANSLATE[편집]

 function TRANSLATE(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                    SRC VARCHAR2 CHARACTER SET STR1%CHARSET,
                    DEST VARCHAR2 CHARACTER SET STR1%CHARSET)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('TRANSLATE', 1452);

1.58 function REPLACE[편집]

 function REPLACE(SRCSTR VARCHAR2 CHARACTER SET ANY_CS,
                  OLDSUB VARCHAR2 CHARACTER SET SRCSTR%CHARSET,
                  NEWSUB VARCHAR2 CHARACTER SET SRCSTR%CHARSET := NULL)
       return VARCHAR2 CHARACTER SET SRCSTR%CHARSET;
   pragma FIPSFLAG('REPLACE', 1452);

1.59 function LTRIM[편집]

 function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ',
                TSET VARCHAR2 CHARACTER SET STR1%CHARSET)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LTRIM', 1452);

1.60 function LTRIM[편집]

 function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LTRIM', 1452);

1.61 function RTRIM[편집]

 function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ',
                TSET VARCHAR2 CHARACTER SET STR1%CHARSET)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RTRIM', 1452);

1.62 function RTRIM[편집]

 function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RTRIM', 1452);

1.63 function 'LIKE[편집]

 function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
                  pat VARCHAR2 CHARACTER SET str%CHARSET)
       return BOOLEAN;

1.64 function 'NOT_LIKE[편집]

 function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
                      pat VARCHAR2 CHARACTER SET str%CHARSET)
       return BOOLEAN;

1.65 function 'LIKE[편집]

 function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
                  pat VARCHAR2 CHARACTER SET str%CHARSET,
                  esc VARCHAR2 CHARACTER SET str%CHARSET)
       return BOOLEAN;

1.66 function 'NOT_LIKE[편집]

 function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
                      pat VARCHAR2 CHARACTER SET str%CHARSET,
                      esc VARCHAR2 CHARACTER SET str%CHARSET)
       return BOOLEAN;

1.67 function 'IS[편집]

 function 'IS NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 1, 20);  -- PEMS_CHAR, PEMDNUL

1.68 function 'IS[편집]

 function 'IS NOT NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 1, 50); -- PEMS_CHAR, PEMDNUL

1.69 function NVL[편집]

 function NVL(s1 VARCHAR2 CHARACTER SET ANY_CS,
              s2 VARCHAR2 CHARACTER SET s1%CHARSET)
       return VARCHAR2 CHARACTER SET s1%CHARSET;
   pragma FIPSFLAG('NVL', 1452);

1.70 function '='[편집]

 function '='  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
   pragma BUILTIN('=',2, 2, 1); -- PEMS_NUMBER, PEMDCMEQ

1.71 function '!='[편집]

 function '!=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;  -- also <> and ~=
   pragma BUILTIN('!=',5, 2, 2); -- PEMS_NUMBER, PEMDCMNE
   pragma FIPSFLAG('!=', 1452);

1.72 function '<'[편집]

 function '<'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
   pragma BUILTIN('<',4, 2, 3); -- PEMS_NUMBER, PEMDCMLT

1.73 function '<='[편집]

 function '<=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
   pragma BUILTIN('<=',6, 2, 4); -- PEMS_NUMBER, PEMDCMLE

1.74 function '>[편집]

 function '>'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
   pragma BUILTIN('>',1, 2, 5); -- PEMS_NUMBER, PEMDCMGT

1.75 function '>[편집]

 function '>=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
   pragma BUILTIN('>=',3, 2, 6); -- PEMS_NUMBER, PEMDCMGE

1.76 function 'IS[편집]

 function 'IS NULL' (n NUMBER) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL

1.77 function 'IS[편집]

 function 'IS NOT NULL' (n NUMBER) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_NUMBER, PEMDNUL

1.78 function NVL[편집]

 function NVL(n1 NUMBER, n2 NUMBER) return NUMBER;
   pragma FIPSFLAG('NVL', 1452);

1.79 function '+'[편집]

 function '+' (RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK

1.80 function '-'[편집]

 function '-' (RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('-',15, 2, 7); -- PEMS_NUMBER, NUM_NEG

1.81 function ABS[편집]

 function ABS(n NUMBER) return NUMBER;
   pragma FIPSFLAG('ABS', 1452);

1.82 function '+'[편집]

 function '+' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('+',14, 2, 8); -- PEMS_NUMBER, NUM_ADD

1.83 function '-'[편집]

 function '-' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('-',15, 2, 9); -- PEMS_NUMBER, NUM_SUB

1.84 function '*'[편집]

 function '*' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('*',17, 2, 10); -- PEMS_NUMBER, NUM_MUL

1.85 function '/'[편집]

 function '/' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma BUILTIN('/',18, 2, 11); -- PEMS_NUMBER, NUM_DIV

1.86 function 'REM[편집]

 function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma FIPSFLAG('REM', 1452);

1.87 function 'MOD[편집]

 function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER;
   pragma FIPSFLAG('MOD', 1452);

1.88 function '**'[편집]

 function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
   pragma FIPSFLAG('**', 1452);

1.89 function FLOOR[편집]

 function FLOOR(n NUMBER) return NUMBER;
   pragma FIPSFLAG('FLOOR', 1452);

1.90 function CEIL[편집]

 function CEIL(n NUMBER) return NUMBER;
   pragma FIPSFLAG('CEIL', 1452);

1.91 function SQRT[편집]

 function SQRT(n NUMBER) return NUMBER;
   pragma FIPSFLAG('SQRT', 1452);

1.92 function SIGN[편집]

 function SIGN(n NUMBER) return SIGNTYPE;
 pragma FIPSFLAG('SIGN', 1452);

1.93 function COS[편집]

 function COS(N NUMBER) return NUMBER;
   pragma FIPSFLAG('COS', 1452);

1.94 function SIN[편집]

 function SIN(N NUMBER) return NUMBER;
   pragma FIPSFLAG('SIN', 1452);

1.95 function TAN[편집]

 function TAN(N NUMBER) return NUMBER;
   pragma FIPSFLAG('TAN', 1452);

1.96 function COSH[편집]

 function COSH(N NUMBER) return NUMBER;
   pragma FIPSFLAG('COSH', 1452);

1.97 function SINH[편집]

 function SINH(N NUMBER) return NUMBER;
   pragma FIPSFLAG('SINH', 1452);

1.98 function TANH[편집]

 function TANH(N NUMBER) return NUMBER;
   pragma FIPSFLAG('TANH', 1452);

1.99 function EXP[편집]

 function EXP(N NUMBER) return NUMBER;

1.100 function LN[편집]

 function LN(N NUMBER) return NUMBER;

1.101 function BITAND[편집]

 function BITAND (LEFT pls_integer, RIGHT pls_integer)
       return pls_integer;

1.102 function BITAND[편집]

 function BITAND (LEFT number, RIGHT number)
       return number;

1.103 function LOG[편집]

 function LOG (LEFT NUMBER, RIGHT NUMBER) return NUMBER;

1.104 function TRUNC[편집]

 function TRUNC (n NUMBER, places pls_integer := 0) return NUMBER;
   pragma FIPSFLAG('TRUNC', 1452);

1.105 function ROUND[편집]

 function ROUND (LEFT NUMBER, RIGHT pls_integer := 0) return NUMBER;
   pragma FIPSFLAG('ROUND', 1452);

1.106 function POWER[편집]

 function POWER (n NUMBER, e NUMBER) return NUMBER;
   pragma FIPSFLAG('POWER', 1452);

1.107 function '='[편집]

 function '='  (LEFT DATE, RIGHT DATE) return BOOLEAN;
   pragma BUILTIN('=',2, 12, 1); -- PEMS_DATE, PEMDCMEQ
   pragma FIPSFLAG('=', 1450);

1.108 function '!='[편집]

 function '!=' (LEFT DATE, RIGHT DATE) return BOOLEAN;  -- also <> and ~=
   pragma BUILTIN('!=',5, 12, 2); -- PEMS_DATE, PEMDCMNE
   pragma FIPSFLAG('!=', 1450);

1.109 function '<'[편집]

 function '<'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
   pragma BUILTIN('<',4, 12, 3); -- PEMS_DATE, PEMDCMLT
   pragma FIPSFLAG('<', 1450);

1.110 function '<='[편집]

 function '<=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
   pragma BUILTIN('<=',6, 12, 4); -- PEMS_DATE, PEMDCMLE
   pragma FIPSFLAG('<=', 1450);

1.111 function '>[편집]

 function '>'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
   pragma BUILTIN('>',1, 12, 5);  -- PEMS_DATE, PEMDCMGT
   pragma FIPSFLAG('>', 1450);

1.112 function '>[편집]

 function '>=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
   pragma BUILTIN('>=',3, 12, 6);  -- PEMS_DATE, PEMDCMGE
   pragma FIPSFLAG('>=', 1450);

1.113 function '+'[편집]

 function '+' (LEFT DATE, RIGHT NUMBER) return DATE;
   pragma BUILTIN('+',14, 12, 7); -- PEMS_DATE, DATE_ADD1
   pragma FIPSFLAG('+', 1450);

1.114 function '+'[편집]

 function '+' (LEFT NUMBER, RIGHT DATE) return DATE;
   pragma BUILTIN('+',14, 12, 8); -- PEMS_DATE, DATE_ADD2
   pragma FIPSFLAG('+', 1450);

1.115 function '-'[편집]

 function '-' (LEFT DATE, RIGHT NUMBER) return DATE;
   pragma BUILTIN('-',15, 12, 9); -- PEMS_DATE, DATE_SUB1
   pragma FIPSFLAG('-', 1450);

1.116 function '-'[편집]

 function '-' (LEFT NUMBER, RIGHT DATE) return DATE;
   pragma BUILTIN('-',15, 12, 10); -- PEMS_DATE, DATE_SUB2
   pragma FIPSFLAG('-', 1450);

1.117 function '-'[편집]

 function '-' (LEFT DATE, RIGHT DATE) return NUMBER;
   pragma BUILTIN('-',15, 12, 11); -- PEMS_DATE, DATE_SUB3
   pragma FIPSFLAG('-', 1450);

1.118 function LAST_DAY[편집]

 function LAST_DAY(RIGHT DATE) return DATE;
   pragma BUILTIN('LAST_DAY',38, 12, 12); -- PEMS_DATE, DATE_LAST_DAY
   pragma FIPSFLAG('LAST_DAY', 1450);

1.119 function ADD_MONTHS[편집]

 function ADD_MONTHS(LEFT DATE, RIGHT NUMBER) return DATE;
   pragma BUILTIN('ADD_MONTHS',39, 12, 13); -- PEMS_DATE, DATE_ADD_MONTHS1
   pragma FIPSFLAG('ADD_MONTHS', 1450);

1.120 function ADD_MONTHS[편집]

 function ADD_MONTHS(LEFT NUMBER, RIGHT DATE) return DATE;
   pragma BUILTIN('ADD_MONTHS',39, 12, 14); -- PEMS_DATE, DATE_ADD_MONTHS2
   pragma FIPSFLAG('ADD_MONTHS', 1450);

1.121 function MONTHS_BETWEEN[편집]

 function MONTHS_BETWEEN(LEFT DATE, RIGHT DATE) return NUMBER;
   pragma BUILTIN('MONTHS_BETWEEN',42, 12, 15); -- PEMS_DATE, DATE_MONTHS_BET
   pragma FIPSFLAG('MONTHS_BETWEEN', 1450);

1.122 function NEXT_DAY[편집]

 function NEXT_DAY(LEFT DATE, RIGHT VARCHAR2) return DATE;
   pragma BUILTIN('NEXT_DAY',43, 12, 16); -- PEMS_DATE, DATE_NEXT_DAY
   pragma FIPSFLAG('NEXT_DAY', 1450);

1.123 function ROUND[편집]

 function ROUND(RIGHT DATE) return DATE;
   pragma BUILTIN('ROUND',24, 12, 17); -- PEMS_DATE, DATE_ROUND
   pragma FIPSFLAG('ROUND', 1450);

1.124 function NEW_TIME[편집]

 function NEW_TIME(RIGHT DATE, MIDDLE VARCHAR2, LEFT VARCHAR2) return DATE;
   pragma FIPSFLAG('NEW_TIME', 1450);

1.125 function 'IS[편집]

 function 'IS NULL' (d DATE) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 12, 0);  -- PEMS_DATE, PEMDNUL
   pragma FIPSFLAG('IS NULL', 1450);

1.126 function 'IS[편집]

 function 'IS NOT NULL' (d DATE) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 12, 50);  -- PEMS_DATE, PEMDNUL
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.127 function NVL[편집]

 function NVL (d1 DATE, d2 DATE) return DATE;
   pragma FIPSFLAG('NVL', 1450);

1.128 function TRUNC[편집]

 function TRUNC(LEFT DATE) return DATE;
   pragma BUILTIN('TRUNC',51, 12, 20); -- PEMS_DATE, DATE_TRUNC1
   pragma FIPSFLAG('TRUNC', 1450);

1.129 function TRUNC[편집]

 function TRUNC(LEFT DATE, RIGHT VARCHAR2) return DATE;
   pragma BUILTIN('TRUNC',51, 12, 21); -- PEMS_DATE, DATE_TRUNC2
   pragma FIPSFLAG('TRUNC', 1450);

1.130 function ROUND[편집]

 function ROUND(LEFT DATE, RIGHT VARCHAR2) return DATE;
   pragma BUILTIN('ROUND',24, 12, 22); -- PEMS_DATE, DATE_ROUND2
   pragma FIPSFLAG('ROUND', 1450);

1.131 function TO_DATE[편집]

 function TO_DATE    (RIGHT VARCHAR2 character set any_cs)  return DATE;
   pragma BUILTIN('TO_DATE',40, 1, 10); -- PEMS_CHAR, CHR_CNV_DAT
   pragma FIPSFLAG('TO_DATE', 1450);

1.132 function TO_DATE[편집]

 function TO_DATE (LEFT VARCHAR2 character set any_cs,
      RIGHT VARCHAR2 character set LEFT%charset) return DATE;
   pragma BUILTIN('TO_DATE',40, 1, 8); -- PEMS_CHAR, CHR_CNV_DATE
   pragma FIPSFLAG('TO_DATE', 1450);

1.133 function TO_DATE[편집]

 function TO_DATE (LEFT NUMBER, RIGHT VARCHAR2) return DATE;
   pragma FIPSFLAG('TO_DATE', 1450);

1.134 function TO_DATE[편집]

 function TO_DATE(left varchar2 character set any_cs,
                  format varchar2 character set LEFT%charset,
                  parms varchar2 character set LEFT%charset) return date;

1.135 function TO_CHAR[편집]

 function TO_CHAR (RIGHT VARCHAR2) return VARCHAR2;
   pragma BUILTIN('TO_CHAR',14, 0, 2);

1.136 function TO_CHAR[편집]

 function TO_CHAR (LEFT DATE, RIGHT VARCHAR2) return VARCHAR2;
   pragma BUILTIN('TO_CHAR',41, 12, 19); -- PEMS_DATE, DAT_CNV_CHR1
   pragma FIPSFLAG('TO_CHAR', 1450);

1.137 function TO_CHAR[편집]

 function TO_CHAR (LEFT NUMBER, RIGHT VARCHAR2) return VARCHAR2;
   pragma BUILTIN('TO_CHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR

1.138 function TO_NUMBER[편집]

 function TO_NUMBER (RIGHT NUMBER) RETURN NUMBER;
   pragma BUILTIN('TO_NUMBER',14, 0, 1); -- PEMS_QUICK

1.139 function TO_NUMBER[편집]

 function TO_NUMBER (RIGHT VARCHAR2 character set any_cs)    return NUMBER;
   pragma BUILTIN('TO_NUMBER',48, 1, 9); -- PEMS_CHAR, CHR_CNV_NUM

1.140 function TO_NUMBER[편집]

 function TO_NUMBER(left varchar2 character set any_cs,
       format varchar2 character set LEFT%charset)
   return number;

1.141 function TO_NUMBER[편집]

 function TO_NUMBER(left varchar2 character set any_cs,
                    format varchar2 character set LEFT%charset,
                    parms varchar2 character set LEFT%charset)
   return number;

 -- Define SQL predicates.  These don't gen code, so no body is needed.

1.142 function call[편집]

 -- PRIOR is WEIRD - For now, it will be treated as a function call.

1.143 function only[편집]

 -- Does the function only take a column name?  how about its use in
 -- a predicate?

1.144 function 'PRIOR[편집]

 function 'PRIOR'(colname VARCHAR2 CHARACTER SET ANY_CS)
         return VARCHAR2 CHARACTER SET colname%CHARSET;
     pragma FIPSFLAG('PRIOR', 1452);

1.145 function 'PRIOR[편집]

 function 'PRIOR'(colname NUMBER) return NUMBER;
     pragma FIPSFLAG('PRIOR', 1452);

1.146 function 'PRIOR[편집]

 function 'PRIOR'(colname DATE) return DATE;
     pragma FIPSFLAG('PRIOR', 1450);

 -- Outer Join has same problem as PRIOR

1.147 function '(+[편집]

 function '(+)'(colname VARCHAR2 CHARACTER SET ANY_CS)
         return VARCHAR2 CHARACTER SET colname%CHARSET;

1.148 function '(+[편집]

 function '(+)'(colname NUMBER) return NUMBER;

1.149 function '(+[편집]

 function '(+)'(colname DATE) return DATE;
     pragma FIPSFLAG('(+)', 1450);

1.150 function '=ANY[편집]

 function '=ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.151 function '=ANY[편집]

 function '=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('=ANY', 1450);

1.152 function '=ANY[편집]

 function '=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.153 function '!=ANY[편집]

 function '!=ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.154 function '!=ANY[편집]

 function '!=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('!=ANY', 1450);

1.155 function '!=ANY[편집]

 function '!=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.156 function '<ANY[편집]

 function '<ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.157 function '<ANY[편집]

 function '<ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<ANY', 1450);

1.158 function '<ANY[편집]

 function '<ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.159 function '<=ANY[편집]

 function '<=ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.160 function '<=ANY[편집]

 function '<=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<=ANY', 1450);

1.161 function '<=ANY[편집]

 function '<=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.162 function '>[편집]

 function '>ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.163 function '>[편집]

 function '>ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>ANY', 1450);

1.164 function '>[편집]

 function '>ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.165 function '>[편집]

 function '>=ANY'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.166 function '>[편집]

 function '>=ANY'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>=ANY', 1450);

1.167 function '>[편집]

 function '>=ANY'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.168 function '=ALL[편집]

 function '=ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.169 function '=ALL[편집]

 function '=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('=ALL', 1450);

1.170 function '=ALL[편집]

 function '=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.171 function '!=ALL[편집]

 function '!=ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.172 function '!=ALL[편집]

 function '!=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('!=ALL', 1450);

1.173 function '!=ALL[편집]

 function '!=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.174 function '<ALL[편집]

 function '<ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.175 function '<ALL[편집]

 function '<ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<ALL', 1450);

1.176 function '<ALL[편집]

 function '<ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.177 function '<=ALL[편집]

 function '<=ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.178 function '<=ALL[편집]

 function '<=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<=ALL', 1450);

1.179 function '<=ALL[편집]

 function '<=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.180 function '>[편집]

 function '>ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                   RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.181 function '>[편집]

 function '>ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>ALL', 1450);

1.182 function '>[편집]

 function '>ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.183 function '>[편집]

 function '>=ALL'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.184 function '>[편집]

 function '>=ALL'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>=ALL', 1450);

1.185 function '>[편집]

 function '>=ALL'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.186 function '=SOME[편집]

 function '=SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.187 function '=SOME[편집]

 function '=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('=SOME', 1450);

1.188 function '=SOME[편집]

 function '=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.189 function '!=SOME[편집]

 function '!=SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                     RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.190 function '!=SOME[편집]

 function '!=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('!=SOME', 1450);

1.191 function '!=SOME[편집]

 function '!=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.192 function '<SOME[편집]

 function '<SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.193 function '<SOME[편집]

 function '<SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<SOME', 1450);

1.194 function '<SOME[편집]

 function '<SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.195 function '<=SOME[편집]

 function '<=SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                     RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.196 function '<=SOME[편집]

 function '<=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('<=SOME', 1450);

1.197 function '<=SOME[편집]

 function '<=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.198 function '>[편집]

 function '>SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.199 function '>[편집]

 function '>SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>SOME', 1450);

1.200 function '>[편집]

 function '>SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

1.201 function '>[편집]

 function '>=SOME'  (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                     RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
         return BOOLEAN;

1.202 function '>[편집]

 function '>=SOME'  (LEFT DATE, RIGHT DATE) return BOOLEAN;
     pragma FIPSFLAG('>=SOME', 1450);

1.203 function '>[편집]

 function '>=SOME'  (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;

 -- SQL Transaction routines
 procedure SET_TRANSACTION_USE(vc VARCHAR2);
 procedure COMMIT;
 procedure COMMIT_CM(vc VARCHAR2);
 procedure ROLLBACK_NR;
 procedure ROLLBACK_SV(Save_Point CHAR);
 procedure SAVEPOINT(Save_Point CHAR);

1.204 function SYSDATE[편집]

 function SYSDATE return DATE;
   pragma FIPSFLAG('SYSDATE', 1452);

1.205 function UID[편집]

 function UID return PLS_INTEGER;
   pragma FIPSFLAG('UID', 1452);

1.206 function USER[편집]

 function USER return VARCHAR2;

1.207 function USERENV[편집]

 function USERENV (envstr VARCHAR2) return VARCHAR2;
   pragma FIPSFLAG('USERENV', 1452);

 -- ROWID: this dreadful identifier is supposed to represent a datatype

1.208 function,[편집]

 -- outside of SQL and and a pseudo-column (function, to us) when inside
 -- a sql statement.  ADA data model doesn't allow for any

1.209 function X[편집]

 -- function X return X;
 -- so we must special case this.  Yuk.  There's special-case code in ph2nre
 -- which maps "rowid" to "rowid " if we're inside a SQL stmt.

1.210 function ROWID[편집]

 function ROWID " return ROWID;
   pragma builtin('ROWID ', 1, 209, 240);  -- this had better never be called.

1.211 function NULLFN[편집]

 function NULLFN (str VARCHAR2) return RAW;
   pragma builtin('NULLFN', 1, 0, 1);

1.212 function HEXTORAW[편집]

 function HEXTORAW (c VARCHAR2) return RAW;
    pragma builtin('HEXTORAW', 1, 23, 1);

1.213 function RAWTOHEX[편집]

 function RAWTOHEX (r RAW) return VARCHAR2;
    pragma builtin('RAWTOHEX', 1, 23, 2);

1.214 function CHARTOROWID[편집]

 function CHARTOROWID (str VARCHAR2) return ROWID;
   pragma builtin('CHARTOROWID', 1, 0, 1);

1.215 function ROWIDTOCHAR[편집]

 function ROWIDTOCHAR (str ROWID) return VARCHAR2;
   pragma builtin('ROWIDTOCHAR', 1, 0, 1);

 -- Trusted*Oracle additions

1.216 Function ROWLABEL[편집]

 Function ROWLABEL return MLSLABEL;                     -- pseudo column

1.217 Function TO_CHAR[편집]

 Function TO_CHAR(label MLSLABEL, format VARCHAR2) return VARCHAR2;
   pragma BUILTIN('TO_CHAR',90, 4, 19); -- PEMS_DATE, MLS_CNV_CHR1
   pragma FIPSFLAG('TO_CHAR', 1450);

1.218 Function TO_LABEL[편집]

 Function TO_LABEL(label VARCHAR2, format VARCHAR2 ) return  MLSLABEL;
   pragma BUILTIN('TO_LABEL',90, 4, 8); -- PEMS_CHAR, CHR_CNV_MLS
   pragma FIPSFLAG('TO_LABEL', 1450);

1.219 Function TO_LABEL[편집]

 Function TO_LABEL(label VARCHAR2 ) return  MLSLABEL;
   pragma BUILTIN('TO_LABEL',90, 4, 2); -- PEMS_CHAR, CHR_CNV_MLS
   pragma FIPSFLAG('TO_LABEL', 1450);

 -- vararg routines - icds in stdbdy

1.220 Function LEAST_UB[편집]

 Function LEAST_UB    (pattern MLSLABEL) return MLSLABEL;
   pragma BUILTIN('LEAST_UB',90, 4, 3); -- PEMS_CHAR, CHR_CNV_MLS

1.221 Function GREATEST_LB[편집]

 Function GREATEST_LB (pattern MLSLABEL) return MLSLABEL;
   pragma BUILTIN('GREATEST_LB',90, 4, 4); -- PEMS_CHAR, CHR_CNV_MLS

1.222 Function '>[편집]

 Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.223 Function '>[편집]

 Function '>'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.224 Function '<='[편집]

 Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.225 Function '<'[편집]

 Function '<'  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.226 Function '='[편집]

 Function '='  (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.227 Function '!='[편집]

 Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;

1.228 function 'IS[편집]

 function 'IS NULL' (label MLSLABEL) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 1, 20); -- same "cod" as IS NULL(varchar2)

1.229 function 'IS[편집]

 function 'IS NOT NULL' (label MLSLABEL) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 1, 50);

1.230 function NVL[편집]

 function NVL(label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL;
   pragma FIPSFLAG('NVL', 1452);

1.231 functions[편집]

 -- group functions

1.232 Function LUB[편집]

 Function LUB (label MLSLABEL) return MLSLABEL;

1.233 Function GLB[편집]

 Function GLB (label MLSLABEL) return MLSLABEL;

 -- end of Trusted*Oracle additions

 -- beginning of NLS routines

1.234 function NLSSORT[편집]

 function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS) return RAW;
   pragma FIPSFLAG('NLSSORT', 1452);

1.235 function NLSSORT[편집]

 function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS, c2 VARCHAR2) return RAW;
   pragma FIPSFLAG('NLSSORT', 1452);

1.236 function NLS_UPPER[편집]

 function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS,
                    parms VARCHAR2 CHARACTER SET ch%CHARSET)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_UPPER', 1452);

1.237 function NLS_UPPER[편집]

 function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_UPPER', 1452);

1.238 function NLS_LOWER[편집]

 function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS,
                    parms VARCHAR2 CHARACTER SET ch%CHARSET)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_LOWER', 1452);

1.239 function NLS_LOWER[편집]

 function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_LOWER', 1452);

1.240 function NLS_INITCAP[편집]

 function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS,
                      parms VARCHAR2 CHARACTER SET ch%CHARSET)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_INITCAP', 1452);

1.241 function NLS_INITCAP[편집]

 function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_INITCAP', 1452);

1.242 function LENGTHB[편집]

 function LENGTHB(ch VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
   pragma FIPSFLAG('LENGTHB', 1452);

1.243 function SUBSTRB[편집]

 function SUBSTRB(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                  POS PLS_INTEGER,
                  LEN PLS_INTEGER := 2147483647)
       return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTRB', 1452);

1.244 function INSTRB[편집]

 function INSTRB(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
                POS PLS_INTEGER := 1,
                NTH POSITIVE := 1) return PLS_INTEGER;
   pragma FIPSFLAG('INSTRB', 1452);

1.245 function TO_SINGLE_BYTE[편집]

 function TO_SINGLE_BYTE(c VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET c%CHARSET;
   pragma FIPSFLAG('TO_SINGLE_BYTE', 1452);

1.246 function TO_MULTI_BYTE[편집]

 function TO_MULTI_BYTE(c VARCHAR2 CHARACTER SET ANY_CS)
       return VARCHAR2 CHARACTER SET c%CHARSET;
   pragma FIPSFLAG('TO_MULTI_BYTE', 1452);

 -- Next two added for NLS 6/3/92 JEM.

1.247 function TO_CHAR[편집]

 function TO_CHAR(left date, format varchar2, parms varchar2) return varchar2;

1.248 function TO_CHAR[편집]

 function TO_CHAR(left number, format varchar2, parms varchar2)
   return varchar2;

1.249 function NLS_CHARSET_NAME[편집]

 function NLS_CHARSET_NAME(csetid PLS_INTEGER) return VARCHAR2;

1.250 function NLS_CHARSET_ID[편집]

 function NLS_CHARSET_ID(csetname VARCHAR2) return PLS_INTEGER;

1.251 function NLS_CHARSET_DECL_LEN[편집]

 function NLS_CHARSET_DECL_LEN(bytecnt NUMBER, csetid NUMBER)
   return PLS_INTEGER;

 -- end of NLS routines

1.252 function CONVERT[편집]

 function CONVERT(src VARCHAR2 character set any_cs,
                  destcset VARCHAR2)
          return VARCHAR2 character set src%charset;

1.253 function CONVERT[편집]

 function CONVERT(src VARCHAR2 character set any_cs,
                  destcset VARCHAR2,
                  srccset VARCHAR2)
         return VARCHAR2 character set src%charset;

1.254 function[편집]

 function  SYS$STANDARD_TRANSLATE" (src VARCHAR2 CHARACTER SET ANY_CS,
                                     csn VARCHAR2 CHARACTER SET ANY_CS)
         return VARCHAR2 CHARACTER SET csn%CHARSET;
    pragma FIPSFLAG(' SYS$STANDARD_TRANSLATE',1452);

1.255 function VSIZE[편집]

 function VSIZE (e number ) return NUMBER;
     pragma builtin('VSIZE', 1, 0, 1);

1.256 function VSIZE[편집]

 function VSIZE (e DATE) return NUMBER;
     pragma builtin('VSIZE', 1, 0, 1);

1.257 function VSIZE[편집]

 function VSIZE (e VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
     pragma builtin('VSIZE', 1, 0, 1);

 -- dump( expr [,display_format[,start_pos[,length]]]) return VARCHAR2

1.258 function DUMP[편집]

 function DUMP(e varchar2 character set any_cs,
               df pls_integer := null,sp pls_integer := null,
               len pls_integer := null) return VARCHAR2;
     pragma builtin('DUMP', 1, 0, 1);

1.259 function DUMP[편집]

 function DUMP(e number,df pls_integer := null,sp pls_integer := null,
                 len pls_integer := null) return VARCHAR2;
     pragma builtin('DUMP', 1, 0, 1);

1.260 function DUMP[편집]

 function DUMP(e date,df pls_integer := null,sp pls_integer := null,
                 len pls_integer := null) return VARCHAR2;
     pragma builtin('DUMP', 1, 0, 1);

 --
 -- ACOS, ASIN, ATAN, ATAN2

1.261 functions[편집]

 --   Inverse Trigonometric functions

1.262 functions[편집]

 --   These functions return NULL if any of the inputs are NULL
 --

1.263 function ACOS[편집]

 function ACOS(N NUMBER) return NUMBER;
   pragma FIPSFLAG('ACOS', 1452);

1.264 function ASIN[편집]

 function ASIN(N NUMBER) return NUMBER;
   pragma FIPSFLAG('ASIN', 1452);

1.265 function ATAN[편집]

 function ATAN(N NUMBER) return NUMBER;
   pragma FIPSFLAG('ATAN', 1452);

1.266 function ATAN2[편집]

 function ATAN2(x NUMBER, y NUMBER) return NUMBER;
 pragma FIPSFLAG('ATAN2', 1452);

 --#### This is the end of 7.3 Standard

 -- LOB IS NULL

1.267 function 'IS[편집]

 function 'IS NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL

1.268 function 'IS[편집]

 function 'IS NOT NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50);

1.269 function 'IS[편집]

 function 'IS NULL' (n BLOB) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL

1.270 function 'IS[편집]

 function 'IS NOT NULL' (n BLOB) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50);

1.271 function 'IS[편집]

 function 'IS NULL' (n BFILE) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL

1.272 function 'IS[편집]

 function 'IS NOT NULL' (n BFILE) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50);
 -- end LOB IS NULL

 --****************************************************************
 -- 20 mar 96 =G=> In the following, arguments "1, 1, 1" to pragma BUILTIN
 -- e.g.,                pragma builtin('whatever', 1, 1, 1)
 -- indicate that those three numeric arguments to pragma BUILTIN are unknown,
 -- because they are not yet implemented by the backend.

1.273 function '='[편집]

 function '='  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('=', 1, 1, 1);
   pragma FIPSFLAG('=', 1450);

1.274 function '!='[편집]

 function '!=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('!=', 1, 1, 1);
   pragma FIPSFLAG('!=', 1450);

1.275 function '<'[편집]

 function '<'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('<', 1, 1, 1);
   pragma FIPSFLAG('<', 1450);

1.276 function '<='[편집]

 function '<=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('<=', 1, 1, 1);
   pragma FIPSFLAG('<=', 1450);

1.277 function '>[편집]

 function '>'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('>', 1, 1, 1);
   pragma FIPSFLAG('>', 1450);

1.278 function '>[편집]

 function '>=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('>=', 1, 1, 1);
   pragma FIPSFLAG('>=', 1450);

1.279 function '=ANY[편집]

 function '=ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.280 function '!=ANY[편집]

 function '!=ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.281 function '<ANY[편집]

 function '<ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.282 function '<=ANY[편집]

 function '<=ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.283 function '>[편집]

 function '>ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.284 function '>[편집]

 function '>=ANY'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.285 function '=ALL[편집]

 function '=ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.286 function '!=ALL[편집]

 function '!=ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.287 function '<ALL[편집]

 function '<ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.288 function '<=ALL[편집]

 function '<=ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.289 function '>[편집]

 function '>ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.290 function '>[편집]

 function '>=ALL'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.291 function '=SOME[편집]

 function '=SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.292 function '!=SOME[편집]

 function '!=SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.293 function '<SOME[편집]

 function '<SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.294 function '<=SOME[편집]

 function '<=SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.295 function '>[편집]

 function '>SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

1.296 function '>[편집]

 function '>=SOME'  (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;

 -- Outer Join

1.297 function '(+[편집]

 function '(+)'  ( colname "<ADT_1>") return "<ADT_1>";
   pragma FIPSFLAG('(+)', 1450);

 --  GREATEST and LEAST are not yet supported for ADTs in 8.0.2.

1.298 function GREATEST[편집]

 --  function GREATEST (pattern "<ADT_1>") return "<ADT_1>";
 --    pragma BUILTIN('GREATEST', 1, 1, 1);

1.299 function LEAST[편집]

 --  function LEAST (pattern "<ADT_1>") return "<ADT_1>";
 --    pragma BUILTIN('LEAST', 1, 1, 1);

1.300 function DECODE[편집]

 function DECODE (expr "<ADT_1>", pat "<ADT_1>", res "<ADT_1>")
       return "<ADT_1>";
   pragma BUILTIN('DECODE', 1, 1, 1);

1.301 function 'IS[편집]

 function 'IS NULL' (B "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.302 function 'IS[편집]

 function 'IS NOT NULL' (B "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.303 function NVL[편집]

 function NVL (B1 "<ADT_1>", B2 "<ADT_1>") return "<ADT_1>";
   pragma FIPSFLAG('NVL', 1450);

1.304 function VALUE[편집]

 function VALUE (item "<ADT_WITH_OID>") return "<ADT_1>";
   pragma BUILTIN('VALUE', 1, 1, 1);
   pragma FIPSFLAG('VALUE', 1450);

1.305 function REF[편집]

 function REF (item "<ADT_WITH_OID>") return REF "<ADT_1>";
   pragma BUILTIN('REF', 1, 1, 1);
   pragma FIPSFLAG('REF', 1450);

1.306 function DEREF[편집]

 function DEREF (r REF "<ADT_1>") return "<ADT_1>";
   pragma BUILTIN('DEREF', 1, 1, 1);
   pragma FIPSFLAG('DEREF', 1450);

 -- overloadings for REF ADT

1.307 function 'IS[편집]

 function 'IS NULL' (B REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.308 function 'IS[편집]

 function 'IS NOT NULL' (B REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.309 function 'IS[편집]

 function 'IS DANGLING' (B REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS DANGLING', 1, 1, 1);
   pragma FIPSFLAG('IS DANGLING', 1450);

1.310 function 'IS[편집]

 function 'IS NOT DANGLING' (B REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT DANGLING', 1, 1, 1);
   pragma FIPSFLAG('IS NOT DANGLING', 1450);

1.311 function NVL[편집]

 function NVL (B1 REF "<ADT_1>", B2 REF "<ADT_1>") return REF "<ADT_1>";
   pragma FIPSFLAG('NVL', 1450);

1.312 function '='[편집]

 function '='  (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('=', 0, 3, 1);
   pragma FIPSFLAG('=', 1450);

1.313 function '!='[편집]

 function '!=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
   pragma BUILTIN('!=', 0, 3, 2);
   pragma FIPSFLAG('!=', 1450);

1.314 function '='[편집]

 --  function '='  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;
 --    pragma BUILTIN('=', 1, 1, 1);
 --    pragma FIPSFLAG('=', 1450);
 --

1.315 function '!='[편집]

 --  function '!=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;
 --    pragma BUILTIN('!=', 1, 1, 1);
 --    pragma FIPSFLAG('!=', 1450);
 --

1.316 function '=ANY[편집]

 --  function '=ANY'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;

1.317 function '!=ANY[편집]

 --  function '!=ANY'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;

1.318 function '=ALL[편집]

 --  function '=ALL'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;

1.319 function '!=ALL[편집]

 --  function '!=ALL'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;

1.320 function '=SOME[편집]

 --  function '=SOME'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;

1.321 function '!=SOME[편집]

 --  function '!=SOME'  (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
 --      return BOOLEAN;
 --

1.322 function DECODE[편집]

 --  function DECODE (expr "<COLLECTION_1>", pat "<COLLECTION_1>",
 --                                        res "<COLLECTION_1>")
 --      return "<COLLECTION_1>";
 --    pragma BUILTIN('DECODE', 1, 1, 1);

1.323 function will[편집]

 -- Note that index-by tables are never NULL: this function will always
 -- return FALSE for them.

1.324 function 'IS[편집]

 function 'IS NULL' (B "<COLLECTION_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.325 function will[편집]

 -- Note that index-by tables are never NULL: this function will always
 -- return TRUE for them.

1.326 function 'IS[편집]

 function 'IS NOT NULL' (B "<COLLECTION_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.327 function will[편집]

 -- Note that index-by tables are never NULL: this function will always
 -- return B1 for them.

1.328 function NVL[편집]

 function NVL (B1 "<COLLECTION_1>", B2 "<COLLECTION_1>")
       return "<COLLECTION_1>";
   pragma FIPSFLAG('NVL', 1450);

1.329 function 'IS[편집]

 function 'IS NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.330 function 'IS[편집]

 function 'IS NOT NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.331 function NVL[편집]

 function NVL (B1 "<REF_CURSOR_1>", B2 "<REF_CURSOR_1>")
       return "<REF_CURSOR_1>";
   pragma FIPSFLAG('NVL', 1450);

1.332 function will[편집]

 -- Note that associative arrays are never NULL: this function will always
 -- return FALSE.

1.333 function 'IS[편집]

 function 'IS NULL' (B "<ASSOC_ARRAY_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.334 function will[편집]

 -- Note that associative arrays are never NULL: this function will always
 -- return TRUE.

1.335 function 'IS[편집]

 function 'IS NOT NULL' (B "<ASSOC_ARRAY_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.336 function will[편집]

 -- Note that associative arrays are never NULL: this function will always
 -- return B1.

1.337 function NVL[편집]

 function NVL (B1 "<ASSOC_ARRAY_1>", B2 "<ASSOC_ARRAY_1>")
       return "<ASSOC_ARRAY_1>";
   pragma FIPSFLAG('NVL', 1450);

1.338 function EMPTY_CLOB[편집]

 function EMPTY_CLOB return clob;

1.339 function EMPTY_BLOB[편집]

 function EMPTY_BLOB return blob;

1.340 function BFILENAME[편집]

 function BFILENAME(directory varchar2,filename varchar2) return BFILE;

1.341 function SYS[편집]

 function SYS$LOB_REPLICATION" (x in blob) return blob;

1.342 function SYS[편집]

 function SYS$LOB_REPLICATION" (x in clob character set any_cs)
   return clob character set x%charset;

 --#### This is the end of 8.0 Standard

 --  + overloadings

1.343 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.344 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.345 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_TZ_UNCONSTRAINED ;

1.346 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_TZ_UNCONSTRAINED ;

1.347 function '+'(LEFT[편집]

 function '+'(LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return TIME_UNCONSTRAINED;

1.348 function '+'(LEFT[편집]

 function '+'(LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return TIME_TZ_UNCONSTRAINED;

1.349 function '+'(LEFT[편집]

 function '+'(LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date ;

1.350 function '+'(LEFT[편집]

 function '+'(LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date ;

1.351 function '+'(LEFT[편집]

 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.352 function '+'(LEFT[편집]

 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
              return TIMESTAMP_TZ_UNCONSTRAINED ;

1.353 function '+'(LEFT[편집]

 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT date) return date ;

1.354 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.355 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
               return TIMESTAMP_TZ_UNCONSTRAINED ;

1.356 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
               return TIME_UNCONSTRAINED ;

1.357 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
               return TIME_TZ_UNCONSTRAINED ;

1.358 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT date) return date ;

1.359 function '+'(LEFT[편집]

 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return DSINTERVAL_UNCONSTRAINED ;

1.360 function '+'(LEFT[편집]

 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
              return YMINTERVAL_UNCONSTRAINED ;

 -- begin subtract

1.361 function[편집]

 function  SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
                                    RIGHT TIMESTAMP_UNCONSTRAINED)
          return DSINTERVAL_UNCONSTRAINED ;

1.362 function[편집]

 function  SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
                                    RIGHT TIMESTAMP_UNCONSTRAINED)
          return YMINTERVAL_UNCONSTRAINED ;

1.363 function '-'(LEFT[편집]

 function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.364 function '-'(LEFT[편집]

 function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
              return TIMESTAMP_UNCONSTRAINED;

1.365 function[편집]

 function  SYS$DSINTERVALSUBTRACT"
  (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED ;

1.366 function[편집]

 function  SYS$YMINTERVALSUBTRACT"
  (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED ;

1.367 function '-'[편집]

 function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED ;

1.368 function '-'[편집]

 function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED ;

1.369 function[편집]

 function  SYS$DSINTERVALSUBTRACT" (LEFT TIME_UNCONSTRAINED,
                                     RIGHT TIME_UNCONSTRAINED)
    return DSINTERVAL_UNCONSTRAINED ;

1.370 function '-'[편집]

 function '-' (LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
   return TIME_UNCONSTRAINED ;

1.371 function[편집]

 function  SYS$DSINTERVALSUBTRACT"
  (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED ;

1.372 function '-'[편집]

 function '-' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
   return TIME_TZ_UNCONSTRAINED ;

1.373 function "[편집]

 function  " SYS$DSINTERVALSUBTRACT" (LEFT date, RIGHT date)
   return DSINTERVAL_UNCONSTRAINED ;

1.374 function[편집]

 function  SYS$YMINTERVALSUBTRACT" (LEFT date, RIGHT date)
   return YMINTERVAL_UNCONSTRAINED ;

1.375 function '-'[편집]

 function '-' (LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date;

1.376 function '-'[편집]

 function '-' (LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date;

1.377 function '-'[편집]

 function '-' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED ;

1.378 function '-'[편집]

 function '-' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
  return DSINTERVAL_UNCONSTRAINED ;

 -- end subtract

 -- other datetime operators

1.379 function '*'[편집]

 function '*' (LEFT number, RIGHT YMINTERVAL_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED ;

1.380 function '*'[편집]

 function '*' (LEFT number, RIGHT DSINTERVAL_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED ;

1.381 function '*'[편집]

 function '*' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
   return YMINTERVAL_UNCONSTRAINED ;

1.382 function '*'[편집]

 function '*' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
   return DSINTERVAL_UNCONSTRAINED ;

1.383 function '/'[편집]

 function '/' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
   return YMINTERVAL_UNCONSTRAINED ;

1.384 function '/'[편집]

 function '/' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
   return DSINTERVAL_UNCONSTRAINED ;

1.385 function current_date[편집]

 function current_date return date;

1.386 function current_time[편집]

 function current_time return TIME_TZ_UNCONSTRAINED;

1.387 function current_timestamp[편집]

 function current_timestamp return TIMESTAMP_TZ_UNCONSTRAINED;

1.388 function TO_TIME[편집]

 function TO_TIME (RIGHT varchar2 character set any_cs) return
   time_unconstrained;
   pragma BUILTIN('TO_TIME', 0, 15, 1);

1.389 function TO_TIMESTAMP[편집]

   function TO_TIMESTAMP (RIGHT varchar2 character set any_cs)
                          return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP', 0, 15, 3);

1.390 function TO_TIME_TZ[편집]

 function TO_TIME_TZ (RIGHT varchar2 character set any_cs)
   return  TIME_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIME_TZ', 0, 15, 5);

1.391 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ (RIGHT varchar2 character set any_cs)
   return  TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 7);

1.392 function TO_YMINTERVAL[편집]

 function TO_YMINTERVAL (RIGHT varchar2 character set any_cs)
   return  YMINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('TO_YMINTERVAL', 0, 15, 9);

1.393 function TO_DSINTERVAL[편집]

 function TO_DSINTERVAL (RIGHT varchar2 character set any_cs)
   return  DSINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('TO_DSINTERVAL', 0, 15, 11);

 -- with nls args

1.394 function TO_TIME[편집]

 function TO_TIME(left varchar2 character set any_cs,
                  format varchar2 character set left%charset,
                  parms varchar2 character set left%charset)
   return TIME_UNCONSTRAINED;

1.395 function TO_TIME[편집]

 function TO_TIME(left varchar2 character set any_cs,
                  format varchar2 character set left%charset)
   return TIME_UNCONSTRAINED;

1.396 function TO_TIMESTAMP[편집]

 function TO_TIMESTAMP(left varchar2 character set any_cs,
                       format varchar2 character set left%charset,
                       parms varchar2 character set left%charset)
   return TIMESTAMP_UNCONSTRAINED;

1.397 function TO_TIMESTAMP[편집]

 function TO_TIMESTAMP(left varchar2 character set any_cs,
                       format varchar2 character set left%charset)
   return TIMESTAMP_UNCONSTRAINED;

1.398 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ(left varchar2 character set any_cs,
                          format varchar2 character set left%charset,
                          parms varchar2 character set left%charset)
   return TIMESTAMP_TZ_UNCONSTRAINED;

1.399 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ(left varchar2 character set any_cs,
                          format varchar2 character set left%charset)
   return TIMESTAMP_TZ_UNCONSTRAINED;

1.400 function TO_TIME_TZ[편집]

 function TO_TIME_TZ(left varchar2 character set any_cs,
                     format varchar2 character set left%charset,
                     parms varchar2 character set left%charset)
   return TIME_TZ_UNCONSTRAINED;

1.401 function TO_TIME_TZ[편집]

 function TO_TIME_TZ(left varchar2 character set any_cs,
                     format varchar2 character set left%charset)
   return TIME_TZ_UNCONSTRAINED;

1.402 function TO_DSINTERVAL[편집]

 function TO_DSINTERVAL(RIGHT varchar2 character set any_cs,
                        parms varchar2 character set RIGHT%charset)
   return DSINTERVAL_UNCONSTRAINED;

1.403 function NUMTOYMINTERVAL[편집]

 function NUMTOYMINTERVAL(numerator number,
                          units varchar2 character set any_cs)
   return YMINTERVAL_UNCONSTRAINED;

1.404 function NUMTODSINTERVAL[편집]

 function NUMTODSINTERVAL(numerator number,
                          units varchar2 character set any_cs)
   return DSINTERVAL_UNCONSTRAINED;

1.405 function '='[편집]

 function '='  (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
   pragma BUILTIN('=',0, 11, 1);
   pragma FIPSFLAG('=', 1450);

1.406 function '!='[편집]

 function '!=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;  -- also <> and ~=
   pragma BUILTIN('!=',0, 11, 2);
   pragma FIPSFLAG('!=', 1450);

1.407 function '<'[편집]

 function '<'  (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
   pragma BUILTIN('<',0, 11, 3);
   pragma FIPSFLAG('<', 1450);

1.408 function '<='[편집]

 function '<=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
   pragma BUILTIN('<=',0, 11, 4);
   pragma FIPSFLAG('<=', 1450);

1.409 function '>[편집]

 function '>'  (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
   pragma BUILTIN('>',0, 11, 5);
   pragma FIPSFLAG('>', 1450);

1.410 function '>[편집]

 function '>=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
   pragma BUILTIN('>=',0, 11, 6);
   pragma FIPSFLAG('>=', 1450);

1.411 function 'IS[편집]

 function 'IS NULL' (u UROWID) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 14, 0); -- PEMS_UROWID, PEMDNUL
   pragma FIPSFLAG('IS NULL', 1450);

1.412 function 'IS[편집]

 function 'IS NOT NULL' (u UROWID) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 14, 50); -- PEMS_UROWID, PEMDNUL
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.413 function UROWID[편집]

 function UROWID " return UROWID;
   pragma builtin('UROWID ', 1, 209, 240);  -- this had better never be called.

1.414 function SYS_GUID[편집]

 -- New built-in function SYS_GUID, returns globally unique id

1.415 function SYS_GUID[편집]

 function SYS_GUID return RAW;

1.416 function SYS_CONTEXT[편집]

 -- New built-in function SYS_CONTEXT

1.417 function SYS_CONTEXT[편집]

 function SYS_CONTEXT (namespace varchar2, attribute varchar2)
   return varchar2;

1.418 function TRIM[편집]

 function TRIM(v VARCHAR2 CHARACTER SET ANY_CS)
   return VARCHAR2 CHARACTER SET v%CHARSET;

 --#### This is the end of 8.1.5 Standard

 -- SYS_CONTEXT now has an additional optional parameter

1.419 function SYS_CONTEXT[편집]

 function SYS_CONTEXT(namespace varchar2, attribute varchar2,
                      newoptional varchar2)
   return varchar2;

1.420 functions[편집]

 -- CUBE and ROLLUP are not real functions; they are variants on the GROUP
 -- BY clause (GROUP BY CUBE (...) and GROUP BY ROLLUP (...)). They have

1.421 functions[편집]

 -- been added here as functions to avoid name capture issues.
 --

1.422 functions[편집]

 -- Note that both CUBE and ROLLUP look like true vararg functions with
 -- *no* repeating pattern of formals - hence they are special cased in
 -- the overloading code.

1.423 function CUBE[편집]

 function CUBE return NUMBER;

1.424 function ROLLUP[편집]

 function ROLLUP return NUMBER;

1.425 function must[편집]

 -- The GROUPING function must be used in conjunction with CUBE and ROLLUP
 -- in the GROUP BY clause. The type of the parameter to GROUPING can be
 -- any type that can appear in a GROUP BY list.

1.426 function GROUPING[편집]

 function GROUPING(v VARCHAR2) return NUMBER;

1.427 function GROUPING[편집]

 function GROUPING(a "<ADT_1>") return NUMBER;

 -- This is for TRIM(x). No trim set.

1.428 function[편집]

 function  SYS$STANDARD_TRIM" (v VARCHAR2 CHARACTER SET ANY_CS)
   return VARCHAR2 CHARACTER SET v%CHARSET;

 -- This is for TRIM(LEADING/TRAILING FROM x). No trim set.

1.429 function[편집]

 function  SYS$STANDARD_TRIM" (STR1 VARCHAR2 CHARACTER SET ANY_CS ,
                                TRFLAG PLS_INTEGER)
   return VARCHAR2 CHARACTER SET STR1%CHARSET;

 -- General TRIM. LEADING, TRAILING and BOTH options as 3rd argument.
 -- This one takes a trim set.

1.430 function[편집]

 function  SYS$STANDARD_TRIM" (STR1   VARCHAR2 CHARACTER SET ANY_CS ,
                                TSET   VARCHAR2 CHARACTER SET STR1%CHARSET,
                                TRFLAG PLS_INTEGER)
   return VARCHAR2 CHARACTER SET STR1%CHARSET;

 --#### This is the end of the supported parts of 8.1.6 Standard

 --## Support for ANSI datetime data types is under development.
 --## The following operations, as well as the related types and
 --## operations defined above in the 8.1.5 section, are not yet
 --## available for use and are still subject to change.

 --- datetime equivalence

1.431 function '='[편집]

 function '='  (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.432 function '!='[편집]

 function '!=' (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.433 function '<'[편집]

 function '<'  (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.434 function '<='[편집]

 function '<=' (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.435 function '>[편집]

 function '>'  (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.436 function '>[편집]

 function '>=' (LEFT TIME_UNCONSTRAINED,
                RIGHT TIME_UNCONSTRAINED) return BOOLEAN;

1.437 function '='[편집]

 function '='  (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.438 function '!='[편집]

 function '!=' (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.439 function '<'[편집]

 function '<'  (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.440 function '<='[편집]

 function '<=' (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.441 function '>[편집]

 function '>'  (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.442 function '>[편집]

 function '>=' (LEFT TIMESTAMP_UNCONSTRAINED,
                RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.443 function '='[편집]

 function '='  (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.444 function '!='[편집]

 function '!=' (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.445 function '<'[편집]

 function '<'  (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.446 function '<='[편집]

 function '<=' (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.447 function '>[편집]

 function '>'  (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.448 function '>[편집]

 function '>=' (LEFT TIME_TZ_UNCONSTRAINED,
                RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.449 function '='[편집]

 function '='  (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.450 function '!='[편집]

 function '!=' (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.451 function '<'[편집]

 function '<'  (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.452 function '<='[편집]

 function '<=' (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.453 function '>[편집]

 function '>'  (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.454 function '>[편집]

 function '>=' (LEFT YMINTERVAL_UNCONSTRAINED,
                RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.455 function '='[편집]

 function '='  (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.456 function '!='[편집]

 function '!=' (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.457 function '<'[편집]

 function '<'  (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.458 function '<='[편집]

 function '<=' (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.459 function '>[편집]

 function '>'  (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.460 function '>[편집]

 function '>=' (LEFT DSINTERVAL_UNCONSTRAINED,
                RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.461 function TO_TIME[편집]

 function TO_TIME (RIGHT TIME_TZ_UNCONSTRAINED)  return TIME_UNCONSTRAINED;
   pragma BUILTIN('TO_TIME', 0, 15, 13);

1.462 function TO_TIME_TZ[편집]

 function TO_TIME_TZ (RIGHT TIME_UNCONSTRAINED)  return TIME_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIME_TZ', 0, 15, 14);

1.463 function TO_TIMESTAMP[편집]

 function TO_TIMESTAMP (RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
   return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP', 0, 15, 15);

1.464 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ (RIGHT TIMESTAMP_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 16);

1.465 function '-'[편집]

 function '-'
     (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;

1.466 function '-'[편집]

 function '-'
     (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;

1.467 function '-'[편집]

 function '-'
     (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;

1.468 function '-'[편집]

 function '-'
     (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;

1.469 functions[편집]

 -- timezone functions

1.470 function SYS_AT_TIME_ZONE[편집]

 function SYS_AT_TIME_ZONE(t time_tz_unconstrained,
                           i varchar2) RETURN time_tz_unconstrained;

1.471 function SYS_AT_TIME_ZONE[편집]

 function SYS_AT_TIME_ZONE(t timestamp_tz_unconstrained,
                           i varchar2) RETURN timestamp_tz_unconstrained;

1.472 FUNCTION systimestamp[편집]

 FUNCTION systimestamp RETURN timestamp_tz_unconstrained;

1.473 FUNCTION dbtimezone[편집]

 FUNCTION dbtimezone RETURN varchar2;

1.474 FUNCTION sessiontimezone[편집]

 FUNCTION sessiontimezone RETURN varchar2;

1.475 FUNCTION localtimestamp[편집]

 FUNCTION localtimestamp RETURN timestamp_unconstrained;

1.476 FUNCTION localtime[편집]

 FUNCTION localtime RETURN time_unconstrained;

1.477 function TO_TIMESTAMP[편집]

 function TO_TIMESTAMP (RIGHT DATE)  return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP', 0, 15, 17);

1.478 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
              RIGHT yminterval_unconstrained)
   return TIMESTAMP_LTZ_UNCONSTRAINED;

1.479 function '+'(LEFT[편집]

 function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
              RIGHT dsinterval_unconstrained)
   return TIMESTAMP_LTZ_UNCONSTRAINED;

1.480 function '+'(LEFT[편집]

 function '+'(LEFT yminterval_unconstrained,
              RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_LTZ_UNCONSTRAINED ;

1.481 function '+'(LEFT[편집]

 function '+'(LEFT dsinterval_unconstrained,
              RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_LTZ_UNCONSTRAINED ;

1.482 function '-'(LEFT[편집]

 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
              RIGHT yminterval_unconstrained)
   return TIMESTAMP_LTZ_UNCONSTRAINED ;

1.483 function '-'(LEFT[편집]

 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
              RIGHT dsinterval_unconstrained)
   return TIMESTAMP_LTZ_UNCONSTRAINED ;

1.484 function[편집]

 function  SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                                    RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
   return dsinterval_unconstrained;

1.485 function[편집]

 function  SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                                    RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
   return yminterval_unconstrained;

1.486 function '-'(LEFT[편집]

 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
              RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
   return dsinterval_unconstrained;

1.487 function '='[편집]

 function '='  (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.488 function '!='[편집]

 function '!=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.489 function '<'[편집]

 function '<'  (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.490 function '<='[편집]

 function '<=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.491 function '>[편집]

 function '>'  (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.492 function '>[편집]

 function '>=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.493 function '='[편집]

 function '='  (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.494 function '!='[편집]

 function '!=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.495 function '<'[편집]

 function '<'  (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.496 function '<='[편집]

 function '<=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.497 function '>[편집]

 function '>'  (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.498 function '>[편집]

 function '>=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
                RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.499 function SYS_LITERALTOYMINTERVAL[편집]

 function SYS_LITERALTOYMINTERVAL(numerator varchar2, units varchar2)
   return YMINTERVAL_UNCONSTRAINED;

1.500 function SYS_LITERALTODSINTERVAL[편집]

 function SYS_LITERALTODSINTERVAL(numerator varchar2, units varchar2)
   return DSINTERVAL_UNCONSTRAINED;

1.501 function SYS_LITERALTOTIME[편집]

 function SYS_LITERALTOTIME(numerator varchar2)
   return TIME_UNCONSTRAINED;

1.502 function SYS_LITERALTOTZTIME[편집]

 function SYS_LITERALTOTZTIME(numerator varchar2)
   return TIME_TZ_UNCONSTRAINED;

1.503 function SYS_LITERALTOTIMESTAMP[편집]

 function SYS_LITERALTOTIMESTAMP(numerator varchar2)
   return TIMESTAMP_UNCONSTRAINED;

1.504 function SYS_LITERALTOTZTIMESTAMP[편집]

 function SYS_LITERALTOTZTIMESTAMP(numerator varchar2)
   return TIMESTAMP_TZ_UNCONSTRAINED;

1.505 function SYS_LITERALTODATE[편집]

 function SYS_LITERALTODATE(numerator varchar2) return DATE;

 -- Explicit conversions between date and datetime

1.506 function TO_TIMESTAMP[편집]

 function TO_TIMESTAMP(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP', 0, 15, 24);

1.507 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ(ARG DATE) return TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 27);

1.508 function TO_TIMESTAMP_TZ[편집]

 function TO_TIMESTAMP_TZ(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 26);

 -- IS [NOT] NULL / NVL for datetime

1.509 function 'IS[편집]

 function 'IS NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;

1.510 function 'IS[편집]

 function 'IS NOT NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;

1.511 function NVL[편집]

 function NVL (b1 TIME_UNCONSTRAINED,
               b2 TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;

1.512 function 'IS[편집]

 function 'IS NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.513 function 'IS[편집]

 function 'IS NOT NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;

1.514 function NVL[편집]

 function NVL (b1 TIME_TZ_UNCONSTRAINED, b2 TIME_TZ_UNCONSTRAINED)
   return TIME_TZ_UNCONSTRAINED;

1.515 function 'IS[편집]

 function 'IS NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.516 function 'IS[편집]

 function 'IS NOT NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;

1.517 function NVL[편집]

 function NVL (b1 TIMESTAMP_UNCONSTRAINED,
               b2 TIMESTAMP_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;

1.518 function 'IS[편집]

 function 'IS NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.519 function 'IS[편집]

 function 'IS NOT NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;

1.520 function NVL[편집]

 function NVL (b1 TIMESTAMP_TZ_UNCONSTRAINED, b2 TIMESTAMP_TZ_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED;

1.521 function 'IS[편집]

 function 'IS NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.522 function 'IS[편집]

 function 'IS NOT NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;

1.523 function NVL[편집]

 function NVL (b1 TIMESTAMP_LTZ_UNCONSTRAINED,
               b2 TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_LTZ_UNCONSTRAINED;

1.524 function 'IS[편집]

 function 'IS NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.525 function 'IS[편집]

 function 'IS NOT NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.526 function NVL[편집]

 function NVL (b1 YMINTERVAL_UNCONSTRAINED, b2 YMINTERVAL_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED;

1.527 function 'IS[편집]

 function 'IS NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.528 function 'IS[편집]

 function 'IS NOT NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;

1.529 function NVL[편집]

 function NVL (b1 DSINTERVAL_UNCONSTRAINED, b2 DSINTERVAL_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;

1.530 function[편집]

 function  SYS$EXTRACT_FROM"
             (T TIME_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;

1.531 function[편집]

 function  SYS$EXTRACT_FROM"
             (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;

1.532 function[편집]

 function  SYS$EXTRACT_FROM"
             (T TIMESTAMP_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;

1.533 function[편집]

 function  SYS$EXTRACT_FROM"
             (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;

1.534 function[편집]

 function  SYS$EXTRACT_FROM"
             (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;

1.535 function[편집]

 function  SYS$EXTRACT_FROM"
             (T DATE,FIELD VARCHAR2) return NUMBER;

1.536 function[편집]

 function  SYS$EXTRACT_FROM"
             (I YMINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;

1.537 function[편집]

 function  SYS$EXTRACT_FROM"
             (I DSINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;

1.538 Functions[편집]

 -- ##########      8.2 LOB Built-in Functions       ######## --

 -- LENGTH --

1.539 function LENGTH[편집]

 function LENGTH(ch CLOB CHARACTER SET ANY_CS) return integer;
   pragma FIPSFLAG('LENGTH', 1452);

1.540 function LENGTHB[편집]

 function LENGTHB(ch CLOB CHARACTER SET ANY_CS) return integer;
   pragma FIPSFLAG('LENGTHB', 1452);

1.541 function LENGTH[편집]

 function LENGTH(bl BLOB) return integer;
   pragma FIPSFLAG('LENGTH', 1452);

1.542 function LENGTHB[편집]

 function LENGTHB(bl BLOB) return integer;
   pragma FIPSFLAG('LENGTHB', 1452);

 -- SUBSTR --

1.543 function SUBSTR[편집]

 function SUBSTR(STR1 CLOB CHARACTER SET ANY_CS,
                 POS INTEGER,
                 LEN INTEGER := 18446744073709551615)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTR', 1452);

1.544 function SUBSTRB[편집]

 function SUBSTRB(STR1 CLOB CHARACTER SET ANY_CS,
                 POS INTEGER,
                 LEN INTEGER := 18446744073709551615)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTRB', 1452);

 -- INSTR --

1.545 function INSTR[편집]

 function INSTR(STR1 CLOB CHARACTER SET ANY_CS,
                STR2 CLOB CHARACTER SET STR1%CHARSET,
                POS INTEGER := 1,
                NTH INTEGER := 1) return INTEGER;
   pragma FIPSFLAG('INSTR', 1452);

1.546 function INSTRB[편집]

 function INSTRB(STR1 CLOB CHARACTER SET ANY_CS,
                 STR2 CLOB CHARACTER SET STR1%CHARSET,
                 POS INTEGER := 1,
                 NTH INTEGER := 1) return INTEGER;
   pragma FIPSFLAG('INSTRB', 1452);

 -- CONCAT --

1.547 function '||'[편집]

 function '||' (LEFT CLOB CHARACTER SET ANY_CS,
                RIGHT CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET LEFT%CHARSET;
   pragma FIPSFLAG('||', 1454);

1.548 function CONCAT[편집]

 function CONCAT(LEFT CLOB CHARACTER SET ANY_CS,
                 RIGHT CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET LEFT%CHARSET;
   pragma FIPSFLAG(CONCAT, 1454);

 -- UPPER --

1.549 function UPPER[편집]

 function UPPER(ch CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('UPPER', 1452);

 -- LOWER --

1.550 function LOWER[편집]

 function LOWER(ch CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('LOWER', 1452);

 -- LPAD --

1.551 function LPAD[편집]

 function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
               LEN integer,
               PAD CLOB CHARACTER SET STR1%CHARSET)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LPAD', 1452);

1.552 function LPAD[편집]

 function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
               LEN integer)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LPAD', 1452);

 -- RPAD --

1.553 function RPAD[편집]

 function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
               LEN integer,
               PAD CLOB CHARACTER SET STR1%CHARSET)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RPAD', 1452);

1.554 function RPAD[편집]

 function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
               LEN integer)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RPAD', 1452);

 -- LTRIM --

1.555 function LTRIM[편집]

 function LTRIM(STR1 CLOB CHARACTER SET ANY_CS,
                TSET CLOB CHARACTER SET STR1%CHARSET)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LTRIM', 1452);

1.556 function LTRIM[편집]

 function LTRIM(STR1 CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('LTRIM', 1452);

 -- RTRIM --

1.557 function RTRIM[편집]

 function RTRIM(STR1 CLOB CHARACTER SET ANY_CS,
                TSET CLOB CHARACTER SET STR1%CHARSET)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RTRIM', 1452);

1.558 function RTRIM[편집]

 function RTRIM(STR1 CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('RTRIM', 1452);

 -- TRIM --

1.559 function TRIM[편집]

 function TRIM(v CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET v%CHARSET;

 -- This is for TRIM(x). No trim set.

1.560 function[편집]

 function  SYS$STANDARD_TRIM" (v CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET v%CHARSET;

 -- This is for TRIM(LEADING/TRAILING FROM x). No trim set.

1.561 function[편집]

 function  SYS$STANDARD_TRIM" (STR1 CLOB CHARACTER SET ANY_CS ,
                              TRFLAG PLS_INTEGER)
   return CLOB CHARACTER SET STR1%CHARSET;

 -- General TRIM. LEADING, TRAILING and BOTH options as 3rd argument.
 -- This one takes a trim set.

1.562 function[편집]

 function  SYS$STANDARD_TRIM" (STR1   CLOB CHARACTER SET ANY_CS ,
                                TSET   CLOB CHARACTER SET STR1%CHARSET,
                                TRFLAG PLS_INTEGER)
   return CLOB CHARACTER SET STR1%CHARSET;

 -- LIKE --

1.563 function 'LIKE[편집]

 function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
                  pat CLOB CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.564 function 'NOT_LIKE[편집]

 function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS,
                      pat CLOB CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.565 function 'LIKE[편집]

 function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
                  pat CLOB CHARACTER SET str%CHARSET,
                  esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.566 function 'NOT_LIKE[편집]

 function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS,
                      pat CLOB CHARACTER SET str%CHARSET,
                      esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

 -- NVL --

1.567 function NVL[편집]

 function NVL(s1 CLOB CHARACTER SET ANY_CS,
              s2 CLOB CHARACTER SET s1%CHARSET)
   return CLOB CHARACTER SET s1%CHARSET;
   pragma FIPSFLAG('NVL', 1452);

 -- REPLACE --

1.568 function REPLACE[편집]

 function REPLACE(SRCSTR CLOB CHARACTER SET ANY_CS,
                  OLDSUB CLOB CHARACTER SET SRCSTR%CHARSET,
                  NEWSUB CLOB CHARACTER SET SRCSTR%CHARSET := NULL)
   return CLOB CHARACTER SET SRCSTR%CHARSET;
   pragma FIPSFLAG('REPLACE', 1452);

 -- LOB RELATIONAL OPERATORS --

1.569 Function '='[편집]

 Function '='  (LEFT  CLOB CHARACTER SET ANY_CS,

RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.570 Function '!='[편집]

 Function '!=' (LEFT  CLOB CHARACTER SET ANY_CS,

RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.571 Function '>[편집]

 Function '>'  (LEFT  CLOB CHARACTER SET ANY_CS,
                RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.572 Function '<'[편집]

 Function '<'  (LEFT  CLOB CHARACTER SET ANY_CS,

RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.573 Function '>[편집]

 Function '>=' (LEFT  CLOB CHARACTER SET ANY_CS,
                RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.574 Function '<='[편집]

 Function '<=' (LEFT  CLOB CHARACTER SET ANY_CS,
                RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;

1.575 Function '='[편집]

 Function '='  (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.576 Function '!='[편집]

 Function '!=' (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.577 Function '>[편집]

 Function '>'  (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.578 Function '<'[편집]

 Function '<'  (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.579 Function '>[편집]

 Function '>=' (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.580 Function '<='[편집]

 Function '<=' (LEFT  CLOB     CHARACTER SET ANY_CS,
                RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;

1.581 Function '='[편집]

 Function '='  (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.582 Function '!='[편집]

 Function '!=' (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.583 Function '>[편집]

 Function '>'  (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.584 Function '<'[편집]

 Function '<'  (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.585 Function '>[편집]

 Function '>=' (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.586 Function '<='[편집]

 Function '<=' (LEFT  VARCHAR2 CHARACTER SET ANY_CS,
                RIGHT CLOB     CHARACTER SET ANY_CS) return BOOLEAN;

1.587 functions[편집]

 /* LOB-related conversion functions */

1.588 function TO_CLOB[편집]

 function TO_CLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS) return CLOB;
   pragma BUILTIN('TO_CLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB

1.589 function TO_BLOB[편집]

 function TO_BLOB(RIGHT RAW) return BLOB;
   pragma BUILTIN('TO_BLOB', 0, 15, 30); -- OPC_CVT_RAW2BLB

1.590 function TO_RAW[편집]

 function TO_RAW(RIGHT BLOB) return RAW;
   pragma BUILTIN('TO_RAW', 0, 15, 32); -- OPC_CVT_BLB2RAW

1.591 Functions[편집]

 -- ####### end of 8.2 LOB Built-in Functions  ######## --

1.592 function NULLIF[편집]

 function NULLIF(v1 VARCHAR2, v2 VARCHAR2) return VARCHAR2;

1.593 function NULLIF[편집]

 function NULLIF(v1 BOOLEAN, v2 BOOLEAN) return BOOLEAN;

1.594 function NULLIF[편집]

 function NULLIF(a1 "<ADT_1>", a2 "<ADT_1>") return "<ADT_1>";

1.595 function COALESCE[편집]

 function COALESCE return VARCHAR2;

1.596 Functions[편집]

 /* Daylight Saving Time Functions */

1.597 FUNCTION tz_offset[편집]

 FUNCTION tz_offset(region VARCHAR2)  RETURN VARCHAR2;

1.598 FUNCTION from_tz[편집]

 FUNCTION from_tz(t TIMESTAMP_UNCONSTRAINED,timezone VARCHAR2)
   RETURN timestamp_tz_unconstrained;

1.599 function[편집]

 function  SYS$EXTRACT_STRING_FROM"
             (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;

1.600 function[편집]

 function  SYS$EXTRACT_STRING_FROM"
             (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return VARCHAR2;

1.601 function[편집]

 function  SYS$EXTRACT_STRING_FROM"
             (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;

1.602 function INSTR2[편집]

 function INSTR2(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
                 POS PLS_INTEGER := 1,
                 NTH POSITIVE := 1) return PLS_INTEGER;
   pragma FIPSFLAG('INSTR2', 1452);

1.603 function INSTR4[편집]

 function INSTR4(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
                 POS PLS_INTEGER := 1,
                 NTH POSITIVE := 1) return PLS_INTEGER;
   pragma FIPSFLAG('INSTR4', 1452);

1.604 function INSTRC[편집]

 function INSTRC(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
                 POS PLS_INTEGER := 1,
                 NTH POSITIVE := 1) return PLS_INTEGER;
   pragma FIPSFLAG('INSTRC', 1452);

1.605 function LENGTH2[편집]

 function LENGTH2(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
   pragma FIPSFLAG('LENGTH2', 1452);

1.606 function LENGTH4[편집]

 function LENGTH4(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
   pragma FIPSFLAG('LENGTH4', 1452);

1.607 function LENGTHC[편집]

 function LENGTHC(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
   pragma FIPSFLAG('LENGTHC', 1452);

1.608 function 'LIKE2[편집]

 function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.609 function 'NOT_LIKE2[편집]

 function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.610 function 'LIKE2[편집]

 function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET,
                   esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.611 function 'NOT_LIKE2[편집]

 function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET,
                       esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.612 function 'LIKE4[편집]

 function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.613 function 'NOT_LIKE4[편집]

 function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.614 function 'LIKE4[편집]

 function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET,
                   esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.615 function 'NOT_LIKE4[편집]

 function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET,
                       esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.616 function 'LIKEC[편집]

 function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.617 function 'NOT_LIKEC[편집]

 function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.618 function 'LIKEC[편집]

 function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
                   pat VARCHAR2 CHARACTER SET str%CHARSET,
                   esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.619 function 'NOT_LIKEC[편집]

 function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
                       pat VARCHAR2 CHARACTER SET str%CHARSET,
                       esc VARCHAR2 CHARACTER SET str%CHARSET)
   return BOOLEAN;

1.620 function SUBSTR2[편집]

 function SUBSTR2(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                  POS PLS_INTEGER,
                  LEN PLS_INTEGER := 2147483647)
   return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTR2', 1452);

1.621 function SUBSTR4[편집]

 function SUBSTR4(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                  POS PLS_INTEGER,
                  LEN PLS_INTEGER := 2147483647)
   return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTR4', 1452);

1.622 function SUBSTRC[편집]

 function SUBSTRC(STR1 VARCHAR2 CHARACTER SET ANY_CS,
                  POS PLS_INTEGER,
                  LEN PLS_INTEGER := 2147483647)
   return VARCHAR2 CHARACTER SET STR1%CHARSET;
   pragma FIPSFLAG('SUBSTRC', 1452);

1.623 functions[편집]

 /**** char <--> nchar conversion functions in Unicode project ********/

1.624 function TO_NCHAR[편집]

 function TO_NCHAR(RIGHT NVARCHAR2) return NVARCHAR2;
   pragma BUILTIN('TO_NCHAR',14, 0, 2);

1.625 function TO_NCLOB[편집]

 function TO_NCLOB(cl CLOB CHARACTER SET ANY_CS) return NCLOB;

1.626 function TO_CLOB[편집]

 function TO_CLOB(cl CLOB CHARACTER SET ANY_CS) return CLOB;

1.627 function TO_NCLOB[편집]

 function TO_NCLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS)
   return NCLOB;
   pragma BUILTIN('TO_NCLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
 /* convert to either CLOB or NCLOB respectively if parm is char or nchar */

1.628 function TO_ANYLOB[편집]

 function TO_ANYLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET RIGHT%CHARSET;
   pragma BUILTIN('TO_ANYLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB

1.629 functions[편집]

 /* Followings are the same builtin op codes as without N prefix functions,
  * implementation relys on impilcit conversion MCODEs
  */

1.630 function TO_NCHAR[편집]

 function TO_NCHAR (LEFT DATE, FORMAT NVARCHAR2) return NVARCHAR2;
   pragma BUILTIN('TO_NCHAR',41, 12, 19); -- PEMS_DATE, DAT_CNV_CHR1
   pragma FIPSFLAG('TO_NCHAR', 1450);

1.631 function TO_NCHAR[편집]

 function TO_NCHAR (LEFT NUMBER, FORMAT NVARCHAR2) return NVARCHAR2;
   pragma BUILTIN('TO_NCHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR

1.632 function NHEXTORAW[편집]

 function NHEXTORAW (c NVARCHAR2) return RAW;
   pragma builtin('NHEXTORAW', 1, 23, 1);

1.633 function RAWTONHEX[편집]

 function RAWTONHEX (r RAW) return NVARCHAR2;
   pragma builtin('RAWTONHEX', 1, 23, 2);

1.634 function NCHARTOROWID[편집]

 function NCHARTOROWID (str NVARCHAR2) return ROWID;
   pragma builtin('NCHARTOROWID', 1, 0, 1);

1.635 function ROWIDTONCHAR[편집]

 function ROWIDTONCHAR (str ROWID) return NVARCHAR2;
   pragma builtin('ROWIDTONCHAR', 1, 0, 1);

1.636 function NCHR[편집]

 function NCHR(n integer) return NVARCHAR2;

 /* implemented by icd calls as the same as TO_CHAR */

1.637 function TO_NCHAR[편집]

 function TO_NCHAR(left date, format nvarchar2, parms nvarchar2)
   return nvarchar2;

1.638 function TO_NCHAR[편집]

 function TO_NCHAR(left number, format nvarchar2, parms nvarchar2)
   return nvarchar2;

 /* implemented as a icd call, return TRUE if nchar, otherwise FALSE */

1.639 function ISNCHAR[편집]

 function ISNCHAR(c VARCHAR2 character set any_cs) return boolean;

1.640 functions[편집]

 /************ end of char <--> nchar conversion functions ************/

1.641 functions[편집]

 /* Create overloads for all standard functions that work with <ADT_1> for
    <OPAQUE_1> */

1.642 function '='[편집]

 function '='  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('=', 1, 1, 1);
   pragma FIPSFLAG('=', 1450);

1.643 function '!='[편집]

 function '!=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('!=', 1, 1, 1);
   pragma FIPSFLAG('!=', 1450);

1.644 function '<'[편집]

 function '<'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('<', 1, 1, 1);
   pragma FIPSFLAG('<', 1450);

1.645 function '<='[편집]

 function '<=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('<=', 1, 1, 1);
   pragma FIPSFLAG('<=', 1450);

1.646 function '>[편집]

 function '>'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('>', 1, 1, 1);
   pragma FIPSFLAG('>', 1450);

1.647 function '>[편집]

 function '>=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('>=', 1, 1, 1);
   pragma FIPSFLAG('>=', 1450);

1.648 function '=ANY[편집]

 function '=ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.649 function '!=ANY[편집]

 function '!=ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.650 function '<ANY[편집]

 function '<ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.651 function '<=ANY[편집]

 function '<=ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.652 function '>[편집]

 function '>ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.653 function '>[편집]

 function '>=ANY'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.654 function '=ALL[편집]

 function '=ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.655 function '!=ALL[편집]

 function '!=ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.656 function '<ALL[편집]

 function '<ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.657 function '<=ALL[편집]

 function '<=ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.658 function '>[편집]

 function '>ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.659 function '>[편집]

 function '>=ALL'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.660 function '=SOME[편집]

 function '=SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.661 function '!=SOME[편집]

 function '!=SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.662 function '<SOME[편집]

 function '<SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.663 function '<=SOME[편집]

 function '<=SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.664 function '>[편집]

 function '>SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

1.665 function '>[편집]

 function '>=SOME'  (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;

 -- Outer Join

1.666 function '(+[편집]

 function '(+)'  ( colname "<OPAQUE_1>") return "<OPAQUE_1>";
   pragma FIPSFLAG('(+)', 1450);

 --  GREATEST and LEAST are not yet supported for ADTs in 8.0.2.

1.667 function GREATEST[편집]

 --  function GREATEST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
 --    pragma BUILTIN('GREATEST', 1, 1, 1);

1.668 function LEAST[편집]

 --  function LEAST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
 --    pragma BUILTIN('LEAST', 1, 1, 1);

1.669 function DECODE[편집]

 function DECODE (expr "<OPAQUE_1>", pat "<OPAQUE_1>", res "<OPAQUE_1>")
   return "<OPAQUE_1>";
   pragma BUILTIN('DECODE', 1, 1, 1);

1.670 function 'IS[편집]

 function 'IS NULL' (B "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 3, 0);
   pragma FIPSFLAG('IS NULL', 1450);

1.671 function 'IS[편집]

 function 'IS NOT NULL' (B "<OPAQUE_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 3, 50);
   pragma FIPSFLAG('IS NOT NULL', 1450);

1.672 function NVL[편집]

 function NVL (B1 "<OPAQUE_1>", B2 "<OPAQUE_1>") return "<OPAQUE_1>";
   pragma FIPSFLAG('NVL', 1450);

 --  REFs to opaques are not supported yet.

1.673 function VALUE[편집]

 --  function VALUE (item "<ADT_WITH_OID>") return "<OPAQUE_1>";
 --    pragma BUILTIN('VALUE', 1, 1, 1);
 --    pragma FIPSFLAG('VALUE', 1450);

1.674 function REF[편집]

 --  function REF (item "<ADT_WITH_OID>") return REF "<OPAQUE_1>";
 --    pragma BUILTIN('REF', 1, 1, 1);
 --    pragma FIPSFLAG('REF', 1450);

1.675 function DEREF[편집]

 --  function DEREF (r REF "<OPAQUE_1>") return "<OPAQUE_1>";
 --    pragma BUILTIN('DEREF', 1, 1, 1);
 --    pragma FIPSFLAG('DEREF', 1450);

 -- overloadings for REF OPAQUE

1.676 function 'IS[편집]

 --  function 'IS NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
 --    pragma BUILTIN('IS NULL', 0, 3, 0);
 --    pragma FIPSFLAG('IS NULL', 1450);

1.677 function 'IS[편집]

 --  function 'IS NOT NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
 --    pragma FIPSFLAG('IS NOT NULL', 1450);

1.678 function 'IS[편집]

 --  function 'IS DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN;
 --    pragma BUILTIN('IS DANGLING', 1, 1, 1);
 --    pragma FIPSFLAG('IS DANGLING', 1450);

1.679 function 'IS[편집]

 --  function 'IS NOT DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN;
 --    pragma BUILTIN('IS NOT DANGLING', 1, 1, 1);
 --    pragma FIPSFLAG('IS NOT DANGLING', 1450);

1.680 function NVL[편집]

 --  function NVL (B1 REF "<OPAQUE_1>", B2 REF "<OPAQUE_1>")
 --    return REF "<OPAQUE_1>";
 --    pragma FIPSFLAG('NVL', 1450);

1.681 function '='[편집]

 --  function '='  (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
 --    return BOOLEAN;
 --    pragma BUILTIN('=', 0, 3, 1);
 --    pragma FIPSFLAG('=', 1450);

1.682 function '!='[편집]

 --  function '!=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
 --    return BOOLEAN;
 --    pragma BUILTIN('!=', 0, 3, 2);
 --    pragma FIPSFLAG('!=', 1450);

1.683 function GROUPING[편집]

 function GROUPING(a "<OPAQUE_1>") return NUMBER;

1.684 function NULLIF[편집]

 function NULLIF(a1 "<OPAQUE_1>", a2 "<OPAQUE_1>") RETURN "<OPAQUE_1>";

1.685 function GREATEST[편집]

 function GREATEST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.686 function GREATEST[편집]

 function GREATEST (pattern TIME_TZ_UNCONSTRAINED)
   return TIME_TZ_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.687 function GREATEST[편집]

 function GREATEST (pattern TIMESTAMP_UNCONSTRAINED)
   return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.688 function GREATEST[편집]

 function GREATEST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.689 function GREATEST[편집]

 function GREATEST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_LTZ_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.690 function GREATEST[편집]

 function GREATEST (pattern YMINTERVAL_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.691 function GREATEST[편집]

 function GREATEST (pattern DSINTERVAL_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj

1.692 function LEAST[편집]

 function LEAST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.693 function LEAST[편집]

 function LEAST (pattern TIME_TZ_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.694 function LEAST[편집]

 function LEAST (pattern TIMESTAMP_UNCONSTRAINED)
   return TIMESTAMP_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.695 function LEAST[편집]

 function LEAST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
   return TIMESTAMP_TZ_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.696 function LEAST[편집]

 function LEAST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
   return TIMESTAMP_LTZ_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.697 function LEAST[편집]

 function LEAST (pattern YMINTERVAL_UNCONSTRAINED)
   return YMINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.698 function LEAST[편집]

 function LEAST (pattern DSINTERVAL_UNCONSTRAINED)
   return DSINTERVAL_UNCONSTRAINED;
   pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj

1.699 function TO_CHAR[편집]

 function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.700 function TO_CHAR[편집]

 function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2) return VARCHAR2;

1.701 function TO_CHAR[편집]

 function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.702 function TO_CHAR[편집]

 function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

1.703 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.704 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

1.705 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.706 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

1.707 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.708 function TO_CHAR[편집]

 function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

1.709 function TO_CHAR[편집]

 function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.710 function TO_CHAR[편집]

 function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

1.711 function TO_CHAR[편집]

 function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2,
                  parms VARCHAR2) return VARCHAR2;

1.712 function TO_CHAR[편집]

 function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2)
   return VARCHAR2;

 -- CONVERT FOR LOB --

1.713 function CONVERT[편집]

 function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS,
                  DSTCSN VARCHAR2)
   return CLOB CHARACTER SET SRCSTR%CHARSET;

1.714 function CONVERT[편집]

 function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS,
                  DSTCSN VARCHAR2,
                  SRCCSN VARCHAR2)
   return CLOB CHARACTER SET SRCSTR%CHARSET;

 -- NLS_UPPER/NLS_LOWER FOR LOB --

1.715 function NLS_UPPER[편집]

 function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS,
                    parms VARCHAR2 CHARACTER SET ch%CHARSET)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_UPPER', 1452);

1.716 function NLS_UPPER[편집]

 function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_UPPER', 1452);

1.717 function NLS_LOWER[편집]

 function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS,
                    parms VARCHAR2 CHARACTER SET ch%CHARSET)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_LOWER', 1452);

1.718 function NLS_LOWER[편집]

 function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS)
   return CLOB CHARACTER SET ch%CHARSET;
   pragma FIPSFLAG('NLS_LOWER', 1452);

1.719 function COMPOSE[편집]

 function COMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS)
   return varchar2 character set ch%charset;
   pragma FIPSFLAG('COMPOSE', 1452);

1.720 function DECOMPOSE[편집]

 function DECOMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS,
                    canmode in VARCHAR2 DEFAULT 'CANONICAL')
   return varchar2 character set ch%charset;
   pragma FIPSFLAG('DECOMPOSE', 1452);

1.721 FUNCTION SYS_EXTRACT_UTC[편집]

 FUNCTION SYS_EXTRACT_UTC(t timestamp_tz_unconstrained)
   return TIMESTAMP_UNCONSTRAINED;

 -- Begin REGEXP Support (10iR1) --

 -- REGEXP_LIKE --

1.722 function REGEXP_LIKE[편집]

 function REGEXP_LIKE (srcstr   VARCHAR2 CHARACTER SET ANY_CS,
                       pattern  VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       modifier VARCHAR2 DEFAULT NULL)
   return BOOLEAN;
   pragma FIPSFLAG('REGEXP_LIKE', 1452);

1.723 function REGEXP_LIKE[편집]

 function REGEXP_LIKE (srcstr   CLOB CHARACTER SET ANY_CS,
                       pattern  VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       modifier VARCHAR2 DEFAULT NULL)
   return BOOLEAN;
   pragma FIPSFLAG('REGEXP_LIKE', 1452);

 -- REGEXP_INSTR --

1.724 function REGEXP_INSTR[편집]

 function REGEXP_INSTR(srcstr      VARCHAR2 CHARACTER SET ANY_CS,
                       pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       position    PLS_INTEGER := 1,
                       occurrence  PLS_INTEGER := 1,
                       returnparam PLS_INTEGER := 0,
                       modifier    VARCHAR2 DEFAULT NULL,
                       subexpression PLS_INTEGER := 0)
   return PLS_INTEGER;
   pragma FIPSFLAG('REGEXP_INSTR', 1452);

1.725 function REGEXP_INSTR[편집]

 function REGEXP_INSTR(srcstr      CLOB CHARACTER SET ANY_CS,
                       pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       position    INTEGER := 1,
                       occurrence  INTEGER := 1,
                       returnparam PLS_INTEGER := 0,
                       modifier    VARCHAR2 DEFAULT NULL,
                       subexpression PLS_INTEGER := 0)
   return INTEGER;
   pragma FIPSFLAG('REGEXP_INSTR', 1452);

 -- REGEXP_SUBSTR --

1.726 function REGEXP_SUBSTR[편집]

 function REGEXP_SUBSTR(srcstr      VARCHAR2 CHARACTER SET ANY_CS,
                        pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                        position    PLS_INTEGER := 1,
                        occurrence  PLS_INTEGER := 1,
                        modifier    VARCHAR2 DEFAULT NULL,
                        subexpression PLS_INTEGER := 0)
   return VARCHAR2 CHARACTER SET srcstr%CHARSET;
   pragma FIPSFLAG('REGEXP_SUBSTR', 1452);

1.727 function REGEXP_SUBSTR[편집]

 function REGEXP_SUBSTR(srcstr      CLOB CHARACTER SET ANY_CS,
                        pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                        position    INTEGER := 1,
                        occurrence  INTEGER := 1,
                        modifier    VARCHAR2 DEFAULT NULL,
                        subexpression PLS_INTEGER := 0)
   return CLOB CHARACTER SET srcstr%CHARSET;
   pragma FIPSFLAG('REGEXP_SUBSTR', 1452);

 -- REGEXP_REPLACE --

1.728 function REGEXP_REPLACE[편집]

 function REGEXP_REPLACE(srcstr      VARCHAR2 CHARACTER SET ANY_CS,
                         pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                         replacestr  VARCHAR2 CHARACTER SET srcstr%CHARSET
                                       DEFAULT NULL,
                         position    PLS_INTEGER := 1,
                         occurrence  PLS_INTEGER := 0,
                         modifier    VARCHAR2 DEFAULT NULL)
   return VARCHAR2 CHARACTER SET srcstr%CHARSET;
   pragma FIPSFLAG('REGEXP_REPLACE', 1452);

1.729 function REGEXP_REPLACE[편집]

 function REGEXP_REPLACE(srcstr      CLOB CHARACTER SET ANY_CS,
                         pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                         replacestr  CLOB CHARACTER SET srcstr%CHARSET
                                       DEFAULT NULL,
                         position    INTEGER := 1,
                         occurrence  INTEGER := 0,
                         modifier    VARCHAR2 DEFAULT NULL)
   return CLOB CHARACTER SET srcstr%CHARSET;
   pragma FIPSFLAG('REGEXP_REPLACE', 1452);

1.730 function REGEXP_REPLACE[편집]

 function REGEXP_REPLACE(srcstr      CLOB CHARACTER SET ANY_CS,
                         pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                         replacestr  VARCHAR2 CHARACTER SET srcstr%CHARSET
                                       DEFAULT NULL,
                         position    INTEGER := 1,
                         occurrence  INTEGER := 0,
                         modifier    VARCHAR2 DEFAULT NULL)
   return CLOB CHARACTER SET srcstr%CHARSET;
   pragma FIPSFLAG('REGEXP_REPLACE', 1452);

 -- End REGEXP Support --

1.731 functions[편집]

 -- binary_float and binary_double functions and operators.

1.732 function TO_BINARY_FLOAT[편집]

 function TO_BINARY_FLOAT (RIGHT BINARY_FLOAT) RETURN BINARY_FLOAT;
   pragma BUILTIN('TO_BINARY_FLOAT',14, 0, 1); -- PEMS_QUICK

1.733 function TO_BINARY_FLOAT[편집]

 function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
   RETURN BINARY_FLOAT;

1.734 function TO_BINARY_FLOAT[편집]

 function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET,
                    PARMS VARCHAR2 CHARACTER SET LEFT%CHARSET)
   RETURN BINARY_FLOAT;

1.735 function TO_BINARY_DOUBLE[편집]

 function TO_BINARY_DOUBLE (RIGHT BINARY_DOUBLE) RETURN BINARY_DOUBLE;
   pragma BUILTIN('TO_BINARY_DOUBLE',14, 0, 1); -- PEMS_QUICK

1.736 function TO_BINARY_DOUBLE[편집]

 function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
   RETURN BINARY_DOUBLE;

1.737 function TO_BINARY_DOUBLE[편집]

 function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS,
                    FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET,
                    PARMS VARCHAR2 CHARACTER SET LEFT%CHARSET)
   RETURN BINARY_DOUBLE;

1.738 function 'IS[편집]

 function 'IS NAN' (N NUMBER) RETURN BOOLEAN;

1.739 function 'IS[편집]

 function 'IS NAN' (F BINARY_FLOAT) RETURN BOOLEAN;

1.740 function 'IS[편집]

 function 'IS NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;

1.741 function 'IS[편집]

 function 'IS INFINITE' (N NUMBER) RETURN BOOLEAN;

1.742 function 'IS[편집]

 function 'IS INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;

1.743 function 'IS[편집]

 function 'IS INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;

1.744 function 'IS[편집]

 function 'IS NOT NAN' (N NUMBER) RETURN BOOLEAN;

1.745 function 'IS[편집]

 function 'IS NOT NAN' (F BINARY_FLOAT) RETURN BOOLEAN;

1.746 function 'IS[편집]

 function 'IS NOT NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;

1.747 function 'IS[편집]

 function 'IS NOT INFINITE' (N NUMBER) RETURN BOOLEAN;

1.748 function 'IS[편집]

 function 'IS NOT INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;

1.749 function 'IS[편집]

 function 'IS NOT INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;

1.750 function TO_CHAR[편집]

 function TO_CHAR (left binary_float, format varchar2)
   return VARCHAR2;

1.751 function TO_CHAR[편집]

 function TO_CHAR (left binary_double, format varchar2)
   return VARCHAR2;

1.752 function TO_CHAR[편집]

 function TO_CHAR(left binary_float, format varchar2, parms varchar2)
   return varchar2;

1.753 function TO_CHAR[편집]

 function TO_CHAR(left binary_double, format varchar2, parms varchar2)
   return varchar2;

1.754 function TO_NCHAR[편집]

 function TO_NCHAR(left binary_float, format nvarchar2) return NVARCHAR2;

1.755 function TO_NCHAR[편집]

 function TO_NCHAR(left binary_double, format nvarchar2) return NVARCHAR2;

1.756 function TO_NCHAR[편집]

 function TO_NCHAR(left binary_float, format nvarchar2, parms nvarchar2)
   return nvarchar2;

1.757 function TO_NCHAR[편집]

 function TO_NCHAR(left binary_double, format nvarchar2, parms nvarchar2)
   return nvarchar2;

1.758 function 'REMAINDER[편집]

 function 'REMAINDER'(n1 NUMBER, n2 NUMBER) return NUMBER;
   pragma FIPSFLAG('REMAINDER', 1452);

1.759 function REMAINDER[편집]

 function REMAINDER(n1 NUMBER, n2 NUMBER) return NUMBER;
   pragma FIPSFLAG(REMAINDER, 1452);

1.760 function 'REMAINDER[편집]

 function 'REMAINDER'(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('REMAINDER', 1452);

1.761 function REMAINDER[편집]

 function REMAINDER(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG(REMAINDER, 1452);

1.762 function 'REMAINDER[편집]

 function 'REMAINDER'(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('REMAINDER', 1452);

1.763 function REMAINDER[편집]

 function REMAINDER(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG(REMAINDER, 1452);

1.764 function '='[편집]

 function '='  (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('=',2, 2, 15);

1.765 function '!='[편집]

 function '!=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('!=',5, 2, 16);
   pragma FIPSFLAG('!=', 1452);

1.766 function '<'[편집]

 function '<'  (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('<',4, 2, 17);

1.767 function '<='[편집]

 function '<=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('<=',6, 2, 18);

1.768 function '>[편집]

 function '>'  (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('>',1, 2, 19);

1.769 function '>[편집]

 function '>=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('>=',3, 2, 20);

1.770 function 'IS[편집]

 function 'IS NULL' (n BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0);

1.771 function 'IS[편집]

 function 'IS NOT NULL' (n BINARY_FLOAT) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50);

1.772 function NVL[편집]

 function NVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('NVL', 1452);

1.773 function '+'[편집]

 function '+' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('+',14, 0, 1);

1.774 function '-'[편집]

 function '-' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('-',15, 2, 23);

1.775 function ABS[편집]

 function ABS(F BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('ABS', 1452);

1.776 function '+'[편집]

 function '+' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('+',14, 2, 24);

1.777 function '-'[편집]

 function '-' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('-',15, 2, 25);

1.778 function '*'[편집]

 function '*' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('*',17, 2, 26);

1.779 function '/'[편집]

 function '/' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('/',18, 2, 27);

1.780 function 'REM[편집]

 function 'REM' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('REM', 1452);

1.781 function 'MOD[편집]

 function 'MOD'(F1 BINARY_FLOAT, F2 BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('MOD', 1452);

1.782 function FLOOR[편집]

 function FLOOR(F BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('FLOOR', 1452);

1.783 function CEIL[편집]

 function CEIL(F BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('CEIL', 1452);

1.784 function SIGN[편집]

 function SIGN(f BINARY_FLOAT) return SIGNTYPE;
   pragma FIPSFLAG('SIGN', 1452);

1.785 function SQRT[편집]

 function SQRT(f BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('SQRT', 1452);

1.786 function TRUNC[편집]

 function TRUNC (F BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('TRUNC', 1452);

1.787 function ROUND[편집]

 function ROUND (LEFT BINARY_FLOAT) return BINARY_FLOAT;
   pragma FIPSFLAG('ROUND', 1452);

1.788 function '='[편집]

 function '='  (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('=',2, 2, 28);

1.789 function '!='[편집]

 function '!=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   -- also <> and ~=
   pragma BUILTIN('!=',5, 2, 29);
   pragma FIPSFLAG('!=', 1452);

1.790 function '<'[편집]

 function '<'  (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('<',4, 2, 30);

1.791 function '<='[편집]

 function '<=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('<=',6, 2, 31);

1.792 function '>[편집]

 function '>'  (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('>',1, 2, 32);

1.793 function '>[편집]

 function '>=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('>=',3, 2, 33);

1.794 function 'IS[편집]

 function 'IS NULL' (n BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0);

1.795 function 'IS[편집]

 function 'IS NOT NULL' (n BINARY_DOUBLE) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50);

1.796 function NVL[편집]

 function NVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('NVL', 1452);

1.797 function '+'[편집]

 function '+' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('+',14, 0, 1);

1.798 function '-'[편집]

 function '-' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('-',15, 2, 36);

1.799 function ABS[편집]

 function ABS(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ABS', 1452);

1.800 function ACOS[편집]

 function ACOS(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ACOS', 1452);

1.801 function ASIN[편집]

 function ASIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ASIN', 1452);

1.802 function ATAN[편집]

 function ATAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ATAN', 1452);

1.803 function ATAN2[편집]

 function ATAN2(x BINARY_DOUBLE, y BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ATAN2', 1452);

1.804 function '+'[편집]

 function '+' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('+',14, 2, 37);

1.805 function '-'[편집]

 function '-' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('-',15, 2, 38);

1.806 function '*'[편집]

 function '*' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('*',17, 2, 39);

1.807 function '/'[편집]

 function '/' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('/',18, 2, 40);

1.808 function 'REM[편집]

 function 'REM' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
   return BINARY_DOUBLE;
   pragma FIPSFLAG('REM', 1452);

1.809 function 'MOD[편집]

 function 'MOD'(D1 BINARY_DOUBLE, D2 BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('MOD', 1452);

1.810 function '**'[편집]

 function '**' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
   return BINARY_DOUBLE;
   pragma FIPSFLAG('**', 1452);

1.811 function FLOOR[편집]

 function FLOOR(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('FLOOR', 1452);

1.812 function CEIL[편집]

 function CEIL(D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('CEIL', 1452);

1.813 function SQRT[편집]

 function SQRT(d BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('SQRT', 1452);

1.814 function SIGN[편집]

 function SIGN(d BINARY_DOUBLE) return SIGNTYPE;
 pragma FIPSFLAG('SIGN', 1452);

1.815 function COS[편집]

 function COS(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.816 function SIN[편집]

 function SIN(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.817 function TAN[편집]

 function TAN(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.818 function COSH[편집]

 function COSH(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.819 function SINH[편집]

 function SINH(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.820 function TANH[편집]

 function TANH(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.821 function EXP[편집]

 function EXP(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.822 function LN[편집]

 function LN(D BINARY_DOUBLE) return BINARY_DOUBLE;

1.823 function LOG[편집]

 function LOG (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;

1.824 function TRUNC[편집]

 function TRUNC (D BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('TRUNC', 1452);

1.825 function ROUND[편집]

 function ROUND (LEFT BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('ROUND', 1452);

1.826 function POWER[편집]

 function POWER (d BINARY_DOUBLE, e BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma FIPSFLAG('POWER', 1452);

1.827 function NANVL[편집]

 function NANVL(n1 NUMBER, n2 NUMBER) return NUMBER;

1.828 function NANVL[편집]

 function NANVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;

1.829 function NANVL[편집]

 function NANVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;

1.830 function GREATEST[편집]

 function GREATEST (pattern BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2

1.831 function GREATEST[편집]

 function GREATEST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2

1.832 function LEAST[편집]

 function LEAST (pattern BINARY_FLOAT) return BINARY_FLOAT;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2

1.833 function LEAST[편집]

 function LEAST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2

1.834 function '+'[편집]

 function '+' (RIGHT PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK

1.835 function '-'[편집]

 function '-' (RIGHT PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('-',15, 2, 41);

1.836 function ABS[편집]

 function ABS(I PLS_INTEGER) return PLS_INTEGER;
   pragma FIPSFLAG('ABS', 1452);

1.837 function '+'[편집]

 function '+' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('+',14, 2, 42);

1.838 function '-'[편집]

 function '-' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('-',14, 2, 43);

1.839 function '*'[편집]

 function '*' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('*',14, 2, 44);

1.840 function '='[편집]

 function '='  (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('=',2, 2, 45); -- PEMS_PLS_INTEGER, PEMDCMEQ

1.841 function '!='[편집]

 function '!=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   -- also <> and ~=
   pragma BUILTIN('!=',5, 2, 46); -- PEMS_PLS_INTEGER, PEMDCMNE
   pragma FIPSFLAG('!=', 1452);

1.842 function '<'[편집]

 function '<'  (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('<',4, 2, 47); -- PEMS_PLS_INTEGER, PEMDCMLT

1.843 function '<='[편집]

 function '<=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('<=',6, 2, 48); -- PEMS_PLS_INTEGER, PEMDCMLE

1.844 function '>[편집]

 function '>'  (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('>',1, 2, 49); -- PEMS_PLS_INTEGER, PEMDCMGT

1.845 function '>[편집]

 function '>=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('>=',3, 2, 51); -- PEMS_PLS_INTEGER, PEMDCMGE

1.846 function 'IS[편집]

 function 'IS NULL' (I PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_PLS_INTEGER, PEMDNUL

1.847 function 'IS[편집]

 function 'IS NOT NULL' (I PLS_INTEGER) return BOOLEAN;
   pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_PLS_INTEGER, PEMDNUL

1.848 function NVL[편집]

 function NVL(I1 PLS_INTEGER, I2 PLS_INTEGER) return PLS_INTEGER;
   pragma FIPSFLAG('NVL', 1452);

1.849 function TRUNC[편집]

 function TRUNC (i pls_integer, places pls_integer := 0) return pls_integer;
   pragma FIPSFLAG('TRUNC', 1452);

1.850 function ROUND[편집]

 function ROUND (i pls_integer, places pls_integer := 0) return pls_integer;
   pragma FIPSFLAG('ROUND', 1452);

1.851 function SIGN[편집]

 function SIGN(i PLS_INTEGER) return SIGNTYPE;
   pragma FIPSFLAG('SIGN', 1452);

1.852 function GREATEST[편집]

 function GREATEST (pattern PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2

1.853 function LEAST[편집]

 function LEAST (pattern PLS_INTEGER) return PLS_INTEGER;
   pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2

1.854 Functions[편집]

 -- MultiSet Functions and Operators.

 -- Equality

1.855 function '='(collection1[편집]

 function '='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
   return BOOLEAN;
     pragma BUILTIN('=',2, 16, 1);

1.856 function '!='(collection1[편집]

 function '!='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
   return BOOLEAN;
     pragma BUILTIN('!=',2, 16, 2);

1.857 function CARDINALITY[편집]

 function CARDINALITY (collection IN "<TABLE_1>") return PLS_INTEGER;

1.858 function SET[편집]

 function SET (collection IN "<TABLE_1>") return "<TABLE_1>";
   pragma BUILTIN('SET',18, 5, 40);-- Dummy

1.859 function 'IS[편집]

 function 'IS A SET' (collection IN  "<TABLE_1>") return BOOLEAN;
   pragma BUILTIN('IS A SET',18, 5, 41);-- Dummy

1.860 function 'IS[편집]

 function 'IS NOT A SET'(collection IN  "<TABLE_1>") return BOOLEAN;
   pragma BUILTIN('IS NOT A SET',18, 5, 42);-- Dummy

1.861 function 'IS[편집]

 function 'IS EMPTY' (collection IN  "<TABLE_1>") return BOOLEAN;

1.862 function 'IS[편집]

 function 'IS NOT EMPTY'(collection IN  "<TABLE_1>") return BOOLEAN;

 -- IS A SUBMULTISET OF

1.863 function 'SUBMULTISET[편집]

 function 'SUBMULTISET' (collection IN  "<TABLE_1>",
                         collection2 IN "<TABLE_1>")
   return BOOLEAN;
     pragma BUILTIN('SUBMULTISET',18, 5, 43);

1.864 function 'MULTISET_UNION_ALL[편집]

 function 'MULTISET_UNION_ALL' (collection IN  "<TABLE_1>",
                                collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
     pragma BUILTIN('MULTISET_UNION_ALL',18, 5, 44);

1.865 function 'MULTISET_UNION_DISTINCT[편집]

 function 'MULTISET_UNION_DISTINCT' (collection IN  "<TABLE_1>",
                                     collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
   pragma BUILTIN('MULTISET_UNION_DISTINCT',18, 5, 45);-- Dummy

1.866 function 'MULTISET_EXCEPT_ALL[편집]

 function 'MULTISET_EXCEPT_ALL' (collection IN  "<TABLE_1>",
                                collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
   pragma BUILTIN('MULTISET_EXCEPT_ALL',18, 5, 46);-- Dummy

1.867 function 'MULTISET_EXCEPT_DISTINCT[편집]

 function 'MULTISET_EXCEPT_DISTINCT' (collection IN  "<TABLE_1>",
                                     collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
   pragma BUILTIN('MULTISET_EXCEPT_DISTINCT',18, 5, 47);-- Dummy

1.868 function 'MULTISET_INTERSECT_ALL[편집]

 function 'MULTISET_INTERSECT_ALL' (collection IN  "<TABLE_1>",
                                collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
   pragma BUILTIN('MULTISET_INTERSECT_ALL',18, 5, 48);-- Dummy

1.869 function 'MULTISET_INTERSECT_DISTINCT[편집]

 function 'MULTISET_INTERSECT_DISTINCT' (collection IN  "<TABLE_1>",
                                     collection2 IN "<TABLE_1>")
   return "<TABLE_1>";
   pragma BUILTIN('MULTISET_INTERSECT_DISTINCT',18, 5, 49);-- Dummy

 -- These are dummy procedures for correct management of new control
 -- statements added to PL/SQL. They ensure local procedures which have the
 -- same names as newly introduced keywords are not masked by those keywords.

 procedure continue;

 -- REGEXP_COUNT --

1.870 function REGEXP_COUNT[편집]

 function REGEXP_COUNT(srcstr      VARCHAR2 CHARACTER SET ANY_CS,
                       pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       position    PLS_INTEGER := 1,
                       modifier    VARCHAR2 DEFAULT NULL)
   return PLS_INTEGER;
   pragma FIPSFLAG('REGEXP_COUNT', 1452);

1.871 function REGEXP_COUNT[편집]

 function REGEXP_COUNT(srcstr      CLOB CHARACTER SET ANY_CS,
                       pattern     VARCHAR2 CHARACTER SET srcstr%CHARSET,
                       position    INTEGER := 1,
                       modifier    VARCHAR2 DEFAULT NULL)
   return INTEGER;
   pragma FIPSFLAG('REGEXP_COUNT', 1452);

 -- 47322: JSON

1.872 function is[편집]

 -- Because of the variety of inputs and outputs, this dummy function is used
 -- for all JSON operations. The name (with the space) is to avoid name
 -- capture.

1.873 function[편집]

 function  SYS$STANDARD_JSON" return VARCHAR2;

 --#### All user-visible declarations should precede this point.  The
 --#### following are implementation-oriented pragmas that may need
 --#### editing in the future; we would prefer to be able to edit them
 --#### without affecting the rft numbering of user-visible items.

 --#### interface pragmas

 --#### Note that for any ICD which maps directly to a PVM
 --#### Opcode MUST be mapped to pes_dummy.
 --#### An ICD which invokes another ICD by flipping operands is
 --#### mapped to pes_flip, and an ICD whose result is the inverse of
 --#### another ICD is mapped to pes_invert
 --#### New ICDs should be placed at the end of this list, and a
 --#### corresponding entry must be made in the ICD table in pdz7

오라클 함수

DB CAFE

목차

1 Oracle Function[편집]

1.1 function EXISTS[편집]

1.2 function GREATEST[편집]

1.3 function GREATEST[편집]

1.4 function GREATEST[편집]

1.5 function LEAST[편집]

1.6 function LEAST[편집]

1.7 function LEAST[편집]

1.8 function DECODE[편집]

1.9 function DECODE[편집]

1.10 function DECODE[편집]

1.11 function DECODE[편집]

1.12 function DECODE[편집]

1.13 function DECODE[편집]

1.14 function DECODE[편집]

1.15 function DECODE[편집]

1.16 function DECODE[편집]

1.17 function SQLCODE[편집]

1.18 function SQLERRM[편집]

1.19 function SQLERRM[편집]

1.20 function LEVEL[편집]

1.21 function ROWNUM[편집]

1.22 function '='[편집]

1.23 function '!='[편집]

1.24 function '<'[편집]

1.25 function '<='[편집]

1.26 function '>[편집]

1.27 function '>[편집]

1.28 function XOR[편집]

1.29 function 'NOT[편집]

1.30 function 'IS[편집]

1.31 function 'IS[편집]

1.32 function NVL[편집]

1.33 function '='[편집]

1.34 function '!='[편집]

1.35 function '<'[편집]

1.36 function '<='[편집]

1.37 function '>[편집]

1.38 function '>[편집]

1.39 function '||'[편집]

1.40 function CONCAT[편집]

1.41 function LENGTH[편집]

1.42 function SUBSTR[편집]

1.43 function INSTR[편집]

1.44 function UPPER[편집]

1.45 function LOWER[편집]

1.46 function ASCII[편집]

1.47 function ASCIISTR[편집]

1.48 function UNISTR[편집]

1.49 function CHR[편집]

1.50 function[편집]

1.51 function INITCAP[편집]

1.52 function SOUNDEX[편집]

1.53 function LPAD[편집]

1.54 function LPAD[편집]

1.55 function RPAD[편집]

1.56 function RPAD[편집]

1.57 function TRANSLATE[편집]

1.58 function REPLACE[편집]

1.59 function LTRIM[편집]

1.60 function LTRIM[편집]

1.61 function RTRIM[편집]

1.62 function RTRIM[편집]

1.63 function 'LIKE[편집]

1.64 function 'NOT_LIKE[편집]

1.65 function 'LIKE[편집]

1.66 function 'NOT_LIKE[편집]

1.67 function 'IS[편집]

1.68 function 'IS[편집]

1.69 function NVL[편집]

1.70 function '='[편집]

1.71 function '!='[편집]

1.72 function '<'[편집]

1.73 function '<='[편집]

1.74 function '>[편집]

1.75 function '>[편집]

1.76 function 'IS[편집]