"오라클 함수"의 두 판 사이의 차이

DB CAFE

2023년 2월 6일 (월) 21:45 판

추천메뉴 바로가기

DBA { Oracle DBA 명령어 > DBA 초급 과정 > DBA 고급 과정 }
튜닝 { 오라클 튜닝 목록 }
모델링 { 데이터 모델링 가이드 }

1 함수[편집]

2 그룹 함수[편집]

3 윈도우/분석 함수[편집]

4 MODEL 함수[편집]

--------------------------------------------------------------------------------
-- MODEL을 이용한 SUM(합계) 영역 추가
--------------------------------------------------------------------------------
SELECT COL_TERM
     , COL_SAL
  FROM (SELECT 1 NUM, '200701' TERM, 1000000 SALARY FROM DUAL UNION ALL
        SELECT 2 NUM, '200702' TERM, 2000000 SALARY FROM DUAL UNION ALL
        SELECT 3 NUM, '200703' TERM, 1500000 SALARY FROM DUAL UNION ALL
        SELECT 4 NUM, '200704' TERM, 1900000 SALARY FROM DUAL UNION ALL
        SELECT 5 NUM, '200705' TERM, 2300000 SALARY FROM DUAL UNION ALL
        SELECT 6 NUM, '200706' TERM, 3000000 SALARY FROM DUAL          )
 MODEL
 DIMENSION BY (TERM AS COL_TERM)
 MEASURES ( SALARY AS COL_SAL )
 RULES (
         COL_SAL['분1'] = COL_SAL['200701'] + COL_SAL['200702'] + COL_SAL['200703']
       , COL_SAL['분기'] = COL_SAL['200704'] + COL_SAL['200705'] + COL_SAL['200706']
       , COL_SAL['평균' ] = AVG(COL_SAL) [ COL_TERM BETWEEN '200701' AND '200706' ]
       , COL_SAL['합계' ] = SUM(COL_SAL) [ COL_TERM BETWEEN '200701' AND '200706' ]
       )
 ORDER BY 1
;

4.1 윈도우/분석 함수[편집]

5 윈도우 함수 / 분석 함수[편집]

분석함수 Analytic Functions

분석 함수는 행 그룹을 기반으로 집계 값을 계산합니다.
각 그룹에 대해 여러 행을 반환한다는 점에서 집계 함수와 다릅니다.
행 그룹을 윈도우(Window) 라고하며 analytic_clause에 의해 정의됩니다.
각 행에 대해 행의 슬라이딩 윈도우가 정의됩니다.
윈도우는 현재 행에 대한 계산을 수행하는 데 사용되는 행 범위를 결정합니다.
윈도우 크기는 물리적 행 수 또는 시간과 같은 논리적 간격을 기반으로 할 수 있습니다.
분석 함수가 처리되기 전에 모든 조인과 모든 WHERE, GROUP BY 및 HAVING 절이 완료됩니다.

5.1 OVER[편집]

oracle 12c syntax

OVER 절

누적 집계 등를 구하기 위해 분석함수 OVER절 사용
ORDER BY 절 뒤로 WINDOWING 절을 사용
WINDOWING절에서는 분석함수의 대상이 되는 행들의 범위 조정이 가능.
누적 합계를 구하기 위해서는 첫번째 행부터 읽고 있는 행까지(ROWS UNBOUNDED PRECEDING)를 분석함수의 범위 대상으로 지정.
WINDOWING절에서는 물리적(ROWS), 논리적(RANGE) 범위를 지정 가능.

5.1.1 ROWS UNBOUNDED PRECEDING[편집]

SELECT DEPTNO
     , EMPNO
     , ENAME
     , SAL
     , SUM(SAL) OVER(ORDER BY DEPTNO
                      ROWS UNBOUNDED PRECEDING
                    ) AS SUM_SAL
  FROM EMP;

5.1.2 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW[편집]

설명

ROWS 는 WINDOW의 범위를 정의할 때 물리적인 행을 지정.
RANGE 는 WINDOW의 범위를 논리적 행을 지정
어떤 행에서 시작해서 어떤 행 까지가 하나의 WINDOW 영역으로 정의 할지 범위를 BETWEEN 을 통하여 정의 함.
UNBOUNDED PRECEDING 은 시작점(첫 번째 행)을 가리키며 UNBOUNDED FOLLOWING 은 끝점(마지막 행)을 의미.
1. UNBOUNDED PRECEDING 은 윈도우 파티션의 시작점 사양이며 끝점 사양으로 사용할 수 없음.
CURRENT ROW 는 현재 행을 의미.
order_by_clause를 지정하지 않으면 이 절을 지정할 수 없음.
RANGE 절로 정의 된 일부 윈도우 바운더리(경계)를 사용하면 order_by_clause에서 하나의 표현식 만 지정할 수 있음.

