[Home] [Help]
PACKAGE BODY: APPS.FND_ADG_OBJECT
Source
1 package body fnd_adg_object as
2 /* $Header: AFDGOBJB.pls 120.4 2011/03/03 17:42:25 rsanders noship $ */
3
4 C_FORCE_PUBLIC_DBLINK constant boolean := true;
5
6 -- use real returm for LF to get passed arcs.
7
8 LF constant varchar2(20) := '
9 ';
10
11 C_PARSE_PIECE_SIZE constant number := 32000;
12 C_SLAVE_PREFIX constant varchar2(10):= 'SV_';
13
14 C_COMPILE_DIRECTIVE_PACKAGE constant varchar2(30) :=
15 upper('fnd_adg_compile_directive');
16
17 type remapMethodTokenRec is record
18 ( method_name varchar2(30),
19 auto_tx_wrapper varchar2(10),
20 use_commit_wait_on_autotx varchar2(10)
21 );
22
23 type remapMethodTokenArray is table of remapMethodTokenRec;
24 type tokenArray is table of varchar2(50);
25
26 C_COMPILE_DIRECTIVE_ON constant varchar2(32000) :=
27 -- *** COMPILE UNIT START OF INLINE ***
28 q'[
29 create or replace package fnd_adg_compile_directive as
30 /* $Header: AFDGOBJB.pls 120.4 2011/03/03 17:42:25 rsanders noship $ */
31
32 enable_rpc constant boolean := true;
33
34 end fnd_adg_compile_directive;
35 ]' ;
36 -- *** COMPILE UNIT END OF INLINE ***
37
38 C_COMPILE_DIRECTIVE_OFF constant varchar2(32000) :=
39 -- *** COMPILE UNIT START OF INLINE ***
40 q'[
41 create or replace package fnd_adg_compile_directive as
42 /* $Header: AFDGOBJB.pls 120.4 2011/03/03 17:42:25 rsanders noship $ */
43
44 enable_rpc constant boolean := false;
45
46 end fnd_adg_compile_directive;
47 ]' ;
48 -- *** COMPILE UNIT END OF INLINE ***
49
50 type charArray is table of varchar2(30);
51
52 /*==========================================================================*/
53
54 function is_valid_ret_type_for_autotx(p_datatype number) return boolean
55 as
56 begin
57
58 case p_datatype
59 when 2 then return true;
60 when 12 then return true;
61 when 252 then return true;
62 else return false;
63 end case;
64
65 return false;
66
67 end;
68
69 /*==========================================================================*/
70
71 function get_type_string(p_datatype number,
72 p_rpcDescriptor fnd_adg_manage.rpcDescriptor)
73 return varchar2
74 as
75 begin
76
77 case p_datatype
78 when 1 then return ' varchar2 ';
79 when 2 then return ' number ';
80 when 12 then return ' date ';
81 when 252 then return ' boolean ';
82
83 else fnd_adg_exception.raise_error
84 (fnd_adg_exception.C_OBJERR_UNSUPPORTD_DATA_TY,
85 p_rpcDescriptor.package_name||'.'||
86 p_rpcDescriptor.method_name ||
87 ':Type=' || p_datatype );
88 end case;
89
90 return null;
91
92 end;
93
94 /*==========================================================================*/
95
96 function is_supported_type(p_datatype number,
97 p_rpcDescriptor fnd_adg_manage.rpcDescriptor)
98 return boolean
99 as
100 l_type_string varchar2(255);
101 begin
102
103 l_type_string := get_type_string(p_datatype,p_rpcDescriptor);
104
105 return true;
106
107 exception
108 when others then
109
110 -- We will eventually use dba_arguments to do this properly
111 -- but for now we just ignore methods with pl/sql tables as
112 -- none are required.
113
114 if ( p_datatype = 251 )
115 then
116 return false;
117 end if;
118
119 raise;
120
121 end;
122
123 /*==========================================================================*/
124
125 function get_inout_mode(p_inout number,
126 p_rpcDescriptor fnd_adg_manage.rpcDescriptor)
127 return varchar2
128 as
129 begin
130
131 case p_inout
132 when 0 then return ' in ';
133 when 1 then return ' out ';
134 when 2 then return ' in out ';
135 else fnd_adg_exception.raise_error
136 (fnd_adg_exception.C_OBJERR_UNSUPPORTD_IO_MODE,
137 p_rpcDescriptor.package_name||'.'||
138 p_rpcDescriptor.method_name ||
139 ':Mode=' || p_inout);
140 end case;
141
142 return null;
143
144 end;
145
146 /*==========================================================================*/
147
148 procedure string_to_tokens(p_string varchar2,p_token in out nocopy tokenArray,
149 p_separator varchar2)
150 as
151 l_idx number;
152 l_offset number;
153 l_strlen number;
154 l_piece varchar2(255);
155 l_piece_trimmed varchar2(255);
156
157 begin
158
159 if ( p_string is null or p_separator is null or p_token is null )
160 then
161 return;
162 end if;
163
164 l_offset := 1;
165 l_strlen := length(p_string);
166
167 loop
168
169 exit when l_offset > l_strlen ;
170
171 l_idx:= instr(p_string,p_separator,l_offset,1);
172
173 if ( l_idx = 0 )
174 then
175 l_piece := substr(p_string,l_offset);
176 else
177 l_piece := substr(p_string,l_offset,l_idx-l_offset);
178 end if;
179
180 l_piece_trimmed := ltrim(rtrim(l_piece));
181
182 if ( l_piece_trimmed is not null )
183 then
184 if ( length(l_piece_trimmed) > 0 )
185 then
186 p_token.extend;
187 p_token(p_token.last) := l_piece_trimmed;
188 end if;
189 end if;
190
191 if ( l_piece is not null )
192 then
193 l_offset := l_offset + length(l_piece);
194 end if;
195
196 if ( l_idx > 0 )
197 then
198 l_offset := l_offset + 1;
199 end if;
200
201 end loop;
202
203 end;
204
205 /*==========================================================================*/
206
207 procedure parse_remap_method_entry(p_methods varchar2,
208 p_remapMethodTokenTable
209 in out nocopy remapMethodTokenArray)
210 as
211 l_idx number;
212 l_tokenMethod tokenArray;
213 l_tokenOption tokenArray;
214
215 begin
216 if ( p_methods is null )
217 then
218 return;
219 end if;
220
221 l_tokenMethod := tokenArray();
222
223 string_to_tokens(p_methods,l_tokenMethod,',');
224
225 if ( l_tokenMethod.count > 0 )
226 then
227 for i in 1..l_tokenMethod.count loop
228
229 l_tokenOption := tokenArray();
230
231 string_to_tokens(l_tokenMethod(i),l_tokenOption,':');
232
233 if ( l_tokenOption.count > 0 )
234 then
235 p_remapMethodTokenTable.extend;
236
237 l_idx := p_remapMethodTokenTable.last;
238
239 p_remapMethodTokenTable(l_idx).auto_tx_wrapper := 'N';
240 p_remapMethodTokenTable(l_idx).use_commit_wait_on_autotx := 'N';
241
242 for j in 1..l_tokenOption.count loop
243
244 case j
245
246 when 1 then p_remapMethodTokenTable(l_idx).method_name
247 := l_tokenOption(j);
248
249 when 2 then
250 if ( upper(l_tokenOption(j)) = 'Y' or
251 upper(l_tokenOption(j)) = 'N'
252 )
253 then
254 p_remapMethodTokenTable(l_idx).auto_tx_wrapper
255 := l_tokenOption(j);
256 end if;
257 when 3 then
258 if ( upper(l_tokenOption(j)) = 'Y' or
259 upper(l_tokenOption(j)) = 'N'
260 )
261 then
262 p_remapMethodTokenTable(l_idx).
263 use_commit_wait_on_autotx:= l_tokenOption(j);
264 end if;
265 else null;
266 end case;
267 end loop;
268 end if;
269 end loop;
270 end if;
271
272 end;
273
274 /*==========================================================================*/
275
276 function is_reserved_package(p_package_name varchar2,
277 p_synonym_only varchar2) return boolean
278 as
279 begin
280
281 if ( upper(p_package_name) = upper(C_ADG_MANAGE_PACKAGE) or
282 upper(p_package_name) = upper(C_COMPILE_DIRECTIVE_PACKAGE) or
283 upper(p_synonym_only) = 'Y' )
284 then
285 return true;
286 else
287 return false;
288 end if;
289
290 end;
291
292 /*==========================================================================*/
293
294 procedure insert_adg_package ( owner varchar2 default user,
295 package_name varchar2,
296 rpc_package_name varchar2,
297 rpc_synonym_name varchar2,
298 methods varchar2 default null,
299 synonym_only varchar2 default 'N'
300 )
301 as
302 l_adg_package_rec fnd_adg_package%rowtype;
303
304 begin
305
306 l_adg_package_rec.owner := upper(owner);
307 l_adg_package_rec.package_name := upper(package_name);
308 l_adg_package_rec.rpc_package_name := upper(rpc_package_name);
309 l_adg_package_rec.rpc_synonym_name := upper(rpc_synonym_name);
310 l_adg_package_rec.synonym_only := upper(synonym_only);
311 l_adg_package_rec.methods := upper(methods);
312 l_adg_package_rec.spec_code := empty_clob();
313 l_adg_package_rec.body_code := empty_clob();
314
315 if ( l_adg_package_rec.package_name = C_COMPILE_DIRECTIVE_PACKAGE )
316 then
317 l_adg_package_rec.spec_code := C_COMPILE_DIRECTIVE_ON;
318 l_adg_package_rec.body_code := C_COMPILE_DIRECTIVE_OFF;
319 end if;
320
321 insert into fnd_adg_package values l_adg_package_rec;
322
323 end;
324
325 /*==========================================================================*/
326
327 procedure generate_support_objects(p_body_code in out nocopy clob)
328 as
329 begin
330
331 dbms_lob.append
332 (p_body_code,
333 -- *** RPC START OF INLINE ***
334 q'[
335 G_IS_VALID_SYNONYM boolean := null;
336 G_IS_VALID_TIMESTAMP boolean := null;
337 G_IS_VALID_STANDBY_TO_PRIMARY boolean := null;
338
339 G_COMMIT_WAIT_SEQUENCE number := null;
340
341 procedure validate_standby(p_rpcDescriptor fnd_adg_manage.rpcDescriptor) as
342 l_err number;
343 l_msg varchar2(255);
344
345 begin
346
347 if ( not fnd_adg_support.is_standby )
348 then
349 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,
350 'VALIDATE_IS_STANDBY');
351 end if;
352
353 fnd_adg_manage.validate_standby_to_primary(l_err,l_msg,true);
354
355 if ( l_err <> 0 )
356 then
357 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,
358 'VALIDATE_STANDBY_TO_PRIMARY',
359 l_msg);
360 end if;
361
362 end;
363
364 procedure validate_synonym(p_rpcDescriptor fnd_adg_manage.rpcDescriptor) as
365 begin
366
367 if ( G_IS_VALID_SYNONYM is null )
368 then
369 G_IS_VALID_SYNONYM :=
370 fnd_adg_manage.validate_rpc_synonym(p_rpcDescriptor);
371 end if;
372
373 if ( G_IS_VALID_SYNONYM )
374 then
375 return;
376 else
377 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,'VALIDATE_SYNONYM');
378 end if;
379 end;
380
381 procedure validate_timestamp(p_rpcDescriptor fnd_adg_manage.rpcDescriptor) as
382 begin
383
384 if ( G_IS_VALID_TIMESTAMP is null )
385 then
386 G_IS_VALID_TIMESTAMP :=
387 fnd_adg_manage.validate_rpc_timestamp(p_rpcDescriptor);
388 end if;
389
390 if ( G_IS_VALID_TIMESTAMP )
391 then
392 return;
393 else
394 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,'VALIDATE_TIMESTAMP');
395 end if;
396 end;
397
398 procedure validate_slave_rpc(p_rpcDescriptor fnd_adg_manage.rpcDescriptor)
399 as
400 begin
401
402 if ( not fnd_adg_support.is_primary )
403 then
404 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,
405 'VALIDATE_SLAVE_RPC',
406 'Slave is not on primary');
407 end if;
408
409 if ( not fnd_adg_support.is_rpc_from_standby )
410 then
411 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,
412 'VALIDATE_SLAVE_RPC',
413 'Slave is not running as RPC');
414 end if;
415
416 fnd_adg_manage.handle_slave_rpc_debug;
417
418 end;
419
420 procedure wait_for_commit_from_slave(p_rpcDescriptor
421 fnd_adg_manage.rpcDescriptor)
422 as
423 begin
424
425 -- procedure only generated [used] when method commit_wait is true.
426
427 if ( fnd_adg_utility.is_commit_wait_enabled )
428 then
429 if ( not fnd_adg_manage.wait_for_commit_count
430 (p_rpcDescriptor,G_COMMIT_WAIT_SEQUENCE) )
431 then
432 fnd_adg_manage.raise_rpc_exec_error(p_rpcDescriptor,
433 'HANDLE_COMMIT_WAIT_SLAVE_RPC',
434 'Timeout waiting for data');
435 end if;
436 end if;
437
438 end;
439
440 procedure handle_commit_wait_on_slave(p_rpcDescriptor
441 fnd_adg_manage.rpcDescriptor)
442 as
443 begin
444
445 -- procedure only generated [used] when method commit_wait is true.
446
447 if ( fnd_adg_utility.is_commit_wait_enabled )
448 then
449 fnd_adg_manage.increment_commit_count(p_rpcDescriptor);
450 end if;
451
452 end;
453
454 procedure validate_rpc(p_rpcDescriptor fnd_adg_manage.rpcDescriptor,
455 p_use_commit_wait boolean default false)
456 as
457 begin
458 validate_standby(p_rpcDescriptor);
459 validate_synonym(p_rpcDescriptor);
460 validate_timestamp(p_rpcDescriptor);
461
462 fnd_adg_manage.handle_rpc_debug;
463
464 if ( p_use_commit_wait and fnd_adg_utility.is_commit_wait_enabled )
465 then
466 G_COMMIT_WAIT_SEQUENCE := fnd_adg_manage.get_commit_wait_seq
467 (p_rpcDescriptor);
468 end if;
469
470 end;
471
472 ]'
473 -- *** RPC END OF INLINE ***
474 );
475
476 end;
477
478 /*==========================================================================*/
479
480 procedure generate_method_body(p_rpcDescriptor fnd_adg_manage.rpcDescriptor,
481 p_body_code in out nocopy clob,
482 p_arg_table charArray,p_is_function boolean,
483 p_function_return_type number,
484 p_is_slave boolean)
485 as
486 l_slave_prefix varchar2(10);
487 l_use_autonomous_tx boolean := false;
488 l_use_commit_wait boolean := false;
489
490 begin
491
492 if ( p_rpcDescriptor.auto_tx_wrapper = 'Y'
493 and ( not p_is_function or
494 ( p_is_function and
495 is_valid_ret_type_for_autotx(p_function_return_type)
496 )
497 )
498 )
499 then
500 l_use_autonomous_tx := true;
501
502 if ( p_rpcDescriptor.use_commit_wait_on_autotx = 'Y' )
503 then
504 l_use_commit_wait := true;
505 end if;
506 end if;
507
508 if ( p_is_slave and l_use_autonomous_tx )
509 then
510 dbms_lob.append(p_body_code,'PRAGMA AUTONOMOUS_TRANSACTION;'||LF);
511 end if;
512
513 if ( l_use_autonomous_tx and p_is_function )
514 then
515 dbms_lob.append(p_body_code,
516 'l_rc '||
517 get_type_string(p_function_return_type,p_rpcDescriptor) ||
518 ';'||LF);
519 end if;
520
521 dbms_lob.append(p_body_code,
522 'l_rpcDescriptor fnd_adg_manage.rpcDescriptor;'||LF);
523
524 dbms_lob.append(p_body_code,'begin'||LF);
525
526 dbms_lob.append(p_body_code,
527 ' l_rpcDescriptor.owner := ''' ||
528 p_rpcDescriptor.owner || ''';' || LF);
529
530 dbms_lob.append(p_body_code,
531 ' l_rpcDescriptor.package_name := ''' ||
532 p_rpcDescriptor.package_name || ''';' || LF);
533
534 dbms_lob.append(p_body_code,
535 ' l_rpcDescriptor.rpc_package_name := ''' ||
536 p_rpcDescriptor.rpc_package_name || ''';' || LF);
537
538 dbms_lob.append(p_body_code,
539 ' l_rpcDescriptor.rpc_synonym_name := ''' ||
540 p_rpcDescriptor.rpc_synonym_name || ''';' || LF);
541
542 dbms_lob.append(p_body_code,
543 ' l_rpcDescriptor.method_name := ''' ||
544 p_rpcDescriptor.method_name || ''';' || LF);
545
546 if ( p_is_slave )
547 then
548 dbms_lob.append(p_body_code,
549 ' validate_slave_rpc(l_rpcDescriptor); ' || LF);
550 else
551 if ( l_use_commit_wait )
552 then
553 dbms_lob.append(p_body_code,
554 ' validate_rpc(l_rpcDescriptor,true); ' || LF);
555 else
556 dbms_lob.append(p_body_code,
557 ' validate_rpc(l_rpcDescriptor); ' || LF);
558 end if;
559 end if;
560
561 if ( p_is_function )
562 then
563 if ( l_use_autonomous_tx )
564 then
565 dbms_lob.append(p_body_code,' l_rc := ');
566 else
567 dbms_lob.append(p_body_code,'return ');
568 end if;
569 end if;
570
571 if ( p_is_slave )
572 then
573 dbms_lob.append(p_body_code,
574 p_rpcDescriptor.package_name || '.' ||
575 p_rpcDescriptor.method_name);
576 else
577 dbms_lob.append(p_body_code,
578 p_rpcDescriptor.rpc_synonym_name || '.' ||
579 C_SLAVE_PREFIX||p_rpcDescriptor.method_name);
580 end if;
581
582 if ( p_arg_table.count > 0 )
583 then
584 dbms_lob.append(p_body_code,'('||LF);
585
586 for i in 1..p_arg_table.count loop
587
588 if ( i > 1 )
589 then
590 dbms_lob.append(p_body_code,','||LF);
591 end if;
592
593 dbms_lob.append(p_body_code,p_arg_table(i));
594
595 end loop;
596
597 dbms_lob.append(p_body_code,')');
598
599 end if;
600
601 dbms_lob.append(p_body_code,';'||LF);
602
603 if ( l_use_autonomous_tx )
604 then
605 if ( p_is_slave )
606 then
607 if ( l_use_commit_wait )
608 then
609 dbms_lob.append(p_body_code,
610 ' handle_commit_wait_on_slave(l_rpcDescriptor);'||LF);
611 end if;
612
613 dbms_lob.append(p_body_code,' commit;'||LF);
614
615 if ( p_is_function )
616 then
617 dbms_lob.append(p_body_code,' return l_rc;'||LF);
618 end if;
619
620 dbms_lob.append(p_body_code,' exception when others then '||LF);
621 dbms_lob.append(p_body_code,' rollback;'||LF);
622 dbms_lob.append(p_body_code,' raise ;'||LF);
623
624 else
625
626 if ( l_use_commit_wait )
627 then
628 dbms_lob.append(p_body_code,
629 ' wait_for_commit_from_slave(l_rpcDescriptor);'||LF);
630 end if;
631
632 if ( p_is_function )
633 then
634 dbms_lob.append(p_body_code,' return l_rc;'||LF);
635 end if;
636
637 end if;
638 end if;
639
640 dbms_lob.append(p_body_code,'end;'||LF);
641
642 end;
643
644 /*==========================================================================*/
645
646 procedure generate_method_definition(p_rpcDescriptor
647 fnd_adg_manage.rpcDescriptor,
648 p_overload number,
649 p_method_definition in out nocopy varchar2,
650 p_arg_table in out nocopy charArray,
651 p_is_function in out nocopy boolean,
652 p_function_return_type in out nocopy number,
653 p_is_spec_mode boolean,
654 p_slave boolean)
655 as
656 t_overload DBMS_DESCRIBE.NUMBER_TABLE;
657 t_position DBMS_DESCRIBE.NUMBER_TABLE;
658 t_level DBMS_DESCRIBE.NUMBER_TABLE;
659 t_arg_name DBMS_DESCRIBE.VARCHAR2_TABLE;
660 t_data_type DBMS_DESCRIBE.NUMBER_TABLE;
661 t_default_val DBMS_DESCRIBE.NUMBER_TABLE;
662 t_in_out_mode DBMS_DESCRIBE.NUMBER_TABLE;
663 t_length DBMS_DESCRIBE.NUMBER_TABLE;
664 t_precision DBMS_DESCRIBE.NUMBER_TABLE;
665 t_scale DBMS_DESCRIBE.NUMBER_TABLE;
666 t_radix DBMS_DESCRIBE.NUMBER_TABLE;
667 t_spare DBMS_DESCRIBE.NUMBER_TABLE;
668
669 l_code_method_type varchar2(30);
670 l_code_method_return varchar2(255) := null;
671
672 l_has_args boolean := false;
673
674 l_slave_prefix varchar2(10);
675
676 begin
677
678 if ( p_slave )
679 then
680 l_slave_prefix := C_SLAVE_PREFIX;
681 else
682 l_slave_prefix := '';
683 end if;
684
685 p_method_definition := null;
686
687 dbms_describe.describe_procedure(p_rpcDescriptor.owner||'.'||
688 p_rpcDescriptor.package_name||'.'||
689 p_rpcDescriptor.method_name,
690 null,
691 null,
692 t_overload,
693 t_position,
694 t_level ,
695 t_arg_name,
696 t_data_type,
697 t_default_val,
698 t_in_out_mode,
699 t_length,
700 t_precision,
701 t_scale,
702 t_radix,
703 t_spare
704 );
705
706 l_code_method_type := ' procedure ';
707 p_is_function := false;
708
709 for i in 1..t_overload.count loop
710
711 if ( t_overload(i) = p_overload )
712 then
713 if ( t_position(i) = 0 )
714 then
715 l_code_method_type := ' function ';
716 p_is_function := true;
717 p_function_return_type := null;
718
719 if ( not is_supported_type(t_data_type(i),p_rpcDescriptor) )
720 then
721 p_method_definition := null;
722 exit;
723 end if;
724
725 l_code_method_return :=
726 ' return ' || get_type_string(t_data_type(i),p_rpcDescriptor);
727
728 p_function_return_type := t_data_type(i);
729 end if;
730
731 if ( l_code_method_type is not null )
732 then
733 p_method_definition := p_method_definition || l_code_method_type||
734 l_slave_prefix || p_rpcDescriptor.method_name;
735 l_code_method_type := null;
736 end if;
737
738 if ( t_position(i) > 0 and t_arg_name(i) is null )
739 then
740 exit; -- null arg procedure;
741 end if;
742
743 if ( t_position(i) > 0 and not l_has_args )
744 then
745 l_has_args := true;
746 p_method_definition := p_method_definition || '(';
747 end if;
748
749 if ( t_position(i) > 1 )
750 then
751 p_method_definition := p_method_definition || ','||LF;
752 end if;
753
754 if ( t_position(i) > 0 )
755 then
756 p_method_definition := p_method_definition || t_arg_name(i)||' ';
757 p_method_definition := p_method_definition ||
758 get_inout_mode(t_in_out_mode(i),p_rpcDescriptor)||' ';
759
760 if ( not is_supported_type(t_data_type(i),p_rpcDescriptor) )
761 then
762 p_method_definition := null;
763 exit;
764 end if;
765
766 p_method_definition := p_method_definition ||
767 get_type_string(t_data_type(i),p_rpcDescriptor);
768
769 p_arg_table.extend;
770 p_arg_table(p_arg_table.last) := t_arg_name(i);
771
772 end if;
773
774 end if;
775
776 end loop;
777
778 if ( p_method_definition is null )
779 then
780 return ;
781 end if;
782
783 if ( l_has_args )
784 then
785 p_method_definition := p_method_definition || ')';
786 end if;
787
788 if ( l_code_method_return is not null )
789 then
790 p_method_definition := p_method_definition || l_code_method_return;
791 end if;
792
793 if ( p_is_spec_mode )
794 then
795 p_method_definition := p_method_definition || ';'||LF;
796 else
797 p_method_definition := p_method_definition || ' is '||LF;
798 end if;
799
800 end;
801
802 /*==========================================================================*/
803
804 procedure generate_code_spec(p_rpcDescriptor
805 in out nocopy fnd_adg_manage.rpcDescriptor,
806 p_spec_code in out nocopy clob)
807 as
808 cursor c1(c_owner varchar2, c_package_name varchar2)
809 is select a.authid
810 from dba_procedures a
811 where a.owner = c_owner
812 and a.object_name = c_package_name
813 and a.object_type = 'PACKAGE';
814
815 cursor c2(c_owner varchar2, c_package_name varchar2)
816 is select a.rpc_synonym_name,a.package_name,a.owner,
817 a.rpc_package_name,a.methods
818 from fnd_adg_package a
819 where a.package_name = c_package_name
820 and a.owner = c_owner
821 order by a.owner,a.package_name;
822
823 cursor c3(c_owner varchar2, c_package_name varchar2, c_method_name varchar2)
824 is select nvl(a.overload,0) overload
825 from dba_procedures a
826 where a.owner = c_owner
827 and a.object_name = c_package_name
828 and a.procedure_name = c_method_name
829 and a.object_type = 'PACKAGE'
830 and not ( a.aggregate = 'YES'
831 or a.pipelined = 'YES'
832 or a.parallel = 'YES'
833 or a.interface = 'YES'
834 or a.deterministic = 'YES'
835 or a.IMPLTYPEOWNER is not null
836 or a.IMPLTYPENAME is not null
837 );
838
839 l_authid varchar2(128);
840 l_arg_table charArray := charArray();
841 l_slave_arg_table charArray := charArray();
842 l_overload number;
843 l_is_function boolean ;
844 l_method_definition varchar2(32000); -- we can change to clob if we ever hit
845 -- this limit! Unlikely though.
846 l_function_return_type number;
847
848 l_remapMethodTokenTable remapMethodTokenArray ;
849
850 begin
851
852 dbms_lob.trim(p_spec_code,0);
853
854 for f_rec in c1(p_rpcDescriptor.owner,p_rpcDescriptor.package_name) loop
855
856 if ( f_rec.authid = 'DEFINER' )
857 then
858 l_authid := ' AUTHID DEFINER ';
859 else
860 l_authid := ' AUTHID CURRENT_USER ';
861 end if;
862
863 end loop;
864
865 dbms_lob.append
866 (p_spec_code,
867 'create or replace package ' || p_rpcDescriptor.rpc_package_name ||
868 l_authid || ' as ' || LF
869 );
870
871 dbms_lob.append
872 (p_spec_code, ' C_TIMESTAMP constant varchar2(30) := ''' ||
873 to_char(sysdate,'J SSSSS') || ''';' || LF
874 );
875
876 for f_rec in c2(p_rpcDescriptor.owner,p_rpcDescriptor.package_name) loop
877
878 l_remapMethodTokenTable := remapMethodTokenArray();
879
880 parse_remap_method_entry(f_rec.methods,l_remapMethodTokenTable);
881
882 if ( l_remapMethodTokenTable.count > 0 )
883 then
884 for i in 1..l_remapMethodTokenTable.count loop
885
886 p_rpcDescriptor.method_name := l_remapMethodTokenTable(i).method_name;
887 p_rpcDescriptor.auto_tx_wrapper :=
888 l_remapMethodTokenTable(i).auto_tx_wrapper;
889 p_rpcDescriptor.use_commit_wait_on_autotx :=
890 l_remapMethodTokenTable(i).use_commit_wait_on_autotx;
891
892 for f_overload in c3(f_rec.owner,f_rec.package_name,
893 p_rpcDescriptor.method_name) loop
894
895 l_overload := f_overload.overload;
896
897 l_arg_table := charArray();
898 l_slave_arg_table := charArray();
899
900 generate_method_definition(p_rpcDescriptor,l_overload,
901 l_method_definition,
902 l_arg_table, l_is_function,
903 l_function_return_type,true,false);
904
905 if ( l_method_definition is not null )
906 then
907 dbms_lob.append(p_spec_code,l_method_definition);
908 end if;
909
910 generate_method_definition(p_rpcDescriptor,l_overload,
911 l_method_definition,
912 l_slave_arg_table, l_is_function,
913 l_function_return_type,true,true);
914
915 if ( l_method_definition is not null )
916 then
917 dbms_lob.append(p_spec_code,l_method_definition);
918 end if;
919
920 end loop;
921 end loop;
922 end if;
923 end loop;
924
925 dbms_lob.append
926 (p_spec_code, 'end ' || p_rpcDescriptor.rpc_package_name || ';' || LF );
927
928 end;
929
930 /*==========================================================================*/
931
932 procedure generate_code_body(p_rpcDescriptor
933 in out nocopy fnd_adg_manage.rpcDescriptor,
934 p_body_code in out nocopy clob)
935 as
936 cursor c2(c_owner varchar2, c_package_name varchar2)
937 is select a.rpc_synonym_name,a.package_name,a.owner,
938 a.rpc_package_name,a.methods
939 from fnd_adg_package a
940 where a.package_name = c_package_name
941 and a.owner = c_owner
942 order by a.owner,a.package_name;
943
944 cursor c3(c_owner varchar2, c_package_name varchar2, c_method_name varchar2)
945 is select nvl(a.overload,0) overload
946 from dba_procedures a
947 where a.owner = c_owner
948 and a.object_name = c_package_name
949 and a.procedure_name = c_method_name
950 and a.object_type = 'PACKAGE'
951 and not ( a.aggregate = 'YES'
952 or a.pipelined = 'YES'
953 or a.parallel = 'YES'
954 or a.interface = 'YES'
955 or a.deterministic = 'YES'
956 or a.IMPLTYPEOWNER is not null
957 or a.IMPLTYPENAME is not null
958 );
959
960 l_arg_table charArray := charArray();
961 l_slave_arg_table charArray := charArray();
962 l_overload number;
963 l_is_function boolean ;
964 l_method_definition varchar2(32000); -- we can change to clob if we ever hit
965 -- this limit! Unlikely though.
966 l_function_return_type number;
967
968 l_remapMethodTokenTable remapMethodTokenArray ;
969
970 begin
971
972 dbms_lob.trim(p_body_code,0);
973
974 dbms_lob.append
975 (p_body_code,
976 'create or replace package body ' || p_rpcDescriptor.rpc_package_name ||
977 ' as ' || LF
978 );
979
980 generate_support_objects(p_body_code);
981
982 for f_rec in c2(p_rpcDescriptor.owner,p_rpcDescriptor.package_name) loop
983
984 l_remapMethodTokenTable := remapMethodTokenArray();
985
986 parse_remap_method_entry(f_rec.methods,l_remapMethodTokenTable);
987
988 if ( l_remapMethodTokenTable.count > 0 )
989 then
990 for i in 1..l_remapMethodTokenTable.count loop
991
992 p_rpcDescriptor.method_name := l_remapMethodTokenTable(i).method_name;
993 p_rpcDescriptor.auto_tx_wrapper :=
994 l_remapMethodTokenTable(i).auto_tx_wrapper;
995 p_rpcDescriptor.use_commit_wait_on_autotx :=
996 l_remapMethodTokenTable(i).use_commit_wait_on_autotx;
997
998 for f_overload in c3(f_rec.owner,f_rec.package_name,
999 p_rpcDescriptor.method_name) loop
1000
1001 l_overload := f_overload.overload;
1002
1003 l_arg_table := charArray();
1004 l_slave_arg_table := charArray();
1005
1006 generate_method_definition(p_rpcDescriptor,l_overload,
1007 l_method_definition,
1008 l_arg_table, l_is_function,
1009 l_function_return_type, false,false );
1010
1011 if ( l_method_definition is not null )
1012 then
1013 dbms_lob.append(p_body_code,l_method_definition);
1014
1015 generate_method_body(p_rpcDescriptor,p_body_code,l_arg_table,
1016 l_is_function,l_function_return_type,false);
1017 end if;
1018
1019 generate_method_definition(p_rpcDescriptor,l_overload,
1020 l_method_definition,
1021 l_slave_arg_table, l_is_function,
1022 l_function_return_type, false,true );
1023
1024 if ( l_method_definition is not null )
1025 then
1026 dbms_lob.append(p_body_code,l_method_definition);
1027
1028 generate_method_body(p_rpcDescriptor,p_body_code,
1029 l_slave_arg_table,
1030 l_is_function,l_function_return_type,true);
1031 end if;
1032 end loop;
1033 end loop;
1034 end if;
1035 end loop;
1036
1037 dbms_lob.append
1038 (p_body_code, ' begin null; end; ' || LF );
1039
1040 end;
1041
1042 /*==========================================================================*/
1043
1044 procedure validate_method_supported(p_owner varchar2,
1045 p_package varchar2,p_method varchar2)
1046 as
1047 l_count1 number;
1048 begin
1049
1050 select count(*)
1051 into l_count1
1052 from dba_procedures a
1053 where a.owner = p_owner
1054 and a.object_name = p_package
1055 and a.procedure_name = p_method
1056 and a.object_type = 'PACKAGE'
1057 and not ( a.aggregate = 'YES'
1058 or a.pipelined = 'YES'
1059 or a.parallel = 'YES'
1060 or a.interface = 'YES'
1061 or a.deterministic = 'YES'
1062 or a.IMPLTYPEOWNER is not null
1063 or a.IMPLTYPENAME is not null
1064 );
1065
1066 if ( l_count1 = 0 )
1067 then
1068 fnd_adg_exception.raise_error(fnd_adg_exception.C_OBJERR_GEN_MISSING_METHOD,
1069 p_package || '.' || p_method );
1070 end if;
1071
1072 end;
1073
1074
1075 /*==========================================================================*/
1076
1077 procedure compile_package_unit(p_owner varchar2,
1078 p_package_name varchar2,
1079 p_rpc_package_name varchar2,
1080 p_code clob,
1081 p_is_spec_unit boolean)
1082 as
1083 success_with_compilation exception;
1084 pragma exception_init(success_with_compilation,-24344);
1085
1086 l_compile_spec varchar2(10) := 'N' ;
1087 l_compile_body varchar2(10) := 'N' ;
1088
1089 l_compile_status number := -2;
1090 l_err_msg varchar2(2048);
1091
1092 l_stmt dbms_sql.varchar2a;
1093 l_clob_len number;
1094 l_no_chunks number;
1095
1096 l_csr integer;
1097 l_amount number;
1098 l_buffer varchar2(32767);
1099
1100 begin
1101
1102 if ( p_is_spec_unit )
1103 then
1104 l_compile_spec := 'Y';
1105 else
1106 l_compile_body := 'Y';
1107 end if;
1108
1109 /* We're using varchar2a rather than clob because of 10gR2
1110 dependencies. However, varchar2a doesn't raise -24344 - it
1111 just sets invalid status! Ah well, just check dictionary.
1112 */
1113
1114 l_clob_len := dbms_lob.getlength(p_code);
1115 l_no_chunks := trunc(l_clob_len/C_PARSE_PIECE_SIZE);
1116
1117 /* We use dbms_lob.read as substr has limit of 32767/4 for
1118 utf8 so we lose chars!*/
1119
1120 for i in 1..l_no_chunks loop
1121 l_amount := C_PARSE_PIECE_SIZE;
1122 dbms_lob.read(p_code,l_amount,1+(C_PARSE_PIECE_SIZE*(i-1)),l_buffer);
1123 l_stmt(i) := l_buffer;
1124 end loop;
1125
1126 if ( mod(l_clob_len,C_PARSE_PIECE_SIZE) > 0 )
1127 then
1128 l_amount := mod(l_clob_len,C_PARSE_PIECE_SIZE);
1129
1130 dbms_lob.read(p_code,l_amount,1+(C_PARSE_PIECE_SIZE*l_no_chunks),l_buffer);
1131 l_stmt(l_no_chunks+1) := l_buffer;
1132 end if;
1133
1134 /*
1135 sys.dbms_output.put_line('l_clob_len='||l_clob_len||' l_no_chunks='||l_no_chunks||' count='||l_stmt.count);
1136
1137 for i in 1..l_stmt.count loop
1138 sys.dbms_output.put_line(l_stmt(i));
1139 end loop;
1140 */
1141
1142 l_csr := dbms_sql.open_cursor;
1143
1144 begin
1145
1146 dbms_sql.parse(l_csr,l_stmt,1,l_stmt.count,false,1);
1147
1148 l_compile_status := 0;
1149
1150 exception
1151 when success_with_compilation then
1152 l_compile_status := 1;
1153
1154 when others then
1155
1156 if ( dbms_sql.is_open(l_csr) )
1157 then
1158 dbms_sql.close_cursor(l_csr);
1159 end if;
1160
1161 raise;
1162 end;
1163
1164 if ( dbms_sql.is_open(l_csr) )
1165 then
1166 dbms_sql.close_cursor(l_csr);
1167 end if;
1168
1169 /* dbms_sql.parse with varchar2a doesn't raise -24344 ! */
1170
1171 if ( p_package_name = C_COMPILE_DIRECTIVE_PACKAGE )
1172 then
1173 select count(*)
1174 into l_compile_status
1175 from dba_objects a
1176 where a.owner = p_owner
1177 and a.object_name = p_package_name
1178 and a.object_type = 'PACKAGE'
1179 and a.status = 'INVALID';
1180 else
1181 select count(*)
1182 into l_compile_status
1183 from dba_objects a
1184 where a.owner = p_owner
1185 and a.object_name = p_rpc_package_name
1186 and a.object_type = decode(l_compile_spec,'Y','PACKAGE','PACKAGE BODY')
1187 and a.status = 'INVALID';
1188 end if;
1189
1190 if ( l_compile_status <> 0 )
1191 then
1192 l_err_msg := p_owner || '.' ||p_rpc_package_name
1193 ||' Spec='||l_compile_spec
1194 ||' Body='||l_compile_body||' Status='||l_compile_status;
1195
1196 if ( p_package_name = C_COMPILE_DIRECTIVE_PACKAGE )
1197 then
1198 raise_application_error(-20001,'Directive package failed to compile!');
1199 else
1200 fnd_adg_exception.raise_error(fnd_adg_exception.C_OBJERR_COMPILE_ERROR,l_err_msg);
1201 end if;
1202 end if;
1203
1204 end;
1205
1206 /*==========================================================================*/
1207
1208 procedure compile_package_spec(p_owner varchar2,
1209 p_package_name varchar2,
1210 p_rpc_package_name varchar2,
1211 p_code clob)
1212 as
1213 begin
1214
1215 compile_package_unit(p_owner,p_package_name,p_rpc_package_name,p_code,true);
1216
1217 end;
1218
1219 /*==========================================================================*/
1220
1221 procedure compile_package_body(p_owner varchar2,
1222 p_package_name varchar2,
1223 p_rpc_package_name varchar2,
1224 p_code clob)
1225 as
1226 begin
1227
1228 compile_package_unit(p_owner,p_package_name,p_rpc_package_name,p_code,false);
1229
1230 end;
1231
1232 /*==========================================================================*/
1233
1234 procedure set_compile_directive_rcs_id(p_owner varchar2,
1235 p_code in clob,
1236 p_adj_code in out nocopy clob)
1237 as
1238 l_code_str varchar2(32000);
1239 l_new_code_str varchar2(32000);
1240 l_src_rcs_id varchar2(8000);
1241 l_start_code_rcs number;
1242 l_end_code_rcs number;
1243
1244 cursor c1 is select a.text
1245 from dba_source a
1246 where a.owner = p_owner
1247 and a.name = C_COMPILE_DIRECTIVE_PACKAGE
1248 and a.type = 'PACKAGE'
1249 and instr(a.text,'Header') > 0
1250 and instr(a.text,'$Head') > 0;
1251 begin
1252
1253 l_code_str := p_code;
1254
1255 l_src_rcs_id := null;
1256
1257 for f_rec in c1 loop
1258
1259 l_src_rcs_id := f_rec.text;
1260
1261 end loop;
1262
1263 if ( l_src_rcs_id is null )
1264 then
1265 return ; /* Not found */
1266 end if;
1267
1268 l_src_rcs_id := replace(l_src_rcs_id,'/*','');
1269 l_src_rcs_id := replace(l_src_rcs_id,'*/','');
1270 l_src_rcs_id := replace(l_src_rcs_id,'*','');
1271 l_src_rcs_id := rtrim(l_src_rcs_id);
1272 l_src_rcs_id := ltrim(l_src_rcs_id);
1273
1274 /* Handle issue where first version used AFDGOBJB.pls.*/
1275
1276 if (instr(l_src_rcs_id,'AFDGOBJ') > 0 )
1277 then
1278 l_src_rcs_id := '$' ||
1279 'Header: ' ||
1280 'AFDGCPDS.pls 120.0.12010000.2 2010/09/17 09:54:04 rsanders ' ||
1281 'noship $';
1282 end if;
1283
1284 l_start_code_rcs := instr(l_code_str,'$Header');
1285 l_end_code_rcs := instr(l_code_str,'$',l_start_code_rcs+1);
1286
1287 l_new_code_str := substr(l_code_str,1,l_start_code_rcs-1) ||
1288 l_src_rcs_id || substr(l_code_str,l_end_code_rcs+1);
1289
1290 dbms_lob.createtemporary(p_adj_code,false);
1291
1292 dbms_lob.write(p_adj_code,length(l_new_code_str),1,l_new_code_str);
1293 dbms_lob.trim(p_adj_code,length(l_new_code_str));
1294
1295 end;
1296
1297 /*==========================================================================*/
1298 /*==================Start of public methods ================================*/
1299 /*==========================================================================*/
1300
1301 /*==========================================================================*/
1302
1303 procedure build_synonym(p_owner varchar2 default user,
1304 p_package_name varchar2)
1305 as
1306 cursor c1 is select a.owner,a.rpc_synonym_name,a.package_name,a.synonym_only,
1307 a.rpc_package_name
1308 from fnd_adg_package a
1309 where a.owner = p_owner
1310 and a.package_name = p_package_name
1311 order by 1,2,3;
1312
1313 l_dblink varchar2(255);
1314
1315 l_rpc_synonym_name varchar2(30);
1316 l_rpc_synonym_target varchar2(30);
1317
1318 l_cmd_string varchar2(2048);
1319 l_ok number;
1320
1321 begin
1322
1323 l_dblink := fnd_adg_utility.get_standby_to_primary_dblink;
1324
1325 for f_rec in c1 loop
1326
1327 if ( is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1328 then
1329 if ( upper(f_rec.package_name) = upper(C_COMPILE_DIRECTIVE_PACKAGE) )
1330 then
1331 return;
1332 end if;
1333 end if;
1334
1335 l_rpc_synonym_name := f_rec.rpc_synonym_name;
1336 l_rpc_synonym_target:=f_rec.rpc_package_name;
1337
1338 if ( f_rec.package_name = C_ADG_MANAGE_PACKAGE )
1339 then
1340 l_rpc_synonym_name := C_ADG_MANAGE_NAME_REMOTE;
1341 l_rpc_synonym_target:= f_rec.package_name;
1342 end if;
1343
1344 select count(*)
1345 into l_ok
1346 from dba_synonyms a
1347 where a.owner = f_rec.owner
1348 and a.synonym_name = l_rpc_synonym_name
1349 and a.table_owner = f_rec.owner
1350 and a.table_name = l_rpc_synonym_target
1351 and ( ( a.db_link is null and l_dblink is null )
1352 or( a.db_link = l_dblink )
1353 );
1354
1355 if ( l_ok <> 1 )
1356 then
1357
1358 if ( l_dblink is null )
1359 then
1360 l_cmd_string :=
1361 ' create or replace synonym ' || l_rpc_synonym_name ||
1362 ' for ' || l_rpc_synonym_target;
1363 else
1364 l_cmd_string :=
1365 ' create or replace synonym ' || l_rpc_synonym_name ||
1366 ' for ' || l_rpc_synonym_target ||
1367 '@' || l_dblink ;
1368 end if;
1369
1370 -- sys.dbms_output.put_line(l_cmd_string);
1371
1372 execute immediate l_cmd_string;
1373
1374 end if;
1375
1376 end loop;
1377
1378 end;
1379
1380 /*==========================================================================*/
1381
1382 procedure build_all_synonyms
1383 as
1384 cursor c1 is select a.owner,a.package_name,a.rpc_package_name,a.synonym_only
1385 from fnd_adg_package a
1386 order by a.owner,a.package_name;
1387 begin
1388
1389 for f_rec in c1 loop
1390
1391 if ( not is_reserved_package(f_rec.package_name,f_rec.synonym_only) or
1392 ( is_reserved_package(f_rec.package_name,f_rec.synonym_only) and
1393 upper(f_rec.package_name) <> upper(C_COMPILE_DIRECTIVE_PACKAGE) ) )
1394 then
1395 build_synonym(f_rec.owner,f_rec.package_name);
1396 end if;
1397
1398 end loop;
1399
1400 end;
1401
1402 /*==========================================================================*/
1403
1404 procedure compile_package(p_owner varchar2 default user,
1405 p_package_name varchar2,
1406 p_compile_spec boolean default true,
1407 p_compile_body boolean default true)
1408 as
1409 cursor c1 is select a.owner,a.package_name,a.rpc_package_name,a.synonym_only,
1410 a.spec_code,a.body_code,
1411 dbms_lob.getlength(a.spec_code) spec_len,
1412 dbms_lob.getlength(a.body_code) body_len
1413 from fnd_adg_package a
1414 where a.owner = p_owner
1415 and a.package_name = p_package_name
1416 order by a.owner,a.package_name;
1417
1418 l_package_error boolean;
1419 spec_is_empty boolean;
1420 body_is_empty boolean;
1421 l_rpc_package_name varchar2(30);
1422
1423 begin
1424
1425 l_package_error := true;
1426 spec_is_empty := false;
1427 body_is_empty := false;
1428
1429 for f_rec in c1 loop
1430
1431 if ( is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1432 then
1433 return;
1434 end if;
1435
1436 l_package_error := false;
1437
1438 l_rpc_package_name := f_rec.rpc_package_name;
1439
1440 if ( p_compile_spec )
1441 then
1442 if ( f_rec.spec_len = 0 )
1443 then
1444 spec_is_empty := true;
1445 else
1446 compile_package_spec(p_owner,p_package_name,l_rpc_package_name,
1447 f_rec.spec_code);
1448 end if;
1449 end if;
1450
1451 if ( p_compile_body )
1452 then
1453 if ( f_rec.body_len = 0 )
1454 then
1455 body_is_empty := true;
1456 else
1457 compile_package_body(p_owner,p_package_name,l_rpc_package_name,
1458 f_rec.body_code);
1459 end if;
1460 end if;
1461
1462 exit;
1463
1464 end loop;
1465
1466 if ( l_package_error )
1467 then
1468 fnd_adg_exception.raise_error(fnd_adg_exception.C_OBJERR_COMPILE_NOT_DEFINED,
1469 p_owner || '.' ||l_rpc_package_name
1470 );
1471 end if;
1472
1473 if ( spec_is_empty or body_is_empty )
1474 then
1475 fnd_adg_exception.raise_error(fnd_adg_exception.C_OBJERR_COMPILE_NO_CODE,
1476 p_owner || '.' ||l_rpc_package_name
1477 );
1478 end if;
1479
1480 end;
1481
1482 /*==========================================================================*/
1483
1484 procedure compile_all_packages
1485 as
1486 cursor c1 is select a.owner,a.package_name,a.rpc_package_name,a.synonym_only
1487 from fnd_adg_package a
1488 order by a.owner,a.package_name;
1489 begin
1490
1491 for f_rec in c1 loop
1492
1493 if ( not is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1494 then
1495 compile_package(f_rec.owner,f_rec.package_name);
1496 end if;
1497
1498 end loop;
1499
1500 end;
1501
1502 /*==========================================================================*/
1503
1504 procedure build_package(p_owner varchar2 default user,
1505 p_package_name varchar2,
1506 p_build_spec boolean default true,
1507 p_build_body boolean default true)
1508 as
1509 l_fnd_adg_package_rec fnd_adg_package%rowtype;
1510 l_spec_code clob;
1511 l_body_code clob;
1512 l_rpcDescriptor fnd_adg_manage.rpcDescriptor;
1513
1514 l_remapMethodTokenTable remapMethodTokenArray ;
1515
1516 begin
1517
1518 select a.*
1519 into l_fnd_adg_package_rec
1520 from fnd_adg_package a
1521 where a.owner = p_owner
1522 and a.package_name = p_package_name;
1523
1524 if ( is_reserved_package(l_fnd_adg_package_rec.package_name,
1525 l_fnd_adg_package_rec.synonym_only) )
1526 then
1527 return;
1528 end if;
1529
1530 l_remapMethodTokenTable := remapMethodTokenArray();
1531
1532 parse_remap_method_entry(l_fnd_adg_package_rec.methods,
1533 l_remapMethodTokenTable);
1534
1535 if ( l_remapMethodTokenTable.count > 0 )
1536 then
1537 for i in 1..l_remapMethodTokenTable.count loop
1538
1539 validate_method_supported(p_owner,p_package_name,
1540 l_remapMethodTokenTable(i).method_name);
1541 end loop;
1542 end if;
1543
1544 select a.spec_code,a.body_code
1545 into l_spec_code,l_body_code
1546 from fnd_adg_package a
1547 where a.owner = p_owner
1548 and a.package_name = p_package_name
1549 for update ;
1550
1551 l_rpcDescriptor.owner := p_owner;
1552 l_rpcDescriptor.package_name := p_package_name;
1553 l_rpcDescriptor.rpc_package_name := l_fnd_adg_package_rec.rpc_package_name;
1554 l_rpcDescriptor.rpc_synonym_name := l_fnd_adg_package_rec.rpc_synonym_name;
1555
1556 if ( p_build_spec )
1557 then
1558 generate_code_spec(l_rpcDescriptor,l_spec_code);
1559 end if;
1560
1561 if ( p_build_body )
1562 then
1563 generate_code_body(l_rpcDescriptor,l_body_code);
1564 end if;
1565
1566 end;
1567
1568 /*==========================================================================*/
1569
1570 procedure build_all_packages
1571 as
1572 cursor c1 is select a.owner,a.package_name,a.synonym_only
1573 from fnd_adg_package a
1574 order by a.owner,a.package_name;
1575 begin
1576
1577 for f_rec in c1 loop
1578
1579 if ( not is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1580 then
1581 build_package(f_rec.owner,f_rec.package_name);
1582 end if;
1583
1584 end loop;
1585
1586 end;
1587
1588 /*==========================================================================*/
1589
1590 procedure compile_directive(p_enable boolean default null)
1591 as
1592 l_spec_code clob;
1593 l_body_code clob;
1594 l_compile_unit clob := empty_clob();
1595
1596 begin
1597
1598 if ( p_enable is null )
1599 then
1600 return;
1601 end if;
1602
1603 select a.spec_code,a.body_code
1604 into l_spec_code,l_body_code
1605 from fnd_adg_package a
1606 where a.owner = user
1607 and a.package_name = C_COMPILE_DIRECTIVE_PACKAGE;
1608
1609 dbms_lob.createtemporary(l_compile_unit,false);
1610
1611 if ( p_enable )
1612 then
1613 set_compile_directive_rcs_id(user,l_spec_code,l_compile_unit);
1614 compile_package_unit(user,C_COMPILE_DIRECTIVE_PACKAGE,
1615 C_COMPILE_DIRECTIVE_PACKAGE,l_compile_unit,true);
1616 else
1617 set_compile_directive_rcs_id(user,l_body_code,l_compile_unit);
1618 compile_package_unit(user,C_COMPILE_DIRECTIVE_PACKAGE,
1619 C_COMPILE_DIRECTIVE_PACKAGE,l_compile_unit,false);
1620 end if;
1621
1622 dbms_lob.freetemporary(l_compile_unit);
1623
1624 end;
1625
1626 /*==========================================================================*/
1627
1628 procedure compile_rpc_dependents
1629 as
1630 cursor c1 is select a.owner,a.package_name,a.rpc_package_name,a.synonym_only
1631 from fnd_adg_package a
1632 order by a.owner,a.package_name;
1633 begin
1634
1635 for f_rec in c1 loop
1636
1637 if ( not is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1638 then
1639 execute immediate
1640 'alter package ' || f_rec.owner || '.' || f_rec.rpc_package_name ||
1641 ' compile body';
1642
1643 execute immediate
1644 'alter package ' || f_rec.owner || '.' || f_rec.package_name ||
1645 ' compile body';
1646 else
1647
1648 if ( is_reserved_package(f_rec.package_name,f_rec.synonym_only) and
1649 upper(f_rec.package_name) = upper(C_ADG_MANAGE_PACKAGE) )
1650 then
1651 execute immediate
1652 'alter package ' || f_rec.owner || '.' || f_rec.package_name ||
1653 ' compile body';
1654 end if;
1655 end if;
1656
1657 end loop;
1658
1659 end;
1660
1661 /*==========================================================================*/
1662
1663 procedure validate_package_usage(p_use_rpc_dependency boolean)
1664 as
1665 cursor c1 is select a.owner,a.package_name,a.rpc_package_name,a.methods,
1666 a.synonym_only
1667 from fnd_adg_package a
1668 order by a.owner,a.package_name;
1669
1670 l_package_count number := 0;
1671 l_valid_count number;
1672 l_referenced_name varchar2(255);
1673 begin
1674
1675 for f_rec in c1 loop
1676
1677 if ( not is_reserved_package(f_rec.package_name,f_rec.synonym_only) )
1678 then
1679 l_package_count := l_package_count + 1;
1680
1681 -- We only need to check valid count when doing
1682 -- rpc dependency checking. Compile directive
1683 -- is just to check that the correct packages have been
1684 -- installed.
1685
1686 if ( p_use_rpc_dependency )
1687 then
1688
1689 select count(*)
1690 into l_valid_count
1691 from dba_objects a
1692 where a.owner = f_rec.owner
1693 and a.object_name = f_rec.package_name
1694 and a.object_type in ('PACKAGE','PACKAGE BODY')
1695 and a.status = 'VALID';
1696
1697 if ( l_valid_count <> 2 )
1698 then
1699 fnd_adg_exception.raise_error(
1700 fnd_adg_exception.C_OBJERR_USAGE_NOT_VALID,
1701 f_rec.package_name
1702 );
1703 end if;
1704
1705 select count(*)
1706 into l_valid_count
1707 from dba_objects a
1708 where a.owner = f_rec.owner
1709 and a.object_name = f_rec.rpc_package_name
1710 and a.object_type in ('PACKAGE','PACKAGE BODY')
1711 and a.status = 'VALID';
1712
1713 if ( l_valid_count <> 2 )
1714 then
1715 fnd_adg_exception.raise_error(
1716 fnd_adg_exception.C_OBJERR_USAGE_RPC_NOT_VALID,
1717 f_rec.rpc_package_name
1718 );
1719 end if;
1720
1721 end if;
1722
1723 if ( p_use_rpc_dependency )
1724 then
1725 -- If methods is null then there will be no RPC
1726 -- dependents. Best we can do is check for compile directive.
1727
1728 if ( f_rec.methods is null )
1729 then
1730 l_referenced_name := C_COMPILE_DIRECTIVE_PACKAGE;
1731 else
1732 l_referenced_name := f_rec.rpc_package_name;
1733 end if;
1734 else
1735 -- compile directive only.
1736
1737 l_referenced_name := C_COMPILE_DIRECTIVE_PACKAGE;
1738
1739 end if;
1740
1741 select count(*)
1742 into l_valid_count
1743 from dba_dependencies a
1744 where a.owner = f_rec.owner
1745 and a.NAME = f_rec.package_name
1746 and a.type = 'PACKAGE BODY'
1747 and a.REFERENCED_OWNER = f_rec.owner
1748 and a.REFERENCED_NAME = l_referenced_name
1749 and a.referenced_type = 'PACKAGE';
1750
1751 if ( l_valid_count = 0 )
1752 then
1753 fnd_adg_exception.raise_error(
1754 fnd_adg_exception.C_OBJERR_USAGE_NO_DEP,
1755 f_rec.package_name
1756 );
1757 end if;
1758
1759 end if;
1760
1761 end loop;
1762
1763 if ( l_package_count = 0 )
1764 then
1765 fnd_adg_exception.raise_error(
1766 fnd_adg_exception.C_OBJERR_USAGE_LIST_IS_EMPTY);
1767 end if;
1768
1769 end;
1770
1771 /*==========================================================================*/
1772
1773 procedure init_package_list
1774 as
1775 begin
1776
1777 delete from fnd_adg_package;
1778
1779 insert_adg_package( package_name => C_ADG_MANAGE_PACKAGE,
1780 rpc_package_name => C_ADG_MANAGE_PACKAGE,
1781 rpc_synonym_name => C_ADG_MANAGE_NAME_REMOTE
1782 );
1783
1784 insert_adg_package( package_name => C_COMPILE_DIRECTIVE_PACKAGE,
1785 rpc_package_name => C_COMPILE_DIRECTIVE_PACKAGE,
1786 rpc_synonym_name => C_COMPILE_DIRECTIVE_PACKAGE||'_NULL'
1787 );
1788
1789 /*
1790 insert_adg_package( package_name => 'FND_GLOBAL',
1791 rpc_package_name => 'FND_GLOBAL_RPC',
1792 rpc_synonym_name => 'FND_GLOBAL_REMOTE',
1793 methods => 'bless_next_init,initialize'
1794 );
1795 */
1796
1797 insert_adg_package( package_name => 'MO_GLOBAL',
1798 rpc_package_name => 'MO_GLOBAL_RPC',
1799 rpc_synonym_name => 'MO_GLOBAL_REMOTE',
1800 methods => null
1801 );
1802
1803 insert_adg_package( package_name => 'FND_CONCURRENT_REQUESTS',
1804 rpc_package_name => 'FND_CONCURRENT_REQUESTS',
1805 rpc_synonym_name => 'FND_CONCURRENT_REQUESTS_REMOTE',
1806 methods => null,
1807 synonym_only => 'Y'
1808 );
1809
1810 insert_adg_package( package_name => 'FND_MO_SP_PREFERENCES',
1811 rpc_package_name => 'FND_MO_SP_PREFERENCES',
1812 rpc_synonym_name => 'FND_MO_SP_PREFERENCES_REMOTE',
1813 methods => null,
1814 synonym_only => 'Y'
1815 );
1816
1817 insert_adg_package( package_name => 'MO_GLOB_ORG_ACCESS_TMP',
1818 rpc_package_name => 'MO_GLOB_ORG_ACCESS_TMP',
1819 rpc_synonym_name => 'MO_GLOB_ORG_ACCESS_TMP_REMOTE',
1820 methods => null,
1821 synonym_only => 'Y'
1822 );
1823
1824 /*
1825 insert_adg_package( package_name => 'FND_PROFILE',
1826 rpc_package_name => 'FND_PROFILE_RPC',
1827 rpc_synonym_name => 'FND_PROFILE_REMOTE',
1828 methods => 'put'
1829 );
1830 */
1831
1832 insert_adg_package( package_name => 'FND_CONCURRENT',
1833 rpc_package_name => 'FND_CONCURRENT_RPC',
1834 rpc_synonym_name => 'FND_CONCURRENT_REMOTE',
1835 -- methods =>'init_request:Y:Y,set_interim_status:Y:Y,'||
1836 -- 'set_preferred_rbs:Y'
1837 methods => null
1838 );
1839
1840 end;
1841
1842 /*==========================================================================*/
1843
1844 begin
1845 null;
1846 end fnd_adg_object;