오라클 함수

1 Oracle Function[편집]
1.1 EXISTS[편집]
function EXISTS" return BOOLEAN;
pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj
1.2 GREATEST[편집]
function GREATEST (pattern NUMBER) return NUMBER;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.3 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 GREATEST[편집]
function GREATEST (pattern DATE) return DATE;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.5 LEAST[편집]
function LEAST (pattern NUMBER) return NUMBER;
pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
1.6 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 LEAST[편집]
function LEAST (pattern DATE) return DATE;
pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
1.8 DECODE[편집]
function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
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
function DECODE (expr NUMBER, pat NUMBER, res DATE) return DATE;
pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj

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
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
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

function DECODE (expr DATE, pat DATE, res NUMBER) return NUMBER;
pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
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
function DECODE (expr DATE, pat DATE, res DATE) return DATE;
pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
1.9 SQLCODE[편집]
function SQLCODE return PLS_INTEGER;
pragma BUILTIN('SQLCODE',45, 10, 0); -- PEMS_DB, DB_SQLCODE
1.10 SQLERRM[편집]
function SQLERRM return varchar2;
pragma FIPSFLAG('SQLERRM', 1452);
1.11 SQLERRM[편집]
function SQLERRM (code PLS_INTEGER) return varchar2;
pragma BUILTIN('SQLERRM',46, 10, 1); -- PEMS_DB, DB_SQLERRM pragma FIPSFLAG('SQLERRM', 1452);
1.12 LEVEL[편집]
function LEVEL return NUMBER;
1.13 ROWNUM[편집]
function ROWNUM return NUMBER;
1.14 '='[편집]
function '=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('=',2, 3, 1); -- PEMS_INTEGER, PEMDCMEQ pragma FIPSFLAG('=', 1450);
1.15 '!='[편집]
function '!=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN; -- also <> and ~=
pragma BUILTIN('!=',5, 3, 2); -- PEMS_INTEGER, PEMDCMNE pragma FIPSFLAG('!=', 1450);
1.16 '<'[편집]
function '<' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('<',4, 3, 3); -- PEMS_INTEGER, PEMDCMLT pragma FIPSFLAG('<', 1450);
1.17 '<='[편집]
function '<=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('<=',6, 3, 4); -- PEMS_INTEGER, PEMDCMLE pragma FIPSFLAG('<=', 1450);
1.18 '>'[편집]
function '>' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('>',1, 3, 5); -- PEMS_INTEGER, PEMDCMGT pragma FIPSFLAG('>', 1450);
1.19 '>='[편집]
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.20 XOR[편집]
function XOR (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('XOR',8, 3, 9); -- PEMS_INTEGER, INT_XOR pragma FIPSFLAG('XOR', 1450);
1.21 NOT[편집]
function 'NOT' (RIGHT BOOLEAN) return BOOLEAN;
pragma BUILTIN('NOT',9, 3, 10); -- PEMS_INTEGER, INT_NOT
1.22 IS NULL[편집]
function 'IS NULL' (B BOOLEAN) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); -- PEMS_INTEGER, PEMDNUL pragma FIPSFLAG('IS NULL', 1450);
1.23 IS NOT NULL[편집]
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.24 NVL[편집]
function NVL (B1 BOOLEAN, B2 BOOLEAN) return BOOLEAN;
pragma FIPSFLAG('NVL', 1450);
1.25 '='[편집]
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.26 '!='[편집]
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.27 '<'[편집]
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.28 '<='[편집]
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.29 '>[편집]
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.30 '>[편집]
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.31 '||'[편집]
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.32 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.33 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.34 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.35 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.36 UPPER[편집]
function UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('UPPER', 1452);
1.37 LOWER[편집]
function LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('LOWER', 1452);
1.38 ASCII[편집]
function ASCII(ch VARCHAR2 CHARACTER SET ANY_CS)
return INTEGER; -- should be ASCII.CHRANGE pragma FIPSFLAG('ASCII', 1452);
1.39 ASCIISTR[편집]
function ASCIISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('ASCIISTR', 1452);
1.40 UNISTR[편집]
function UNISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
return NVARCHAR2; pragma FIPSFLAG('UNISTR', 1452);
1.41 CHR[편집]
function CHR(n INTEGER) return varchar2; -- N should be ASCII.CHRANGE
pragma FIPSFLAG('CHR', 1452);
1.42 [편집]
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.43 INITCAP[편집]
function INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('INITCAP', 1452);
1.44 SOUNDEX[편집]
function SOUNDEX(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('SOUNDEX', 1452);
1.45 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.46 LPAD[편집]
function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
LEN pls_integer) return VARCHAR2 CHARACTER SET STR1%CHARSET;
pragma FIPSFLAG('LPAD', 1452);
1.47 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.48 RPAD[편집]
function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
LEN pls_integer) return VARCHAR2 CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('RPAD', 1452);
1.49 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.50 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.51 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.52 LTRIM[편집]
function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
return VARCHAR2 CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('LTRIM', 1452);
1.53 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.54 RTRIM[편집]
function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
return VARCHAR2 CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('RTRIM', 1452);
1.55 LIKE[편집]
function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS, pat VARCHAR2 CHARACTER SET str%CHARSET)
return BOOLEAN;
1.56 NOT_LIKE[편집]
function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS, pat VARCHAR2 CHARACTER SET str%CHARSET)
return BOOLEAN;
1.57 LIKE[편집]
function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS, pat VARCHAR2 CHARACTER SET str%CHARSET, esc VARCHAR2 CHARACTER SET str%CHARSET)
return BOOLEAN;
1.58 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.59 IS[편집]
function 'IS NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 1, 20); -- PEMS_CHAR, PEMDNUL
1.60 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.61 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.62 '='[편집]
function '=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
pragma BUILTIN('=',2, 2, 1); -- PEMS_NUMBER, PEMDCMEQ
1.63 '!='[편집]
function '!=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN; -- also <> and ~=
pragma BUILTIN('!=',5, 2, 2); -- PEMS_NUMBER, PEMDCMNE pragma FIPSFLAG('!=', 1452);
1.64 '<'[편집]
function '<' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
pragma BUILTIN('<',4, 2, 3); -- PEMS_NUMBER, PEMDCMLT
1.65 '<='[편집]
function '<=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
pragma BUILTIN('<=',6, 2, 4); -- PEMS_NUMBER, PEMDCMLE
1.66 '>'[편집]
function '>' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
pragma BUILTIN('>',1, 2, 5); -- PEMS_NUMBER, PEMDCMGT
1.67 '>='[편집]
function '>=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
pragma BUILTIN('>=',3, 2, 6); -- PEMS_NUMBER, PEMDCMGE
1.68 IS NULL[편집]
function 'IS NULL' (n NUMBER) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1.69 IS NOT NULL[편집]
function 'IS NOT NULL' (n NUMBER) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_NUMBER, PEMDNUL
1.70 NVL[편집]
function NVL(n1 NUMBER, n2 NUMBER) return NUMBER;
pragma FIPSFLAG('NVL', 1452);
1.71 '+'[편집]
function '+' (RIGHT NUMBER) return NUMBER;
pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
1.72 '-'[편집]
function '-' (RIGHT NUMBER) return NUMBER;
pragma BUILTIN('-',15, 2, 7); -- PEMS_NUMBER, NUM_NEG
1.73 ABS[편집]
function ABS(n NUMBER) return NUMBER;
pragma FIPSFLAG('ABS', 1452);
1.74 '+'[편집]
function '+' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma BUILTIN('+',14, 2, 8); -- PEMS_NUMBER, NUM_ADD
1.75 '-'[편집]
function '-' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma BUILTIN('-',15, 2, 9); -- PEMS_NUMBER, NUM_SUB
1.76 '*'[편집]
function '*' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma BUILTIN('*',17, 2, 10); -- PEMS_NUMBER, NUM_MUL
1.77 '/'[편집]
function '/' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma BUILTIN('/',18, 2, 11); -- PEMS_NUMBER, NUM_DIV
1.78 REM[편집]
function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma FIPSFLAG('REM', 1452);
1.79 MOD[편집]
function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER;
pragma FIPSFLAG('MOD', 1452);
1.80 '**'[편집]
function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
pragma FIPSFLAG('**', 1452);
1.81 FLOOR[편집]
function FLOOR(n NUMBER) return NUMBER;
pragma FIPSFLAG('FLOOR', 1452);
1.82 CEIL[편집]
function CEIL(n NUMBER) return NUMBER;
pragma FIPSFLAG('CEIL', 1452);
1.83 SQRT[편집]
function SQRT(n NUMBER) return NUMBER;
pragma FIPSFLAG('SQRT', 1452);
1.84 SIGN[편집]
function SIGN(n NUMBER) return SIGNTYPE; pragma FIPSFLAG('SIGN', 1452);
1.85 COS[편집]
function COS(N NUMBER) return NUMBER;
pragma FIPSFLAG('COS', 1452);
1.86 SIN[편집]
function SIN(N NUMBER) return NUMBER;
pragma FIPSFLAG('SIN', 1452);
1.87 TAN[편집]
function TAN(N NUMBER) return NUMBER;
pragma FIPSFLAG('TAN', 1452);
1.88 COSH[편집]
function COSH(N NUMBER) return NUMBER;
pragma FIPSFLAG('COSH', 1452);
1.89 SINH[편집]
function SINH(N NUMBER) return NUMBER;
pragma FIPSFLAG('SINH', 1452);
1.90 TANH[편집]
function TANH(N NUMBER) return NUMBER;
pragma FIPSFLAG('TANH', 1452);
1.91 EXP[편집]
function EXP(N NUMBER) return NUMBER;
1.92 LN[편집]
function LN(N NUMBER) return NUMBER;
1.93 BITAND[편집]
function BITAND (LEFT pls_integer, RIGHT pls_integer)
return pls_integer;
1.94 BITAND[편집]
function BITAND (LEFT number, RIGHT number)
return number;
1.95 LOG[편집]
function LOG (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
1.96 TRUNC[편집]
function TRUNC (n NUMBER, places pls_integer := 0) return NUMBER;
pragma FIPSFLAG('TRUNC', 1452);
1.97 ROUND[편집]
function ROUND (LEFT NUMBER, RIGHT pls_integer := 0) return NUMBER;
pragma FIPSFLAG('ROUND', 1452);
1.98 POWER[편집]
function POWER (n NUMBER, e NUMBER) return NUMBER;
pragma FIPSFLAG('POWER', 1452);
1.99 '='[편집]
function '=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
pragma BUILTIN('=',2, 12, 1); -- PEMS_DATE, PEMDCMEQ pragma FIPSFLAG('=', 1450);
1.100 '!='[편집]
function '!=' (LEFT DATE, RIGHT DATE) return BOOLEAN; -- also <> and ~=
pragma BUILTIN('!=',5, 12, 2); -- PEMS_DATE, PEMDCMNE pragma FIPSFLAG('!=', 1450);
1.101 '<'[편집]
function '<' (LEFT DATE, RIGHT DATE) return BOOLEAN;
pragma BUILTIN('<',4, 12, 3); -- PEMS_DATE, PEMDCMLT pragma FIPSFLAG('<', 1450);
1.102 '<='[편집]
function '<=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
pragma BUILTIN('<=',6, 12, 4); -- PEMS_DATE, PEMDCMLE pragma FIPSFLAG('<=', 1450);
1.103 '>'[편집]
function '>' (LEFT DATE, RIGHT DATE) return BOOLEAN;
pragma BUILTIN('>',1, 12, 5); -- PEMS_DATE, PEMDCMGT pragma FIPSFLAG('>', 1450);
1.104 '>='[편집]
function '>=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
pragma BUILTIN('>=',3, 12, 6); -- PEMS_DATE, PEMDCMGE pragma FIPSFLAG('>=', 1450);
1.105 '+'[편집]
function '+' (LEFT DATE, RIGHT NUMBER) return DATE;
pragma BUILTIN('+',14, 12, 7); -- PEMS_DATE, DATE_ADD1 pragma FIPSFLAG('+', 1450);
1.106 '+'[편집]
function '+' (LEFT NUMBER, RIGHT DATE) return DATE;
pragma BUILTIN('+',14, 12, 8); -- PEMS_DATE, DATE_ADD2 pragma FIPSFLAG('+', 1450);
1.107 '-'[편집]
function '-' (LEFT DATE, RIGHT NUMBER) return DATE;
pragma BUILTIN('-',15, 12, 9); -- PEMS_DATE, DATE_SUB1 pragma FIPSFLAG('-', 1450);
1.108 '-'[편집]
function '-' (LEFT NUMBER, RIGHT DATE) return DATE;
pragma BUILTIN('-',15, 12, 10); -- PEMS_DATE, DATE_SUB2 pragma FIPSFLAG('-', 1450);
1.109 '-'[편집]
function '-' (LEFT DATE, RIGHT DATE) return NUMBER;
pragma BUILTIN('-',15, 12, 11); -- PEMS_DATE, DATE_SUB3 pragma FIPSFLAG('-', 1450);
1.110 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.111 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.112 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.113 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.114 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.115 ROUND[편집]
function ROUND(RIGHT DATE) return DATE;
pragma BUILTIN('ROUND',24, 12, 17); -- PEMS_DATE, DATE_ROUND pragma FIPSFLAG('ROUND', 1450);
1.116 NEW_TIME[편집]
function NEW_TIME(RIGHT DATE, MIDDLE VARCHAR2, LEFT VARCHAR2) return DATE;
pragma FIPSFLAG('NEW_TIME', 1450);
1.117 IS NULL[편집]
function 'IS NULL' (d DATE) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 12, 0); -- PEMS_DATE, PEMDNUL pragma FIPSFLAG('IS NULL', 1450);
1.118 IS NOT NULL[편집]
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.119 NVL[편집]
function NVL (d1 DATE, d2 DATE) return DATE;
pragma FIPSFLAG('NVL', 1450);
1.120 TRUNC[편집]
function TRUNC(LEFT DATE) return DATE;
pragma BUILTIN('TRUNC',51, 12, 20); -- PEMS_DATE, DATE_TRUNC1 pragma FIPSFLAG('TRUNC', 1450);
1.121 TRUNC[편집]
function TRUNC(LEFT DATE, RIGHT VARCHAR2) return DATE;
pragma BUILTIN('TRUNC',51, 12, 21); -- PEMS_DATE, DATE_TRUNC2 pragma FIPSFLAG('TRUNC', 1450);
1.122 ROUND[편집]
function ROUND(LEFT DATE, RIGHT VARCHAR2) return DATE;
pragma BUILTIN('ROUND',24, 12, 22); -- PEMS_DATE, DATE_ROUND2 pragma FIPSFLAG('ROUND', 1450);
1.123 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.124 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.125 TO_DATE[편집]
function TO_DATE (LEFT NUMBER, RIGHT VARCHAR2) return DATE;
pragma FIPSFLAG('TO_DATE', 1450);
1.126 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.127 TO_CHAR[편집]
function TO_CHAR (RIGHT VARCHAR2) return VARCHAR2;
pragma BUILTIN('TO_CHAR',14, 0, 2);
1.128 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.129 TO_CHAR[편집]
function TO_CHAR (LEFT NUMBER, RIGHT VARCHAR2) return VARCHAR2;
pragma BUILTIN('TO_CHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
1.130 TO_NUMBER[편집]
function TO_NUMBER (RIGHT NUMBER) RETURN NUMBER;
pragma BUILTIN('TO_NUMBER',14, 0, 1); -- PEMS_QUICK
1.131 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.132 TO_NUMBER[편집]
function TO_NUMBER(left varchar2 character set any_cs,
format varchar2 character set LEFT%charset) return number;
1.133 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.134 call[편집]
-- PRIOR is WEIRD - For now, it will be treated as a function call.
1.135 only[편집]
-- Does the function only take a column name? how about its use in -- a predicate?
1.136 PRIOR[편집]
function 'PRIOR'(colname VARCHAR2 CHARACTER SET ANY_CS) return VARCHAR2 CHARACTER SET colname%CHARSET; pragma FIPSFLAG('PRIOR', 1452);
1.137 PRIOR[편집]
function 'PRIOR'(colname NUMBER) return NUMBER; pragma FIPSFLAG('PRIOR', 1452);
1.138 PRIOR[편집]
function 'PRIOR'(colname DATE) return DATE; pragma FIPSFLAG('PRIOR', 1450);
-- Outer Join has same problem as PRIOR
1.139 '(+)'[편집]
function '(+)'(colname VARCHAR2 CHARACTER SET ANY_CS) return VARCHAR2 CHARACTER SET colname%CHARSET;
1.140 '(+)'[편집]
function '(+)'(colname NUMBER) return NUMBER;
1.141 '(+)'[편집]
function '(+)'(colname DATE) return DATE; pragma FIPSFLAG('(+)', 1450);
1.142 '=ANY'[편집]
function '=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.143 '=ANY'[편집]
function '=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('=ANY', 1450);
1.144 '=ANY'[편집]
function '=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.145 '!=ANY'[편집]
function '!=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.146 '!=ANY'[편집]
function '!=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('!=ANY', 1450);
1.147 '!=ANY'[편집]
function '!=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.148 '<ANY'[편집]
function '<ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.149 '<ANY'[편집]
function '<ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<ANY', 1450);
1.150 '<ANY'[편집]
function '<ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.151 '<=ANY'[편집]
function '<=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.152 '<=ANY'[편집]
function '<=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<=ANY', 1450);
1.153 '<=ANY'[편집]
function '<=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.154 '>ANY'[편집]
function '>ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.155 '>ANY'[편집]
function '>ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>ANY', 1450);
1.156 '>[편집]
function '>ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.157 '>=ANY'[편집]
function '>=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.158 '>=ANY'[편집]
function '>=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>=ANY', 1450);
1.159 '>=ANY'[편집]
function '>=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.160 '=ALL'[편집]
function '=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.161 '=ALL'[편집]
function '=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('=ALL', 1450);
1.162 '=ALL'[편집]
function '=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.163 '!=ALL'[편집]
function '!=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.164 '!=ALL'[편집]
function '!=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('!=ALL', 1450);
1.165 '!=ALL'[편집]
function '!=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.166 '<ALL'[편집]
function '<ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.167 '<ALL'[편집]
function '<ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<ALL', 1450);
1.168 '<ALL'[편집]
function '<ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.169 '<=ALL'[편집]
function '<=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.170 '<=ALL'[편집]
function '<=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<=ALL', 1450);
1.171 '<=ALL'[편집]
function '<=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.172 '>ALL'[편집]
function '>ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
return BOOLEAN;
1.173 '>ALL'[편집]
function '>ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>ALL', 1450);
1.174 '>ALL'[편집]
function '>ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.175 '>=ALL'[편집]
function '>=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.176 '>=ALL'[편집]
function '>=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>=ALL', 1450);
1.177 '>[편집]
function '>=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.178 '=SOME'[편집]
function '=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.179 '=SOME'[편집]
function '=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('=SOME', 1450);
1.180 '=SOME'[편집]
function '=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.181 '!=SOME'[편집]
function '!=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.182 '!=SOME'[편집]
function '!=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('!=SOME', 1450);
1.183 '!=SOME'[편집]
function '!=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.184 '<SOME'[편집]
function '<SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.185 '<SOME'[편집]
function '<SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<SOME', 1450);
1.186 '<SOME'[편집]
function '<SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.187 '<=SOME'[편집]
function '<=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.188 '<=SOME'[편집]
function '<=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('<=SOME', 1450);
1.189 '<=SOME'[편집]
function '<=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.190 '>SOME'[편집]
function '>SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.191 '>SOME'[편집]
function '>SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>SOME', 1450);
1.192 '>SOME'[편집]
function '>SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
1.193 '>SOME'[편집]
function '>=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET) return BOOLEAN;
1.194 '>SOME'[편집]
function '>=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN; pragma FIPSFLAG('>=SOME', 1450);
1.195 '>SOME'[편집]
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.196 SYSDATE[편집]
function SYSDATE return DATE;
pragma FIPSFLAG('SYSDATE', 1452);
1.197 UID[편집]
function UID return PLS_INTEGER;
pragma FIPSFLAG('UID', 1452);
1.198 USER[편집]
function USER return VARCHAR2;
1.199 USERENV[편집]
function USERENV (envstr VARCHAR2) return VARCHAR2;
pragma FIPSFLAG('USERENV', 1452);
-- ROWID: this dreadful identifier is supposed to represent a datatype
1.200 ==[편집]
-- 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.200.1 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.200.2 ROWID[편집]
function ROWID " return ROWID;
pragma builtin('ROWID ', 1, 209, 240); -- this had better never be called.
1.200.3 NULLFN[편집]
function NULLFN (str VARCHAR2) return RAW;
pragma builtin('NULLFN', 1, 0, 1);
1.200.4 HEXTORAW[편집]
function HEXTORAW (c VARCHAR2) return RAW; pragma builtin('HEXTORAW', 1, 23, 1);
1.200.5 RAWTOHEX[편집]
function RAWTOHEX (r RAW) return VARCHAR2; pragma builtin('RAWTOHEX', 1, 23, 2);
1.200.6 CHARTOROWID[편집]
function CHARTOROWID (str VARCHAR2) return ROWID;
pragma builtin('CHARTOROWID', 1, 0, 1);
1.200.7 ROWIDTOCHAR[편집]
function ROWIDTOCHAR (str ROWID) return VARCHAR2;
pragma builtin('ROWIDTOCHAR', 1, 0, 1);

