[Home] [Help]
PACKAGE: SYS.STANDARD
Source
1 package STANDARD AUTHID CURRENT_USER is -- careful on this line; SED edit occurs!
2
3 /********** Types and subtypes, do not reorder **********/
4 type BOOLEAN is (FALSE, TRUE);
5
6 type DATE is DATE_BASE;
7
8 type NUMBER is NUMBER_BASE;
9 subtype FLOAT is NUMBER; -- NUMBER(126)
10 subtype REAL is FLOAT; -- FLOAT(63)
11 subtype "DOUBLE PRECISION" is FLOAT;
12 subtype INTEGER is NUMBER(38,0);
13 subtype INT is INTEGER;
14 subtype SMALLINT is NUMBER(38,0);
15 subtype DECIMAL is NUMBER(38,0);
16 subtype NUMERIC is DECIMAL;
17 subtype DEC is DECIMAL;
18
19
20 subtype BINARY_INTEGER is INTEGER range '-2147483647'..2147483647;
21 subtype NATURAL is BINARY_INTEGER range 0..2147483647;
22 subtype NATURALN is NATURAL not null;
23 subtype POSITIVE is BINARY_INTEGER range 1..2147483647;
24 subtype POSITIVEN is POSITIVE not null;
25 subtype SIGNTYPE is BINARY_INTEGER range '-1'..1; -- for SIGN functions
26
27 type VARCHAR2 is NEW CHAR_BASE;
28
29 subtype VARCHAR is VARCHAR2;
30 subtype STRING is VARCHAR2;
31
32 subtype LONG is VARCHAR2(32760);
33
34 subtype RAW is VARCHAR2;
35 subtype "LONG RAW" is RAW(32760);
36
37 subtype ROWID is VARCHAR2(256);
38
39 -- Ansi fixed-length char
40 -- Define synonyms for CHAR and CHARN.
41 subtype CHAR is VARCHAR2;
42 subtype CHARACTER is CHAR;
43
44 type MLSLABEL is new CHAR_BASE;
45
46 -- Large object data types.
47 -- binary, character, binary file.
48 type BLOB is BLOB_BASE;
49 type CLOB is CLOB_BASE;
50 type BFILE is BFILE_BASE;
51
52 -- Verbose and NCHAR type names
53 subtype "CHARACTER VARYING" is VARCHAR;
54 subtype "CHAR VARYING" is VARCHAR;
55 subtype "NATIONAL CHARACTER" is CHAR CHARACTER SET NCHAR_CS;
56 subtype "NATIONAL CHAR" is CHAR CHARACTER SET NCHAR_CS;
57 subtype "NCHAR" is CHAR CHARACTER SET NCHAR_CS;
58 subtype "NATIONAL CHARACTER VARYING" is VARCHAR CHARACTER SET NCHAR_CS;
59 subtype "NATIONAL CHAR VARYING" is VARCHAR CHARACTER SET NCHAR_CS;
60 subtype "NCHAR VARYING" is VARCHAR CHARACTER SET NCHAR_CS;
61 subtype "NVARCHAR2" is VARCHAR2 CHARACTER SET NCHAR_CS;
62 subtype "CHARACTER LARGE OBJECT" is CLOB;
63 subtype "CHAR LARGE OBJECT" is CLOB;
64 subtype "NATIONAL CHARACTER LARGE OBJEC" is CLOB CHARACTER SET NCHAR_CS;
65 subtype "NCHAR LARGE OBJECT" is CLOB CHARACTER SET NCHAR_CS;
66 subtype "NCLOB" is CLOB CHARACTER SET NCHAR_CS;
67 subtype "BINARY LARGE OBJECT" is BLOB;
68
69 subtype pls_integer is binary_integer;
70
71 type TIME is new DATE_BASE;
72 type TIMESTAMP is new DATE_BASE;
73 type "TIME WITH TIME ZONE" is new DATE_BASE;
74 type "TIMESTAMP WITH TIME ZONE" is new DATE_BASE;
75 type "INTERVAL YEAR TO MONTH" is new DATE_BASE;
76 type "INTERVAL DAY TO SECOND" is new DATE_BASE;
77
78 SUBTYPE TIME_UNCONSTRAINED IS TIME(9);
79 SUBTYPE TIME_TZ_UNCONSTRAINED IS TIME(9) WITH TIME ZONE;
80 SUBTYPE TIMESTAMP_UNCONSTRAINED IS TIMESTAMP(9);
81 SUBTYPE TIMESTAMP_TZ_UNCONSTRAINED IS TIMESTAMP(9) WITH TIME ZONE;
82 SUBTYPE YMINTERVAL_UNCONSTRAINED IS INTERVAL YEAR(9) TO MONTH;
83 SUBTYPE DSINTERVAL_UNCONSTRAINED IS INTERVAL DAY(9) TO SECOND (9);
84
85 TYPE UROWID IS NEW CHAR_BASE;
86
87 type "TIMESTAMP WITH LOCAL TIME ZONE" is new DATE_BASE;
88 subtype timestamp_ltz_unconstrained is timestamp(9) with local time zone;
89
90 subtype BINARY_FLOAT is NUMBER;
91 subtype BINARY_DOUBLE is NUMBER;
92
93 -- The following data types are generics, used specially within package
94 -- STANDARD and some other Oracle packages. They are protected against
95 -- other use; sorry. True generic types are not yet part of the language.
96
97 type "<ADT_1>" as object (dummy char(1));
98 type "<RECORD_1>" is record (dummy char(1));
99 type "<TUPLE_1>" as object (dummy char(1));
100 type "<VARRAY_1>" is varray (1) of char(1);
101 type "<V2_TABLE_1>" is table of char(1) index by binary_integer;
102 type "<TABLE_1>" is table of char(1);
103 type "<COLLECTION_1>" is table of char(1);
104 type "<REF_CURSOR_1>" is ref cursor;
105
106 -- This will actually match against a Q_TABLE
107 type "<TYPED_TABLE>" is table of "<ADT_1>";
108 subtype "<ADT_WITH_OID>" is "<TYPED_TABLE>";
109
110 -- The following generic index table data types are used by the PL/SQL
111 -- compiler to materialize an array attribute at the runtime (for more
112 -- details about the array attributes, please see Bulk Binds document).
113 type " SYS$INT_V2TABLE" is table of integer index by binary_integer;
114
115 -- The following record type and the corresponding generic index table
116 -- data types are used by the PL/SQL compiler to materialize a table
117 -- at the runtime in order to record the exceptions raised during the
118 -- execution of FORALL bulk bind statement (for more details, please
119 -- see bulk binds extensions document in 8.2).
120 type " SYS$BULK_ERROR_RECORD" is
121 record (error_index pls_integer, error_code pls_integer);
122 type " SYS$REC_V2TABLE" is table of " SYS$BULK_ERROR_RECORD"
123 index by binary_integer;
124
125 /* Adding a generic weak ref cursor type */
126 type sys_refcursor is ref cursor;
127
128 /* the following data type is a generic for all opaque types */
129 type "<OPAQUE_1>" as opaque FIXED(1) USING LIBRARY dummy_lib
130 (static function dummy return number);
131
132 type "<ASSOC_ARRAY_1>" is table of char(1) index by varchar2(1);
133
134 /********** Add new types or subtypes here **********/
135
136 -- Simple scalar types
137
138 subtype SIMPLE_INTEGER is BINARY_INTEGER NOT NULL;
139 subtype SIMPLE_FLOAT is BINARY_FLOAT NOT NULL;
140 subtype SIMPLE_DOUBLE is BINARY_DOUBLE NOT NULL;
141
142 /********** Predefined constants **********/
143
144 BINARY_FLOAT_NAN constant BINARY_FLOAT;
145 BINARY_FLOAT_INFINITY constant BINARY_FLOAT;
146 BINARY_FLOAT_MAX_NORMAL constant BINARY_FLOAT;
147 BINARY_FLOAT_MIN_NORMAL constant BINARY_FLOAT;
148 BINARY_FLOAT_MAX_SUBNORMAL constant BINARY_FLOAT;
149 BINARY_FLOAT_MIN_SUBNORMAL constant BINARY_FLOAT;
150 BINARY_DOUBLE_NAN constant BINARY_DOUBLE;
151 BINARY_DOUBLE_INFINITY constant BINARY_DOUBLE;
152 BINARY_DOUBLE_MAX_NORMAL constant BINARY_DOUBLE;
153 BINARY_DOUBLE_MIN_NORMAL constant BINARY_DOUBLE;
154 BINARY_DOUBLE_MAX_SUBNORMAL constant BINARY_DOUBLE;
155 BINARY_DOUBLE_MIN_SUBNORMAL constant BINARY_DOUBLE;
156
157 /********** Add new constants here **********/
158
159 /********** Predefined exceptions **********/
160
161 CURSOR_ALREADY_OPEN exception;
162 pragma EXCEPTION_INIT(CURSOR_ALREADY_OPEN, '-6511');
163
164 DUP_VAL_ON_INDEX exception;
165 pragma EXCEPTION_INIT(DUP_VAL_ON_INDEX, '-0001');
166
167 TIMEOUT_ON_RESOURCE exception;
168 pragma EXCEPTION_INIT(TIMEOUT_ON_RESOURCE, '-0051');
169
170 INVALID_CURSOR exception;
171 pragma EXCEPTION_INIT(INVALID_CURSOR, '-1001');
172
173 NOT_LOGGED_ON exception;
174 pragma EXCEPTION_INIT(NOT_LOGGED_ON, '-1012');
175
176 LOGIN_DENIED exception;
177 pragma EXCEPTION_INIT(LOGIN_DENIED, '-1017');
178
179 NO_DATA_FOUND exception;
180 pragma EXCEPTION_INIT(NO_DATA_FOUND, 100);
181
182 ZERO_DIVIDE exception;
183 pragma EXCEPTION_INIT(ZERO_DIVIDE, '-1476');
184
185 INVALID_NUMBER exception;
186 pragma EXCEPTION_INIT(INVALID_NUMBER, '-1722');
187
188 TOO_MANY_ROWS exception;
189 pragma EXCEPTION_INIT(TOO_MANY_ROWS, '-1422');
190
191 STORAGE_ERROR exception;
192 pragma EXCEPTION_INIT(STORAGE_ERROR, '-6500');
193
194 PROGRAM_ERROR exception;
195 pragma EXCEPTION_INIT(PROGRAM_ERROR, '-6501');
196
197 VALUE_ERROR exception;
198 pragma EXCEPTION_INIT(VALUE_ERROR, '-6502');
199
200 ACCESS_INTO_NULL exception;
201 pragma EXCEPTION_INIT(ACCESS_INTO_NULL, '-6530');
202
203 COLLECTION_IS_NULL exception;
204 pragma EXCEPTION_INIT(COLLECTION_IS_NULL , '-6531');
205
206 SUBSCRIPT_OUTSIDE_LIMIT exception;
207 pragma EXCEPTION_INIT(SUBSCRIPT_OUTSIDE_LIMIT,'-6532');
208
209 SUBSCRIPT_BEYOND_COUNT exception;
210 pragma EXCEPTION_INIT(SUBSCRIPT_BEYOND_COUNT ,'-6533');
211
212 -- exception for ref cursors
213 ROWTYPE_MISMATCH exception;
214 pragma EXCEPTION_INIT(ROWTYPE_MISMATCH, '-6504');
215
216 SYS_INVALID_ROWID EXCEPTION;
217 PRAGMA EXCEPTION_INIT(SYS_INVALID_ROWID, '-1410');
218
219 -- The object instance i.e. SELF is null
220 SELF_IS_NULL exception;
221 pragma EXCEPTION_INIT(SELF_IS_NULL, '-30625');
222
223 CASE_NOT_FOUND exception;
224 pragma EXCEPTION_INIT(CASE_NOT_FOUND, '-6592');
225
226 -- Added for USERENV enhancement, bug 1622213.
227 USERENV_COMMITSCN_ERROR exception;
228 pragma EXCEPTION_INIT(USERENV_COMMITSCN_ERROR, '-1725');
229
230 -- Parallel and pipelined support
231 NO_DATA_NEEDED exception;
232 pragma EXCEPTION_INIT(NO_DATA_NEEDED, '-6548');
233 -- End of 8.2 parallel and pipelined support
234
235 /********** Add new exceptions here **********/
236
237 /********** Function, operators and procedures **********/
238
239 function "EXISTS" return BOOLEAN;
240 pragma BUILTIN('EXISTS',10,240,240); -- This is special cased in PH2 -- Pj
241
242 function GREATEST (pattern NUMBER) return NUMBER;
243 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
244 function GREATEST (pattern VARCHAR2 CHARACTER SET ANY_CS)
245 return VARCHAR2 CHARACTER SET pattern%CHARSET;
246 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
247 function GREATEST (pattern DATE) return DATE;
248 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
249
250 function LEAST (pattern NUMBER) return NUMBER;
251 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
252 function LEAST (pattern VARCHAR2 CHARACTER SET ANY_CS)
253 return VARCHAR2 CHARACTER SET pattern%CHARSET;
254 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
255 function LEAST (pattern DATE) return DATE;
256 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2 -- Pj
257
258 function DECODE (expr NUMBER, pat NUMBER, res NUMBER) return NUMBER;
259 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
260 function DECODE (expr NUMBER,
261 pat NUMBER,
262 res VARCHAR2 CHARACTER SET ANY_CS)
263 return VARCHAR2 CHARACTER SET res%CHARSET;
264 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
265 function DECODE (expr NUMBER, pat NUMBER, res DATE) return DATE;
266 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
267
268 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
269 pat VARCHAR2 CHARACTER SET expr%CHARSET,
270 res NUMBER) return NUMBER;
271 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
272 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
273 pat VARCHAR2 CHARACTER SET expr%CHARSET,
274 res VARCHAR2 CHARACTER SET ANY_CS)
275 return VARCHAR2 CHARACTER SET res%CHARSET;
276 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
277 function DECODE (expr VARCHAR2 CHARACTER SET ANY_CS,
278 pat VARCHAR2 CHARACTER SET expr%CHARSET,
279 res DATE) return DATE;
280 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
281
282 function DECODE (expr DATE, pat DATE, res NUMBER) return NUMBER;
283 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
284 function DECODE (expr DATE,
285 pat DATE,
286 res VARCHAR2 CHARACTER SET ANY_CS)
287 return VARCHAR2 CHARACTER SET res%CHARSET;
288 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
289 function DECODE (expr DATE, pat DATE, res DATE) return DATE;
290 pragma BUILTIN('DECODE',22,240,240);-- This is special cased in PH2 -- Pj
291
292 function SQLCODE return PLS_INTEGER;
293 pragma BUILTIN('SQLCODE',45, 10, 0); -- PEMS_DB, DB_SQLCODE
294
295 function SQLERRM return varchar2;
296 pragma FIPSFLAG('SQLERRM', 1452);
297
298 function SQLERRM (code PLS_INTEGER) return varchar2;
299 pragma BUILTIN('SQLERRM',46, 10, 1); -- PEMS_DB, DB_SQLERRM
300 pragma FIPSFLAG('SQLERRM', 1452);
301
302 function LEVEL return NUMBER;
303
304 function ROWNUM return NUMBER;
305
306 function '=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
307 pragma BUILTIN('=',2, 3, 1); -- PEMS_INTEGER, PEMDCMEQ
308 pragma FIPSFLAG('=', 1450);
309 function '!=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN; -- also <> and ~=
310 pragma BUILTIN('!=',5, 3, 2); -- PEMS_INTEGER, PEMDCMNE
311 pragma FIPSFLAG('!=', 1450);
312 function '<' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
313 pragma BUILTIN('<',4, 3, 3); -- PEMS_INTEGER, PEMDCMLT
314 pragma FIPSFLAG('<', 1450);
315 function '<=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
316 pragma BUILTIN('<=',6, 3, 4); -- PEMS_INTEGER, PEMDCMLE
317 pragma FIPSFLAG('<=', 1450);
318 function '>' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
319 pragma BUILTIN('>',1, 3, 5); -- PEMS_INTEGER, PEMDCMGT
320 pragma FIPSFLAG('>', 1450);
321 function '>=' (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
322 pragma BUILTIN('>=',3, 3, 6); -- PEMS_INTEGER, PEMDMGE
323 pragma FIPSFLAG('>=', 1450);
324
325 -- Since SQL permits short-circuit evaluation, the 'and' and 'or'
326 -- operations will always be interpreted as 'and then' and 'or else'
327 -- when they occur in conditional statements.
328
329 function XOR (LEFT BOOLEAN, RIGHT BOOLEAN) return BOOLEAN;
330 pragma BUILTIN('XOR',8, 3, 9); -- PEMS_INTEGER, INT_XOR
331 pragma FIPSFLAG('XOR', 1450);
332
333 function 'NOT' (RIGHT BOOLEAN) return BOOLEAN;
334 pragma BUILTIN('NOT',9, 3, 10); -- PEMS_INTEGER, INT_NOT
335
336 function 'IS NULL' (B BOOLEAN) return BOOLEAN;
337 pragma BUILTIN('IS NULL', 0, 3, 0); -- PEMS_INTEGER, PEMDNUL
338 pragma FIPSFLAG('IS NULL', 1450);
339
340 function 'IS NOT NULL' (B BOOLEAN) return BOOLEAN;
341 pragma BUILTIN('IS NOT NULL', 0, 3, 50); -- PEMS_INTEGER, PEMDNUL
342 pragma FIPSFLAG('IS NOT NULL', 1450);
343
344 function NVL (B1 BOOLEAN, B2 BOOLEAN) return BOOLEAN;
345 pragma FIPSFLAG('NVL', 1450);
346
347 function '=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
348 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
349 pragma BUILTIN('=',2, 1, 14); -- PEMS_CHAR, PEMDCMEQ (VARCHAR2 SEMANTICS)
350 pragma FIPSFLAG('=', 1454);
351 function '!=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
352 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
353 pragma BUILTIN('!=',5, 1, 15); -- PEMS_CHAR, PEMDCMNE (VARCHAR2 SEMANTICS)
354 pragma FIPSFLAG('!=', 1454);
355 function '<' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
356 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
357 pragma BUILTIN('<',4, 1, 16); -- PEMS_CHAR, PEMDCMLT (VARCHAR2 SEMANTICS)
358 pragma FIPSFLAG('<', 1454);
359 function '<=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
360 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
361 pragma BUILTIN('<=',6, 1, 17); -- PEMS_CHAR, PEMDCMLE (VARCHAR2 SEMANTICS)
362 pragma FIPSFLAG('<=', 1454);
363 function '>' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
364 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
365 pragma BUILTIN('>',1, 1, 18); -- PEMS_CHAR, PEMDCMGT (VARCHAR2 SEMANTICS)
366 pragma FIPSFLAG('>', 1454);
367 function '>=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
368 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
369 pragma BUILTIN('>=',3, 1, 19); -- PEMS_CHAR, PEMDCMGE (VARCHAR2 SEMANTICS)
370 pragma FIPSFLAG('>=', 1454);
371
372 function '||' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
373 RIGHT VARCHAR2 CHARACTER SET ANY_CS)
374 return VARCHAR2 CHARACTER SET LEFT%CHARSET;
375 pragma BUILTIN('||',25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
376 pragma FIPSFLAG('||', 1454);
377
378 function CONCAT(LEFT VARCHAR2 CHARACTER SET ANY_CS,
379 RIGHT VARCHAR2 CHARACTER SET ANY_CS)
380 return VARCHAR2 CHARACTER SET LEFT%CHARSET;
381 pragma BUILTIN(CONCAT,25, 1, 7); -- PEMS_CHAR, CHAR_CONCAT
382 pragma FIPSFLAG(CONCAT, 1454);
383
387 -- In substr and instr, a negative value of parameter POS means to
384 function LENGTH(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
385 pragma FIPSFLAG('LENGTH', 1452);
386 -- In SUBSTR, LEN defaults to remainder of string
388 -- count from the right end of the string.
389 function SUBSTR(STR1 VARCHAR2 CHARACTER SET ANY_CS,
390 POS PLS_INTEGER,
391 LEN PLS_INTEGER := 2147483647)
392 return VARCHAR2 CHARACTER SET STR1%CHARSET;
393 pragma FIPSFLAG('SUBSTR', 1452);
394
395 -- Find nth occurrence of str1 in str2 starting at pos
396 function INSTR(STR1 VARCHAR2 CHARACTER SET ANY_CS,
397 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
398 POS PLS_INTEGER := 1,
399 NTH POSITIVE := 1) return PLS_INTEGER;
400 pragma FIPSFLAG('INSTR', 1452);
401
402 function UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
403 return VARCHAR2 CHARACTER SET ch%CHARSET;
404 pragma FIPSFLAG('UPPER', 1452);
405 function LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
406 return VARCHAR2 CHARACTER SET ch%CHARSET;
407 pragma FIPSFLAG('LOWER', 1452);
408 function ASCII(ch VARCHAR2 CHARACTER SET ANY_CS)
409 return INTEGER; -- should be ASCII.CHRANGE
410 pragma FIPSFLAG('ASCII', 1452);
411 function ASCIISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
412 return VARCHAR2 CHARACTER SET ch%CHARSET;
413 pragma FIPSFLAG('ASCIISTR', 1452);
414 function UNISTR(ch VARCHAR2 CHARACTER SET ANY_CS)
415 return NVARCHAR2;
416 pragma FIPSFLAG('UNISTR', 1452);
417 function CHR(n INTEGER) return varchar2; -- N should be ASCII.CHRANGE
418 pragma FIPSFLAG('CHR', 1452);
419 function " SYS$STANDARD_CHR"(n INTEGER,csn VARCHAR2 CHARACTER SET ANY_CS)
420 return VARCHAR2 CHARACTER SET csn%CHARSET;
421 pragma FIPSFLAG(' SYS$STANDARD_CHR', 1452);
422 function INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
423 return VARCHAR2 CHARACTER SET ch%CHARSET;
424 pragma FIPSFLAG('INITCAP', 1452);
425 function SOUNDEX(ch VARCHAR2 CHARACTER SET ANY_CS)
426 return VARCHAR2 CHARACTER SET ch%CHARSET;
427 pragma FIPSFLAG('SOUNDEX', 1452);
428
429 function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
430 LEN pls_integer,
431 PAD VARCHAR2 CHARACTER SET STR1%CHARSET)
432 return VARCHAR2 CHARACTER SET STR1%CHARSET;
433 pragma FIPSFLAG('LPAD', 1452);
434 function LPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
435 LEN pls_integer)
436 return VARCHAR2 CHARACTER SET STR1%CHARSET;
437 pragma FIPSFLAG('LPAD', 1452);
438
439 function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
440 LEN pls_integer,
441 PAD VARCHAR2 CHARACTER SET STR1%CHARSET)
442 return VARCHAR2 CHARACTER SET STR1%CHARSET;
443 pragma FIPSFLAG('RPAD', 1452);
444 function RPAD(STR1 VARCHAR2 CHARACTER SET ANY_CS,
445 LEN pls_integer)
446 return VARCHAR2 CHARACTER SET STR1%CHARSET;
447 pragma FIPSFLAG('RPAD', 1452);
448
449 function TRANSLATE(STR1 VARCHAR2 CHARACTER SET ANY_CS,
450 SRC VARCHAR2 CHARACTER SET STR1%CHARSET,
451 DEST VARCHAR2 CHARACTER SET STR1%CHARSET)
452 return VARCHAR2 CHARACTER SET STR1%CHARSET;
453 pragma FIPSFLAG('TRANSLATE', 1452);
454
455 function REPLACE(SRCSTR VARCHAR2 CHARACTER SET ANY_CS,
456 OLDSUB VARCHAR2 CHARACTER SET SRCSTR%CHARSET,
457 NEWSUB VARCHAR2 CHARACTER SET SRCSTR%CHARSET := NULL)
458 return VARCHAR2 CHARACTER SET SRCSTR%CHARSET;
459 pragma FIPSFLAG('REPLACE', 1452);
460
461 function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ',
462 TSET VARCHAR2 CHARACTER SET STR1%CHARSET)
463 return VARCHAR2 CHARACTER SET STR1%CHARSET;
464 pragma FIPSFLAG('LTRIM', 1452);
465 function LTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
466 return VARCHAR2 CHARACTER SET STR1%CHARSET;
467 pragma FIPSFLAG('LTRIM', 1452);
468
469 function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ',
470 TSET VARCHAR2 CHARACTER SET STR1%CHARSET)
471 return VARCHAR2 CHARACTER SET STR1%CHARSET;
472 pragma FIPSFLAG('RTRIM', 1452);
473 function RTRIM(STR1 VARCHAR2 CHARACTER SET ANY_CS := ' ')
474 return VARCHAR2 CHARACTER SET STR1%CHARSET;
475 pragma FIPSFLAG('RTRIM', 1452);
476
477 function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
478 pat VARCHAR2 CHARACTER SET str%CHARSET)
479 return BOOLEAN;
480 function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
481 pat VARCHAR2 CHARACTER SET str%CHARSET)
482 return BOOLEAN;
483 function 'LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
484 pat VARCHAR2 CHARACTER SET str%CHARSET,
485 esc VARCHAR2 CHARACTER SET str%CHARSET)
486 return BOOLEAN;
487 function 'NOT_LIKE' (str VARCHAR2 CHARACTER SET ANY_CS,
488 pat VARCHAR2 CHARACTER SET str%CHARSET,
489 esc VARCHAR2 CHARACTER SET str%CHARSET)
490 return BOOLEAN;
491 function 'IS NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
492 pragma BUILTIN('IS NULL', 0, 1, 20); -- PEMS_CHAR, PEMDNUL
493 function 'IS NOT NULL' (s VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
494 pragma BUILTIN('IS NOT NULL', 0, 1, 50); -- PEMS_CHAR, PEMDNUL
495
496 function NVL(s1 VARCHAR2 CHARACTER SET ANY_CS,
497 s2 VARCHAR2 CHARACTER SET s1%CHARSET)
498 return VARCHAR2 CHARACTER SET s1%CHARSET;
502 function '=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
499 pragma FIPSFLAG('NVL', 1452);
500
501
503 pragma BUILTIN('=',2, 2, 1); -- PEMS_NUMBER, PEMDCMEQ
504 function '!=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN; -- also <> and ~=
505 pragma BUILTIN('!=',5, 2, 2); -- PEMS_NUMBER, PEMDCMNE
506 pragma FIPSFLAG('!=', 1452);
507 function '<' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
508 pragma BUILTIN('<',4, 2, 3); -- PEMS_NUMBER, PEMDCMLT
509 function '<=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
510 pragma BUILTIN('<=',6, 2, 4); -- PEMS_NUMBER, PEMDCMLE
511 function '>' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
512 pragma BUILTIN('>',1, 2, 5); -- PEMS_NUMBER, PEMDCMGT
513 function '>=' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
514 pragma BUILTIN('>=',3, 2, 6); -- PEMS_NUMBER, PEMDCMGE
515
516 function 'IS NULL' (n NUMBER) return BOOLEAN;
517 pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
518 function 'IS NOT NULL' (n NUMBER) return BOOLEAN;
519 pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_NUMBER, PEMDNUL
520
521 function NVL(n1 NUMBER, n2 NUMBER) return NUMBER;
522 pragma FIPSFLAG('NVL', 1452);
523
524 function '+' (RIGHT NUMBER) return NUMBER;
525 pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
526 function '-' (RIGHT NUMBER) return NUMBER;
527 pragma BUILTIN('-',15, 2, 7); -- PEMS_NUMBER, NUM_NEG
528 function ABS(n NUMBER) return NUMBER;
529 pragma FIPSFLAG('ABS', 1452);
530
531 function '+' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
532 pragma BUILTIN('+',14, 2, 8); -- PEMS_NUMBER, NUM_ADD
533 function '-' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
534 pragma BUILTIN('-',15, 2, 9); -- PEMS_NUMBER, NUM_SUB
535 function '*' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
536 pragma BUILTIN('*',17, 2, 10); -- PEMS_NUMBER, NUM_MUL
537 function '/' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
538 pragma BUILTIN('/',18, 2, 11); -- PEMS_NUMBER, NUM_DIV
539
540 function 'REM' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
541 pragma FIPSFLAG('REM', 1452);
542 function 'MOD'(n1 NUMBER, n2 NUMBER) return NUMBER;
543 pragma FIPSFLAG('MOD', 1452);
544
545 function '**' (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
546 pragma FIPSFLAG('**', 1452);
547
548 function FLOOR(n NUMBER) return NUMBER;
549 pragma FIPSFLAG('FLOOR', 1452);
550 function CEIL(n NUMBER) return NUMBER;
551 pragma FIPSFLAG('CEIL', 1452);
552 function SQRT(n NUMBER) return NUMBER;
553 pragma FIPSFLAG('SQRT', 1452);
554 function SIGN(n NUMBER) return SIGNTYPE;
555 pragma FIPSFLAG('SIGN', 1452);
556
557 function COS(N NUMBER) return NUMBER;
558 pragma FIPSFLAG('COS', 1452);
559 function SIN(N NUMBER) return NUMBER;
560 pragma FIPSFLAG('SIN', 1452);
561 function TAN(N NUMBER) return NUMBER;
562 pragma FIPSFLAG('TAN', 1452);
563 function COSH(N NUMBER) return NUMBER;
564 pragma FIPSFLAG('COSH', 1452);
565 function SINH(N NUMBER) return NUMBER;
566 pragma FIPSFLAG('SINH', 1452);
567 function TANH(N NUMBER) return NUMBER;
568 pragma FIPSFLAG('TANH', 1452);
569
570 function EXP(N NUMBER) return NUMBER;
571 function LN(N NUMBER) return NUMBER;
572
573 function BITAND (LEFT pls_integer, RIGHT pls_integer)
574 return pls_integer;
575 function BITAND (LEFT integer, RIGHT integer)
576 return integer;
577 function LOG (LEFT NUMBER, RIGHT NUMBER) return NUMBER;
578
579 function TRUNC (n NUMBER, places pls_integer := 0) return NUMBER;
580 pragma FIPSFLAG('TRUNC', 1452);
581
582 function ROUND (LEFT NUMBER, RIGHT pls_integer := 0) return NUMBER;
583 pragma FIPSFLAG('ROUND', 1452);
584
585 function POWER (n NUMBER, e NUMBER) return NUMBER;
586 pragma FIPSFLAG('POWER', 1452);
587
588 function '=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
589 pragma BUILTIN('=',2, 12, 1); -- PEMS_DATE, PEMDCMEQ
590 pragma FIPSFLAG('=', 1450);
591 function '!=' (LEFT DATE, RIGHT DATE) return BOOLEAN; -- also <> and ~=
592 pragma BUILTIN('!=',5, 12, 2); -- PEMS_DATE, PEMDCMNE
593 pragma FIPSFLAG('!=', 1450);
594 function '<' (LEFT DATE, RIGHT DATE) return BOOLEAN;
595 pragma BUILTIN('<',4, 12, 3); -- PEMS_DATE, PEMDCMLT
596 pragma FIPSFLAG('<', 1450);
597 function '<=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
598 pragma BUILTIN('<=',6, 12, 4); -- PEMS_DATE, PEMDCMLE
599 pragma FIPSFLAG('<=', 1450);
600 function '>' (LEFT DATE, RIGHT DATE) return BOOLEAN;
601 pragma BUILTIN('>',1, 12, 5); -- PEMS_DATE, PEMDCMGT
602 pragma FIPSFLAG('>', 1450);
603 function '>=' (LEFT DATE, RIGHT DATE) return BOOLEAN;
604 pragma BUILTIN('>=',3, 12, 6); -- PEMS_DATE, PEMDCMGE
605 pragma FIPSFLAG('>=', 1450);
606
607 function '+' (LEFT DATE, RIGHT NUMBER) return DATE;
608 pragma BUILTIN('+',14, 12, 7); -- PEMS_DATE, DATE_ADD1
609 pragma FIPSFLAG('+', 1450);
610 function '+' (LEFT NUMBER, RIGHT DATE) return DATE;
611 pragma BUILTIN('+',14, 12, 8); -- PEMS_DATE, DATE_ADD2
612 pragma FIPSFLAG('+', 1450);
613 function '-' (LEFT DATE, RIGHT NUMBER) return DATE;
614 pragma BUILTIN('-',15, 12, 9); -- PEMS_DATE, DATE_SUB1
615 pragma FIPSFLAG('-', 1450);
616 function '-' (LEFT NUMBER, RIGHT DATE) return DATE;
617 pragma BUILTIN('-',15, 12, 10); -- PEMS_DATE, DATE_SUB2
618 pragma FIPSFLAG('-', 1450);
619 function '-' (LEFT DATE, RIGHT DATE) return NUMBER;
620 pragma BUILTIN('-',15, 12, 11); -- PEMS_DATE, DATE_SUB3
621 pragma FIPSFLAG('-', 1450);
622
626 function ADD_MONTHS(LEFT DATE, RIGHT NUMBER) return DATE;
623 function LAST_DAY(RIGHT DATE) return DATE;
624 pragma BUILTIN('LAST_DAY',38, 12, 12); -- PEMS_DATE, DATE_LAST_DAY
625 pragma FIPSFLAG('LAST_DAY', 1450);
627 pragma BUILTIN('ADD_MONTHS',39, 12, 13); -- PEMS_DATE, DATE_ADD_MONTHS1
628 pragma FIPSFLAG('ADD_MONTHS', 1450);
629 function ADD_MONTHS(LEFT NUMBER, RIGHT DATE) return DATE;
630 pragma BUILTIN('ADD_MONTHS',39, 12, 14); -- PEMS_DATE, DATE_ADD_MONTHS2
631 pragma FIPSFLAG('ADD_MONTHS', 1450);
632
633 function MONTHS_BETWEEN(LEFT DATE, RIGHT DATE) return NUMBER;
634 pragma BUILTIN('MONTHS_BETWEEN',42, 12, 15); -- PEMS_DATE, DATE_MONTHS_BET
635 pragma FIPSFLAG('MONTHS_BETWEEN', 1450);
636 function NEXT_DAY(LEFT DATE, RIGHT VARCHAR2) return DATE;
637 pragma BUILTIN('NEXT_DAY',43, 12, 16); -- PEMS_DATE, DATE_NEXT_DAY
638 pragma FIPSFLAG('NEXT_DAY', 1450);
639 function ROUND(RIGHT DATE) return DATE;
640 pragma BUILTIN('ROUND',24, 12, 17); -- PEMS_DATE, DATE_ROUND
641 pragma FIPSFLAG('ROUND', 1450);
642 function NEW_TIME(RIGHT DATE, MIDDLE VARCHAR2, LEFT VARCHAR2) return DATE;
643 pragma FIPSFLAG('NEW_TIME', 1450);
644
645 function 'IS NULL' (d DATE) return BOOLEAN;
646 pragma BUILTIN('IS NULL', 0, 12, 0); -- PEMS_DATE, PEMDNUL
647 pragma FIPSFLAG('IS NULL', 1450);
648 function 'IS NOT NULL' (d DATE) return BOOLEAN;
649 pragma BUILTIN('IS NOT NULL', 0, 12, 50); -- PEMS_DATE, PEMDNUL
650 pragma FIPSFLAG('IS NOT NULL', 1450);
651 function NVL (d1 DATE, d2 DATE) return DATE;
652 pragma FIPSFLAG('NVL', 1450);
653
654 function TRUNC(LEFT DATE) return DATE;
655 pragma BUILTIN('TRUNC',51, 12, 20); -- PEMS_DATE, DATE_TRUNC1
656 pragma FIPSFLAG('TRUNC', 1450);
657 function TRUNC(LEFT DATE, RIGHT VARCHAR2) return DATE;
658 pragma BUILTIN('TRUNC',51, 12, 21); -- PEMS_DATE, DATE_TRUNC2
659 pragma FIPSFLAG('TRUNC', 1450);
660 function ROUND(LEFT DATE, RIGHT VARCHAR2) return DATE;
661 pragma BUILTIN('ROUND',24, 12, 22); -- PEMS_DATE, DATE_ROUND2
662 pragma FIPSFLAG('ROUND', 1450);
663
664 function TO_DATE (RIGHT VARCHAR2 character set any_cs) return DATE;
665 pragma BUILTIN('TO_DATE',40, 1, 10); -- PEMS_CHAR, CHR_CNV_DAT
666 pragma FIPSFLAG('TO_DATE', 1450);
667
668 function TO_DATE (LEFT VARCHAR2 character set any_cs,
669 RIGHT VARCHAR2 character set LEFT%charset) return DATE;
670 pragma BUILTIN('TO_DATE',40, 1, 8); -- PEMS_CHAR, CHR_CNV_DATE
671 pragma FIPSFLAG('TO_DATE', 1450);
672
673 function TO_DATE (LEFT NUMBER, RIGHT VARCHAR2) return DATE;
674 pragma FIPSFLAG('TO_DATE', 1450);
675
676 function TO_DATE(left varchar2 character set any_cs,
677 format varchar2 character set LEFT%charset,
678 parms varchar2 character set LEFT%charset) return date;
679
680 function TO_CHAR (RIGHT VARCHAR2) return VARCHAR2;
681 pragma BUILTIN('TO_CHAR',14, 0, 2);
682
683 function TO_CHAR (LEFT DATE, RIGHT VARCHAR2) return VARCHAR2;
684 pragma BUILTIN('TO_CHAR',41, 12, 19); -- PEMS_DATE, DAT_CNV_CHR1
685 pragma FIPSFLAG('TO_CHAR', 1450);
686
687 function TO_CHAR (LEFT NUMBER, RIGHT VARCHAR2) return VARCHAR2;
688 pragma BUILTIN('TO_CHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
689
690 function TO_NUMBER (RIGHT NUMBER) RETURN NUMBER;
691 pragma BUILTIN('TO_NUMBER',14, 0, 1); -- PEMS_QUICK
692
693 function TO_NUMBER (RIGHT VARCHAR2 character set any_cs) return NUMBER;
694 pragma BUILTIN('TO_NUMBER',48, 1, 9); -- PEMS_CHAR, CHR_CNV_NUM
695
696 function TO_NUMBER(left varchar2 character set any_cs,
697 format varchar2 character set LEFT%charset)
698 return number;
699 function TO_NUMBER(left varchar2 character set any_cs,
700 format varchar2 character set LEFT%charset,
701 parms varchar2 character set LEFT%charset)
702 return number;
703
704 -- Define SQL predicates. These don't gen code, so no body is needed.
705
706 -- PRIOR is WEIRD - For now, it will be treated as a function call.
707 -- Does the function only take a column name? how about its use in
708 -- a predicate?
709 function 'PRIOR'(colname VARCHAR2 CHARACTER SET ANY_CS)
710 return VARCHAR2 CHARACTER SET colname%CHARSET;
711 pragma FIPSFLAG('PRIOR', 1452);
712 function 'PRIOR'(colname NUMBER) return NUMBER;
713 pragma FIPSFLAG('PRIOR', 1452);
714 function 'PRIOR'(colname DATE) return DATE;
715 pragma FIPSFLAG('PRIOR', 1450);
716
717 -- Outer Join has same problem as PRIOR
718 function '(+)'(colname VARCHAR2 CHARACTER SET ANY_CS)
719 return VARCHAR2 CHARACTER SET colname%CHARSET;
720 function '(+)'(colname NUMBER) return NUMBER;
721 function '(+)'(colname DATE) return DATE;
722 pragma FIPSFLAG('(+)', 1450);
723
724 function '=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
725 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
726 return BOOLEAN;
727 function '=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
728 pragma FIPSFLAG('=ANY', 1450);
729 function '=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
730
731 function '!=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
732 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
733 return BOOLEAN;
734 function '!=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
735 pragma FIPSFLAG('!=ANY', 1450);
736 function '!=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
737
738 function '<ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
742 pragma FIPSFLAG('<ANY', 1450);
739 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
740 return BOOLEAN;
741 function '<ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
743 function '<ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
744
745 function '<=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
746 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
747 return BOOLEAN;
748 function '<=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
749 pragma FIPSFLAG('<=ANY', 1450);
750 function '<=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
751
752 function '>ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
753 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
754 return BOOLEAN;
755 function '>ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
756 pragma FIPSFLAG('>ANY', 1450);
757 function '>ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
758
759 function '>=ANY' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
760 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
761 return BOOLEAN;
762 function '>=ANY' (LEFT DATE, RIGHT DATE) return BOOLEAN;
763 pragma FIPSFLAG('>=ANY', 1450);
764 function '>=ANY' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
765
766 function '=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
767 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
768 return BOOLEAN;
769 function '=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
770 pragma FIPSFLAG('=ALL', 1450);
771 function '=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
772
773 function '!=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
774 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
775 return BOOLEAN;
776 function '!=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
777 pragma FIPSFLAG('!=ALL', 1450);
778 function '!=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
779
780 function '<ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
781 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
782 return BOOLEAN;
783 function '<ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
784 pragma FIPSFLAG('<ALL', 1450);
785 function '<ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
786
787 function '<=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
788 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
789 return BOOLEAN;
790 function '<=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
791 pragma FIPSFLAG('<=ALL', 1450);
792 function '<=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
793
794 function '>ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
795 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
796 return BOOLEAN;
797 function '>ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
798 pragma FIPSFLAG('>ALL', 1450);
799 function '>ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
800
801 function '>=ALL' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
802 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
803 return BOOLEAN;
804 function '>=ALL' (LEFT DATE, RIGHT DATE) return BOOLEAN;
805 pragma FIPSFLAG('>=ALL', 1450);
806 function '>=ALL' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
807
808 function '=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
809 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
810 return BOOLEAN;
811 function '=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
812 pragma FIPSFLAG('=SOME', 1450);
813 function '=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
814
815 function '!=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
816 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
817 return BOOLEAN;
818 function '!=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
819 pragma FIPSFLAG('!=SOME', 1450);
820 function '!=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
821
822 function '<SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
823 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
824 return BOOLEAN;
825 function '<SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
826 pragma FIPSFLAG('<SOME', 1450);
827 function '<SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
828
829 function '<=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
830 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
831 return BOOLEAN;
832 function '<=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
833 pragma FIPSFLAG('<=SOME', 1450);
834 function '<=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
835
836 function '>SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
837 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
838 return BOOLEAN;
839 function '>SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
840 pragma FIPSFLAG('>SOME', 1450);
841 function '>SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
842
843 function '>=SOME' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
844 RIGHT VARCHAR2 CHARACTER SET LEFT%CHARSET)
845 return BOOLEAN;
846 function '>=SOME' (LEFT DATE, RIGHT DATE) return BOOLEAN;
847 pragma FIPSFLAG('>=SOME', 1450);
848 function '>=SOME' (LEFT NUMBER, RIGHT NUMBER) return BOOLEAN;
849
850 -- SQL Transaction routines
851 procedure SET_TRANSACTION_USE(vc VARCHAR2);
852 procedure COMMIT;
853 procedure COMMIT_CM(vc VARCHAR2);
854 procedure ROLLBACK_NR;
855 procedure ROLLBACK_SV(Save_Point CHAR);
856 procedure SAVEPOINT(Save_Point CHAR);
860
857
858 function SYSDATE return DATE;
859 pragma FIPSFLAG('SYSDATE', 1452);
861 function UID return PLS_INTEGER;
862 pragma FIPSFLAG('UID', 1452);
863
864 function USER return VARCHAR2;
865
866 function USERENV (envstr VARCHAR2) return VARCHAR2;
867 pragma FIPSFLAG('USERENV', 1452);
868
869 -- ROWID: this dreadful identifier is supposed to represent a datatype
870 -- outside of SQL and and a pseudo-column (function, to us) when inside
871 -- a sql statement. ADA data model doesn't allow for any
872 -- function X return X;
873 -- so we must special case this. Yuk. There's special-case code in ph2nre
874 -- which maps "rowid" to "rowid " if we're inside a SQL stmt.
875 function "ROWID " return ROWID;
876 pragma builtin('ROWID ', 1, 209, 240); -- this had better never be called.
877
878 function NULLFN (str VARCHAR2) return RAW;
879 pragma builtin('NULLFN', 1, 0, 1);
880
881 function HEXTORAW (c VARCHAR2) return RAW;
882 pragma builtin('HEXTORAW', 1, 23, 1);
883
884 function RAWTOHEX (r RAW) return VARCHAR2;
885 pragma builtin('RAWTOHEX', 1, 23, 2);
886
887 function CHARTOROWID (str VARCHAR2) return ROWID;
888 pragma builtin('CHARTOROWID', 1, 0, 1);
889
890 function ROWIDTOCHAR (str ROWID) return VARCHAR2;
891 pragma builtin('ROWIDTOCHAR', 1, 0, 1);
892
893
894 -- Trusted*Oracle additions
895 Function ROWLABEL return MLSLABEL; -- pseudo column
896
897 Function TO_CHAR(label MLSLABEL, format VARCHAR2) return VARCHAR2;
898 pragma BUILTIN('TO_CHAR',90, 4, 19); -- PEMS_DATE, MLS_CNV_CHR1
899 pragma FIPSFLAG('TO_CHAR', 1450);
900
901 Function TO_LABEL(label VARCHAR2, format VARCHAR2 ) return MLSLABEL;
902 pragma BUILTIN('TO_LABEL',90, 4, 8); -- PEMS_CHAR, CHR_CNV_MLS
903 pragma FIPSFLAG('TO_LABEL', 1450);
904
905 Function TO_LABEL(label VARCHAR2 ) return MLSLABEL;
906 pragma BUILTIN('TO_LABEL',90, 4, 2); -- PEMS_CHAR, CHR_CNV_MLS
907 pragma FIPSFLAG('TO_LABEL', 1450);
908
909 -- vararg routines - icds in stdbdy
910 Function LEAST_UB (pattern MLSLABEL) return MLSLABEL;
911 pragma BUILTIN('LEAST_UB',90, 4, 3); -- PEMS_CHAR, CHR_CNV_MLS
912 Function GREATEST_LB (pattern MLSLABEL) return MLSLABEL;
913 pragma BUILTIN('GREATEST_LB',90, 4, 4); -- PEMS_CHAR, CHR_CNV_MLS
914
915 Function '>=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
916 Function '>' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
917 Function '<=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
918 Function '<' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
919 Function '=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
920 Function '!=' (label1 MLSLABEL, label2 MLSLABEL) return BOOLEAN;
921 function 'IS NULL' (label MLSLABEL) return BOOLEAN;
922 pragma BUILTIN('IS NULL', 0, 1, 20); -- same "cod" as IS NULL(varchar2)
923 function 'IS NOT NULL' (label MLSLABEL) return BOOLEAN;
924 pragma BUILTIN('IS NOT NULL', 0, 1, 50);
925
926 function NVL(label1 MLSLABEL, label2 MLSLABEL) return MLSLABEL;
927 pragma FIPSFLAG('NVL', 1452);
928
929 -- group functions
930 Function LUB (label MLSLABEL) return MLSLABEL;
931 Function GLB (label MLSLABEL) return MLSLABEL;
932
933 -- end of Trusted*Oracle additions
934
935
936 -- beginning of NLS routines
937
938 function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS) return RAW;
939 pragma FIPSFLAG('NLSSORT', 1452);
940 function NLSSORT(c VARCHAR2 CHARACTER SET ANY_CS, c2 VARCHAR2) return RAW;
941 pragma FIPSFLAG('NLSSORT', 1452);
942 function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS,
943 parms VARCHAR2 CHARACTER SET ch%CHARSET)
944 return VARCHAR2 CHARACTER SET ch%CHARSET;
945 pragma FIPSFLAG('NLS_UPPER', 1452);
946 function NLS_UPPER(ch VARCHAR2 CHARACTER SET ANY_CS)
947 return VARCHAR2 CHARACTER SET ch%CHARSET;
948 pragma FIPSFLAG('NLS_UPPER', 1452);
949 function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS,
950 parms VARCHAR2 CHARACTER SET ch%CHARSET)
951 return VARCHAR2 CHARACTER SET ch%CHARSET;
952 pragma FIPSFLAG('NLS_LOWER', 1452);
953 function NLS_LOWER(ch VARCHAR2 CHARACTER SET ANY_CS)
954 return VARCHAR2 CHARACTER SET ch%CHARSET;
955 pragma FIPSFLAG('NLS_LOWER', 1452);
956 function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS,
957 parms VARCHAR2 CHARACTER SET ch%CHARSET)
958 return VARCHAR2 CHARACTER SET ch%CHARSET;
959 pragma FIPSFLAG('NLS_INITCAP', 1452);
960 function NLS_INITCAP(ch VARCHAR2 CHARACTER SET ANY_CS)
961 return VARCHAR2 CHARACTER SET ch%CHARSET;
962 pragma FIPSFLAG('NLS_INITCAP', 1452);
963
964 function LENGTHB(ch VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
965 pragma FIPSFLAG('LENGTHB', 1452);
966 function SUBSTRB(STR1 VARCHAR2 CHARACTER SET ANY_CS,
967 POS PLS_INTEGER,
968 LEN PLS_INTEGER := 2147483647)
969 return VARCHAR2 CHARACTER SET STR1%CHARSET;
970 pragma FIPSFLAG('SUBSTRB', 1452);
971 function INSTRB(STR1 VARCHAR2 CHARACTER SET ANY_CS,
972 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
973 POS PLS_INTEGER := 1,
974 NTH POSITIVE := 1) return PLS_INTEGER;
975 pragma FIPSFLAG('INSTRB', 1452);
976
977 function TO_SINGLE_BYTE(c VARCHAR2 CHARACTER SET ANY_CS)
978 return VARCHAR2 CHARACTER SET c%CHARSET;
982 pragma FIPSFLAG('TO_MULTI_BYTE', 1452);
979 pragma FIPSFLAG('TO_SINGLE_BYTE', 1452);
980 function TO_MULTI_BYTE(c VARCHAR2 CHARACTER SET ANY_CS)
981 return VARCHAR2 CHARACTER SET c%CHARSET;
983
984 -- Next two added for NLS 6/3/92 JEM.
985 function TO_CHAR(left date, format varchar2, parms varchar2) return varchar2;
986 function TO_CHAR(left number, format varchar2, parms varchar2)
987 return varchar2;
988 function NLS_CHARSET_NAME(csetid PLS_INTEGER) return VARCHAR2;
989 function NLS_CHARSET_ID(csetname VARCHAR2) return PLS_INTEGER;
990 function NLS_CHARSET_DECL_LEN(bytecnt NUMBER, csetid NUMBER)
991 return PLS_INTEGER;
992
993 -- end of NLS routines
994
995 function CONVERT(src VARCHAR2 character set any_cs,
996 destcset VARCHAR2)
997 return VARCHAR2 character set src%charset;
998 function CONVERT(src VARCHAR2 character set any_cs,
999 destcset VARCHAR2,
1000 srccset VARCHAR2)
1001 return VARCHAR2 character set src%charset;
1002
1003 function " SYS$STANDARD_TRANSLATE" (src VARCHAR2 CHARACTER SET ANY_CS,
1004 csn VARCHAR2 CHARACTER SET ANY_CS)
1005 return VARCHAR2 CHARACTER SET csn%CHARSET;
1006 pragma FIPSFLAG(' SYS$STANDARD_TRANSLATE',1452);
1007
1008 function VSIZE (e number ) return NUMBER;
1009 pragma builtin('VSIZE', 1, 0, 1);
1010 function VSIZE (e DATE) return NUMBER;
1011 pragma builtin('VSIZE', 1, 0, 1);
1012 function VSIZE (e VARCHAR2 CHARACTER SET ANY_CS) return NUMBER;
1013 pragma builtin('VSIZE', 1, 0, 1);
1014
1015
1016 -- dump( expr [,display_format[,start_pos[,length]]]) return VARCHAR2
1017 function DUMP(e varchar2 character set any_cs,
1018 df pls_integer := null,sp pls_integer := null,
1019 len pls_integer := null) return VARCHAR2;
1020 pragma builtin('DUMP', 1, 0, 1);
1021
1022 function DUMP(e number,df pls_integer := null,sp pls_integer := null,
1023 len pls_integer := null) return VARCHAR2;
1024 pragma builtin('DUMP', 1, 0, 1);
1025
1026 function DUMP(e date,df pls_integer := null,sp pls_integer := null,
1027 len pls_integer := null) return VARCHAR2;
1028 pragma builtin('DUMP', 1, 0, 1);
1029
1030 --
1031 -- ACOS, ASIN, ATAN, ATAN2
1032 -- Inverse Trigonometric functions
1033 -- These functions return NULL if any of the inputs are NULL
1034 --
1035 function ACOS(N NUMBER) return NUMBER;
1036 pragma FIPSFLAG('ACOS', 1452);
1037
1038 function ASIN(N NUMBER) return NUMBER;
1039 pragma FIPSFLAG('ASIN', 1452);
1040
1041 function ATAN(N NUMBER) return NUMBER;
1042 pragma FIPSFLAG('ATAN', 1452);
1043
1044 function ATAN2(x NUMBER, y NUMBER) return NUMBER;
1045 pragma FIPSFLAG('ATAN2', 1452);
1046
1047 --#### This is the end of 7.3 Standard
1048
1049 -- LOB IS NULL
1050 function 'IS NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1051 pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1052 function 'IS NOT NULL' (n CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1053 pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1054
1055 function 'IS NULL' (n BLOB) return BOOLEAN;
1056 pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1057 function 'IS NOT NULL' (n BLOB) return BOOLEAN;
1058 pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1059
1060 function 'IS NULL' (n BFILE) return BOOLEAN;
1061 pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_NUMBER, PEMDNUL
1062 function 'IS NOT NULL' (n BFILE) return BOOLEAN;
1063 pragma BUILTIN('IS NOT NULL', 0, 2, 50);
1064 -- end LOB IS NULL
1065
1066 --****************************************************************
1067 -- 20 mar 96 =G=> In the following, arguments "1, 1, 1" to pragma BUILTIN
1068 -- e.g., pragma builtin('whatever', 1, 1, 1)
1069 -- indicate that those three numeric arguments to pragma BUILTIN are unknown,
1070 -- because they are not yet implemented by the backend.
1071
1072 function '=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1073 pragma BUILTIN('=', 1, 1, 1);
1074 pragma FIPSFLAG('=', 1450);
1075 function '!=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1076 pragma BUILTIN('!=', 1, 1, 1);
1077 pragma FIPSFLAG('!=', 1450);
1078 function '<' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1079 pragma BUILTIN('<', 1, 1, 1);
1080 pragma FIPSFLAG('<', 1450);
1081 function '<=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1082 pragma BUILTIN('<=', 1, 1, 1);
1083 pragma FIPSFLAG('<=', 1450);
1084 function '>' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1085 pragma BUILTIN('>', 1, 1, 1);
1086 pragma FIPSFLAG('>', 1450);
1087 function '>=' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1088 pragma BUILTIN('>=', 1, 1, 1);
1089 pragma FIPSFLAG('>=', 1450);
1090
1091 function '=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1092 function '!=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1093 function '<ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1094 function '<=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1095 function '>ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1096 function '>=ANY' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1097 function '=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1098 function '!=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1099 function '<ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1103 function '=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1100 function '<=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1101 function '>ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1102 function '>=ALL' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1104 function '!=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1105 function '<SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1106 function '<=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1107 function '>SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1108 function '>=SOME' (LEFT "<ADT_1>", RIGHT "<ADT_1>") return BOOLEAN;
1109
1110 -- Outer Join
1111 function '(+)' ( colname "<ADT_1>") return "<ADT_1>";
1112 pragma FIPSFLAG('(+)', 1450);
1113
1114 -- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
1115 -- function GREATEST (pattern "<ADT_1>") return "<ADT_1>";
1116 -- pragma BUILTIN('GREATEST', 1, 1, 1);
1117
1118 -- function LEAST (pattern "<ADT_1>") return "<ADT_1>";
1119 -- pragma BUILTIN('LEAST', 1, 1, 1);
1120
1121 function DECODE (expr "<ADT_1>", pat "<ADT_1>", res "<ADT_1>")
1122 return "<ADT_1>";
1123 pragma BUILTIN('DECODE', 1, 1, 1);
1124
1125 function 'IS NULL' (B "<ADT_1>") return BOOLEAN;
1126 pragma BUILTIN('IS NULL', 0, 3, 0);
1127 pragma FIPSFLAG('IS NULL', 1450);
1128
1129 function 'IS NOT NULL' (B "<ADT_1>") return BOOLEAN;
1130 pragma BUILTIN('IS NOT NULL', 0, 3, 50);
1131 pragma FIPSFLAG('IS NOT NULL', 1450);
1132
1133 function NVL (B1 "<ADT_1>", B2 "<ADT_1>") return "<ADT_1>";
1134 pragma FIPSFLAG('NVL', 1450);
1135
1136 function VALUE (item "<ADT_WITH_OID>") return "<ADT_1>";
1137 pragma BUILTIN('VALUE', 1, 1, 1);
1138 pragma FIPSFLAG('VALUE', 1450);
1139
1140 function REF (item "<ADT_WITH_OID>") return REF "<ADT_1>";
1141 pragma BUILTIN('REF', 1, 1, 1);
1142 pragma FIPSFLAG('REF', 1450);
1143
1144 function DEREF (r REF "<ADT_1>") return "<ADT_1>";
1145 pragma BUILTIN('DEREF', 1, 1, 1);
1146 pragma FIPSFLAG('DEREF', 1450);
1147
1148 -- overloadings for REF ADT
1149
1150 function 'IS NULL' (B REF "<ADT_1>") return BOOLEAN;
1151 pragma BUILTIN('IS NULL', 0, 3, 0);
1152 pragma FIPSFLAG('IS NULL', 1450);
1153
1154 function 'IS NOT NULL' (B REF "<ADT_1>") return BOOLEAN;
1155 pragma BUILTIN('IS NOT NULL', 0, 3, 50);
1156 pragma FIPSFLAG('IS NOT NULL', 1450);
1157
1158 function 'IS DANGLING' (B REF "<ADT_1>") return BOOLEAN;
1159 pragma BUILTIN('IS DANGLING', 1, 1, 1);
1160 pragma FIPSFLAG('IS DANGLING', 1450);
1161
1162 function 'IS NOT DANGLING' (B REF "<ADT_1>") return BOOLEAN;
1163 pragma BUILTIN('IS NOT DANGLING', 1, 1, 1);
1164 pragma FIPSFLAG('IS NOT DANGLING', 1450);
1165
1166 function NVL (B1 REF "<ADT_1>", B2 REF "<ADT_1>") return REF "<ADT_1>";
1167 pragma FIPSFLAG('NVL', 1450);
1168
1169 function '=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
1170 pragma BUILTIN('=', 0, 3, 1);
1171 pragma FIPSFLAG('=', 1450);
1172
1173 function '!=' (LEFT REF "<ADT_1>", RIGHT REF "<ADT_1>") return BOOLEAN;
1174 pragma BUILTIN('!=', 0, 3, 2);
1175 pragma FIPSFLAG('!=', 1450);
1176
1177 -- function '=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1178 -- return BOOLEAN;
1179 -- pragma BUILTIN('=', 1, 1, 1);
1180 -- pragma FIPSFLAG('=', 1450);
1181 --
1182 -- function '!=' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1183 -- return BOOLEAN;
1184 -- pragma BUILTIN('!=', 1, 1, 1);
1185 -- pragma FIPSFLAG('!=', 1450);
1186 --
1187 -- function '=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1188 -- return BOOLEAN;
1189 -- function '!=ANY' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1190 -- return BOOLEAN;
1191 -- function '=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1192 -- return BOOLEAN;
1193 -- function '!=ALL' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1194 -- return BOOLEAN;
1195 -- function '=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1196 -- return BOOLEAN;
1197 -- function '!=SOME' (LEFT "<COLLECTION_1>", RIGHT "<COLLECTION_1>")
1198 -- return BOOLEAN;
1199 --
1200 -- function DECODE (expr "<COLLECTION_1>", pat "<COLLECTION_1>",
1201 -- res "<COLLECTION_1>")
1202 -- return "<COLLECTION_1>";
1203 -- pragma BUILTIN('DECODE', 1, 1, 1);
1204
1205 function 'IS NULL' (B "<COLLECTION_1>") return BOOLEAN;
1206 pragma BUILTIN('IS NULL', 0, 3, 0);
1207 pragma FIPSFLAG('IS NULL', 1450);
1208
1209 function 'IS NOT NULL' (B "<COLLECTION_1>") return BOOLEAN;
1210 pragma BUILTIN('IS NOT NULL', 0, 3, 50);
1211 pragma FIPSFLAG('IS NOT NULL', 1450);
1212
1213 function NVL (B1 "<COLLECTION_1>", B2 "<COLLECTION_1>")
1214 return "<COLLECTION_1>";
1215 pragma FIPSFLAG('NVL', 1450);
1216
1217 function 'IS NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
1218 pragma BUILTIN('IS NULL', 0, 3, 0);
1219 pragma FIPSFLAG('IS NULL', 1450);
1220
1221 function 'IS NOT NULL' (B "<REF_CURSOR_1>") return BOOLEAN;
1222 pragma BUILTIN('IS NOT NULL', 0, 3, 50);
1223 pragma FIPSFLAG('IS NOT NULL', 1450);
1224
1225 function NVL (B1 "<REF_CURSOR_1>", B2 "<REF_CURSOR_1>")
1226 return "<REF_CURSOR_1>";
1227 pragma FIPSFLAG('NVL', 1450);
1228
1229 function EMPTY_CLOB return clob;
1230 function EMPTY_BLOB return blob;
1231
1235 function "SYS$LOB_REPLICATION" (x in clob character set any_cs)
1232 function BFILENAME(directory varchar2,filename varchar2) return BFILE;
1233
1234 function "SYS$LOB_REPLICATION" (x in blob) return blob;
1236 return clob character set x%charset;
1237
1238 --#### This is the end of 8.0 Standard
1239
1240 -- + overloadings
1241
1242 function '+'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1243 return TIMESTAMP_UNCONSTRAINED;
1244 function '+'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1245 return TIMESTAMP_UNCONSTRAINED;
1246
1247 function '+'(LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1248 return TIMESTAMP_TZ_UNCONSTRAINED ;
1249 function '+'(LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1250 return TIMESTAMP_TZ_UNCONSTRAINED ;
1251
1252 function '+'(LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1253 return TIME_UNCONSTRAINED;
1254
1255 function '+'(LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1256 return TIME_TZ_UNCONSTRAINED;
1257
1258 function '+'(LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date ;
1259 function '+'(LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date ;
1260 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
1261 return TIMESTAMP_UNCONSTRAINED;
1262 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1263 return TIMESTAMP_TZ_UNCONSTRAINED ;
1264 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT date) return date ;
1265
1266 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
1267 return TIMESTAMP_UNCONSTRAINED;
1268 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1269 return TIMESTAMP_TZ_UNCONSTRAINED ;
1270 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
1271 return TIME_UNCONSTRAINED ;
1272 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
1273 return TIME_TZ_UNCONSTRAINED ;
1274 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT date) return date ;
1275
1276 function '+'(LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1277 return DSINTERVAL_UNCONSTRAINED ;
1278 function '+'(LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1279 return YMINTERVAL_UNCONSTRAINED ;
1280
1281 -- begin subtract
1282 function " SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
1283 RIGHT TIMESTAMP_UNCONSTRAINED)
1284 return DSINTERVAL_UNCONSTRAINED ;
1285 function " SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_UNCONSTRAINED,
1286 RIGHT TIMESTAMP_UNCONSTRAINED)
1287 return YMINTERVAL_UNCONSTRAINED ;
1288 function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1289 return TIMESTAMP_UNCONSTRAINED;
1290 function '-'(LEFT TIMESTAMP_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1291 return TIMESTAMP_UNCONSTRAINED;
1292
1293 function " SYS$DSINTERVALSUBTRACT"
1294 (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1295 return DSINTERVAL_UNCONSTRAINED ;
1296 function " SYS$YMINTERVALSUBTRACT"
1297 (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1298 return YMINTERVAL_UNCONSTRAINED ;
1299 function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1300 return TIMESTAMP_TZ_UNCONSTRAINED ;
1301 function '-' (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1302 return TIMESTAMP_TZ_UNCONSTRAINED ;
1303
1304 function " SYS$DSINTERVALSUBTRACT" (LEFT TIME_UNCONSTRAINED,
1305 RIGHT TIME_UNCONSTRAINED)
1306 return DSINTERVAL_UNCONSTRAINED ;
1307 function '-' (LEFT TIME_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1308 return TIME_UNCONSTRAINED ;
1309 function " SYS$DSINTERVALSUBTRACT"
1310 (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
1311 return DSINTERVAL_UNCONSTRAINED ;
1312 function '-' (LEFT TIME_TZ_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1313 return TIME_TZ_UNCONSTRAINED ;
1314 function " SYS$DSINTERVALSUBTRACT" (LEFT date, RIGHT date)
1315 return DSINTERVAL_UNCONSTRAINED ;
1316 function " SYS$YMINTERVALSUBTRACT" (LEFT date, RIGHT date)
1317 return YMINTERVAL_UNCONSTRAINED ;
1318 function '-' (LEFT date, RIGHT YMINTERVAL_UNCONSTRAINED) return date;
1319 function '-' (LEFT date, RIGHT DSINTERVAL_UNCONSTRAINED) return date;
1320
1321 function '-' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT YMINTERVAL_UNCONSTRAINED)
1322 return YMINTERVAL_UNCONSTRAINED ;
1323 function '-' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT DSINTERVAL_UNCONSTRAINED)
1324 return DSINTERVAL_UNCONSTRAINED ;
1325
1326 -- end subtract
1327
1328 -- other datetime operators
1329
1330 function '*' (LEFT number, RIGHT YMINTERVAL_UNCONSTRAINED)
1331 return YMINTERVAL_UNCONSTRAINED ;
1332 function '*' (LEFT number, RIGHT DSINTERVAL_UNCONSTRAINED)
1333 return DSINTERVAL_UNCONSTRAINED ;
1334
1335 function '*' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
1336 return YMINTERVAL_UNCONSTRAINED ;
1337 function '*' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
1338 return DSINTERVAL_UNCONSTRAINED ;
1339
1340 function '/' (LEFT YMINTERVAL_UNCONSTRAINED, RIGHT number)
1341 return YMINTERVAL_UNCONSTRAINED ;
1342 function '/' (LEFT DSINTERVAL_UNCONSTRAINED, RIGHT number)
1343 return DSINTERVAL_UNCONSTRAINED ;
1344
1348 function current_timestamp return TIMESTAMP_TZ_UNCONSTRAINED;
1345
1346 function current_date return date;
1347 function current_time return TIME_TZ_UNCONSTRAINED;
1349
1350 function TO_TIME (RIGHT varchar2 character set any_cs) return
1351 time_unconstrained;
1352 pragma BUILTIN('TO_TIME', 0, 15, 1);
1353 function TO_TIMESTAMP (RIGHT varchar2 character set any_cs)
1354 return TIMESTAMP_UNCONSTRAINED;
1355 pragma BUILTIN('TO_TIMESTAMP', 0, 15, 3);
1356 function TO_TIME_TZ (RIGHT varchar2 character set any_cs)
1357 return TIME_TZ_UNCONSTRAINED;
1358 pragma BUILTIN('TO_TIME_TZ', 0, 15, 5);
1359 function TO_TIMESTAMP_TZ (RIGHT varchar2 character set any_cs)
1360 return TIMESTAMP_TZ_UNCONSTRAINED;
1361 pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 7);
1362 function TO_YMINTERVAL (RIGHT varchar2 character set any_cs)
1363 return YMINTERVAL_UNCONSTRAINED;
1364 pragma BUILTIN('TO_YMINTERVAL', 0, 15, 9);
1365 function TO_DSINTERVAL (RIGHT varchar2 character set any_cs)
1366 return DSINTERVAL_UNCONSTRAINED;
1367 pragma BUILTIN('TO_DSINTERVAL', 0, 15, 11);
1368
1369 -- with nls args
1370 function TO_TIME(left varchar2 character set any_cs,
1371 format varchar2 character set left%charset,
1372 parms varchar2 character set left%charset)
1373 return TIME_UNCONSTRAINED;
1374 function TO_TIME(left varchar2 character set any_cs,
1375 format varchar2 character set left%charset)
1376 return TIME_UNCONSTRAINED;
1377 function TO_TIMESTAMP(left varchar2 character set any_cs,
1378 format varchar2 character set left%charset,
1379 parms varchar2 character set left%charset)
1380 return TIMESTAMP_UNCONSTRAINED;
1381 function TO_TIMESTAMP(left varchar2 character set any_cs,
1382 format varchar2 character set left%charset)
1383 return TIMESTAMP_UNCONSTRAINED;
1384 function TO_TIMESTAMP_TZ(left varchar2 character set any_cs,
1385 format varchar2 character set left%charset,
1386 parms varchar2 character set left%charset)
1387 return TIMESTAMP_TZ_UNCONSTRAINED;
1388 function TO_TIMESTAMP_TZ(left varchar2 character set any_cs,
1389 format varchar2 character set left%charset)
1390 return TIMESTAMP_TZ_UNCONSTRAINED;
1391 function TO_TIME_TZ(left varchar2 character set any_cs,
1392 format varchar2 character set left%charset,
1393 parms varchar2 character set left%charset)
1394 return TIME_TZ_UNCONSTRAINED;
1395 function TO_TIME_TZ(left varchar2 character set any_cs,
1396 format varchar2 character set left%charset)
1397 return TIME_TZ_UNCONSTRAINED;
1398 function TO_DSINTERVAL(RIGHT varchar2 character set any_cs,
1399 parms varchar2 character set RIGHT%charset)
1400 return DSINTERVAL_UNCONSTRAINED;
1401
1402 function NUMTOYMINTERVAL(numerator number,
1403 units varchar2 character set any_cs)
1404 return YMINTERVAL_UNCONSTRAINED;
1405 function NUMTODSINTERVAL(numerator number,
1406 units varchar2 character set any_cs)
1407 return DSINTERVAL_UNCONSTRAINED;
1408
1409 function '=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
1410 pragma BUILTIN('=',0, 11, 1);
1411 pragma FIPSFLAG('=', 1450);
1412 function '!=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN; -- also <> and ~=
1413 pragma BUILTIN('!=',0, 11, 2);
1414 pragma FIPSFLAG('!=', 1450);
1415 function '<' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
1416 pragma BUILTIN('<',0, 11, 3);
1417 pragma FIPSFLAG('<', 1450);
1418 function '<=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
1419 pragma BUILTIN('<=',0, 11, 4);
1420 pragma FIPSFLAG('<=', 1450);
1421 function '>' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
1422 pragma BUILTIN('>',0, 11, 5);
1423 pragma FIPSFLAG('>', 1450);
1424 function '>=' (LEFT UROWID, RIGHT UROWID) return BOOLEAN;
1425 pragma BUILTIN('>=',0, 11, 6);
1426 pragma FIPSFLAG('>=', 1450);
1427
1428 function 'IS NULL' (u UROWID) return BOOLEAN;
1429 pragma BUILTIN('IS NULL', 0, 14, 0); -- PEMS_UROWID, PEMDNUL
1430 pragma FIPSFLAG('IS NULL', 1450);
1431 function 'IS NOT NULL' (u UROWID) return BOOLEAN;
1432 pragma BUILTIN('IS NOT NULL', 0, 14, 50); -- PEMS_UROWID, PEMDNUL
1433 pragma FIPSFLAG('IS NOT NULL', 1450);
1434
1435 function "UROWID " return UROWID;
1436 pragma builtin('UROWID ', 1, 209, 240); -- this had better never be called.
1437
1438 -- New built-in function SYS_GUID, returns globally unique id
1439 function SYS_GUID return RAW;
1440
1441 -- New built-in function SYS_CONTEXT
1442 function SYS_CONTEXT (namespace varchar2, attribute varchar2)
1443 return varchar2;
1444
1445 function TRIM(v VARCHAR2 CHARACTER SET ANY_CS)
1446 return VARCHAR2 CHARACTER SET v%CHARSET;
1447
1448 --#### This is the end of 8.1.5 Standard
1449
1450 -- SYS_CONTEXT now has an additional optional parameter
1451 function SYS_CONTEXT(namespace varchar2, attribute varchar2,
1452 newoptional varchar2)
1453 return varchar2;
1454
1455 -- CUBE and ROLLUP are not real functions; they are variants on the GROUP
1456 -- BY clause (GROUP BY CUBE (...) and GROUP BY ROLLUP (...)). They have
1457 -- been added here as functions to avoid name capture issues.
1458 --
1459 -- Note that both CUBE and ROLLUP look like true vararg functions with
1463 function ROLLUP return NUMBER;
1460 -- *no* repeating pattern of formals - hence they are special cased in
1461 -- the overloading code.
1462 function CUBE return NUMBER;
1464
1465 -- The GROUPING function must be used in conjunction with CUBE and ROLLUP
1466 -- in the GROUP BY clause. The type of the parameter to GROUPING can be
1467 -- any type that can appear in a GROUP BY list.
1468 function GROUPING(v VARCHAR2) return NUMBER;
1469 function GROUPING(a "<ADT_1>") return NUMBER;
1470
1471 -- This is for TRIM(x). No trim set.
1472 function " SYS$STANDARD_TRIM" (v VARCHAR2 CHARACTER SET ANY_CS)
1473 return VARCHAR2 CHARACTER SET v%CHARSET;
1474
1475 -- This is for TRIM(LEADING/TRAILING FROM x). No trim set.
1476 function " SYS$STANDARD_TRIM" (STR1 VARCHAR2 CHARACTER SET ANY_CS ,
1477 TRFLAG PLS_INTEGER)
1478 return VARCHAR2 CHARACTER SET STR1%CHARSET;
1479
1480 -- General TRIM. LEADING, TRAILING and BOTH options as 3rd argument.
1481 -- This one takes a trim set.
1482 function " SYS$STANDARD_TRIM" (STR1 VARCHAR2 CHARACTER SET ANY_CS ,
1483 TSET VARCHAR2 CHARACTER SET STR1%CHARSET,
1484 TRFLAG PLS_INTEGER)
1485 return VARCHAR2 CHARACTER SET STR1%CHARSET;
1486
1487 --#### This is the end of the supported parts of 8.1.6 Standard
1488
1489 --## Support for ANSI datetime data types is under development.
1490 --## The following operations, as well as the related types and
1491 --## operations defined above in the 8.1.5 section, are not yet
1492 --## available for use and are still subject to change.
1493
1494 --- datetime equivalence
1495 function '=' (LEFT TIME_UNCONSTRAINED,
1496 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1497 function '!=' (LEFT TIME_UNCONSTRAINED,
1498 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1499 function '<' (LEFT TIME_UNCONSTRAINED,
1500 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1501 function '<=' (LEFT TIME_UNCONSTRAINED,
1502 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1503 function '>' (LEFT TIME_UNCONSTRAINED,
1504 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1505 function '>=' (LEFT TIME_UNCONSTRAINED,
1506 RIGHT TIME_UNCONSTRAINED) return BOOLEAN;
1507
1508 function '=' (LEFT TIMESTAMP_UNCONSTRAINED,
1509 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1510 function '!=' (LEFT TIMESTAMP_UNCONSTRAINED,
1511 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1512 function '<' (LEFT TIMESTAMP_UNCONSTRAINED,
1513 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1514 function '<=' (LEFT TIMESTAMP_UNCONSTRAINED,
1515 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1516 function '>' (LEFT TIMESTAMP_UNCONSTRAINED,
1517 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1518 function '>=' (LEFT TIMESTAMP_UNCONSTRAINED,
1519 RIGHT TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1520
1521 function '=' (LEFT TIME_TZ_UNCONSTRAINED,
1522 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1523 function '!=' (LEFT TIME_TZ_UNCONSTRAINED,
1524 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1525 function '<' (LEFT TIME_TZ_UNCONSTRAINED,
1526 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1527 function '<=' (LEFT TIME_TZ_UNCONSTRAINED,
1528 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1529 function '>' (LEFT TIME_TZ_UNCONSTRAINED,
1530 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1531 function '>=' (LEFT TIME_TZ_UNCONSTRAINED,
1532 RIGHT TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1533
1534 function '=' (LEFT YMINTERVAL_UNCONSTRAINED,
1535 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1536 function '!=' (LEFT YMINTERVAL_UNCONSTRAINED,
1537 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1538 function '<' (LEFT YMINTERVAL_UNCONSTRAINED,
1539 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1540 function '<=' (LEFT YMINTERVAL_UNCONSTRAINED,
1541 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1542 function '>' (LEFT YMINTERVAL_UNCONSTRAINED,
1543 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1544 function '>=' (LEFT YMINTERVAL_UNCONSTRAINED,
1545 RIGHT YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1546
1547 function '=' (LEFT DSINTERVAL_UNCONSTRAINED,
1548 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1549 function '!=' (LEFT DSINTERVAL_UNCONSTRAINED,
1550 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1551 function '<' (LEFT DSINTERVAL_UNCONSTRAINED,
1552 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1553 function '<=' (LEFT DSINTERVAL_UNCONSTRAINED,
1554 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1555 function '>' (LEFT DSINTERVAL_UNCONSTRAINED,
1556 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1557 function '>=' (LEFT DSINTERVAL_UNCONSTRAINED,
1558 RIGHT DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1559
1560 function TO_TIME (RIGHT TIME_TZ_UNCONSTRAINED) return TIME_UNCONSTRAINED;
1561 pragma BUILTIN('TO_TIME', 0, 15, 13);
1562 function TO_TIME_TZ (RIGHT TIME_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
1563 pragma BUILTIN('TO_TIME_TZ', 0, 15, 14);
1564 function TO_TIMESTAMP (RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1565 return TIMESTAMP_UNCONSTRAINED;
1566 pragma BUILTIN('TO_TIMESTAMP', 0, 15, 15);
1567 function TO_TIMESTAMP_TZ (RIGHT TIMESTAMP_UNCONSTRAINED)
1571 function '-'
1568 return TIMESTAMP_TZ_UNCONSTRAINED;
1569 pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 16);
1570
1572 (LEFT TIME_UNCONSTRAINED, RIGHT TIME_UNCONSTRAINED)
1573 return DSINTERVAL_UNCONSTRAINED;
1574 function '-'
1575 (LEFT TIMESTAMP_UNCONSTRAINED, RIGHT TIMESTAMP_UNCONSTRAINED)
1576 return DSINTERVAL_UNCONSTRAINED;
1577 function '-'
1578 (LEFT TIME_TZ_UNCONSTRAINED, RIGHT TIME_TZ_UNCONSTRAINED)
1579 return DSINTERVAL_UNCONSTRAINED;
1580 function '-'
1581 (LEFT TIMESTAMP_TZ_UNCONSTRAINED, RIGHT TIMESTAMP_TZ_UNCONSTRAINED)
1582 return DSINTERVAL_UNCONSTRAINED;
1583
1584 -- timezone functions
1585 function SYS_AT_TIME_ZONE(t time_tz_unconstrained,
1586 i varchar2) RETURN time_tz_unconstrained;
1587 function SYS_AT_TIME_ZONE(t timestamp_tz_unconstrained,
1588 i varchar2) RETURN timestamp_tz_unconstrained;
1589 FUNCTION systimestamp RETURN timestamp_tz_unconstrained;
1590 FUNCTION dbtimezone RETURN varchar2;
1591 FUNCTION sessiontimezone RETURN varchar2;
1592 FUNCTION localtimestamp RETURN timestamp_unconstrained;
1593 FUNCTION localtime RETURN time_unconstrained;
1594
1595 function TO_TIMESTAMP (RIGHT DATE) return TIMESTAMP_UNCONSTRAINED;
1596 pragma BUILTIN('TO_TIMESTAMP', 0, 15, 17);
1597
1598 function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1599 RIGHT yminterval_unconstrained)
1600 return TIMESTAMP_LTZ_UNCONSTRAINED;
1601 function '+'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1602 RIGHT dsinterval_unconstrained)
1603 return TIMESTAMP_LTZ_UNCONSTRAINED;
1604 function '+'(LEFT yminterval_unconstrained,
1605 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
1606 return TIMESTAMP_LTZ_UNCONSTRAINED ;
1607 function '+'(LEFT dsinterval_unconstrained,
1608 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
1609 return TIMESTAMP_LTZ_UNCONSTRAINED ;
1610
1611 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1612 RIGHT yminterval_unconstrained)
1613 return TIMESTAMP_LTZ_UNCONSTRAINED ;
1614 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1615 RIGHT dsinterval_unconstrained)
1616 return TIMESTAMP_LTZ_UNCONSTRAINED ;
1617
1618 function " SYS$DSINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1619 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
1620 return dsinterval_unconstrained;
1621 function " SYS$YMINTERVALSUBTRACT"(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1622 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
1623 return yminterval_unconstrained;
1624
1625 function '-'(LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1626 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED)
1627 return dsinterval_unconstrained;
1628
1629 function '=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1630 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1631 function '!=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1632 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1633 function '<' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1634 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1635 function '<=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1636 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1637 function '>' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1638 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1639 function '>=' (LEFT TIMESTAMP_TZ_UNCONSTRAINED,
1640 RIGHT TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1641
1642 function '=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1643 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1644 function '!=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1645 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1646 function '<' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1647 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1648 function '<=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1649 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1650 function '>' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1651 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1652 function '>=' (LEFT TIMESTAMP_LTZ_UNCONSTRAINED,
1653 RIGHT TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1654
1655 function SYS_LITERALTOYMINTERVAL(numerator varchar2, units varchar2)
1656 return YMINTERVAL_UNCONSTRAINED;
1657 function SYS_LITERALTODSINTERVAL(numerator varchar2, units varchar2)
1658 return DSINTERVAL_UNCONSTRAINED;
1659 function SYS_LITERALTOTIME(numerator varchar2)
1660 return TIME_UNCONSTRAINED;
1661 function SYS_LITERALTOTZTIME(numerator varchar2)
1662 return TIME_TZ_UNCONSTRAINED;
1663 function SYS_LITERALTOTIMESTAMP(numerator varchar2)
1664 return TIMESTAMP_UNCONSTRAINED;
1665 function SYS_LITERALTOTZTIMESTAMP(numerator varchar2)
1666 return TIMESTAMP_TZ_UNCONSTRAINED;
1667 function SYS_LITERALTODATE(numerator varchar2) return DATE;
1668
1669
1670 -- Explicit conversions between date and datetime
1671 function TO_TIMESTAMP(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
1672 return TIMESTAMP_UNCONSTRAINED;
1673 pragma BUILTIN('TO_TIMESTAMP', 0, 15, 24);
1674
1675 function TO_TIMESTAMP_TZ(ARG DATE) return TIMESTAMP_TZ_UNCONSTRAINED;
1676 pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 27);
1677
1678 function TO_TIMESTAMP_TZ(ARG TIMESTAMP_LTZ_UNCONSTRAINED)
1679 return TIMESTAMP_TZ_UNCONSTRAINED;
1680 pragma BUILTIN('TO_TIMESTAMP_TZ', 0, 15, 26);
1681
1682 -- IS [NOT] NULL / NVL for datetime
1686 b2 TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
1683 function 'IS NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
1684 function 'IS NOT NULL' (b TIME_UNCONSTRAINED) return BOOLEAN;
1685 function NVL (b1 TIME_UNCONSTRAINED,
1687
1688 function 'IS NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1689 function 'IS NOT NULL' (b TIME_TZ_UNCONSTRAINED) return BOOLEAN;
1690 function NVL (b1 TIME_TZ_UNCONSTRAINED, b2 TIME_TZ_UNCONSTRAINED)
1691 return TIME_TZ_UNCONSTRAINED;
1692
1693 function 'IS NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1694 function 'IS NOT NULL' (b TIMESTAMP_UNCONSTRAINED) return BOOLEAN;
1695 function NVL (b1 TIMESTAMP_UNCONSTRAINED,
1696 b2 TIMESTAMP_UNCONSTRAINED) return TIMESTAMP_UNCONSTRAINED;
1697
1698 function 'IS NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1699 function 'IS NOT NULL' (b TIMESTAMP_TZ_UNCONSTRAINED) return BOOLEAN;
1700 function NVL (b1 TIMESTAMP_TZ_UNCONSTRAINED, b2 TIMESTAMP_TZ_UNCONSTRAINED)
1701 return TIMESTAMP_TZ_UNCONSTRAINED;
1702
1703 function 'IS NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1704 function 'IS NOT NULL' (b TIMESTAMP_LTZ_UNCONSTRAINED) return BOOLEAN;
1705 function NVL (b1 TIMESTAMP_LTZ_UNCONSTRAINED,
1706 b2 TIMESTAMP_LTZ_UNCONSTRAINED)
1707 return TIMESTAMP_LTZ_UNCONSTRAINED;
1708
1709 function 'IS NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1710 function 'IS NOT NULL' (b YMINTERVAL_UNCONSTRAINED) return BOOLEAN;
1711 function NVL (b1 YMINTERVAL_UNCONSTRAINED, b2 YMINTERVAL_UNCONSTRAINED)
1712 return YMINTERVAL_UNCONSTRAINED;
1713
1714 function 'IS NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1715 function 'IS NOT NULL' (b DSINTERVAL_UNCONSTRAINED) return BOOLEAN;
1716 function NVL (b1 DSINTERVAL_UNCONSTRAINED, b2 DSINTERVAL_UNCONSTRAINED)
1717 return DSINTERVAL_UNCONSTRAINED;
1718
1719 function " SYS$EXTRACT_FROM"
1720 (T TIME_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1721 function " SYS$EXTRACT_FROM"
1722 (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
1723 function " SYS$EXTRACT_FROM"
1724 (T TIMESTAMP_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1725 function " SYS$EXTRACT_FROM"
1726 (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1727 function " SYS$EXTRACT_FROM"
1728 (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return NUMBER;
1729 function " SYS$EXTRACT_FROM"
1730 (T DATE,FIELD VARCHAR2) return NUMBER;
1731 function " SYS$EXTRACT_FROM"
1732 (I YMINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1733 function " SYS$EXTRACT_FROM"
1734 (I DSINTERVAL_UNCONSTRAINED,FIELD VARCHAR2) return NUMBER;
1735
1736 -- ########## 8.2 LOB Built-in Functions ######## --
1737
1738 -- LENGTH --
1739 function LENGTH(ch CLOB CHARACTER SET ANY_CS) return integer;
1740 pragma FIPSFLAG('LENGTH', 1452);
1741
1742 function LENGTHB(ch CLOB CHARACTER SET ANY_CS) return integer;
1743 pragma FIPSFLAG('LENGTHB', 1452);
1744
1745 function LENGTH(bl BLOB) return integer;
1746 pragma FIPSFLAG('LENGTH', 1452);
1747
1748 function LENGTHB(bl BLOB) return integer;
1749 pragma FIPSFLAG('LENGTHB', 1452);
1750
1751 -- SUBSTR --
1752 function SUBSTR(STR1 CLOB CHARACTER SET ANY_CS,
1753 POS INTEGER,
1754 LEN INTEGER := 18446744073709551615)
1755 return CLOB CHARACTER SET STR1%CHARSET;
1756 pragma FIPSFLAG('SUBSTR', 1452);
1757
1758 function SUBSTRB(STR1 CLOB CHARACTER SET ANY_CS,
1759 POS INTEGER,
1760 LEN INTEGER := 18446744073709551615)
1761 return CLOB CHARACTER SET STR1%CHARSET;
1762 pragma FIPSFLAG('SUBSTRB', 1452);
1763
1764 -- INSTR --
1765 function INSTR(STR1 CLOB CHARACTER SET ANY_CS,
1766 STR2 CLOB CHARACTER SET STR1%CHARSET,
1767 POS INTEGER := 1,
1768 NTH INTEGER := 1) return INTEGER;
1769 pragma FIPSFLAG('INSTR', 1452);
1770
1771 function INSTRB(STR1 CLOB CHARACTER SET ANY_CS,
1772 STR2 CLOB CHARACTER SET STR1%CHARSET,
1773 POS INTEGER := 1,
1774 NTH INTEGER := 1) return INTEGER;
1775 pragma FIPSFLAG('INSTRB', 1452);
1776
1777 -- CONCAT --
1778 function '||' (LEFT CLOB CHARACTER SET ANY_CS,
1779 RIGHT CLOB CHARACTER SET ANY_CS)
1780 return CLOB CHARACTER SET LEFT%CHARSET;
1781 pragma FIPSFLAG('||', 1454);
1782
1783 function CONCAT(LEFT CLOB CHARACTER SET ANY_CS,
1784 RIGHT CLOB CHARACTER SET ANY_CS)
1785 return CLOB CHARACTER SET LEFT%CHARSET;
1786 pragma FIPSFLAG(CONCAT, 1454);
1787
1788 -- UPPER --
1789 function UPPER(ch CLOB CHARACTER SET ANY_CS)
1790 return CLOB CHARACTER SET ch%CHARSET;
1791 pragma FIPSFLAG('UPPER', 1452);
1792
1793 -- LOWER --
1794 function LOWER(ch CLOB CHARACTER SET ANY_CS)
1795 return CLOB CHARACTER SET ch%CHARSET;
1796 pragma FIPSFLAG('LOWER', 1452);
1797
1798 -- LPAD --
1799 function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
1800 LEN integer,
1801 PAD CLOB CHARACTER SET STR1%CHARSET)
1802 return CLOB CHARACTER SET STR1%CHARSET;
1803 pragma FIPSFLAG('LPAD', 1452);
1804
1805 function LPAD(STR1 CLOB CHARACTER SET ANY_CS,
1806 LEN integer)
1807 return CLOB CHARACTER SET STR1%CHARSET;
1808 pragma FIPSFLAG('LPAD', 1452);
1809
1810 -- RPAD --
1814 return CLOB CHARACTER SET STR1%CHARSET;
1811 function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
1812 LEN integer,
1813 PAD CLOB CHARACTER SET STR1%CHARSET)
1815 pragma FIPSFLAG('RPAD', 1452);
1816
1817 function RPAD(STR1 CLOB CHARACTER SET ANY_CS,
1818 LEN integer)
1819 return CLOB CHARACTER SET STR1%CHARSET;
1820 pragma FIPSFLAG('RPAD', 1452);
1821
1822 -- LTRIM --
1823 function LTRIM(STR1 CLOB CHARACTER SET ANY_CS,
1824 TSET CLOB CHARACTER SET STR1%CHARSET)
1825 return CLOB CHARACTER SET STR1%CHARSET;
1826 pragma FIPSFLAG('LTRIM', 1452);
1827
1828 function LTRIM(STR1 CLOB CHARACTER SET ANY_CS)
1829 return CLOB CHARACTER SET STR1%CHARSET;
1830 pragma FIPSFLAG('LTRIM', 1452);
1831
1832 -- RTRIM --
1833 function RTRIM(STR1 CLOB CHARACTER SET ANY_CS,
1834 TSET CLOB CHARACTER SET STR1%CHARSET)
1835 return CLOB CHARACTER SET STR1%CHARSET;
1836 pragma FIPSFLAG('RTRIM', 1452);
1837
1838 function RTRIM(STR1 CLOB CHARACTER SET ANY_CS)
1839 return CLOB CHARACTER SET STR1%CHARSET;
1840 pragma FIPSFLAG('RTRIM', 1452);
1841
1842 -- TRIM --
1843 function TRIM(v CLOB CHARACTER SET ANY_CS)
1844 return CLOB CHARACTER SET v%CHARSET;
1845
1846 -- This is for TRIM(x). No trim set.
1847 function " SYS$STANDARD_TRIM" (v CLOB CHARACTER SET ANY_CS)
1848 return CLOB CHARACTER SET v%CHARSET;
1849
1850 -- This is for TRIM(LEADING/TRAILING FROM x). No trim set.
1851 function " SYS$STANDARD_TRIM" (STR1 CLOB CHARACTER SET ANY_CS ,
1852 TRFLAG PLS_INTEGER)
1853 return CLOB CHARACTER SET STR1%CHARSET;
1854
1855 -- General TRIM. LEADING, TRAILING and BOTH options as 3rd argument.
1856 -- This one takes a trim set.
1857 function " SYS$STANDARD_TRIM" (STR1 CLOB CHARACTER SET ANY_CS ,
1858 TSET CLOB CHARACTER SET STR1%CHARSET,
1859 TRFLAG PLS_INTEGER)
1860 return CLOB CHARACTER SET STR1%CHARSET;
1861
1862
1863 -- LIKE --
1864 function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
1865 pat CLOB CHARACTER SET str%CHARSET)
1866 return BOOLEAN;
1867 function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS,
1868 pat CLOB CHARACTER SET str%CHARSET)
1869 return BOOLEAN;
1870
1871 function 'LIKE' (str CLOB CHARACTER SET ANY_CS,
1872 pat CLOB CHARACTER SET str%CHARSET,
1873 esc VARCHAR2 CHARACTER SET str%CHARSET)
1874 return BOOLEAN;
1875 function 'NOT_LIKE' (str CLOB CHARACTER SET ANY_CS,
1876 pat CLOB CHARACTER SET str%CHARSET,
1877 esc VARCHAR2 CHARACTER SET str%CHARSET)
1878 return BOOLEAN;
1879
1880 -- NVL --
1881 function NVL(s1 CLOB CHARACTER SET ANY_CS,
1882 s2 CLOB CHARACTER SET s1%CHARSET)
1883 return CLOB CHARACTER SET s1%CHARSET;
1884 pragma FIPSFLAG('NVL', 1452);
1885
1886 -- REPLACE --
1887 function REPLACE(SRCSTR CLOB CHARACTER SET ANY_CS,
1888 OLDSUB CLOB CHARACTER SET SRCSTR%CHARSET,
1889 NEWSUB CLOB CHARACTER SET SRCSTR%CHARSET := NULL)
1890 return CLOB CHARACTER SET SRCSTR%CHARSET;
1891 pragma FIPSFLAG('REPLACE', 1452);
1892
1893 -- LOB RELATIONAL OPERATORS --
1894
1895 Function '=' (LEFT CLOB CHARACTER SET ANY_CS,
1896 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1897 Function '!=' (LEFT CLOB CHARACTER SET ANY_CS,
1898 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1899 Function '>' (LEFT CLOB CHARACTER SET ANY_CS,
1900 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1901 Function '<' (LEFT CLOB CHARACTER SET ANY_CS,
1902 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1903 Function '>=' (LEFT CLOB CHARACTER SET ANY_CS,
1904 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1905 Function '<=' (LEFT CLOB CHARACTER SET ANY_CS,
1906 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1907
1908 Function '=' (LEFT CLOB CHARACTER SET ANY_CS,
1909 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1910 Function '!=' (LEFT CLOB CHARACTER SET ANY_CS,
1911 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1912 Function '>' (LEFT CLOB CHARACTER SET ANY_CS,
1913 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1914 Function '<' (LEFT CLOB CHARACTER SET ANY_CS,
1915 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1916 Function '>=' (LEFT CLOB CHARACTER SET ANY_CS,
1917 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1918 Function '<=' (LEFT CLOB CHARACTER SET ANY_CS,
1919 RIGHT VARCHAR2 CHARACTER SET ANY_CS) return BOOLEAN;
1920
1921 Function '=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1922 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1923 Function '!=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1924 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1925 Function '>' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1926 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1927 Function '<' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1928 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1929 Function '>=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1930 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1931 Function '<=' (LEFT VARCHAR2 CHARACTER SET ANY_CS,
1935 function TO_CLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS) return CLOB;
1932 RIGHT CLOB CHARACTER SET ANY_CS) return BOOLEAN;
1933
1934 /* LOB-related conversion functions */
1936 pragma BUILTIN('TO_CLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
1937 function TO_BLOB(RIGHT RAW) return BLOB;
1938 pragma BUILTIN('TO_BLOB', 0, 15, 30); -- OPC_CVT_RAW2BLB
1939 function TO_RAW(RIGHT BLOB) return RAW;
1940 pragma BUILTIN('TO_RAW', 0, 15, 32); -- OPC_CVT_BLB2RAW
1941
1942 -- ####### end of 8.2 LOB Built-in Functions ######## --
1943
1944 function NULLIF(v1 VARCHAR2, v2 VARCHAR2) return VARCHAR2;
1945 function NULLIF(v1 BOOLEAN, v2 BOOLEAN) return VARCHAR2;
1946 function NULLIF(a1 "<ADT_1>", a2 "<ADT_1>") return VARCHAR2;
1947
1948 function COALESCE return VARCHAR2;
1949
1950 /* Daylight Saving Time Functions */
1951 FUNCTION tz_offset(region VARCHAR2) RETURN VARCHAR2;
1952 FUNCTION from_tz(t TIMESTAMP_UNCONSTRAINED,timezone VARCHAR2)
1953 RETURN timestamp_tz_unconstrained;
1954
1955 function " SYS$EXTRACT_STRING_FROM"
1956 (T TIME_TZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
1957 function " SYS$EXTRACT_STRING_FROM"
1958 (T TIMESTAMP_TZ_UNCONSTRAINED,FIELD VARCHAR2) return VARCHAR2;
1959 function " SYS$EXTRACT_STRING_FROM"
1960 (T TIMESTAMP_LTZ_UNCONSTRAINED,FIELD varchar2) return VARCHAR2;
1961
1962 function INSTR2(STR1 VARCHAR2 CHARACTER SET ANY_CS,
1963 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
1964 POS PLS_INTEGER := 1,
1965 NTH POSITIVE := 1) return PLS_INTEGER;
1966 pragma FIPSFLAG('INSTR2', 1452);
1967
1968 function INSTR4(STR1 VARCHAR2 CHARACTER SET ANY_CS,
1969 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
1970 POS PLS_INTEGER := 1,
1971 NTH POSITIVE := 1) return PLS_INTEGER;
1972 pragma FIPSFLAG('INSTR4', 1452);
1973
1974 function INSTRC(STR1 VARCHAR2 CHARACTER SET ANY_CS,
1975 STR2 VARCHAR2 CHARACTER SET STR1%CHARSET,
1976 POS PLS_INTEGER := 1,
1977 NTH POSITIVE := 1) return PLS_INTEGER;
1978 pragma FIPSFLAG('INSTRC', 1452);
1979
1980 function LENGTH2(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
1981 pragma FIPSFLAG('LENGTH2', 1452);
1982
1983 function LENGTH4(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
1984 pragma FIPSFLAG('LENGTH4', 1452);
1985
1986 function LENGTHC(ch VARCHAR2 CHARACTER SET ANY_CS) return natural;
1987 pragma FIPSFLAG('LENGTHC', 1452);
1988
1989 function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
1990 pat VARCHAR2 CHARACTER SET str%CHARSET)
1991 return BOOLEAN;
1992 function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
1993 pat VARCHAR2 CHARACTER SET str%CHARSET)
1994 return BOOLEAN;
1995 function 'LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
1996 pat VARCHAR2 CHARACTER SET str%CHARSET,
1997 esc VARCHAR2 CHARACTER SET str%CHARSET)
1998 return BOOLEAN;
1999 function 'NOT_LIKE2' (str VARCHAR2 CHARACTER SET ANY_CS,
2000 pat VARCHAR2 CHARACTER SET str%CHARSET,
2001 esc VARCHAR2 CHARACTER SET str%CHARSET)
2002 return BOOLEAN;
2003
2004 function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
2005 pat VARCHAR2 CHARACTER SET str%CHARSET)
2006 return BOOLEAN;
2007 function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
2008 pat VARCHAR2 CHARACTER SET str%CHARSET)
2009 return BOOLEAN;
2010 function 'LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
2011 pat VARCHAR2 CHARACTER SET str%CHARSET,
2012 esc VARCHAR2 CHARACTER SET str%CHARSET)
2013 return BOOLEAN;
2014 function 'NOT_LIKE4' (str VARCHAR2 CHARACTER SET ANY_CS,
2015 pat VARCHAR2 CHARACTER SET str%CHARSET,
2016 esc VARCHAR2 CHARACTER SET str%CHARSET)
2017 return BOOLEAN;
2018
2019 function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
2020 pat VARCHAR2 CHARACTER SET str%CHARSET)
2021 return BOOLEAN;
2022 function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
2023 pat VARCHAR2 CHARACTER SET str%CHARSET)
2024 return BOOLEAN;
2025 function 'LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
2026 pat VARCHAR2 CHARACTER SET str%CHARSET,
2027 esc VARCHAR2 CHARACTER SET str%CHARSET)
2028 return BOOLEAN;
2029 function 'NOT_LIKEC' (str VARCHAR2 CHARACTER SET ANY_CS,
2030 pat VARCHAR2 CHARACTER SET str%CHARSET,
2031 esc VARCHAR2 CHARACTER SET str%CHARSET)
2032 return BOOLEAN;
2033
2034 function SUBSTR2(STR1 VARCHAR2 CHARACTER SET ANY_CS,
2035 POS PLS_INTEGER,
2036 LEN PLS_INTEGER := 2147483647)
2037 return VARCHAR2 CHARACTER SET STR1%CHARSET;
2038 pragma FIPSFLAG('SUBSTR2', 1452);
2039
2040 function SUBSTR4(STR1 VARCHAR2 CHARACTER SET ANY_CS,
2041 POS PLS_INTEGER,
2042 LEN PLS_INTEGER := 2147483647)
2043 return VARCHAR2 CHARACTER SET STR1%CHARSET;
2044 pragma FIPSFLAG('SUBSTR4', 1452);
2045
2046 function SUBSTRC(STR1 VARCHAR2 CHARACTER SET ANY_CS,
2047 POS PLS_INTEGER,
2048 LEN PLS_INTEGER := 2147483647)
2049 return VARCHAR2 CHARACTER SET STR1%CHARSET;
2050 pragma FIPSFLAG('SUBSTRC', 1452);
2051
2055 pragma BUILTIN('TO_NCHAR',14, 0, 2);
2052 /**** char <--> nchar conversion functions in Unicode project ********/
2053
2054 function TO_NCHAR(RIGHT NVARCHAR2) return NVARCHAR2;
2056
2057 function TO_NCLOB(cl CLOB CHARACTER SET ANY_CS) return NCLOB;
2058 function TO_CLOB(cl CLOB CHARACTER SET ANY_CS) return CLOB;
2059
2060 function TO_NCLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS)
2061 return NCLOB;
2062 pragma BUILTIN('TO_NCLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
2063 /* convert to either CLOB or NCLOB respectively if parm is char or nchar */
2064 function TO_ANYLOB(RIGHT VARCHAR2 CHARACTER SET ANY_CS)
2065 return CLOB CHARACTER SET RIGHT%CHARSET;
2066 pragma BUILTIN('TO_ANYLOB', 0, 15, 29); -- OPC_CVT_CHR2CLB
2067
2068 /* Followings are the same builtin op codes as without N prefix functions,
2069 * implementation relys on impilcit conversion MCODEs
2070 */
2071 function TO_NCHAR (LEFT DATE, FORMAT NVARCHAR2) return NVARCHAR2;
2072 pragma BUILTIN('TO_NCHAR',41, 12, 19); -- PEMS_DATE, DAT_CNV_CHR1
2073 pragma FIPSFLAG('TO_NCHAR', 1450);
2074 function TO_NCHAR (LEFT NUMBER, FORMAT NVARCHAR2) return NVARCHAR2;
2075 pragma BUILTIN('TO_NCHAR',41, 2, 14); -- PEMS_NUMBER, NUM_CNV_CHR
2076
2077 function NHEXTORAW (c NVARCHAR2) return RAW;
2078 pragma builtin('NHEXTORAW', 1, 23, 1);
2079 function RAWTONHEX (r RAW) return NVARCHAR2;
2080 pragma builtin('RAWTONHEX', 1, 23, 2);
2081 function NCHARTOROWID (str NVARCHAR2) return ROWID;
2082 pragma builtin('NCHARTOROWID', 1, 0, 1);
2083 function ROWIDTONCHAR (str ROWID) return NVARCHAR2;
2084 pragma builtin('ROWIDTONCHAR', 1, 0, 1);
2085
2086 function NCHR(n integer) return NVARCHAR2;
2087
2088 /* implemented by icd calls as the same as TO_CHAR */
2089 function TO_NCHAR(left date, format nvarchar2, parms nvarchar2)
2090 return nvarchar2;
2091 function TO_NCHAR(left number, format nvarchar2, parms nvarchar2)
2092 return nvarchar2;
2093
2094 /* implemented as a icd call, return TRUE if nchar, otherwise FALSE */
2095 function ISNCHAR(c VARCHAR2 character set any_cs) return boolean;
2096
2097 /************ end of char <--> nchar conversion functions ************/
2098
2099 /* Create overloads for all standard functions that work with <ADT_1> for
2100 <OPAQUE_1> */
2101 function '=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2102 pragma BUILTIN('=', 1, 1, 1);
2103 pragma FIPSFLAG('=', 1450);
2104 function '!=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2105 pragma BUILTIN('!=', 1, 1, 1);
2106 pragma FIPSFLAG('!=', 1450);
2107 function '<' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2108 pragma BUILTIN('<', 1, 1, 1);
2109 pragma FIPSFLAG('<', 1450);
2110 function '<=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2111 pragma BUILTIN('<=', 1, 1, 1);
2112 pragma FIPSFLAG('<=', 1450);
2113 function '>' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2114 pragma BUILTIN('>', 1, 1, 1);
2115 pragma FIPSFLAG('>', 1450);
2116 function '>=' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2117 pragma BUILTIN('>=', 1, 1, 1);
2118 pragma FIPSFLAG('>=', 1450);
2119
2120 function '=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2121 function '!=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2122 function '<ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2123 function '<=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2124 function '>ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2125 function '>=ANY' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2126 function '=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2127 function '!=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2128 function '<ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2129 function '<=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2130 function '>ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2131 function '>=ALL' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2132 function '=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2133 function '!=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2134 function '<SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2135 function '<=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2136 function '>SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2137 function '>=SOME' (LEFT "<OPAQUE_1>", RIGHT "<OPAQUE_1>") return BOOLEAN;
2138
2139 -- Outer Join
2140 function '(+)' ( colname "<OPAQUE_1>") return "<OPAQUE_1>";
2141 pragma FIPSFLAG('(+)', 1450);
2142
2143 -- GREATEST and LEAST are not yet supported for ADTs in 8.0.2.
2144 -- function GREATEST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
2145 -- pragma BUILTIN('GREATEST', 1, 1, 1);
2146
2147 -- function LEAST (pattern "<OPAQUE_1>") return "<OPAQUE_1>";
2148 -- pragma BUILTIN('LEAST', 1, 1, 1);
2149
2150 function DECODE (expr "<OPAQUE_1>", pat "<OPAQUE_1>", res "<OPAQUE_1>")
2151 return "<OPAQUE_1>";
2152 pragma BUILTIN('DECODE', 1, 1, 1);
2153
2154 function 'IS NULL' (B "<OPAQUE_1>") return BOOLEAN;
2155 pragma BUILTIN('IS NULL', 0, 3, 0);
2156 pragma FIPSFLAG('IS NULL', 1450);
2157
2158 function 'IS NOT NULL' (B "<OPAQUE_1>") return BOOLEAN;
2159 pragma BUILTIN('IS NOT NULL', 0, 3, 50);
2160 pragma FIPSFLAG('IS NOT NULL', 1450);
2161
2162 function NVL (B1 "<OPAQUE_1>", B2 "<OPAQUE_1>") return "<OPAQUE_1>";
2163 pragma FIPSFLAG('NVL', 1450);
2164
2168 -- pragma FIPSFLAG('VALUE', 1450);
2165 -- REFs to opaques are not supported yet.
2166 -- function VALUE (item "<ADT_WITH_OID>") return "<OPAQUE_1>";
2167 -- pragma BUILTIN('VALUE', 1, 1, 1);
2169
2170 -- function REF (item "<ADT_WITH_OID>") return REF "<OPAQUE_1>";
2171 -- pragma BUILTIN('REF', 1, 1, 1);
2172 -- pragma FIPSFLAG('REF', 1450);
2173
2174 -- function DEREF (r REF "<OPAQUE_1>") return "<OPAQUE_1>";
2175 -- pragma BUILTIN('DEREF', 1, 1, 1);
2176 -- pragma FIPSFLAG('DEREF', 1450);
2177
2178 -- overloadings for REF OPAQUE
2179
2180 -- function 'IS NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
2181 -- pragma BUILTIN('IS NULL', 0, 3, 0);
2182 -- pragma FIPSFLAG('IS NULL', 1450);
2183
2184 -- function 'IS NOT NULL' (B REF "<OPAQUE_1>") return BOOLEAN;
2185 -- pragma FIPSFLAG('IS NOT NULL', 1450);
2186
2187 -- function 'IS DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN;
2188 -- pragma BUILTIN('IS DANGLING', 1, 1, 1);
2189 -- pragma FIPSFLAG('IS DANGLING', 1450);
2190
2191 -- function 'IS NOT DANGLING' (B REF "<OPAQUE_1>") return BOOLEAN;
2192 -- pragma BUILTIN('IS NOT DANGLING', 1, 1, 1);
2193 -- pragma FIPSFLAG('IS NOT DANGLING', 1450);
2194
2195 -- function NVL (B1 REF "<OPAQUE_1>", B2 REF "<OPAQUE_1>")
2196 -- return REF "<OPAQUE_1>";
2197 -- pragma FIPSFLAG('NVL', 1450);
2198
2199 -- function '=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
2200 -- return BOOLEAN;
2201 -- pragma BUILTIN('=', 0, 3, 1);
2202 -- pragma FIPSFLAG('=', 1450);
2203
2204 -- function '!=' (LEFT REF "<OPAQUE_1>", RIGHT REF "<OPAQUE_1>")
2205 -- return BOOLEAN;
2206 -- pragma BUILTIN('!=', 0, 3, 2);
2207 -- pragma FIPSFLAG('!=', 1450);
2208
2209 function GROUPING(a "<OPAQUE_1>") return NUMBER;
2210 function NULLIF(a1 "<OPAQUE_1>", a2 "<OPAQUE_1>") return VARCHAR2;
2211
2212 function GREATEST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
2213 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2214 function GREATEST (pattern TIME_TZ_UNCONSTRAINED)
2215 return TIME_TZ_UNCONSTRAINED;
2216 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2217 function GREATEST (pattern TIMESTAMP_UNCONSTRAINED)
2218 return TIMESTAMP_UNCONSTRAINED;
2219 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2220 function GREATEST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
2221 return TIMESTAMP_TZ_UNCONSTRAINED;
2222 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2223 function GREATEST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
2224 return TIMESTAMP_LTZ_UNCONSTRAINED;
2225 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2226 function GREATEST (pattern YMINTERVAL_UNCONSTRAINED)
2227 return YMINTERVAL_UNCONSTRAINED;
2228 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2229 function GREATEST (pattern DSINTERVAL_UNCONSTRAINED)
2230 return DSINTERVAL_UNCONSTRAINED;
2231 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2 -- Pj
2232
2233 function LEAST (pattern TIME_UNCONSTRAINED) return TIME_UNCONSTRAINED;
2234 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2235 function LEAST (pattern TIME_TZ_UNCONSTRAINED) return TIME_TZ_UNCONSTRAINED;
2236 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2237 function LEAST (pattern TIMESTAMP_UNCONSTRAINED)
2238 return TIMESTAMP_UNCONSTRAINED;
2239 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2240 function LEAST (pattern TIMESTAMP_TZ_UNCONSTRAINED)
2241 return TIMESTAMP_TZ_UNCONSTRAINED;
2242 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2243 function LEAST (pattern TIMESTAMP_LTZ_UNCONSTRAINED)
2244 return TIMESTAMP_LTZ_UNCONSTRAINED;
2245 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2246 function LEAST (pattern YMINTERVAL_UNCONSTRAINED)
2247 return YMINTERVAL_UNCONSTRAINED;
2248 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2249 function LEAST (pattern DSINTERVAL_UNCONSTRAINED)
2250 return DSINTERVAL_UNCONSTRAINED;
2251 pragma BUILTIN('LEAST',12,240,240);-- This is special cased in PH2 -- Pj
2252
2253 function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2,
2254 parms VARCHAR2) return VARCHAR2;
2255 function TO_CHAR(left TIME_UNCONSTRAINED, format VARCHAR2) return VARCHAR2;
2256 function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2,
2257 parms VARCHAR2) return VARCHAR2;
2258 function TO_CHAR(left TIME_TZ_UNCONSTRAINED, format VARCHAR2)
2259 return VARCHAR2;
2260 function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2,
2261 parms VARCHAR2) return VARCHAR2;
2262 function TO_CHAR(left TIMESTAMP_UNCONSTRAINED, format VARCHAR2)
2263 return VARCHAR2;
2264 function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2,
2265 parms VARCHAR2) return VARCHAR2;
2266 function TO_CHAR(left TIMESTAMP_TZ_UNCONSTRAINED, format VARCHAR2)
2267 return VARCHAR2;
2268 function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2,
2269 parms VARCHAR2) return VARCHAR2;
2270 function TO_CHAR(left TIMESTAMP_LTZ_UNCONSTRAINED, format VARCHAR2)
2271 return VARCHAR2;
2272 function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2,
2273 parms VARCHAR2) return VARCHAR2;
2274 function TO_CHAR(left YMINTERVAL_UNCONSTRAINED, format VARCHAR2)
2278 function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2)
2275 return VARCHAR2;
2276 function TO_CHAR(left DSINTERVAL_UNCONSTRAINED, format VARCHAR2,
2277 parms VARCHAR2) return VARCHAR2;
2279 return VARCHAR2;
2280
2281 -- CONVERT FOR LOB --
2282 function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS,
2283 DSTCSN VARCHAR2)
2284 return CLOB CHARACTER SET SRCSTR%CHARSET;
2285 function CONVERT(SRCSTR CLOB CHARACTER SET ANY_CS,
2286 DSTCSN VARCHAR2,
2287 SRCCSN VARCHAR2)
2288 return CLOB CHARACTER SET SRCSTR%CHARSET;
2289
2290 -- NLS_UPPER/NLS_LOWER FOR LOB --
2291 function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS,
2292 parms VARCHAR2 CHARACTER SET ch%CHARSET)
2293 return CLOB CHARACTER SET ch%CHARSET;
2294 pragma FIPSFLAG('NLS_UPPER', 1452);
2295 function NLS_UPPER(ch CLOB CHARACTER SET ANY_CS)
2296 return CLOB CHARACTER SET ch%CHARSET;
2297 pragma FIPSFLAG('NLS_UPPER', 1452);
2298 function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS,
2299 parms VARCHAR2 CHARACTER SET ch%CHARSET)
2300 return CLOB CHARACTER SET ch%CHARSET;
2301 pragma FIPSFLAG('NLS_LOWER', 1452);
2302 function NLS_LOWER(ch CLOB CHARACTER SET ANY_CS)
2303 return CLOB CHARACTER SET ch%CHARSET;
2304 pragma FIPSFLAG('NLS_LOWER', 1452);
2305
2306 function COMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS)
2307 return varchar2 character set ch%charset;
2308 pragma FIPSFLAG('COMPOSE', 1452);
2309 function DECOMPOSE(ch VARCHAR2 CHARACTER SET ANY_CS,
2310 canmode in VARCHAR2 DEFAULT 'CANONICAL')
2311 return varchar2 character set ch%charset;
2312 pragma FIPSFLAG('DECOMPOSE', 1452);
2313 FUNCTION SYS_EXTRACT_UTC(t timestamp_tz_unconstrained)
2314 return TIMESTAMP_UNCONSTRAINED;
2315
2316 -- Begin REGEXP Support (10iR1) --
2317
2318 -- REGEXP_LIKE --
2319 function REGEXP_LIKE (srcstr VARCHAR2 CHARACTER SET ANY_CS,
2320 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2321 modifier VARCHAR2 DEFAULT NULL)
2322 return BOOLEAN;
2323 pragma FIPSFLAG('REGEXP_LIKE', 1452);
2324
2325 function REGEXP_LIKE (srcstr CLOB CHARACTER SET ANY_CS,
2326 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2327 modifier VARCHAR2 DEFAULT NULL)
2328 return BOOLEAN;
2329 pragma FIPSFLAG('REGEXP_LIKE', 1452);
2330
2331 -- REGEXP_INSTR --
2332 function REGEXP_INSTR(srcstr VARCHAR2 CHARACTER SET ANY_CS,
2333 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2334 position PLS_INTEGER := 1,
2335 occurrence PLS_INTEGER := 1,
2336 returnparam PLS_INTEGER := 0,
2337 modifier VARCHAR2 DEFAULT NULL,
2338 subexpression PLS_INTEGER := 0)
2339 return PLS_INTEGER;
2340 pragma FIPSFLAG('REGEXP_INSTR', 1452);
2341
2342 function REGEXP_INSTR(srcstr CLOB CHARACTER SET ANY_CS,
2343 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2344 position INTEGER := 1,
2345 occurrence INTEGER := 1,
2346 returnparam PLS_INTEGER := 0,
2347 modifier VARCHAR2 DEFAULT NULL,
2348 subexpression PLS_INTEGER := 0)
2349 return INTEGER;
2350 pragma FIPSFLAG('REGEXP_INSTR', 1452);
2351
2352
2353 -- REGEXP_SUBSTR --
2354 function REGEXP_SUBSTR(srcstr VARCHAR2 CHARACTER SET ANY_CS,
2355 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2356 position PLS_INTEGER := 1,
2357 occurrence PLS_INTEGER := 1,
2358 modifier VARCHAR2 DEFAULT NULL,
2359 subexpression PLS_INTEGER := 0)
2360 return VARCHAR2 CHARACTER SET srcstr%CHARSET;
2361 pragma FIPSFLAG('REGEXP_SUBSTR', 1452);
2362
2363 function REGEXP_SUBSTR(srcstr CLOB CHARACTER SET ANY_CS,
2364 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2365 position INTEGER := 1,
2366 occurrence INTEGER := 1,
2367 modifier VARCHAR2 DEFAULT NULL,
2368 subexpression PLS_INTEGER := 0)
2369 return CLOB CHARACTER SET srcstr%CHARSET;
2370 pragma FIPSFLAG('REGEXP_SUBSTR', 1452);
2371
2372 -- REGEXP_REPLACE --
2373 function REGEXP_REPLACE(srcstr VARCHAR2 CHARACTER SET ANY_CS,
2374 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2375 replacestr VARCHAR2 CHARACTER SET srcstr%CHARSET
2376 DEFAULT NULL,
2377 position PLS_INTEGER := 1,
2378 occurrence PLS_INTEGER := 0,
2379 modifier VARCHAR2 DEFAULT NULL)
2380 return VARCHAR2 CHARACTER SET srcstr%CHARSET;
2381 pragma FIPSFLAG('REGEXP_REPLACE', 1452);
2382
2383 function REGEXP_REPLACE(srcstr CLOB CHARACTER SET ANY_CS,
2384 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2385 replacestr CLOB CHARACTER SET srcstr%CHARSET
2386 DEFAULT NULL,
2387 position INTEGER := 1,
2388 occurrence INTEGER := 0,
2389 modifier VARCHAR2 DEFAULT NULL)
2393 function REGEXP_REPLACE(srcstr CLOB CHARACTER SET ANY_CS,
2390 return CLOB CHARACTER SET srcstr%CHARSET;
2391 pragma FIPSFLAG('REGEXP_REPLACE', 1452);
2392
2394 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2395 replacestr VARCHAR2 CHARACTER SET srcstr%CHARSET
2396 DEFAULT NULL,
2397 position INTEGER := 1,
2398 occurrence INTEGER := 0,
2399 modifier VARCHAR2 DEFAULT NULL)
2400 return CLOB CHARACTER SET srcstr%CHARSET;
2401 pragma FIPSFLAG('REGEXP_REPLACE', 1452);
2402
2403 -- End REGEXP Support --
2404
2405 -- binary_float and binary_double functions and operators.
2406 function TO_BINARY_FLOAT (RIGHT BINARY_FLOAT) RETURN BINARY_FLOAT;
2407 pragma BUILTIN('TO_BINARY_FLOAT',14, 0, 1); -- PEMS_QUICK
2408 function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS,
2409 FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
2410 RETURN BINARY_FLOAT;
2411 function TO_BINARY_FLOAT (LEFT VARCHAR2 CHARACTER SET ANY_CS,
2412 FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET,
2413 PARMS VARCHAR2 CHARACTER SET LEFT%CHARSET)
2414 RETURN BINARY_FLOAT;
2415
2416 function TO_BINARY_DOUBLE (RIGHT BINARY_DOUBLE) RETURN BINARY_DOUBLE;
2417 pragma BUILTIN('TO_BINARY_DOUBLE',14, 0, 1); -- PEMS_QUICK
2418 function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS,
2419 FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET)
2420 RETURN BINARY_DOUBLE;
2421 function TO_BINARY_DOUBLE (LEFT VARCHAR2 CHARACTER SET ANY_CS,
2422 FORMAT VARCHAR2 CHARACTER SET LEFT%CHARSET,
2423 PARMS VARCHAR2 CHARACTER SET LEFT%CHARSET)
2424 RETURN BINARY_DOUBLE;
2425
2426 function 'IS NAN' (N NUMBER) RETURN BOOLEAN;
2427 function 'IS NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
2428 function 'IS NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
2429 function 'IS INFINITE' (N NUMBER) RETURN BOOLEAN;
2430 function 'IS INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
2431 function 'IS INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
2432 function 'IS NOT NAN' (N NUMBER) RETURN BOOLEAN;
2433 function 'IS NOT NAN' (F BINARY_FLOAT) RETURN BOOLEAN;
2434 function 'IS NOT NAN' (D BINARY_DOUBLE) RETURN BOOLEAN;
2435 function 'IS NOT INFINITE' (N NUMBER) RETURN BOOLEAN;
2436 function 'IS NOT INFINITE' (F BINARY_FLOAT) RETURN BOOLEAN;
2437 function 'IS NOT INFINITE' (D BINARY_DOUBLE) RETURN BOOLEAN;
2438
2439 function TO_CHAR (left binary_float, format varchar2)
2440 return VARCHAR2;
2441 function TO_CHAR (left binary_double, format varchar2)
2442 return VARCHAR2;
2443
2444 function TO_CHAR(left binary_float, format varchar2, parms varchar2)
2445 return varchar2;
2446 function TO_CHAR(left binary_double, format varchar2, parms varchar2)
2447 return varchar2;
2448
2449 function TO_NCHAR(left binary_float, format nvarchar2) return NVARCHAR2;
2450 function TO_NCHAR(left binary_double, format nvarchar2) return NVARCHAR2;
2451
2452 function TO_NCHAR(left binary_float, format nvarchar2, parms nvarchar2)
2453 return nvarchar2;
2454 function TO_NCHAR(left binary_double, format nvarchar2, parms nvarchar2)
2455 return nvarchar2;
2456
2457 function 'REMAINDER'(n1 NUMBER, n2 NUMBER) return NUMBER;
2458 pragma FIPSFLAG('REMAINDER', 1452);
2459 function REMAINDER(n1 NUMBER, n2 NUMBER) return NUMBER;
2460 pragma FIPSFLAG(REMAINDER, 1452);
2461 function 'REMAINDER'(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
2462 pragma FIPSFLAG('REMAINDER', 1452);
2463 function REMAINDER(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
2464 pragma FIPSFLAG(REMAINDER, 1452);
2465 function 'REMAINDER'(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
2466 pragma FIPSFLAG('REMAINDER', 1452);
2467 function REMAINDER(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
2468 pragma FIPSFLAG(REMAINDER, 1452);
2469
2470 function '=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2471 pragma BUILTIN('=',2, 2, 15);
2472 function '!=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2473 pragma BUILTIN('!=',5, 2, 16);
2474 pragma FIPSFLAG('!=', 1452);
2475 function '<' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2476 pragma BUILTIN('<',4, 2, 17);
2477 function '<=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2478 pragma BUILTIN('<=',6, 2, 18);
2479 function '>' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2480 pragma BUILTIN('>',1, 2, 19);
2481 function '>=' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BOOLEAN;
2482 pragma BUILTIN('>=',3, 2, 20);
2483
2484 function 'IS NULL' (n BINARY_FLOAT) return BOOLEAN;
2485 pragma BUILTIN('IS NULL', 0, 2, 0);
2486 function 'IS NOT NULL' (n BINARY_FLOAT) return BOOLEAN;
2487 pragma BUILTIN('IS NOT NULL', 0, 2, 50);
2488
2489 function NVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
2490 pragma FIPSFLAG('NVL', 1452);
2491
2492 function '+' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2493 pragma BUILTIN('+',14, 0, 1);
2494 function '-' (RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2495 pragma BUILTIN('-',15, 2, 23);
2496 function ABS(F BINARY_FLOAT) return BINARY_FLOAT;
2497 pragma FIPSFLAG('ABS', 1452);
2498
2499 function '+' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2500 pragma BUILTIN('+',14, 2, 24);
2501 function '-' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2505 function '/' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2502 pragma BUILTIN('-',15, 2, 25);
2503 function '*' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2504 pragma BUILTIN('*',17, 2, 26);
2506 pragma BUILTIN('/',18, 2, 27);
2507
2508 function 'REM' (LEFT BINARY_FLOAT, RIGHT BINARY_FLOAT) return BINARY_FLOAT;
2509 pragma FIPSFLAG('REM', 1452);
2510 function 'MOD'(F1 BINARY_FLOAT, F2 BINARY_FLOAT) return BINARY_FLOAT;
2511 pragma FIPSFLAG('MOD', 1452);
2512
2513 function FLOOR(F BINARY_FLOAT) return BINARY_FLOAT;
2514 pragma FIPSFLAG('FLOOR', 1452);
2515 function CEIL(F BINARY_FLOAT) return BINARY_FLOAT;
2516 pragma FIPSFLAG('CEIL', 1452);
2517 function SIGN(f BINARY_FLOAT) return SIGNTYPE;
2518 pragma FIPSFLAG('SIGN', 1452);
2519 function SQRT(f BINARY_FLOAT) return BINARY_FLOAT;
2520 pragma FIPSFLAG('SQRT', 1452);
2521
2522 function TRUNC (F BINARY_FLOAT) return BINARY_FLOAT;
2523 pragma FIPSFLAG('TRUNC', 1452);
2524
2525 function ROUND (LEFT BINARY_FLOAT) return BINARY_FLOAT;
2526 pragma FIPSFLAG('ROUND', 1452);
2527
2528 function '=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2529 pragma BUILTIN('=',2, 2, 28);
2530 function '!=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2531 -- also <> and ~=
2532 pragma BUILTIN('!=',5, 2, 29);
2533 pragma FIPSFLAG('!=', 1452);
2534 function '<' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2535 pragma BUILTIN('<',4, 2, 30);
2536 function '<=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2537 pragma BUILTIN('<=',6, 2, 31);
2538 function '>' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2539 pragma BUILTIN('>',1, 2, 32);
2540 function '>=' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BOOLEAN;
2541 pragma BUILTIN('>=',3, 2, 33);
2542
2543 function 'IS NULL' (n BINARY_DOUBLE) return BOOLEAN;
2544 pragma BUILTIN('IS NULL', 0, 2, 0);
2545 function 'IS NOT NULL' (n BINARY_DOUBLE) return BOOLEAN;
2546 pragma BUILTIN('IS NOT NULL', 0, 2, 50);
2547
2548 function NVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
2549 pragma FIPSFLAG('NVL', 1452);
2550
2551 function '+' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2552 pragma BUILTIN('+',14, 0, 1);
2553 function '-' (RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2554 pragma BUILTIN('-',15, 2, 36);
2555 function ABS(D BINARY_DOUBLE) return BINARY_DOUBLE;
2556 pragma FIPSFLAG('ABS', 1452);
2557
2558 function ACOS(D BINARY_DOUBLE) return BINARY_DOUBLE;
2559 pragma FIPSFLAG('ACOS', 1452);
2560
2561 function ASIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
2562 pragma FIPSFLAG('ASIN', 1452);
2563
2564 function ATAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
2565 pragma FIPSFLAG('ATAN', 1452);
2566
2567 function ATAN2(x BINARY_DOUBLE, y BINARY_DOUBLE) return BINARY_DOUBLE;
2568 pragma FIPSFLAG('ATAN2', 1452);
2569
2570 function '+' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2571 pragma BUILTIN('+',14, 2, 37);
2572 function '-' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2573 pragma BUILTIN('-',15, 2, 38);
2574 function '*' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2575 pragma BUILTIN('*',17, 2, 39);
2576 function '/' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2577 pragma BUILTIN('/',18, 2, 40);
2578
2579 function 'REM' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
2580 return BINARY_DOUBLE;
2581 pragma FIPSFLAG('REM', 1452);
2582 function 'MOD'(D1 BINARY_DOUBLE, D2 BINARY_DOUBLE) return BINARY_DOUBLE;
2583 pragma FIPSFLAG('MOD', 1452);
2584
2585 function '**' (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE)
2586 return BINARY_DOUBLE;
2587 pragma FIPSFLAG('**', 1452);
2588
2589 function FLOOR(D BINARY_DOUBLE) return BINARY_DOUBLE;
2590 pragma FIPSFLAG('FLOOR', 1452);
2591 function CEIL(D BINARY_DOUBLE) return BINARY_DOUBLE;
2592 pragma FIPSFLAG('CEIL', 1452);
2593 function SQRT(d BINARY_DOUBLE) return BINARY_DOUBLE;
2594 pragma FIPSFLAG('SQRT', 1452);
2595 function SIGN(d BINARY_DOUBLE) return SIGNTYPE;
2596 pragma FIPSFLAG('SIGN', 1452);
2597
2598 function COS(D BINARY_DOUBLE) return BINARY_DOUBLE;
2599 function SIN(D BINARY_DOUBLE) return BINARY_DOUBLE;
2600 function TAN(D BINARY_DOUBLE) return BINARY_DOUBLE;
2601 function COSH(D BINARY_DOUBLE) return BINARY_DOUBLE;
2602 function SINH(D BINARY_DOUBLE) return BINARY_DOUBLE;
2603 function TANH(D BINARY_DOUBLE) return BINARY_DOUBLE;
2604 function EXP(D BINARY_DOUBLE) return BINARY_DOUBLE;
2605 function LN(D BINARY_DOUBLE) return BINARY_DOUBLE;
2606
2607 function LOG (LEFT BINARY_DOUBLE, RIGHT BINARY_DOUBLE) return BINARY_DOUBLE;
2608
2609 function TRUNC (D BINARY_DOUBLE) return BINARY_DOUBLE;
2610 pragma FIPSFLAG('TRUNC', 1452);
2611
2612 function ROUND (LEFT BINARY_DOUBLE) return BINARY_DOUBLE;
2613 pragma FIPSFLAG('ROUND', 1452);
2614
2615 function POWER (d BINARY_DOUBLE, e BINARY_DOUBLE) return BINARY_DOUBLE;
2616 pragma FIPSFLAG('POWER', 1452);
2617
2618 function NANVL(n1 NUMBER, n2 NUMBER) return NUMBER;
2619 function NANVL(f1 BINARY_FLOAT, f2 BINARY_FLOAT) return BINARY_FLOAT;
2620 function NANVL(d1 BINARY_DOUBLE, d2 BINARY_DOUBLE) return BINARY_DOUBLE;
2621
2622 function GREATEST (pattern BINARY_FLOAT) return BINARY_FLOAT;
2623 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
2624 function GREATEST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
2628 function LEAST (pattern BINARY_DOUBLE) return BINARY_DOUBLE;
2625 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
2626 function LEAST (pattern BINARY_FLOAT) return BINARY_FLOAT;
2627 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
2629 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
2630
2631
2632 function '+' (RIGHT PLS_INTEGER) return PLS_INTEGER;
2633 pragma BUILTIN('+',14, 0, 1); -- PEMS_QUICK
2634 function '-' (RIGHT PLS_INTEGER) return PLS_INTEGER;
2635 pragma BUILTIN('-',15, 2, 41);
2636 function ABS(I PLS_INTEGER) return PLS_INTEGER;
2637 pragma FIPSFLAG('ABS', 1452);
2638
2639 function '+' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
2640 pragma BUILTIN('+',14, 2, 42);
2641 function '-' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
2642 pragma BUILTIN('-',14, 2, 43);
2643 function '*' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return PLS_INTEGER;
2644 pragma BUILTIN('*',14, 2, 44);
2645
2646 function '=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2647 pragma BUILTIN('=',2, 2, 45); -- PEMS_PLS_INTEGER, PEMDCMEQ
2648 function '!=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2649 -- also <> and ~=
2650 pragma BUILTIN('!=',5, 2, 46); -- PEMS_PLS_INTEGER, PEMDCMNE
2651 pragma FIPSFLAG('!=', 1452);
2652 function '<' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2653 pragma BUILTIN('<',4, 2, 47); -- PEMS_PLS_INTEGER, PEMDCMLT
2654 function '<=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2655 pragma BUILTIN('<=',6, 2, 48); -- PEMS_PLS_INTEGER, PEMDCMLE
2656 function '>' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2657 pragma BUILTIN('>',1, 2, 49); -- PEMS_PLS_INTEGER, PEMDCMGT
2658 function '>=' (LEFT PLS_INTEGER, RIGHT PLS_INTEGER) return BOOLEAN;
2659 pragma BUILTIN('>=',3, 2, 51); -- PEMS_PLS_INTEGER, PEMDCMGE
2660
2661 function 'IS NULL' (I PLS_INTEGER) return BOOLEAN;
2662 pragma BUILTIN('IS NULL', 0, 2, 0); -- PEMS_PLS_INTEGER, PEMDNUL
2663 function 'IS NOT NULL' (I PLS_INTEGER) return BOOLEAN;
2664 pragma BUILTIN('IS NOT NULL', 0, 2, 50); -- PEMS_PLS_INTEGER, PEMDNUL
2665
2666 function NVL(I1 PLS_INTEGER, I2 PLS_INTEGER) return PLS_INTEGER;
2667 pragma FIPSFLAG('NVL', 1452);
2668
2669 function TRUNC (i pls_integer, places pls_integer := 0) return pls_integer;
2670 pragma FIPSFLAG('TRUNC', 1452);
2671
2672 function ROUND (i pls_integer, places pls_integer := 0) return pls_integer;
2673 pragma FIPSFLAG('ROUND', 1452);
2674
2675 function SIGN(i PLS_INTEGER) return SIGNTYPE;
2676 pragma FIPSFLAG('SIGN', 1452);
2677
2678 function GREATEST (pattern PLS_INTEGER) return PLS_INTEGER;
2679 pragma BUILTIN('GREATEST',12,240,240);-- This is special cased in PH2
2680 function LEAST (pattern PLS_INTEGER) return PLS_INTEGER;
2681 pragma BUILTIN('LEAST',13,240,240);-- This is special cased in PH2
2682
2683 -- MultiSet Functions and Operators.
2684
2685 -- Equality
2686 function '='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
2687 return BOOLEAN;
2688 pragma BUILTIN('=',2, 16, 1);
2689
2690 function '!='(collection1 IN "<TABLE_1>",collection2 IN "<TABLE_1>")
2691 return BOOLEAN;
2692 pragma BUILTIN('!=',2, 16, 2);
2693
2694 function CARDINALITY (collection IN "<TABLE_1>") return PLS_INTEGER;
2695
2696 function SET (collection IN "<TABLE_1>") return "<TABLE_1>";
2697 pragma BUILTIN('SET',18, 2, 40);-- Dummy
2698
2699 function 'IS A SET' (collection IN "<TABLE_1>") return BOOLEAN;
2700 pragma BUILTIN('IS A SET',18, 2, 40);-- Dummy
2701 function 'IS NOT A SET'(collection IN "<TABLE_1>") return BOOLEAN;
2702 pragma BUILTIN('IS NOT A SET',18, 2, 40);-- Dummy
2703
2704 function 'IS EMPTY' (collection IN "<TABLE_1>") return BOOLEAN;
2705 function 'IS NOT EMPTY'(collection IN "<TABLE_1>") return BOOLEAN;
2706
2707 -- IS A SUBMULTISET OF
2708 function 'SUBMULTISET' (collection IN "<TABLE_1>",
2709 collection2 IN "<TABLE_1>")
2710 return BOOLEAN;
2711 pragma BUILTIN('SUBMULTISET',18, 2, 40);
2712
2713 function 'MULTISET_UNION_ALL' (collection IN "<TABLE_1>",
2714 collection2 IN "<TABLE_1>")
2715 return "<TABLE_1>";
2716 pragma BUILTIN('MULTISET_UNION_ALL',18, 2, 40);
2717
2718 function 'MULTISET_UNION_DISTINCT' (collection IN "<TABLE_1>",
2719 collection2 IN "<TABLE_1>")
2720 return "<TABLE_1>";
2721 pragma BUILTIN('MULTISET_UNION_DISTINCT',18, 2, 40);-- Dummy
2722
2723 function 'MULTISET_EXCEPT_ALL' (collection IN "<TABLE_1>",
2724 collection2 IN "<TABLE_1>")
2725 return "<TABLE_1>";
2726 pragma BUILTIN('MULTISET_EXCEPT_ALL',18, 2, 40);-- Dummy
2727
2728 function 'MULTISET_EXCEPT_DISTINCT' (collection IN "<TABLE_1>",
2729 collection2 IN "<TABLE_1>")
2730 return "<TABLE_1>";
2731 pragma BUILTIN('MULTISET_EXCEPT_DISTINCT',18, 2, 40);-- Dummy
2732
2733 function 'MULTISET_INTERSECT_ALL' (collection IN "<TABLE_1>",
2734 collection2 IN "<TABLE_1>")
2735 return "<TABLE_1>";
2736 pragma BUILTIN('MULTISET_INTERSECT_ALL',18, 2, 40);-- Dummy
2737
2738 function 'MULTISET_INTERSECT_DISTINCT' (collection IN "<TABLE_1>",
2739 collection2 IN "<TABLE_1>")
2740 return "<TABLE_1>";
2741 pragma BUILTIN('MULTISET_INTERSECT_DISTINCT',18, 2, 40);-- Dummy
2742
2746
2743 -- These are dummy procedures for correct management of new control
2744 -- statements added to PL/SQL. They ensure local procedures which have the
2745 -- same names as newly introduced keywords are not masked by those keywords.
2747 procedure continue;
2748
2749 -- REGEXP_COUNT --
2750 function REGEXP_COUNT(srcstr VARCHAR2 CHARACTER SET ANY_CS,
2751 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2752 position PLS_INTEGER := 1,
2753 modifier VARCHAR2 DEFAULT NULL)
2754 return PLS_INTEGER;
2755 pragma FIPSFLAG('REGEXP_COUNT', 1452);
2756
2757 function REGEXP_COUNT(srcstr CLOB CHARACTER SET ANY_CS,
2758 pattern VARCHAR2 CHARACTER SET srcstr%CHARSET,
2759 position INTEGER := 1,
2760 modifier VARCHAR2 DEFAULT NULL)
2761 return INTEGER;
2762 pragma FIPSFLAG('REGEXP_COUNT', 1452);
2763
2764 --#### All user-visible declarations should preceed this point. The
2765 --#### following are implementation-oriented pragmas that may need
2766 --#### editing in the future; we would prefer to be able to edit them
2767 --#### without affecting the rft numbering of user-visible items.
2768
2769 --#### interface pragmas
2770
2771 --#### Note that for any ICD which maps directly to a PVM
2772 --#### Opcode MUST be mapped to pes_dummy.
2773 --#### An ICD which invokes another ICD by flipping operands is
2774 --#### mapped to pes_flip, and an ICD whose result is the inverse of
2775 --#### another ICD is mapped to pes_invert
2776 --#### New ICDs should be placed at the end of this list, and a
2777 --#### corresponding entry must be made in the ICD table in pdz7
2778
2779 PRAGMA interface(c,length,"pes_dummy",1);
2780 PRAGMA interface(c,substr,"pes_dummy",1);
2781 PRAGMA interface(c,instr,"pesist",1);
2782 PRAGMA interface(c,UPPER,"pesupp",1);
2783 PRAGMA interface(c,LOWER,"peslow",1);
2784 PRAGMA interface(c,ASCII,"pesasc");
2785 PRAGMA interface(c,ASCIISTR,"pesastr");
2786 PRAGMA interface(c,UNISTR,"pesustr");
2787 PRAGMA interface(c,CHR,"peschr");
2788 PRAGMA interface(c," SYS$STANDARD_CHR","peschr");
2789 PRAGMA interface(c,INITCAP,"pesicp");
2790 PRAGMA interface(c,LPAD,"peslpd",1);
2791 PRAGMA interface(c,LPAD,"peslpd",2);
2792 PRAGMA interface(c,RPAD,"pesrpd",1);
2793 PRAGMA interface(c,RPAD,"pesrpd",2);
2794 PRAGMA interface(c,REPLACE,"pesrep",1);
2795 PRAGMA interface(c,LTRIM,"pesltr",1);
2796 PRAGMA interface(c,LTRIM,"pesltr",2);
2797 PRAGMA interface(c,RTRIM,"pesrtr",1);
2798 PRAGMA interface(c,RTRIM,"pesrtr",2);
2799 PRAGMA interface(c,'LIKE',"peslik",1);
2800 PRAGMA interface(c,'LIKE',"pesli2",2);
2801 PRAGMA interface(c,ABS,"pes_dummy",1);
2802 PRAGMA interface(c,'MOD',"pesmod", 1);
2803 PRAGMA interface(c,floor,"pesflo", 1);
2804 PRAGMA interface(c,CEIL,"pescei", 1);
2805 PRAGMA interface (c, SQRT, "pessqt", 1);
2806 PRAGMA interface(c,SIGN,"pessgn", 1);
2807 PRAGMA interface(c,cos,"pescos", 1);
2808 PRAGMA interface(c,sin,"pessin",1);
2809 PRAGMA interface(c,TAN,"pestan",1);
2810 PRAGMA interface(c,COSH,"pescsh",1);
2811 PRAGMA interface(c,SINH,"pessnh",1);
2812 PRAGMA interface(c,TANH,"pestnh",1);
2813 PRAGMA interface(c,EXP,"pesexp",1);
2814 PRAGMA interface(c,LN,"pesln",1);
2815 PRAGMA interface(c,BITAND,"pesbtd",1);
2816 PRAGMA interface(c,BITAND,"pesbtdn",2);
2817 PRAGMA interface(c,LOG,"peslog",1);
2818 PRAGMA interface(c,TRUNC,"pestru",1);
2819 PRAGMA interface(c,ROUND,"pesrnd",1);
2820 PRAGMA interface(c,POWER,"pespow",1);
2821 PRAGMA interface(c,NEW_TIME,"pesnwt");
2822 PRAGMA interface(c,TO_DATE,"pesc2d",4);
2823 PRAGMA interface(c,TO_NUMBER,"pesc2n",3);
2824 PRAGMA interface(c,TO_NUMBER,"pesc2n",4);
2825 PRAGMA interface(c,'>=',"pes_flip",5);
2826 PRAGMA interface(c,'>',"pes_flip",5);
2827 PRAGMA interface(c,'<=',"peszle",5);
2828 PRAGMA interface(c,'<',"peszlt",5); -- ICD #50
2829 PRAGMA interface(c,'=',"peszeq",5);
2830 PRAGMA interface(c,'!=',"pes_invert",5);
2831 PRAGMA interface(c,nlssort,"pesxco",2);
2832 PRAGMA interface(c,NLS_UPPER,"pesxup",1);
2833 PRAGMA interface(c,NLS_UPPER,"peslcnup",3); -- LOB NLS_UPPER
2834 PRAGMA interface(c,NLS_UPPER,"peslcnup",4); -- LOB NLS_UPPER
2835 PRAGMA interface(c,NLS_LOWER,"pesxlo",1);
2836 PRAGMA interface(c,NLS_LOWER,"peslcnlr",3); -- LOB NLS_LOWER
2837 PRAGMA interface(c,NLS_LOWER,"peslcnlr",4); -- LOB NLS_LOWER
2838 PRAGMA interface(c,NLS_INITCAP,"pesxcp",1);
2839 PRAGMA interface(c,lengthb,"pes_dummy",1);
2840 PRAGMA interface(c,substrb,"pes_dummy",1);
2841 PRAGMA interface(c,instrb,"pesxis",1);
2842 PRAGMA interface(c,TO_SINGLE_BYTE, "pesxsi");
2843 PRAGMA interface(c,TO_MULTI_BYTE,"pesxmu");
2844 PRAGMA interface(c,TO_CHAR,"pesd2c",5);
2845 PRAGMA interface(c,TO_CHAR,"pesn2c",6);
2846 PRAGMA interface(c,TO_NCHAR,"pesd2c",4);
2847 PRAGMA interface(c,TO_NCHAR,"pesn2c",5);
2848 PRAGMA interface(c," SYS$STANDARD_TRANSLATE","pesxcs");
2849 PRAGMA interface(c,ATAN,"pesatan",1);
2850 PRAGMA interface(c,EMPTY_CLOB,"peslcem");
2851 PRAGMA interface(c,EMPTY_BLOB,"peslbem");
2852 PRAGMA interface(c,BFILENAME,"pesfnm");
2853 PRAGMA interface(c,TO_TIME,"pes3tm",2);
2854 PRAGMA interface(c,TO_TIME,"pes3tm",3);
2855 PRAGMA interface(c,TO_TIMESTAMP,"pes3ts",2);
2856 PRAGMA interface(c,TO_TIMESTAMP,"pes3ts",3);
2857 PRAGMA interface(c,TO_TIMESTAMP_TZ,"pes3tp",2);
2858 PRAGMA interface(c,TO_TIMESTAMP_TZ,"pes3tp",3);
2859 PRAGMA interface(c,TO_TIME_TZ,"pes3te",2);
2860 PRAGMA interface(c,TO_TIME_TZ,"pes3te",3);
2864 PRAGMA interface(c,SESSIONTIMEZONE,"pesstz",1);
2861 PRAGMA interface(c,TO_DSINTERVAL,"pes2dsi",2);
2862 PRAGMA interface(c,SYS_AT_TIME_ZONE,"pesatz",1);
2863 PRAGMA interface(c,SYS_AT_TIME_ZONE,"pesatz",2);
2865 PRAGMA interface(c," SYS$STANDARD_TRIM","pestrim",1);
2866 PRAGMA interface(c," SYS$STANDARD_TRIM","pestrim",2);
2867 PRAGMA interface(c," SYS$STANDARD_TRIM","pestrim",3);
2868 PRAGMA interface(c,TRIM,"pestrim",1);
2869 -- Datetime addition
2870 PRAGMA interface(c,'+',"pesati",5); -- +(tsp, iym) return tsp
2871 PRAGMA interface(c,'+',"pesati",6); -- +(tsp, ids) return tsp
2872 PRAGMA interface(c,'+',"pesati",7); -- +(tsz, iym) return tsz
2873 PRAGMA interface(c,'+',"pesati",8); -- +(tsz, ids) return tsz
2874 PRAGMA interface(c,'+',"pesati",9); -- +(tim, ids) return tim
2875 PRAGMA interface(c,'+',"pesati",10); -- +(tmz, ids) return tmz
2876 PRAGMA interface(c,'+',"pesadi",11); -- +(dat, iym) return dat
2877 PRAGMA interface(c,'+',"pesadi",12); -- +(dat, ids) return dat
2878 PRAGMA interface(c,'+',"pes_flip",13); -- +(iym, tsp) return tsp
2879 PRAGMA interface(c,'+',"pes_flip",14); -- +(iym, tsz) return tsz -- ICD #100
2880 PRAGMA interface(c,'+',"pes_flip",15); -- +(iym, dat) return dat
2881 PRAGMA interface(c,'+',"pes_flip",16); -- +(ids, tsp) return tsp
2882 PRAGMA interface(c,'+',"pes_flip",17); -- +(ids, tsz) return tsz
2883 PRAGMA interface(c,'+',"pes_flip",18); -- +(ids, tim) return tim
2884 PRAGMA interface(c,'+',"pes_flip",19); -- +(ids, tmz) return tmz
2885 PRAGMA interface(c,'+',"pes_flip",20); -- +(ids, dat) return dat
2886 PRAGMA interface(c,'+',"pesaii",21); -- +(ids, ids) return ids
2887 PRAGMA interface(c,'+',"pesaii",22); -- +(iym, iym) return iym
2888 PRAGMA interface(c,'+',"pesati",23); -- +(ltz, iym) return ltz
2889 PRAGMA interface(c,'+',"pesati",24); -- +(ltz, ids) return ltz
2890 PRAGMA interface(c,'+',"pes_flip",25);-- +(iym, ltz) return ltz
2891 PRAGMA interface(c,'+',"pes_flip",26);-- +(ids, ltz) return ltz
2892 -- Datetime subtraction
2893 PRAGMA interface(c,'-',"pessti",6); -- -(tsp, iym) return tsp
2894 PRAGMA interface(c,'-',"pessti",7); -- -(tsp, ids) return tsp
2895 PRAGMA interface(c,'-',"pessti",8); -- -(tsz, iym) return tsz
2896 PRAGMA interface(c,'-',"pessti",9); -- -(tsz, ids) return tsz
2897 PRAGMA interface(c,'-',"pessti",10); -- -(tim, ids) return tim
2898 PRAGMA interface(c,'-',"pessti",11); -- -(tmz, ids) return tmz
2899 PRAGMA interface(c,'-',"pessdi",12); -- -(dat, iym) return dat
2900 PRAGMA interface(c,'-',"pessdi",13); -- -(dat, ids) return dat
2901 PRAGMA interface(c,'-',"pessii",14); -- -(iym, iym) return iym
2902 PRAGMA interface(c,'-',"pessii",15); -- -(ids, ids) return ids
2903 PRAGMA interface(c,'-',"pessttds",16); -- -(tim, tim) return ids
2904 PRAGMA interface(c,'-',"pessttds",17); -- -(tsp, tsp) return ids
2905 PRAGMA interface(c,'-',"pessttds",18); -- -(tmz, tmz) return ids
2906 PRAGMA interface(c,'-',"pessttds",19); -- -(tsz, tsz) return ids
2907 PRAGMA interface(c,'-',"pessti",20); -- -(ltz, iym) return iym
2908 PRAGMA interface(c,'-',"pessti",21); -- -(ltz, ids) return ids
2909 PRAGMA interface(c,'-',"pessttds",22); -- -(ltz, ltz) return ids
2910 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessttds",1);
2911 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessttds",2);
2912 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessttds",3);
2913 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessttds",4);
2914 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessddds",5);
2915 PRAGMA interface(c," SYS$DSINTERVALSUBTRACT","pessttds",6);
2916 PRAGMA interface(c," SYS$YMINTERVALSUBTRACT","pessttym",1);
2917 PRAGMA interface(c," SYS$YMINTERVALSUBTRACT","pessttym",2);
2918 PRAGMA interface(c," SYS$YMINTERVALSUBTRACT","pessddym",3);
2919 PRAGMA interface(c," SYS$YMINTERVALSUBTRACT","pessttym",4);
2920 -- Datetime multiplication
2921 PRAGMA interface(c,'*',"pesmni",2); -- *(num, iym) return iym
2922 PRAGMA interface(c,'*',"pesmni",3); -- *(num, ids) return ids
2923 PRAGMA interface(c,'*',"pes_flip",4); -- *(iym, num) return iym
2924 PRAGMA interface(c,'*',"pes_flip",5); -- *(ids, num) return ids
2925 -- Datetime division
2926 PRAGMA interface(c,'/',"pesdvin",2); -- /(iym, num) return iym
2927 PRAGMA interface(c,'/',"pesdvin",3); -- /(ids, num) return ids
2928 -- TIME
2929 PRAGMA interface(c,'=',"pes_dummy",9);
2930 PRAGMA interface(c,'!=',"pes_invert",9);
2931 PRAGMA interface(c,'>',"pes_flip",8);
2932 PRAGMA interface(c,'<',"pes_dummy",8);
2933 PRAGMA interface(c,'>=',"pes_flip",8); -- ICD #150
2934 PRAGMA interface(c,'<=',"pes_dummy",8);
2935 -- TIME WITH TIME ZONE
2936 PRAGMA interface(c,'=',"pes_dummy",10);
2937 PRAGMA interface(c,'!=',"pes_invert",10);
2938 PRAGMA interface(c,'>',"pes_flip",9);
2939 PRAGMA interface(c,'<',"pes_dummy",9);
2940 PRAGMA interface(c,'>=',"pes_flip",9);
2941 PRAGMA interface(c,'<=',"pes_dummy",9);
2942 -- TIMESTAMP
2943 PRAGMA interface(c,'=',"pes_dummy",11);
2944 PRAGMA interface(c,'!=',"pes_invert",11);
2945 PRAGMA interface(c,'>',"pes_flip",10);
2946 PRAGMA interface(c,'<',"pes_dummy",10);
2947 PRAGMA interface(c,'>=',"pes_flip",10);
2948 PRAGMA interface(c,'<=',"pes_dummy",10);
2949 -- INTERVAL YEAR TO MONTH
2950 PRAGMA interface(c,'=',"pes_dummy",12);
2951 PRAGMA interface(c,'!=',"pes_invert",12);
2952 PRAGMA interface(c,'>',"pes_flip",11);
2953 PRAGMA interface(c,'<',"pes_dummy",11);
2954 PRAGMA interface(c,'>=',"pes_flip",11);
2955 PRAGMA interface(c,'<=',"pes_dummy",11);
2956 -- INTERVAL DAY TO SECOND
2957 PRAGMA interface(c,'=',"pes_dummy",13);
2958 PRAGMA interface(c,'!=',"pes_invert",13);
2962 PRAGMA interface(c,'<=',"pes_dummy",12);
2959 PRAGMA interface(c,'>',"pes_flip",12);
2960 PRAGMA interface(c,'<',"pes_dummy",12);
2961 PRAGMA interface(c,'>=',"pes_flip",12);
2963 -- TIMESTAMP_TZ_UNCONSTRAINED
2964 PRAGMA interface(c,'=',"pes_dummy",14);
2965 PRAGMA interface(c,'!=',"pes_invert",14);
2966 PRAGMA interface(c,'>',"pes_flip",13);
2967 PRAGMA interface(c,'<',"pes_dummy",13);
2968 PRAGMA interface(c,'>=',"pes_flip",13);
2969 PRAGMA interface(c,'<=',"pes_dummy",13);
2970 -- TIMESTAMP WITH LOCAL TIME ZONE
2971 PRAGMA interface(c,'=',"pes_dummy",15);
2972 PRAGMA interface(c,'!=',"pes_invert",15);
2973 PRAGMA interface(c,'>',"pes_flip",14);
2974 PRAGMA interface(c,'<',"pes_dummy",14);
2975 PRAGMA interface(c,'>=',"pes_flip",14);
2976 PRAGMA interface(c,'<=',"pes_dummy",14);
2977 -- Other datetime functions
2978 PRAGMA interface(c,'CURRENT_DATE',"pescdt",1);
2979 PRAGMA interface(c,'CURRENT_TIME',"pesctm",1);
2980 PRAGMA interface(c,'CURRENT_TIMESTAMP',"pescts",1);
2981 -- Internal calls to evaluate datetime/interval literals without NLS parms.
2982 PRAGMA interface(c,SYS_LITERALTOYMINTERVAL,"pesc2ymi",1);
2983 PRAGMA interface(c,SYS_LITERALTODSINTERVAL,"pesc2dsi",1);
2984 PRAGMA interface(c,SYS_LITERALTOTIME,"pesc2tim",1);
2985 PRAGMA interface(c,SYS_LITERALTOTZTIME,"pesc2tim",1);
2986 PRAGMA interface(c,SYS_LITERALTOTIMESTAMP,"pesc2tsp",1);
2987 PRAGMA interface(c,SYS_LITERALTOTZTIMESTAMP,"pesc2tsp",1);
2988 PRAGMA interface(c,SYS_LITERALTODATE,"pesc2date",1);
2989 -- extract(field from expr)
2990 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefd",1);
2991 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefd",2);
2992 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefd",3); -- ICD #200
2993 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefd",4);
2994 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefd",5);
2995 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefdt",6);
2996 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefi",7);
2997 PRAGMA interface(c," SYS$EXTRACT_FROM","pesefi",8);
2998 -- datetime is null
2999 PRAGMA interface(c,"IS NULL","pes_dummy",14); -- time
3000 PRAGMA interface(c,"IS NULL","pes_dummy",15); -- time wtz
3001 PRAGMA interface(c,"IS NULL","pes_dummy",16); -- timestamp
3002 PRAGMA interface(c,"IS NULL","pes_dummy",17); -- timestamp wtz
3003 PRAGMA interface(c,"IS NULL","pes_dummy",18); -- timestamp lwtz
3004 PRAGMA interface(c,"IS NULL","pes_dummy",19); -- interval ym
3005 PRAGMA interface(c,"IS NULL","pes_dummy",20); -- interval ds
3006
3007 -- 8.2 LOB Built-in Functions
3008 PRAGMA interface(c,length, "peslcln",2); -- LOB LENGTH
3009 PRAGMA interface(c,lengthb,"peslclb",2); -- LOB LENGTHB
3010 PRAGMA interface(c,substr, "peslcst",2); -- LOB SUBSTR
3011 PRAGMA interface(c,substrb,"peslcsb",2); -- LOB SUBSTRB
3012 PRAGMA interface(c,instr, "peslcin",2); -- LOB INSTR
3013 PRAGMA interface(c,instrb, "peslcib",2); -- LOB INSTRB
3014 PRAGMA interface(c,'||', "peslcct",2); -- LOB '||'
3015 PRAGMA interface(c,concat, "peslcct",2); -- LOB CONCAT
3016 PRAGMA interface(c,lpad, "peslclp",3); -- LOB LPAD
3017 PRAGMA interface(c,lpad, "peslclp",4); -- LOB LPAD
3018 PRAGMA interface(c,rpad, "peslcrp",3); -- LOB RPAD
3019 PRAGMA interface(c,rpad, "peslcrp",4); -- LOB RPAD
3020 PRAGMA interface(c,lower, "peslclr",2); -- LOB LOWER
3021 PRAGMA interface(c,upper, "peslcup",2); -- LOB UPPER
3022 PRAGMA interface(c,ltrim, "peslclm",3); -- LOB LTRIM
3023 PRAGMA interface(c,ltrim, "peslclm",4); -- LOB LTRIM
3024 PRAGMA interface(c,rtrim, "peslcrm",3); -- LOB RTRIM
3025 PRAGMA interface(c,rtrim, "peslcrm",4); -- LOB RTRIM
3026 PRAGMA interface(c,trim, "peslctr",2); -- LOB TRIM
3027 PRAGMA interface(c," SYS$STANDARD_TRIM","peslctr",4); -- LOB TRIM
3028 PRAGMA interface(c," SYS$STANDARD_TRIM","peslctr",5); -- LOB TRIM
3029 PRAGMA interface(c," SYS$STANDARD_TRIM","peslctr",6); -- LOB TRIM
3030 PRAGMA interface(c,'LIKE', "peslclk",3); -- LOB LIKE
3031 PRAGMA interface(c,'LIKE', "peslcl2",4); -- LOB LIKE
3032 PRAGMA interface(c,nvl,"peslcnl",17); -- LOB NVL
3033 PRAGMA interface(c,replace, "peslcrl",2); -- LOB REPLACE
3034
3035 -- LOB Relational Operators
3036 -- LHS: CLOB, RHS:CLOB
3037 PRAGMA interface(c,'=' ,"pes_dummy",16); -- LOB '='
3038 PRAGMA interface(c,'!=',"pes_invert",16); -- LOB '!='
3039 PRAGMA interface(c,'>' ,"pes_flip",15); -- LOB '>'
3040 PRAGMA interface(c,'<' ,"pes_dummy",15); -- LOB '<'
3041 PRAGMA interface(c,'>=',"pes_flip",15); -- LOB '>='
3042 PRAGMA interface(c,'<=',"pes_dummy",15); -- LOB '<='
3043 -- LHS: CLOB, RHS:VARCHAR2
3044 PRAGMA interface(c,'=' ,"pesleq2",17); -- LOB '='
3045 PRAGMA interface(c,'!=',"pes_invert",17); -- LOB '!='
3046 PRAGMA interface(c,'>' ,"pes_flip",16); -- LOB '>'
3047 PRAGMA interface(c,'<' ,"pesllt2",16); -- LOB '<'
3048 PRAGMA interface(c,'>=',"pes_flip",16); -- LOB '>='
3049 PRAGMA interface(c,'<=',"peslle2",16); -- LOB '<=' -- ICD #250
3050 -- LHS: VARCHAR2, RHS:CLOB
3051 PRAGMA interface(c,'=' ,"pes_flip",18); -- LOB '='
3052 PRAGMA interface(c,'!=',"pes_flip",18); -- LOB '!='
3053 PRAGMA interface(c,'>' ,"pes_flip",17); -- LOB '>'
3054 PRAGMA interface(c,'<' ,"pesllt3",17); -- LOB '<'
3055 PRAGMA interface(c,'>=',"pes_flip",17); -- LOB '>='
3056 PRAGMA interface(c,'<=',"peslle3",17); -- LOB '<='
3057
3058 PRAGMA interface(c,length, "peslbln",3); -- BLOB LENGTH
3059 PRAGMA interface(c,lengthb,"peslblb",3); -- BLOB LENGTHB
3060 -- End of 8.2 LOB Built-in Functions
3061
3062
3063 PRAGMA interface(c,tz_offset,"pestzo",1);
3064 PRAGMA interface(c,from_tz,"pesftz",1);
3065
3066 PRAGMA interface(c,ISNCHAR,"pesinc", 1);
3067
3068 PRAGMA interface(c,CONVERT,"pescnv", 1);
3069 PRAGMA interface(c,CONVERT,"pescnv", 2);
3070 PRAGMA interface(c,CONVERT,"peslccnv", 3); -- LOB CONVERT
3071 PRAGMA interface(c,CONVERT,"peslccnv", 4); -- LOB CONVERT
3072
3073 PRAGMA interface(c," SYS$EXTRACT_STRING_FROM","pesefdrvc2",1);
3074 PRAGMA interface(c," SYS$EXTRACT_STRING_FROM","pesefdrvc2",2);
3075 PRAGMA interface(c," SYS$EXTRACT_STRING_FROM","pesefdrvc2",3);
3076
3077 PRAGMA interface(c,TO_CHAR,"pesdtm2c",7); -- datetime
3078 PRAGMA interface(c,TO_CHAR,"pesdtm2c",8);
3079 PRAGMA interface(c,TO_CHAR,"pesdtm2c",9);
3080 PRAGMA interface(c,TO_CHAR,"pesdtm2c",10);
3081 PRAGMA interface(c,TO_CHAR,"pesdtm2c",11);
3082 PRAGMA interface(c,TO_CHAR,"pesdtm2c",12);
3083 PRAGMA interface(c,TO_CHAR,"pesdtm2c",13);
3084 PRAGMA interface(c,TO_CHAR,"pesdtm2c",14);
3085 PRAGMA interface(c,TO_CHAR,"pesdtm2c",15);
3086 PRAGMA interface(c,TO_CHAR,"pesdtm2c",16);
3087 PRAGMA interface(c,TO_CHAR,"pesitv2c",17); -- interval
3088 PRAGMA interface(c,TO_CHAR,"pesitv2c",18);
3089 PRAGMA interface(c,TO_CHAR,"pesitv2c",19);
3090 PRAGMA interface(c,TO_CHAR,"pesitv2c",20);
3091
3092 --#### new_names pragmas
3093
3094 -- This is an internal pragma that restricts the use
3095 -- of particular new entries in package standard.
3096 -- It is only valid in package standard.
3097 -- Note that left out of the 8.1.5 set are non datetime
3098 -- entries urowid, "UROWID ", self_is_null and trim.
3099
3100 pragma new_names('8.1.5',
3101 time,"TIME WITH TIME ZONE",
3102 timestamp,"TIMESTAMP WITH TIME ZONE",
3103 "INTERVAL DAY TO SECOND",
3104 "INTERVAL YEAR TO MONTH",
3105 to_time, to_timestamp,
3106 to_time_tz, to_timestamp_tz,
3107 " SYS$DSINTERVALSUBTRACT",
3108 " SYS$YMINTERVALSUBTRACT",
3109 to_yminterval,to_dsinterval,
3110 NUMTOYMINTERVAL, NUMTODSINTERVAL,
3111 current_date,
3112 current_time,current_timestamp);
3113
3114 pragma new_names('8.1.6',
3115 dbtimezone, sessiontimezone, localtimestamp,
3116 localtime,
3117 cube, rollup, grouping, "TIMESTAMP WITH LOCAL TIME ZONE");
3118
3119 -- Should there be a 8.2 new names pragma ?
3120
3121 -- 8.2 UCS2/UCS4/Complete Built-in Functions
3122
3123 PRAGMA interface(c,INSTR2,"pesist2",1);
3124 PRAGMA interface(c,INSTR4,"pesist4",1);
3125 PRAGMA interface(c,INSTRC,"pesistc",1);
3126
3127 PRAGMA interface(c,LENGTH2,"peslen2",1);
3128 PRAGMA interface(c,LENGTH4,"peslen4",1);
3129 PRAGMA interface(c,LENGTHC,"peslenc",1);
3130
3131 PRAGMA interface(c,LIKE2,"peslik2",1);
3132 PRAGMA interface(c,LIKE2,"pesli22",2);
3133 PRAGMA interface(c,LIKE4,"peslik4",1);
3134 PRAGMA interface(c,LIKE4,"pesli42",2);
3135 PRAGMA interface(c,LIKEC,"peslikc",1);
3136 PRAGMA interface(c,LIKEC,"peslic2",2);
3137
3138 PRAGMA interface(c,SUBSTR2,"pes_dummy",1);
3139 PRAGMA interface(c,SUBSTR4,"pes_dummy",1);
3140 PRAGMA interface(c,SUBSTRC,"pes_dummy",1);
3141 PRAGMA interface(c,SYS_EXTRACT_UTC,"pessexu");
3142 PRAGMA interface(c,COMPOSE,"pescomp");
3143 PRAGMA interface(c,DECOMPOSE,"pesdcmp");
3144
3145
3146
3147 -- End of 8.2 UCS2/UCS4/Complete Built-in Functions
3148
3149 -- Begin REGEXP support (10iR1) --
3150 PRAGMA interface(c,regexp_like, "pes_dummy",1);
3151 PRAGMA interface(c,regexp_instr, "pes_dummy",1); -- ICD #300
3152 PRAGMA interface(c,regexp_substr, "pes_dummy",1);
3153 PRAGMA interface(c,regexp_replace, "pes_dummy",1);
3154 PRAGMA interface(c,regexp_count, "pes_dummy",1);
3155 PRAGMA interface(c,regexp_like, "pes_dummy",2); -- LOB REGEXP_LIKE
3156 PRAGMA interface(c,regexp_instr, "pes_dummy",2); -- LOB REGEXP_INSTR
3157 PRAGMA interface(c,regexp_substr, "pes_dummy",2); -- LOB REGEXP_SUBSTR
3158 PRAGMA interface(c,regexp_replace, "pes_dummy",2); -- LOB REGEXP_REPLACE
3159 PRAGMA interface(c,regexp_count, "pes_dummy",2); -- LOB REGEXP_COUNT
3160 PRAGMA interface(c,regexp_replace, "pes_dummy",3); -- LOB REGEXP_REPLACE
3161
3162 -- End of REGEXP Built-in Functions --
3163
3164
3165 -- 10i Binary Floating-point Built-in Functions
3166
3167 PRAGMA interface(c,"IS NAN","pesnanf",2);
3168 PRAGMA interface(c,"IS NAN","pesnand",3);
3169 PRAGMA interface(c,"IS INFINITE","pesinf",1);
3170 PRAGMA interface(c,"IS INFINITE","pesinff",2);
3171 PRAGMA interface(c,"IS INFINITE","pesinfd",3);
3172 PRAGMA interface(c,TO_BINARY_FLOAT,"pesc2flt",2);
3173 PRAGMA interface(c,TO_BINARY_FLOAT,"pesc2flt",3);
3174 PRAGMA interface(c,TO_BINARY_DOUBLE,"pesc2dbl",2);
3175 PRAGMA interface(c,TO_BINARY_DOUBLE,"pesc2dbl",3);
3176 PRAGMA interface(c,TO_CHAR,"pesflt2c",21);
3177 PRAGMA interface(c,TO_CHAR,"pesdbl2c",22);
3178 PRAGMA interface(c,TO_CHAR,"pesflt2c",23);
3179 PRAGMA interface(c,TO_CHAR,"pesdbl2c",24);
3180 PRAGMA interface(c,TO_NCHAR,"pesflt2c",6);
3181 PRAGMA interface(c,TO_NCHAR,"pesdbl2c",7);
3182 PRAGMA interface(c,TO_NCHAR,"pesflt2c",8);
3183 PRAGMA interface(c,TO_NCHAR,"pesdbl2c",9);
3184 PRAGMA interface(c,'REMAINDER',"pesrem", 1);
3185 PRAGMA interface(c,REMAINDER,"pesrem", 2);
3189 PRAGMA interface(c,REMAINDER,"pesremd", 6);
3186 PRAGMA interface(c,'REMAINDER',"pesremf", 3);
3187 PRAGMA interface(c,REMAINDER,"pesremf", 4);
3188 PRAGMA interface(c,'REMAINDER',"pesremd", 5);
3190 PRAGMA interface(c,ABS,"pes_dummy",2);
3191 PRAGMA interface(c,ABS,"pes_dummy",3);
3192 PRAGMA interface(c,ABS,"pes_dummy",4);
3193 PRAGMA interface(c,ATAN,"pesatand",2);
3194 PRAGMA interface(c,'MOD',"pesmodf", 2);
3195 PRAGMA interface(c,'MOD',"pesmodd", 3);
3196 PRAGMA interface(c,floor,"pesflof", 2);
3197 PRAGMA interface(c,floor,"pesflod", 3);
3198 PRAGMA interface(c,CEIL,"pesceif", 2);
3199 PRAGMA interface(c,CEIL,"pesceid", 3);
3200 PRAGMA interface (c, SQRT, "pessqtf", 2);
3201 PRAGMA interface (c, SQRT, "pessqtd", 3);
3202 PRAGMA interface(c,SIGN,"pessgnf", 2);
3203 PRAGMA interface(c,SIGN,"pessgnd", 3);
3204 PRAGMA interface(c,SIGN,"pessgni", 4);
3205 PRAGMA interface(c,cos,"pescosd", 2);
3206 PRAGMA interface(c,sin,"pessind",2);
3207 PRAGMA interface(c,TAN,"pestand",2);
3208 PRAGMA interface(c,COSH,"pescshd",2);
3209 PRAGMA interface(c,SINH,"pessnhd",2); -- ICD #350
3210 PRAGMA interface(c,TANH,"pestnhd",2);
3211 PRAGMA interface(c,EXP,"pesexpd",2);
3212 PRAGMA interface(c,LN,"peslnd",2);
3213 PRAGMA interface(c,LOG,"peslogd",2);
3214 PRAGMA interface(c,TRUNC,"pestruf",4);
3215 PRAGMA interface(c,TRUNC,"pestrud",5);
3216 PRAGMA interface(c,TRUNC,"pestrui",6);
3217 PRAGMA interface(c,ROUND,"pesrndf",4);
3218 PRAGMA interface(c,ROUND,"pesrndd",5);
3219 PRAGMA interface(c,ROUND,"pesrndi",6);
3220 PRAGMA interface(c,POWER,"pespowd",2);
3221
3222 -- End of 10i Binary Floating-point Built-in Functions
3223
3224 -- ICDs for MULTISET
3225
3226 PRAGMA interface(c,CARDINALITY,"pesmcnt");
3227 PRAGMA interface(c,"IS EMPTY","pesmie");
3228 PRAGMA interface(c,"IS NOT EMPTY","pes_invert",1);
3229 -- ICDs which used to be in the body of standard, but which new COG can
3230 -- handle directly
3231
3232 -- NOT (some ICD)
3233 PRAGMA interface(c,NOT_LIKE,"pes_invert",1);
3234 PRAGMA interface(c,NOT_LIKE,"pes_invert",2);
3235 PRAGMA interface(c,NOT_LIKE,"pes_invert",3);
3236 PRAGMA interface(c,NOT_LIKE,"pes_invert",4);
3237 PRAGMA interface(c,NOT_LIKE2,"pes_invert",1);
3238 PRAGMA interface(c,NOT_LIKE2,"pes_invert",2);
3239 PRAGMA interface(c,NOT_LIKE4,"pes_invert",1);
3240 PRAGMA interface(c,NOT_LIKE4,"pes_invert",2);
3241 PRAGMA interface(c,NOT_LIKEC,"pes_invert",1);
3242 PRAGMA interface(c,NOT_LIKEC,"pes_invert",2);
3243 PRAGMA interface(c,"IS NOT NAN","pes_invert",2);
3244 PRAGMA interface(c,"IS NOT NAN","pes_invert",3);
3245 PRAGMA interface(c,"IS NOT INFINITE","pes_invert",1);
3246 PRAGMA interface(c,"IS NOT INFINITE","pes_invert",2);
3247 PRAGMA interface(c,"IS NOT INFINITE","pes_invert",3);
3248
3249 -- datetime is not null
3250 PRAGMA interface(c,"IS NOT NULL","pes_dummy",14); -- time
3251 PRAGMA interface(c,"IS NOT NULL","pes_dummy",15); -- time wtz
3252 PRAGMA interface(c,"IS NOT NULL","pes_dummy",16); -- timestamp
3253 PRAGMA interface(c,"IS NOT NULL","pes_dummy",17); -- timestamp wtz
3254 PRAGMA interface(c,"IS NOT NULL","pes_dummy",18); -- timestamp lwtz
3255 PRAGMA interface(c,"IS NOT NULL","pes_dummy",19); -- interval ym
3256 PRAGMA interface(c,"IS NOT NULL","pes_dummy",20); -- interval ds
3257
3258 -- Misc
3259 PRAGMA interface(c,"**", "pespow",1); -- number
3260 PRAGMA interface(c,"**", "pespowd",2); -- binary double
3261 PRAGMA interface(c,"ACOS", "pesacosd",2); -- binary double
3262 PRAGMA interface(c,"ASIN", "pesasind",2); -- binary double
3263 PRAGMA interface(c,"ATAN2","pesatn2d",2); -- binary double
3264
3265 -- All the flavors of NVL
3266 PRAGMA interface(c,nvl,"pes_dummy",1); -- Boolean -- ICD #400
3267 PRAGMA interface(c,nvl,"pes_dummy",2); -- Varchar2
3268 PRAGMA interface(c,nvl,"pes_dummy",3); -- Number
3269 PRAGMA interface(c,nvl,"pes_dummy",4); -- Date
3270 PRAGMA interface(c,nvl,"pes_dummy",5); -- MLSLabel
3271 PRAGMA interface(c,nvl,"pes_dummy",6); -- ADT
3272 PRAGMA interface(c,nvl,"pes_dummy",7); -- Ref ADT
3273 PRAGMA interface(c,nvl,"pes_dummy",8); -- Collection
3274
3275 -- Ref Cursor has problems. The MOVCR instruction needs more information than
3276 -- the other MOV* instructions, including the PVM register of the destination
3277 -- This cannot be easily supplied through the generic NVL instruction, so
3278 -- for now, this flavor will continue to have a real body
3279 -- PRAGMA interface(c,nvl,"pes_dummy",9); -- Ref Cursor
3280
3281 PRAGMA interface(c,nvl,"pes_dummy",10); -- Time
3282 PRAGMA interface(c,nvl,"pes_dummy",11); -- Time-tz
3283 PRAGMA interface(c,nvl,"pes_dummy",12); -- Timestamp
3284 PRAGMA interface(c,nvl,"pes_dummy",13); -- Timestamp-tz
3285 PRAGMA interface(c,nvl,"pes_dummy",14); -- Timestamp-ltz
3286 PRAGMA interface(c,nvl,"pes_dummy",15); -- Intervalym
3287 PRAGMA interface(c,nvl,"pes_dummy",16); -- Intervalds
3288 -- PRAGMA interface(c,nvl,"pes_dummy",17); -- Clob (Handled above, ICD)
3289 PRAGMA interface(c,nvl,"pes_dummy",18); -- Opaque
3290 PRAGMA interface(c,nvl,"pes_dummy",19); -- Binaryfloat
3291 PRAGMA interface(c,nvl,"pes_dummy",20); -- Binarydouble
3292 PRAGMA interface(c,nvl,"pes_dummy",21); -- PLSInteger
3293
3294 -- The following pragma overrides any other setting of the timestamp,
3295 -- and is used so that we recognize the client-side and server-side instances
3296 -- of package STANDARD as being the same. Package STANDARD is special in
3297 -- that it is really the root of the PL/SQL dependencies graph; as such it
3298 -- itself doesn't ever need recompiling due to changes to things below it.
3299 -- The pragma mechanism used here is currently ignored except for
3300 -- package STANDARD, but in future may not be. Do NOT add similar pragmas
3301 -- to your own code as it may in future interfere with the package
3302 -- consistency maintenance mechanisms and could have dire results.
3303
3304 --#### timestamp pragma (please keep this last)
3305 pragma TIMESTAMP('2006-04-18:00:00:00');
3306 end;