|
|
| (같은 사용자의 중간 판 22개는 보이지 않습니다) |
| 1번째 줄: |
1번째 줄: |
| − | == Oracle Function == | + | === 함수 === |
| | + | #[[LNNVL 함수|LNNVL]] |
| | + | #[[오라클 nvl nvl2|NVL 과 NVL2]] |
| | + | #[[오라클 COALESCE|COALESCE]] |
| | + | #[[오라클 concat 함수|CONCAT]] |
| | + | #[[오라클 distinct 함수|DISTINCT]] |
| | + | #[[오라클 listagg 함수|LISTAGG]] |
| | + | #[[oracle translate 함수|TRANSLATE]] |
| | + | #[[ORACLE XMLAGG|XMLAGG]] |
| | + | ---- |
| | | | |
| − | ==== EXISTS ==== | + | === 그룹 함수 === |
| − | function EXISTS" return BOOLEAN;
| + | # [[ROLLUP]] |
| − | pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj
| + | # [[ROLLUP#GROUPING SETS|GROUPING SETS]] |
| | + | # [[Pivot|피봇(PIVOT)]] |
| | + | # [[Pivot#UNPIVOT|언피봇(UNPIVOT)]] |
| | + | ---- |
| | | | |
| − | ==== GREATEST ==== | + | === [[:분석함수#윈도우/분석 함수|윈도우/분석 함수]] === |
| − | function GREATEST (pattern NUMBER) return NUMBER;
| + | # [[:분석함수#OVER|OVER ]] |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| + | ## [[:분석함수#ROWS UNBOUNDED PRECEDING |ROWS UNBOUNDED PRECEDING ]] |
| − | ==== GREATEST ====
| + | ## [[:분석함수#ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW |ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW ]] |
| − | function GREATEST (pattern VARCHAR2 CHARACTER SET ANY_CS)
| + | ## [[:분석함수#WINDOW 물리적 범위 |WINDOW 물리적 범위 ]] |
| − | return VARCHAR2 CHARACTER SET pattern%CHARSET;
| + | ## [[:분석함수#WINDOW 논리적 범위 |WINDOW 논리적 범위 ]] |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| + | # [[:분석함수#CUME_DIST|CUME_DIST ]] |
| − | ==== GREATEST ====
| + | # [[:분석함수#DENSE_RANK|DENSE_RANK ]] |
| − | function GREATEST (pattern DATE) return DATE;
| + | # [[:분석함수#FIRST_VALUE|FIRST_VALUE ]] |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| + | # [[:분석함수#LAG|LAG ]] |
| − | | + | # [[:분석함수#LAST_VALUE|LAST_VALUE ]] |
| − | ==== LEAST ====
| + | # [[:분석함수#LEAD|LEAD ]] |
| − | function LEAST (pattern NUMBER) return NUMBER;
| + | # [[:분석함수#NTH_VALUE|NTH_VALUE ]] |
| − | pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
| + | # [[:분석함수#NTILE|NTILE ]] |
| − | ==== LEAST ====
| + | # [[:분석함수#PERCENT_RANK|PERCENT_RANK ]] |
| − | function LEAST (pattern VARCHAR2 CHARACTER SET ANY_CS)
| + | # [[:분석함수#RANK|RANK ]] |
| − | return VARCHAR2 CHARACTER SET pattern%CHARSET;
| + | # [[:분석함수#ROW_NUMBER|ROW_NUMBER ]] |
| − | pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
| + | # [[:분석함수#ROW_NUMBER VS RANK|ROW_NUMBER vs. RANK ]] |
| − | ==== LEAST ====
| + | # [[:분석함수#COUNT|COUNT ]] |
| − | function LEAST (pattern DATE) return DATE;
| + | # [[:분석함수#SUM|SUM ]] |
| − | pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
| + | # [[:분석함수#LAG 함수와 LEAD 함수|LAG 함수와 LEAD 함수 ]] |
| − | | + | # [[:분석함수#분석함수의 활용|분석함수의 활용]] |
| − | ==== DECODE ====
| + | ## [[:분석함수#1:M 관계의 조인에서 부모테이블이 기준집합|1:M 관계의 조인에서 부모테이블이 기준집합 ]] |
| − | function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
| + | ## [[:분석함수#집계 연산|집계 연산 ]] |
| − | pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
| + | ---- |
| − | | + | [[category:oracle]] |
| − | 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
| |
| − | | |
| − | ==== SQLCODE ====
| |
| − | function SQLCODE return PLS_INTEGER;
| |
| − | pragma BUILTIN('SQLCODE',45, 10, 0); -- PEMS_DB, DB_SQLCODE
| |
| − | | |
| − | ==== SQLERRM ====
| |
| − | function SQLERRM return varchar2;
| |
| − | pragma FIPSFLAG('SQLERRM', 1452);
| |
| − | | |
| − | ==== SQLERRM ====
| |
| − | function SQLERRM (code PLS_INTEGER) return varchar2;
| |
| − | pragma BUILTIN('SQLERRM',46, 10, 1); -- PEMS_DB, DB_SQLERRM
| |
| − | pragma FIPSFLAG('SQLERRM', 1452);
| |
| − | | |
| − | ==== LEVEL ====
| |
| − | function LEVEL return NUMBER;
| |
| − | | |
| − | ==== ROWNUM ====
| |
| − | function ROWNUM return NUMBER;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 3, 1); -- PEMS_INTEGER, PEMDCMEQ
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN; -- also <> and ~=
| |
| − | pragma BUILTIN('!=',5, 3, 2); -- PEMS_INTEGER, PEMDCMNE
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 3, 3); -- PEMS_INTEGER, PEMDCMLT
| |
| − | pragma FIPSFLAG('<', 1450);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 3, 4); -- PEMS_INTEGER, PEMDCMLE
| |
| − | pragma FIPSFLAG('<=', 1450);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 3, 5); -- PEMS_INTEGER, PEMDCMGT
| |
| − | pragma FIPSFLAG('>', 1450);
| |
| − | ==== '>=' ====
| |
| − | 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.
| |
| − | | |
| − | ==== XOR ====
| |
| − | function XOR (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('XOR',8, 3, 9); -- PEMS_INTEGER, INT_XOR
| |
| − | pragma FIPSFLAG('XOR', 1450);
| |
| − | | |
| − | ==== NOT ====
| |
| − | function 'NOT' (RIGHT BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('NOT',9, 3, 10); -- PEMS_INTEGER, INT_NOT
| |
| − | | |
| − | ==== IS NULL ====
| |
| − | function 'IS NULL' (B BOOLEAN) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0); -- PEMS_INTEGER, PEMDNUL
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL (B1 BOOLEAN, B2 BOOLEAN) return BOOLEAN;
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== '=' ====
| |
| − | 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);
| |
| − | ==== '!=' ====
| |
| − | 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);
| |
| − | ==== '<' ====
| |
| − | 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);
| |
| − | ==== '<=' ====
| |
| − | 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);
| |
| − | ==== '>'' ====
| |
| − | 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);
| |
| − | ==== '>'' ====
| |
| − | 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);
| |
| − | | |
| − | ==== '||' ====
| |
| − | 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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.
| |
| − | ==== 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
| |
| − | ==== 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);
| |
| − | | |
| − | ==== UPPER ====
| |
| − | function UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('UPPER', 1452);
| |
| − | ==== LOWER ====
| |
| − | function LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('LOWER', 1452);
| |
| − | ==== ASCII ====
| |
| − | function ASCII(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return INTEGER; -- should be ASCII.CHRANGE
| |
| − | pragma FIPSFLAG('ASCII', 1452);
| |
| − | ==== ASCIISTR ====
| |
| − | function ASCIISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('ASCIISTR', 1452);
| |
| − | ==== UNISTR ====
| |
| − | function UNISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return NVARCHAR2;
| |
| − | pragma FIPSFLAG('UNISTR', 1452);
| |
| − | ==== CHR ====
| |
| − | function CHR(n INTEGER) return varchar2; -- N should be ASCII.CHRANGE
| |
| − | pragma FIPSFLAG('CHR', 1452);
| |
| − | ==== ====
| |
| − | function SYS$STANDARD_CHR"(n INTEGER,csn VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET csn%CHARSET;
| |
| − | pragma FIPSFLAG(' SYS$STANDARD_CHR', 1452);
| |
| − | ==== INITCAP ====
| |
| − | function INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('INITCAP', 1452);
| |
| − | ==== SOUNDEX ====
| |
| − | function SOUNDEX(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('SOUNDEX', 1452);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== LPAD ====
| |
| − | function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | LEN pls_integer)
| |
| − | return VARCHAR2 CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('LPAD', 1452);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== RPAD ====
| |
| − | function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | LEN pls_integer)
| |
| − | return VARCHAR2 CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('RPAD', 1452);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== LTRIM ====
| |
| − | function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
| |
| − | return VARCHAR2 CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('LTRIM', 1452);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== RTRIM ====
| |
| − | function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
| |
| − | return VARCHAR2 CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('RTRIM', 1452);
| |
| − | | |
| − | ==== LIKE ====
| |
| − | function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== NOT_LIKE ====
| |
| − | function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== LIKE ====
| |
| − | function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET,
| |
| − | esc VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 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;
| |
| − | ==== IS ====
| |
| − | function 'IS NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 1, 20); -- PEMS_CHAR, PEMDNUL
| |
| − | ==== IS ====
| |
| − | function 'IS NOT NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 1, 50); -- PEMS_CHAR, PEMDNUL
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 2, 1); -- PEMS_NUMBER, PEMDCMEQ
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN; -- also <> and ~=
| |
| − | pragma BUILTIN('!=',5, 2, 2); -- PEMS_NUMBER, PEMDCMNE
| |
| − | pragma FIPSFLAG('!=', 1452);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 2, 3); -- PEMS_NUMBER, PEMDCMLT
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 2, 4); -- PEMS_NUMBER, PEMDCMLE
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 2, 5); -- PEMS_NUMBER, PEMDCMGT
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',3, 2, 6); -- PEMS_NUMBER, PEMDCMGE
| |
| − | | |
| − | ==== IS NULL ====
| |
| − | function 'IS NULL' (n NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
| |
| − | ==== IS NOT NULL ====
| |
| − | function 'IS NOT NULL' (n NUMBER) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_NUMBER, PEMDNUL
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL(n1 NUMBER, n2 NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('NVL', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
| |
| − | ==== '-' ====
| |
| − | function '-' (RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('-',15, 2, 7); -- PEMS_NUMBER, NUM_NEG
| |
| − | ==== ABS ====
| |
| − | function ABS(n NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('ABS', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('+',14, 2, 8); -- PEMS_NUMBER, NUM_ADD
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('-',15, 2, 9); -- PEMS_NUMBER, NUM_SUB
| |
| − | ==== '*' ====
| |
| − | function '*' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('*',17, 2, 10); -- PEMS_NUMBER, NUM_MUL
| |
| − | ==== '/' ====
| |
| − | function '/' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma BUILTIN('/',18, 2, 11); -- PEMS_NUMBER, NUM_DIV
| |
| − | | |
| − | ==== REM ====
| |
| − | function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('REM', 1452);
| |
| − | ==== MOD ====
| |
| − | function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('MOD', 1452);
| |
| − | | |
| − | ==== '**' ====
| |
| − | function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('**', 1452);
| |
| − | | |
| − | ==== FLOOR ====
| |
| − | function FLOOR(n NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('FLOOR', 1452);
| |
| − | ==== CEIL ====
| |
| − | function CEIL(n NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('CEIL', 1452);
| |
| − | ==== SQRT ====
| |
| − | function SQRT(n NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('SQRT', 1452);
| |
| − | ==== SIGN ====
| |
| − | function SIGN(n NUMBER) return SIGNTYPE;
| |
| − | pragma FIPSFLAG('SIGN', 1452);
| |
| − | | |
| − | ==== COS ====
| |
| − | function COS(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('COS', 1452);
| |
| − | ==== SIN ====
| |
| − | function SIN(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('SIN', 1452);
| |
| − | ==== TAN ====
| |
| − | function TAN(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('TAN', 1452);
| |
| − | ==== COSH ====
| |
| − | function COSH(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('COSH', 1452);
| |
| − | ==== SINH ====
| |
| − | function SINH(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('SINH', 1452);
| |
| − | ==== TANH ====
| |
| − | function TANH(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('TANH', 1452);
| |
| − | | |
| − | ==== EXP ====
| |
| − | function EXP(N NUMBER) return NUMBER;
| |
| − | ==== LN ====
| |
| − | function LN(N NUMBER) return NUMBER;
| |
| − | | |
| − | ==== BITAND ====
| |
| − | function BITAND (LEFT pls_integer, RIGHT pls_integer)
| |
| − | return pls_integer;
| |
| − | ==== BITAND ====
| |
| − | function BITAND (LEFT number, RIGHT number)
| |
| − | return number;
| |
| − | ==== LOG ====
| |
| − | function LOG (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
| |
| − | | |
| − | ==== TRUNC ====
| |
| − | function TRUNC (n NUMBER, places pls_integer := 0) return NUMBER;
| |
| − | pragma FIPSFLAG('TRUNC', 1452);
| |
| − | | |
| − | ==== ROUND ====
| |
| − | function ROUND (LEFT NUMBER, RIGHT pls_integer := 0) return NUMBER;
| |
| − | pragma FIPSFLAG('ROUND', 1452);
| |
| − | | |
| − | ==== POWER ====
| |
| − | function POWER (n NUMBER, e NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('POWER', 1452);
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 12, 1); -- PEMS_DATE, PEMDCMEQ
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT DATE, RIGHT DATE) return BOOLEAN; -- also <> and ~=
| |
| − | pragma BUILTIN('!=',5, 12, 2); -- PEMS_DATE, PEMDCMNE
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 12, 3); -- PEMS_DATE, PEMDCMLT
| |
| − | pragma FIPSFLAG('<', 1450);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 12, 4); -- PEMS_DATE, PEMDCMLE
| |
| − | pragma FIPSFLAG('<=', 1450);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 12, 5); -- PEMS_DATE, PEMDCMGT
| |
| − | pragma FIPSFLAG('>', 1450);
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',3, 12, 6); -- PEMS_DATE, PEMDCMGE
| |
| − | pragma FIPSFLAG('>=', 1450);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (LEFT DATE, RIGHT NUMBER) return DATE;
| |
| − | pragma BUILTIN('+',14, 12, 7); -- PEMS_DATE, DATE_ADD1
| |
| − | pragma FIPSFLAG('+', 1450);
| |
| − | ==== '+' ====
| |
| − | function '+' (LEFT NUMBER, RIGHT DATE) return DATE;
| |
| − | pragma BUILTIN('+',14, 12, 8); -- PEMS_DATE, DATE_ADD2
| |
| − | pragma FIPSFLAG('+', 1450);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT DATE, RIGHT NUMBER) return DATE;
| |
| − | pragma BUILTIN('-',15, 12, 9); -- PEMS_DATE, DATE_SUB1
| |
| − | pragma FIPSFLAG('-', 1450);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT NUMBER, RIGHT DATE) return DATE;
| |
| − | pragma BUILTIN('-',15, 12, 10); -- PEMS_DATE, DATE_SUB2
| |
| − | pragma FIPSFLAG('-', 1450);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT DATE, RIGHT DATE) return NUMBER;
| |
| − | pragma BUILTIN('-',15, 12, 11); -- PEMS_DATE, DATE_SUB3
| |
| − | pragma FIPSFLAG('-', 1450);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== 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);
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== 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);
| |
| − | ==== ROUND ====
| |
| − | function ROUND(RIGHT DATE) return DATE;
| |
| − | pragma BUILTIN('ROUND',24, 12, 17); -- PEMS_DATE, DATE_ROUND
| |
| − | pragma FIPSFLAG('ROUND', 1450);
| |
| − | ==== NEW_TIME ====
| |
| − | function NEW_TIME(RIGHT DATE, MIDDLE VARCHAR2, LEFT VARCHAR2) return DATE;
| |
| − | pragma FIPSFLAG('NEW_TIME', 1450);
| |
| − | | |
| − | ==== IS NULL ====
| |
| − | function 'IS NULL' (d DATE) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 12, 0); -- PEMS_DATE, PEMDNUL
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | ==== 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);
| |
| − | ==== NVL ====
| |
| − | function NVL (d1 DATE, d2 DATE) return DATE;
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== TRUNC ====
| |
| − | function TRUNC(LEFT DATE) return DATE;
| |
| − | pragma BUILTIN('TRUNC',51, 12, 20); -- PEMS_DATE, DATE_TRUNC1
| |
| − | pragma FIPSFLAG('TRUNC', 1450);
| |
| − | ==== TRUNC ====
| |
| − | function TRUNC(LEFT DATE, RIGHT VARCHAR2) return DATE;
| |
| − | pragma BUILTIN('TRUNC',51, 12, 21); -- PEMS_DATE, DATE_TRUNC2
| |
| − | pragma FIPSFLAG('TRUNC', 1450);
| |
| − | ==== ROUND ====
| |
| − | function ROUND(LEFT DATE, RIGHT VARCHAR2) return DATE;
| |
| − | pragma BUILTIN('ROUND',24, 12, 22); -- PEMS_DATE, DATE_ROUND2
| |
| − | pragma FIPSFLAG('ROUND', 1450);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== TO_DATE ====
| |
| − | function TO_DATE (LEFT NUMBER, RIGHT VARCHAR2) return DATE;
| |
| − | pragma FIPSFLAG('TO_DATE', 1450);
| |
| − | | |
| − | ==== 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;
| |
| − | | |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR (RIGHT VARCHAR2) return VARCHAR2;
| |
| − | pragma BUILTIN('TO_CHAR',14, 0, 2);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR (LEFT NUMBER, RIGHT VARCHAR2) return VARCHAR2;
| |
| − | pragma BUILTIN('TO_CHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
| |
| − | | |
| − | ==== TO_NUMBER ====
| |
| − | function TO_NUMBER (RIGHT NUMBER) RETURN NUMBER;
| |
| − | pragma BUILTIN('TO_NUMBER',14, 0, 1); -- PEMS_QUICK
| |
| − | | |
| − | ==== 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
| |
| − | | |
| − | ==== TO_NUMBER ====
| |
| − | function TO_NUMBER(left varchar2 character set any_cs,
| |
| − | format varchar2 character set LEFT%charset)
| |
| − | return number;
| |
| − | ==== 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.
| |
| − | | |
| − | ==== call ====
| |
| − | -- PRIOR is WEIRD - For now, it will be treated as a function call.
| |
| − | ==== only ====
| |
| − | -- Does the function only take a column name? how about its use in
| |
| − | -- a predicate?
| |
| − | ==== PRIOR ====
| |
| − | function 'PRIOR'(colname VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET colname%CHARSET;
| |
| − | pragma FIPSFLAG('PRIOR', 1452);
| |
| − | ==== PRIOR ====
| |
| − | function 'PRIOR'(colname NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('PRIOR', 1452);
| |
| − | ==== PRIOR ====
| |
| − | function 'PRIOR'(colname DATE) return DATE;
| |
| − | pragma FIPSFLAG('PRIOR', 1450);
| |
| − | | |
| − | -- Outer Join has same problem as PRIOR
| |
| − | ==== '(+)' ====
| |
| − | function '(+)'(colname VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET colname%CHARSET;
| |
| − | ==== '(+)' ====
| |
| − | function '(+)'(colname NUMBER) return NUMBER;
| |
| − | ==== '(+)' ====
| |
| − | function '(+)'(colname DATE) return DATE;
| |
| − | pragma FIPSFLAG('(+)', 1450);
| |
| − | | |
| − | ==== '=ANY' ====
| |
| − | function '=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '=ANY' ====
| |
| − | function '=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('=ANY', 1450);
| |
| − | ==== '=ANY' ====
| |
| − | function '=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '!=ANY' ====
| |
| − | function '!=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '!=ANY' ====
| |
| − | function '!=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('!=ANY', 1450);
| |
| − | ==== '!=ANY' ====
| |
| − | function '!=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<ANY' ====
| |
| − | function '<ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<ANY' ====
| |
| − | function '<ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<ANY', 1450);
| |
| − | ==== '<ANY' ====
| |
| − | function '<ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<=ANY' ====
| |
| − | function '<=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<=ANY' ====
| |
| − | function '<=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<=ANY', 1450);
| |
| − | ==== '<=ANY' ====
| |
| − | function '<=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>ANY' ====
| |
| − | function '>ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>ANY' ====
| |
| − | function '>ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>ANY', 1450);
| |
| − | ==== '> ====
| |
| − | function '>ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>=ANY' ====
| |
| − | function '>=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>=ANY' ====
| |
| − | function '>=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>=ANY', 1450);
| |
| − | ==== '>=ANY' ====
| |
| − | function '>=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '=ALL' ====
| |
| − | function '=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '=ALL' ====
| |
| − | function '=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('=ALL', 1450);
| |
| − | ==== '=ALL' ====
| |
| − | function '=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '!=ALL' ====
| |
| − | function '!=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '!=ALL' ====
| |
| − | function '!=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('!=ALL', 1450);
| |
| − | ==== '!=ALL' ====
| |
| − | function '!=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<ALL' ====
| |
| − | function '<ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<ALL' ====
| |
| − | function '<ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<ALL', 1450);
| |
| − | ==== '<ALL' ====
| |
| − | function '<ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<=ALL' ====
| |
| − | function '<=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<=ALL' ====
| |
| − | function '<=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<=ALL', 1450);
| |
| − | ==== '<=ALL' ====
| |
| − | function '<=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>ALL' ====
| |
| − | function '>ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>ALL' ====
| |
| − | function '>ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>ALL', 1450);
| |
| − | ==== '>ALL' ====
| |
| − | function '>ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>=ALL' ====
| |
| − | function '>=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>=ALL' ====
| |
| − | function '>=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>=ALL', 1450);
| |
| − | ==== '> ====
| |
| − | function '>=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '=SOME' ====
| |
| − | function '=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '=SOME' ====
| |
| − | function '=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('=SOME', 1450);
| |
| − | ==== '=SOME' ====
| |
| − | function '=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '!=SOME' ====
| |
| − | function '!=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '!=SOME' ====
| |
| − | function '!=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('!=SOME', 1450);
| |
| − | ==== '!=SOME' ====
| |
| − | function '!=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<SOME' ====
| |
| − | function '<SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<SOME' ====
| |
| − | function '<SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<SOME', 1450);
| |
| − | ==== '<SOME' ====
| |
| − | function '<SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '<=SOME' ====
| |
| − | function '<=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '<=SOME' ====
| |
| − | function '<=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('<=SOME', 1450);
| |
| − | ==== '<=SOME' ====
| |
| − | function '<=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>SOME' ====
| |
| − | function '>SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>SOME' ====
| |
| − | function '>SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>SOME', 1450);
| |
| − | ==== '>SOME' ====
| |
| − | function '>SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
| |
| − | | |
| − | ==== '>SOME' ====
| |
| − | function '>=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '>SOME' ====
| |
| − | function '>=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
| |
| − | pragma FIPSFLAG('>=SOME', 1450);
| |
| − | ==== '>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);
| |
| − | | |
| − | ==== SYSDATE ====
| |
| − | function SYSDATE return DATE;
| |
| − | pragma FIPSFLAG('SYSDATE', 1452);
| |
| − | | |
| − | ==== UID ====
| |
| − | function UID return PLS_INTEGER;
| |
| − | pragma FIPSFLAG('UID', 1452);
| |
| − | | |
| − | ==== USER ====
| |
| − | function USER return VARCHAR2;
| |
| − | | |
| − | ==== USERENV ====
| |
| − | function USERENV (envstr VARCHAR2) return VARCHAR2;
| |
| − | pragma FIPSFLAG('USERENV', 1452);
| |
| − | | |
| − | -- ROWID: this dreadful identifier is supposed to represent a datatype
| |
| − | ========
| |
| − | -- outside of SQL and and a pseudo-column (function, to us) when inside
| |
| − | -- a sql statement. ADA data model doesn't allow for any
| |
| − | ==== 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.
| |
| − | ==== ROWID ====
| |
| − | function ROWID " return ROWID;
| |
| − | pragma builtin('ROWID ', 1, 209, 240); -- this had better never be called.
| |
| − | | |
| − | ==== NULLFN ====
| |
| − | function NULLFN (str VARCHAR2) return RAW;
| |
| − | pragma builtin('NULLFN', 1, 0, 1);
| |
| − | | |
| − | ==== HEXTORAW ====
| |
| − | function HEXTORAW (c VARCHAR2) return RAW;
| |
| − | pragma builtin('HEXTORAW', 1, 23, 1);
| |
| − | | |
| − | ==== RAWTOHEX ====
| |
| − | function RAWTOHEX (r RAW) return VARCHAR2;
| |
| − | pragma builtin('RAWTOHEX', 1, 23, 2);
| |
| − | | |
| − | ==== CHARTOROWID ====
| |
| − | function CHARTOROWID (str VARCHAR2) return ROWID;
| |
| − | pragma builtin('CHARTOROWID', 1, 0, 1);
| |
| − | | |
| − | ==== ROWIDTOCHAR ====
| |
| − | function ROWIDTOCHAR (str ROWID) return VARCHAR2;
| |
| − | pragma builtin('ROWIDTOCHAR', 1, 0, 1);
| |
| − | | |
| − | | |
| − | -- Trusted*Oracle additions
| |
| − | ==== ROWLABEL ====
| |
| − | Function ROWLABEL return MLSLABEL; -- pseudo column
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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
| |
| − | ==== LEAST_UB ====
| |
| − | Function LEAST_UB(pattern MLSLABEL) return MLSLABEL;
| |
| − | pragma BUILTIN('LEAST_UB',90, 4, 3); -- PEMS_CHAR, CHR_CNV_MLS
| |
| − | ==== GREATEST_LB ====
| |
| − | Function GREATEST_LB (pattern MLSLABEL) return MLSLABEL;
| |
| − | pragma BUILTIN('GREATEST_LB',90, 4, 4); -- PEMS_CHAR, CHR_CNV_MLS
| |
| − | | |
| − | ==== '>=' ====
| |
| − | Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== '>'' ====
| |
| − | Function '>' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | Function '<' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== '=' ====
| |
| − | Function '=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
| |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (label MLSLABEL) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 1, 20); -- same "cod" as IS NULL(varchar2)
| |
| − | ==== 'IS NOT NULL' ====
| |
| − | function 'IS NOT NULL' (label MLSLABEL) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 1, 50);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL(label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL;
| |
| − | pragma FIPSFLAG('NVL', 1452);
| |
| − | | |
| − | -- group functions
| |
| − | ==== LUB ====
| |
| − | Function LUB (label MLSLABEL) return MLSLABEL;
| |
| − | ==== GLB ====
| |
| − | Function GLB (label MLSLABEL) return MLSLABEL;
| |
| − | | |
| − | -- end of Trusted*Oracle additions
| |
| − | | |
| − | | |
| − | -- beginning of NLS routines
| |
| − | | |
| − | ==== NLSSORT ====
| |
| − | function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS) return RAW;
| |
| − | pragma FIPSFLAG('NLSSORT', 1452);
| |
| − | ==== NLSSORT ====
| |
| − | function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS, c2 VARCHAR2) return RAW;
| |
| − | pragma FIPSFLAG('NLSSORT', 1452);
| |
| − | ==== 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);
| |
| − | ==== NLS_UPPER ====
| |
| − | function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('NLS_UPPER', 1452);
| |
| − | ==== 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);
| |
| − | ==== NLS_LOWER ====
| |
| − | function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('NLS_LOWER', 1452);
| |
| − | ==== 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);
| |
| − | ==== NLS_INITCAP ====
| |
| − | function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return VARCHAR2 CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('NLS_INITCAP', 1452);
| |
| − | | |
| − | ==== LENGTHB ====
| |
| − | function LENGTHB(ch VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
| |
| − | pragma FIPSFLAG('LENGTHB', 1452);
| |
| − | ==== 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);
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | ==== 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.
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left date, format varchar2, parms varchar2) return varchar2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left number, format varchar2, parms varchar2)
| |
| − | return varchar2;
| |
| − | ==== NLS_CHARSET_NAME ====
| |
| − | function NLS_CHARSET_NAME(csetid PLS_INTEGER) return VARCHAR2;
| |
| − | ==== NLS_CHARSET_ID ====
| |
| − | function NLS_CHARSET_ID(csetname VARCHAR2) return PLS_INTEGER;
| |
| − | ==== NLS_CHARSET_DECL_LEN ====
| |
| − | function NLS_CHARSET_DECL_LEN(bytecnt NUMBER, csetid NUMBER)
| |
| − | return PLS_INTEGER;
| |
| − | | |
| − | -- end of NLS routines
| |
| − | | |
| − | ==== CONVERT ====
| |
| − | function CONVERT(src VARCHAR2 character set any_cs,
| |
| − | destcset VARCHAR2)
| |
| − | return VARCHAR2 character set src%charset;
| |
| − | ==== CONVERT====
| |
| − | function CONVERT(src VARCHAR2 character set any_cs,
| |
| − | destcset VARCHAR2,
| |
| − | srccset VARCHAR2)
| |
| − | return VARCHAR2 character set src%charset;
| |
| − | | |
| − | ==== "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);
| |
| − | | |
| − | ==== VSIZE ====
| |
| − | function VSIZE (e number ) return NUMBER;
| |
| − | pragma builtin('VSIZE', 1, 0, 1);
| |
| − | ==== VSIZE ====
| |
| − | function VSIZE (e DATE) return NUMBER;
| |
| − | pragma builtin('VSIZE', 1, 0, 1);
| |
| − | ==== 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
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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
| |
| − | --
| |
| − | ==== ACOS ====
| |
| − | function ACOS(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('ACOS', 1452);
| |
| − | | |
| − | ==== ASIN ====
| |
| − | function ASIN(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('ASIN', 1452);
| |
| − | | |
| − | ==== ATAN ====
| |
| − | function ATAN(N NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('ATAN', 1452);
| |
| − | | |
| − | ==== ATAN2 ====
| |
| − | function ATAN2(x NUMBER, y NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('ATAN2', 1452);
| |
| − | | |
| − | --#### This is the end of 7.3 Standard
| |
| − | | |
| − | -- LOB IS NULL
| |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
| |
| − | ==== 'IS NOT NULL'====
| |
| − | function 'IS NOT NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50);
| |
| − | | |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (n BLOB) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
| |
| − | ==== 'IS NOT NULL' ====
| |
| − | function 'IS NOT NULL' (n BLOB) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50);
| |
| − | | |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (n BFILE) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
| |
| − | ==== '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.
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('!=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('<', 1, 1, 1);
| |
| − | pragma FIPSFLAG('<', 1450);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('<=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('<=', 1450);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('>', 1, 1, 1);
| |
| − | pragma FIPSFLAG('>', 1450);
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('>=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('>=', 1450);
| |
| − | | |
| − | ==== '=ANY' ====
| |
| − | function '=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '!=ANY' ====
| |
| − | function '!=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<ANY' ====
| |
| − | function '<ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<=ANY' ====
| |
| − | function '<=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '>ANY' ====
| |
| − | function '>ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '>=ANY' ====
| |
| − | function '>=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '=ALL' ====
| |
| − | function '=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '!=ALL' ====
| |
| − | function '!=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<ALL' ====
| |
| − | function '<ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<=ALL' ====
| |
| − | function '<=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '>ALL' ====
| |
| − | function '>ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '=SOME' ====
| |
| − | function '=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '!=SOME' ====
| |
| − | function '!=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<SOME' ====
| |
| − | function '<SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '<=SOME' ====
| |
| − | function '<=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '>SOME' ====
| |
| − | function '>SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | ==== '>=SOME' ====
| |
| − | function '>=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
| |
| − | | |
| − | -- Outer Join
| |
| − | ==== '(+)' ====
| |
| − | function '(+)' ( colname "<ADT_1>") return "<ADT_1>";
| |
| − | pragma FIPSFLAG('(+)', 1450);
| |
| − | | |
| − | -- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
| |
| − | ==== GREATEST ====
| |
| − | -- function GREATEST (pattern "<ADT_1>") return "<ADT_1>";
| |
| − | --pragma BUILTIN('GREATEST', 1, 1, 1);
| |
| − | | |
| − | ==== LEAST ====
| |
| − | -- function LEAST (pattern "<ADT_1>") return "<ADT_1>";
| |
| − | --pragma BUILTIN('LEAST', 1, 1, 1);
| |
| − | | |
| − | ==== DECODE ====
| |
| − | function DECODE (expr "<ADT_1>", pat "<ADT_1>", res "<ADT_1>")
| |
| − | return "<ADT_1>";
| |
| − | pragma BUILTIN('DECODE', 1, 1, 1);
| |
| − | | |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (B "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== '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);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL (B1 "<ADT_1>", B2 "<ADT_1>") return "<ADT_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== VALUE ====
| |
| − | function VALUE (item "<ADT_WITH_OID>") return "<ADT_1>";
| |
| − | pragma BUILTIN('VALUE', 1, 1, 1);
| |
| − | pragma FIPSFLAG('VALUE', 1450);
| |
| − | | |
| − | ==== REF ====
| |
| − | function REF (item "<ADT_WITH_OID>") return REF "<ADT_1>";
| |
| − | pragma BUILTIN('REF', 1, 1, 1);
| |
| − | pragma FIPSFLAG('REF', 1450);
| |
| − | | |
| − | ==== DEREF ====
| |
| − | function DEREF (r REF "<ADT_1>") return "<ADT_1>";
| |
| − | pragma BUILTIN('DEREF', 1, 1, 1);
| |
| − | pragma FIPSFLAG('DEREF', 1450);
| |
| − | | |
| − | -- overloadings for REF ADT
| |
| − | | |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (B REF "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== '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);
| |
| − | | |
| − | ==== 'IS DANGLING'====
| |
| − | function 'IS DANGLING' (B REF "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS DANGLING', 1, 1, 1);
| |
| − | pragma FIPSFLAG('IS DANGLING', 1450);
| |
| − | | |
| − | ==== '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);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL (B1 REF "<ADT_1>", B2 REF "<ADT_1>") return REF "<ADT_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('=', 0, 3, 1);
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | | |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('!=', 0, 3, 2);
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | | |
| − | ==== '=' ====
| |
| − | -- function '=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | --pragma BUILTIN('=', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('=', 1450);
| |
| − | --
| |
| − | ==== '!=' ====
| |
| − | -- function '!=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | --pragma BUILTIN('!=', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('!=', 1450);
| |
| − | --
| |
| − | ==== '=ANY' ====
| |
| − | -- function '=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | ==== '!=ANY' ====
| |
| − | -- function '!=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | ==== '=ALL' ====
| |
| − | -- function '=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | ==== '!=ALL' ====
| |
| − | -- function '!=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | ==== '=SOME' ====
| |
| − | -- function '=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | ==== '!=SOME' ====
| |
| − | -- function '!=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
| |
| − | -- return BOOLEAN;
| |
| − | --
| |
| − | ==== DECODE ====
| |
| − | -- function DECODE (expr "<COLLECTION_1>", pat "<COLLECTION_1>",
| |
| − | --res "<COLLECTION_1>")
| |
| − | -- return "<COLLECTION_1>";
| |
| − | --pragma BUILTIN('DECODE', 1, 1, 1);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that index-by tables are never NULL: this function will always
| |
| − | -- return FALSE for them.
| |
| − | ==== 'IS NULL' ====
| |
| − | function 'IS NULL' (B "<COLLECTION_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that index-by tables are never NULL: this function will always
| |
| − | -- return TRUE for them.
| |
| − | ==== '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);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that index-by tables are never NULL: this function will always
| |
| − | -- return B1 for them.
| |
| − | ==== NVL ====
| |
| − | function NVL (B1 "<COLLECTION_1>", B2 "<COLLECTION_1>")
| |
| − | return "<COLLECTION_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== 'IS NULL'====
| |
| − | function 'IS NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== '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);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL (B1 "<REF_CURSOR_1>", B2 "<REF_CURSOR_1>")
| |
| − | return "<REF_CURSOR_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that associative arrays are never NULL: this function will always
| |
| − | -- return FALSE.
| |
| − | ==== 'IS NULL'====
| |
| − | function 'IS NULL' (B "<ASSOC_ARRAY_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that associative arrays are never NULL: this function will always
| |
| − | -- return TRUE.
| |
| − | ==== '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);
| |
| − | | |
| − | ==== will ====
| |
| − | -- Note that associative arrays are never NULL: this function will always
| |
| − | -- return B1.
| |
| − | ==== NVL ====
| |
| − | function NVL (B1 "<ASSOC_ARRAY_1>", B2 "<ASSOC_ARRAY_1>")
| |
| − | return "<ASSOC_ARRAY_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== EMPTY_CLOB ====
| |
| − | function EMPTY_CLOB return clob;
| |
| − | ==== EMPTY_BLOB ====
| |
| − | function EMPTY_BLOB return blob;
| |
| − | | |
| − | ==== BFILENAME ====
| |
| − | function BFILENAME(directory varchar2,filename varchar2) return BFILE;
| |
| − | | |
| − | ==== "SYS$LOB_REPLICATION" ====
| |
| − | function "SYS$LOB_REPLICATION" (x in blob) return blob;
| |
| − | ==== "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
| |
| − | ========
| |
| − | function "SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | function "SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-'====
| |
| − | function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | ==== '-'====
| |
| − | function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | | |
| − | ==== "SYS$DSINTERVALSUBTRACT" ====
| |
| − | function "SYS$DSINTERVALSUBTRACT"
| |
| − | (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | ==== "SYS$YMINTERVALSUBTRACT" ====
| |
| − | function SYS$YMINTERVALSUBTRACT"
| |
| − | (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED ;
| |
| − | | |
| − | ==== "SYS$DSINTERVALSUBTRACT" ====
| |
| − | function "SYS$DSINTERVALSUBTRACT" (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
| |
| − | return TIME_UNCONSTRAINED ;
| |
| − | ==== "SYS$DSINTERVALSUBTRACT" ====
| |
| − | function "SYS$DSINTERVALSUBTRACT"
| |
| − | (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
| |
| − | return TIME_TZ_UNCONSTRAINED ;
| |
| − | ==== "SYS$DSINTERVALSUBTRACT" ====
| |
| − | function "SYS$DSINTERVALSUBTRACT" (LEFT date, RIGHT date)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | ==== "SYS$YMINTERVALSUBTRACT" ====
| |
| − | function "SYS$YMINTERVALSUBTRACT" (LEFT date, RIGHT date)
| |
| − | return YMINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date;
| |
| − | | |
| − | ==== '-' ====
| |
| − | function '-' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED ;
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | | |
| − | -- end subtract
| |
| − | | |
| − | -- other datetime operators
| |
| − | | |
| − | ==== '*' ====
| |
| − | 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 ;
| |
| − | | |
| − | ==== '/' ====
| |
| − | function '/' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
| |
| − | return YMINTERVAL_UNCONSTRAINED ;
| |
| − | function '/' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
| |
| − | return DSINTERVAL_UNCONSTRAINED ;
| |
| − | | |
| − | | |
| − | ==== current_date ====
| |
| − | function current_date return date;
| |
| − | ==== current_time ====
| |
| − | function current_time return TIME_TZ_UNCONSTRAINED;
| |
| − | ==== current_timestamp ====
| |
| − | function current_timestamp return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | | |
| − | ==== TO_TIME ====
| |
| − | function TO_TIME (RIGHT varchar2 character set any_cs) return
| |
| − | time_unconstrained;
| |
| − | pragma BUILTIN('TO_TIME', 0, 15, 1);
| |
| − | ==== TO_TIMESTAMP ====
| |
| − | function TO_TIMESTAMP (RIGHT varchar2 character set any_cs)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP', 0, 15, 3);
| |
| − | ==== 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);
| |
| − | ==== 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);
| |
| − | ==== TO_YMINTERVAL ====
| |
| − | function TO_YMINTERVAL (RIGHT varchar2 character set any_cs)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_YMINTERVAL', 0, 15, 9);
| |
| − | ==== TO_DSINTERVAL ====
| |
| − | function TO_DSINTERVAL (RIGHT varchar2 character set any_cs)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_DSINTERVAL', 0, 15, 11);
| |
| − | | |
| − | -- with nls args
| |
| − | ==== 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;
| |
| − | ==== 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;
| |
| − | ==== 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;
| |
| − | ==== 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;
| |
| − | ==== TO_DSINTERVAL ====
| |
| − | function TO_DSINTERVAL(RIGHT varchar2 character set any_cs,
| |
| − | parms varchar2 character set RIGHT%charset)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | | |
| − | ==== NUMTOYMINTERVAL ====
| |
| − | function NUMTOYMINTERVAL(numerator number,
| |
| − | units varchar2 character set any_cs)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | ==== NUMTODSINTERVAL ====
| |
| − | function NUMTODSINTERVAL(numerator number,
| |
| − | units varchar2 character set any_cs)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('=',0, 11, 1);
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN; -- also <> and ~=
| |
| − | pragma BUILTIN('!=',0, 11, 2);
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('<',0, 11, 3);
| |
| − | pragma FIPSFLAG('<', 1450);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',0, 11, 4);
| |
| − | pragma FIPSFLAG('<=', 1450);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('>',0, 11, 5);
| |
| − | pragma FIPSFLAG('>', 1450);
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',0, 11, 6);
| |
| − | pragma FIPSFLAG('>=', 1450);
| |
| − | | |
| − | ==== 'IS NULL'====
| |
| − | function 'IS NULL' (u UROWID) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 14, 0); -- PEMS_UROWID, PEMDNUL
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | ==== '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);
| |
| − | | |
| − | ==== UROWID ====
| |
| − | function UROWID " return UROWID;
| |
| − | pragma builtin('UROWID ', 1, 209, 240); -- this had better never be called.
| |
| − | | |
| − | ==== SYS_GUID ====
| |
| − | -- New built-in function SYS_GUID, returns globally unique id
| |
| − | ==== SYS_GUID ====
| |
| − | function SYS_GUID return RAW;
| |
| − | | |
| − | ==== SYS_CONTEXT ====
| |
| − | -- New built-in function SYS_CONTEXT
| |
| − | ==== SYS_CONTEXT ====
| |
| − | function SYS_CONTEXT (namespace varchar2, attribute varchar2)
| |
| − | return varchar2;
| |
| − | | |
| − | ==== 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
| |
| − | ==== 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
| |
| − | ==== ====
| |
| − | -- been added here as functions to avoid name capture issues.
| |
| − | --
| |
| − | ==== ====
| |
| − | -- 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.
| |
| − | ==== CUBE ====
| |
| − | function CUBE return NUMBER;
| |
| − | ==== ROLLUP ====
| |
| − | function ROLLUP return NUMBER;
| |
| − | | |
| − | ==== 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.
| |
| − | ==== GROUPING ====
| |
| − | function GROUPING(v VARCHAR2) return NUMBER;
| |
| − | ==== GROUPING ====
| |
| − | function GROUPING(a "<ADT_1>") return NUMBER;
| |
| − | | |
| − | -- This is for TRIM(x). No trim set.
| |
| − | ========
| |
| − | 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.
| |
| − | ========
| |
| − | 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.
| |
| − | ========
| |
| − | 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
| |
| − | ==== '=' ====
| |
| − | function '=' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT TIME_UNCONSTRAINED,
| |
| − | RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT TIMESTAMP_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT TIME_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT YMINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT DSINTERVAL_UNCONSTRAINED,
| |
| − | RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== TO_TIME ====
| |
| − | function TO_TIME (RIGHT TIME_TZ_UNCONSTRAINED) return TIME_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIME', 0, 15, 13);
| |
| − | ==== TO_TIME_TZ ====
| |
| − | function TO_TIME_TZ (RIGHT TIME_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIME_TZ', 0, 15, 14);
| |
| − | ==== TO_TIMESTAMP ====
| |
| − | function TO_TIMESTAMP (RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP', 0, 15, 15);
| |
| − | ==== TO_TIMESTAMP_TZ ====
| |
| − | function TO_TIMESTAMP_TZ (RIGHT TIMESTAMP_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 16);
| |
| − | | |
| − | ==== '-' ====
| |
| − | function '-'
| |
| − | (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | ==== '-' ====
| |
| − | function '-'
| |
| − | (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | ==== '-' ====
| |
| − | function '-'
| |
| − | (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | ==== '-' ====
| |
| − | function '-'
| |
| − | (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | | |
| − | -- timezone functions
| |
| − | ==== SYS_AT_TIME_ZONE ====
| |
| − | function SYS_AT_TIME_ZONE(t time_tz_unconstrained,
| |
| − | i varchar2) RETURN time_tz_unconstrained;
| |
| − | ==== SYS_AT_TIME_ZONE ====
| |
| − | function SYS_AT_TIME_ZONE(t timestamp_tz_unconstrained,
| |
| − | i varchar2) RETURN timestamp_tz_unconstrained;
| |
| − | ==== systimestamp ====
| |
| − | FUNCTION systimestamp RETURN timestamp_tz_unconstrained;
| |
| − | ==== dbtimezone ====
| |
| − | FUNCTION dbtimezone RETURN varchar2;
| |
| − | ==== sessiontimezone ====
| |
| − | FUNCTION sessiontimezone RETURN varchar2;
| |
| − | ==== localtimestamp ====
| |
| − | FUNCTION localtimestamp RETURN timestamp_unconstrained;
| |
| − | ==== localtime ====
| |
| − | FUNCTION localtime RETURN time_unconstrained;
| |
| − | | |
| − | ==== TO_TIMESTAMP ====
| |
| − | function TO_TIMESTAMP (RIGHT DATE) return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP', 0, 15, 17);
| |
| − | | |
| − | ==== '+'(LEFT ====
| |
| − | function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT yminterval_unconstrained)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED;
| |
| − | ==== '+'(LEFT ====
| |
| − | function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT dsinterval_unconstrained)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED;
| |
| − | ==== '+'(LEFT ====
| |
| − | function '+'(LEFT yminterval_unconstrained,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED ;
| |
| − | ==== '+'(LEFT ====
| |
| − | function '+'(LEFT dsinterval_unconstrained,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED ;
| |
| − | | |
| − | ==== '-'(LEFT ====
| |
| − | function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT yminterval_unconstrained)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED ;
| |
| − | ==== '-'(LEFT ====
| |
| − | function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT dsinterval_unconstrained)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED ;
| |
| − | | |
| − | ==== ====
| |
| − | function SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return dsinterval_unconstrained;
| |
| − | ==== ====
| |
| − | function SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return yminterval_unconstrained;
| |
| − | | |
| − | ==== '-'(LEFT ====
| |
| − | function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return dsinterval_unconstrained;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | | |
| − | ==== SYS_LITERALTOYMINTERVAL ====
| |
| − | function SYS_LITERALTOYMINTERVAL(numerator varchar2, units varchar2)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTODSINTERVAL ====
| |
| − | function SYS_LITERALTODSINTERVAL(numerator varchar2, units varchar2)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTOTIME ====
| |
| − | function SYS_LITERALTOTIME(numerator varchar2)
| |
| − | return TIME_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTOTZTIME ====
| |
| − | function SYS_LITERALTOTZTIME(numerator varchar2)
| |
| − | return TIME_TZ_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTOTIMESTAMP ====
| |
| − | function SYS_LITERALTOTIMESTAMP(numerator varchar2)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTOTZTIMESTAMP ====
| |
| − | function SYS_LITERALTOTZTIMESTAMP(numerator varchar2)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | ==== SYS_LITERALTODATE ====
| |
| − | function SYS_LITERALTODATE(numerator varchar2) return DATE;
| |
| − | | |
| − | | |
| − | -- Explicit conversions between date and datetime
| |
| − | ==== TO_TIMESTAMP ====
| |
| − | function TO_TIMESTAMP(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP', 0, 15, 24);
| |
| − | | |
| − | ==== TO_TIMESTAMP_TZ ====
| |
| − | function TO_TIMESTAMP_TZ(ARG DATE) return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 27);
| |
| − | | |
| − | ==== 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
| |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 TIME_UNCONSTRAINED,
| |
| − | b2 TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 TIME_TZ_UNCONSTRAINED, b2 TIME_TZ_UNCONSTRAINED)
| |
| − | return TIME_TZ_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 TIMESTAMP_UNCONSTRAINED,
| |
| − | b2 TIMESTAMP_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 TIMESTAMP_TZ_UNCONSTRAINED, b2 TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 TIMESTAMP_LTZ_UNCONSTRAINED,
| |
| − | b2 TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 YMINTERVAL_UNCONSTRAINED, b2 YMINTERVAL_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
| |
| − | ==== NVL ====
| |
| − | function NVL (b1 DSINTERVAL_UNCONSTRAINED, b2 DSINTERVAL_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | | |
| − | ==== ====
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T TIME_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T TIMESTAMP_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (T DATE,FIELD VARCHAR2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (I YMINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
| |
| − | ========
| |
| − | function SYS$EXTRACT_FROM"
| |
| − | (I DSINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
| |
| − | | |
| − | -- ########## 8.2 LOB Built-in Functions ######## --
| |
| − | | |
| − | -- LENGTH --
| |
| − | ==== LENGTH ====
| |
| − | function LENGTH(ch CLOB CHARACTER SET ANY_CS) return integer;
| |
| − | pragma FIPSFLAG('LENGTH', 1452);
| |
| − | | |
| − | ==== LENGTHB ====
| |
| − | function LENGTHB(ch CLOB CHARACTER SET ANY_CS) return integer;
| |
| − | pragma FIPSFLAG('LENGTHB', 1452);
| |
| − | | |
| − | ==== LENGTH ====
| |
| − | function LENGTH(bl BLOB) return integer;
| |
| − | pragma FIPSFLAG('LENGTH', 1452);
| |
| − | | |
| − | ==== LENGTHB ====
| |
| − | function LENGTHB(bl BLOB) return integer;
| |
| − | pragma FIPSFLAG('LENGTHB', 1452);
| |
| − | | |
| − | -- SUBSTR --
| |
| − | ==== SUBSTR ====
| |
| − | function SUBSTR(STR1 CLOB CHARACTER SET ANY_CS,
| |
| − | POS INTEGER,
| |
| − | LEN INTEGER := 18446744073709551615)
| |
| − | return CLOB CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('SUBSTR', 1452);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== '||' ====
| |
| − | function '||' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET LEFT%CHARSET;
| |
| − | pragma FIPSFLAG('||', 1454);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== UPPER ====
| |
| − | function UPPER(ch CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('UPPER', 1452);
| |
| − | | |
| − | -- LOWER --
| |
| − | ==== LOWER ====
| |
| − | function LOWER(ch CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('LOWER', 1452);
| |
| − | | |
| − | -- LPAD --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== LPAD ====
| |
| − | function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
| |
| − | LEN integer)
| |
| − | return CLOB CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('LPAD', 1452);
| |
| − | | |
| − | -- RPAD --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== RPAD ====
| |
| − | function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
| |
| − | LEN integer)
| |
| − | return CLOB CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('RPAD', 1452);
| |
| − | | |
| − | -- LTRIM --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== LTRIM ====
| |
| − | function LTRIM(STR1 CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('LTRIM', 1452);
| |
| − | | |
| − | -- RTRIM --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== RTRIM ====
| |
| − | function RTRIM(STR1 CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET STR1%CHARSET;
| |
| − | pragma FIPSFLAG('RTRIM', 1452);
| |
| − | | |
| − | -- TRIM --
| |
| − | ==== TRIM ====
| |
| − | function TRIM(v CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET v%CHARSET;
| |
| − | | |
| − | -- This is for TRIM(x). No trim set.
| |
| − | ========
| |
| − | 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.
| |
| − | ========
| |
| − | 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.
| |
| − | ========
| |
| − | 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 --
| |
| − | ==== 'LIKE ====
| |
| − | function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
| |
| − | pat CLOB CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'NOT_LIKE ====
| |
| − | function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS,
| |
| − | pat CLOB CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | | |
| − | ==== 'LIKE ====
| |
| − | function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
| |
| − | pat CLOB CHARACTER SET str%CHARSET,
| |
| − | esc VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '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 --
| |
| − | ==== 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 --
| |
| − | ==== 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 --
| |
| − | | |
| − | ==== '=' ====
| |
| − | Function '=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '!='====
| |
| − | Function '!=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '>====
| |
| − | Function '>' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | Function '<' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '>====
| |
| − | Function '>=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | Function '<=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | Function '=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | Function '!=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | Function '>' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | Function '<' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | Function '>=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | Function '<=' (LEFT CLOB CHARACTER SET ANY_CS,
| |
| − | RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | | |
| − | ==== '=' ====
| |
| − | Function '=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '!=' ====
| |
| − | Function '!=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | Function '>' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<' ====
| |
| − | Function '<' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | Function '>=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | ==== '<=' ====
| |
| − | Function '<=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
| |
| − | | |
| − | /* LOB-related conversion functions */
| |
| − | ==== TO_CLOB ====
| |
| − | function TO_CLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS) return CLOB;
| |
| − | pragma BUILTIN('TO_CLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
| |
| − | ==== TO_BLOB ====
| |
| − | function TO_BLOB(RIGHT RAW) return BLOB;
| |
| − | pragma BUILTIN('TO_BLOB', 0, 15, 30); -- OPC_CVT_RAW2BLB
| |
| − | ==== 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 ######## --
| |
| − | | |
| − | ==== NULLIF ====
| |
| − | function NULLIF(v1 VARCHAR2, v2 VARCHAR2) return VARCHAR2;
| |
| − | ==== NULLIF ====
| |
| − | function NULLIF(v1 BOOLEAN, v2 BOOLEAN) return BOOLEAN;
| |
| − | ==== NULLIF ====
| |
| − | function NULLIF(a1 "<ADT_1>", a2 "<ADT_1>") return "<ADT_1>";
| |
| − | | |
| − | ==== COALESCE ====
| |
| − | function COALESCE return VARCHAR2;
| |
| − | | |
| − | /* Daylight Saving Time Functions */
| |
| − | ==== tz_offset ====
| |
| − | FUNCTION tz_offset(region VARCHAR2) RETURN VARCHAR2;
| |
| − | ==== from_tz ====
| |
| − | FUNCTION from_tz(t TIMESTAMP_UNCONSTRAINED,timezone VARCHAR2)
| |
| − | RETURN timestamp_tz_unconstrained;
| |
| − | | |
| − | ==== ====
| |
| − | function SYS$EXTRACT_STRING_FROM"
| |
| − | (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
| |
| − | ========
| |
| − | function SYS$EXTRACT_STRING_FROM"
| |
| − | (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return VARCHAR2;
| |
| − | ========
| |
| − | function SYS$EXTRACT_STRING_FROM"
| |
| − | (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== LENGTH2 ====
| |
| − | function LENGTH2(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
| |
| − | pragma FIPSFLAG('LENGTH2', 1452);
| |
| − | | |
| − | ==== LENGTH4 ====
| |
| − | function LENGTH4(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
| |
| − | pragma FIPSFLAG('LENGTH4', 1452);
| |
| − | | |
| − | ==== LENGTHC ====
| |
| − | function LENGTHC(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
| |
| − | pragma FIPSFLAG('LENGTHC', 1452);
| |
| − | | |
| − | ==== 'LIKE2 ====
| |
| − | function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'NOT_LIKE2 ====
| |
| − | function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'LIKE2 ====
| |
| − | function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET,
| |
| − | esc VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '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;
| |
| − | | |
| − | ==== 'LIKE4 ====
| |
| − | function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'NOT_LIKE4 ====
| |
| − | function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'LIKE4 ====
| |
| − | function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET,
| |
| − | esc VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '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;
| |
| − | | |
| − | ==== 'LIKEC ====
| |
| − | function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'NOT_LIKEC ====
| |
| − | function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== 'LIKEC ====
| |
| − | function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | pat VARCHAR2 CHARACTER SET str%CHARSET,
| |
| − | esc VARCHAR2 CHARACTER SET str%CHARSET)
| |
| − | return BOOLEAN;
| |
| − | ==== '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;
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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 ********/
| |
| − | | |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(RIGHT NVARCHAR2) return NVARCHAR2;
| |
| − | pragma BUILTIN('TO_NCHAR',14, 0, 2);
| |
| − | | |
| − | ==== TO_NCLOB ====
| |
| − | function TO_NCLOB(cl CLOB CHARACTER SET ANY_CS) return NCLOB;
| |
| − | ==== TO_CLOB ====
| |
| − | function TO_CLOB(cl CLOB CHARACTER SET ANY_CS) return CLOB;
| |
| − | | |
| − | ==== 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 */
| |
| − | ==== 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
| |
| − | */
| |
| − | ==== 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);
| |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR (LEFT NUMBER, FORMAT NVARCHAR2) return NVARCHAR2;
| |
| − | pragma BUILTIN('TO_NCHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
| |
| − | | |
| − | ==== NHEXTORAW ====
| |
| − | function NHEXTORAW (c NVARCHAR2) return RAW;
| |
| − | pragma builtin('NHEXTORAW', 1, 23, 1);
| |
| − | ==== RAWTONHEX ====
| |
| − | function RAWTONHEX (r RAW) return NVARCHAR2;
| |
| − | pragma builtin('RAWTONHEX', 1, 23, 2);
| |
| − | ==== NCHARTOROWID ====
| |
| − | function NCHARTOROWID (str NVARCHAR2) return ROWID;
| |
| − | pragma builtin('NCHARTOROWID', 1, 0, 1);
| |
| − | ==== ROWIDTONCHAR ====
| |
| − | function ROWIDTONCHAR (str ROWID) return NVARCHAR2;
| |
| − | pragma builtin('ROWIDTONCHAR', 1, 0, 1);
| |
| − | | |
| − | ==== NCHR ====
| |
| − | function NCHR(n integer) return NVARCHAR2;
| |
| − | | |
| − | /* implemented by icd calls as the same as TO_CHAR */
| |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left date, format nvarchar2, parms nvarchar2)
| |
| − | return nvarchar2;
| |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left number, format nvarchar2, parms nvarchar2)
| |
| − | return nvarchar2;
| |
| − | | |
| − | /* implemented as a icd call, return TRUE if nchar, otherwise FALSE */
| |
| − | ==== 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> */
| |
| − | ==== '=' ====
| |
| − | function '=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('=', 1450);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('!=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('!=', 1450);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('<', 1, 1, 1);
| |
| − | pragma FIPSFLAG('<', 1450);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('<=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('<=', 1450);
| |
| − | ==== '> ====
| |
| − | function '>' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('>', 1, 1, 1);
| |
| − | pragma FIPSFLAG('>', 1450);
| |
| − | ==== '> ====
| |
| − | function '>=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('>=', 1, 1, 1);
| |
| − | pragma FIPSFLAG('>=', 1450);
| |
| − | | |
| − | ==== '=ANY' ====
| |
| − | function '=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | | |
| − | ==== '!=ANY ====
| |
| − | function '!=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<ANY ====
| |
| − | function '<ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<=ANY ====
| |
| − | function '<=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '=ALL ====
| |
| − | function '=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '!=ALL ====
| |
| − | function '!=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<ALL ====
| |
| − | function '<ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<=ALL ====
| |
| − | function '<=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '=SOME ====
| |
| − | function '=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '!=SOME ====
| |
| − | function '!=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<SOME ====
| |
| − | function '<SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '<=SOME ====
| |
| − | function '<=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | ==== '> ====
| |
| − | function '>=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
| |
| − | | |
| − | -- Outer Join
| |
| − | ==== '(+ ====
| |
| − | function '(+)' ( colname "<OPAQUE_1>") return "<OPAQUE_1>";
| |
| − | pragma FIPSFLAG('(+)', 1450);
| |
| − | | |
| − | -- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
| |
| − | ==== GREATEST ====
| |
| − | -- function GREATEST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
| |
| − | --pragma BUILTIN('GREATEST', 1, 1, 1);
| |
| − | | |
| − | ==== LEAST ====
| |
| − | -- function LEAST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
| |
| − | --pragma BUILTIN('LEAST', 1, 1, 1);
| |
| − | | |
| − | ==== DECODE ====
| |
| − | function DECODE (expr "<OPAQUE_1>", pat "<OPAQUE_1>", res "<OPAQUE_1>")
| |
| − | return "<OPAQUE_1>";
| |
| − | pragma BUILTIN('DECODE', 1, 1, 1);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (B "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (B "<OPAQUE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 3, 50);
| |
| − | pragma FIPSFLAG('IS NOT NULL', 1450);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL (B1 "<OPAQUE_1>", B2 "<OPAQUE_1>") return "<OPAQUE_1>";
| |
| − | pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | -- REFs to opaques are not supported yet.
| |
| − | ==== VALUE ====
| |
| − | -- function VALUE (item "<ADT_WITH_OID>") return "<OPAQUE_1>";
| |
| − | --pragma BUILTIN('VALUE', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('VALUE', 1450);
| |
| − | | |
| − | ==== REF ====
| |
| − | -- function REF (item "<ADT_WITH_OID>") return REF "<OPAQUE_1>";
| |
| − | --pragma BUILTIN('REF', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('REF', 1450);
| |
| − | | |
| − | ==== DEREF ====
| |
| − | -- function DEREF (r REF "<OPAQUE_1>") return "<OPAQUE_1>";
| |
| − | --pragma BUILTIN('DEREF', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('DEREF', 1450);
| |
| − | | |
| − | -- overloadings for REF OPAQUE
| |
| − | | |
| − | ==== 'IS ====
| |
| − | -- function 'IS NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
| |
| − | --pragma BUILTIN('IS NULL', 0, 3, 0);
| |
| − | --pragma FIPSFLAG('IS NULL', 1450);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | -- function 'IS NOT NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
| |
| − | --pragma FIPSFLAG('IS NOT NULL', 1450);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | -- function 'IS DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN;
| |
| − | --pragma BUILTIN('IS DANGLING', 1, 1, 1);
| |
| − | --pragma FIPSFLAG('IS DANGLING', 1450);
| |
| − | | |
| − | ==== '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);
| |
| − | | |
| − | ==== NVL ====
| |
| − | -- function NVL (B1 REF "<OPAQUE_1>", B2 REF "<OPAQUE_1>")
| |
| − | --return REF "<OPAQUE_1>";
| |
| − | --pragma FIPSFLAG('NVL', 1450);
| |
| − | | |
| − | ==== '=' ====
| |
| − | -- function '=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
| |
| − | --return BOOLEAN;
| |
| − | --pragma BUILTIN('=', 0, 3, 1);
| |
| − | --pragma FIPSFLAG('=', 1450);
| |
| − | | |
| − | ==== '!=' ====
| |
| − | -- function '!=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
| |
| − | --return BOOLEAN;
| |
| − | --pragma BUILTIN('!=', 0, 3, 2);
| |
| − | --pragma FIPSFLAG('!=', 1450);
| |
| − | | |
| − | ==== GROUPING ====
| |
| − | function GROUPING(a "<OPAQUE_1>") return NUMBER;
| |
| − | ==== NULLIF ====
| |
| − | function NULLIF(a1 "<OPAQUE_1>", a2 "<OPAQUE_1>") RETURN "<OPAQUE_1>";
| |
| − | | |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern TIME_TZ_UNCONSTRAINED)
| |
| − | return TIME_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern TIMESTAMP_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern YMINTERVAL_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern DSINTERVAL_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | | |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern TIME_TZ_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern TIMESTAMP_UNCONSTRAINED)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_TZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
| |
| − | return TIMESTAMP_LTZ_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern YMINTERVAL_UNCONSTRAINED)
| |
| − | return YMINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern DSINTERVAL_UNCONSTRAINED)
| |
| − | return DSINTERVAL_UNCONSTRAINED;
| |
| − | pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
| |
| − | | |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2,
| |
| − | parms VARCHAR2) return VARCHAR2;
| |
| − | ==== TO_CHAR====
| |
| − | function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2)
| |
| − | return VARCHAR2;
| |
| − | | |
| − | -- CONVERT FOR LOB --
| |
| − | ==== CONVERT ====
| |
| − | function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS,
| |
| − | DSTCSN VARCHAR2)
| |
| − | return CLOB CHARACTER SET SRCSTR%CHARSET;
| |
| − | ==== 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 --
| |
| − | ==== 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);
| |
| − | ==== NLS_UPPER ====
| |
| − | function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('NLS_UPPER', 1452);
| |
| − | ==== 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);
| |
| − | ==== NLS_LOWER ====
| |
| − | function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS)
| |
| − | return CLOB CHARACTER SET ch%CHARSET;
| |
| − | pragma FIPSFLAG('NLS_LOWER', 1452);
| |
| − | | |
| − | ==== COMPOSE ====
| |
| − | function COMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS)
| |
| − | return varchar2 character set ch%charset;
| |
| − | pragma FIPSFLAG('COMPOSE', 1452);
| |
| − | ==== DECOMPOSE ====
| |
| − | function DECOMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | canmode in VARCHAR2 DEFAULT 'CANONICAL')
| |
| − | return varchar2 character set ch%charset;
| |
| − | pragma FIPSFLAG('DECOMPOSE', 1452);
| |
| − | ==== SYS_EXTRACT_UTC ====
| |
| − | FUNCTION SYS_EXTRACT_UTC(t timestamp_tz_unconstrained)
| |
| − | return TIMESTAMP_UNCONSTRAINED;
| |
| − | | |
| − | -- Begin REGEXP Support (10iR1) --
| |
| − | | |
| − | -- REGEXP_LIKE --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== 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);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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.
| |
| − | ==== TO_BINARY_FLOAT ====
| |
| − | function TO_BINARY_FLOAT (RIGHT BINARY_FLOAT) RETURN BINARY_FLOAT;
| |
| − | pragma BUILTIN('TO_BINARY_FLOAT',14, 0, 1); -- PEMS_QUICK
| |
| − | ==== TO_BINARY_FLOAT ====
| |
| − | function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | RETURN BINARY_FLOAT;
| |
| − | ==== 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;
| |
| − | | |
| − | ==== TO_BINARY_DOUBLE ====
| |
| − | function TO_BINARY_DOUBLE (RIGHT BINARY_DOUBLE) RETURN BINARY_DOUBLE;
| |
| − | pragma BUILTIN('TO_BINARY_DOUBLE',14, 0, 1); -- PEMS_QUICK
| |
| − | ==== TO_BINARY_DOUBLE ====
| |
| − | function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS,
| |
| − | FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
| |
| − | RETURN BINARY_DOUBLE;
| |
| − | ==== 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;
| |
| − | | |
| − | ==== 'IS NAN====
| |
| − | function 'IS NAN' (N NUMBER) RETURN BOOLEAN;
| |
| − | ==== 'IS NAN ====
| |
| − | function 'IS NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
| |
| − | ==== 'IS NAN ====
| |
| − | function 'IS NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
| |
| − | ==== 'IS INFINITE ====
| |
| − | function 'IS INFINITE' (N NUMBER) RETURN BOOLEAN;
| |
| − | ==== 'IS INFINITE ====
| |
| − | function 'IS INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
| |
| − | ==== 'IS INFINITE ====
| |
| − | function 'IS INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
| |
| − | ==== 'IS NOT NAN ====
| |
| − | function 'IS NOT NAN' (N NUMBER) RETURN BOOLEAN;
| |
| − | ==== 'IS IS NOT NAN ====
| |
| − | function 'IS NOT NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
| |
| − | ==== 'IS IS NOT NAN ====
| |
| − | function 'IS NOT NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
| |
| − | ==== 'IS NOT INFINITE ====
| |
| − | function 'IS NOT INFINITE' (N NUMBER) RETURN BOOLEAN;
| |
| − | ==== 'IS NOT INFINITE ====
| |
| − | function 'IS NOT INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
| |
| − | ==== 'IS NOT INFINITE ====
| |
| − | function 'IS NOT INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
| |
| − | | |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR (left binary_float, format varchar2)
| |
| − | return VARCHAR2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR (left binary_double, format varchar2)
| |
| − | return VARCHAR2;
| |
| − | | |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left binary_float, format varchar2, parms varchar2)
| |
| − | return varchar2;
| |
| − | ==== TO_CHAR ====
| |
| − | function TO_CHAR(left binary_double, format varchar2, parms varchar2)
| |
| − | return varchar2;
| |
| − | | |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left binary_float, format nvarchar2) return NVARCHAR2;
| |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left binary_double, format nvarchar2) return NVARCHAR2;
| |
| − | | |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left binary_float, format nvarchar2, parms nvarchar2)
| |
| − | return nvarchar2;
| |
| − | ==== TO_NCHAR ====
| |
| − | function TO_NCHAR(left binary_double, format nvarchar2, parms nvarchar2)
| |
| − | return nvarchar2;
| |
| − | | |
| − | ==== 'REMAINDER ====
| |
| − | function 'REMAINDER'(n1 NUMBER, n2 NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG('REMAINDER', 1452);
| |
| − | ==== REMAINDER ====
| |
| − | function REMAINDER(n1 NUMBER, n2 NUMBER) return NUMBER;
| |
| − | pragma FIPSFLAG(REMAINDER, 1452);
| |
| − | ==== 'REMAINDER ====
| |
| − | function 'REMAINDER'(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('REMAINDER', 1452);
| |
| − | ==== REMAINDER ====
| |
| − | function REMAINDER(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG(REMAINDER, 1452);
| |
| − | ==== 'REMAINDER ====
| |
| − | function 'REMAINDER'(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('REMAINDER', 1452);
| |
| − | ==== REMAINDER ====
| |
| − | function REMAINDER(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG(REMAINDER, 1452);
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 2, 15);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('!=',5, 2, 16);
| |
| − | pragma FIPSFLAG('!=', 1452);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 2, 17);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 2, 18);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 2, 19);
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',3, 2, 20);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (n BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0);
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (n BINARY_FLOAT) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('NVL', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('+',14, 0, 1);
| |
| − | ==== '-' ====
| |
| − | function '-' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('-',15, 2, 23);
| |
| − | ==== ABS ====
| |
| − | function ABS(F BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('ABS', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('+',14, 2, 24);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('-',15, 2, 25);
| |
| − | ==== '*' ====
| |
| − | function '*' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('*',17, 2, 26);
| |
| − | ==== '/' ====
| |
| − | function '/' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('/',18, 2, 27);
| |
| − | | |
| − | ==== 'REM ====
| |
| − | function 'REM' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('REM', 1452);
| |
| − | ==== 'MOD ====
| |
| − | function 'MOD'(F1 BINARY_FLOAT, F2 BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('MOD', 1452);
| |
| − | | |
| − | ==== FLOOR ====
| |
| − | function FLOOR(F BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('FLOOR', 1452);
| |
| − | ==== CEIL ====
| |
| − | function CEIL(F BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('CEIL', 1452);
| |
| − | ==== SIGN ====
| |
| − | function SIGN(f BINARY_FLOAT) return SIGNTYPE;
| |
| − | pragma FIPSFLAG('SIGN', 1452);
| |
| − | ==== SQRT ====
| |
| − | function SQRT(f BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('SQRT', 1452);
| |
| − | | |
| − | ==== TRUNC ====
| |
| − | function TRUNC (F BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('TRUNC', 1452);
| |
| − | | |
| − | ==== ROUND ====
| |
| − | function ROUND (LEFT BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma FIPSFLAG('ROUND', 1452);
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 2, 28);
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | -- also <> and ~=
| |
| − | pragma BUILTIN('!=',5, 2, 29);
| |
| − | pragma FIPSFLAG('!=', 1452);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 2, 30);
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 2, 31);
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 2, 32);
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',3, 2, 33);
| |
| − | | |
| − | ==== 'IS ====
| |
| − | function 'IS NULL' (n BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0);
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT NULL' (n BINARY_DOUBLE) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50);
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('NVL', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('+',14, 0, 1);
| |
| − | ==== '-' ====
| |
| − | function '-' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('-',15, 2, 36);
| |
| − | ==== ABS ====
| |
| − | function ABS(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ABS', 1452);
| |
| − | | |
| − | ==== ACOS ====
| |
| − | function ACOS(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ACOS', 1452);
| |
| − | | |
| − | ==== ASIN ====
| |
| − | function ASIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ASIN', 1452);
| |
| − | | |
| − | ==== ATAN ====
| |
| − | function ATAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ATAN', 1452);
| |
| − | | |
| − | ==== ATAN2 ====
| |
| − | function ATAN2(x BINARY_DOUBLE, y BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ATAN2', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('+',14, 2, 37);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('-',15, 2, 38);
| |
| − | ==== '*' ====
| |
| − | function '*' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('*',17, 2, 39);
| |
| − | ==== '/' ====
| |
| − | function '/' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('/',18, 2, 40);
| |
| − | | |
| − | ==== 'REM ====
| |
| − | function 'REM' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
| |
| − | return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('REM', 1452);
| |
| − | ==== 'MOD ====
| |
| − | function 'MOD'(D1 BINARY_DOUBLE, D2 BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('MOD', 1452);
| |
| − | | |
| − | ==== '**' ====
| |
| − | function '**' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
| |
| − | return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('**', 1452);
| |
| − | | |
| − | ==== FLOOR ====
| |
| − | function FLOOR(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('FLOOR', 1452);
| |
| − | ==== CEIL ====
| |
| − | function CEIL(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('CEIL', 1452);
| |
| − | ==== SQRT ====
| |
| − | function SQRT(d BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('SQRT', 1452);
| |
| − | ==== SIGN ====
| |
| − | function SIGN(d BINARY_DOUBLE) return SIGNTYPE;
| |
| − | pragma FIPSFLAG('SIGN', 1452);
| |
| − | | |
| − | ==== COS ====
| |
| − | function COS(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== SIN ====
| |
| − | function SIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== TAN ====
| |
| − | function TAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== COSH ====
| |
| − | function COSH(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== SINH ====
| |
| − | function SINH(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== TANH ====
| |
| − | function TANH(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== EXP ====
| |
| − | function EXP(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | ==== LN ====
| |
| − | function LN(D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | | |
| − | ==== LOG ====
| |
| − | function LOG (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | | |
| − | ==== TRUNC ====
| |
| − | function TRUNC (D BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('TRUNC', 1452);
| |
| − | | |
| − | ==== ROUND ====
| |
| − | function ROUND (LEFT BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('ROUND', 1452);
| |
| − | | |
| − | ==== POWER ====
| |
| − | function POWER (d BINARY_DOUBLE, e BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma FIPSFLAG('POWER', 1452);
| |
| − | | |
| − | ==== NANVL ====
| |
| − | function NANVL(n1 NUMBER, n2 NUMBER) return NUMBER;
| |
| − | ==== NANVL ====
| |
| − | function NANVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | ==== NANVL ====
| |
| − | function NANVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | | |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
| |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern BINARY_FLOAT) return BINARY_FLOAT;
| |
| − | pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
| |
| − | ==== LEAST ====
| |
| − | function LEAST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
| |
| − | pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
| |
| − | | |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (RIGHT PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
| |
| − | ==== '-' ====
| |
| − | function '-' (RIGHT PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('-',15, 2, 41);
| |
| − | ==== ABS ====
| |
| − | function ABS(I PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma FIPSFLAG('ABS', 1452);
| |
| − | | |
| − | ==== '+' ====
| |
| − | function '+' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('+',14, 2, 42);
| |
| − | ==== '-' ====
| |
| − | function '-' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('-',14, 2, 43);
| |
| − | ==== '*' ====
| |
| − | function '*' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('*',14, 2, 44);
| |
| − | | |
| − | ==== '=' ====
| |
| − | function '=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 2, 45); -- PEMS_PLS_INTEGER, PEMDCMEQ
| |
| − | ==== '!=' ====
| |
| − | function '!=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | -- also <> and ~=
| |
| − | pragma BUILTIN('!=',5, 2, 46); -- PEMS_PLS_INTEGER, PEMDCMNE
| |
| − | pragma FIPSFLAG('!=', 1452);
| |
| − | ==== '<' ====
| |
| − | function '<' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('<',4, 2, 47); -- PEMS_PLS_INTEGER, PEMDCMLT
| |
| − | ==== '<=' ====
| |
| − | function '<=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('<=',6, 2, 48); -- PEMS_PLS_INTEGER, PEMDCMLE
| |
| − | ==== '>' ====
| |
| − | function '>' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('>',1, 2, 49); -- PEMS_PLS_INTEGER, PEMDCMGT
| |
| − | ==== '>=' ====
| |
| − | function '>=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('>=',3, 2, 51); -- PEMS_PLS_INTEGER, PEMDCMGE
| |
| − | | |
| − | ==== 'IS NULL'====
| |
| − | function 'IS NULL' (I PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_PLS_INTEGER, PEMDNUL
| |
| − | ==== 'IS NOT NULL'====
| |
| − | function 'IS NOT NULL' (I PLS_INTEGER) return BOOLEAN;
| |
| − | pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_PLS_INTEGER, PEMDNUL
| |
| − | | |
| − | ==== NVL ====
| |
| − | function NVL(I1 PLS_INTEGER, I2 PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma FIPSFLAG('NVL', 1452);
| |
| − | | |
| − | ==== TRUNC ====
| |
| − | function TRUNC (i pls_integer, places pls_integer := 0) return pls_integer;
| |
| − | pragma FIPSFLAG('TRUNC', 1452);
| |
| − | | |
| − | ==== ROUND ====
| |
| − | function ROUND (i pls_integer, places pls_integer := 0) return pls_integer;
| |
| − | pragma FIPSFLAG('ROUND', 1452);
| |
| − | | |
| − | ==== SIGN ====
| |
| − | function SIGN(i PLS_INTEGER) return SIGNTYPE;
| |
| − | pragma FIPSFLAG('SIGN', 1452);
| |
| − | | |
| − | ==== GREATEST ====
| |
| − | function GREATEST (pattern PLS_INTEGER) return PLS_INTEGER;
| |
| − | pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
| |
| − | ==== 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
| |
| − | ==== '=' ====
| |
| − | function '='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
| |
| − | return BOOLEAN;
| |
| − | pragma BUILTIN('=',2, 16, 1);
| |
| − | | |
| − | ==== '!=' ====
| |
| − | function '!='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
| |
| − | return BOOLEAN;
| |
| − | pragma BUILTIN('!=',2, 16, 2);
| |
| − | | |
| − | ==== CARDINALITY ====
| |
| − | function CARDINALITY (collection IN "<TABLE_1>") return PLS_INTEGER;
| |
| − | | |
| − | ==== SET ====
| |
| − | function SET (collection IN "<TABLE_1>") return "<TABLE_1>";
| |
| − | pragma BUILTIN('SET',18, 5, 40);-- Dummy
| |
| − | | |
| − | ==== IS A SET====
| |
| − | function 'IS A SET' (collection IN "<TABLE_1>") return BOOLEAN;
| |
| − | pragma BUILTIN('IS A SET',18, 5, 41);-- Dummy
| |
| − | ==== 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
| |
| − | | |
| − | ==== IS EMPTY ====
| |
| − | function 'IS EMPTY' (collection IN "<TABLE_1>") return BOOLEAN;
| |
| − | ==== 'IS ====
| |
| − | function 'IS NOT EMPTY'(collection IN "<TABLE_1>") return BOOLEAN;
| |
| − | | |
| − | -- IS A SUBMULTISET OF
| |
| − | ==== SUBMULTISET ====
| |
| − | function 'SUBMULTISET' (collection IN "<TABLE_1>",
| |
| − | collection2 IN "<TABLE_1>")
| |
| − | return BOOLEAN;
| |
| − | pragma BUILTIN('SUBMULTISET',18, 5, 43);
| |
| − | | |
| − | ==== 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);
| |
| − | | |
| − | ==== 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
| |
| − | | |
| − | ==== 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
| |
| − | | |
| − | ==== 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
| |
| − | | |
| − | ==== 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
| |
| − | | |
| − | ==== 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 --
| |
| − | ==== 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
| |
| − | ==== 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.
| |
| − | ========
| |
| − | 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
| |