-- Trusted*Oracle additions
1.200.8 ROWLABEL[편집]
Function ROWLABEL return MLSLABEL; -- pseudo column
1.200.9 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.200.10 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.200.11 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.200.12 LEAST_UB[편집]
Function LEAST_UB(pattern MLSLABEL) return MLSLABEL;
pragma BUILTIN('LEAST_UB',90, 4, 3); -- PEMS_CHAR, CHR_CNV_MLS
1.200.13 GREATEST_LB[편집]
Function GREATEST_LB (pattern MLSLABEL) return MLSLABEL;
pragma BUILTIN('GREATEST_LB',90, 4, 4); -- PEMS_CHAR, CHR_CNV_MLS
1.200.14 '>='[편집]
Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.15 '>[편집]
Function '>' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.16 '<='[편집]
Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.17 '<'[편집]
Function '<' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.18 '='[편집]
Function '=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.19 '!='[편집]
Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
1.200.20 'IS NULL'[편집]
function 'IS NULL' (label MLSLABEL) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 1, 20); -- same "cod" as IS NULL(varchar2)
1.200.21 'IS NOT NULL'[편집]
function 'IS NOT NULL' (label MLSLABEL) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 1, 50);
1.200.22 NVL[편집]
function NVL(label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL;
pragma FIPSFLAG('NVL', 1452);
-- group functions
1.200.23 LUB[편집]
Function LUB (label MLSLABEL) return MLSLABEL;
1.200.24 GLB[편집]
Function GLB (label MLSLABEL) return MLSLABEL;
-- end of Trusted*Oracle additions

-- beginning of NLS routines
1.200.25 NLSSORT[편집]
function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS) return RAW;
pragma FIPSFLAG('NLSSORT', 1452);
1.200.26 NLSSORT[편집]
function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS, c2 VARCHAR2) return RAW;
pragma FIPSFLAG('NLSSORT', 1452);
1.200.27 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.200.28 NLS_UPPER[편집]
function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('NLS_UPPER', 1452);
1.200.29 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.200.30 NLS_LOWER[편집]
function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('NLS_LOWER', 1452);
1.200.31 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.200.32 NLS_INITCAP[편집]
function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
return VARCHAR2 CHARACTER SET ch%CHARSET; pragma FIPSFLAG('NLS_INITCAP', 1452);
1.200.33 LENGTHB[편집]
function LENGTHB(ch VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
pragma FIPSFLAG('LENGTHB', 1452);
1.200.34 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.200.35 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.200.36 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.200.37 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.200.38 TO_CHAR[편집]
function TO_CHAR(left date, format varchar2, parms varchar2) return varchar2;
1.200.39 TO_CHAR[편집]
function TO_CHAR(left number, format varchar2, parms varchar2)
return varchar2;
1.200.40 NLS_CHARSET_NAME[편집]
function NLS_CHARSET_NAME(csetid PLS_INTEGER) return VARCHAR2;
1.200.41 NLS_CHARSET_ID[편집]
function NLS_CHARSET_ID(csetname VARCHAR2) return PLS_INTEGER;
1.200.42 NLS_CHARSET_DECL_LEN[편집]
function NLS_CHARSET_DECL_LEN(bytecnt NUMBER, csetid NUMBER)
return PLS_INTEGER;
-- end of NLS routines
1.200.43 CONVERT[편집]
function CONVERT(src VARCHAR2 character set any_cs, destcset VARCHAR2) return VARCHAR2 character set src%charset;
1.200.44 CONVERT[편집]
function CONVERT(src VARCHAR2 character set any_cs, destcset VARCHAR2, srccset VARCHAR2) return VARCHAR2 character set src%charset;
1.200.45 "SYS$STANDARD_TRANSLATE"[편집]
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.200.46 VSIZE[편집]
function VSIZE (e number ) return NUMBER; pragma builtin('VSIZE', 1, 0, 1);
1.200.47 VSIZE[편집]
function VSIZE (e DATE) return NUMBER; pragma builtin('VSIZE', 1, 0, 1);
1.200.48 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.200.49 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.200.50 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.200.51 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 -- Inverse Trigonometric functions -- These functions return NULL if any of the inputs are NULL --
1.200.52 ACOS[편집]
function ACOS(N NUMBER) return NUMBER;
pragma FIPSFLAG('ACOS', 1452);
1.200.53 ASIN[편집]
function ASIN(N NUMBER) return NUMBER;
pragma FIPSFLAG('ASIN', 1452);
1.200.54 ATAN[편집]
function ATAN(N NUMBER) return NUMBER;
pragma FIPSFLAG('ATAN', 1452);
1.200.55 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.200.56 'IS NULL'[편집]
function 'IS NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1.200.57 'IS NOT NULL'[편집]
function 'IS NOT NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1.200.58 'IS NULL'[편집]
function 'IS NULL' (n BLOB) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1.200.59 'IS NOT NULL'[편집]
function 'IS NOT NULL' (n BLOB) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1.200.60 'IS NULL'[편집]
function 'IS NULL' (n BFILE) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1.200.61 'IS NOT NULL'[편집]
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.200.62 '='[편집]
function '=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('=', 1, 1, 1); pragma FIPSFLAG('=', 1450);
1.200.63 '!='[편집]
function '!=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('!=', 1, 1, 1); pragma FIPSFLAG('!=', 1450);
1.200.64 '<'[편집]
function '<' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('<', 1, 1, 1); pragma FIPSFLAG('<', 1450);
1.200.65 '<='[편집]
function '<=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('<=', 1, 1, 1); pragma FIPSFLAG('<=', 1450);
1.200.66 '>'[편집]
function '>' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('>', 1, 1, 1); pragma FIPSFLAG('>', 1450);
1.200.67 '>='[편집]
function '>=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
pragma BUILTIN('>=', 1, 1, 1); pragma FIPSFLAG('>=', 1450);
1.200.68 '=ANY'[편집]
function '=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.69 '!=ANY'[편집]
function '!=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.70 '<ANY'[편집]
function '<ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.71 '<=ANY'[편집]
function '<=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.72 '>ANY'[편집]
function '>ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.73 '>=ANY'[편집]
function '>=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.74 '=ALL'[편집]
function '=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.75 '!=ALL'[편집]
function '!=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.76 '<ALL'[편집]
function '<ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.77 '<=ALL'[편집]
function '<=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.78 '>ALL'[편집]
function '>ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.79 '>[편집]
function '>=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.80 '=SOME'[편집]
function '=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.81 '!=SOME'[편집]
function '!=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.82 '<SOME'[편집]
function '<SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.83 '<=SOME'[편집]
function '<=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.84 '>SOME'[편집]
function '>SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1.200.85 '>=SOME'[편집]
function '>=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
-- Outer Join
1.200.86 '(+)'[편집]
function '(+)' ( colname "<ADT_1>") return "<ADT_1>";
pragma FIPSFLAG('(+)', 1450);
-- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
1.200.87 GREATEST[편집]
-- function GREATEST (pattern "<ADT_1>") return "<ADT_1>"; --pragma BUILTIN('GREATEST', 1, 1, 1);
1.200.88 LEAST[편집]
-- function LEAST (pattern "<ADT_1>") return "<ADT_1>"; --pragma BUILTIN('LEAST', 1, 1, 1);
1.200.89 DECODE[편집]
function DECODE (expr "<ADT_1>", pat "<ADT_1>", res "<ADT_1>")
return "<ADT_1>"; pragma BUILTIN('DECODE', 1, 1, 1);
1.200.90 'IS NULL'[편집]
function 'IS NULL' (B "<ADT_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.200.91 'IS NOT NULL'[편집]
function 'IS NOT NULL' (B "<ADT_1>") return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 3, 50); pragma FIPSFLAG('IS NOT NULL', 1450);
1.200.92 NVL[편집]
function NVL (B1 "<ADT_1>", B2 "<ADT_1>") return "<ADT_1>";
pragma FIPSFLAG('NVL', 1450);
1.200.93 VALUE[편집]
function VALUE (item "<ADT_WITH_OID>") return "<ADT_1>";
pragma BUILTIN('VALUE', 1, 1, 1); pragma FIPSFLAG('VALUE', 1450);
1.200.94 REF[편집]
function REF (item "<ADT_WITH_OID>") return REF "<ADT_1>";
pragma BUILTIN('REF', 1, 1, 1); pragma FIPSFLAG('REF', 1450);
1.200.95 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.200.96 'IS NULL'[편집]
function 'IS NULL' (B REF "<ADT_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.200.97 'IS NOT NULL'[편집]
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.200.98 'IS DANGLING'[편집]
function 'IS DANGLING' (B REF "<ADT_1>") return BOOLEAN;
pragma BUILTIN('IS DANGLING', 1, 1, 1); pragma FIPSFLAG('IS DANGLING', 1450);
1.200.99 'IS NOT DANGLING'[편집]
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.200.100 NVL[편집]
function NVL (B1 REF "<ADT_1>", B2 REF "<ADT_1>") return REF "<ADT_1>";
pragma FIPSFLAG('NVL', 1450);
1.200.101 '='[편집]
function '=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
pragma BUILTIN('=', 0, 3, 1); pragma FIPSFLAG('=', 1450);
1.200.102 '!='[편집]
function '!=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
pragma BUILTIN('!=', 0, 3, 2); pragma FIPSFLAG('!=', 1450);
1.200.103 '='[편집]
-- function '=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN; --pragma BUILTIN('=', 1, 1, 1); --pragma FIPSFLAG('=', 1450); --
1.200.104 '!='[편집]
-- function '!=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN; --pragma BUILTIN('!=', 1, 1, 1); --pragma FIPSFLAG('!=', 1450); --
1.200.105 '=ANY'[편집]
-- function '=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN;
1.200.106 '!=ANY'[편집]
-- function '!=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN;
1.200.107 '=ALL'[편집]
-- function '=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN;
1.200.108 '!=ALL'[편집]
-- function '!=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN;
1.200.109 '=SOME'[편집]
-- function '=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN;
1.200.110 '!=SOME'[편집]
-- function '!=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>") -- return BOOLEAN; --
1.200.111 DECODE[편집]
-- function DECODE (expr "<COLLECTION_1>", pat "<COLLECTION_1>", --res "<COLLECTION_1>") -- return "<COLLECTION_1>"; --pragma BUILTIN('DECODE', 1, 1, 1);
1.200.112 will[편집]
-- Note that index-by tables are never NULL: this function will always -- return FALSE for them.
1.200.113 'IS NULL'[편집]
function 'IS NULL' (B "<COLLECTION_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.200.114 will[편집]
-- Note that index-by tables are never NULL: this function will always -- return TRUE for them.
1.200.115 'IS NOT NULL'[편집]
function 'IS NOT NULL' (B "<COLLECTION_1>") return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 3, 50); pragma FIPSFLAG('IS NOT NULL', 1450);
1.200.116 will[편집]
-- Note that index-by tables are never NULL: this function will always -- return B1 for them.
1.200.117 NVL[편집]
function NVL (B1 "<COLLECTION_1>", B2 "<COLLECTION_1>")
return "<COLLECTION_1>"; pragma FIPSFLAG('NVL', 1450);
1.200.118 'IS NULL'[편집]
function 'IS NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.200.119 'IS NOT NULL'[편집]
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.200.120 NVL[편집]
function NVL (B1 "<REF_CURSOR_1>", B2 "<REF_CURSOR_1>")
return "<REF_CURSOR_1>"; pragma FIPSFLAG('NVL', 1450);
1.200.121 will[편집]
-- Note that associative arrays are never NULL: this function will always -- return FALSE.
1.200.122 'IS NULL'[편집]
function 'IS NULL' (B "<ASSOC_ARRAY_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.200.123 will[편집]
-- Note that associative arrays are never NULL: this function will always -- return TRUE.
1.200.124 'IS NOT NULL'[편집]
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.200.125 will[편집]
-- Note that associative arrays are never NULL: this function will always -- return B1.
1.200.126 NVL[편집]
function NVL (B1 "<ASSOC_ARRAY_1>", B2 "<ASSOC_ARRAY_1>")
return "<ASSOC_ARRAY_1>"; pragma FIPSFLAG('NVL', 1450);
1.200.127 EMPTY_CLOB[편집]
function EMPTY_CLOB return clob;
1.200.128 EMPTY_BLOB[편집]
function EMPTY_BLOB return blob;
1.200.129 BFILENAME[편집]
function BFILENAME(directory varchar2,filename varchar2) return BFILE;
1.200.130 "SYS$LOB_REPLICATION"[편집]
function "SYS$LOB_REPLICATION" (x in blob) return blob;
1.200.131 "SYS$LOB_REPLICATION"[편집]
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
-- begin subtract
1.201 ==[편집]
function "SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return DSINTERVAL_UNCONSTRAINED ; function "SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return YMINTERVAL_UNCONSTRAINED ;
1.201.1 '-'[편집]
function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;
1.201.2 '-'[편집]
function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;
1.201.3 "SYS$DSINTERVALSUBTRACT"[편집]
function "SYS$DSINTERVALSUBTRACT" (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED ;
1.201.4 "SYS$YMINTERVALSUBTRACT"[편집]
function SYS$YMINTERVALSUBTRACT" (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED ;
1.201.5 '-'[편집]
function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
return TIMESTAMP_TZ_UNCONSTRAINED ;
1.201.6 '-'[편집]
function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
return TIMESTAMP_TZ_UNCONSTRAINED ;
1.201.7 "SYS$DSINTERVALSUBTRACT"[편집]
function "SYS$DSINTERVALSUBTRACT" (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return DSINTERVAL_UNCONSTRAINED ;
1.201.8 '-'[편집]
function '-' (LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
return TIME_UNCONSTRAINED ;
1.201.9 "SYS$DSINTERVALSUBTRACT"[편집]
function "SYS$DSINTERVALSUBTRACT" (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED ;
1.201.10 '-'[편집]
function '-' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
return TIME_TZ_UNCONSTRAINED ;
1.201.11 "SYS$DSINTERVALSUBTRACT"[편집]
function "SYS$DSINTERVALSUBTRACT" (LEFT date, RIGHT date)
return DSINTERVAL_UNCONSTRAINED ;
1.201.12 "SYS$YMINTERVALSUBTRACT"[편집]
function "SYS$YMINTERVALSUBTRACT" (LEFT date, RIGHT date)
return YMINTERVAL_UNCONSTRAINED ;
1.201.13 '-'[편집]
function '-' (LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date;
1.201.14 '-'[편집]
function '-' (LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date;
1.201.15 '-'[편집]
function '-' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED ;
1.201.16 '-'[편집]
function '-' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return DSINTERVAL_UNCONSTRAINED ;
-- end subtract
-- other datetime operators
1.201.17 '*'[편집]
function '*' (LEFT number, RIGHT YMINTERVAL_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED ;
function '*' (LEFT number, RIGHT DSINTERVAL_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED ;
function '*' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
return YMINTERVAL_UNCONSTRAINED ;
function '*' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
return DSINTERVAL_UNCONSTRAINED ;
1.201.18 '/'[편집]
function '/' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
return YMINTERVAL_UNCONSTRAINED ;
function '/' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
return DSINTERVAL_UNCONSTRAINED ;

1.201.19 current_date[편집]
function current_date return date;
1.201.20 current_time[편집]
function current_time return TIME_TZ_UNCONSTRAINED;
1.201.21 current_timestamp[편집]
function current_timestamp return TIMESTAMP_TZ_UNCONSTRAINED;
1.201.22 TO_TIME[편집]
function TO_TIME (RIGHT varchar2 character set any_cs) return
time_unconstrained; pragma BUILTIN('TO_TIME', 0, 15, 1);
1.201.23 TO_TIMESTAMP[편집]
function TO_TIMESTAMP (RIGHT varchar2 character set any_cs)
return TIMESTAMP_UNCONSTRAINED;
pragma BUILTIN('TO_TIMESTAMP', 0, 15, 3);
1.201.24 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.201.25 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.201.26 TO_YMINTERVAL[편집]
function TO_YMINTERVAL (RIGHT varchar2 character set any_cs)
return YMINTERVAL_UNCONSTRAINED; pragma BUILTIN('TO_YMINTERVAL', 0, 15, 9);
1.201.27 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.201.28 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;
function TO_TIME(left varchar2 character set any_cs, format varchar2 character set left%charset)
return TIME_UNCONSTRAINED;
1.201.29 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;
function TO_TIMESTAMP(left varchar2 character set any_cs,
format varchar2 character set left%charset) return TIMESTAMP_UNCONSTRAINED;
1.201.30 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;
function TO_TIMESTAMP_TZ(left varchar2 character set any_cs, format varchar2 character set left%charset)
return TIMESTAMP_TZ_UNCONSTRAINED;
1.201.31 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;
function TO_TIME_TZ(left varchar2 character set any_cs, format varchar2 character set left%charset)
return TIME_TZ_UNCONSTRAINED;
1.201.32 TO_DSINTERVAL[편집]
function TO_DSINTERVAL(RIGHT varchar2 character set any_cs, parms varchar2 character set RIGHT%charset)
return DSINTERVAL_UNCONSTRAINED;
1.201.33 NUMTOYMINTERVAL[편집]
function NUMTOYMINTERVAL(numerator number, units varchar2 character set any_cs)
return YMINTERVAL_UNCONSTRAINED;
1.201.34 NUMTODSINTERVAL[편집]
function NUMTODSINTERVAL(numerator number, units varchar2 character set any_cs)
return DSINTERVAL_UNCONSTRAINED;
1.201.35 '='[편집]
function '=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
pragma BUILTIN('=',0, 11, 1); pragma FIPSFLAG('=', 1450);
1.201.36 '!='[편집]
function '!=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN; -- also <> and ~=
pragma BUILTIN('!=',0, 11, 2); pragma FIPSFLAG('!=', 1450);
1.201.37 '<'[편집]
function '<' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
pragma BUILTIN('<',0, 11, 3); pragma FIPSFLAG('<', 1450);
1.201.38 '<='[편집]
function '<=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
pragma BUILTIN('<=',0, 11, 4); pragma FIPSFLAG('<=', 1450);
1.201.39 '>'[편집]
function '>' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
pragma BUILTIN('>',0, 11, 5); pragma FIPSFLAG('>', 1450);
1.201.40 '>='[편집]
function '>=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
pragma BUILTIN('>=',0, 11, 6); pragma FIPSFLAG('>=', 1450);
1.201.41 'IS NULL'[편집]
function 'IS NULL' (u UROWID) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 14, 0); -- PEMS_UROWID, PEMDNUL pragma FIPSFLAG('IS NULL', 1450);
1.201.42 'IS NOT NULL'[편집]
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.201.43 UROWID[편집]
function UROWID " return UROWID;
pragma builtin('UROWID ', 1, 209, 240); -- this had better never be called.
1.201.44 SYS_GUID[편집]
-- New built-in function SYS_GUID, returns globally unique id
1.201.45 SYS_GUID[편집]
function SYS_GUID return RAW;
1.201.46 SYS_CONTEXT[편집]
-- New built-in function SYS_CONTEXT
1.201.47 SYS_CONTEXT[편집]
function SYS_CONTEXT (namespace varchar2, attribute varchar2)
return varchar2;
1.201.48 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.201.49 SYS_CONTEXT[편집]
function SYS_CONTEXT(namespace varchar2, attribute varchar2, newoptional varchar2)
return varchar2;
-- 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.201.50 [편집]
-- been added here as functions to avoid name capture issues. --
1.201.51 [편집]
-- 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.201.52 CUBE[편집]
function CUBE return NUMBER;
1.201.53 ROLLUP[편집]
function ROLLUP return NUMBER;
1.201.54 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.201.55 GROUPING[편집]
function GROUPING(v VARCHAR2) return NUMBER;
1.201.56 GROUPING[편집]
function GROUPING(a "<ADT_1>") return NUMBER;
-- This is for TRIM(x). No trim set.
1.202 ==[편집]
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.203 ==[편집]
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.204 ==[편집]
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.204.1 '='[편집]
function '=' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.2 '!='[편집]
function '!=' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.3 '<'[편집]
function '<' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.4 '<='[편집]
function '<=' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.5 '>[편집]
function '>' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.6 '>[편집]
function '>=' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1.204.7 '='[편집]
function '=' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.8 '!='[편집]
function '!=' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.9 '<'[편집]
function '<' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.10 '<='[편집]
function '<=' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.11 '>[편집]
function '>' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.12 '>[편집]
function '>=' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.13 '='[편집]
function '=' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.14 '!='[편집]
function '!=' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.15 '<'[편집]
function '<' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.16 '<='[편집]
function '<=' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.17 '>[편집]
function '>' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.18 '>[편집]
function '>=' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.19 '='[편집]
function '=' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.20 '!='[편집]
function '!=' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.21 '<'[편집]
function '<' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.22 '<='[편집]
function '<=' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.23 '>[편집]
function '>' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.24 '>[편집]
function '>=' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.25 '='[편집]
function '=' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.26 '!='[편집]
function '!=' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.27 '<'[편집]
function '<' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.28 '<='[편집]
function '<=' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.29 '>[편집]
function '>' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.30 '>[편집]
function '>=' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.31 TO_TIME[편집]
function TO_TIME (RIGHT TIME_TZ_UNCONSTRAINED) return TIME_UNCONSTRAINED;
pragma BUILTIN('TO_TIME', 0, 15, 13);
1.204.32 TO_TIME_TZ[편집]
function TO_TIME_TZ (RIGHT TIME_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
pragma BUILTIN('TO_TIME_TZ', 0, 15, 14);
1.204.33 TO_TIMESTAMP[편집]
function TO_TIMESTAMP (RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
return TIMESTAMP_UNCONSTRAINED; pragma BUILTIN('TO_TIMESTAMP', 0, 15, 15);
1.204.34 TO_TIMESTAMP_TZ[편집]
function TO_TIMESTAMP_TZ (RIGHT TIMESTAMP_UNCONSTRAINED)
return TIMESTAMP_TZ_UNCONSTRAINED; pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 16);
1.204.35 '-'[편집]
function '-' (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED;
1.204.36 '-'[편집]
function '-' (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED;
1.204.37 '-'[편집]
function '-' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED;
1.204.38 '-'[편집]
function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED;
-- timezone functions
1.204.39 SYS_AT_TIME_ZONE[편집]
function SYS_AT_TIME_ZONE(t time_tz_unconstrained,
i varchar2) RETURN time_tz_unconstrained;
1.204.40 SYS_AT_TIME_ZONE[편집]
function SYS_AT_TIME_ZONE(t timestamp_tz_unconstrained,
i varchar2) RETURN timestamp_tz_unconstrained;
1.204.41 systimestamp[편집]
FUNCTION systimestamp RETURN timestamp_tz_unconstrained;
1.204.42 dbtimezone[편집]
FUNCTION dbtimezone RETURN varchar2;
1.204.43 sessiontimezone[편집]
FUNCTION sessiontimezone RETURN varchar2;
1.204.44 localtimestamp[편집]
FUNCTION localtimestamp RETURN timestamp_unconstrained;
1.204.45 localtime[편집]
FUNCTION localtime RETURN time_unconstrained;
1.204.46 TO_TIMESTAMP[편집]
function TO_TIMESTAMP (RIGHT DATE) return TIMESTAMP_UNCONSTRAINED;
pragma BUILTIN('TO_TIMESTAMP', 0, 15, 17);
1.204.47 '+'(LEFT[편집]
function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT yminterval_unconstrained)
return TIMESTAMP_LTZ_UNCONSTRAINED;
1.204.48 '+'(LEFT[편집]
function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT dsinterval_unconstrained)
return TIMESTAMP_LTZ_UNCONSTRAINED;
1.204.49 '+'(LEFT[편집]
function '+'(LEFT yminterval_unconstrained, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
return TIMESTAMP_LTZ_UNCONSTRAINED ;
1.204.50 '+'(LEFT[편집]
function '+'(LEFT dsinterval_unconstrained, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
return TIMESTAMP_LTZ_UNCONSTRAINED ;
1.204.51 '-'(LEFT[편집]
function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT yminterval_unconstrained)
return TIMESTAMP_LTZ_UNCONSTRAINED ;
1.204.52 '-'(LEFT[편집]
function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT dsinterval_unconstrained)
return TIMESTAMP_LTZ_UNCONSTRAINED ;
1.204.53 [편집]
function SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
return dsinterval_unconstrained;
1.204.54 [편집]
function SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
return yminterval_unconstrained;
1.204.55 '-'(LEFT[편집]
function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
return dsinterval_unconstrained;
1.204.56 '='[편집]
function '=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.57 '!='[편집]
function '!=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.58 '<'[편집]
function '<' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.59 '<='[편집]
function '<=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.60 '>[편집]
function '>' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.61 '>[편집]
function '>=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.62 '='[편집]
function '=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.63 '!='[편집]
function '!=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.64 '<'[편집]
function '<' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.65 '<='[편집]
function '<=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.66 '>[편집]
function '>' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.67 '>[편집]
function '>=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED, RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.68 SYS_LITERALTOYMINTERVAL[편집]
function SYS_LITERALTOYMINTERVAL(numerator varchar2, units varchar2)
return YMINTERVAL_UNCONSTRAINED;
1.204.69 SYS_LITERALTODSINTERVAL[편집]
function SYS_LITERALTODSINTERVAL(numerator varchar2, units varchar2)
return DSINTERVAL_UNCONSTRAINED;
1.204.70 SYS_LITERALTOTIME[편집]
function SYS_LITERALTOTIME(numerator varchar2)
return TIME_UNCONSTRAINED;
1.204.71 SYS_LITERALTOTZTIME[편집]
function SYS_LITERALTOTZTIME(numerator varchar2)
return TIME_TZ_UNCONSTRAINED;
1.204.72 SYS_LITERALTOTIMESTAMP[편집]
function SYS_LITERALTOTIMESTAMP(numerator varchar2)
return TIMESTAMP_UNCONSTRAINED;
1.204.73 SYS_LITERALTOTZTIMESTAMP[편집]
function SYS_LITERALTOTZTIMESTAMP(numerator varchar2)
return TIMESTAMP_TZ_UNCONSTRAINED;
1.204.74 SYS_LITERALTODATE[편집]
function SYS_LITERALTODATE(numerator varchar2) return DATE;

-- Explicit conversions between date and datetime
1.204.75 TO_TIMESTAMP[편집]
function TO_TIMESTAMP(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
return TIMESTAMP_UNCONSTRAINED; pragma BUILTIN('TO_TIMESTAMP', 0, 15, 24);
1.204.76 TO_TIMESTAMP_TZ[편집]
function TO_TIMESTAMP_TZ(ARG DATE) return TIMESTAMP_TZ_UNCONSTRAINED;
pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 27);
1.204.77 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.204.78 'IS[편집]
function 'IS NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
1.204.79 'IS[편집]
function 'IS NOT NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
1.204.80 NVL[편집]
function NVL (b1 TIME_UNCONSTRAINED,
b2 TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
1.204.81 'IS[편집]
function 'IS NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.82 'IS[편집]
function 'IS NOT NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.83 NVL[편집]
function NVL (b1 TIME_TZ_UNCONSTRAINED, b2 TIME_TZ_UNCONSTRAINED)
return TIME_TZ_UNCONSTRAINED;
1.204.84 'IS[편집]
function 'IS NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.85 'IS[편집]
function 'IS NOT NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1.204.86 NVL[편집]
function NVL (b1 TIMESTAMP_UNCONSTRAINED,
b2 TIMESTAMP_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;
1.204.87 'IS[편집]
function 'IS NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.88 'IS[편집]
function 'IS NOT NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1.204.89 NVL[편집]
function NVL (b1 TIMESTAMP_TZ_UNCONSTRAINED, b2 TIMESTAMP_TZ_UNCONSTRAINED)
return TIMESTAMP_TZ_UNCONSTRAINED;
1.204.90 'IS[편집]
function 'IS NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.91 'IS[편집]
function 'IS NOT NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1.204.92 NVL[편집]
function NVL (b1 TIMESTAMP_LTZ_UNCONSTRAINED,
b2 TIMESTAMP_LTZ_UNCONSTRAINED) return TIMESTAMP_LTZ_UNCONSTRAINED;
1.204.93 'IS[편집]
function 'IS NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.94 'IS[편집]
function 'IS NOT NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.95 NVL[편집]
function NVL (b1 YMINTERVAL_UNCONSTRAINED, b2 YMINTERVAL_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED;
1.204.96 'IS[편집]
function 'IS NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.97 'IS[편집]
function 'IS NOT NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1.204.98 NVL[편집]
function NVL (b1 DSINTERVAL_UNCONSTRAINED, b2 DSINTERVAL_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED;
1.204.99 [편집]
function SYS$EXTRACT_FROM" (T TIME_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1.205 ==[편집]
function SYS$EXTRACT_FROM" (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
1.206 ==[편집]
function SYS$EXTRACT_FROM" (T TIMESTAMP_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1.207 ==[편집]
function SYS$EXTRACT_FROM" (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1.208 ==[편집]
function SYS$EXTRACT_FROM" (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
1.209 ==[편집]
function SYS$EXTRACT_FROM" (T DATE,FIELD VARCHAR2) return NUMBER;
1.210 ==[편집]
function SYS$EXTRACT_FROM" (I YMINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1.211 ==[편집]
function SYS$EXTRACT_FROM" (I DSINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
-- ########## 8.2 LOB Built-in Functions ######## --
-- LENGTH --
1.211.1 LENGTH[편집]
function LENGTH(ch CLOB CHARACTER SET ANY_CS) return integer;
pragma FIPSFLAG('LENGTH', 1452);
1.211.2 LENGTHB[편집]
function LENGTHB(ch CLOB CHARACTER SET ANY_CS) return integer;
pragma FIPSFLAG('LENGTHB', 1452);
1.211.3 LENGTH[편집]
function LENGTH(bl BLOB) return integer;
pragma FIPSFLAG('LENGTH', 1452);
1.211.4 LENGTHB[편집]
function LENGTHB(bl BLOB) return integer;
pragma FIPSFLAG('LENGTHB', 1452);
-- SUBSTR --
1.211.5 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.211.6 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.211.7 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.211.8 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.211.9 '||'[편집]
function '||' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET LEFT%CHARSET; pragma FIPSFLAG('||', 1454);
1.211.10 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.211.11 UPPER[편집]
function UPPER(ch CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET ch%CHARSET; pragma FIPSFLAG('UPPER', 1452);
-- LOWER --
1.211.12 LOWER[편집]
function LOWER(ch CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET ch%CHARSET; pragma FIPSFLAG('LOWER', 1452);
-- LPAD --
1.211.13 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.211.14 LPAD[편집]
function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
LEN integer) return CLOB CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('LPAD', 1452);
-- RPAD --
1.211.15 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.211.16 RPAD[편집]
function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
LEN integer) return CLOB CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('RPAD', 1452);
-- LTRIM --
1.211.17 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.211.18 LTRIM[편집]
function LTRIM(STR1 CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('LTRIM', 1452);
-- RTRIM --
1.211.19 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.211.20 RTRIM[편집]
function RTRIM(STR1 CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET STR1%CHARSET; pragma FIPSFLAG('RTRIM', 1452);
-- TRIM --
1.211.21 TRIM[편집]
function TRIM(v CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET v%CHARSET;
-- This is for TRIM(x). No trim set.
1.212 ==[편집]
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.213 ==[편집]
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.214 ==[편집]
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.214.1 'LIKE[편집]
function 'LIKE' (str CLOB CHARACTER SET ANY_CS, pat CLOB CHARACTER SET str%CHARSET)
return BOOLEAN;
1.214.2 'NOT_LIKE[편집]
function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS, pat CLOB CHARACTER SET str%CHARSET)
return BOOLEAN;
1.214.3 'LIKE[편집]
function 'LIKE' (str CLOB CHARACTER SET ANY_CS, pat CLOB CHARACTER SET str%CHARSET, esc VARCHAR2 CHARACTER SET str%CHARSET)
return BOOLEAN;
1.214.4 '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.214.5 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.214.6 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.214.7 '='[편집]
Function '=' (LEFT CLOB CHARACTER SET ANY_CS,
RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.8 '!='[편집]
Function '!=' (LEFT CLOB CHARACTER SET ANY_CS,
RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.9 '>[편집]
Function '>' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.10 '<'[편집]
Function '<' (LEFT CLOB CHARACTER SET ANY_CS,
RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.11 '>[편집]
Function '>=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.12 '<='[편집]
Function '<=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.13 '='[편집]
Function '=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.14 '!='[편집]
Function '!=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.15 '>[편집]
Function '>' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.16 '<'[편집]
Function '<' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.17 '>[편집]
Function '>=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.18 '<='[편집]
Function '<=' (LEFT CLOB CHARACTER SET ANY_CS, RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1.214.19 '='[편집]
Function '=' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.20 '!='[편집]
Function '!=' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.21 '>[편집]
Function '>' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.22 '<'[편집]
Function '<' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.23 '>[편집]
Function '>=' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1.214.24 '<='[편집]
Function '<=' (LEFT VARCHAR2 CHARACTER SET ANY_CS, RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
/* LOB-related conversion functions */
1.214.25 TO_CLOB[편집]
function TO_CLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS) return CLOB;
pragma BUILTIN('TO_CLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
1.214.26 TO_BLOB[편집]
function TO_BLOB(RIGHT RAW) return BLOB;
pragma BUILTIN('TO_BLOB', 0, 15, 30); -- OPC_CVT_RAW2BLB
1.214.27 TO_RAW[편집]
function TO_RAW(RIGHT BLOB) return RAW;
pragma BUILTIN('TO_RAW', 0, 15, 32); -- OPC_CVT_BLB2RAW
-- ####### end of 8.2 LOB Built-in Functions ######## --
1.214.28 NULLIF[편집]
function NULLIF(v1 VARCHAR2, v2 VARCHAR2) return VARCHAR2;
1.214.29 NULLIF[편집]
function NULLIF(v1 BOOLEAN, v2 BOOLEAN) return BOOLEAN;
1.214.30 NULLIF[편집]
function NULLIF(a1 "<ADT_1>", a2 "<ADT_1>") return "<ADT_1>";
1.214.31 COALESCE[편집]
function COALESCE return VARCHAR2;
/* Daylight Saving Time Functions */
1.214.32 tz_offset[편집]
FUNCTION tz_offset(region VARCHAR2) RETURN VARCHAR2;
1.214.33 from_tz[편집]
FUNCTION from_tz(t TIMESTAMP_UNCONSTRAINED,timezone VARCHAR2)
RETURN timestamp_tz_unconstrained;
1.214.34 [편집]
function SYS$EXTRACT_STRING_FROM" (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
1.215 ==[편집]
function SYS$EXTRACT_STRING_FROM" (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return VARCHAR2;
1.216 ==[편집]
function SYS$EXTRACT_STRING_FROM" (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
1.216.1 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.216.2 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.216.3 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.216.4 LENGTH2[편집]
function LENGTH2(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
pragma FIPSFLAG('LENGTH2', 1452);
1.216.5 LENGTH4[편집]
function LENGTH4(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
pragma FIPSFLAG('LENGTH4', 1452);
1.216.6 LENGTHC[편집]
function LENGTHC(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
pragma FIPSFLAG('LENGTHC', 1452);
1.216.7 'LIKE2[편집]
function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.8 'NOT_LIKE2[편집]
function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.9 'LIKE2[편집]
function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET, esc VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.10 '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.216.11 'LIKE4[편집]
function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.12 'NOT_LIKE4[편집]
function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.13 'LIKE4[편집]
function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET, esc VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.14 '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.216.15 'LIKEC[편집]
function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.16 'NOT_LIKEC[편집]
function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.17 'LIKEC[편집]
function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
pat VARCHAR2 CHARACTER SET str%CHARSET, esc VARCHAR2 CHARACTER SET str%CHARSET) return BOOLEAN;
1.216.18 '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.216.19 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.216.20 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.216.21 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);
/**** char <--> nchar conversion functions in Unicode project ********/
1.216.22 TO_NCHAR[편집]
function TO_NCHAR(RIGHT NVARCHAR2) return NVARCHAR2;
pragma BUILTIN('TO_NCHAR',14, 0, 2);
1.216.23 TO_NCLOB[편집]
function TO_NCLOB(cl CLOB CHARACTER SET ANY_CS) return NCLOB;
1.216.24 TO_CLOB[편집]
function TO_CLOB(cl CLOB CHARACTER SET ANY_CS) return CLOB;
1.216.25 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.216.26 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
/* Followings are the same builtin op codes as without N prefix functions, * implementation relys on impilcit conversion MCODEs */
1.216.27 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.216.28 TO_NCHAR[편집]
function TO_NCHAR (LEFT NUMBER, FORMAT NVARCHAR2) return NVARCHAR2;
pragma BUILTIN('TO_NCHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
1.216.29 NHEXTORAW[편집]
function NHEXTORAW (c NVARCHAR2) return RAW;
pragma builtin('NHEXTORAW', 1, 23, 1);
1.216.30 RAWTONHEX[편집]
function RAWTONHEX (r RAW) return NVARCHAR2;
pragma builtin('RAWTONHEX', 1, 23, 2);
1.216.31 NCHARTOROWID[편집]
function NCHARTOROWID (str NVARCHAR2) return ROWID;
pragma builtin('NCHARTOROWID', 1, 0, 1);
1.216.32 ROWIDTONCHAR[편집]
function ROWIDTONCHAR (str ROWID) return NVARCHAR2;
pragma builtin('ROWIDTONCHAR', 1, 0, 1);
1.216.33 NCHR[편집]
function NCHR(n integer) return NVARCHAR2;
/* implemented by icd calls as the same as TO_CHAR */
1.216.34 TO_NCHAR[편집]
function TO_NCHAR(left date, format nvarchar2, parms nvarchar2)
return nvarchar2;
1.216.35 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.216.36 ISNCHAR[편집]
function ISNCHAR(c VARCHAR2 character set any_cs) return boolean;
/************ end of char <--> nchar conversion functions ************/
/* Create overloads for all standard functions that work with <ADT_1> for <OPAQUE_1> */
1.216.37 '='[편집]
function '=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('=', 1, 1, 1); pragma FIPSFLAG('=', 1450);
1.216.38 '!='[편집]
function '!=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('!=', 1, 1, 1); pragma FIPSFLAG('!=', 1450);
1.216.39 '<'[편집]
function '<' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('<', 1, 1, 1); pragma FIPSFLAG('<', 1450);
1.216.40 '<='[편집]
function '<=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('<=', 1, 1, 1); pragma FIPSFLAG('<=', 1450);
1.216.41 '>[편집]
function '>' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('>', 1, 1, 1); pragma FIPSFLAG('>', 1450);
1.216.42 '>[편집]
function '>=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('>=', 1, 1, 1); pragma FIPSFLAG('>=', 1450);
1.216.43 '=ANY'[편집]
function '=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.44 '!=ANY[편집]
function '!=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.45 '<ANY[편집]
function '<ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.46 '<=ANY[편집]
function '<=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.47 '>[편집]
function '>ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.48 '>[편집]
function '>=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.49 '=ALL[편집]
function '=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.50 '!=ALL[편집]
function '!=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.51 '<ALL[편집]
function '<ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.52 '<=ALL[편집]
function '<=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.53 '>[편집]
function '>ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.54 '>[편집]
function '>=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.55 '=SOME[편집]
function '=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.56 '!=SOME[편집]
function '!=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.57 '<SOME[편집]
function '<SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.58 '<=SOME[편집]
function '<=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.59 '>[편집]
function '>SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
1.216.60 '>[편집]
function '>=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
-- Outer Join
1.216.61 '(+[편집]
function '(+)' ( colname "<OPAQUE_1>") return "<OPAQUE_1>";
pragma FIPSFLAG('(+)', 1450);
-- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
1.216.62 GREATEST[편집]
-- function GREATEST (pattern "<OPAQUE_1>") return "<OPAQUE_1>"; --pragma BUILTIN('GREATEST', 1, 1, 1);
1.216.63 LEAST[편집]
-- function LEAST (pattern "<OPAQUE_1>") return "<OPAQUE_1>"; --pragma BUILTIN('LEAST', 1, 1, 1);
1.216.64 DECODE[편집]
function DECODE (expr "<OPAQUE_1>", pat "<OPAQUE_1>", res "<OPAQUE_1>")
return "<OPAQUE_1>"; pragma BUILTIN('DECODE', 1, 1, 1);
1.216.65 'IS[편집]
function 'IS NULL' (B "<OPAQUE_1>") return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 3, 0); pragma FIPSFLAG('IS NULL', 1450);
1.216.66 '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.216.67 NVL[편집]
function NVL (B1 "<OPAQUE_1>", B2 "<OPAQUE_1>") return "<OPAQUE_1>";
pragma FIPSFLAG('NVL', 1450);
-- REFs to opaques are not supported yet.
1.216.68 VALUE[편집]
-- function VALUE (item "<ADT_WITH_OID>") return "<OPAQUE_1>"; --pragma BUILTIN('VALUE', 1, 1, 1); --pragma FIPSFLAG('VALUE', 1450);
1.216.69 REF[편집]
-- function REF (item "<ADT_WITH_OID>") return REF "<OPAQUE_1>"; --pragma BUILTIN('REF', 1, 1, 1); --pragma FIPSFLAG('REF', 1450);
1.216.70 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.216.71 'IS[편집]
-- function 'IS NULL' (B REF "<OPAQUE_1>") return BOOLEAN; --pragma BUILTIN('IS NULL', 0, 3, 0); --pragma FIPSFLAG('IS NULL', 1450);
1.216.72 'IS[편집]
-- function 'IS NOT NULL' (B REF "<OPAQUE_1>") return BOOLEAN; --pragma FIPSFLAG('IS NOT NULL', 1450);
1.216.73 'IS[편집]
-- function 'IS DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN; --pragma BUILTIN('IS DANGLING', 1, 1, 1); --pragma FIPSFLAG('IS DANGLING', 1450);
1.216.74 '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.216.75 NVL[편집]
-- function NVL (B1 REF "<OPAQUE_1>", B2 REF "<OPAQUE_1>") --return REF "<OPAQUE_1>"; --pragma FIPSFLAG('NVL', 1450);
1.216.76 '='[편집]
-- function '=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>") --return BOOLEAN; --pragma BUILTIN('=', 0, 3, 1); --pragma FIPSFLAG('=', 1450);
1.216.77 '!='[편집]
-- function '!=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>") --return BOOLEAN; --pragma BUILTIN('!=', 0, 3, 2); --pragma FIPSFLAG('!=', 1450);
1.216.78 GROUPING[편집]
function GROUPING(a "<OPAQUE_1>") return NUMBER;
1.216.79 NULLIF[편집]
function NULLIF(a1 "<OPAQUE_1>", a2 "<OPAQUE_1>") RETURN "<OPAQUE_1>";
1.216.80 GREATEST[편집]
function GREATEST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.81 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.216.82 GREATEST[편집]
function GREATEST (pattern TIMESTAMP_UNCONSTRAINED)
return TIMESTAMP_UNCONSTRAINED; pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.83 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.216.84 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.216.85 GREATEST[편집]
function GREATEST (pattern YMINTERVAL_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED; pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.86 GREATEST[편집]
function GREATEST (pattern DSINTERVAL_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED; pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.87 LEAST[편집]
function LEAST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.88 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.216.89 LEAST[편집]
function LEAST (pattern TIMESTAMP_UNCONSTRAINED)
return TIMESTAMP_UNCONSTRAINED; pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.90 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.216.91 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.216.92 LEAST[편집]
function LEAST (pattern YMINTERVAL_UNCONSTRAINED)
return YMINTERVAL_UNCONSTRAINED; pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.93 LEAST[편집]
function LEAST (pattern DSINTERVAL_UNCONSTRAINED)
return DSINTERVAL_UNCONSTRAINED; pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
1.216.94 TO_CHAR[편집]
function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.95 TO_CHAR[편집]
function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2) return VARCHAR2;
1.216.96 TO_CHAR[편집]
function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.97 TO_CHAR[편집]
function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
1.216.98 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.99 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
1.216.100 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.101 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
1.216.102 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.103 TO_CHAR[편집]
function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
1.216.104 TO_CHAR[편집]
function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.105 TO_CHAR[편집]
function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
1.216.106 TO_CHAR[편집]
function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2, parms VARCHAR2) return VARCHAR2;
1.216.107 TO_CHAR[편집]
function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2)
return VARCHAR2;
-- CONVERT FOR LOB --
1.216.108 CONVERT[편집]
function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS, DSTCSN VARCHAR2)
return CLOB CHARACTER SET SRCSTR%CHARSET;
1.216.109 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.216.110 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.216.111 NLS_UPPER[편집]
function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET ch%CHARSET; pragma FIPSFLAG('NLS_UPPER', 1452);
1.216.112 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.216.113 NLS_LOWER[편집]
function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS)
return CLOB CHARACTER SET ch%CHARSET; pragma FIPSFLAG('NLS_LOWER', 1452);
1.216.114 COMPOSE[편집]
function COMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS)
return varchar2 character set ch%charset; pragma FIPSFLAG('COMPOSE', 1452);
1.216.115 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.216.116 SYS_EXTRACT_UTC[편집]
FUNCTION SYS_EXTRACT_UTC(t timestamp_tz_unconstrained)
return TIMESTAMP_UNCONSTRAINED;
-- Begin REGEXP Support (10iR1) --
-- REGEXP_LIKE --
1.216.117 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.216.118 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.216.119 REGEXP_INSTR[편집]
function REGEXP_INSTR(srcstr VARCHAR2 CHARACTER SET ANY_CS,
pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionPLS_INTEGER := 1, occurrence PLS_INTEGER := 1, returnparam PLS_INTEGER := 0, modifierVARCHAR2 DEFAULT NULL, subexpression PLS_INTEGER := 0) return PLS_INTEGER; pragma FIPSFLAG('REGEXP_INSTR', 1452);
1.216.120 REGEXP_INSTR[편집]
function REGEXP_INSTR(srcstr CLOB CHARACTER SET ANY_CS,
pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionINTEGER := 1, occurrence INTEGER := 1, returnparam PLS_INTEGER := 0, modifierVARCHAR2 DEFAULT NULL, subexpression PLS_INTEGER := 0) return INTEGER; pragma FIPSFLAG('REGEXP_INSTR', 1452);

-- REGEXP_SUBSTR --
1.216.121 REGEXP_SUBSTR[편집]
function REGEXP_SUBSTR(srcstr VARCHAR2 CHARACTER SET ANY_CS, pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionPLS_INTEGER := 1, occurrence PLS_INTEGER := 1, modifierVARCHAR2 DEFAULT NULL, subexpression PLS_INTEGER := 0)
return VARCHAR2 CHARACTER SET srcstr%CHARSET; pragma FIPSFLAG('REGEXP_SUBSTR', 1452);
1.216.122 REGEXP_SUBSTR[편집]
function REGEXP_SUBSTR(srcstr CLOB CHARACTER SET ANY_CS, pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionINTEGER := 1, occurrence INTEGER := 1, modifierVARCHAR2 DEFAULT NULL, subexpression PLS_INTEGER := 0)
return CLOB CHARACTER SET srcstr%CHARSET; pragma FIPSFLAG('REGEXP_SUBSTR', 1452);
-- REGEXP_REPLACE --
1.216.123 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,
positionPLS_INTEGER := 1, occurrence PLS_INTEGER := 0, modifierVARCHAR2 DEFAULT NULL)
return VARCHAR2 CHARACTER SET srcstr%CHARSET; pragma FIPSFLAG('REGEXP_REPLACE', 1452);
1.216.124 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,
positionINTEGER := 1, occurrence INTEGER := 0, modifierVARCHAR2 DEFAULT NULL)
return CLOB CHARACTER SET srcstr%CHARSET; pragma FIPSFLAG('REGEXP_REPLACE', 1452);
1.216.125 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,
positionINTEGER := 1, occurrence INTEGER := 0, modifierVARCHAR2 DEFAULT NULL)
return CLOB CHARACTER SET srcstr%CHARSET; pragma FIPSFLAG('REGEXP_REPLACE', 1452);
-- End REGEXP Support --
-- binary_float and binary_double functions and operators.
1.216.126 TO_BINARY_FLOAT[편집]
function TO_BINARY_FLOAT (RIGHT BINARY_FLOAT) RETURN BINARY_FLOAT;
pragma BUILTIN('TO_BINARY_FLOAT',14, 0, 1); -- PEMS_QUICK
1.216.127 TO_BINARY_FLOAT[편집]
function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS, FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
RETURN BINARY_FLOAT;
1.216.128 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.216.129 TO_BINARY_DOUBLE[편집]
function TO_BINARY_DOUBLE (RIGHT BINARY_DOUBLE) RETURN BINARY_DOUBLE;
pragma BUILTIN('TO_BINARY_DOUBLE',14, 0, 1); -- PEMS_QUICK
1.216.130 TO_BINARY_DOUBLE[편집]
function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS, FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
RETURN BINARY_DOUBLE;
1.216.131 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.216.132 'IS NAN[편집]
function 'IS NAN' (N NUMBER) RETURN BOOLEAN;
1.216.133 'IS NAN[편집]
function 'IS NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
1.216.134 'IS NAN[편집]
function 'IS NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
1.216.135 'IS INFINITE[편집]
function 'IS INFINITE' (N NUMBER) RETURN BOOLEAN;
1.216.136 'IS INFINITE[편집]
function 'IS INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
1.216.137 'IS INFINITE[편집]
function 'IS INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
1.216.138 'IS NOT NAN[편집]
function 'IS NOT NAN' (N NUMBER) RETURN BOOLEAN;
1.216.139 'IS IS NOT NAN[편집]
function 'IS NOT NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
1.216.140 'IS IS NOT NAN[편집]
function 'IS NOT NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
1.216.141 'IS NOT INFINITE[편집]
function 'IS NOT INFINITE' (N NUMBER) RETURN BOOLEAN;
1.216.142 'IS NOT INFINITE[편집]
function 'IS NOT INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
1.216.143 'IS NOT INFINITE[편집]
function 'IS NOT INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
1.216.144 TO_CHAR[편집]
function TO_CHAR (left binary_float, format varchar2)
return VARCHAR2;
1.216.145 TO_CHAR[편집]
function TO_CHAR (left binary_double, format varchar2)
return VARCHAR2;
1.216.146 TO_CHAR[편집]
function TO_CHAR(left binary_float, format varchar2, parms varchar2)
return varchar2;
1.216.147 TO_CHAR[편집]
function TO_CHAR(left binary_double, format varchar2, parms varchar2)
return varchar2;
1.216.148 TO_NCHAR[편집]
function TO_NCHAR(left binary_float, format nvarchar2) return NVARCHAR2;
1.216.149 TO_NCHAR[편집]
function TO_NCHAR(left binary_double, format nvarchar2) return NVARCHAR2;
1.216.150 TO_NCHAR[편집]
function TO_NCHAR(left binary_float, format nvarchar2, parms nvarchar2)
return nvarchar2;
1.216.151 TO_NCHAR[편집]
function TO_NCHAR(left binary_double, format nvarchar2, parms nvarchar2)
return nvarchar2;
1.216.152 'REMAINDER[편집]
function 'REMAINDER'(n1 NUMBER, n2 NUMBER) return NUMBER;
pragma FIPSFLAG('REMAINDER', 1452);
1.216.153 REMAINDER[편집]
function REMAINDER(n1 NUMBER, n2 NUMBER) return NUMBER;
pragma FIPSFLAG(REMAINDER, 1452);
1.216.154 'REMAINDER[편집]
function 'REMAINDER'(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('REMAINDER', 1452);
1.216.155 REMAINDER[편집]
function REMAINDER(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG(REMAINDER, 1452);
1.216.156 'REMAINDER[편집]
function 'REMAINDER'(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('REMAINDER', 1452);
1.216.157 REMAINDER[편집]
function REMAINDER(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG(REMAINDER, 1452);
1.216.158 '='[편집]
function '=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('=',2, 2, 15);
1.216.159 '!='[편집]
function '!=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('!=',5, 2, 16); pragma FIPSFLAG('!=', 1452);
1.216.160 '<'[편집]
function '<' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('<',4, 2, 17);
1.216.161 '<='[편집]
function '<=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('<=',6, 2, 18);
1.216.162 '>'[편집]
function '>' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('>',1, 2, 19);
1.216.163 '>='[편집]
function '>=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('>=',3, 2, 20);
1.216.164 'IS[편집]
function 'IS NULL' (n BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0);
1.216.165 'IS[편집]
function 'IS NOT NULL' (n BINARY_FLOAT) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1.216.166 NVL[편집]
function NVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('NVL', 1452);
1.216.167 '+'[편집]
function '+' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('+',14, 0, 1);
1.216.168 '-'[편집]
function '-' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('-',15, 2, 23);
1.216.169 ABS[편집]
function ABS(F BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('ABS', 1452);
1.216.170 '+'[편집]
function '+' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('+',14, 2, 24);
1.216.171 '-'[편집]
function '-' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('-',15, 2, 25);
1.216.172 '*'[편집]
function '*' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('*',17, 2, 26);
1.216.173 '/'[편집]
function '/' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('/',18, 2, 27);
1.216.174 'REM[편집]
function 'REM' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('REM', 1452);
1.216.175 'MOD[편집]
function 'MOD'(F1 BINARY_FLOAT, F2 BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('MOD', 1452);
1.216.176 FLOOR[편집]
function FLOOR(F BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('FLOOR', 1452);
1.216.177 CEIL[편집]
function CEIL(F BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('CEIL', 1452);
1.216.178 SIGN[편집]
function SIGN(f BINARY_FLOAT) return SIGNTYPE;
pragma FIPSFLAG('SIGN', 1452);
1.216.179 SQRT[편집]
function SQRT(f BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('SQRT', 1452);
1.216.180 TRUNC[편집]
function TRUNC (F BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('TRUNC', 1452);
1.216.181 ROUND[편집]
function ROUND (LEFT BINARY_FLOAT) return BINARY_FLOAT;
pragma FIPSFLAG('ROUND', 1452);
1.216.182 '='[편집]
function '=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('=',2, 2, 28);
1.216.183 '!='[편집]
function '!=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
-- also <> and ~= pragma BUILTIN('!=',5, 2, 29); pragma FIPSFLAG('!=', 1452);
1.216.184 '<'[편집]
function '<' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('<',4, 2, 30);
1.216.185 '<='[편집]
function '<=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('<=',6, 2, 31);
1.216.186 '>'[편집]
function '>' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('>',1, 2, 32);
1.216.187 '>='[편집]
function '>=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('>=',3, 2, 33);
1.216.188 'IS[편집]
function 'IS NULL' (n BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0);
1.216.189 'IS[편집]
function 'IS NOT NULL' (n BINARY_DOUBLE) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1.216.190 NVL[편집]
function NVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('NVL', 1452);
1.216.191 '+'[편집]
function '+' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('+',14, 0, 1);
1.216.192 '-'[편집]
function '-' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('-',15, 2, 36);
1.216.193 ABS[편집]
function ABS(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ABS', 1452);
1.216.194 ACOS[편집]
function ACOS(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ACOS', 1452);
1.216.195 ASIN[편집]
function ASIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ASIN', 1452);
1.216.196 ATAN[편집]
function ATAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ATAN', 1452);
1.216.197 ATAN2[편집]
function ATAN2(x BINARY_DOUBLE, y BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ATAN2', 1452);
1.216.198 '+'[편집]
function '+' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('+',14, 2, 37);
1.216.199 '-'[편집]
function '-' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('-',15, 2, 38);
1.216.200 '*'[편집]
function '*' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('*',17, 2, 39);
1.216.201 '/'[편집]
function '/' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('/',18, 2, 40);
1.216.202 'REM[편집]
function 'REM' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
return BINARY_DOUBLE; pragma FIPSFLAG('REM', 1452);
1.216.203 'MOD[편집]
function 'MOD'(D1 BINARY_DOUBLE, D2 BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('MOD', 1452);
1.216.204 '**'[편집]
function '**' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
return BINARY_DOUBLE; pragma FIPSFLAG('**', 1452);
1.216.205 FLOOR[편집]
function FLOOR(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('FLOOR', 1452);
1.216.206 CEIL[편집]
function CEIL(D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('CEIL', 1452);
1.216.207 SQRT[편집]
function SQRT(d BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('SQRT', 1452);
1.216.208 SIGN[편집]
function SIGN(d BINARY_DOUBLE) return SIGNTYPE; pragma FIPSFLAG('SIGN', 1452);
1.216.209 COS[편집]
function COS(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.210 SIN[편집]
function SIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.211 TAN[편집]
function TAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.212 COSH[편집]
function COSH(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.213 SINH[편집]
function SINH(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.214 TANH[편집]
function TANH(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.215 EXP[편집]
function EXP(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.216 LN[편집]
function LN(D BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.217 LOG[편집]
function LOG (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.218 TRUNC[편집]
function TRUNC (D BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('TRUNC', 1452);
1.216.219 ROUND[편집]
function ROUND (LEFT BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('ROUND', 1452);
1.216.220 POWER[편집]
function POWER (d BINARY_DOUBLE, e BINARY_DOUBLE) return BINARY_DOUBLE;
pragma FIPSFLAG('POWER', 1452);
1.216.221 NANVL[편집]
function NANVL(n1 NUMBER, n2 NUMBER) return NUMBER;
1.216.222 NANVL[편집]
function NANVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
1.216.223 NANVL[편집]
function NANVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
1.216.224 GREATEST[편집]
function GREATEST (pattern BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
1.216.225 GREATEST[편집]
function GREATEST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
1.216.226 LEAST[편집]
function LEAST (pattern BINARY_FLOAT) return BINARY_FLOAT;
pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
1.216.227 LEAST[편집]
function LEAST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2

1.216.228 '+'[편집]
function '+' (RIGHT PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
1.216.229 '-'[편집]
function '-' (RIGHT PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('-',15, 2, 41);
1.216.230 ABS[편집]
function ABS(I PLS_INTEGER) return PLS_INTEGER;
pragma FIPSFLAG('ABS', 1452);
1.216.231 '+'[편집]
function '+' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('+',14, 2, 42);
1.216.232 '-'[편집]
function '-' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('-',14, 2, 43);
1.216.233 '*'[편집]
function '*' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('*',14, 2, 44);
1.216.234 '='[편집]
function '=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('=',2, 2, 45); -- PEMS_PLS_INTEGER, PEMDCMEQ
1.216.235 '!='[편집]
function '!=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
-- also <> and ~= pragma BUILTIN('!=',5, 2, 46); -- PEMS_PLS_INTEGER, PEMDCMNE pragma FIPSFLAG('!=', 1452);
1.216.236 '<'[편집]
function '<' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('<',4, 2, 47); -- PEMS_PLS_INTEGER, PEMDCMLT
1.216.237 '<='[편집]
function '<=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('<=',6, 2, 48); -- PEMS_PLS_INTEGER, PEMDCMLE
1.216.238 '>'[편집]
function '>' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('>',1, 2, 49); -- PEMS_PLS_INTEGER, PEMDCMGT
1.216.239 '>='[편집]
function '>=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('>=',3, 2, 51); -- PEMS_PLS_INTEGER, PEMDCMGE
1.216.240 'IS NULL'[편집]
function 'IS NULL' (I PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_PLS_INTEGER, PEMDNUL
1.216.241 'IS NOT NULL'[편집]
function 'IS NOT NULL' (I PLS_INTEGER) return BOOLEAN;
pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_PLS_INTEGER, PEMDNUL
1.216.242 NVL[편집]
function NVL(I1 PLS_INTEGER, I2 PLS_INTEGER) return PLS_INTEGER;
pragma FIPSFLAG('NVL', 1452);
1.216.243 TRUNC[편집]
function TRUNC (i pls_integer, places pls_integer := 0) return pls_integer;
pragma FIPSFLAG('TRUNC', 1452);
1.216.244 ROUND[편집]
function ROUND (i pls_integer, places pls_integer := 0) return pls_integer;
pragma FIPSFLAG('ROUND', 1452);
1.216.245 SIGN[편집]
function SIGN(i PLS_INTEGER) return SIGNTYPE;
pragma FIPSFLAG('SIGN', 1452);
1.216.246 GREATEST[편집]
function GREATEST (pattern PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
1.216.247 LEAST[편집]
function LEAST (pattern PLS_INTEGER) return PLS_INTEGER;
pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
-- MultiSet Functions and Operators.
-- Equality
1.216.248 '='[편집]
function '='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
return BOOLEAN;
pragma BUILTIN('=',2, 16, 1);
1.216.249 '!='[편집]
function '!='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
return BOOLEAN;
pragma BUILTIN('!=',2, 16, 2);
1.216.250 CARDINALITY[편집]
function CARDINALITY (collection IN "<TABLE_1>") return PLS_INTEGER;
1.216.251 SET[편집]
function SET (collection IN "<TABLE_1>") return "<TABLE_1>";
pragma BUILTIN('SET',18, 5, 40);-- Dummy
1.216.252 IS A SET[편집]
function 'IS A SET' (collection IN "<TABLE_1>") return BOOLEAN;
pragma BUILTIN('IS A SET',18, 5, 41);-- Dummy
1.216.253 IS NOT A SET[편집]
function 'IS NOT A SET'(collection IN "<TABLE_1>") return BOOLEAN;
pragma BUILTIN('IS NOT A SET',18, 5, 42);-- Dummy
1.216.254 IS EMPTY[편집]
function 'IS EMPTY' (collection IN "<TABLE_1>") return BOOLEAN;
1.216.255 'IS[편집]
function 'IS NOT EMPTY'(collection IN "<TABLE_1>") return BOOLEAN;
-- IS A SUBMULTISET OF
1.216.256 SUBMULTISET[편집]
function 'SUBMULTISET' (collection IN "<TABLE_1>", collection2 IN "<TABLE_1>")
return BOOLEAN;
pragma BUILTIN('SUBMULTISET',18, 5, 43);
1.216.257 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.216.258 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.216.259 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.216.260 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.216.261 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.216.262 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.216.263 REGEXP_COUNT[편집]
function REGEXP_COUNT(srcstr VARCHAR2 CHARACTER SET ANY_CS,
pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionPLS_INTEGER := 1, modifierVARCHAR2 DEFAULT NULL) return PLS_INTEGER; pragma FIPSFLAG('REGEXP_COUNT', 1452);
function REGEXP_COUNT(srcstr CLOB CHARACTER SET ANY_CS,
pattern VARCHAR2 CHARACTER SET srcstr%CHARSET, positionINTEGER := 1, modifierVARCHAR2 DEFAULT NULL) return INTEGER; pragma FIPSFLAG('REGEXP_COUNT', 1452);
-- 47322: JSON
1.216.264 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.217 ==[편집]
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

Dbcafe (토론 | 기여)님의 2019년 12월 22일 (일) 15:04 판(차이) ← 이전 판 | 최신판 (차이) | 다음 판 → (차이)

목차

1 Oracle Function[편집]

1.1 EXISTS[편집]

1.2 GREATEST[편집]

1.3 GREATEST[편집]

1.4 GREATEST[편집]

1.5 LEAST[편집]

1.6 LEAST[편집]

1.7 LEAST[편집]

1.8 DECODE[편집]

1.9 SQLCODE[편집]

1.10 SQLERRM[편집]

1.11 SQLERRM[편집]

1.12 LEVEL[편집]

1.13 ROWNUM[편집]

1.14 '='[편집]

1.15 '!='[편집]

1.16 '<'[편집]

1.17 '<='[편집]

1.18 '>'[편집]

1.19 '>='[편집]

1.20 XOR[편집]

1.21 NOT[편집]

1.22 IS NULL[편집]

1.23 IS NOT NULL[편집]

1.24 NVL[편집]

1.25 '='[편집]

1.26 '!='[편집]

1.27 '<'[편집]

1.28 '<='[편집]

1.29 '>[편집]

1.30 '>[편집]

1.31 '||'[편집]

1.32 CONCAT[편집]

1.33 LENGTH[편집]

1.34 SUBSTR[편집]

1.35 INSTR[편집]

1.36 UPPER[편집]

1.37 LOWER[편집]

1.38 ASCII[편집]

1.39 ASCIISTR[편집]

1.40 UNISTR[편집]

1.41 CHR[편집]

1.42 [편집]

1.43 INITCAP[편집]

1.44 SOUNDEX[편집]

1.45 LPAD[편집]

1.46 LPAD[편집]

1.47 RPAD[편집]

1.48 RPAD[편집]

1.49 TRANSLATE[편집]

1.50 REPLACE[편집]

1.51 LTRIM[편집]

1.52 LTRIM[편집]

1.53 RTRIM[편집]

1.54 RTRIM[편집]

1.55 LIKE[편집]

1.56 NOT_LIKE[편집]

1.57 LIKE[편집]

1.58 NOT_LIKE[편집]

1.59 IS[편집]

1.60 IS[편집]

1.61 NVL[편집]

1.62 '='[편집]

1.63 '!='[편집]

1.64 '<'[편집]

1.65 '<='[편집]

1.66 '>'[편집]

1.67 '>='[편집]

1.68 IS NULL[편집]

1.69 IS NOT NULL[편집]

1.70 NVL[편집]

1.71 '+'[편집]

1.72 '-'[편집]

1.73 ABS[편집]

1.74 '+'[편집]

1.75 '-'[편집]

Dbcafe (토론 | 기여)님의 2019년 12월 22일 (일) 15:04 판
(차이) ← 이전 판 | 최신판 (차이) | 다음 판 → (차이)