SELECT
    DEPTNO
    ,EMPNO
    ,ENAME
    ,SAL
    ,SUM(SAL) OVER(
        ORDER BY DEPTNO
        ROWS BETWEEN UNBOUNDED PRECEDING    -- 윈도우 범위를 첫행 부터 ~ 현재 행까지 
        AND CURRENT ROW
    ) AS SUM_SAL
FROM EMP;

5.1.3 WINDOW 물리적 범위[편집]

설명

물리적 범위는 행을 기준으로 범위를 지정하는 것.
ROWS를 사용해서 행으로 부터 전(PRECEDING)과 후(FOLLOWING)의 범위를 지정

누적 합계를 구하는 예시

SELECT
    DEPTNO
    ,EMPNO
    ,ENAME
    ,SAL
    ,ROUND(
        AVG(SAL) OVER(
            ORDER BY DEPTNO
            ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING
        )
    ) AS AVG_SAL
FROM EMP;

사원의 정보를 부서 번호 기준으로 정렬 했을때 바로 전과 후 행의 급여평균 값과 함께 출력.

5.1.4 WINDOW 논리적 범위[편집]

설명

논리적 범위는 값을 기준으로 범위를 지정하는 것
RANGE를 사용해서 해당 행의 값을 기준으로 전(PRECEDING)과 후(FOLLOWING)의 범위를 지정
예시) 2번째 행에서 급여 4000의 1000 PRECEDING과 1000 FOLLOWING 범위는 3000 ~ 5000까지의 값을 분석함수에 적용하는 것.

SELECT DEPTNO
     , EMPNO
     , ENAME
     , SAL
     , ROUND(
        AVG(SAL) OVER(
            ORDER BY SAL --어떤 컬럼으로 정렬하느냐에 따라서 논리적인 값이 변경된다.
            RANGE BETWEEN 1000 PRECEDING
            AND 1000 FOLLOWING
        )
    ) AS AVG_SAL
FROM EMP;

사원의 정보를 부서 번호 기준으로 정렬 했을때 기준 행의 -1000 ~ 1000에 해당하는 값들의 급여평균 값과 함께 출력.

5.2 CUME_DIST[편집]

값 집합에서 값의 누적 분포 계산

5.3 DENSE_RANK[편집]

순위 값에 간격이없는 순서가 지정된 행 집합에서 행의 순위를 계산합니다.

5.4 FIRST_VALUE[편집]

지정된 창 프레임에서 첫 번째 행의 값을 가져옵니다.

5.5 LAG[편집]

셀프조인을 사용하지 않고 현재 행 앞에 오는 지정된 물리적 오프셋에서 행에 대한 액세스를 제공합니다.

5.6 LAST_VALUE[편집]

지정된 창 프레임에서 마지막 행의 값을 가져옵니다.

5.7 LEAD[편집]

셀프조인을 사용하지 않고 현재 행을 따르는 주어진 물리적 오프셋에서 행에 대한 액세스를 제공

5.8 NTH_VALUE[편집]

값 집합에서 N 번째 값을 가져옵니다.

5.9 NTILE[편집]

순서가 지정된 행 집합을 여러 버킷으로 나누고 각 행에 적절한 버킷 번호를 할당

5.10 PERCENT_RANK[편집]

일련의 값에서 값의 순위를 계산

5.11 RANK[편집]

일련의 값에서 값의 순위를 계산

5.12 ROW_NUMBER[편집]

파티션에서 또는 전체 결과에서 1부터 시작하여 고유 한 순차 정수를 각 행에 할당

5.13 ROW_NUMBER 함수[편집]

SELECT A.부서코드
      ,A.사원번호
      ,ROW_NUMBER() OVER (PARTITION BY A.부서코드
                              ORDER BY A.사원번호)  사원순번
FROM 사원 A
WHERE 부서코드 IN ('10', '20')
ORDER BY A.부서코드
        ,A.사원번호
;

5.14 ROW_NUMBER VS RANK[편집]

