Overview
This chapter describes
concurrent processing APIs you can use in your PL/SQL procedures. It also
includes example PL/SQL code using these concurrent processing APIs.
The following
concurrent processing packages are covered:
•
FND_CONC_GLOBAL.REQUEST_DATA:
Sub–request Submission
•
FND_CONCURRENT:
Information on Submitted Requests
•
FND_FILE:
PL/SQL: File I/O
•
FND_PROGRAM:
Concurrent Program Loader
•
FND_SET:
Request Set Creation
•
FND_REQUEST:
Concurrent Program Submission
•
FND_REQUEST_INFO:
Request Information
•
FND_SUBMIT:
Request Set Submission
FND_CONC_GLOBAL Package
This package is used
for submitting sub-requests from PL/SQL concurrent programs.
FND_CONC_GLOBAL.REQUEST_DATA
Summary function FND_CONC_GLOBAL.REQUEST_DATA
return
varchar2;
Description FND_CONC_GLOBAL.REQUEST_DATA retrieves the
value of the REQUEST_DATA global.
FND_CONC_GLOBAL.SET_REQ_GLOBALS
|
Summary
|
procedure
SET_REQ_GLOBALS (conc_status in
varchar2
default null,
request_data in varchar2 default
null,
conc_restart_time in varchar2 default
null,
release_sub_request in varchar2
default
null);
|
|
Description
|
FND_CONC_GLOBAL
.SET_REQ_GLOBALS sets the
|
values
for special globals.
Example
/*
* This is sample PL/SQL
concurrent program submits 10
* sub-requests. The
sub-requests are submitted one at a
* time. Each time a sub-request is submitted, the
parent
* exits to the Running/Paused
state, so that it does not
* consume any resources while
waiting for the child
* request, to complete. When the child completes the * parent is
restarted.
*/
create
or replace procedure parent (errbuf out
varchar2, retcode out number) is
i number;
req_data varchar2(10); r
number;
begin --
-- Read the value from REQUEST_DATA. If this is the
-- first run of the program, then this value
will be -- null.
-- Otherwise, this will be the value that we
passed to -- SET_REQ_GLOBALS on the
previous run.
--
req_data := fnd_conc_global.request_data;
- --
If this is the first run, we'll set i = 1.
-- Otherwise, we'll set i = request_data +
1, and we'll -- exit if we're done.
--
if (req_data is not null) then i := to_number(req_data);
i := i + 1; if (i < 11 ) then
errbuf := 'Done!'; retcode
:= 0 ; return; end if;
else i := 1; end if;
--
-- Submit the child request. The sub_request parameter -- must be set to 'Y'.
--
r := fnd_request.submit_request('FND',
'CHILD', 'Child '
|| to_char(i), NULL,
TRUE,
fnd_conc_global.printer);
if r = 0 then -
-- If request submission failed, exit with error.
--
errbuf := fnd_message.get;
retcode := 2; else
--
-- Here we set the globals to
put the program into the
-- PAUSED status on exit, and to save the
state in -- request_data.
--
fnd_conc_global.set_req_globals(conc_status
=> 'PAUSED',
request_data => to_char(i));
errbuf := 'Sub-Request submitted!';
retcode := 0 ; end if;
return;
end;
FND_CONCURRENT Package
FND_CONCURRENT.AF_COMMIT
Summary function
FND_CONCURRENT.AF_COMMIT;
Description FND_CONCURRENT.AF_COMMIT
is used by concurrent programs that use a particular rollback segment. This
rollback segment must be defined in the Define Concurrent Program form.
FND_CONCURRENT.AF_COMMIT
executes the COMMIT command for the specified rollback segment.
FND_CONCURRENT.AF_COMMIT
has no arguments.
FND_CONCURRENT.AF_ROLLBACK
|
Summary
|
function
FND_CONCURRENT.AF_ROLLBACK;
|
|
Description
|
FND_CONCURRENT.AF_ROLLBACK
is used by concurrent programs that use a particular rollback segment. This
rollback segment must be defined in the Define Concurrent Program form.
|
FND_CONCURRENT.AF_ROLLBACK
executes the
ROLLBACK
command for the specified rollback segment.
FND_CONCURRENT.AF_ROLLBACK
has no arguments.
FND_CONCURRENT.GET_REQUEST_STATUS (Client or
Server)
|
Summary
|
function
FND_CONCURRENT.GET_REQUEST_STATUS
(request_id IN OUT number,
application IN varchar2 default
NULL, program IN varchar2 default NULL,
phase OUT varchar2, status OUT varchar2, dev_phase OUT varchar2, dev_status OUT varchar2, message OUT varchar2)
return
boolean;
|
|
Description
Arguments (input)
|
Returns
the status of a concurrent request. If the request has already completed,
also returns a completion message.
FND_CONCURRENT.GET_REQUEST_STATUS
returns
both
"user-friendly" (i.e., translatable) phase and status values, as
well as "developer" phase and status values that can drive program
logic.
|
|
request_id
|
The
request ID of the program to be checked.
|
|
application
|
Short
name of the application associated with the concurrent program. This
parameter is necessary only when the request_id is not specified.
|
|
program
Arguments (output)
|
Short
name of the concurrent program (not the executable). This parameter is
necessary only when the request_id is not
specified. When application and program are provided, the request ID of
the last request for this program is returned in request_id.
|
|
phase
|
The
user-friendly request phase from FND_LOOKUPS.
|
|
status
|
The
user-friendly request status from FND_LOOKUPS.
|
|
dev_phase
|
The
request phase as a constant string that can be used for program logic
comparisons.
|
|
dev_status
|
The
request status as a constant string that can be used for program logic
comparisons.
|
|
message
|
The
completion message supplied if the request has completed.
|
Example
call_status
boolean; rphase varchar2(80); rstatus varchar2(80); dphase varchar2(30); dstatus varchar2(30); message varchar2(240);
call_status :=
FND_CONCURRENT.GET_REQUEST_STATUS(<Request_ID>,
'', '',
rphase,rstatus,dphase,dstatus,
message); end;
In the above example,
rphase and rstatusreceive the same phase and status values as are displayed on
the Concurrent Requests form. The completion text of a completed request
returns in a message.
Any developer who
wishes to control the flow of a program based on a request's outcome should use
the following values to compare the request's phase and status.
Possible values for
dev_phase and dev_status are listed and described in the following table:
|
dev_phase
|
dev_status
|
Description
|
|
PENDING
|
NORMAL
|
Request is waiting
for the next available manager.
|
|
PENDING
|
STANDBY
|
A
constrained request (i.e. incompatible with currently running or actively
pending programs) is waiting for the Internal concurrent manager to release
it.
|
|
PENDING
|
SCHEDULED
|
Request
is scheduled to start at a future time or date.
|
|
PENDING
|
PAUSED
|
Child
request is waiting for its Parent request to mark it ready to run. For
example, a report in a report set that runs sequentially must wait for a
prior report to complete.
|
|
RUNNING
|
NORMAL
|
Request
is being processed.
|
|
RUNNING
|
WAITING
|
Parent
request is waiting for its sub-requests to complete.
|
|
dev_phase
|
dev_status
|
Description
|
|
RUNNING
|
RESUMING
|
Parent
request is waiting to restart after its sub-requests have completed.
|
|
RUNNING
|
TERMINATING
|
A
user has requested to terminate this running request.
|
|
COMPLETE
|
NORMAL
|
Request
completed successfully.
|
|
COMPLETE
|
ERROR
|
Request
failed to complete successfully.
|
|
COMPLETE
|
WARNING
|
Request
completed with warnings. For example, a report is generated successfully but
failed to print.
|
|
COMPLETE
|
CANCELLED
|
Pending
or Inactive request was cancelled.
|
|
COMPLETE
|
TERMINATED
|
Running
request was terminated.
|
|
INACTIVE
|
DISABLED
|
Concurrent
program associated with the request is disabled.
|
|
INACTIVE
|
ON_HOLD
|
Pending
request placed on hold.
|
|
INACTIVE
|
NO_
MANAGER
|
No
manager is defined to run the request.
|
|
INACTIVE
|
SUSPENDED
|
This
value is included for upward compatibility. It indicates that a user has
paused the request at the OS level.
|
FND_CONCURRENT.WAIT_FOR_REQUEST (Client or
Server)
|
Summary
|
function
FND_CONCURRENT.WAIT_FOR_REQUEST
(request_id IN number
default NULL, interval IN number default 60, max_wait IN number default 0, phase OUT varchar2, status OUT varchar2, dev_phase OUT varchar2, dev_status OUT varchar2, message OUT varchar2) return
boolean;
|
|
Description
Arguments (input)
|
Waits
for request completion, then returns the request phase/status and completion
message to the caller. Goes to sleep between checks for request completion.
|
|
request_id
|
The
request ID of the request to wait on.
|
|
interval
|
Number
of seconds to wait between checks (i.e., number of seconds to sleep.)
|
|
max_wait
Arguments (output)
|
The
maximum time in seconds to wait for the request's completion.
|
|
phase
|
The
user-friendly request phase from the FND_LOOKUPS table.
|
|
status
|
The
user-friendly request status from the FND_LOOKUPS table.
|
|
dev_phase
|
The
request phase as a constant string that can be used for program logic
comparisons.
|
|
dev_status
|
The
request status as a constant string that can be used for program logic
comparisons.
|
|
message
|
The
completion message supplied if the request has already completed.
|
FND_CONCURRENT.SET_COMPLETION_STATUS (Server)
Summary function
FND_CONCURRENT.SET_COMPLETION_STATUS
(status IN varchar2,
message IN varchar2) return boolean;
|
Description
Arguments (input)
|
Call
SET_COMPLETION_STATUS from a concurrent
program
to set its completion status. The function returns TRUE on success, otherwise
FALSE.
|
|
status
|
The
status to set the concurrent program to. Either
NORMAL,
WARNING, or ERROR.
|
|
message
|
An
optional message.
|
FND_FILE: PL/SQL File I/O
The FND_FILE package
contains procedures to write text to log and output files. These procedures are
supported in all types of concurrent programs.
For testing and
debugging, you can use the procedures FND_FILE.PUT_NAMES and FND_FILE.CLOSE.
Note that these two procedures should not be called from a concurrent program.
FND_FILE supports a
maximum buffer line size of 32K for both log and output files.
Important:
This
package is not designed for generic PL/SQL text I/O, but rather only for
writing to request log and output files.
See: PL/SQL File I/O
Processing, page 17-2
FND_FILE.PUT
|
Summary
|
procedure
FND_FILE.PUT
(which
IN NUMBER, buff IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to write text to a file (without a new line character).
Multiple calls to FND_FILE.PUT will produce
concatenated
text. Typically used with
FND_FILE.NEW_LINE.
|
|
which
|
Log
file or output file. Use either FND_FILE.LOG or FND_FILE.OUTPUT.
|
|
buff
|
Text
to write.
|
FND_FILE.PUT_LINE
|
Summary
|
procedure
FND_FILE.PUT_LINE
(which IN NUMBER, buff IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to write a line of text to a file (followed by a new line
character). You will use this utility most often.
|
|
which
|
Log
file or output file. Use either FND_FILE.LOG or FND_FILE.OUTPUT.
|
|
buff
|
Text
to write.
|
Example
Using Message
Dictionary to retrieve a message already set up on the server and putting it in
the log file (allows the log file to contain a translated message):
FND_FILE.PUT_LINE(
FND_FILE.LOG, fnd_message.get );
Putting a line of text
in the log file directly (message cannot be translated because it is hardcoded
in English; not recommended):
fnd_file.put_line(FND_FILE.LOG,'Warning:
Employee '||
l_log_employee_name||' ('|| l_log_employee_num
|| ') does not
have a manager.');
FND_FILE.NEW_LINE
|
Summary
|
procedure
FND_FILE.NEW_LINE
(which IN NUMBER,
LINES
IN NATURAL := 1);
|
|
Description
Arguments (input)
|
Use
this procedure to write line terminators (new line characters) to a file.
|
|
which
|
Log
file or output file. Use either FND_FILE.LOG or FND_FILE.OUTPUT.
|
|
lines
|
Number
of line terminators to write.
|
Example
To write two new line
characters:
fnd_file.new_line(FND_FILE.LOG,2);
FND_FILE.PUT_NAMES
|
Summary
|
procedure
FND_FILE.PUT_NAMES
(p_log IN VARCHAR2, p_out IN VARCHAR2, (p_dir IN VARCHAR2);
|
|
Description
|
Sets the temporary log and out filenames and the temp
|
directory to the
user-specified values. DIR must be a directory to which the database can write.
FND_FILE.PUT_NAMES
should be called before calling any other FND_FILE function, and only once per
session.
Important:
FND_FILE.PUT_NAMES
is meant for testing and debugging from SQL*Plus; it does nothing if called
from a concurrent program.
BEGIN
fnd_file.put_names('test.log', 'test.out',
'/local/db/8.0.4/db-temp-dir/');
fnd_file.put_line(fnd_file.output,'Called
stored
procedure');
/* Some logic here... */
fnd_file.put_line(fnd_file.output, 'Reached
point A');
/* More logic, etc... */ fnd_file.close; END;
|
Arguments (input)
|
|
|
p_log
|
Temporary
log filename.
|
|
p_out
|
Temporary output filename.
|
|
p_dir
|
Temporary directory name.
|
Example
BEGIN
fnd_file.put_names('test.log', 'test.out',
'/local/db/8.0.4/db-temp-dir/');
fnd_file.put_line(fnd_file.output,'Called
stored
procedure');
/* Some logic here... */
fnd_file.put_line(fnd_file.output, 'Reached
point A');
/* More logic, etc... */ fnd_file.close; END;
FND_FILE.CLOSE
Summary procedure FND_FILE.CLOSE;
Description Use this procedure to
close open files.
Important:
Use
FND_FILE.CLOSE only in command lines sessions.
FND_FILE.CLOSE should
not be called from a concurrent program.
Example
BEGIN
fnd_file.put_names('test.log', 'test.out',
'/local/db/8.0.4/db-temp-dir/'); fnd_file.put_line(fnd_file.output,'Called
stored
procedure');
/* Some logic here... */
fnd_file.put_line(fnd_file.output, 'Reached
point A');
/* More logic, etc... */ fnd_file.close; END;
Error Handling
The FND_FILE package
can raise one exception, FND_FILE.UTL_FILE_ERROR, which is raised to indicate
an UTL_FILE error condition. Specifically, the procedures
FND_FILE.PUT,
FND_FILE.PUT_LINE and FND_FILE.NEW_LINE can raise
FND_FILE.UTL_FILE_ERROR
if there is an error. In addition to this package exception, FND_FILE can also
raise predefined PL/SQL exceptions such as NO_DATA_FOUND or VALUE_ERROR.
FND_FILE will raise a
UTL_FILE_ERROR if it is not able to open or write to a temporary file. It is up
to the concurrent program to error out or complete normally, after the
FND_FILE.UTL_FILE_ERROR exception is raised. FND_FILE keeps the translated
message in the message stack before raising the UTL_FILE_ERROR exception.
Developers can get the message for FND_FILE errors and use it as a Request
Completion text. It is up to the caller to get the message from the message
stack by using the FND_MESSAGE routine within an exception handler.
The concurrent manager
will keep all the temporary file creation errors in the request log file.
FND_PROGRAM: Concurrent Program Loaders
The FND_PROGRAM
package includes procedures for creating concurrent program executables,
concurrent programs with parameters and incompatibility rules, request sets,
and request groups. The FND_PROGRAM package also contains functions you can use
to check for the existence of concurrent programs, executables, parameters, and
incompatibility rules.
The arguments passed
to the procedures correspond to the fields in the Oracle
Application Object
Library forms, with minor exceptions. In general, first enter the parameters to
these procedures into the forms for validation and debugging.
If an error is
detected, ORA-06501: PL/SQL: internal error is raised. The error message can be
retrieved by a call to the function fnd_program.message().
Some errors are not
trapped by the package, notably "duplicate value on index".
Note that an exception
is raised if bad foreign key information is provided. For example,
delete_program() does not fail if the program does not exist, but does fail if
given a bad application name.
FND_PROGRAM.MESSAGE
|
Summary
|
function
FND_PROGRAM.MESSAGE return VARCHAR2;
|
||
|
Description
FND_PROGRAM.EXECUTABLE
|
Use
the message function to return an error message. Messages are set when any
validation (program) errors occur.
|
||
|
Summary
|
procedure
FND_PROGRAM.EXECUTABLE
(executable IN VARCHAR2, application IN VARCHAR2,
description IN VARCHAR2 DEFAULT NULL,
execution_method IN VARCHAR2,
execution_file_name IN VARCHAR2 DEFAULT
NULL, subroutine_name IN VARCHAR2 DEFAULT NULL, icon_name
IN VARCHAR2 DEFAULT NULL,
language_code IN VARCHAR2
DEFAULT 'US');
|
||
|
Description
Arguments (input)
|
Use
this procedure to define a concurrent program executable. This procedure
corresponds to the "Concurrent
Program
Executable" window accessible from the System
Administrator and Application Developer
responsibilities.
|
||
|
executable
|
Name
of executable (for example, 'FNDSCRMT').
|
||
|
application
|
The
short name of the executable's application, for example, 'FND'.
|
||
|
description
|
Optional
description of the executable.
|
||
|
execution_ method
|
The
type of program this executable uses. Possible values are 'Host',
'Immediate', 'Oracle Reports', 'PL/SQL Stored Procedure', 'Spawned',
'SQL*Loader', 'SQL*Plus'.
|
||
|
execution_ file_name
|
The
operating system name of the file. Required for all but Immediate programs.
This file name should not include spaces or periods unless the file is a
PL/SQL stored procedure.
|
||
|
subroutine_name
|
Used
only by Immediate programs. Cannot contain spaces or periods.
|
||
|
icon_name
|
Reserved
for future use by internal developers only. Specify NULL.
|
||
|
language_code
|
Language
code for the name and description, for example, 'US'.
|
||
FND_PROGRAM.DELETE_EXECUTABLE
|
Summary
|
procedure
FND_PROGRAM.DELETE_EXECUTABLE
(executable IN varchar2, application
IN varchar2);
|
|
Description
Arguments (input)
|
Use
this procedure to delete a concurrent program executable. An executable that
is assigned to a concurrent program cannot be deleted.
|
|
executable
|
The
short name of the executable to delete.
|
|
application
|
The
short name of the executable's application, for example 'FND'.
|
FND_PROGRAM.REGISTER
|
Summary
|
procedure
FND_PROGRAM.REGISTER (program IN VARCHAR2, application IN VARCHAR2, enabled IN VARCHAR2, short_name IN VARCHAR2,
description IN VARCHAR2 DEFAULT NULL,
executable_name IN VARCHAR2, executable_application IN VARCHAR2, execution_options IN VARCHAR2 DEFAULT NULL, priority IN NUMBER DEFAULT NULL, save_output IN VARCHAR2 DEFAULT 'Y', print IN VARCHAR2 DEFAULT 'Y', cols
IN NUMBER DEFAULT NULL, rows
IN NUMBER DEFAULT NULL, style IN VARCHAR2 DEFAULT NULL, style_required IN VARCHAR2 DEFAULT 'N', printer IN VARCHAR2 DEFAULT NULL, request_type IN VARCHAR2 DEFAULT NULL, request_type_application IN VARCHAR2 DEFAULT
NULL,
use_in_srs IN VARCHAR2 DEFAULT 'N', allow_disabled_values IN VARCHAR2 DEFAULT
'N',
run_alone IN VARCHAR2 DEFAULT 'N', output_type IN VARCHAR2 DEFAULT 'TEXT', enable_trace IN VARCHAR2 DEFAULT 'N', restart IN VARCHAR2 DEFAULT 'Y', nls_compliant IN VARCHAR2 DEFAULT 'N', icon_name IN VARCHAR2 DEFAULT NULL, language_code IN VARCHAR2 DEFAULT 'US' mls_function_short_name IN VARCHAR2, mls_function_application IN VARCHAR2, incrementor IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to define a concurrent program. This procedure corresponds to
the "Concurrent Program" window accessible from the System
Administrator and Application Developer responsibilities.
|
|
program
|
The
user-visible program name, for example 'Menu Report'.
|
|
application
|
The
short name of the application that owns the program. The program application
determines the Oracle user name used by the program.
|
|
enabled
|
Specify
either "Y" or "N".
|
|
short_name
|
The
internal developer program name.
|
|
description
|
An
optional description of the program.
|
|
executable_name
|
The
short name of the registered concurrent program executable.
|
||
|
executable_ application
|
The
short name of the application under which the executable is registered.
|
||
|
execution_ options
|
Any
special option string, used by certain executables such as Oracle Reports.
|
||
|
priority
|
An
optional program level priority.
|
||
|
save_output
|
Indicate
with "Y" or "N" whether to save the output.
|
||
|
print
|
Allow
printing by specifying "Y", otherwise "N".
|
||
|
cols
|
The
page width of report columns.
|
||
|
rows
|
The
page length of report rows.
|
||
|
style
|
The
default print style name.
|
||
|
style_required
|
Specify
whether to allow changing the default print style from the Submit Requests
window.
|
||
|
printer
|
Force
output to the specified printer.
|
||
|
request_type
|
A
user-defined request type.
|
||
|
request_type_ application
|
The short name of the application owning the request
type.
|
||
|
use_in_srs
|
Specify
"Y" to allow users to submit the program from the Submit Requests
window, otherwise "N".
|
||
|
allow_ disabled_values
|
Specify
"Y" to allow parameters based on outdated value sets to validate
anyway. Specify "N" to require current values.
|
||
|
run_alone
|
Program
must have the whole system to itself. ("Y" or "N")
|
||
|
output_type
|
The
type of output generated by the concurrent program. Either "HTML",
"PS", "TEXT" or "PDF".
|
||
|
enable_trace
|
Specify
"Y" if you want to always enable SQL trace for this program,
"N" if not.
|
||
|
nls_compliant
|
Reserved
for use by internal developers only. Use "N".
|
||
|
icon_name
|
Reserved
for use by internal developers only. Use NULL.
|
||
|
language_code Language code for
the name and description.
mls_function_
short_name The name of the
registered MLS function.
mls_function_ application The short name of
the application under which the MLS function is registered.
incrementor The incrementor
PL/SQL function name.
FND_PROGRAM.DELETE_PROGRAM
|
|||
|
Summary
|
procedure
FND_PROGRAM.DELETE_PROGRAM
(program_short_name IN
varchar2, application IN varchar2);
|
||
|
Description
Arguments (input)
|
Use
this procedure to delete a concurrent program. All references to the program
are deleted as well.
|
||
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
||
|
application
FND_PROGRAM.PARAMETER
|
The
application that owns the concurrent program.
|
||
|
Summary
|
procedure
FND_PROGRAM.PARAMETER
(program_short_name IN VARCHAR2, application IN VARCHAR2, sequence IN NUMBER, parameter IN VARCHAR2,
description IN VARCHAR2 DEFAULT NULL, enabled
IN VARCHAR2 DEFAULT 'Y',
value_set
IN VARCHAR2,
default_type IN VARCHAR2 DEFAULT NULL, default_value IN VARCHAR2 DEFAULT NULL, required
IN VARCHAR2 DEFAULT 'N',
enable_security IN VARCHAR2
DEFAULT 'N', range IN VARCHAR2 DEFAULT NULL, display
IN VARCHAR2 DEFAULT 'Y',
display_size IN NUMBER, description_size IN NUMBER,
concatenated_description_size IN
NUMBER, prompt IN VARCHAR2 DEFAULT NULL, token
IN VARCHAR2 DEFAULT NULL);
|
||
|
Description
|
Creates
a new parameter for a specified concurrent
|
||
program.
This procedure corresponds to the "Concurrent Program Parameters"
window accessible from the System Administrator and Application Developer
responsibilities.
Important:
A
newly added parameter does not show up in the SRS form until the descriptive
flexfields are compiled. The program
$FND_TOP/$APPLBIN/fdfcmp
compiles the descriptive flexfields.
|
Arguments (input)
|
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
|
application
|
The
short name of the application that owns the concurrent program.
|
|
sequence
|
The
parameter sequence number that determines the order of the parameters.
|
|
parameter
|
The
parameter name.
|
|
description
|
An
optional parameter description.
|
|
enabled
|
"Y"
for enabled parameters; "N" for disabled parameters.
|
|
value_set
|
The
value set to use with this parameter.
|
|
default_type
|
An
optional default type. Possible values are 'Constant', 'Profile', 'SQL
Statement', or 'Segment'.
|
|
default_value
|
Only
required if the default_type is not NULL.
|
|
required
|
"Y"
for required parameters, "N" for optional ones.
|
|
enable_security
|
"Y"
enables value security if the value set permits it. "N" prevents
value security from operating on this parameter.
|
|
range
|
Optionally
specify "High", "Low", or "Pair".
|
|
display
|
"Y"
to display the parameter, "N" to hide it.
|
|
display_size
|
The
length of the item in the parameter window.
|
|
description_size
|
The
length of the item's description in the parameter window.
|
|
concatenated_
description_size
|
The
Length of the description in the concatenated parameters field.
|
|
prompt
|
The
item prompt in the parameter window.
|
token The Oracle Reports
token (only used with Oracle Reports programs).
FND_PROGRAM.DELETE_PARAMETER
|
Summary
|
procedure
FND_PROGRAM.DELETE_PARAMETER
(program_short_name IN varchar2, application IN varchar2 parameter IN varchar2);
|
|
Description
Arguments (input)
|
Call
this procedure to remove a parameter from a concurrent program.
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
|
application
|
The
application that owns the concurrent program.
|
|
parameter
FND_PROGRAM.INCOMPATIBILITY
|
The
parameter to delete.
|
|
Summary
|
procedure
FND_PROGRAM.INCOMPATIBILITY
(program_short_name IN VARCHAR2, application IN VARCHAR2 inc_prog_short_name IN VARCHAR2, inc_prog_application IN VARCHAR2,
scope IN VARCHAR2 DEFAULT 'Set');
|
|
Description
Arguments (input)
|
Use
this procedure to register an incompatibility for a specified concurrent
program. This procedure corresponds to the "Incompatible Programs"
window accessible from the System Administrator and Application Developer
responsibilities.
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
|
application
|
The
short name of the application that owns the concurrent program
|
|
inc_prog_ short_name
|
The
short name of the incompatible program.
|
|
inc_prog_ application
|
Application
that owns the incompatible program.
|
scope Either "Set"
or "Program Only"
FND_PROGRAM.DELETE_INCOMPATIBILITY
Summary procedure
FND_PROGRAM.DELETE_INCOMPATIBILITY
(program_short_name IN VARCHAR2, application IN VARCHAR2, inc_prog_short_name IN VARCHAR2, inc_prog_application IN VARCHAR2);
Description Use this procedure to
delete a concurrent program
incompatibility
rule.
Arguments
(input)
program_short_ name The short name used as
the developer name of the concurrent program.
application Application that owns the concurrent program inc_prog_
short_name Short name of the
incompatible program to delete. inc_prog_ application Application
that owns the incompatible program.
FND_PROGRAM.REQUEST_GROUP
Summary procedure
FND_PROGRAM.REQUEST_GROUP
(request_group IN VARCHAR2,
application IN VARCHAR2, code
IN VARCHAR2 DEFAULT NULL,
description IN VARCHAR2 DEFAULT
NULL);
Description Use this procedure to
create a new request group. This procedure corresponds to the master region of
the "Request Groups" window in the System Administration
responsibility.
Arguments
(input)
request_group The name of the request group application The application that owns the request group. code An optional code for the request group.
description An optional
description of the request group.
FND_PROGRAM.DELETE_GROUP
|
Summary
|
procedure
FND_PROGRAM.DELETE_GROUP
(group IN VARCHAR2, application IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to delete a request group.
|
|
request_group
|
The
name of the request group to delete.
|
|
application
FND_PROGRAM.ADD_TO_GROUP
|
The
application that owns the request group.
|
|
Summary
|
procedure
FND_PROGRAM.ADD_TO_GROUP
(program_short_name IN VARCHAR2, program_application IN VARCHAR2, request_group IN VARCHAR2, group_application IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to add a concurrent program to a request group. This procedure
corresponds to the "Requests" region in the "Request
Groups" window in System Administration.
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
|
program_ application
|
The
application that owns the concurrent program.
|
|
request_group
|
The request group to which to add the concurrent
program.
|
|
group_ application
|
The
application that owns the request group.
|
FND_PROGRAM.REMOVE_FROM_GROUP
|
Summary
|
procedure
FND_PROGRAM.REMOVE_FROM_GROUP
(program_short_name IN VARCHAR2, program_application IN VARCHAR2, request_group IN VARCHAR2, group_application IN VARCHAR2);
|
|
Description
|
Use this procedure to remove a concurrent program from
a
|
request
group.
Arguments
(input)
program_short_ name The short name used as
the developer name of the concurrent program.
program_
application The application that
owns the concurrent program.
request_group The request group from
which to delete the concurrent program.
group_
application The application that
owns the request group.
FND_PROGRAM.PROGRAM_EXISTS
Summary function
FND_PROGRAM.PROGRAM_EXISTS
(program IN VARCHAR2,
application IN VARCHAR2) return boolean;
Description Returns TRUE if a
concurrent program exists.
Arguments
(input)
program The short name of the program application Application short name of the program.
FND_PROGRAM.PARAMETER_EXISTS
|
Summary
|
function FND_PROGRAM.PARAMETER_EXISTS
(program_short_name
IN VARCHAR2, application IN VARCHAR2, parameteR
IN VARCHAR2)
return
boolean;
|
|
Description
Arguments (input)
|
Returns TRUE if a program parameter exists.
|
|
program
|
The
short name of the program
|
|
application
|
Application
short name of the program.
|
|
parameter
|
Name
of the parameter.
|
FND_PROGRAM.INCOMPATIBILITY_EXISTS
|
Summary
|
function
FND_PROGRAM.INCOMPATIBILITY_EXISTS
(program_short_name IN VARCHAR2, application IN VARCHAR2, inc_prog_short_name IN VARCHAR2, inc_prog_application IN VARCHAR2)
return
boolean;
|
|
Description
Arguments (input)
|
Returns
TRUE if a program incompatibility exists.
|
|
program
|
The
short name of the first program
|
|
application
|
Application
short name of the program.
|
|
inc_prog_short_ name
|
Short
name of the incompatible program.
|
|
inc_prog_ applicatoin
|
Application short name of the incompatible program.
|
FND_PROGRAM.EXECUTABLE_EXISTS
|
Summary
|
function FND_PROGRAM.EXECUTABLE_EXISTS
(executable_short_name
IN VARCHAR2, application IN VARCHAR2)
return
boolean;
|
|
Description
Arguments (input)
|
Returns
TRUE if program executable exists.
|
|
program
|
The
name of the executable.
|
|
application
|
Application
short name of the executable.
|
FND_PROGRAM.REQUEST_GROUP_EXISTS
|
Summary
|
function FND_PROGRAM.REQUEST_GROUP_EXISTS
(request_group
IN VARCHAR2, application IN VARCHAR2)
return
boolean;
|
|
Description
Arguments (input)
|
Returns
TRUE if request group exists.
|
|
program
|
The
name of the executable.
|
|
application
|
Application
short name of the request group.
|
FND_PROGRAM.PROGRAM_IN_GROUP
Summary function
FND_PROGRAM.INCOMPATIBILITY_EXISTS
(program_short_name IN VARCHAR2,
application IN VARCHAR2, request_group IN VARCHAR2,
group_application IN VARCHAR2)
return boolean;
Description Returns TRUE if a
program is in a request group.
Arguments
(input)
program The short name of the first program. application Application short name of the program. request_group Name of the request group.
group_
application Application short name
of the request group.
FND_PROGRAM.ENABLE_PROGRAM
Syntax procedure FND_PROGRAM_ENABLE_PROGRAM
(short_name IN VARCHAR2,
application IN VARCHAR2, ENABLED
IN VARCHAR2);
Description Use this procedure to
enable or disable a concurrent program.
Arguments
(input)
short_name The shortname of the program. application Application short name of the program.
enabled Specify 'Y' to enable
the program and 'N' to disable the program.
FND_REQUEST Package
FND_REQUEST.SET_OPTIONS (Client or Server)
|
Syntax
|
function
FND_REQUEST.SET_OPTIONS
(implicit IN varchar2 default 'NO', protected IN varchar2 default
'NO', language IN varchar2 default NULL, territory IN varchar2 default
NULL)
return boolean;
|
|
Description
Arguments (input)
|
Optionally
call before submitting a concurrent request to set request options. Returns
TRUE on successful completion, and FALSE otherwise.
|
|
implicit
|
Determines
whether to display this concurrent request in the end-user Concurrent
Requests form. (All requests are automatically displayed in the System
Administrator's privileged Concurrent Requests form, regardless of the value
of this argument.) Specify 'NO', 'YES', 'ERROR', or 'WARNING'.
'NO'
allows the request to be viewed on the end-user Concurrent Requests form.
'YES'
means that the request may be viewed only from the System Administrator's
privileged Concurrent Requests form.
'ERROR'
causes the request to be displayed in the end user Concurrent Requests form
only if it fails.
'WARNING'
allows the request to display in the end-user Concurrent Requests form only
if it completes with a warning or an error.
|
|
protected
|
Indicates
whether this concurrent request is protected against updates made using the
Concurrent Requests form. 'YES' means the request is protected against
updates; 'NO' means the request is not protected.
|
|
language
|
Indicates
the NLS language. If left NULL, defaults to the current language.
|
|
territory
|
Indicates
the language territory. If left NULL, defaults to the current language
territory.
|
FND_REQUEST.SET_REPEAT_OPTIONS (Client or
Server)
|
Summary
|
function
FND_REQUEST.SET_REPEAT_OPTIONS
(repeat_time IN varchar2 default NULL,
repeat_interval IN number default
NULL, repeat_unit IN varchar2
default 'DAYS', repeat_type IN
varchar2 default 'START' repeat_end_time
IN varchar2 default NULL)
return
boolean;
|
|
Description
Arguments (input)
|
Optionally
call before submitting a concurrent request to set repeat options. Returns
TRUE on successful completion, and FALSE otherwise.
|
|
repeat_time
|
Time
of day to repeat the concurrent request, formatted as HH24:MI or HH24:MI:SS.
The only other parameter you may use with repeat_time is repeat_end_time.
|
|
repeat_interval
|
Interval
between resubmissions of the request. Use this parameter along with repeat_unit
to specify the time between resubmissions. This parameter applies only when
repeat_time is NULL.
|
|
repeat_unit
|
The
unit of time used along with repeat_interval to specify the time between
resubmissions of the request. The available units are 'MINUTES', 'HOURS',
'DAYS', and 'MONTHS'. This parameter applies only when repeat_time is NULL.
|
|
repeat_type
|
Determines
whether to apply the resubmission interval from either the 'START' or the
'END' of the request's execution. This parameter applies only when
repeat_time is NULL.
|
|
repeat_end_time
|
The
date and time to stop resubmitting the concurrent request, formatted as either:
'DD-MON-YYYY HH24:MI:SS' or 'DD-MON-RR HH24:MI:SS'
|
FND_REQUEST.SET_PRINT_OPTIONS (Client or
Server)
|
Summary
|
function
FND_REQUEST.SET_PRINT_OPTIONS
(printer IN varchar2 default NULL, style IN varchar2 default NULL, copies IN number default NULL, save_output IN boolean default TRUE,
print_together IN varchar2 default
'N')
return
boolean;
|
|
Description
|
Optionally call before submitting a concurrent request
to
|
set print options.
Returns TRUE on successful completion, and FALSE otherwise.
Important:
Some
print options that are set at the program level (i.e., using the Concurrent
Programs form) cannot be overridden using this procedure. See the following
argument descriptions to determine which print options can be overridden.
|
Arguments (input)
|
|
|
printer
|
Name
of the printer to which concurrent request output should be sent. You cannot
override this print option if it was already set using the Concurrent
Programs form.
|
|
style
|
Style
used to print request output, for example 'Landscape' or 'Portrait'. (Valid print
styles are defined using the Print Styles form.) If the Style option was
already set using the Concurrent Programs form, and the Style Required check
box is checked, you cannot override this print option.
|
|
copies
|
Number
of copies of request output to print. You can override this print option even
if it was already set using the Concurrent Programs form.
|
|
save_output
|
Indicates
whether to save the output file. Valid values are TRUE and FALSE. You can
override this print option even if it was already set using the Concurrent
Programs form.
|
|
print_together
|
This
parameter applies only to requests that contain sub-requests. 'Y' indicates
that output of sub-requests should not be printed until all sub-requests
complete. 'N' indicates that the output of each sub-request should be printed
as it completes.
|
FND_REQUEST.SUBMIT_REQUEST (Client or Server)
|
Summary
|
function
FND_REQUEST.SUBMIT_REQUEST
(application IN varchar2 default NULL, program IN varchar2 default NULL,
description IN varchar2 default
NULL, start_time IN varchar2
default NULL, sub_request IN
boolean default FALSE
argument1,
argument2, ..., argument99,
argument100) return number;
|
|
Description
|
Submits a concurrent request for processing by a
|
concurrent manager. If
the request completes successfully, this function returns the concurrent
request ID; otherwise, it returns 0.
The
FND_REQUEST.SUBMIT_REQUEST function returns
the concurrent request
ID upon successful completion. It is then up to the caller to issue a commit to
complete the request submission.
Your code should
retrieve and handle the error message generated if there is a submission
problem (the concurrent request ID returned is 0). Use FND_MESSAGE.RETRIEVE and
FND_MESSAGE.ERROR to retrieve and display the error (if the request is
submitted from the client side). See: Overview of Message Dictionary, page 12-1
You must call
FND_REQUEST.SET_MODE before calling FND_REQUEST.SUBMIT_REQUEST from a database
trigger.
If
FND_REQUEST.SUBMIT_REQUEST fails from anywhere but a database trigger, database
changes are rolled back up to the point of the function call.
After a call to the
FND_REQUEST.SUBMIT_REQUEST function, all setup parameters are reset to their
default values.
Important:
FND_REQUEST
must know information about the user and responsibility from which the request
is submitted. Therefore, this function only works from concurrent programs or
forms within Oracle Applications.
Arguments
(input)
application Short name of the
application associated with the
concurrent
request to be submitted.
program Short name of the
concurrent program (not the executable)
for which the request
should be submitted.
description Description of the
request that is displayed in the Concurrent Requests form (Optional.)
start_time Time at which the
request should start running, formatted as HH24:MI or HH24:MI:SS (Optional.)
sub_request Set to TRUE if the
request is submitted from another request and should be treated as a
sub-request.
This parameter can be
used if you are submitting requests from within a PL/SQL stored procedure
concurrent program.
argument1...100 Arguments for the
concurrent request; up to 100 arguments are permitted. If submitted from Oracle
Forms, you must specify all 100 arguments.
FND_REQUEST.SET_MODE (Server)
Summary function FND_REQUEST.SET_MODE
(db_trigger IN boolean) return boolean;
Description Call this function
before calling
FND_REQUEST.SUBMIT_REQUEST
from a database trigger.
Note that a failure in
the database trigger call of FND_REQUEST.SUBMIT_REQUEST does not roll back
changes. Arguments (input) db_trigger Set
to TRUE if request is submitted from a database trigger.
Example Request Submissions
/* Example 1 */
/* Submit a request from a
form and commit*/
:parameter.req_id :=
FND_REQUEST.SUBMIT_REQUEST (
:blockname.appsname,
:blockname.program,
:blockname.description,
:blockname.start_time,
:blockname.sub_req = 'Y',
123, NAME_IN('ORDERS.ORDER_ID'),
'abc', chr(0), '', '', '', '',
'', '',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '',
'',
'', '', '', '', '', '', '', '', '',
'');
IF :parameter.req_id = 0 THEN
FND_MESSAGE.RETRIEVE;
FND_MESSAGE.ERROR;
ELSE
IF :SYSTEM.FORM_STATUS != 'CHANGED' THEN
IF app_form.quietcommit THEN
/*form commits without asking user to
save changes*/
fnd_message.set_name('SQLGL', 'GL_REQUEST_SUBMITTED'); fnd_message.set_TOKEN('REQUEST_ID',
TO_CHAR(:PARAMETER.REQ_ID), FALSE);
fnd_message.show;
ELSE
fnd_message.set_name('FND',
'CONC-REQUEST SUBMISSION FAILED');
fnd_message.error;
END IF;
ELSE
DO_KEY('COMMIT_FORM');
IF :SYSTEM.FORM_STATUS != 'CHANGED' THEN
/*commit was successful*/ fnd_message.set_name('SQLGL', 'GL_REQUEST_SUBMITTED'); fnd_message.set_TOKEN('REQUEST_ID',
TO_CHAR(:PARAMETER.REQ_ID),
FALSE);
fnd_message.show;
END IF;
END IF;
END IF;
/* Example 2 */
/* Submit a request where no
setup is required */
declare req_id number; begin
req_id := FND_REQUEST.SUBMIT_REQUEST ('FND',
'FNDMDGEN', 'Message File
Generator',
'01-NOV-02 00:00:00', FALSE,
...arguments...);
if (req_id = 0) then
/* Handle submission error */
FND_MESSAGE.RETRIEVE;
FND_MESSAGE.ERROR;
else
commit; end if; end; /* Example
3 */
/* Submit a request from a
database trigger */ result := FND_REQUEST.SET_MODE(TRUE); req_id :=
FND_REQUEST.SUBMIT_REQUEST (FND',
'FNDMDGEN', 'Message File Generator',
'01-NOV-02 00:00:00', FALSE,
...arguments...);
/* Example 4 */
/* Submit a request inserting
NULL arguments.
This call inserts 6 arguments with arguments
1, 3,
4, and 6 being NULL */
req_id :=
FND_REQUEST.SUBMIT_REQUEST ('FND',
'FNDPROG',
'Description of
FNDPROG',
'01-FEB-01 00:00:00',
FALSE,
'', 'arg2', '', NULL,
arg5, '');
/* Example 5 */
/* Submit a repeating request
*/
result :=
FND_REQUEST.SET_REPEAT_OPTIONS ('', 4, 'HOURS', 'END');
req_id :=
FND_REQUEST.SUBMIT_REQUEST ('CUS',
'CUSPOST', 'Custom
Posting',
'01-APR-01 00:00:00',
FALSE,
...arguments...);
Important:
You
may not want to submit a request if
FND_REQUEST.SET_REPEAT_OPTIONS
returns failure. Thus, you may wish to test the result of
FND_REQUEST.SET_REPEAT_OPTIONS before issuing the call to
FND_REQUEST.SUBMIT_REQUEST.
/* Example 6 */
/* Submit a request for 5
copies of a menu report */ result := FND_REQUEST.SET_PRINT_OPTIONS ('hqunx138',
'Landscape',
5,
'Yes',
FALSE); req_id := FND_REQUEST.SUBMIT_REQUEST ('FND', 'FNDMNRMT',
'',
'',
'N', 0, 101);
/* Example 7 */
/* Submit a protected request
that repeats at noon */
result :=
FND_REQUEST.SET_OPTIONS ('YES'); result := FND_REQUEST.SET_REPEAT_OPTIONS
('12:00'); req_id := FND_REQUEST.SUBMIT_REQUEST ('CUS',
'CUSPOST', 'Custom Posting',
'01-APR-01
00:00:00', FALSE,
... args ...);
FND_REQUEST_INFO and Multiple Language
Support (MLS)
FND_REQUEST_INFO APIs
can be used in multi-language support functions (MLS functions) to get
information for a request.
A multi-language
support function is a function that supports running concurrent programs in
multiple languages. A user can submit a single request for a concurrent program
and have that program run several times, each time in a different language. An
MLS function determines the language(s) in which a request should run.
To enable this
functionality, a developer creates an MLS function as a stored function in the
database. When called, the function determines which languages are to be used
for the concurrent program's data set and returns the list of language codes as
a comma-delimited string. The string is then used by the concurrent manager to
submit child requests for the concurrent program for each target language.
The MLS function can
use the FND_REQUEST_INFO APIs to retrieve the concurrent program application
short name, the concurrent program short name, and the concurrent request
parameters if needed.
The developer
registers the MLS function in the Concurrent Program Executable form, and then
associates the registered MLS function with a concurrent program in the
Concurrent Programs form.
FND_REQUEST_INFO.GET_PARAM_NUMBER
Summary function GET_PARAM_NUMBER
(name IN VARCHAR2, param_num OUT NUMBER);
|
Description
Arguments (input)
|
Use
this function to retrieve the parameter number for a given parameter name.
The function will return -1 if it fails to retrieve the parameter number.
|
|
name
|
The
name of the parameter of the request's concurrent program.
|
FND_REQUEST_INFO.GET_PARAM_INFO
|
Summary
|
function
GET_PARAM_INFO
(param_num IN NUMBER,
name OUT VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this function to retrieve the parameter name for a given parameter number.
The function will return -1 if it fails to retrieve the parameter name.
|
|
param_num
|
The
number of the parameter of the request's concurrent program.
|
FND_REQUEST_INFO.GET_PROGRAM
|
Summary
|
procedure
GET_PROGRAM
(program_name OUT VARCHAR2, program_app_name OUT VARCHAR2);
|
|
Description
Arguments (input)
|
This
procedure returns the developer concurrent program name and application short
name.
|
|
prog_name
|
The
name of the concurrent program.
|
|
prog_app_name
|
The
concurrent program's application short name.
|
FND_REQUEST_INFO.GET_PARAMETER
|
Summary
|
function
GET_PARAMETER
(param_num IN NUMBER) return varchar2;
|
|
Description
|
This function returns the concurrent request's
parameter
|
value for a given
parameter number. The function will return the value as varchar2.
Arguments
(input)
param_num The number of the
parameter of the request's concurrent program.
Example MLS Function
Suppose you have a
concurrent program that will send each employee a report of his or her
available vacation days. Assume that the concurrent program will accept a range
of employee numbers as parameters. The employees all want to receive the
vacation days report in their preferred language. Without an MLS function, the
user who submits this concurrent program has to guess at all the preferred
languages for the given range of employee numbers and select those languages
while submitting the request. Selecting all installed languages might be a
waste of resources, because output may not be required in all installed
languages.
Assume you have an
employees table (emp) with the following columns:
emp_no number(15),
...
preferred_lang_code varchar2(4), ...
Your concurrent
program has two parameters for the range of employee numbers: parameter 1 is
the starting emp_no and parameter 2 is the ending emp_no.
This MLS function
could be used for other concurrent programs that have the same parameters for
starting and ending employee numbers.
Example
CREATE OR REPLACE FUNCTION
EMPLOYEE_LANG_FUNCTION RETURN VARCHAR2 IS
language_string varchar2(240); start_value varchar2(240); end_value varchar2(240);
CURSOR language_cursor (starting number,
ending number) IS
SELECT DISTINCT(preferred_lang_code)
language_code
FROM
emp
WHERE emp_no BETWEEN starting AND ending
AND
preferred_lang_code IS NOT NULL;
BEGIN
-- Initialize the language string language_string := null;
-- Get parameter values for starting and
-- ending EMP_NO
start_value :=
FND_REQUEST_INFO.GET_PARAMETER(1); end_value
:= FND_REQUEST_INFO.GET_PARAMETER(2);
FOR languages IN language_cursor(
to_number(start_value), to_number(end_value))
LOOP
IF( language_string IS NULL ) THEN
language_string :=
languages.language_code;
ELSE
language_string := language_string
|| ',' ||
languages.language_code;
END IF;
END LOOP;
RETURN (language_string);
END EMPLOYEE_LANG_FUNCTION;
FND_SET: Request Set Loaders
The FND_SET package
includes procedures for creating concurrent program request sets, adding
programs to a request set, deleting programs from a request set. and defining
parameters for request sets.
The arguments passed
to the procedures correspond to the fields in the Oracle Application Object
Library forms, with minor exceptions. In general, first enter the parameters to
these procedures into the forms for validation and debugging.
If an error is detected,
ORA-06501: PL/SQL: internal error is raised. The error message can be retrieved
by a call to the function fnd_program.message().
Some errors are not
trapped by the package, notably "duplicate value on index".
Note that an exception
is raised if bad foreign key information is provided. For example,
delete_program() does not fail if the program does not exist, but does fail if
given a bad application name.
See: Overview of
Request Sets, page 23-1
FND_SET.MESSAGE
|
Summary
|
function
FND_SET.MESSAGE return VARCHAR2;
|
|
|
Description
FND_SET.CREATE_SET
|
Use
the message function to return an error message. Messages are set when any
validation (program) errors occur.
|
|
|
Summary
|
procedure
FND_SET.CREATE_SET
(name IN VARCHAR2, short_name IN VARCHAR2, application IN VARCHAR2, description IN VARCHAR2 DEFAULT
NULL,
owner IN VARCHAR2 DEFAULT
NULL,
start_date IN DATE DEFAULT
SYSDATE,
end_date IN DATE DEFAULT
NULL,
print_together IN VARCHAR2 DEFAULT
'N',
incompatibilities_allowed IN VARCHAR2 DEFAULT
'N',
language_code IN VARCHAR2 DEFAULT
'US');
|
|
|
Description
Arguments (input)
|
Use
this procedure to register a Request Set. This procedure corresponds to the
master region of the "Request Set" window.
|
|
|
name
|
The
name of the new request set.
|
|
|
short_name
|
The
short name for the request set.
|
|
|
application
|
The
application that owns the request set.
|
|
|
description
|
An
optional description of the set.
|
|
|
owner
|
An
optional Oracle Applications user ID identifying the set owner, for example
SYSADMIN.
|
|
|
start_date
|
The
date the set becomes effective.
|
|
|
end_date
|
An
optional date on which the set becomes outdated.
|
|
|
print_together
|
Specify
"Y" or "N" to indication whether all the reports in a set
should print at the same time.
|
|
|
incompatibilities
_allowed
|
Specify
"Y" or "N" to indicate whether to allow incompatibilities
for this set.
|
|
|
language_code
FND_SET.DELETE_SET
|
Language
code for the above data, for example "US".
|
|
|
Summary
|
procedure
FND_SET.DELETE_SET
(request_set IN VARCHAR2, application
IN VARCHAR2);
|
|
|
Description
Arguments (input)
|
Use
this procedure to delete a request set and references to that set.
|
|
|
request_set
|
The
short name of the request set to delete.
|
|
|
application
FND_SET.ADD_PROGRAM
|
The
application that owns the request set.
|
|
|
Summary
|
procedure
FND_SET.ADD_PROGRAM
(program IN VARCHAR2, program_application IN VARCHAR2, request_set IN VARCHAR2, set_application IN VARCHAR2, stage IN VARCHAR2, program_sequence IN NUMBER, critical IN VARCHAR2
DEFAULT
'Y',
number_of_copies IN NUMBER
DEFAULT
0,
save_output IN VARCHAR2
DEFAULT
'Y',
style IN VARCHAR2
DEFAULT
NULL,
printer IN VARCHAR2
DEFAULT
NULL);
|
|
|
Description
|
Use
this procedure to add a concurrent program to a
|
|
request set stage.
This procedure corresponds to the "Programs" region in the
"Stage Requests" window of the "Request Set" form.
|
Arguments (input)
|
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program, for example
'FNDSCRMT'.
|
|
program_ application
|
The
short name of the application that owns the concurrent program.
|
|
request_set
|
The
short name of the request set.
|
|
set_application
|
The
application that owns the request set.
|
|
stage
|
The
short name of the stage.
|
|
program_ sequence
|
The
sequence number of this program in the stage. All programs in a stage require
a unique sequence number.
|
|
critical
|
Specify
'Y' if this program can affect the stage's outcome, and 'N' if not.
|
|
number_of_ copies
|
An
optional default for the number of copies to print.
|
|
save_output
|
Specify
'Y' to allow users to save output, or 'N' if the default is not to save the
output.
|
|
style
|
Optionally
provide a default print style.
|
|
printer
FND_SET.REMOVE_PROGRAM
|
Optionally
provide a default printer.
|
|
Summary
|
procedure
FND_SET.REMOVE_PROGRAM
(program_short_name IN VARCHAR2, program_application IN VARCHAR2, request_set IN VARCHAR2, set_application IN VARCHAR2, stage IN VARCHAR2, program_sequence IN NUMBER);
|
|
Description
Arguments (input)
|
Use
this procedure to remove a concurrent program from a request set.
|
|
program_short_ name
|
The
short name used as the developer name of the concurrent program.
|
|
program_ application
|
The
short name of the application that owns the concurrent program.
|
request_set The short name of the request set. set_application The short name of the application that owns
the request set.
program_ sequence The sequence number of
this program in the stage. All programs in a stage require a unique sequence
number.
FND_SET.PROGRAM_PARAMETER
Summary procedure
FND_SET.PROGRAM_PARAMETER
(program IN VARCHAR2, program_application IN VARCHAR2, request_set IN VARCHAR2, set_application IN VARCHAR2, stage
IN VARCHAR2.
program_sequence IN NUMBER,
parameter IN VARCHAR2,
display IN VARCHAR2 DEFAULT 'Y', modify IN VARCHAR2 DEFAULT 'Y', shared_parameter IN VARCHAR2 DEFAULT
NULL,
default_type IN VARCHAR2 DEFAULT NULL, default_value IN VARCHAR2 DEFAULT NULL);
Description This procedure
registers shared parameter information and the request set level overrides of
program parameter attributes. This procedure corresponds to the "Request
Parameters" window of the "Request Sets" form.
Arguments
(input)
program The short name used as
the developer name of the concurrent program.
program_ application The short name of the
application that owns the concurrent program.
request_set The short name of the request set. set_application The short name of the application that owns
the request set. program_ sequence The
sequence number of this program in the stage.
parameter The name of the program parameter. display "Y" to display the parameter,
"N" to hide it.
modify "Y" to allow
users to modify the parameter value, "N" to
prevent
it.
|
shared_parameter
|
If
the parameter uses a shared parameter, enter the shared parameter name here.
|
|
default_type
|
If
the parameter uses a default, enter the type here. Valid types are
'Constant', 'Profile', 'SQL Statement', or 'Segment'.
|
|
default_value
|
If
the parameter uses a default, enter a value appropriate for the default type
here. This argument is required if default_type is not null.
|
FND_SET.DELETE_PROGRAM_PARAMETER
|
Summary
|
procedure
FND_SET.DELETE_SET_PARAMETER
program IN VARCHAR2, program_application IN VARCHAR2,
request_set IN VARCHAR2 DEFAULT NULL,
stage IN VARCHAR2, set_application IN VARCHAR2, program_sequence IN NUMBER, parameter IN VARCHAR2);
|
|
Description
Arguments (input)
|
This
procedure removes a concurrent program request set parameter from a request
set definition.
|
|
program
|
The
short name used as the developer name of the concurrent program.
|
|
program_ application
|
The
short name of the application that owns the concurrent program.
|
|
request_set
|
The
short name of the request set.
|
|
set_application
|
The short name of the application that owns the request
set.
|
|
program_ sequence
|
The
sequence number of this program in the set. All programs in a stage require a
unique sequence number.
|
|
parameter
|
The
name of the program parameter to delete.
|
FND_SET.ADD_STAGE
|
Summary
|
procedure
FND_SET.ADD_STAGE
(name IN VARCHAR2,
request_set IN VARCHAR2,
set_application IN VARCHAR2,
short_name IN VARCHAR2,
description IN
VARCHAR2 DEFAULT NULL,
display_sequence IN NUMBER,
function_short_name IN VARCHAR2 DEFAULT
'FNDRSSTE'
function_application IN VARCHAR2 DEFAULT
'FND',
critical IN VARCHAR2 DEFAULT 'N',
incompatibilities_allowed IN VARCHAR2
DEFAULT
'N',
start_stage IN VARCHAR2 DEFAULT 'N',
language_code IN VARCHAR2 DEFAULT
'US');
|
||
|
Description
Arguments (input)
|
Adds
a stage to a request set. This procedure corresponds to the
"Stages" window of the "Request Sets" window.
|
||
|
name
|
The
name of the stage.
|
||
|
request_set
|
The
short name of the request set.
|
||
|
set_application
|
The
application that owns the request set.
|
||
|
short_name
|
The
stage short (non-translated) name.
|
||
|
description
|
Description
of the stage.
|
||
|
function_ short_name
|
Accept
the default, "FNDRSSTE", the Standard Stage Evaluation function.
|
||
|
function_ application
|
The
short name of the application owning the function. The default is
"FND".
|
||
|
function_ application
|
Accept
the default, "FND".
|
||
|
critical
|
Specify
"Y" if the return value of this stage affects the completion status
of the request set, and "N" if it does not.
|
||
|
start_stage
|
Specify
"Y" or "N" to indicate whether this stage is the start
stage for the set.
|
||
|
incompatibilities _allowed
|
Specify
"Y" or "N" to indicate whether to allow incompatibilities
for this stage.
|
||
|
language_code
FND_SET.REMOVE_STAGE
|
The
language code for the above data.
|
||
|
Summary
|
procedure
FND_SET.REMOVE_STAGE
(request_set IN VARCHAR2, set_application IN VARCHAR2, stage
IN VARCHAR2);
|
||
|
Description
Arguments (input)
|
Use
this procedure to delete a stage from a request set.
|
||
|
request_set
|
The
short name of the request set.
|
||
|
set_application
|
The short name of the application that owns the request
set.
|
||
|
stage
FND_SET.LINK_STAGES
|
The
short name of the stage to be removed.
|
||
|
Summary
|
procedure
FND_SET.LINK_STAGES
|
||
(request_set IN VARCHAR2, set_application IN VARCHAR2, from_stage
IN VARCHAR2, to_stage IN VARCHAR2 DEFAULT NULL, success
IN VARCHAR2 DEFAULT 'N',
warning IN VARCHAR2 DEFAULT
'N', error IN VARCHAR2 DEFAULT 'N');
Description Use this procedure to
link two stages.
Important:
This
procedure updates the specified links. Sets created by FND_SET.CREATE_SET have
null links between stages by default.
|
Arguments (input)
|
|
||
|
request_set
|
The
short name of the request set.
|
||
|
set_application
|
The application that owns the request set.
|
||
|
from_stage
|
The
short name of the "from" stage.
|
||
|
to_stage
|
The
short name of the "to" stage.
|
||
|
success
|
Create
success link. Specify 'Y' or 'N'.
|
||
|
warning
|
Create
warning link. Specify 'Y' or 'N'.
|
||
|
error
FND_SET.INCOMPATIBILITY
|
Create
error link. Specify 'Y' or 'N'.
|
||
|
Summary
|
procedure
FND_SET.INCOMPATIBILITY
(request_set IN VARCHAR2, application IN VARCHAR2, stage
IN VARCHAR2 DEFAULT NULL,
inc_prog IN VARCHAR2
DEFAULT NULL inc_prog_application IN
VARCHAR2 DEFAULT NULL,
inc_request_set IN VARCHAR2
DEFAULT NULL, inc_set_application IN VARCHAR2 DEFAULT NULL, inc_stage IN VARCHAR2 DEFAULT NULL);
|
||
|
Description
Arguments (input)
|
Use
this procedure to register an incompatibility for a set or stage. Examples
are given below.
|
||
|
request_set
|
The
short name of the request set.
|
||
|
application
|
The short name of the application that owns the request
set.
|
||
|
stage
|
The
short name of the stage (for stage incompatibility).
|
||
|
inc_prog
|
Short
name of the incompatible program.
|
||
|
inc_prog_ application
|
Application
that owns the incompatible program.
|
||
|
inc_request_set
|
Short
name of the incompatible request set.
|
||
|
inc_set_ application
|
The
short name of the application that owns the incompatible request set.
|
||
|
inc_stage
|
Short
name of the incompatible stage.
|
||
Examples
1.
Set X is incompatible with program Y:
fnd_set.incompatibility(request_set=>'X'
application=>'APPX'
inc_prog_short_name=>'Y', inc_prog_application=>'APPY');
2.
Set X is incompatible with set Y:
fnd_set.incompatibility(request_set=>'X', application=>'APPX',
inc_request_set=>'Y',
inc_set_application=>'APPY');
3.
Set X is incompatible with stage 2 of set Y:
fnd_set.incompatibility(request_set=>'X', application=>'APPX',
inc_request_set=>'Y',
inc_set_application=>'APPY', inc_stage_number=>2);
4.
Stage 3 of set X is incompatible with program Y:
fnd_set.incompatibility(request_set=>'X', application=>'APPX',
stage_number=>3,
inc_prog_short_name=>'Y',
inc_prog_application=>'APPY');
FND_SET.DELETE_INCOMPATIBILITY
|
Summary
|
procedure
FND_SET.DELETE_INCOMPATIBILITY
(request_set IN VARCHAR2, application IN VARCHAR2, stage
IN VARCHAR2 DEFAULT NULL,
inc_prog IN VARCHAR2
DEFAULT NULL inc_prog_application IN
VARCHAR2 DEFAULT NULL,
inc_request_set IN VARCHAR2
DEFAULT NULL, inc_set_application IN VARCHAR2 DEFAULT NULL, inc_stage IN VARCHAR2 DEFAULT NULL);
|
|
Description
Arguments (input)
|
Use
this procedure to delete a request set incompatibility rule.
|
|
request_set
|
The
short name of the request set.
|
|
application
|
The short name of the application that owns the request
set.
|
|
stage
|
The
short name of the stage (for stage incompatibility).
|
|
inc_prog
|
Short
name of the incompatible program.
|
|
inc_prog_ application
|
Application
that owns the incompatible program.
|
|
inc_request_set
|
Short
name of the incompatible request set.
|
|
inc_set_ application
|
The
short name of the application that owns the incompatible request set.
|
|
inc_stage
|
Short
name of the incompatible stage.
|
FND_SET.ADD_SET_TO_GROUP
|
Summary
|
procedure
FND_SET.ADD_SET_TO_GROUP
(request_set IN
VARCHAR2, set_application IN
VARCHAR2, request_group IN VARCHAR2, group_application IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to add a request set to a request group. This procedure
corresponds to the "Requests" region in the "Request
Groups" window in System Administration.
|
|
request_set
|
The
short name of the request set to add to the request group.
|
|
set_application
|
The
application that owns the request set.
|
|
request_group
|
The
request group to which to add the request set.
|
|
group_ application
|
The
application that owns the request group.
|
FND_SET.REMOVE_SET_FROM_GROUP
|
Summary
|
procedure
FND_SET.REMOVE_SET_FROM_GROUP
(request_set IN VARCHAR2, set_application IN VARCHAR2, request_group IN VARCHAR2, group_application IN VARCHAR2);
|
|
Description
Arguments (input)
|
Use
this procedure to remove a request set from a request group.
|
|
request_set
|
The
short name of the request set to remove from the request group.
|
|
set_application
|
The
application that owns the request set.
|
|
request_group
|
The
request group from which to remove the request set.
|
|
group_ application
|
The
application that owns the request group.
|
FND_SUBMIT: Request Set Submission
This document
describes the FND_SUBMIT APIs for request set submission. The APIs are
described in the order that they would be called. Some of these APIs are
optional.
FND_SUBMIT.SET_MODE
|
Summary
|
function
FND_SUBMIT.SET_MODE (db_trigger IN
boolean)
return boolean;
|
|
Description
Arguments (input)
|
Use
this optional procedure to set the mode if the request
set is submitted from a database trigger. Call this
function
before
calling FND_SUBMIT.SET_REQUEST_SET from a
database
trigger. Note that a failure in the database trigger call of FND_SUBMIT.SUBMIT_SET
does not rollback changes.
|
|
db_trigger
|
Set
to TRUE if the request set is submitted from a database trigger.
|
FND_SUBMIT.SET_REL_CLASS_OPTIONS
|
Summary
|
function
FND_SUBMIT.SET_REL_CLASS_OPTIONS
(application IN varchar2 default NULL, class_name
IN varchar2 default NULL,
cancel_or_hold IN varchar2 default 'H', stale_date
IN varchar2 default NULL)
return
boolean;
|
|
Description
Arguments (input)
|
Call
this function before calling
FND_SUBMIT.SET_REQUEST_SET
to use the advanced scheduling feature. If both
FND_SUBMIT.SET_REL_CLASS_OPTIONS
and
FND_SUBMIT.SET_REPEAT_OPTIONS
are set then FND_SUBMIT.SET_REL_CLASS_OPTIONS will take
precedence.
This function returns TRUE on successful completion, and FALSE otherwise.
|
|
application
|
The
short name of the application associated with the release class.
|
|
class_name
|
Developer
name of the release class.
|
|
cancel_or_hold
|
Cancel
or Hold flag.
|
|
stale_date
|
Cancel
this request on or after this date if the request has not yet run.
|
FND_SUBMIT.SET_REPEAT_OPTIONS
|
Summary
|
function
FND_SUBMIT.SET_REPEAT_OPTIONS
(repeat_time IN varchar2 default NULL, repeat_interval IN number default NULL, repeat_unit IN varchar2 default 'DAYS', repeat_type IN varchar2 default 'START', repeat_end_time IN varchar2 default NULL)
return
boolean;
|
|
Description
Arguments (input)
|
Optionally call this function to set the repeat options
for the
request
set before submitting a concurrent request set. If both
FND_SUBMIT.SET_REL_CLASS_OPTIONS and FND_SUBMIT.SET_REPEAT_OPTIONS were set
then
FND_SUBMIT.SET_REL_CLASS_OPTIONS
will take the percedence. Returns TRUE on successful completion, and FALSE
otherwise.
|
|
repeat_time
|
Time
of day at which the request set is to be repeated.
|
|
repeat_interval
|
Frequency
at which the request set is to be repeated.
|
|
repeat_unit
|
Unit
for the repeat interval. The default is DAYS. Valid values are MONTHS, DAYS,
HOURS, and MINUTES.
|
|
repeat_type
|
The
repeat type specifies whether the repeat interval should apply from the start
or end of the previous request.
Valid
values are START or END. Default value is START.
|
|
repeat_end_time
FND_SUBMIT_SET.REQUEST_SET
|
Time
at which the repetitions should end.
|
|
Summary
|
function
FND_SUBMIT.SET_REQUEST_SET
(application
IN VARCHAR2,
request_set IN VARCHAR2) return
boolean;
|
|
Description
|
This
function sets the request set context. Call this function at the very
beginning of the submission of a concurrent
request
set transaction. Call this function after calling the optional functions
FND_SUBMIT.SET_MODE,
FND_SUBMIT.SET_REL_CLASS,
FND_SUBMIT.SET_REPEAT_OPTIONS.
It returns TRUE on successful completion, and FALSE otherwise.
|
Arguments
(input)
request_set The short name of
request set (the developer name of the
request
set).
application The short name of the
application that owns the request set.
FND_SUBMIT.SET_PRINT_OPTIONS
Summary function
FND_SUBMIT.SET_PRINT_OPTIONS
(printer IN varchar2 default NULL, style
IN varchar2 default NULL, copies IN number default NULL, save_output
IN boolean default
print_together IN varchar2
default 'N') return boolean;
Description Call this function
before submitting the request if the
printing of output has
to be controlled with specific printer/style/copies, etc. Optionally call for
each program in the request set. Returns TRUE on successful completion, and
FALSE otherwise.
Arguments
(input)
printer Printer name for the
output. style Print style to be used
for printing. copies Number of copies to
print.
save_output Specify TRUE if the
output should be saved after printing, otherwise FALSE. The default is TRUE.
print_together This argument applies
only for subrequests. If 'Y', then output will not be printed untill all the
subrequests are completed. The default is 'N'.
FND_SUBMIT.ADD_PRINTER
Summary function
FND_SUBMIT.SET.ADD_PRINTER
(printer IN varchar2 default null, copies
IN number default null) return
boolean;
Description Call this function
after you set print options to add a printer to the printer list. Optionally
call for each program in the request set. Returns TRUE on successful
completion, and FALSE otherwise.
|
Arguments (input)
|
|
|
printer
|
Printer
name where the request output should be sent.
|
|
copies
FND_SUBMIT.ADD_NOTIFICATION
|
Number
of copies to print.
|
|
Summary
|
function
FND_SUBMIT.ADD_NOTIFICATION (user IN
varchar2) return boolean;
|
|
Description
Arguments (input)
|
This
function is called before submission to add a user to the notification list.
Optionally call for each program in the request set. This function returns
TRUE on successful completion, and FALSE otherwise.
|
|
user
FND_SUBMIT.SET_NLS_OPTIONS
|
User
name.
|
|
Summary
|
function
FND_SUBMIT.SET_NLS_OPTIONS
(language IN varchar2 default NULL, territory
IN varchar2 default NULL) return
boolean;
|
|
Description
Arguments (input)
|
Call
this function before submitting request. This function sets request
attributes. Optionally call for each program in the request set. This
function returns TRUE on successful completion, and FALSE otherwise.
|
|
implicit
|
Nature
of the request to be submitted.
|
|
protected
|
Whether
the request is protected against updates.
|
|
language
|
The
NLS language.
|
|
territory
FND_SUBMIT.SUBMIT_PROGRAM
|
The
language territory.
|
|
Summary
|
function
FND_SUBMIT.SUBMIT_PROGRAM
|
(application IN
varchar2, program IN varchar2, stage
IN varchar2,
argument1,...argument100) return boolean;
|
Description
Arguments (input)
|
Call
FND_SUBMIT.SET_REQUEST_SET function before
calling
this function to set the context for the report set submission. Before
calling this function you may want to
call
the optional functions SET_PRINT_OPTIONS,
ADD_PRINTER,
ADD_NOTIFICATION,
SET_NLS_OPTIONS.
Call this function for each program
(report)
in the request set. You must call fnd_submits.set_request_set before calling
this function. You have to call fnd_submit.set_request_set only once for all
the submit_program calls for that request set.
|
|
application
|
Short
name of the application associated with the program within a report set.
|
|
program
|
Name
of the program with the report set.
|
|
stage
|
Developer
name of the request set stage that the program belongs to.
|
|
argument1...100
FND_SUBMIT.SUBMIT_SET
|
Arguments
for the program
|
|
Summary
|
function
FND_SUBMIT.SUBMIT_SET
(start_time
IN varchar2 default null,
sub_request IN boolean default FALSE)
return
integer;
|
|
Description
Arguments (input)
|
Call this function to submit the request set which is
set by
using
the SET_REQUEST_SET. If the request set submission is successful, this
function returns the concurrent request ID; otherwise; it returns 0.
|
|
start_time
|
Time
at which the request should start running, formated as HH24:MI or HH24:MI:SS.
|
|
sub_request
|
Set
to TRUE if the request is submitted from another request and should be
treated as a sub-request.
|
Examples of Request Set Submission
/* Example 1 */
/* To submit a Request set
which is having STAGE1 and
STAGE2. STAGE1 is having
'FNDSCARU' and 'FNDPRNEV' programs. STAGE2 is having 'FNDSCURS'. */
/* set the context for the
request set FNDRSTEST */ success := fnd_submit.set_request_set('FND',
'FNDRSTEST'); if ( success ) then
/* submit program FNDSCARU which is in stage
STAGE1 */ success :=
fnd_submit.submit_program('FND','FNDSCARU',
'STAGE1', CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* submit program FNDPRNEV which is in stage
STAGE1 */ success :=
fnd_submit.submit_program('FND','FNDPRNEV',
'STAGE1','','','','','','','','','','',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* submit program FNDSCURS which is in stage
STAGE2 */ success :=
fnd_submit.submit_program('FND','FNDSCURS',
'STAGE2',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* Submit the Request Set */ req_id := fnd_submit.submit_set(null,FALSE);
end if;
/* Example 2 */ /* To submit
a request set FNDRSTEST as a repeating request set.
Request set FNDRSTEST has
STAGE1 and STAGE2.
STAGE1 contains
'FNDSCARU' and 'FNDPRNEV' programs.
STAGE2 has 'FNDSCURS'. */
/* set the repeating options for the request
set before
calling the set_request_set */
success := fnd_submit.set_repeat_options(
'', 4, 'HOURS', 'END');
/* set the context for the request set
FNDRSTEST */ success :=
fnd_submit.set_request_set('FND',
'FNDRSTEST'); if ( success )
then
/* submit program FNDSCARU which is in stage
STAGE1 */ success := fnd_submit.submit_program('FND','FNDSCARU',
'STAGE1',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* submit program FNDPRNEV which is in stage
STAGE1 */ success :=
fnd_submit.submit_program('FND','FNDPRNEV',
'STAGE1','','','','','','','','','','',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* submit program FNDSCURS which is in stage
STAGE2 */ success :=
fnd_submit.submit_program('FND','FNDSCURS',
'STAGE2', CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/*
Submit the Request set */ req_id :=
fnd_submit.submit_set(null,FALSE); end if;
/* Example 3 */
/* To submit a Request
set FNDRSTEST with 5 copies of the Print
environment variables report. Request
set FNDRSTEST has STAGE1 and STAGE2.
STAGE1 has 'FNDSCARU' and
'FNDPRNEV' programs. STAGE2 has
'FNDSCURS'. */
/* set the context for the request set
FNDRSTEST */ success :=
fnd_submit.set_request_set('FND', 'FNDRSTEST'); if ( success ) then
/* submit program FNDSCARU which is in
stage STAGE1 */ success :=
fnd_submit.submit_program('FND','FNDSCARU', 'STAGE1',
CHR(0),'','','','','','','','','', ...arguments...);
if ( not success ) then raise submit_failed; end if;
/* set the print options for the program */
success := fnd_submit.set_print_options(
'hqunx138', 'Landscape', 5, 'Yes',
FALSE);
/* submit program FNDPRNEV which is in stage
STAGE1 */ success:=
fnd_submit.submit_program('FND','FNDPRNEV',
'STAGE1','','','','','','','','','','',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/* submit program FNDSCURS which is in stage
STAGE2 */ success :=
fnd_submit.submit_program('FND','FNDSCURS',
'STAGE2',
CHR(0),'','','','','','','','','',
...arguments...); if ( not success ) then raise submit_failed; end if;
/*
Submit the Request set */ req_id :=
fnd_submit.submit_set(null,FALSE); end if;
