1 PACKAGE dbms_reputil2 AS
2
3 ------------
4 -- OVERVIEW
5 --
6 -- This package is referenced only by the generated code
7 -- and needs higher purity than the code in dbms_reputil.
8
9 FUNCTION bit(flag IN RAW,
10 byte IN NUMBER,
11 bit_offset IN NUMBER) RETURN BOOLEAN;
12 PRAGMA RESTRICT_REFERENCES(bit, WNPS, RNDS, WNDS);
13 -- Test a bit in a byte in a raw. Byte and bit_offset are 1-based.
14
15 FUNCTION bit(flag IN RAW,
16 bit_offset IN NUMBER) RETURN BOOLEAN;
17 PRAGMA RESTRICT_REFERENCES(bit, WNPS, RNDS, WNDS);
18 -- Test a bit in a raw. Bit_offset is 1-based.
19
20 -- same 2 functions above but returns number for use in SQL
21 -- changed args ordering in order to override. SQL cannot choose between
22 -- return boolean and return number
23 FUNCTION bit(byte IN NUMBER,
24 bit_offset IN NUMBER,
25 flag IN RAW) RETURN NUMBER;
26 PRAGMA RESTRICT_REFERENCES(bit, WNPS, RNDS, WNDS);
27 -- Test a bit in a byte in a raw. Byte and bit_offset are 1-based.
28
29 FUNCTION bit(bit_offset IN NUMBER,
30 flag IN RAW) RETURN NUMBER;
31 PRAGMA RESTRICT_REFERENCES(bit, WNPS, RNDS, WNDS);
32 -- Test a bit in a raw. Bit_offset is 1-based.
33
34 PROCEDURE bis(flag IN OUT RAW,
35 bit_offset IN NUMBER);
36 PRAGMA RESTRICT_REFERENCES(bis, WNPS, RNDS, WNDS);
37 -- Set a bit in a one-byte raw. Bit_offset is 1-based.
38
39 PROCEDURE bic(flag IN OUT RAW,
40 bit_offset IN NUMBER);
41 PRAGMA RESTRICT_REFERENCES(bic, WNPS, RNDS, WNDS);
42 -- Clear a bit in a one-byte raw. Bit_offset is 1-based.
43
44 FUNCTION choose_number(old IN NUMBER,
45 new IN NUMBER,
46 flag IN VARCHAR2,
47 byte IN NUMBER) RETURN NUMBER;
48 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
49 -- else return old.
50 PRAGMA RESTRICT_REFERENCES(choose_number, WNPS, RNDS, WNDS);
51
52 FUNCTION choose_date(old IN DATE,
53 new IN DATE,
54 flag IN VARCHAR2,
55 byte IN NUMBER) RETURN DATE;
56 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
57 -- else return old.
58 PRAGMA RESTRICT_REFERENCES(choose_date, WNPS, RNDS, WNDS);
59
60 FUNCTION choose_varchar2(old IN VARCHAR2,
61 new IN VARCHAR2,
62 flag IN VARCHAR2,
63 byte IN NUMBER) RETURN VARCHAR2;
64 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
65 -- else return old.
66 PRAGMA RESTRICT_REFERENCES(choose_varchar2, WNPS, RNDS, WNDS);
67
68 FUNCTION choose_nvarchar2(old IN NVARCHAR2,
69 new IN NVARCHAR2,
70 flag IN VARCHAR2,
71 byte IN NUMBER) RETURN NVARCHAR2;
72 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
73 -- else return old.
74 PRAGMA RESTRICT_REFERENCES(choose_nvarchar2, WNPS, RNDS, WNDS);
75
76 FUNCTION choose_char(old IN CHAR,
77 new IN CHAR,
78 flag IN VARCHAR2,
79 byte IN NUMBER) RETURN CHAR;
80 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
81 -- else return old.
82 PRAGMA RESTRICT_REFERENCES(choose_char, WNPS, RNDS, WNDS);
83
84 FUNCTION choose_nchar(old IN NCHAR,
85 new IN NCHAR,
86 flag IN VARCHAR2,
87 byte IN NUMBER) RETURN NCHAR;
88 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
89 -- else return old.
90 PRAGMA RESTRICT_REFERENCES(choose_nchar, WNPS, RNDS, WNDS);
91
92 FUNCTION choose_rowid(old IN ROWID,
93 new IN ROWID,
94 flag IN VARCHAR2,
95 byte IN NUMBER) RETURN ROWID;
96 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
97 -- else return old.
98 PRAGMA RESTRICT_REFERENCES(choose_rowid, WNPS, RNDS, WNDS);
99
100 FUNCTION choose_raw(old IN RAW,
101 new IN RAW,
102 flag IN VARCHAR2,
103 byte IN NUMBER) RETURN RAW;
104 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
105 -- else return old.
106 PRAGMA RESTRICT_REFERENCES(choose_raw, WNPS, RNDS, WNDS);
107
108 FUNCTION choose_blob(old IN BLOB,
109 new IN BLOB,
110 flag IN VARCHAR2,
111 byte IN NUMBER) RETURN BLOB;
112 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
113 -- else return old.
114 PRAGMA RESTRICT_REFERENCES(choose_blob, RNPS, WNPS, RNDS, WNDS);
115
116 FUNCTION choose_clob(old IN CLOB,
117 new IN CLOB,
118 flag IN VARCHAR2,
119 byte IN NUMBER) RETURN CLOB;
120 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
121 -- else return old.
122 PRAGMA RESTRICT_REFERENCES(choose_clob, RNPS, WNPS, RNDS, WNDS);
123
124 FUNCTION choose_nclob(old IN NCLOB,
125 new IN NCLOB,
126 flag IN VARCHAR2,
127 byte IN NUMBER) RETURN NCLOB;
128 -- If flag is null or substr(flag,byte,1) = 'Y' then return new
129 -- else return old.
130 PRAGMA RESTRICT_REFERENCES(choose_nclob, RNPS, WNPS, RNDS, WNDS);
131
132 FUNCTION old_varchar2_equals_new(column_changed$_varchar2 IN VARCHAR2,
133 offset IN NUMBER,
134 old IN VARCHAR2
135 CHARACTER SET
136 ANY_CS,
137 new IN VARCHAR2
138 CHARACTER SET
139 old%CHARSET)
140 RETURN VARCHAR2;
141 -- If old and new are identical then return 'Y' else return 'N.'
142 -- Use column_changed$_varchar2 if not null.
143 -- Otherwise use equality and null checks.
144 PRAGMA RESTRICT_REFERENCES(old_varchar2_equals_new, RNPS, WNPS, RNDS, WNDS);
145
146 FUNCTION old_char_equals_new(column_changed$_varchar2 IN VARCHAR2,
147 offset IN NUMBER,
148 old IN CHAR CHARACTER SET
149 ANY_CS,
150 new IN CHAR CHARACTER SET
151 old%CHARSET)
152 RETURN VARCHAR2;
153 -- If old and new are identical then return 'Y' else return 'N.'
154 -- Use column_changed$_varchar2 if not null.
155 -- Otherwise use equality and null checks.
156 PRAGMA RESTRICT_REFERENCES(old_char_equals_new, RNPS, WNPS, RNDS, WNDS);
157
158 FUNCTION old_rowid_equals_new(column_changed$_varchar2 IN VARCHAR2,
159 offset IN NUMBER,
160 old IN ROWID,
161 new IN ROWID)
162 RETURN VARCHAR2;
163 -- If old and new are identical then return 'Y' else return 'N.'
164 -- Use column_changed$_varchar2 if not null.
165 -- Otherwise use equality and null checks.
166 PRAGMA RESTRICT_REFERENCES(old_rowid_equals_new, RNPS, WNPS, RNDS, WNDS);
167
168 FUNCTION old_date_equals_new(column_changed$_varchar2 IN VARCHAR2,
169 offset IN NUMBER,
170 old IN DATE,
171 new IN DATE)
172 RETURN VARCHAR2;
173 -- If old and new are identical then return 'Y' else return 'N.'
174 -- Use column_changed$_varchar2 if not null.
175 -- Otherwise use equality and null checks.
176 PRAGMA RESTRICT_REFERENCES(old_date_equals_new, RNPS, WNPS, RNDS, WNDS);
177
178 FUNCTION old_raw_equals_new(column_changed$_varchar2 IN VARCHAR2,
179 offset IN NUMBER,
180 old IN RAW,
181 new IN RAW)
182 RETURN VARCHAR2;
183 -- If old and new are identical then return 'Y' else return 'N.'
184 -- Use column_changed$_varchar2 if not null.
185 -- Otherwise use equality and null checks.
186 PRAGMA RESTRICT_REFERENCES(old_raw_equals_new, RNPS, WNPS, RNDS, WNDS);
187
188 FUNCTION old_number_equals_new(column_changed$_varchar2 IN VARCHAR2,
189 offset IN NUMBER,
190 old IN NUMBER,
191 new IN NUMBER)
192 RETURN VARCHAR2;
193 -- If old and new are identical then return 'Y' else return 'N.'
194 -- Use column_changed$_varchar2 if not null.
195 -- Otherwise use equality and null checks.
196 PRAGMA RESTRICT_REFERENCES(old_number_equals_new, RNPS, WNPS, RNDS, WNDS);
197
198 FUNCTION old_clob_equals_new(column_changed$_varchar2 IN VARCHAR2,
199 offset IN NUMBER,
200 old IN CLOB CHARACTER SET
201 ANY_CS,
202 new IN CLOB CHARACTER SET
203 old%CHARSET)
204 RETURN VARCHAR2;
205 -- If old and new are identical then return 'Y' else return 'N.'
206 -- Use column_changed$_varchar2 if not null.
207 -- Otherwise use equality and null checks.
208 PRAGMA RESTRICT_REFERENCES(old_clob_equals_new, RNPS, WNPS, RNDS, WNDS);
209
210 FUNCTION old_blob_equals_new(column_changed$_varchar2 IN VARCHAR2,
211 offset IN NUMBER,
212 old IN BLOB,
213 new IN BLOB)
214 RETURN VARCHAR2;
215 -- If old and new are identical then return 'Y' else return 'N.'
216 -- Use column_changed$_varchar2 if not null.
217 -- Otherwise use equality and null checks.
218 PRAGMA RESTRICT_REFERENCES(old_blob_equals_new, RNPS, WNPS, RNDS, WNDS);
219
220 FUNCTION old_varchar2_eq_new(column_changed$_varchar2 IN VARCHAR2,
221 offset IN NUMBER,
222 old IN VARCHAR2
223 CHARACTER SET
224 ANY_CS,
225 new IN VARCHAR2
226 CHARACTER SET
227 old%CHARSET)
228 RETURN BOOLEAN;
229 -- If old and new are identical then return true else return false.
230 -- Use column_changed$_varchar2 if not null.
231 -- Otherwise use equality and null checks.
232 PRAGMA RESTRICT_REFERENCES(old_varchar2_eq_new, RNPS, WNPS, RNDS, WNDS);
233
234 FUNCTION old_char_eq_new(column_changed$_varchar2 IN VARCHAR2,
235 offset IN NUMBER,
236 old IN CHAR CHARACTER SET
237 ANY_CS,
238 new IN CHAR CHARACTER SET
239 old%CHARSET)
240 RETURN BOOLEAN;
241 -- If old and new are identical then return true else return false.
242 -- Use column_changed$_varchar2 if not null.
243 -- Otherwise use equality and null checks.
244 PRAGMA RESTRICT_REFERENCES(old_char_eq_new, RNPS, WNPS, RNDS, WNDS);
245
246 FUNCTION old_date_eq_new(column_changed$_varchar2 IN VARCHAR2,
247 offset IN NUMBER,
248 old IN DATE,
249 new IN DATE)
250 RETURN BOOLEAN;
251 -- If old and new are identical then return true else return false.
252 -- Use column_changed$_varchar2 if not null.
253 -- Otherwise use equality and null checks.
254 PRAGMA RESTRICT_REFERENCES(old_date_eq_new, RNPS, WNPS, RNDS, WNDS);
255
256 FUNCTION old_rowid_eq_new(column_changed$_varchar2 IN VARCHAR2,
257 offset IN NUMBER,
258 old IN ROWID,
259 new IN ROWID)
260 RETURN BOOLEAN;
261 -- If old and new are identical then return true else return false.
262 -- Use column_changed$_varchar2 if not null.
263 -- Otherwise use equality and null checks.
264 PRAGMA RESTRICT_REFERENCES(old_rowid_eq_new, RNPS, WNPS, RNDS, WNDS);
265
266 FUNCTION old_raw_eq_new(column_changed$_varchar2 IN VARCHAR2,
267 offset IN NUMBER,
268 old IN RAW,
269 new IN RAW)
270 RETURN BOOLEAN;
271 -- If old and new are identical then return true else return false.
272 -- Use column_changed$_varchar2 if not null.
273 -- Otherwise use equality and null checks.
274 PRAGMA RESTRICT_REFERENCES(old_raw_eq_new, RNPS, WNPS, RNDS, WNDS);
275
276 FUNCTION old_number_eq_new(column_changed$_varchar2 IN VARCHAR2,
277 offset IN NUMBER,
278 old IN NUMBER,
279 new IN NUMBER)
280 RETURN BOOLEAN;
281 -- If old and new are identical then return true else return false.
282 -- Use column_changed$_varchar2 if not null.
283 -- Otherwise use equality and null checks.
284 PRAGMA RESTRICT_REFERENCES(old_number_eq_new, RNPS, WNPS, RNDS, WNDS);
285
286 FUNCTION old_clob_eq_new(column_changed$_varchar2 IN VARCHAR2,
287 offset IN NUMBER,
288 old IN CLOB CHARACTER SET
289 ANY_CS,
290 new IN CLOB CHARACTER SET
291 old%CHARSET)
292 RETURN BOOLEAN;
293 -- If old and new are identical then return true else return false.
294 -- Use column_changed$_varchar2 if not null.
295 -- Otherwise use equality and null checks.
296 PRAGMA RESTRICT_REFERENCES(old_clob_eq_new, RNPS, WNPS, RNDS, WNDS);
297
298 FUNCTION old_blob_eq_new(column_changed$_varchar2 IN VARCHAR2,
299 offset IN NUMBER,
300 old IN BLOB,
301 new IN BLOB)
302 RETURN BOOLEAN;
303 -- If old and new are identical then return true else return false.
304 -- Use column_changed$_varchar2 if not null.
305 -- Otherwise use equality and null checks.
306 PRAGMA RESTRICT_REFERENCES(old_blob_eq_new, RNPS, WNPS, RNDS, WNDS);
307
308 FUNCTION old_varchar2_equals_current(column_sent$_varchar2 IN VARCHAR2,
309 offset IN NUMBER,
310 old IN VARCHAR2
311 CHARACTER SET
312 ANY_CS,
313 current IN VARCHAR2
314 CHARACTER SET
315 old%CHARSET)
316 RETURN VARCHAR2;
317 -- If column_sent$_varchar2 is NULL, return 'Y.'
318 -- If old and current are identical then return 'Y' else return 'N.'
319 -- Use equality and null checks.
320 PRAGMA RESTRICT_REFERENCES(old_varchar2_equals_current,
321 RNPS, WNPS, RNDS, WNDS);
322
323 FUNCTION old_char_equals_current(column_sent$_varchar2 IN VARCHAR2,
324 offset IN NUMBER,
325 old IN CHAR CHARACTER SET
326 ANY_CS,
327 current IN CHAR CHARACTER SET
328 old%CHARSET)
329 RETURN VARCHAR2;
330 -- If column_sent$_varchar2 is NULL, return 'Y.'
334 RNPS, WNPS, RNDS, WNDS);
331 -- If old and current are identical then return 'Y' else return 'N.'
332 -- Use equality and null checks.
333 PRAGMA RESTRICT_REFERENCES(old_char_equals_current,
335
336 FUNCTION old_raw_equals_current(column_sent$_varchar2 IN VARCHAR2,
337 offset IN NUMBER,
338 old IN RAW,
339 current IN RAW)
340 RETURN VARCHAR2;
341 -- If column_sent$_varchar2 is NULL, return 'Y.'
342 -- If old and current are identical then return 'Y' else return 'N.'
343 -- Use equality and null checks.
344 PRAGMA RESTRICT_REFERENCES(old_raw_equals_current,
345 RNPS, WNPS, RNDS, WNDS);
346
347 FUNCTION old_rowid_equals_current(column_sent$_varchar2 IN VARCHAR2,
348 offset IN NUMBER,
349 old IN ROWID,
350 current IN ROWID)
351 RETURN VARCHAR2;
352 -- If column_sent$_varchar2 is NULL, return 'Y.'
353 -- If old and current are identical then return 'Y' else return 'N.'
354 -- Use equality and null checks.
355 PRAGMA RESTRICT_REFERENCES(old_rowid_equals_current,
356 RNPS, WNPS, RNDS, WNDS);
357
358 FUNCTION old_date_equals_current(column_sent$_varchar2 IN VARCHAR2,
359 offset IN NUMBER,
360 old IN DATE,
361 current IN DATE)
362 RETURN VARCHAR2;
363 -- If column_sent$_varchar2 is NULL, return 'Y.'
364 -- If old and current are identical then return 'Y' else return 'N.'
365 -- Use equality and null checks.
366 PRAGMA RESTRICT_REFERENCES(old_date_equals_current,
367 RNPS, WNPS, RNDS, WNDS);
368
369 FUNCTION old_number_equals_current(column_sent$_varchar2 IN VARCHAR2,
370 offset IN NUMBER,
371 old IN NUMBER,
372 current IN NUMBER)
373 RETURN VARCHAR2;
374 -- If column_sent$_varchar2 is NULL, return 'Y.'
375 -- If old and current are identical then return 'Y' else return 'N.'
376 -- Use equality and null checks.
377 PRAGMA RESTRICT_REFERENCES(old_number_equals_current,
378 RNPS, WNPS, RNDS, WNDS);
379
380 FUNCTION old_blob_equals_current(column_sent$_varchar2 IN VARCHAR2,
381 offset IN NUMBER,
382 old IN BLOB,
383 current IN BLOB)
384 RETURN VARCHAR2;
385 -- If column_sent$_varchar2 is NULL, return 'Y.'
386 -- If old and current are identical then return 'Y' else return 'N.'
387 -- Use equality and null checks.
388 PRAGMA RESTRICT_REFERENCES(old_blob_equals_current,
389 RNPS, WNPS, RNDS, WNDS);
390
391 FUNCTION old_clob_equals_current(column_sent$_varchar2 IN VARCHAR2,
392 offset IN NUMBER,
393 old IN CLOB CHARACTER SET
394 ANY_CS,
395 current IN CLOB CHARACTER SET
396 old%CHARSET)
397 RETURN VARCHAR2;
398 -- If column_sent$_varchar2 is NULL, return 'Y.'
399 -- If old and current are identical then return 'Y' else return 'N.'
400 -- Use equality and null checks.
401 PRAGMA RESTRICT_REFERENCES(old_clob_equals_current,
402 RNPS, WNPS, RNDS, WNDS);
403
404 FUNCTION old_varchar2_eq_current(column_sent$_varchar2 IN VARCHAR2,
405 offset IN NUMBER,
406 old IN VARCHAR2
407 CHARACTER SET
408 ANY_CS,
409 current IN VARCHAR2
410 CHARACTER SET
411 old%CHARSET)
412 RETURN BOOLEAN;
413 -- If column_sent$_varchar2 is NULL, return 'Y.'
414 -- If old and current are identical then return 'Y' else return 'N.'
415 -- Use equality and null checks.
416 PRAGMA RESTRICT_REFERENCES(old_varchar2_eq_current,
417 RNPS, WNPS, RNDS, WNDS);
418
419 FUNCTION old_char_eq_current(column_sent$_varchar2 IN VARCHAR2,
420 offset IN NUMBER,
421 old IN CHAR CHARACTER SET
422 ANY_CS,
423 current IN CHAR CHARACTER SET
424 old%CHARSET)
425 RETURN BOOLEAN;
426 -- If column_sent$_varchar2 is NULL, return 'Y.'
427 -- If old and current are identical then return 'Y' else return 'N.'
428 -- Use equality and null checks.
429 PRAGMA RESTRICT_REFERENCES(old_char_eq_current,
430 RNPS, WNPS, RNDS, WNDS);
431
432 FUNCTION old_raw_eq_current(column_sent$_varchar2 IN VARCHAR2,
433 offset IN NUMBER,
437 -- If column_sent$_varchar2 is NULL, return 'Y.'
434 old IN RAW,
435 current IN RAW)
436 RETURN BOOLEAN;
438 -- If old and current are identical then return 'Y' else return 'N.'
439 -- Use equality and null checks.
440 PRAGMA RESTRICT_REFERENCES(old_raw_eq_current,
441 RNPS, WNPS, RNDS, WNDS);
442
443 FUNCTION old_rowid_eq_current(column_sent$_varchar2 IN VARCHAR2,
444 offset IN NUMBER,
445 old IN ROWID,
446 current IN ROWID)
447 RETURN BOOLEAN;
448 -- If column_sent$_varchar2 is NULL, return 'Y.'
449 -- If old and current are identical then return 'Y' else return 'N.'
450 -- Use equality and null checks.
451 PRAGMA RESTRICT_REFERENCES(old_rowid_eq_current,
452 RNPS, WNPS, RNDS, WNDS);
453
454 FUNCTION old_date_eq_current(column_sent$_varchar2 IN VARCHAR2,
455 offset IN NUMBER,
456 old IN DATE,
457 current IN DATE)
458 RETURN BOOLEAN;
459 -- If column_sent$_varchar2 is NULL, return 'Y.'
460 -- If old and current are identical then return 'Y' else return 'N.'
461 -- Use equality and null checks.
462 PRAGMA RESTRICT_REFERENCES(old_date_eq_current,
463 RNPS, WNPS, RNDS, WNDS);
464
465 FUNCTION old_number_eq_current(column_sent$_varchar2 IN VARCHAR2,
466 offset IN NUMBER,
467 old IN NUMBER,
468 current IN NUMBER)
469 RETURN BOOLEAN;
470 -- If column_sent$_varchar2 is NULL, return 'Y.'
471 -- If old and current are identical then return 'Y' else return 'N.'
472 -- Use equality and null checks.
473 PRAGMA RESTRICT_REFERENCES(old_number_eq_current,
474 RNPS, WNPS, RNDS, WNDS);
475
476 FUNCTION old_clob_eq_current(column_sent$_varchar2 IN VARCHAR2,
477 offset IN NUMBER,
478 old IN CLOB CHARACTER SET
479 ANY_CS,
480 current IN CLOB CHARACTER SET
481 old%CHARSET)
482 RETURN BOOLEAN;
483 -- If column_sent$_varchar2 is NULL, return 'Y.'
484 -- If old and current are identical then return 'Y' else return 'N.'
485 -- Use equality and null checks.
486 PRAGMA RESTRICT_REFERENCES(old_clob_eq_current,
487 RNPS, WNPS, RNDS, WNDS);
488
489 FUNCTION old_blob_eq_current(column_sent$_varchar2 IN VARCHAR2,
490 offset IN NUMBER,
491 old IN BLOB,
492 current IN BLOB)
493 RETURN BOOLEAN;
494 -- If column_sent$_varchar2 is NULL, return 'Y.'
495 -- If old and current are identical then return 'Y' else return 'N.'
496 -- Use equality and null checks.
497 PRAGMA RESTRICT_REFERENCES(old_blob_eq_current,
498 RNPS, WNPS, RNDS, WNDS);
499
500 FUNCTION get_final_varchar2(column_changed$_varchar2 IN VARCHAR2,
501 offset IN NUMBER,
502 current IN VARCHAR2 CHARACTER
503 SET ANY_CS,
504 old IN VARCHAR2
505 CHARACTER SET
506 "CURRENT"%CHARSET,
507 new IN VARCHAR2
508 CHARACTER SET
509 "CURRENT"%CHARSET)
510 RETURN VARCHAR2 CHARACTER SET "CURRENT"%CHARSET;
511 -- If old and new are identical, then return current else return new.
512 -- Use column_changed$_varchar2 if non-null.
513 PRAGMA RESTRICT_REFERENCES(get_final_varchar2, RNPS, WNPS, RNDS, WNDS);
514
515 FUNCTION get_final_char(column_changed$_varchar2 IN VARCHAR2,
516 offset IN NUMBER,
517 current IN CHAR CHARACTER SET
518 ANY_CS,
519 old IN CHAR CHARACTER SET
520 "CURRENT"%CHARSET,
521 new IN CHAR CHARACTER SET
522 "CURRENT"%CHARSET)
523 RETURN CHAR CHARACTER SET "CURRENT"%CHARSET;
524 -- If old and new are identical, then return current else return new.
525 -- Use column_changed$_varchar2 if non-null.
526 PRAGMA RESTRICT_REFERENCES(get_final_char, RNPS, WNPS, RNDS, WNDS);
527
528 FUNCTION get_final_rowid(column_changed$_varchar2 IN VARCHAR2,
529 offset IN NUMBER,
530 current IN ROWID,
531 old IN ROWID,
532 new IN ROWID)
533 RETURN ROWID;
534 -- If old and new are identical, then return current else return new.
535 -- Use column_changed$_varchar2 if non-null.
539 offset IN NUMBER,
536 PRAGMA RESTRICT_REFERENCES(get_final_rowid, RNPS, WNPS, RNDS, WNDS);
537
538 FUNCTION get_final_date(column_changed$_varchar2 IN VARCHAR2,
540 current IN DATE,
541 old IN DATE,
542 new IN DATE)
543 RETURN DATE;
544 -- If old and new are identical, then return current else return new.
545 -- Use column_changed$_varchar2 if non-null.
546 PRAGMA RESTRICT_REFERENCES(get_final_date, RNPS, WNPS, RNDS, WNDS);
547
548 FUNCTION get_final_raw(column_changed$_varchar2 IN VARCHAR2,
549 offset IN NUMBER,
550 current IN RAW,
551 old IN RAW,
552 new IN RAW)
553 RETURN RAW;
554 -- If old and new are identical, then return current else return new.
555 -- Use column_changed$_varchar2 if non-null.
556 PRAGMA RESTRICT_REFERENCES(get_final_raw, RNPS, WNPS, RNDS, WNDS);
557
558 FUNCTION get_final_number(column_changed$_varchar2 IN VARCHAR2,
559 offset IN NUMBER,
560 current IN NUMBER,
561 old IN NUMBER,
562 new IN NUMBER)
563 RETURN NUMBER;
564 -- If old and new are identical, then return current else return new.
565 -- Use column_changed$_varchar2 if non-null.
566 PRAGMA RESTRICT_REFERENCES(get_final_number, RNPS, WNPS, RNDS, WNDS);
567
568 FUNCTION get_final_lob(column_changed$_char IN CHAR,
569 current IN CLOB CHARACTER SET
570 ANY_CS,
571 new IN CLOB CHARACTER SET
572 "CURRENT"%CHARSET)
573 RETURN CLOB CHARACTER SET "CURRENT"%CHARSET;
574 -- column_changed$_char is non NULL
575 -- returns new if and only if column_changed$_char is 'Y'
576 PRAGMA RESTRICT_REFERENCES(get_final_lob, RNPS, WNPS, RNDS, WNDS);
577
578 FUNCTION get_final_lob(column_changed$_char IN CHAR,
579 current IN BLOB,
580 new IN BLOB)
581 RETURN BLOB;
582 -- column_changed$_char is non NULL
583 -- returns new if and only if column_changed$_char is 'Y'
584 PRAGMA RESTRICT_REFERENCES(get_final_lob, RNPS, WNPS, RNDS, WNDS);
585
586 FUNCTION get_final_clob(column_changed$_varchar2 IN VARCHAR2,
587 offset IN NUMBER,
588 current IN CLOB CHARACTER SET
589 ANY_CS,
590 old IN CLOB CHARACTER SET
591 "CURRENT"%CHARSET,
592 new IN CLOB CHARACTER SET
593 "CURRENT"%CHARSET)
594 RETURN CLOB CHARACTER SET "CURRENT"%CHARSET;
595 -- If old and new are identical, then return current else return new.
596 -- Use column_changed$_varchar2 if non-null.
597 PRAGMA RESTRICT_REFERENCES(get_final_clob, RNPS, WNPS, RNDS, WNDS);
598
599 FUNCTION get_final_blob(column_changed$_varchar2 IN VARCHAR2,
600 offset IN NUMBER,
601 current IN BLOB,
602 old IN BLOB,
603 new IN BLOB)
604 RETURN BLOB;
605 -- If old and new are identical, then return current else return new.
606 -- Use column_changed$_varchar2 if non-null.
607 PRAGMA RESTRICT_REFERENCES(get_final_blob, RNPS, WNPS, RNDS, WNDS);
608
609 END dbms_reputil2;
[Home] [Help]