SELECT A.부서코드
      ,A.월급여
      ,A.사원번호
      ,ROW_NUMBER() OVER (PARTITION BY A.부서코드 ORDER BY A.월급여)            사원순번1
      ,RANK()       OVER (PARTITION BY A.부서코드 ORDER BY A.월급여)            사원순번2
      ,ROW_NUMBER() OVER (PARTITION BY A.부서코드 ORDER BY A.월급여,A.사원번호) 사원순번3
      ,RANK()       OVER (PARTITION BY A.부서코드 ORDER BY A.월급여,A.사원번호) 사원순번4
FROM 사원 A
WHERE 부서코드 IN ('10', '20')
ORDER BY A.부서코드
        ,A.월급여
        ,A.사원번호
;

-- 2) COUNT 함수와 SUM 함수

5.15 COUNT[편집]

SELECT A.부서코드
      ,A.사원번호
      ,A.퇴사일자
      ,A.직급
      ,COUNT(*)                OVER ()                         전체사원수
      ,COUNT(*)                OVER (PARTITION BY A.부서코드)  부서별사원수
      ,COUNT(A.퇴사일자)       OVER (PARTITION BY A.부서코드)  부서별퇴사자수
      ,COUNT(DISTINCT A.직급)  OVER (PARTITION BY A.부서코드)  부서별직급수
      ,COUNT(*)                OVER (PARTITION BY A.부서코드
                                         ORDER BY A.사원번호)  부서별사원수누계
FROM 사원 A
WHERE 부서코드 IN ('10', '20')
ORDER BY A.부서코드
        ,A.사원번호
;

5.16 SUM[편집]

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,SUM(A.월급여) OVER ()                                                     전체급여합
      ,SUM(A.월급여) OVER (PARTITION BY A.부서코드)                              부서별급여합
      ,SUM(A.월급여) OVER (PARTITION BY A.부서코드 ORDER BY A.월급여           ) 부서별급여누계1
      ,SUM(A.월급여) OVER (PARTITION BY A.부서코드 ORDER BY A.월급여,A.사원번호) 부서별급여누계2
FROM 사원 A
WHERE 부서코드 IN ('10', '20')
ORDER BY A.부서코드
        ,A.월급여
        ,A.사원번호
;

5.17 LAG 함수와 LEAD 함수[편집]

SELECT A.사원번호
      ,A.월급여
      ,LAG (A.월급여) OVER (ORDER BY A.월급여 DESC,A.사원번호)             이전급여
      ,LEAD(A.월급여) OVER (ORDER BY A.월급여 DESC,A.사원번호)             다음급여
      ,LAG (A.월급여) OVER (ORDER BY A.월급여 DESC,A.사원번호) - A.월급여  이전급여와의차이
      ,A.월급여 - LEAD(A.월급여) OVER (ORDER BY A.월급여 DESC,A.사원번호)  다음급여와의차이
FROM 사원 A
WHERE A.부서코드 = '20'
ORDER BY A.월급여   DESC
        ,A.사원번호
;

6 분석함수의 활용[편집]

6.1 1:M 관계의 조인에서 부모테이블이 기준집합[편집]

SELECT A.사원번호
      ,A.사원명
      ,B.발령일자
      ,B.직급
      ,B.부서코드
FROM 사원 A
    ,(
     SELECT B.사원번호
           ,B.발령일자
           ,B.직급
           ,B.부서코드
           ,ROW_NUMBER() OVER (PARTITION BY B.사원번호 ORDER BY B.이력순번 DESC)
                                            RN
     FROM 발령이력 B
     ) B
WHERE B.사원번호 = A.사원번호
AND B.RN = 1
;

6.2 집계 연산[편집]

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,ROUND(A.월급여/A.부서급여합, 2)  급여비중
      ,ROUND(RATIO_TO_REPORT(A.월급여) OVER (PARTITION BY A.부서코드), 2)
                                        급여비중2
FROM (
     SELECT A.부서코드
           ,A.사원번호
           ,A.월급여
           ,SUM(A.월급여) OVER (PARTITION BY A.부서코드) 부서급여합
     FROM 사원 A
     WHERE A.부서코드 IN ('10', '20')
     ) A
ORDER BY A.부서코드
        ,A.월급여   DESC
        ,A.사원번호
;

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,ROUND(A.월급여/B.부서급여합, 2)  급여비중
FROM 사원 A
    ,(
     SELECT B.부서코드
           ,SUM(B.월급여) 부서급여합
     FROM 사원 B
     WHERE B.부서코드 IN ('10', '20')
     GROUP BY B.부서코드
     ) B
WHERE A.부서코드 IN ('10', '20')
AND B.부서코드 = A.부서코드
ORDER BY A.부서코드
        ,A.월급여   DESC
        ,A.사원번호
;

-- 실습문제 10.1 : 점이력을 선분이력 형태로 표현

SELECT A.사원번호
      ,A.이력순번
      ,A.발령일자
FROM 발령이력 A
WHERE A.사원번호 BETWEEN 102 AND 104
ORDER BY A.사원번호
        ,A.이력순번
;

-- * 답안 SQL
SELECT A.사원번호
      ,A.이력순번
      ,A.발령일자                                              발령시작일자
      ,NVL(A.다음발령일자 - 1, TO_DATE('99991231','YYYYMMDD')) 발령종료일자
FROM (
     SELECT A.사원번호
           ,A.이력순번
           ,A.발령일자
           ,LEAD(A.발령일자) OVER (PARTITION BY A.사원번호 ORDER BY A.이력순번)
                                   다음발령일자
     FROM 발령이력 A
     WHERE A.사원번호 BETWEEN 102 AND 104
     ) A
ORDER BY A.사원번호
        ,A.이력순번
;

-----------------------------------------------------
-- 실습문제 10.2 : 데이터를 특정기준에 따라 할당
-----------------------------------------------------
-- * 문제 SQL
SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
FROM 사원 A
ORDER BY A.부서코드
        ,A.사원번호
;

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,A.급여비중
      ,A.부서성과급                        부서성과급
      ,TRUNC(A.급여비중*A.부서성과급, -3)  개별성과급
      ,SUM(TRUNC(A.급여비중*A.부서성과급, -3)) OVER (PARTITION BY A.부서코드
                                                         ORDER BY A.월급여 DESC
                                                                 ,A.사원번호)
                                           개별성과급누계
FROM (
     SELECT A.부서코드
           ,A.사원번호
           ,A.월급여
           ,ROUND(A.월급여/A.급여합, 4) 급여비중
           ,1000000                     부서성과급
     FROM (
          SELECT A.부서코드
                ,A.사원번호
                ,A.월급여
                ,SUM(A.월급여) OVER (PARTITION BY A.부서코드) 급여합
          FROM 사원 A
          ) A
     ) A
ORDER BY A.부서코드
        ,A.월급여   DESC
        ,A.사원번호
;

-- * 답안 SQL

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,CASE WHEN A.부서사원수 = A.부서사원순번     --> 부서별로 최종 데이터인 경우
         THEN A.개별성과급 +                       --> 개별성과급에
              (A.부서성과급 - A.개별성과급누계)    --> 자투리를 더해 줌
         ELSE A.개별성과급
       END                   성과급
      ,A.급여비중
      ,A.부서성과급
      ,A.개별성과급
      ,A.개별성과급누계
FROM (
     -- 개별성과급누계와 부서사원수, 부서사원순번을 구함
     SELECT A.부서코드
           ,A.사원번호
           ,A.월급여
           ,A.급여비중
           ,A.부서성과급                                        부서성과급
           ,A.개별성과급
           ,SUM(A.개별성과급) OVER (PARTITION BY A.부서코드 
                                        ORDER BY A.월급여 DESC
                                                ,A.사원번호)    개별성과급누계
           ,COUNT(*) OVER (PARTITION BY A.부서코드)             부서사원수
           ,ROW_NUMBER()  OVER (PARTITION BY A.부서코드 
                                    ORDER BY A.월급여 DESC
                                            ,A.사원번호)        부서사원순번
     FROM (
          -- (급여비중*부서성과급)으로 개별성과급을 구함
          SELECT A.부서코드
                ,A.사원번호
                ,A.월급여
                ,A.급여비중
                ,A.부서성과급                        부서성과급
                ,TRUNC(A.급여비중*A.부서성과급, -3)  개별성과급
          FROM (
               -- 급여비중과 부서성과급 포함
               SELECT A.부서코드
                     ,A.사원번호
                     ,A.월급여
                     ,ROUND(A.월급여/A.급여합, 4) 급여비중
                     ,1000000                     부서성과급
               FROM (
                    -- 부서별급여합
                    SELECT A.부서코드
                          ,A.사원번호
                          ,A.월급여
                          ,SUM(A.월급여) OVER (PARTITION BY A.부서코드) 급여합
                    FROM 사원 A
                    ) A
               ) A
          ) A
     ) A
ORDER BY A.부서코드
        ,A.월급여   DESC
        ,A.사원번호
;

-- LAST_VALUE 이용

SELECT A.부서코드
      ,A.사원번호
      ,A.월급여
      ,CASE WHEN A.사원번호 = LAST_VALUE(A.사원번호) OVER (PARTITION BY A.부서코드)    
                                                   --> 부서별로 최종 데이터인 경우
         THEN A.개별성과급 +                       --> 개별성과급에
              (A.부서성과급 - A.개별성과급누계)    --> 자투리를 더해 줌
         ELSE A.개별성과급
       END                   성과급
      ,A.급여비중
      ,A.부서성과급
      ,A.개별성과급
      ,A.개별성과급누계
FROM (
     -- 개별성과급누계와 부서사원수, 부서사원순번을 구함
     SELECT A.부서코드
           ,A.사원번호
           ,A.월급여
           ,A.급여비중
           ,A.부서성과급                                        부서성과급
           ,A.개별성과급
           ,SUM(A.개별성과급) OVER (PARTITION BY A.부서코드 
                                        ORDER BY A.월급여 DESC
                                                ,A.사원번호)    개별성과급누계
     FROM (
          -- (급여비중*부서성과급)으로 개별성과급을 구함
          SELECT A.부서코드
                ,A.사원번호
                ,A.월급여
                ,A.급여비중
                ,A.부서성과급                        부서성과급
                ,TRUNC(A.급여비중*A.부서성과급, -3)  개별성과급
          FROM (
               -- 급여비중과 부서성과급 포함
               SELECT A.부서코드
                     ,A.사원번호
                     ,A.월급여
                     ,ROUND(A.월급여/A.급여합, 4) 급여비중
                     ,1000000                     부서성과급
               FROM (
                    -- 부서별급여합
                    SELECT A.부서코드
                          ,A.사원번호
                          ,A.월급여
                          ,SUM(A.월급여) OVER (PARTITION BY A.부서코드) 급여합
                    FROM 사원 A
                    ) A
               ) A
          ) A
     ) A
ORDER BY A.부서코드
        ,A.월급여   DESC
        ,A.사원번호
;

원본 주소 "http://dbcafe.co.kr/wiki/index.php?title=오라클_함수&oldid=7222"

@@ 1번째 줄: / 1번째 줄: @@
-== Oracle  Function ==
+{{:오라클 함수}}
+----
-==== EXISTS ====
+{{:오라클 그룹함수}}
-  function EXISTS" return BOOLEAN;
+----
-pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj
+=== 윈도우/분석 함수 ===
+{{:분석함수}}
-==== GREATEST ====
-  function GREATEST (pattern NUMBER) return NUMBER;
-pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
-==== GREATEST ====
-  function GREATEST (pattern VARCHAR2 CHARACTER SET ANY_CS)
-return VARCHAR2 CHARACTER SET pattern%CHARSET;
-pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
-==== GREATEST ====
-  function GREATEST (pattern DATE) return DATE;
-pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
-==== LEAST ====
-  function LEAST (pattern NUMBER) return NUMBER;
-pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
-==== LEAST ====
-  function LEAST (pattern VARCHAR2 CHARACTER SET ANY_CS)
-return VARCHAR2 CHARACTER SET pattern%CHARSET;
-pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
-==== LEAST ====
-  function LEAST (pattern DATE) return DATE;
-pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
-==== DECODE ====
-  function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr NUMBER,
-   pat NUMBER,
-   res VARCHAR2 CHARACTER SET ANY_CS)
-return VARCHAR2 CHARACTER SET res%CHARSET;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr NUMBER, pat NUMBER, res DATE) return DATE;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
-   pat VARCHAR2 CHARACTER SET expr%CHARSET,
-   res NUMBER) return NUMBER;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
-   pat VARCHAR2 CHARACTER SET expr%CHARSET,
-   res VARCHAR2 CHARACTER SET ANY_CS)
-return VARCHAR2 CHARACTER SET res%CHARSET;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
-   pat VARCHAR2 CHARACTER SET expr%CHARSET,
-   res DATE) return DATE;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr DATE, pat DATE, res NUMBER) return NUMBER;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr DATE,
-   pat DATE,
-   res VARCHAR2 CHARACTER SET ANY_CS)
-return VARCHAR2 CHARACTER SET res%CHARSET;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-  function DECODE (expr DATE, pat DATE, res DATE) return DATE;
-pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
-==== 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
-[[Category:oracle]]