Concurrent Manager Queries

By using below Concurrent Manager and Program rules:


request_id, user_concurrent_program_name, u.user_name, u.description,
ROUND ((r.actual_completion_date - r.actual_start_date) * 24 * 60,
ROUND ((SYSDATE - r.actual_start_date) * 24 * 60, 2) time_elapsed,
ROUND ( ( r.actual_completion_date
- DECODE (TRUNC (r.request_date),
r.requested_start_date, r.request_date,
* 60
* 24
) waittimemin,
DECODE (r.phase_code,
'C', 'Completed',
'R', 'Running',
'P', 'Pending',
'I', 'Inactive',
) phase_code,
DECODE (r.status_code,
'A', 'Waiting',
'B', 'Resuming',
'C', 'Normal',
'D', 'Cancelled',
'E', 'Error',
'F', 'Scheduled',
'G', 'Warning',
'H', 'On Hold',
'I', 'Normal',
'M', 'No Manager',
'Q', 'Standby',
'R', 'Normal',
'S', 'Suspended',
'T', 'Terminating',
'U', 'Disabled',
'W', 'Paused',
'X', 'Terminated',
'Z', 'Waiting',
) status_code,
TO_CHAR (r.request_date, 'DD-MON-YYYY HH24:MI:SS') request_date,
TO_CHAR (r.requested_start_date,
'DD-MON-YYYY HH24:MI:SS') start_time,
TO_CHAR (r.actual_completion_date,
) complete_time,
number_of_arguments, argument_text, completion_text
apps.fnd_concurrent_requests r,
apps.fnd_concurrent_programs_vl p,
apps.fnd_user u
1 = 1
r.concurrent_program_id = p.concurrent_program_id
u.user_id = r.requested_by
p.user_concurrent_program_name LIKE
'Receiving Transaction Processor'

AND TRUNC (requested_start_date) >= TRUNC (SYSDATE)
ORDER BY r.requested_start_date DESC;
--Query to get the Responsibility/Request group attached for a given Concurrent
--Gives Detail of the Concurrent_queue_name and User_concurrent_program_name
SELECT b.concurrent_queue_name, c.user_concurrent_program_name
FROM FND_CONCURRENT_QUEUE_CONTENT a, fnd_concurrent_queues b, fnd_concurrent_pro
grams_vl c
WHERE a.queue_application_id = 283
and a.concurrent_queue_id = b.concurrent_queue_id
and a.type_id = c.concurrent_program_id
order by decode(INCLUDE_FLAG, 'I', 1, 2), type_code;
Cancelling Concurrent request:
--By request id
update fnd_concurrent_requests
set status_code='D', phase_code='C'
where request_id=&req_id;
--By program_id
update fnd_concurrent_requests
set status_code='D', phase_code='C'
Checking last run of a Concurrent Program along with Processed time:
-- Useful to find the Details of Concurrent programs which run daily and compari
son purpose
) AS Process_time,
a.request_id,a.parent_request_id,To_Char(a.request_date,'DD-MON-YY H
H24:MI:SS'),To_Char(a.actual_start_date,'DD-MON-YY HH24:MI:SS'),
To_Char(a.actual_completion_date,'DD-MON-YY HH24:MI:SS'), (a.actual_completion
_date-a.request_date)*24*60*60 AS end_to_end,
(a.actual_start_date-a.request_date)*24*60*60 AS lag_time,

d.user_name, a.phase_code,a.status_code,a.argument_text,a.priority
apps.fnd_concurrent_requests a,
apps.fnd_concurrent_programs b ,
apps.fnd_user d
a.concurrent_program_id= b.concurrent_program_id AND
b.concurrent_program_id=c.concurrent_program_id AND
a.requested_by =d.user_id AND
-trunc(a.actual_completion_date) = '24-AUG-2005'
c.USER_CONCURRENT_PROGRAM_NAME='Incentive Compensation Analytics - ODI' -- and
argument_text like '%, , , , ,%';
-and status_code!='C'

Checking the concurrent programs running currently with Details of Processed tim
e and Start Date:
SELECT DISTINCT c.USER_CONCURRENT_PROGRAM_NAME,round(((sysdate-a.actual_start_da
te)*24*60*60/60),2) AS Process_time,
mpletion_date,(a.actual_completion_date-a.request_date)*24*60*60 AS end_to_end,
(a.actual_start_date-a.request_date)*24*60*60 AS lag_time,d.user_name, a.phase_
FROM apps.fnd_concurrent_requests a,apps.fnd_concurrent_programs b,apps.FND_CO
NCURRENT_PROGRAMS_TL c,apps.fnd_user d
WHERE a.concurrent_program_id=b.concurrent_program_id AND b.concurrent_program_
id=c.concurrent_program_id AND
a.requested_by=d.user_id AND status_code='R' order by Process_time desc;
Checking the last run of concurrent Program:
- Use below query to check all the concurrent request running which may refer gi
ven package
-- This is very useful check before compiling any package on given instance.
-- The query can be modified as per requirement.
-- Remove FND_CONCURRENT_REQUESTS table and joins to check all program dependent
given package.
--AND referenced_owner = 'XXCUS'
AND fcr.phase_code NOT IN ( 'C','P');

Concurrent Program count under QUEUE:
col "program name" format a55;
col "name" format a17;
col "queue name" format a15
col "statuscode" format a3
select user_CONCURRENT_PROGRAM_NAME "PROGRAM NAME",concurrent_queue_name "QUEUE
NAME", priority,decode(phase_code,'P','Pending') "PHASE",
'Scheduled','G','Warning','H','On Hold','I','Normal','M','No Manager','Q','Stand
Waiting') "
NAME", status_code,count(*) from
where phase_code='P' and hold_flag!='Y'
and requested_start_date<=sysdate
and concurrent_queue_name<> 'FNDCRM'
and concurrent_queue_name<> 'GEMSPS'
group by
order by count(*) desc
Concurrent QUEUE Details:
set echo off
set linesize 130
set serveroutput on size 50000
set feed off
set veri off
running_count NUMBER := 0;
pending_count NUMBER := 0;
crm_pend_count NUMBER := 0;
--get the list of all conc managers and max worker and running workers
CURSOR conc_que IS
SELECT concurrent_queue_id,
FROM apps.fnd_concurrent_queues_vl
WHERE enabled_flag='Y' and
concurrent_queue_name not like 'XDP%' and
concurrent_queue_name not like 'IEU%' and
concurrent_queue_name not in ('ARTAXMGR','PASMGR') ;
DBMS_OUTPUT.PUT_LINE('QueueID'||' '||'Queue
'Concurrent Queue Name
'||' '||'MAX '||' '||'RUN '||' '||
'Running '||' '||'Pending '||' '||'In CRM');
FOR i IN conc_que Loop
Concurrent request status for a given sid:

col MODULE for a20
col OSUSER for a10
col USERNAME for a10
set num 10
col MACHINE for a20
set lines 200
col SCHEMANAME for a10
select s.INST_ID,s.sid,s.serial#,p.spid os_pid,s.status, s.osuser,s.username, s.
s.action from gv$session s, gv$process p WHERE s.paddr = p.addr and s.sid = '&or
COL name FORMAT a50
COL st_time FORMAT a7
COL requestor FORMAT a18
SELECT a.request_id request_id
, SUBSTR(a.user_concurrent_program_name,1,50) name
, TO_CHAR(a.actual_start_date,'Hh34:MI') st_time
, TO_CHAR(a.actual_completion_date,'Hh34:MI') end_time
, requestor
, DECODE(a.phase_code, 'R'
,'Running', 'P'
,'Inactive', 'C'
,'Completed', a.phase_code) phase_code
, DECODE(a.status_code, 'E'
,'Error', 'C'
,'Normal', 'X'
,'Terminated', 'Q'
,'On Hold', 'D'
,'Cancelled', 'G'
,'Warning', 'R'
,'Normal', 'W'
,'Paused', a.status_code) status_code
FROM apps.fnd_conc_req_summary_v a
WHERE TRUNC(actual_completion_date) >= TRUNC(SYSDATE -1)
AND a.status_code IN ('E','X','D')
ORDER BY actual_start_date

LAST_UPDATED_BY=B. SUBSTR(B.USER_ID. For checking the locks in concurrent jobs: SELECT DECODE(request.DESCRIPTION.'DD-MON-YY Hh34:MI') st_dt . requestor . lmode .1.AND TRUNC(ACTUAL_COMPLETION_DATE) > TRUNC(SYSDATE-6) AND TO_CHAR(TRUNC(ACTUAL_START_DATE). 1.ENABLE_TRACE='Y' AND A.1.inst_id.status_code. 'X' .25) DESCRIPTION FROM APPS. id2.ORACLE_PROCESS_ID.USER_CONCURRENT_PROGRAM_NAME. SUBSTR(A. 1. 'SUNDAY' .15) "Last_Updated_By". type FROM gV$LOCK WHERE request>0) O RDER BY id1. nvl(sum(decode(phase_code. name / Find out Concurrent Program which enable with trace: col User_Program_Name for a40 col Last_Updated_By for a30 col DESCRIPTION for a30 SELECT A.'DD-MON-YY DY') IS NOT NULL GROUP BY TRUNC(ACTUAL_START_DATE) ORDER BY TRUNC(ACTUAL_START_DATE) ASC.FND_USER B WHERE A.request_id .0. TO_CHAR(actual_completion_date. SUBSTR(user_concurrent_program_name. DECODE(a. TRUNC(SYSDATE-1)) AND NVL(actual_completion_date. type) IN (SELECT id1. For each manager get the number of pending and running requests in each queue: SELECT /*+ RULE */ nvl(sum(decode(phase_code.1.50) name . pending_count FROM fnd_concurrent_worker_requests WHERE requested_start_date <= sysdate and concurrent_queue_id = i. 'R'. APPLSYS.'Holder: '. 0)).'Hh34:MI') end_tm .40) "User_Program_Name".request.fnd_conc_req_summary_v a WHERE actual_start_date >= DECODE(TO_CHAR(SYSDATE.'Error'.SYSDATE) .concurrent_queue_id .FND_CONCURRENT_PROGRAMS_VL A. 0). 'E' .USER_NAME. request.CONCURRENT_PROGRAM_NAME "Program_Name". id2.'Terminated'.OS_PROCESS_Id from apps.TRUNC(SYSDATE)-3. CONCURRENT REQUESTS WHICH HAS MORE THAN 30 MINUTES OF EXECUTION TIME: SELECT a. TRUNC(((actual_completion_date-actual_start_date)*24*60*60)/60)+(((actual_comp letion_date-actual_start_date)*24*60*60)-(TRUNC(((actual_completion_date-actual_ start_date)*24*60*60)/60)*60))/100 exe_time . Find out request id from Oracle_Process Id: select REQUEST_ID. id2. 0) INTO running_count. SUBSTR(B.1.'Waiter: ')||sid sess. 'Normal') status_code FROM apps. 'MONDAY' .id1.TRUNC(SYSDATE)-2. 'P'. TO_CHAR(actual_start_date.'DAY').actual_start_date >= 30/24/60 ORDER BY actual_start_date.fnd_concurrent_reque sts where ORACLE_PROCESS_ID='&a'. type FROM gV$LOCK WHERE (id1. 0)).

' ')|| rpad(i.NAME) AND DD.6.8. END. --print the output by joining the outputs of manager counts.EXECUTION_METHOD_CODE = 'I' AND SUBSTR(FE.phase_code NOT IN ( 'C'.fnd_concurrent_worker_requests b WHERE a.PHASE_CODE FROM FND_CONCURRENT_PROGRAMS_VL FCPV .PUT_LINE('========================================================== ==========================================').10.STATUS_CODE . 'PACKAGE') -.FCR. 'TABLE'. ' ')|| rpad(i. DBMS_OUTPUT. 'TRIGGER'.EXECUTABLE_ID AND FE.10.concurrent_queue_id.REQUEST_ID . / set verify on set echo on Gives detail of Concurrent job completed and pending: SELECT FCR. 1) .user_concurrent_queue_name.SYS.EXECUTABLE_ID = FE.FCPV.' ')). .EXECUTION_FILE_NAME.CONCURRENT_PROGRAM_NAME .FCR.FCPV.REFERENCED_NAME = UPPER('&Package_name') AND FCR.15.fnd_concurrent_worker_requests a WHERE concurrent_queue_id = 4 AND hold_flag != 'Y' AND requested_start_date <= sysdate AND exists ( SELECT 'x' FROM apps. '.1 ) = UPPER(DD.max_processes.40.EXECUTION_FILE_NAME.' ')|| rpad(running_count.CONCURRENT_PROGRAM_ID AND fcr.PUT_LINE('---------------------------------------------------------------------------------------------------').FCPV. END LOOP.6.CONCURRENT_PROGRAM_ID = FCPV.INSTR(FE.' ')|| rpad(crm_pend_count.request_id=b.USER_CONCURRENT_PROGRAM_NAME .AND hold_flag != 'Y'.concurrent_queue_id AND hold_flag != 'Y' AND requested_start_date <= sysdate).CONCURRENT_PROGRAM_ID . --DBMS_OUTPUT.' ')|| rpad(pending_count.'.'P'). 1.FND_CONCURRENT_REQUESTS FCR WHERE FCPV.request_id and concurrent_queue_id = i.1.REFERENCED_TYPE IN ('VIEW'.PUT_LINE( rpad(i.running_processes.add as requ ired --AND referenced_owner = 'XXCUS' AND DD.FND_EXECUTABLES FE .10.' ')|| rpad(i. DBMS_OUTPUT.concurrent_queue_name.DBA_DEPENDENCIES DD . --for each manager get the list of requests pending due to conflicts in each man ager SELECT /*+ RULE */ count(1) INTO crm_pend_count FROM apps.'_')|| rpad(i.

concurrent_program_id and f.concurrent_program_id AND a.request_date)*24*60*60 AS end_to_end.concurrent_program_id=c. round(((sysdate-a.application_id and f. apps.actual_start_date) *24*60*60)/3600)*3600)/60) || ' MINUTES ' || round((((f.fnd_concurrent_programs b .'R'.actual_completion_date end_on.request_date)*24*60*60 AS lag_time.user_id AND status_code='R' order by Process_time desc.actual_completion_date-f.2) AS Process_time.user_concurrent_program_name user_conc_program_name.a. floor(((f. apps. d.a. apps.actual_completion_date-a.'C'.argument_text.actual_completion_date-f.actual_start_date desc.actual_start_date)*24*60*60/60).user_name.concurrent_program_name concurrent_program_name.f.actual_start_date) *24*60*60) floor(((f.actual_start_date is not null order by f.priority FROM apps.fnd_user d WHERE a.fnd_concurrent_programs p.'Running'.fnd_concurrent_requests f where f. apps.a.'Complete'.SCRIPT (PROGRAM WISE): .a.a.fnd_concurrent_requests a.actual_start_date) *24*60*60)/3600) || ' HOURS ' || floor((((f.status_code from apps.request_id.requested_by=d.application_id AND pt. pt.Gives Detail of Running and Completed Concurrent jobs with Start date and end da te: select f.actual_start_date-a. (a. apps.phase_code.concurrent_program_id and f.concurrent_program_id = p.a. f.actual_completion_date-f.actual_completion_date-f.actual_completion_date-f.a.phase_code.actual_completion_date-f. p.concurrent_program_id = pt.status_code.concurrent_program_id AND b.program_application_id = pt.phase_code) Phase.language = USERENV('Lang') and f.FND_CONCURRENT_PROGRAMS_TL c.actual_start_date) *24*60*60) floor(((f. f.request_date. (a.actual_start_date) *24*60*60)/3600)*3600 (floor((((f. f.USER_CONCURRENT_PROGRAM_NAME.actual_start_date start_on. a.program_application_id = p. Gives Details of Running Concurrent jobs: SELECT DISTINCT c.actual_completion_date-f.actual_start_date) *24*60*60)/3600)*3600)/60)*60) )) || ' SECS ' time_difference.actual_start_date. a.fnd_concurrent_programs_tl pt.parent_request_id.actual _completion_date.request_id . HISTORY OF CONCURRENT REQUEST .concurrent_program_id=b.actual_start_date) *24*60*60) floor(((f. decode(f.

'G'.concurrent_program_id AND r.status_code = 'E' AND a. 'I'.'Scheduled'.'Terminated'.user_concurrent_program_name like '%%' order by to_char(r.sysdate)-v.applsys.2 AND b.'On Hold'. 'T'.'P '.concurrent_program_id AND a.'Terminating'.set pagesize 200 set linesize 200 col "Who submitted" for a25 col "Status" for a10 col "Parameters" for a20 col USER_CONCURRENT_PROGRAM_NAME for a42 SELECT distinct t.'Running'.round(((nvl(v. to_char(r.request_id ='2260046' in ('13829387'.concurrent_queue_id = q. 'NA') phasecode. 'Z'.25) "Who submitted". 'W'.user_id AND v. to_char(r.fnd_concurrent_processes b . 'F'.ACTUAL_COMPLETION_DATE.concurrent_program_id=r.controlling_manager = b. 'M '.'Waiting'.c.queue_application_id = q.APPLICATION_ID AND t.STATUS_CODE.'Standby'.request_id "Req Id" .actual_start_date >= (sysdate-30) --AND r. 'B'.LANGUAGE = 'US' ORDER BY 5 DESC. decode(r.'Inactive'.fnd_Concurrent_requests a. . actual_completion_date .act ual_completion_date. 'E'.'Waiting') "Status".'C'.'I'.APPLSYS.concurrent_queue_id AND ctl. 'Q'. 'R'.ACTUAL_COMPLETION_DATE.phase_code.ACTUAL_START_DATE.PROGRAM_APPLICATION_ID = p. apps.'Normal'. ' U'.application_id AND b.description.'Suspended'.'13850423') and t.fnd_concurrent_requests r .'Disabled'.'R'. 'A'. apps. actual_start_date .requested_by=22378 AND r.fnd_concurrent_queues q .APPLSYS.APPLSYS.'Warning'.phase_code = 'C' AND actual_start_date > sysdate .'Error'.'Completed'.1.'Paused'.PHASE_CODE.CONCURRENT_PROGRAM_ID = p.'Cancelle d'.fnd_concurrent_programs p .'Normal'.fnd_concurrent_programs_tl t.argumen t_text "Parameters". decode(r. apps.concurrent_program_id = c.concurrent_program_id AND ctl.a.r.'Resuming'.user_concurrent_program_name.REQUESTED_BY=u.program_application_id = c. 'X'.status_code .concurrent_program_id = c. 'D'.'Pending'.request_id --AND r.CONCURRENT_PROGRAM_ID AND r. History of concurrent requests which are error out: SELECT a. 'No Manager'. apps. 'C'.actual_start_date)*24*60)) Etime FROM apps.concurrent_process_id AND a.application_id AND a.user_concurrent_program_name "program" FROM APPLSYS.fnd_conc_req_summary_v v WHERE r.'Normal'. 'S'. r. 'H'.'dd-mm-yy hh24:mi:ss') "Completed at".'dd-mm-yy hh24:mi:ss') "Started at".concurrent_program_name || ': ' || ctl.substr(u.'dd-mm-yy hh24:mi:ss').a.request_id=r.fnd_concurrent_programs c .fnd_concurrent_programs_tl ctl WHERE a.fnd_user u.REQUEST_ID.

16) PROGRAM .application_short_name SHORT_NAME . SUBSTR(f.55) USER_PROGRAM_NAME FROM applsys.user_concurrent_program_name.'R'. FND_CONCURRENT_WORKER_REQUESTS b where a. SYSDATE .0)) Pending_Standby.application_short_name LIKE UPPER('PA') ORDER BY 1.55) c5 FROM applsys.CONCURRENT_PROGRAM_ID AND a.application_id = a.1.1.2. applsys.FND_APPLICATION_TL a.application_id AND d.FORM_ID AND a.CONCURRENT_PROGRAM_ID = cp.USER_CONCURRENT_QUEUE_NAME.'P'. of Requests in PendingRunning: col "USER_CONCURRENT_QUEUE_NAME" format a40.1).FND_CONCURRENT_PROGRAMS_TL cp.APPLICATION_ID AND b.1. applsys.fnd_application b. SET PAGES 900 SELECT COUNT(*) cnt FROM apps.application_name. 'Subprogram or Function') TYPE . SELECT a.FND_CONCURRENT_PROGRAMS d. SUBSTR(d.1.1 FROM dual .APPLICATION_ID = b.1. applsys. SUBSTR(cp.Requested_Start_Date<=SYSDATE GROUP BY a.concurrent_queue_id = b.fnd_form f .LIST ALL THE REGISTERED CONCURRENT PROGRAMS BY MODULE: set lines 180 set pages 300 col SHORT_NAME for a10 col APPLICATION_NAME for a30 SELECT SUBSTR(a. DECODE(SUBSTR(cp.fnd_concurrent_requests WHERE TRUNC(actual_start_date) = TRUNC(SYSDATE) .STATUS_CODE.0)) Running_Normal FROM FND_CONCURRENT_QUEUES_VL a. 'Form Executable' c3 .application_id = a.1. sum(decode(b.4.decode(b.concurrent_queue_id AND b.'R'.0).16) c4 .'P'.application_name.1.concurrent_program_name.FORM_ID = f.application_id AND d.1 / PRESENTLY RUNNING REQUEST: set lines 180 set pages 500 .1.3. Lists the Manager Names with the No.'Q'. SUBSTR(d. b.60) Application_NAME .PHASE_CODE.a.'I'.FND_FORM_TL d WHERE f.0).STATUS_CODE.1.0).FND_APPLICATION_TL a.user_form_name.APPLICATION_ID = b.USER_CONCURRENT_QUEUE_NAME. applsys.MAX_PROCESSES.60) c1 .application_short_name c2 . sum(decode(b.4.':' . sum(decode(b.PHASE_CODE.0)) Pending_Normal.form_name.APPLICATION_ID AND b.PHASE_CODE. b.STATUS_CODE.user_concurrent_program_name.a.fnd_application b WHERE cp. 'Concurrent Manager Executable' . a pplsys.application_short_name LIKE UPPER('PA') UNION ALL SELECT SUBSTR(a.decode(b.decode(b. applsys.MAX_PROCESSES NUMBER OF CONCURRENT REQUESTS IN A DAY: SET LINES 120 SET PAGES 0 COL cnt FORMAT 999999 HEADING "Total No of Requests" SELECT ' Number of Concurrent Requests for '.

phase_code = 'R' AND fcu.request_id.fnd_concurrent_requests a. d.fnd_concurrent_requests fcr. c.actual_completion_date-f. apps.actual_start_date) .requested_by AND fcr. d.session_id=d.request_id .fnd_concurrent_processes = b.1.actual_start_date start_on.concurrent_process_id AND c. floor(((f.user_id = fcr. apps.concurrent_program_id = ftp.actual_start_date) *24*60*60)/3600) || ' HOURS ' || floor((((f. apps.actual_start_date) *24*60*60)/3600)*3600)/60) || ' MINUTES ' || round((((f. v$process c. f.fnd_concurrent_programs_tl ftp.fnd_conc_req_summary_v WHERE TRUNC(actual_start_date) = TRUNC(SYSDATE) -1 GROUP BY SUBSTR(user_concurrent_program_name.SPID FROM apps.col USER_CONCURRENT_PROGRAM_NAME for a50 col USER_NAME for a30 SELECT fcr.user_name FROM apps.oracle_process_id AND b.fnd_user fcu WHERE fcr.sid.actual_completion_date end_on.1.serial#.phase_code = 'R'. ftp.concurrent_program_id. Query will display the time taken to execute the concurrent Programs: The following query will display the time taken to execute the concurrent Progra ms --for a particular user with the latest concurrent programs sorted in least time taken SELECT f. pt. f.request_id = &Request_ID AND a. COUNT(*) cnt FROM apps.spid of the concurrent Request: SELECT a.controlling_manager = b.actual_completion_date-f.request_id.actual_start_date) *24*60*60) floor(((f.user_concurrent_program_name.70) program . fcu.70) HAVING COUNT(*) > 200 ORDER BY 2 Query we can get sid. PROGRAMS RAN MORE 200 TIMES IN A DAY: SET LINES 120 SET PAGES 900 COL program FORMAT a70 COL cnt FORMAT 999999 HEADING "Number of Runs" ttitle 'Programs that ran for more than 200 times ' skip 2 SELECT SUBSTR(user_concurrent_program_name.actual_completion_date-f.serial# . v$session d WHERE a.status_code = 'R' AND fcr.actual_completion_date-f.user_concurrent_program_name user_conc_program_name.audsid AND a.

fnd_concurrent_requests f where f.fnd_concurr ent_requests c WHERE 1=1 AND a. TO_CHAR( actual_completion_date. gv$session d WHERE a.PHASE_CODE='R' AND a.actual_completion_date-f. c.process.actual_completion_date-f. 'DD-MON-YYYY HH24:MI:SS' ) current_date.'R'. apps.f.actual_completion_date-f.controlling_manager AND c.concurrent_process_id AND c. 'DD-MON-YYYY HH24:MI:SS' ) request_date.concurrent_program_id and f.fnd_concurrent_programs p.concurrent_program_id = pt. Requests completion date details: SELECT request_id.concurrent_program_id and f.actual_start_dat e ) * 24. d. 'DD-MON-YYYY HH24:MI:SS' ) actual_completion_date.actual_start_date) *24*60*60)/3600)*3600)/60)*60) )) || ' SECS ' time_difference.request_id = '&Request_id'. sysdate ) . decode( = b.program_application_id = pt. a. apps. . d.concurrent_program_name concurrent_program_name. d.STATUS_CODE='R' AND d.phase_code) Phase. p.actual_start_date is not null order by f.SPID as OS_Process_ID FROM apps.controlling_manager = b.'DD-MON-YYYY HH24:MI:SS' ) requested_start_date.PHASE_CODE.'Complete'.language = USERENV('Lang') and f.osuser.serial#.actual_start_date desc.actual_start_date) *24*60*60) floor(((f. 'DD-MON-YYYY HH24:MI:SS' ) actual_start_date.oracle_process_id AND b.fnd_concurrent_programs_tl pt.fnd_concurrent_requests a.actual_start_date) *24*60*60)/3600)*3600 (floor((((f.phase_code. TO_CHAR( sysdate. Request_id from sid: SELECT a. gv$process c. ROUND( ( NVL( actual_completion_date.concurrent_program_id = p.concurrent_queue_id AND a.'Running'.session_id=d.application_id and f.concurrent_queue_id = b. d.sid = &SID.*24*60*60) floor(((f. TO_CHAR( request_date.status_code from apps. f.program_application_id = p.concurrent_process_id = c. apps. Request id related manager: SELECT * FROM fnd_concurrent_processes a . a. TO_CHAR( requested_start_date.application_id AND pt.fnd_concurrent_processes b.sid as Oracle_SID.audsid AND a.fnd_concurrent_queues_vl b.'C'. 2 ) duration FROM fnd_concurrent_requests WHERE request_id = TO_NUMBER('&p_request_id').request_id. TO_CHAR( actual_start_date.STATUS_CODE.

null.phase_code.requested_by = fu.'Inactive'.fnd_user fu . 'Q' .'Terminating'.request_id) ||'~'|| decode(to_char(parent_request_id).description. 'W' .requested_start_date-SYSDATE).'DD-MON-RR HH24:MI:SS') ||'~'|| to_char(a.DECODE(fcr.'Paused'.actual_start_date.'Completed'.status_code) status_code .requested_start_date.DECODE(fcr. 'X' .'Cancelled'.'Terminated'.'On Hold'.'DD-MON-RR HH24:MI:SS') ||'~'|| to_char(a.request_id . 'I' .to_char(parent_request_id)) ||'~'|| a. DECODE(fcr. 'R' .'Normal'.user_name requestor .fnd_concurrent_requests fcr WHERE fcp.'Error'. 'R' .'Standby')). 'Y' . fcr. 'W' . 'C' .'Running'. apps. 'C' .1 .2) ||'~'|| .'Terminating'.'-1'.user_concurrent_program_name || ' ' || fcr.requested_start_date. fcp.'Scheduled'.hold_flag.phase_code = 'P' AND fcr.'DD-MON-YYYY Hh24:MI:SS') req_start_dt FROM apps. 'G' . fu. 'Y' .user_concurrent_program_name ||'~'|| to_char(a.SCHEDULED REQUESTS: SET LINE 130 PAGESIZE 1000 COLUMN request_id FORMAT 999999999 COLUMN conc_prog_name FORMAT A47 COLUMN requestor FORMAT A18 COLUMN phase_code FORMAT A10 head 'Phase Code' COLUMN status_code FORMAT A10 head 'Status Code' COLUMN req_start_dt FORMAT A20 head 'Requested Start Date' SELECT fcr.'Scheduled'. DECODE(SIGN(fcr. 'T' .status_code IN ('Q'. 'Report Set' . 'D' .user_id ORDER BY 1 / TO CHECK PARTICULAR PROGRAM REPORT: set lines 180 set pages 300 SELECT to_char(a.'Normal'. TO_CHAR(fcr.1. DECODE(fcr. fcr. 'Pending'). apps.'DD-MON-RR HH24:MI:SS') ||'~'|| round(trunc(((actual_completion_date-actual_start_date)*24*60*60)/60)+(((actual_ completion_date-actual_start_date)*24*60*60)-(trunc(((actual_completion_date-act ual_start_date)*24*60*60)/60)*60))/100.hold_flag.user_concurrent_program_name.47) conc_prog_name .'Paused'.phase_code) phase_code .fcp.concurrent_program_id AND fcr. SUBSTR(DECODE(fcp.user_concurrent _program_name).'Normal'. 'T' . 'I') AND fcr.concurrent_program_id = fcr.'Warning'.fnd_concurrent_programs_vl fcp .status_code.actual_completion_date. 'R' . 'P' . 'E' .

user_concurrent_program_name. 'S'.request_id = '&RequstID' order by request_id . 1.'Completed'.fnd_concurrent_queues fcq. 'WAITING'. 'F'. 'CANCELLED'. substr(fcr. 'Q'. 60) name.controlling_manager = fcp. 'NORMAL'. 'C'.'Running'.queue_application_id = fcq. 1.fnd_concurrent_processes fcp.'Normal'.argument_text FROM apps.'On Hold'.phase_co de) Phase. 'WARNING'. Fnd_Concurrent_Queues Q. 'X'. Q.process_status_code Status.'S') Order by Concurrent_Process_ID. 'G'. 'R'.a. to_char(fcr. FND_V$Process where Q.'hh24:mi') s_time.'Running'. Os_Process_ID Osid.user_concurrent_program_name. 'I'. 'DISABLED'. 'B'.fnd_conc_req_summary_v a WHERE a.request_id req_id. 'U'. 'Z'.Application_Id = Queue_Application_ID And (Q. 'W'. substr(fcq. Q. 'D'.status_code.NODE_NAME node. 'H'.requestor. TO CHECK THE MANAGERS RUNNING OR NOT SHOULD BE ACTIVE: set lines 180 set pages 300 col OSID for a30. 'UNKNOWN'). 'ERROR'.'Inactive'. 'PAUSED'.Concurrent_Queue_Name .phase_code.a. Os_Process_Id.'Cancelled'.'Warning'. To_Char(P. substr(fcr. 'C'.'Error'. PID Opid. 'WAITING'. Select distinct Concurrent_Process_Id CpId. 'STANDBY'. 'T'.concurrent_queue_name. 'NORMAL'.'Completed'. TO CHECK PARTICULAR REQUEST STATUS: set lines 180 set pages 300 col name format a20 col QUEUE for a20 col U_NAME for a20 select fcr.status_code) ||' ~'|| a.actual_start_date. 'G'.'C'.'Inactive'.user_concurrent_program_name like ('&programname%') order by a.concurrent_queue_id = fcq. 'E'. 'M'. 'R'. substr(decode( fcr.concurrent_process_id and fcr. round((sysdate -actual_start_date) *24.a. 'W'. 'Q'. 1. 'TERMINATED'.phase_code. P.status_code. 'NO MANAGER'. 'MM-DD-YYYY HH:MI:SSAM') Started_At from Fnd_Concurrent_Processes P. fcr.'R'.'P'. apps. 20) queue.'C'. 'SUSPENDED'.'E'. a. 1. 'SCHEDULED'.requestor ||'~'|| decode(a.'R'.Concurrent_Queue_ID = P.Concurrent_Queue_ID) And ( Spid = Os_Process_ID ) And Process_Status_Code not in ('K'.phase_code. 9 ) u_name. 'X'. decode(fcr.concurrent_queue_id and fcp. 'A'. a. P. 'RESUMING'. 2) elap. 'TERMINATED'. 'Paused'.application_id and fcr.'Normal'.'P'.actual_start_date.Process_Start_Date. 10) from apps.phase_code) ||'~'|| decode(a.Concurrent_Queue_Name Manager.'Terminated'. 'D'. 'NORMAL'.fnd_conc_req_summary_v fcr where fcp. apps. 'ON HOLD'.

'Suspending'. 'E'. 'R'.target_node. 'Terminated'. COUNT(phase_code) run FROM fnd_concurrent_worker_requests WHERE phase_code = 'R' AND hold_flag != 'Y' AND requested_start_date <= SYSDATE GROUP BY concurrent_queue_name) running. 'Verifying'. 'Restarting') status FROM (SELECT concurrent_queue_name. max_processes) DESC. To find child requests for Parent request id: set lines 200 col USER_CONCURRENT_PROGRAM_NAME for a40 .pend. q.TO CHECK WHICH MANAGER IS RUNNING ON WHICH NODE AND MANAGER STATUS: set verify off set lines 256 set trims ON set pages 60 col concurrent_queue_id format 99999 heading "QUEUE Id" col concurrent_queue_name format a20 trunc heading "QUEUE Code" col user_concurrent_queue_name format a30 trunc heading "Concurrent Queue Name" col max_processes format 999 heading "Max" col running_processes format 999 heading "Act" col running format 999 heading "Run" col target_node format a15 heading "Node" col status format a12 trunc heading "Status" col run format 9999 heading 'Run' col pend format 9999 heading 'Pending' col cmgr_program FOR a65. 'Activating'. 'Suspended'. 'Q'.concurrent_queue_id. 0.running_processes.concurrent_queue_name = running.fnd_concurrent_queues_vl q WHERE q. running. q. Decode(q. 'V'. q. 'X'.user_concurrent_queue_name. 'Deactivating'. 'Terminating'. 1. Decode(q. q. 'D'.max_processes.control_code.concurren t_queue_name = pending. 'Deactivated'.run running.4. 'N'.concurrent_queue_id. Prompt =========================== Prompt concurrent manager status Prompt =========================== SELECT q. Sign(q.enabled_flag = 'Y' ORDER B Y Decode(q.concurrent_queue_name. q. 'Resuming'. 2)). 'T'.application_id.concurrent_queue_name(+) AND q. 'P'.concurrent_queue_name(+) AND q. 1. q. 'Node unavai'. (SE LECT concurrent_queue_name. COUNT(phase_code) pend FROM fnd_concurrent_worker_re quests WHERE phase_code = 'P' AND hold_flag != 'Y' AND requested_start_date <= S YSDATE GROUP BY concurrent_queue_name) pending. q. apps. SELECT 'Instance : ' ||NAME instance_name FROM v$database. 'O'.concurrent_queue_name.application_id. 'A'. pending.

'X'. c. 'No Mana ger' .fnd_concurrent_requests req where req. b. 'Terminating'. sum. 'Terminated'.'Complete d'.phase code.fnd_concurrent_requests a.Query 13:To find the Database SID of the Concurrent job -.actu al_start_date. To find concurrent program name.fnd_concurrent_processes b.request_id. d.audsid AND a.inst_id. 'G'.sql_address = sql.'D'.fnd_conc_req_summary_v WHERE request_id = '&req_id' ORDER BY 6 DESC. 'Cancelled' .status_code) status_code.status code for a given request id: SELECT request_id. to_char(actu al_start_date. v$session d WHERE a. -.fnd_concurrent_requests c where a.PARENT_REQUEST_ID.'On Hold' . 'Error' .address(+) and ses. ORACLE_PROCESS_ID. 'Normal'. set col os_process_id for 99 select HAS_SUB_REQUEST. apps. 'M'. d. sum.inst_id = b.SPID FROM apps.sid= is the Oracle process id SQL> column process heading "FNDLIBR PID" SELECT a. sid.process . 'Normal'.inst_id and c.request_id = &Request_ID AND a.phase_code = 'R'. 'C'.oracle_process_id AND b. DECODE(phase_code.sum.hash_value(+) and ses. 'T'. DE CODE(sum.addr and request_ID ='31689665' AND a. DECODE(status_code.phase_code) phase_code.paddr = b . 'C'.request_id=sum. 'G'. 'H'.'C'.statu s_code. sum.d. To find the sql query for a given concurrent request sid: select sid. gv$sqlarea sql where ses.'Completed'.d.controlling_manager = b. is_SUB_REQUEST. sum.serial# . 'X'.osuser. 'Warning'.request_id. 'Warning'. 'Terminated'.phase_code.'dd-mon-yy:hh24:mi:ss') Start_Date. 'M'.req. 'T'. request_id and req.fnd_con c_req_summary_v sum. OS_PROCESS_ID from fnd_concurrent_requests where request_id= '& Req_ID' . completion_text FROM apps.completion_text FROM apps.phase_code) = b.We need our concurrent request ID as an input.sql_text from gv$session ses. 'No Mana ger' .sid='&oracle_sid' TO FINDOUT PAST ONE MONTH HISTORY: set pause off set pagesize 2000 .apps. gv$process b.PARENT_REQUEST_ID = '&parent_concurrent_request_id'. -. to_char(actual_completion_date .sid.concurrent_process_id AND c.'On Hold' . 'Terminating'. status_code) status_code. apps.'D'. v$process c.'C'. 'H'. 'E'. 'Cancelled' .d.session_id=d.sql_hash_value = sql. 'E'. DECODE(sum.process.spid from gv$session a.'dd-mon-yy:hh24:mi:ss').c. OR ACLE_SESSION_ID.col PHASE_CODE for a10 col STATUS_CODE for a10 col COMPLETION_TEXT for a20 SELECT sum.SPID= is the operating system process id -. 'Error' .user_concurrent_program_name.sum. user_concurrent_program_name.actual_completion_date.os_process_id = a. To find the pid of the Concurrent job and kill it: Select a. parent_request_id.

TO FINDOUT THE TRACEFILE OF A PARTICULAR REQUEST: column traceid format a8 column tracename format a80 column user_concurrent_program_name format a40 column execname format a15 column enable_trace format a12 set lines 80 set pages 22 set head off SELECT 'Request id: '||request_id .ACTUAL_COMPLETION_DATE desc. fnd_concurrent_queues fcq WHERE fcp.application_id AND fcq.'|| ses. TO FINDOUT THE REQUEST LOGFILE NAME AND LOCATION: SELECT REQUEST_ID. v$parameter dbnm.fnd_concurrent_requests req.fnd_executables execname where req. apps. argument_text.process_status_code = 'A'.'DD/MON HH24:MI:SS') END_TIME.enable_trace. 'Trace id: '||oracle_Process_id. 'Prog.apps.queue_application_id = fcq.logfile_name.manager_type = '0'AND fcp.value||'/'||lower(dbnm.user_concurrent_program_name.value)||'_ora_'||oracle_process_id||'.sid||'. apps.module from apps. outfile_node_name.FND_CONCURRENT_REQUESTS WHERE REQUEST_ID =&Req_ID. to_char(ACTUAL_COMPLETION_DATE. phase_code from apps.request_id = '&request' .concurrent_program_id and user_concurrent_program_name like '%Gather Schema%' and fnd_concurrent_programs_tl. 'Module : '||ses.99 select request_id.set linesize 120 set wrap off column user_concurrent_program_name format a45 noprint column argument_text format a45 print column user_name format a15 column start_time format a15 column end_time format a15 column comp_time format 9999.language='US' and requested_by=user_id order by actual_start_date desc.fnd_concurrent_programs_vl prog.execution_file_name|| execname.logfile_name LogFile FROM fnd_concurrent_processes fcp.concurrent_queue_id AND fcp. user_concurrent_program_name.user_n ame. 'Trace Name: '||dest.concurrent_queue_id = fcq. v$session ses. apps. outfile_name. TO FINDOUT THE ICM CURRENT LOGFILE NAME AND LOCATION: SELECT 'LOG=' || fcp. 'Status : '||decode(phase_code.subroutine_name .'Normal').fnd_concurrent_programs_tl.serial#. 'File Name: '||execname. Name: '||prog. v$parameter dest.trc'. last_update_dat e FROM apps.'R'.'Running') ||'-'||decode(status_code.fnd_user where fnd_concurrent_requests. to_char(actual_start_date.'R'. (actual_completion_date-actual_start_date)*24*60 comp_time. 'Trace Flag: '||req.fnd_concurrent_requests.concurrent_program_id = fnd_concurrent_programs_tl . 'SID Serial: '||ses. v$process proc. status_code.'DD/MON HH24:MI:SS') START_TIME.

request_id.sql_exec_id.self_serv_session_COUNT "SelfServ Sessions" .schemaname. s. s. s. s.icx_sessions WHERE TRUNC(creation_date) = TRUNC(SYSDATE-1)) icxs.executable_id=execname. UPPER (s.module_hash.sql_child_number.paddr.application_id prog.application_id = execname.prev_sql_addr.SID. icxs.concurrent_program_id = prog. icxs. s.paddr(+) dest.username.application_id'db_name' req. COUNT(*) forms_session_COUNT FROM applsys. s. s. COUNT(*) self_serv_session_COUNT FROM icx. s.CONCURRENT_QUEUE_ID = b.'DD-MON-Y Y HH24:MI:SS') from apps.sql_hash_value. s.to_char(actual_completion_date. TO FINDOUT WHICH MANAGER RAN THE REQUEST: select b. s.oracle_process_id=proc. .schema#.CONCURRENT_PROCESS_ID = c. s.machine.sql_id.serial#. s. (SELECT COUNT(distinct user_id) forms_user_COUNT . s. s. s.lockwait.CONCURRENT_QUEUE_ID and a.forms_user_COUNT "Forms Users" .taddr. s. s. s.status. s.' from g v$session where MODULE like 'GLPREV'. s.prev_exec_id.USER_CONCURRENT_QUEUE_NAME from fnd_concurrent_processes a.process.fnd_conc_req_summary_v where request_id='&Requstno'.saddr.fnd_logins WHERE TRUNC(start_time) = TRUNC(SYSDATE-1)) fl.osuser. s.TYPE.plsql_entry_object_id. TO KNOW THE REQUEST SINCE HOW LONG ITS RUNNING: select user_concurrent_program_name. s. s.status_code.program) program.spid(+) proc.prev_hash_value. s.fnd_concurrent_requests WHERE TRUNC(actual_start_date) = TRUNC(SYSDATE-1) ) fcr / wait events details related with Concurrent programs: SELECT s. s.forms_session_COUNT "Forms Sessions" FROM (SELECT COUNT(distinct user_id) self_serv_user_COUNT .to_char(ac tual_start_date.sql_address. fnd_concurrent_queues_vl b. s.module. s.sql_exec_start.program_application_id = prog.cnt "Conc Reqs" . (SELECT COUNT(*) cnt FROM apps.'DD-MON-YY HH24:MI:SS').name='user_dump_dest' dbnm. fl.plsql_subprogram_id.audsid. fnd_concurrent_requests c where a.plsql_object_id.command. s. USAGE REPORT FOR TODAY: SET PAGES 900 SELECT fcr. s. s. s.'||serial#||''' immediate.prev_child_number.controlling_manager and c.concurrent_program_id req. s.executable_id.server.addr = ses.phase_code. s.user#.prev_exec_start.plsql_entry_subprogram_id. s.terminal. fl.and and and and and and and and req.prev_sql_id. To terminate the all concurrent requests using by Module wise: select 'ALTER SYSTEM KILL SESSION '''||sid||'.ownerid. s.request_id = '&requistno'.self_serv_user_COUNT "SelfServ Users" . s. s.

fnd_concurrent_requests c where a.d.username.sql_trace_plan_stats.s.sql_trace_binds.row_wait_block#. s.failed_over.logon_time. s. s.serial#. s.event. s.failover_type. s. to_char(a. s.a.p1.event.pdml_status.request_id = '&conc_reqid'.status_code "ST_CD". s.p2text.p3.pdml_enabled.USER_CONCURRENT_QUEUE_NAME from fnd_concurrent_processes a. s. s.TYPE <> 'BACKGROUND') AND STATUS='ACTIVE' ) ORDER BY "PROGRAM". fnd_concurrent_queues_vl b.blocking_instance.CONCURRENT_QUEUE_ID = b.session_edition_id.pq_status. s.paddr=d.creator_serial# FROM v$session s WHERE ( (s.action_hash.client_info. s.row_wait_obj#.a.a.CONCURRENT_PROCESS_ID = c.fnd_concurrent_programs_tl e.wait_class. c. s.wait_class#. s. s. . s.p1text.sql_trace.p2. s. s. s.program.state. s.client_identifier. s. s. s. b. s.time_remaining_micro. Which Manager Ran a Specific Concurrent Request: col USER_CONCURRENT_QUEUE_NAME for a100 select b. b. s.service_name.os_process_id "PPID".c. s.addr) b.(select c.failover_method.phase_code "PH_CD". s. e. s.blocking_session. v$process d where c.creator_addr.action.p2raw. s.p3raw.fnd_concurrent_requests a. s.osuser.pddl_status. s. s. s.spid from v$session c. s.row_wait_file#.username. SQL TO FIND OUT CONCURRENT REQUESTS CURRENTLY RUNNING: set lines 180 set pages 1000 set verify off undef spid column req_id format 99999999999 column OPID format a10 column PPID format a8 column SPID format a8 column ST_CD format a1 column ph_cd format a1 column CNAME format a30 column event format a15 column user_name format a10 column program format a8 column serial# format 999999 column sid format 9999 column username format a8 select a. s. s. s. s.user_concurrent_program_name "CNAME".g. 'x') <> 'SYSTEM') AND (s.'MON-DD-HH-MI-SS') COMPL_DATE from apps.user_name.username IS NOT NULL) AND (NVL (s.sid.row_wait_row#.oracle_process_id "OPID". s.request_id "REQ_ID".controlling_manager and c.b.serial#.wait_time_micro.wait_class_id. s. s.seq#.resource_consumer_group.'MON-DD-HH-MI-SS') START_DATE.program.wait_time.event#.time_since_last_wait_micro.ACTUAL_START_DATE. s. s.current_queue_duration.c.b. apps.sql_trace_waits. apps.p1raw. s.CONCURRENT_QUEUE_ID and a. s. s. f.blocking_session_status.fnd_user f.last_call_et. s. s.p3text. s.sid. to_char(a.fixed_table_sequence.a.ACTUAL_COMPLETION_DATE.seconds_in_wait. s. s.

language='US' and a.requested_by=f.'Nor mal').user_concurrent_program_name. 'Status : '||decode(phase_code.oracle_process_id=b. SQL TO FIND THE CONCURRENT REQUEST TRACE FILE DETAILS (Input Request ID): SELECT 'Request id: '||request_id . Concurrent Manager_request-SID & Serial# find script: SELECT ses.trc'.argument_text.user_id and b. v$process proc.PADDR. FND_CONCURRENT_REQUESTS B.PID FROM GV$PROCESS A. GV$SESSION C WHERE B.spid IN (SELECT oracle_process_id FROM FND_CONCURRENT_REQUESTS .concurrent_program_id = prog. a.'|| ses. 'Trace Name: '||dest.application_id and prog.paddr(+) and dest.concurrent_program_id=e.addr = ses. v$session ses.OS PROCESS DETAILS BY REQUEST ID: select a.spid and a.executable_id=execname.phase_code.executable_id .SPID -.fnd_concurrent_requests a. fnd_concurrent_programs_vl prog.sid||'.spid(+) and proc.module from fnd_concurrent_requests req.serial# FROM v$session ses. 'Trace Flag: '||req.status_code='R' and a.v$session_wait g where a.user_id.oracle_process_id=proc.concurrent_program_id and req.execution_file_name|| execname.AND B.program_application_id = prog. v$parameter dbnm. apps. A. 'Trace id: '||'db_name' and req.paddr = pro.requested_by=f.value||'/'||lower(dbnm. SQL TO FIND CONCURRENT REQUEST SID.request_id = &request and req. a.fnd_user f where request_id='&REQUEST_ ID' and a.REQUEST_ID like '%' AND B. v$process pro WHERE ses.value)||'_ora_'||oracle_process_id| |'.SERIAL#. 'File Name: '||execname.application_id = execname.ORACLE_PROCESS_ID = A.oracle_process_id "DB_PRO CESS". C.addr AND pro. 'Module : '||ses.enable_trace.sid and a.subroutine_name .OS_PROCESS_ID "MT_PROCESS". --'Prog.phase_code='R'. OR == SELECT C.sid=g.ADDR=C. 'SID Serial: '||ses.status_code. v$parameter dest.'R'.concurrent_program_id and e.user_name from apps.REQUEST_ID ='&x' AND A.sid. fnd_executables execname where req.'Running') ||'-'||decode(status_code.application_id and prog.'R'.serial#. ses. a. a.SID. Name: '||'user_dump_dest' and dbnm. f.

WHERE request_id ='&request_id'). Query to find concurrent program: select frt. STATUS_CODE = 'X' where request_id = '&Req_id'.request_group_name.session_id=d. SELECT a.request_unit_id.audsid AND a.SPID FROM apps.oracle_process_id AND b.sid.request_group_id and fcpt.request_id.fnd_concurrent_requests a. fcpt. frgu. fnd_request_groups frg.responsibility_id and frg.fnd_concurrent_processes b.user_concurrent_program_name From fnd_Responsibility fr.controlling_manager = b.fnd_concurrent_requests set phase_code = 'C'. v$process c.request_unit_id . fnd_responsibility_tl frt. phase_code='C' where request_id="".concurrent_process_id AND c.responsibility_name. phase_code='C' where request_id=31783706. d.Error X .pid = b.responsibility_id = fr. d.request_unit_type. This will change the status of any request.serial# .osuser.request_group_id = fr.Terminate G . System altered.concurrent_program_id = frgu. c. Action: #First Terminate the Request as follows update fnd_concurrent_requests set status_code='X'. 8017' IMMEDIATE.request_group_id and frgu. apps. update fnd_concurrent_requests set status_code='E'. commit. frg. #Then change the status with Completed-Error as follows. status_code. fnd_request_group_units frgu. v$session d WHERE a. Issue: Request is in pending from long time.request_group_id = frg. Status Code E . commit. fnd_concurrent_programs_tl fcpt where frt.phase_code = 'R'. Commit.request_id = '&Request_ID' AND a. Find out OSPID: select os_process_id from fnd_concurrent_requests where request_id ='&request_id '.process . SQL> ALTER SYSTEM KILL SESSION ' 1114. select request_id.Warning update applsys.frgu. phase_code.d. oracle_process_id from fnd_concurren t_requests where request_id ='&request_id'.d.

actual_start_date .user_concurrent_program_name "program" FROM APPLSYS. frg.request_unit_type. frgu.APPLSYS.queue_application_id = q. fcpt.APPLSYS.c. actual_completion_date .language = USERENV('LANG') and fcpt.fnd_Concurrent_requests a.language = USERENV('LANG') and fcpt.language = USERENV('LANG') and fcpt.fnd_concurrent_programs_tl ctl WHERE a.2.status_code = 'E' AND a.fnd_concurrent_programs_tl ctl WHERE a.concurrent_program_name || ': ' || ctl. apps.APPLSYS.request_unit_id and frt.status_code .a.frgu.concurrent_program_id AND CTL.concurrent_program_id = c.4 Query to find Request Set: select frt.concurrent_program_id AND a.responsibility_id = fr.LANGUAGE = 'US' ORDER BY 5 DESC.program_application_id = c.request_group_id and fcpt.user_request_set_name From apps.fnd_concurrent_programs c .a.application_id AND a. actual_completion_date .fnd_Concurrent_requests a. apps.phase_code = 'C' AND actual_start_date > sysdate .fnd_concurrent_queues q .applsys.concurrent_program_name || ': ' || ctl. apps.concurrent_process_id AND a.a.phase_code = 'C' .7 AND b.user_concurrent_program_name "program" FROM APPLSYS.request_group_id and frgu.c.application_id AND b.request_group_name.APPLSYS.status_code .concurrent_program_id = c.fnd_concurrent_processes b . History of concurrent requests which are error out : SELECT a.fnd_request_Sets_tl fcpt where frt. apps.user_concurrent_program_name = :conc_prg_name order by 1.user_request_set_name = :request_set_name order by 1.phase_code.responsibility_name.controlling_manager = b.and frt.application_id AND a.request_group_id = frg.concurrent_program_id AND a.APPLSYS.program_application_id = c.concurrent_queue_id = q.concurrent_process_id AND a.request_group_id = fr.request_id "Req Id" .fnd_Responsibility fr.concurrent_queue_id AND ctl.2. actual_start_date .fnd_concurrent_programs c .controlling_manager = b.fnd_request_groups frg.status_code = 'E' AND a.request_unit_id.4 Concurrent Request Error Script: SELECT a.fnd_concurrent_processes b .request_id "Req Id" .fnd_request_group_units frgu.fnd_responsibility_tl frt.phase_code.responsibility_id and frg.fnd_concurrent_queues q .applsys.3.3.concurrent_program_id = c.request_set_id = frgu.APPLSYS.language = USERENV('LANG') and fcpt.a.

execname.queue_application_id = q.application_id AND b. 'Trace Name: '||dest. fnd_executables execname where req.SID .status_code .logfile_node_name node .APPLICATION_ID = EXECNAME.user_concurrent_program_name . 'Trace id: '||oracle_Process_id.AND actual_start_date > sysdate .module .concurrent_program_id = .application_id AND PROG. v$process proc.v$parameter dest .sid||'. v$parameter dest.concurrent_queue_id = q.'No rmal').prog.subroutine_name . SQL to find out the Raw trace name and location for the concurrent program: SELECT req.LANGUAGE = 'US' ORDER BY 5 DESC.trc' trace_fi lename .NAME='db_name' AND req. Trace file Including SID: SELECT 'Request id: '||request_id .spid(+) AND proc.2 AND b.execname. fnd_concurre nt_programs_vl prog.user_concurrent_program_name.execution_file_name .request_id = &request and req.program_application_id = prog. 'Trace Fl ag: '||req.oracle_process_id=proc.concurrent_program_id = prog.req. 'Status : '||decode(phase_code.value)||'_ora_'||oracle_process_id| |'.oracle_process_id=proc.VALUE||'/'||LOWER(dbnm.fnd_executables execname WHERE 1=1 AND req.addr = ses.execution_file_nam e|| execname.v$parameter dbnm .serial#.'R'. Name: ' ||prog.machine FROM fnd_concurrent_requests req . v$parameter dbnm.paddr(+) AND dest.phase_code .concurrent_queue_id AND ctl.module from fnd_c oncurrent_requests req.req.executable_id.dest. 'Prog.APPLICATION_ID AND prog.'R'.'|| ses.request_id = &request AND req.value||'/'||lower(dbnm.enable_trace . v$session ses.v$process proc .trc'.concurrent_program_id AND ctl.fnd_concurrent_programs_vl prog .VALUE)||'_ora_'||oracle_process_id||'.subroutine_name .executable_id=execname. 'File Name: '||execname.concurrent_program_id AND req.req.enable_trace. 'SID Serial: '||ses.serial# .request_id .v$session ses . 'Module : '||ses.NAME='user_dump_dest' AND dbnm.'Running') ||'-'||decode(status_code.

. . TO_CHAR('db_ name' and req.actual_start_dat e ) * 24. . SUBSTR(A. .user_id fl.request_id fcr. ROUND( ( NVL( actual_completion_date.1.fnd_concurrent_requests fcr apps. Scheduled Concurrent Requests SQL query: SELECT . Find out Concurrent Program which enable with trace: col User_Program_Name for a40 col Last_Updated_By for a30 col DESCRIPTION for a30 SELECT A. .paddr(+) and dest.25) DESCRIPTION FROM APPS.fnd_lookups fl apps.lookup_code fcr. TO_CHAR( request_date. FROM .responsibility_name apps.requested_by = fu.USER_NAME.1.description fcr.1. 'n/a') email_address fcr.email_address. To check the timeline of the request : SELECT request_id.application_id and prog.FND_USER B WHERE A.phase_code = 'P' . 'DD-MON-YYYY HH24:MI:SS' ) actual_start_date.meaning fu.40) "User_Program_Name".program_appl ication_id = prog. SUBSTR(B. TO_CHAR( sysdate.fnd_concurrent_programs_vl fcp apps.application_id = execname.USER_ID.DESCRIPTION.lookup_type = 'CP_STATUS_CODE' fcr.printer fcr. .argument_text frt.executable_id=execna me.status_code = fl.CONCURRENT_PROGRAM_NAME "Program_Name". .number_of_copies fcr. WHERE AND AND AND AND AND AND fl.end_date NVL(fu.fnd_responsibility_tl frt fcr.request_date fcr. TO_CHAR( actual_completion_date.description requestor fu.fnd_user fu apps. 'DD-MON-YYYY HH24:MI:SS' ) request_date.concurrent_program_id and req.15) "Last_Updated_By".concurrent_program_id fcr.requested_start_date fcp.LAST_UPDATED_BY=B.FND_CONCURRENT_PROGRAMS_VL A.application_id and prog.concurrent_program_id = fcp.and proc.application_id fcr. 'DD-MON-YYYY HH24:MI:SS' ) actual_completion_date.responsibility_id fcr.concurrent_program_id = prog.program_application_id = fcp. TO_CHAR( requested_start_date. sysdate ) .'DD-MON-YYYY HH24:MI:SS' ) requested_start_date. .USER_CONCURRENT_PROGRAM_NAME. .user_name fu. SUBSTR(B.executable_id.ENABLE_TRACE='Y' AND A. . .addr = ses. .responsibility_id ='user_dump_dest' and dbnm. APPLSYS. . . 'DD-MON-YYYY HH24:MI:SS' ) current_date. 2 ) duration FROM FND_CONCURRENT_REQUESTS WHERE request_id = TO_NUMBER('&p_request_id').

RUNNING_PR OCESSES AS "ACTUAL Processes" FROM APPS.'On Hold' . to_char(actual_co mpletion_date. 'FNDSM_AQHERP'.request_id).'XDP_SMIT_SVC'.'XDP_Q_FA_SVC'.'Service Manager: AQHERP'. 'PASMGR'.'WFALSNRSVC'.'FastFor mula Transaction Manager'.'XDP_Q_WI_SVC'.'AMSDMIN'.FND_CONCURRENT_QUEUES WHERE CONCURRENT_QUEUE_NAME IN ('FNDICM'. 'No Mana ger' .'XDP_Q_FE_READY_SVC'. 'IEU_SH_CS'.'Output Post Processor'.'XDP_APPL_SVC'.'XDP_SMIT _SVC').'Workflow Document Web Services Service'.15) concreq.'UWQ Worklist Items Release f or Crashed session'.'OAM Metrics Collection Manager'.'AMSDMIN'.1.'INV Remote Procedure Manager'.'Complete d'.'FNDCPOPP'.fnd_conc_req_summary_v WHERE request_id = '&req_id' ORDER BY 6 DESC.'Confli ct Resolution Manager'.15) clproc.'Receiving Transaction Manager'. 'Error' .'IEU_SH_CS'. Concurrent Manager Actual Target Process finding script : SELECT DECODE(CONCURRENT_QUEUE_NAME.'dd-mon-yy:hh24:mi:ss') Start_Date.Status Code: select lookup_code.'D'. 'G'.'WMSTAMGR'. 'M'. user_concurrent_program_name.oracle_process_id).'SFM Timer Queue Service'. 'C'.10) reqph. 'XDP_Q_IN_MSG_SVC'. To find concurrent program name.phase code.'XDP_Q_TIMER_SVC'.'Workflow Agent Listener Service'. 'FNDCPOPP'. Phase Code: Select lookup_code.'XDP_APPL_SVC'. 'Normal'. 'XDP_Q_TIMER_SVC'.'RCVOLTM'. 'WFWSSVC'.'XDP_Q_ORDER_SVC'.'SFM SM Interface Test Service') AS "Concurrent Manager's Name".'SFM Event Manager Qu eue Service'. 'INVMGR'.'Workflow Mailer Service'.'XDP_Q_FE_READY_SVC'.'dd-mon-yy:hh24:mi:ss').'Inventory Manager'. 'Warning'.'SFM Work Item Queue Service'. 'XDP_Q_FA_SVC'.'C AQCART Service'.'SFM Fulfillment Actions Queue Service'.'IEU_WL_CS'.1.15) opid.'IEU_WL_CS'. status_code) status_code.1.status code for a given request id? SELECT request_id.'XDP_Q_EVENT_SVC'.'W FMLRSVC'.phase_code) phase_code.'FNDCR M'. to_char(actual_start_date. DECODE(phase_code.'STANDARD'.'SFM Inbound Messages Queue Service'.'FNDICM'.'Standard Manager'. completion_text FROM apps. 'Cancelled' . 'Terminating'.'O AMCOLMGR'. 'STANDARD'. MAX_PROCESSES AS "TARGET Processes". This script will list running concurrent requests: SELECT SUBSTR(LTRIM(req.'PO Document Approval Manager'.'FFTM'.'INVTMRPM'.'WMSTAMGR'. 'H'. 'Marketing Data Mining Manager'.'XDP_Q_ORDER_SVC'.'SFM Order Queue Service'. 'XDP_Q_IN_MSG_SVC'.'INVMGR'.'C_AQCT_SVC'. 'X'. 'WFALSNRSVC'.'WFWSSVC'. 'Terminated'.'SFM Controller Service'.'XDP_CTRL_SVC'. SUBSTR(look.'PASMGR'.'XDP_Q_WI_SVC'.'FNDCRM'.'RCVO LTM'.'FNDSCH'.meaning from fnd_lookups where lookup_type = 'CP_STATUS_CODE' order by lookup_code.'OAMCOLM GR'.'Session History Cleanup'.'FTE_TXN_MANAGER'.'INVTMRPM'. 'FNDSM_AQHERP'.'PA Streamline Manager'. 'T'.'XDP _Q_EVENT_SVC'.'Internal Manager'. 'E'. .os_process_id.'C'.1.'SF M Fulfillment Element Ready Queue Service'.'SFM Application Monitoring Service'.'FFTM'.'WMS Task Archivi ng Manager'.'PODAMGR'.'WFMLRSVC'.'FTE_TXN_MANAGER'.'C_AQCT_SVC'.'PODAMGR'.'Transportation Mana ger'.'FNDSCH'. SUBSTR(proc.'Scheduler/Prereleaser Manager'. 'XDP_CTRL_SVC'. SUBSTR(LTRIM(proc. DECODE(status_code.meaning from fnd_lookups where lookup_type = 'CP_PHASE_CODE'.meaning.

machine machine.meaning. v$process vproc.SUBSTR(look1.1.15) opid.10) svrproc.10) reqst. SUBSTR(look1. This script will map concurrent request information about a specific request id: SELECT SUBSTR(LTRIM(req. fnd_lookups look1.10) svrproc FROM fnd_concurrent_requests req.15) concreq.meaning.lookup_code AND look1.schemaname schema.lookup_code AND look. SUBSTR(proc. v$session vsess WHERE req.lookup_code AND look1. fnd_lookups look.spid spid.addr = vsess.1.lookup_type = 'CP_PHASE_CODE' AND look1.phase_code = look1.meaning.1.status_code = look. AND vproc.username usr.1. SUBSTR(look.request_id).controlling_manager = proc. a.username.spid.1.oracle_process_id = vproc.1.paddr(+). a. fnd_concurrent_processes proc. .concurrent_process_id(+) AND req. Query to display session information: SELECT a. SUBSTR(LTRIM(proc.concurrent_process_id(+) AND req. a.10) reqph.1. fnd_lookups look.1.lookup_type = 'CP_PHASE_CODE' AND req.ORACLE_PROCESS_ID = VPROC.sid sid.request_id = &&reqid AND proc.addr = vsess. a.os_process_id. fnd_lookups look1.serial# serial# FROM fnd_concurrent_requests req.program program FROM v$session a. a.phase_code = look1. vsess.lookup_type = 'CP_STATUS_CODE' AND req. a. b.lookup_code AND look.controlling_manager = proc.spid.osuser cosusr.15) clproc.10) dbuser. v$process vproc.terminal terminal.sid sid. SUBSTR(vproc.process process.10) reqst.status status.username. b. v$session vsess WHERE req. a. vsess.server server. fnd_concurrent_processes proc.10) dbuser. SUBSTR(vsess.status_code = look. SUBSTR(vproc.paddr(+).username sosusr.lookup_type = 'CP_STATUS_CODE' AND req. SUBSTR(vsess.meaning = 'Running' AND PROC.PID(+) AND vproc.1.1.oracle_process_id). a.

/*To Get Current Running SQL*/ SELECT t. 'R:Running'.logfile_name . 2)runtime_se c . Serial# & SPID: SELECT s.10046.application_id AND ROUND (((SYSDATE .SET_EV(1033 .requested_by rqst_by . To Get SID.2) Time_Wait .TO_CHAR (fcr.fcr.concurrent_program_id = fcp.fcr.outfile_name .fcr.fcr.oracle_process_id "oracle_pid/SPID" .os_process_id os_pid .fcr.serial# .request_id rqst_id .paddr.responsibility_id AND fcr. v$process p WHERE f.sql_text FROM v$sqltext t .fnd_concurrent_programs_tl fcp WHERE fcr.status_code LIKE 'R' AND fu.actual_start_date.concurrent_program_id .fnd_user fu .concurrent_program_id cp_id .request_id DESC.status_code) status . 19376 .apps. v$session s . 'DD-MON-YYYY HH24:MI:SS')act_start_date time .spid AND p.responsibility_name . /*To Get The Overall Wait Event Statistics*/ SELECT event .fcr.actual_start_date) * 60 * 24). s.fcr.paddr = b.fnd_responsibility_tl fr .hash_value = s.user_concurrent_program_name cp_name .user_id = fcr.ROUND (((SYSDATE .addr = s.user_name .fcr.responsibility_id = fcr.apps.apps.ROUND (((SYSDATE .ROUND(time_waited/6000.oracle_process_id = p.addr = s.fcp.fnd_concurrent_requests f.type != 'BACKGROUND' AND a.v$session s$process b WHERE a.argument_text . 'R'.fu.requested_by AND fr.spid FROM apps.sql_hash_value ORDER BY piece.concurrent_program_id AND fcr.paddr AND t.fcr. --EXEC DBMS_SYSTEM. 2) > 60 ORDER BY fcr.addr ORDER BY a.spid = 8072 AND p.sid . To Know The Current Wait Event: SELECT * FROM v$session_wait WHERE sid=1322.oracle_session_id . 2) runtime_min .fcr.actual_start_date) * 60 * 60 * 24).total_waits . 12 .p. fcr.'').enable_trace FROM apps.program_application_id = fcp.actual_start_date) * 60 * 24).request_id = 150332400 AND f.DECODE (fcr.fcr. v$process p WHERE p.status DESC / To Get Long Running Concurrent Programs: SELECT fcr.fnd_concurrent_requests fcr .

ROUND (( ( NVL (fcr. apps.requested_by RQST_BY.2) runtime_min .fcr.'C:Completed'.requested_by rqst_by .fcr.actual_start_date.responsibility_name.actual_star t_date)* 60* 24).user_name usern .program_application_id = FCP. apps. FCR.argument_text .fcp.fcr.'E'.TO_CHAR (fcr.fnd_concurrent_programs_tl FCP WHERE --fcr. DECODE(FCR.request_id DESC.responsibility_id = FCR.FCR. To Get The Running History Of A Concurrent Program--modified: SELECT fcr.fcr. 'E:Er ror'. FCP.fcr.concurrent_program_id cp_id .fcr.DECODE (fcr.status_code.actual_completion_date .2) Runtime_Sec.'C'.oracle_session_id o_sid .fcr.enable_trace .ROUND (( ( NVL (fcr.os_process_id gument_text. FCR. ROUND(((FCR.'E:Error'.FROM v$session_event WHERE sid =678 ORDER BY time_waited/6000 DESC. FR.requested_by AND FR.fcr.fcr.2) Run time_Min.responsibility_name -. FCR.'DD-MON-YYYY HH24:MI:SS') Act_End_Date Time.concurrent_program_id AND FCR.OUTFILE_NAME. FCR. apps.request_id = 150336946 fcp.concurrent_program_id = FCP. 'G:Warning'.FCR.request_id RQST_ID. 'DD-MON-YYYY HH24:MI:SS') start_time . TO_CHAR(FCR.actual_completion_date. FU.LOGFILE_NAME.TO_CHAR (fcr. 'E'.fu.fcr.request_id rqst_id -.user_concurrent_program_name CP_NAME . SELECT * FROM fnd_concurrent_requests WHERE request_id = 150331168.actual_completion_date .concurrent_program_id CP_ID.status_code) status . 'C:Completed'.'G:Warning'.actual_start_date)*60*60*24). SYSDATE).fcr.ENABLE_TRACE FROM apps.FCR.user_concurrent_program_name LIKE 'Unisys A/P Standard VAT Audit Tra il Report' AND FU.FCR.actual_completion_date. FCR.application_id ORDER BY FCR. FCR.'Q:Queued'.Oracle_Session_Id .actual_completion_date.status_code) Status.user_id = FCR.user_name.oracle_process_id "oracle_pid/SPID".fr.fcr.fnd_concurrent_requests FCR. SYSDATE).responsibility_id AND FCR.actual_star t_date)* 60* 60* 24).concurrent_program_id.oracle_process_id "oracle_pid/SPID" . TO_CHAR(FCR.fnd_responsibility_tl FR. To Get The Running History Of A Concurrent Program: SELECT FCR.2) runtime_sec .'DD-MON-YYYY HH24:MI:SS') Act_Start_DateTim e.outfile_name .os_process_id os_pid .'C'. ROUND(((FCR. 'DD-MON-YYYY HH24:MI:SS')end_time . FCR. 'G'.user_concurrent_program_name cp_name .actual_start_date.'Q'. SYSDATE.fnd_user FU.FCR.logfile_name .actual_start_date)*60*24).status_code .'G'.actual_completion_date.

apps. TO GET THE FAMILY PATCH LEVEL: SELECT patch_level FROM FND_PRODUCT_INSTALLATIONS WHERE patch_level LIKE '%CSI%' .'0 5-MAR-2008'.fnd_responsibility_tl fr .fnd_concurrent_programs_vl p . SELECT TO_CHAR(SYSDATE.fnd_executables_tl application_id = 20006 description LIKE 'Unisys AP Invoice Import Interface'.status_code IN ('R'. Executable .concurrent_program_id AND fcr.fnd_concurrent_programs_tl fcp WHERE --fcr.executable_application_id = e.concurrent_program_id = fcp.actual_completion_date . Execution Method : SELECT FROM WHERE SELECT FROM WHERE AND * apps.fnd_concurrent_requests fcr .fnd_concurrent_requests WHERE concurrent_program_id =40856 GROUP BY TRUNC(apps.user_concurrent_program_name .application_id AND fu. COUNT(*) COUNT FROM apps.actual_start_date DESC --ORDER BY runtime_min DESC.apps.fcr.lookup_code = e.fnd_concurrent_programs_tl user_concurrent_program_name LIKE 'Trans%'.'Q')) ORDER BY fcr.request_id = 150336946 fcp.request_id DESC --ORDER BY runtime_min DESC.requested_by --AND (fcr.executable_id = e.actual_start_date).e.fcr.actual_start_date) * 60 * 2 4).fnd_lookups l WHERE lookup_type = 'CP_EXECUTION_METHOD_CODE' AND l.execution_file_name . To Get Number Of Times A Concurrent Program Is Run: SELECT p.apps.concurrent_program_id .fnd_user fu . 'DD-MON-YYYY') IN ('04-MAR-2008'.'06-MAR-2008') --AND ROUND (((fcr. To Get Number Of Times A Concurrent Program Is Run: SELECT TRUNC(apps.application_id. * apps.fnd_concurrent_requests.user_concurrent_program_name LIKE 'Unisys Customer Re-Tiering Open O rders Report' --AND TO_CHAR (fcr.program_application_id = fcp.executable_name FROM apps.apps.user_concurrent_program_name =:User_Control_Program_Name AND p.responsibility_id AND fcr. .actual_start_date) DATE_run .fnd_concurrent_requests.FROM apps.responsibility_id = fcr.execution_method_code) TYPE .executable_id AND p.'dd-MON-RR HH:MM:SS') FROM dual.user_id = fcr.2) > 60 AND fr. To Get The Details About Concurrent Program.fnd_executables e WHERE p.e. (SELECT meaning FROM apps.actual_start_date.

username IS NOT NULL AND sesion.sid.executions .hash_value. (cpu_time / 1000000) "CPU_Seconds". (elapsed_time / 1000000) "Elapsed_Seconds". v$session sesion WHERE sesion.logon_time. CASE WHEN rows_processed = 0 THEN NULL ELSE (buffer_gets / NVL(REPLACE(rows_processed. 0. v$session.consistent_gets.q.fnd_tables ORDER BY table_name.SET_EV(818 . sess_io. 1)) END "Buffer_gets/rows_proc". 22295 . buffer_gets "Buffer_Gets".rows_processed .v$sql q WHERE s.fetches .block_changes.sql_hash_value = q. v$sql. No of physical GETs: SELECT sess_io.'DD-MON-RR HH:MI:SS AM') sql_load FROM v$session s .sid = sess_io.SELECT * FROM apps. 1). .sid. 1). sess_io.users_opening .process = (SELECT os_process_id FROM fnd_concurrent_requests WHERE requ est_id = 18855640) AND s.fnd_executables WHERE executable_id = 7157.q.q. sess_io.MODULE "Module".sid = 678 . sess_io. To Get details On A Table: SELECT * FROM apps. (buffer_gets / NVL(REPLACE(executions. disk_reads "Disk_Reads". TOP_SQL by different parameters: SELECT v$session.last_call_et --.TO_CHAR (TO_DATE (q. 12 .physical_reads.10046.''). /*To Get Details On An Object*/ SELECT * FROM all_objects WHERE object_name LIKE 'V$%'.sid AND sesion.TO_CHAR (s.first_load_time.serial#.block_gets.consistent_changes FROM v$sess_io sess_io.q. No of sec elapsed since the last call made to the database: SELECT s. executions "Executions".q. 'RRRR-MM-DD/HH24:MI:SS'). /*To Enable Trace From Back End*/ EXEC DBMS_SYSTEM. 1)) "Buffer_gets/execu tions".sql_text . 'DD-MON-RR HH:MI:SS AM') session_logon . 0. sess_io.

v$session WHERE v$sql.application_id = execname. d. 'Trace id: ' || oracle_process_id. Name: ' || prog.request_id request.program_application_id = prog. SELECT * FROM fnd_concurrent_programs WHERE CONCURRENT_PROGRAM_ID = 36034. disk_reads DESC .serial#. v$parameter dest. executions DESC nulls last. 'Normal').application_id AND prog.executable_id SELECT * FROM apps. 'Module : ' || ses.hr_organization_information hoi2 WHERE hoi2.request_id = '&request' AND req.paddr(+) AND dest.parent_request_id.SID || '.spid(+) AND proc. /*Script to get the trace file name from request_id*/ SELECT 'Request id: ' || request_id. v$session ses.meaning phase. 'Prog.hash_value = v$session.parent_request_id ) PARENT. fnd_executables execname WHERE req.1)) DESC .trc '.VALUE || '/' || LOWER (dbnm.enable_trace. 'Status : ' || DECODE (phase_code. v$parameter dbnm.SUBSTR(sql_text.concurrent_program_id = prog.application_id AND prog. 'R'.executable_id = execname.addr = ses.program.concurrent_program_id AND req. b.0.sql_hash_value ORDER BY cpu_time DESC .' || ses. 'SID Serial: ' || ses. DECODE (b.user_concurrent_program_name.NAME = 'user_dump_dest' AND dbnm. fnd_concurrent_programs_vl prog. SID for completed request: SELECT DISTINCT b.requestor. 500) "SQL" FROM v$sql.subroutine_name. 'Trace Flag: ' || req.execution_file_name || execname. . -1.module FROM fnd_concurrent_requests req. 'File Name: ' || execname.oracle_process_id = proc. '-------'. 'R'.org_information3 = '29'.NAME = 'db_name' AND req. 1. b.1). buffer_gets DESC .VALUE) || '_ora_' || oracle_process_id || '. 'Running') || '-' || DECODE (status_code. (buffer_gets/NVL(REPLACE(rows_processed. b. v$process proc. 'Trace Name: ' || dest.

user_id = fcr. 2) runtime_min .status_code .fnd_user fu . e. CCM-completed-With-Error: SELECT fcr. (SELECT lookup_code.actual_start_date) * 60 * 24).lookup_code AND d.status_code.os_process_id) fndpid.concurrent_program_id cp_id .fcr.fcr.null.concurrent_program_id = fcp.SID SI D.apps.responsibility_name .apps.fnd_concurrent_programs_tl fcp WHERE fcr.phase_code = d.actual_completion_date.concurrent_program_id AND fcr.requested_by rqst_by .oracle_session_id . 'DD-MON-YYYY HH24:MI:SS') > '27-F . lookup_type FROM fnd_lookups WHERE lookup_type = 'CP_PHASE_CODE') d.status_code = c. 'R'.TRIM (c.fcr.argument_text .enable_trace FROM apps.application_id AND to_char (fcr. gv$session e. fnd_concurrent_requests a.status_code not in ('C'.oracle_process_id "oracle_pid/SPID" . 'DD-MM-YY-HH24:mi') rdate.meaning) status.actual_completion_date.lookup_code AND b.oracle_process_id AND e.DECODE (fcr.ROUND (((SYSDATE .fcr.request_id='&REQUEST_ID' AND (fcr.fcr.status_code) status .program_application_id = fcp.request_id DESC.actual_start_date.'-----'. fcr.fcr.request_id rqst_id .TO_CHAR (fcr.lookup_type = 'CP_STATUS_CODE' AND b. f.phase_code .addr ORDER BY b. fnd_lookups c.fcr.description request_set_name .fcp. 'DD-MON-YYYY HH24:MI:SS') act_completion_date time .request_date.spid spid.paddr(+) = f. decode(os_process_id.fcr.responsibility_id = fcr. TO_CHAR (a.user_name . gv$process f WHERE b.outfile_name .inst_id server FROM fnd_conc_req_summary_v b. e. 'DD-MON-YYYY HH24:MI:SS') act_start_datetime . meaning.fcr.fcr.fcr.fu.fcr.apps.fnd_concurrent_requests fcr . 'R:Running'.fcr.request_id AND f.responsibility_id AND fcr.fnd_responsibility_tl fr .user_concurrent_program_name cp_name .spid(+) = a.lookup_type = 'CP_PHASE_CODE' AND b.'G') AND fu.request_id = a.logfile_name .requested_by AND fr.phase_code ='C' AND fcr.os_process_id os_pid .

Find out request id from Oracle_Process Id: select REQUEST_ID.ROUND (((SYSDATE .apps.DECODE (fcr.fcr.s.status_code.fcr.actual_completion_date DESC.actual_start_date.phase_code .enable_trace FROM apps.OS_PROCESS_Id from apps.action from gv$session s.SCHEMANAME.status.fcr.fcr.fcr.s. gv$process p WHERE s.outfile_name .p.user_name .apps.actual_completion_date.username.paddr = p. 'R'. s.application_id AND to_char (fcr.addr and s.actual_completion_date.TO_CHAR (fcr.fcr. MACHINE.actual_completion_date DESC.fnd_responsibility_tl fr .fnd_user fu . 'DD-MON-YYYY HH24:MI:SS') act_completion_date time .fr.user_concurrent_program_name cp_name .oracle_process_id "oracle_pid/SPID" .responsibility_id AND fcr.ORACLE_PROCESS_ID.INST_ID. fcr. 'DD-MON-YYYY HH24:MI:SS') > '27-F EB-2012 03:25:42' ORDER BY fcr.requested_by rqst_by .concurrent_program_id = fcp. CCM-completed-With-Warning: SELECT fcr. 'DD-MON-YYYY HH24:MI:SS') act_start_datetime .concurrent_program_id AND fcr.program_application_id = fcp.fcr.s.spid os_pid.fnd_concurrent_reque . Concurrent request status for a given sid: col MODULE for a20 col OSUSER for a10 col USERNAME for a10 set num 10 col MACHINE for a20 set lines 200 col SCHEMANAME for a10 select s.fnd_concurrent_requests fcr .sid.fu.sid = '&or acle_sid'.oracle_session_id . s.status_code .serial#.phase_code ='C' AND fcr.fcr.user_id = fcr.apps.requested_by AND fr.EB-2012 03:25:42' ORDER BY fcr.logfile_name .osuser.s.status_code in ('G') AND fu.fcp. 2) runtime_min .fcr.MODULE.fnd_concurrent_programs_tl fcp WHERE fcr.fcr. s.s.request_id rqst_id .description request_set_name .argument_text .concurrent_program_id cp_id .fcr.fcr.status_code) status .responsibility_name .TO_CHAR (fcr. s.os_process_id os_pid .actual_start_date) * 60 * 24).fcr.responsibility_id = fcr. 'R:Running'.

parent_request_id.completion_text FROM apps.'||serial#||''' immediate.PARENT_REQUEST_ID. 'T'.'On Hold' . DE CODE(sum.address(+) and ses.phase_code.fnd_concurrent_requests req where re q. 'Terminated'.sts where ORACLE_PROCESS_ID='&a'.status_code) status_code.sum.phase_code) phase_code. OR ACLE_SESSION_ID.sid='&oracle_sid' / To find child requests for Parent request id: set lines 200 col USER_CONCURRENT_PROGRAM_NAME for a40 col PHASE_CODE for a10 col STATUS_CODE for a10 col COMPLETION_TEXT for a20 SELECT sum.request_id=sum.hash_value(+) and ses. set col os_process_id for 99 select HAS_SUB_REQUEST. --get the list of all conc managers and max worker and running workers CURSOR conc_que IS SELECT concurrent_queue_id.user_concurrent_program_name. 'Normal'.sql_hash_value = sql. 'Warni ng'. 'Error' .'C'. sum.req. 'G'.'D'. running_processes FROM apps. 'C'. 'H'. gv$sqlarea sql where ses. 'M'.PARENT_REQUEST_ID = '&parent_concurrent_request_id'. 'No Manager' . user_concurrent_queue_name. 'E'. pending_count NUMBER := 0. OS_PROCESS_ID from fnd_concurrent_requests where request_id= '&Req_ID' . sum.sum. DECODE(sum. 'Cancelled' .'Completed'. To find the sql query for a given concurrent request sid: select sid. To terminate the all concurrent requests using by Module wise: select 'ALTER SYSTEM KILL SESSION '''||sid||'.' from g v$session where MODULE like 'GLPREV'.request_id.status_code.sql_text from gv$session ses. Concurrent QUEUE Details: set echo off set linesize 130 set serveroutput on size 50000 set feed off set veri off DECLARE running_count NUMBER := 0.actual_star t_date. crm_pend_count NUMBER := 0. ORACLE_PROCESS_ID.sql_address = sql.fnd_concurrent_queues_vl WHERE enabled_flag='Y' and concurrent_queue_name not like 'XDP%' and concurrent_queue_name not like 'IEU%' and . 'Terminating'. concurrent_queue_name.request_id and req. sum. sum. max_processes.actual_completion_date. 'X'. is_SUB_REQUEST. apps.fnd_conc_req_summary_v sum.

' ')|| rpad(i. END LOOP. END.fnd_concurrent_worker_requests b WHERE a. 1. DBMS_OUTPUT.' ')|| rpad(crm_pend_count. --print the output by joining the outputs of manager counts.'_')|| rpad(i. DBMS_OUTPUT. DBMS_OUTPUT.running_processes.concurrent_queue_id AND hold_flag != 'Y'. 0)).10.request_id and concurrent_queue_id = i. BEGIN DBMS_OUTPUT.concurrent_queue_name.15.fnd_concurrent_worker_requests a WHERE concurrent_queue_id = 4 AND hold_flag != 'Y' AND requested_start_date <= sysdate AND exists ( SELECT 'x' FROM apps.8.PUT_LINE('---------------------------------------------------------------------------------------------------'). nvl(sum(decode(phase_code.concurrent_queue_id. 0)).concurrent_queue_id AND hold_flag != 'Y' AND requested_start_date <= sysdate).PUT_LINE('========================================================== =========================================='). --for each manager get the list of requests pending due to conflicts in each man ager SELECT /*+ RULE */ count(1) INTO crm_pend_count FROM apps. FOR i IN conc_que LOOP --for each manager get the number of pending and running requests in each queue SELECT /*+ RULE */ nvl(sum(decode(phase_code.max_processes.6.user_concurrent_queue_name.concurrent_queue_name not in ('ARTAXMGR'.'PASMGR') . / set verify on set echo on CCM Failed jobs: select fcr.' ')|| rpad(running_count.40. fcr.' ')).parent_request_id. 0).PUT_LINE('========================================================== ==========================================').10. DBMS_OUTPUT.PUT_LINE( rpad(i.6. 'P'.request_id=b. 'R'. --DBMS_OUTPUT. 1.request_id. 0) INTO running_count.' ')|| rpad(pending_count.10.PUT_LINE('QueueID'||' '||'Queue '|| 'Concurrent Queue Name '||' '||'MAX '||' '||'RUN '||' '|| 'Running '||' '||'Pending '||' '||'In CRM'). .PUT_LINE('========================================================== =========================================='). pending_count FROM fnd_concurrent_worker_requests WHERE requested_start_date <= sysdate and concurrent_queue_id = i.' ')|| rpad(i. ' ')|| rpad(i.

request_id .request_id. 'Inactive'. 'Waiting'. fcpt.responsibility_id order by fcr.oracle_id . decode(fcr. fnd_concurrent_programs fcp.responsibility_key responsibility. fnd_user fu. 'Pending'. 'T'. 'E'. 'H'. 'On Hold'.last_update_date. 'Normal'.phase_code.responsibility_id = fr. 'E'. 'Scheduled'. b. 'D'. 'Z'.os_process_id .status_code . 'Standby'. 'W'. 'Normal'. decode(fcr. 'B'. 'No Manager'.completion_text from fnd_concurrent_requests fcr. fnd_concurrent_programs_tl fcpt. fcr. 'R'. 'I'.concurrent_program_id = fcp. 'Suspended'.status_code. a.status_code in ('D'.user_name requestor.concurrent_program_id and fcr. 'Running') phase. 'F'.REQUEST_DATE. 'U'. fcr. 'A'.fu.last_update_date > sysdate . 'Error'. 'S'. 'X'. 'T'. 'MON-DD-YYYY HH24:MM:SS') LAST_UPDATE. 'Warning'. 'Cancelled'. 'Paused'.concurrent_program_id = fcpt. 'Resuming'. 'Q'. 'I'.phase_code = 'C' and fcr.concurrent_program_name. 'G'.user_id = fcr. fr. 'Terminated'. fnd_responsibility fr where fcr. 'Terminating'. a. 'X') and fcr. Show the concurrent manager job status: SELECT a.'DD-MON-YYYY HH24:MI:SS') Req_Date . a.user_concurrent_program_name. to_char(a. 'Waiting') status.requested_by .last_update_date. c. to_char(fcr. a. 'S'.concurrent_program_id and fcr.argument_text. 'M'. 'C'. 'Disabled'. 'C'. 'R'. 'Completed'. 'P'.phase_code .requested_by and fcr.1 and fu. fcp. fcr.user_name . 'Normal'.

oracle_process_id AND a. v$process = b. applsys.fnd_concurrent_processes b.concurrent_process_id = a.'247320592'. apps.request_id = &req_id AND A.oracle_process_id AND A.fnd_concurrent_processes b. c.controlling_manager = b.. applsys. phase_code.fnd_concurrent_requests a. CCM-PLSQL-Find: SELECT request_id.serial# = d.spid FROM apps. logfile_name FROM FND_CONCURRENT_REQUESTS WHERE REQUEST_ID in ('41261937'.serial# AND a. SELECT OUTFILE_NODE_NAME.controlling_manager AND a. Change The PHASE CODE.PHASE_CODE = 'C'.request_id.SPID: SELECT a.To Find oracle SID.'247319626'.pid = b.request_id.controlling_manager = b.fnd_concurrent_requests a.concurrent_process_id AND c. d. v$process c WHERE c.'247319378' ).request_id = &req_id ) AND a.phase_code in ('R'.concurrent_process_id AND c. 'T') ORDER BY a.requested_by = b. ORACLE SPID find from Conc Request_ID: SELECT a. . apps.completion_text FROM applsys.spid IN ( SELECT c.user_id AND c. requested_by. logfile_node_name.concurrent_process_id AND c.sid. v$process c WHERE a.fnd_concurrent_requests a .'247319556' = b.spid FROM apps. c. v$session d WHERE a.'41234458'. d.os_process_id / Output file find script : SELECT OUTFILE_NODE_NAME.oracle_process_id AND c.PHASE_CODE = UPPER('&phase').fnd_concurrent_processes b. apps.serial# FROM apps..fnd_user b .OUTFILE_NAME.OUTFILE_NAME FROM FND_CONCURRENT_REQUESTS WHERE REQUEST_ID in ('247321000'.controlling_manager = b.'41234160').fnd_concurrent_requests a.fnd_concurrent_processes c WHERE a. a.

a.application_id and d.application_id = b.request_unit_id and b.application_id = c. fnd_responsibility d. USER-ID find Script: Input: Requestor Name SELECT user_id.concurrent_program_id = c. a.actual_completion_date-fcr. enable_trace FROM FND_CONCURRENT_REQUESTS WHERE REQUEST_ID = TO_NUMBER('&p_request_id'). Find the Responsibility name from which a concurrent program can be run: select distinct a.request_id request_id. fnd_responsibility_tl e where a.and a. a. os_process_id.plsql_dir.user_concurrent_program_name like 'XX%' and a.application_id -. user_name.REQUEST_ID = '&REQUEST_ID' and cp. FND_CONCURRENT_PROCESSES CP WHERE CR. program_application_id.responsibility_name from fnd_concurrent_programs_tl a. e.request_group_id.application_id = e. .request_group_id = c. TRUNC(((fcr. Query can be executed to identify requests based on the number of minutes the re quest ran: SELECT fcr.plsql_log FROM FND_CONCURRENT_REQUESTS CR.request_group_id and b.actual_start_date)/(1/24))*60) exec_time. cp. fnd_request_group_units c. concurrent_program_id.request_group_id = d. fnd_request_groups b. description FROM FND_USER WHERE USER_name = '&P_REQUESTED_BY'.concurrent_process_id = cr.responsibility_id = e.application_id. request_group_name.responsibility_id and a.plsql_out. oracle_process_id.concurrent_program_id = '45220'. b.concurrent_program_id. oracle_session_id.user_concurrent_program_name.request_group_id and d. controlling_manager. Find PLSQL from request_id: select cp.application_id and b.description. cp.status_code.controlling_manager.

fnd_concurrent_requests f WHERE f.application_id and fcpt.actual_start_date start_date.actual_start_date is not null ORDER by f. 2011 || ' HOURS ' || floor((((f.actual_start_date)*24*60*60)/3600)*360 0)/60) || ' MINUTES ' || round((((f.45) and fcr.'C'.'ALECDC'.language = USERENV('Lang') and f.application_id AND pt.actual_completion_date-f.concurrent_program_name) concurrent_program_name.actual_start_date desc. f.'Running'.fnd_concurrent_programs_tl pt. f. fnd_concurrent_requests fcr WHERE TRUNC(((fcr.phase_code) Phase.concurrent_program_id = fcp.actual_completion_date-f.p.language = USERENV('Lang') ORDER BY TRUNC(((fcr.concurrent_program_id = p.program_application_id = fcpt.actual_completion_date-f.actual_start_date)*24*60*60) floor(((f.'R'.concurrent_program_name conc_prog.concurrent_program_id = fcpt. DECODE(p.actual_completion_date actual_completion_date.actual_start_date actual_start_date .concurrent_program_id = pt.request_id .concurrent_program_name. fnd_concurrent_programs_tl fcpt. apps.concurrent_program_id and f.actual_completion_date-fcr.actual_completion_date-f.description||']'.application_id and f.fnd_concurrent_programs p.concurrent_program_id and fcr.'Complete'.actual_completion_date-f.program_application_id = pt.actual_start_date)*24*60*60)/3600)*360 0 (floor((((f. concurrent_program_name||'['||f.actual_completion_date-f. fcpt.actual_start_date)*24*60*60)/3600)*360 0)/60)*60) )) || ' SECS ' time_difference.f.concurrent_program_id and fcr.program_application_id = fcp.concurrent_program_id and f.program_application_id = p. decode(f.actual_start_date)*24*60*60) floor(((f. Request Status Listing: Purpose: To calculate request time Description : This query will shows report processing time SELECT f.application_id and fcr. floor(((f.user_concurrent_program_name user_conc_prog FROM fnd_concurrent_programs fcp. fcp.actual_completion_date-f. f.actual_start_date)/(1/24))*60) > NVL('&mi n'.user_concurrent_program_name user_concurrent_program_na me . . pt.actual_start_date)*24*60*60)/3600) AUG. p.actual_start_date)/(1/24))*60) desc.fcr. apps.actual_completion_date-fcr.actual_start_date)*24*60*60) floor(((f.actual_completion_date-f.status_code FROM apps.phase_code.

CONCURRENT_PROCESS_ID AND C.ADDRESS AND A.CONTROLLING_MANAGER = B.controlling_manager AND c. E.ORACLE_PROCESS_ID AND B.SESSION_ID = D.requested_by = d. SERIAL#.concurrent_program_id and a.SERIAL#. WAIT_CLASS.SID.SQL_ADDRESS = B.OSUSER.concurrent_process_id = c.FND_CONCURRENT_PROCESSES B.responsibility_id and a.concurrent_program_id.SQL_TEXT FROM APPS. SECONDS_IN_WAIT V$SESSION BLOCKING_SESSION IS NOT NULL BLOCKING_SESSION. D.fnd_concurrent_queues_vl b . D.SID.user_id and user_name like 'PRUDHVIA'. a.responsibility_id = c. D.PROCESS.REQUEST_ID = '&REQUEST_ID'. fnd_concurrent_programs_tl b.fnd_responsibility_tl c. outfile_name from f nd_concurrent_requests a. status_code. responsibility_name.SQL_TEXT FROM V$SESSION A.USERNAME = 'APPS'. V$SQL E WHERE A. SID. D. a.fnd_user d where a.REQUEST_ID. V$SQLAREA B WHERE A. requested_by.responsibility_id. argument_text. SQL STATEMENTS RUNNING BY A USER: SELECT A.GET THE CURRENT SQL STATEMENT RUNNING FOR A CONCURRENT REQUEST: SELECT A.PID = B. APPS.user_concurrent_queue_name FROM fnd_concurrent_processes a .SQL_ADDRESS = E. C.CONCURRENT_PROGRAM_ID = b.AUDSID AND D.SERIAL#. GET THE BLOCKING SESSIONS: SELECT FROM WHERE ORDER BY BLOCKING_SESSION. request_id.concurrent_queue_id = b.FND_CONCURRENT_REQUESTS A. V$PROCESS C.SPID.concurrent_queue_id AND a.ADDRESS AND A. Display status of all the Concurrent Managers: . A. request_date. Determine which manager ran a specific concurrent request: SELECT b. user_name.fnd_concurrent_requests c WHERE 1=1 AND a. logfile_name. V$SESSION D. B.request_id = &request_id / Find from which responsibility user has ran the concurrent program: select distinct user_concurrent_program_name. phase_code.

fcr.fcr.Concurrent_Queue_ID = P.logfile_name .fcr.Concurrent_Queue_Name .fcr.user_name .fu. 'MM-DD-YYYY HH:MI:SSAM') Started_At from Fnd_Concurrent_Processes P.fcr. Q.requested_by rqst_by .fcr. FND_V$Process where Q.responsibility_id = fcr.fcr.os_process_id os_pid .status_code) status .process_status_code Status.actual_completion_date. Error Request Details: SELECT fcr.status_code not in ('C'.fcr.Concurrent_Queue_Name Manager.fnd_responsibility_tl fr .user_id = .status_code.fcr. Fnd_Concurrent_Queues Q.'S') Order by Concurrent_Process_ID.apps. fcr.status_code .apps.phase_code .fr.actual_completion_date DESC. 'DD-MON-YYYY HH24:MI:SS') act_completion_date time . P.fcp.oracle_process_id ""oracle_pid/SPID"" .fcr. 'R:Running'.user_name . 'DD-MON-YYYY HH24:MI:SS') > '27-F EB-2012 03:25:42' ORDER BY fcr. Warning Request Details: SELECT fcr.requested_by AND fr.fnd_concurrent_requests fcr .'G') AND fu.oracle_session_id . 2) runtime_min . Os_Process_Id.DECODE (fcr.fu.Process_Start_Date.argument_text .application_id AND to_char (fcr.request_id rqst_id .concurrent_program_id cp_id .fcr.responsibility_name .user_concurrent_program_name cp_name .program_application_id = fcp.actual_start_date) * 60 * 24).responsibility_name .concurrent_program_id AND fcr.actual_start_date.apps.TO_CHAR (fcr. To_Char(P.description request_set_name .fcr. PID Opid.actual_completion_date. Q.request_id rqst_id .concurrent_program_id = fcp.enable_trace FROM apps. 'DD-MON-YYYY HH24:MI:SS') act_start_datetime .Select distinct Concurrent_Process_Id CpId.fcr.ROUND (((SYSDATE .fcr.TO_CHAR (fcr.requested_by rqst_by .status_code .fnd_user fu .oracle_session_id .responsibility_id AND fcr.Concurrent_Queue_ID) And ( Spid = Os_Process_ID ) And Process_Status_Code not in ('K'.phase_code .Application_Id = Queue_Application_ID And (Q. Os_Process_ID Osid. 'R'.fnd_concurrent_programs_tl fcp WHERE fcr.fcr.phase_code ='C' AND fcr.fcr.

fcr.'Normal'.'Cancelled'.'Disabled'.program_application_id = fcp.3) * 14 40).concurrent_program_id AND fcr.responsibility_id = fcr.fnd_concurrent_requests fcr .enable_trace FROM apps.3) * 1440 as Run_Tim e.'Scheduled'.user_concurrent_program_name Request_Name. 'P'. 'I'.concurrent_program_id cp_id . DECODE(fcr.fcp.fcr.2) wait_time.fcr.'Normal'. 'I'.phase_code ='C' AND fcr.fcr.'Waiting'.'Terminating'.TO_CHAR (fcr. 'R:Running'. 'DD-MON-YYYY HH24:MI:SS') > '27-F EB-2012 03:25:42' ORDER BY fcr. 'W'.'Waiting'. 'E'. 'B'.fnd_user fu .actual_start_date).apps. 'S'.'Incactive'.fnd_concurrent_programs_tl fcp WHERE fcr. fu. fcr. 'U'. 'H'.actual_start_date.'On Hold'.actual_completion_date DESC.actual_start_date) * 60 * 24).status_code) status .status_code in ('G') AND fu.requested_start_date). 'R'.'Error'.actual_completion_date. Script to get all the Concurrent Program Request details: select request_id. 'C'. fcpt.fcr.'Pending'. 'D'.'No Manager'. round(avg(round(to_number(actual_start_date .argument_text .TO_CHAR (fcr.'N/A') status. 'DD-MON-YYYY HH24:MI:SS') act_completion_date time . .fcr.fcr.apps.. 'P'.concurrent_program_id = fcp.actual_completion_date. 'R'. parent_request_id.'Paused'.'Suspended'.fcr.'Completed'.application_id AND to_char (fcr. 'A'.outfile_name .'Terminat ed'. 'X'.'Warning'.actual_completion_date .ROUND (((SYSDATE .'Normal'.description request_set_name . 'Q'.user_id = fcr. 'C'.DECODE (fcr.status_code.responsibility_id AND fcr. 'G'.'Resuming'. 2) runtime_min .'Running') phase.'Standby'. 'R'.fnd_responsibility_tl fr .apps.fcr.status_code.fcr.os_process_id os_pid .phase_code. 'T'. 'Z'. 'DD-MON-YYYY HH24:MI:SS') act_start_datetime .logfile_name . 'M'. DECODE(fcr.oracle_process_id ""oracle_pid/SPID"" . round((fcr.fcr.requested_by AND fr.User_Name Requestor.user_concurrent_program_name cp_name .user_concurrent_program_name program_name. fcpt.

actual_completion_date.concurrent_program_id cp_id .user_id and fcpt.fcr. apps.fcr. fcr.resubmit_inter val. fcr. 'DD-MON-YYYY HH24:MI:SS') act_completion_date time . fcr.fcr.and fcr.program_application_id = fcp. fcr. to_char(actual_start_date.status_code = 'C' GROUP BY request_id.ROUND (((SYSDATE .fnd_concurrent_requests fcr .apps.fnd_user fu . Find out Error jobs: SELECT fcr.phase_code . 'MM/DD/YY HH24:mi:SS') ACT_COMP.requested_by = fu.and fu. fcr.and fcpt.fcr.responsibility_name .requested_by rqst_by . fcr.completion_text. 'MM/DD/YY HH24:mi:SS') ACT_START.actual_start_d ate. (fcr. 2) runtime_min .fnd_user fu Where 1=1 -.actual_start_date.fu.description request_set_name . 'MM/DD HH24:mi:SS') requested_start. fcr.fnd_concurrent_programs_tl fcp WHERE fcr. fcr.concurrent_program_id and fcr.phase_code ='C' . fcpt.fcr.TO_CHAR (fcr.phase_code = 'C' -. apps. to_char (fcr.user_name . 'DD-MON-YYYY HH24:MI:SS') act_start_datetime .fnd_concurrent_programs_tl fcpt.status_code) status .fcp.actual_start_date like sysdate -.User_Name.fnd_concurrent_programs fcp.user_concurrent_program_name.application_id = fcpt.request_id rqst_id .fcr. 'R:Running'.resubmit_interval_unit_code.user_concurrent_program_name = 'Payables Open Interface Import'' and fcr. fcr.oracle_session_id .status_code.actual_start_date) * 60 * 24).apps. apps.phase_code.os_process_id os_pid .fcr. to_char(actual_completion_date.user_concurrent_program_name cp_name .user_name = 'DJKOCH' ' -. fcr.and fcr. fcr. parent_request_id.description Order by 1 desc.argument_text. requested_start_date.oracle_process_id "oracle_pid/SPID" .apps.language = 'US' and fcr. fcr.fcr.resubmit_interval.fnd_concurrent_requests fcr.argument_text parameters.concurrent_program_id = fcpt. 'R'.actual_completion_date.and hold_flag = 'Y' -.fnd_responsibility_tl fr .fcr.argument_text .concurrent_program_id and fcp.fcr.outfile_name .enable_trace FROM apps.status_code .status_code.fcr.concurrent_program_id = fcp.fcr.and fcr.application_id and fcr.request_id = 1565261 -.fcr.DECODE (fcr.logfile_name . fcr.application_id and fcp.completion_text From apps.

user_concurrent_program_name . (SELECT con. fnd_concurrent_programs cprog.actual_completion_date.sysdate) >= creq_run.application_id) AND (creq_run.concurrent_program_id ) req .concurrent_program_id = req.request_id.req.responsibility_id AND fcr.phase_code .actual_completion_date.fnd_concurrent_programs_vl con WHERE 1 = 1 AND con.req.status_code . 'DD-MON-RR HH24:MI:SS') ac tual_completion_date_run FROM fnd_concurrent_requests creq_run.actual_start_date ) AND (creq_base.actual_completion_date. Start And End Dates of a Parent Concurrent Request and all Child Processes: SELECT creq_run.argument_text.parent_request_id FROM fnd_concurrent_requests req .concurrent_program_id = cprog.requested_by AND fr. to_char(creq_run.actual_completion_date.'G') AND fu.req.actual_start_date.req.req.actual_completion_date.req.concurrent_program_id = fcp.AND fcr.request_date . to_char(creq_base.req.* FROM (SELECT con.req.request_id = &REQUEST_NUMBER)).program_application_id = fcp. 'DD-MON-RR HH24:MI:SS') act ual_completion_date_run.concurrent_program_id = req. to_char(creq_run.concurrent_program_id ) req_set. cprog. creq_run.sysdate) ) AND (creq_base.user_concurrent_program_name . to_char(creq_base.request_id . parent_request_id FROM fnd_concurrent_requests req .concurrent_program_name.application_id AND to_char (fcr. 'DD-MON-RR HH24:MI:SS') actual_ start_date_run. Query to find subrequests for a submitted request set: SELECT req. 'DD-MON-YYYY HH24:MI:SS') > '25-S EP-2012 04:00:00' ORDER BY fcr.status_code.actual_completion_date DESC.status_code not in ('C'.user_id = fcr. 'DD-MON-RR HH24:MI:SS') actual_s tart_date_run.responsibility_id = fcr.requested_start_date .concurrent_program_id AND fcr.concurrent_program_id) AND (nvl(creq_base.fnd_concurrent_programs_vl con WHERE 1 = 1 AND con.actual_start_date <= nvl(creq_run.req.request_id .program_application_id = cprog.actual_start_date.actual_completion_date .phase_code . fnd_concurrent_requests creq_base WHERE ( (creq_run.

fnd_conc_req_summary_v v WHERE r. HISTORY OF CONCURRENT REQUEST . 'B'. 'X'.'Scheduled'. 'I'.substr(u. outfile_node_name.'I') requested_start_date > SYSDATE hold_flag = 'N'.request_id=r. 'Z'. apps.requested_by=22378 AND r. 'T'.'Error'.'C'. 'A'.'Pending'.'Waiting') "Status".parent_request_id = 88564179 -.'Normal'.'Terminating'.'Inactive'.fnd_concurrent_programs p .'P '.request_id ='2260046' in ('13829387'.concurrent_program_id AND r.'Waiting'. Find the Scheduled Requests: select from where and and request_id fnd_concurrent_requests status_code in ('Q'. 'D'. outfile_name. to_char(r. 'C'.CONCURRENT_PROGRAM_ID = p.SCRIPT (PROGRAM WISE) : set pagesize 200 set linesize 200 col "Who submitted" for a25 col "Status" for a10 col "Parameters" for a20 col USER_CONCURRENT_PROGRAM_NAME for a42 SELECT distinct t.argumen t_text "Parameters". 'NA') phasecode. 'H'.'Warning'. 'F'. apps.'Terminated'.'Disabled'. logfile_node_name.ACTUAL_COMPLETION_DATE. apps.'13850423') and t.concurrent_program_id=r.'On Hold'.'Standby'.sysdate)-v.'Running'. 'W'.round(((nvl(v. ' U'.'I'.ACTUAL_START_DATE. Determine the Internal Concurrent Manager log file and node name: .actual_start_date)*24*60)) Etime FROM apps. 'S'.description.PROGRAM_APPLICATION_ID = p. 'E'.1.user_id AND v.'Normal'.ACTUAL_COMPLETION_DATE.'Normal'.'dd-mm-yy hh24:mi:ss') "Completed at".fnd_concurrent_requests r .'R'.WHERE req_set. 'R'. Find log file & out file for request: SELECT logfile_name. to_char(r. apps.'Resuming'.'dd-mm-yy hh24:mi:ss'). r.user_concurrent_program_name. 'Q'. 'M '.REQUEST_ID.r.STATUS_CODE.CONCURRENT_PROGRAM_ID AND r. AND req.request_id order by requested_start_date desc.'Paused'. 'G'.act ual_completion_date.fnd_concurrent_programs_tl t.user_concurrent_program_name like '%%' order by to_char(r.request_id --AND r.'dd-mm-yy hh24:mi:ss') "Started at". decode(r. controlling_manager FROM fnd_concurrent_requests WHERE request_id = &&request_id.fnd_user u.PHASE_CODE. 'No Manager'.APPLICATION_ID AND t.'Suspended'.Request id of the submitted reques t set.REQUESTED_BY=u. decode(r.'Completed'.parent_request_id = req_set.actual_start_date >= (sysdate-30) --AND r.'Cancelle d'.25) "Who submitted".

far. node_name "Nodename" FROM (SELECT * FROM fnd_concurrent_processes WHERE queue_application_id = 0 AND concurrent_queue_id = 1 ORDER BY concurrent_process_id DESC) WHERE ROWNUM = 1. phase.queue_application_id = cq.concurrent_queue_ id AND cwr.request_id.30).concurrent_queue_id = cq. status. (CASE WHEN far.fnd_concurrent_queues_t l).application_id and cq. apps.user_concurrent_queue_name in ( select unique user_concurrent_queue_name from apps.status_code = 'P' THEN 'Scheduled to be run by the Advanced Scheduler' WHEN far.phase_code = 'P' AND (far.requested_start_date. 'B') THEN 'Bad queue_method_code of: ' || far.CONCURRENT_QUEUE_ID and a.queue_method_code WHEN far.queue_method_code = 'B' AND far.phase_code = 'R') AND cwr. apps. fnd_concurrent_queues_vl b.LANGUAGE='US' AND cwr.requested_by = fu. Pending requests count: select COUNT (distinct cwr.fnd_user fu WHERE (c wr.status_code = 'I' OR far. fnd_concurrent_requests c where a.status_code = 'Q') AND far.request_id) Peding_Requests FROM apps. SUBSTR (program.CONCURRENT_PROCESS_ID = c.request_id = '&conc_reqid'.controlling_manager and c.phase_code. 1.status_code.status_code = 'Q' AND EXISTS ( SELECT 1 FROM fnd_amp_requests_v farv WHERE phase_code = 'P' AND program_application_id = fcps.user_id and cq. quested_start_date <= SYSDATE AND cwr.to_run_application_id AND concurrent_program_id = .phase_code = 'P' AND far.requested_start_date > SYSDATE THEN 'Job is scheduled to run at ' || TO_CHAR (far.fnd_concurrent_ worker_requests cwr. far. How to Determine Which Manager Ran a Specific Concurrent Request: col USER_CONCURRENT_QUEUE_NAME for a100 select b.queue_control_flag = 'Y' THEN 'ICM will run ths request on its next sleep cycle' WHEN far.SELECT logfile_name "Filename".fnd_concurrent_queues_tl cq.queue_method_code NOT IN ('I'.user_name.phase_code = 'P' OR cwr.status_code = 'I' OR far.hold_flag = 'Y' THEN 'Job is on Hold by user' WHEN far.CONCURRENT_QUEUE_ID = b.status_code = 'Q') AND fcp.phase_code = 'P' AND (far. 'DD-MON-RR HH24:MI:SS' ) WHEN far. Pending requests: SELECT DISTINCT far.hold_flag != 'Y' AND cwr.run_alone_flag = 'Y' THEN 'Waiting on a run alone request' WHEN far.USER_CONCURRENT_QUEUE_NAME from fnd_concurrent_processes a.phase_code = 'P' AND far.

to_run_application_id=fcps1.concurrent_program_id = fcp.status_code IN ('A'.request_id || ': ' || farv.status_code = 'I' THEN 'Waiting for next available ' || fcqt. 'Could not locate Parent Request ID' ) WHEN far.status_code = 'Q' THEN 'This Standby request might not run' WHEN far.to_run_concurrent_program_id=fcps1.' other requests FROM WHERE AND AND AND AND WHEN far. fnd_concurrent_queue_content fcqc. fnd_concurrent_program_serial fcps.queue_method_code = 'I' AND far. fnd_conflicts_domain fcd.to_run_concurr ent_program_id) WHEN fcp.sleep_seconds || ' Seconds' WHEN far.cd_id fcps.running_concurrent_program_id(+) = far.status_code = 'Q' THEN 'Waiting on the Conflict Resolution Manager' WHEN far. 'Z') THEN 'Waiting for Parent Request: ' || NVL (far.phase_code = 'P' AND far.single_thread_flag = 'Y' THEN 'Single-threaded request.user_concurrent_queue_name || ' process to run the job.running_application_id(+) = far. fnd_concurrent_programs fcp.queue_method_code = 'I' AND far.' END ) reason fnd_amp_requests_v far.request_limit = 'Y' THEN 'Concurrent: Active Request Limit is set. fnd_concurrent_queues_tl fcqt far.enabled_flag = 'N' THEN 'Concurrent program is disabled' WHEN far.queue_method_code = 'B' AND far.to_run_concurrent_program_id) 'Incompatible request ' || (SELECT DISTINCT farv.status_code = 'I' THEN 'Waiting for next available ' || fcqt.phase_code = 'P' AND far.to_run_application_id AND fcps. Waiting on for this user.program_application_id fcps.phase_code = 'P' far.running_concurrent_progra m_id AND fcps.concurrent_program_i .concurrent_program_id fcd. fnd_concurrent_queues fcq.queue_method_code = 'B' AND far.user_concurrent_queue_name || ' process to run the job.running_application_id AND concurrent_program_id =fcps1.sleep_seconds || ' Seconds' WHEN far.cd_id = far. Waiting on other requests for this user. Estimate Wait time ' || fcq.user_name FROM fnd_amp_requests_v farv.parent_request_id.fnd_concurrent_program_serial THEN fcps1 WHERE phase_code = 'R' AND program_application_id =fcps1. Estimate Wait time ' || fcq.fcps.queue_method_code = 'I' AND far.program || ' is Ruuning by : ' || farv.

'P'.'P'.to_run_concurrent_program_id(+) far.1.requested_start_date <= SYSDATE -. Pending Request In Managers: SELECT v.'Q'.PHASE_CODE.'B'. sum(decode(b.STATUS_CODE.'R'. sum(decode(b. Concurrent Program count under QUEUE: col "program name" format a55.a.phase_code = 'P' -.program_application_id = fcps.0).STATUS_CODE.'S'.program_application_id = fcqc.'Warning'.application_id(+) = fcqc.'No Manager'.'Normal'.USER_CONCURRENT_QUEUE_NAME.'I'.No Future jobs AND r.concurrent_queue_id AND b.Pending AND r.user_concurrent_queue_name HAVING COUNT (phase_code) >= 1. 'Scheduled'.'Error'.'Pending') "PHASE".type_application_id(+) fcq. col "queue name" format a15 col "statuscode" format a3 select user_CONCURRENT_PROGRAM_NAME "PROGRAM NAME".count(*) from fnd_concurrent_worker_requests where phase_code='P' and hold_flag!='Y' and requested_start_date<=sysdate and concurrent_queue_name<> 'FNDCRM' and concurrent_queue_name<> 'GEMSPS' group by user_CONCURRENT_PROGRAM_NAME. priority.queue_application_id = 0 AND r.'Z'.' Waiting') " NAME".0)) Pending_Standby.application_id far. col "name" format a17. concurrent_queue_name.'I'.concurrent_queue_id = b.Requested_Start_Date<=SYSDATE .'H'.queue_application_id fcqt.'Normal'.'Resuming'.concurrent_queue_name "QUEUE NAME".decode(phase_code. apps.fnd_concurrent_worker_requests r WHERE r.'D'.MAX_PROCESSES.fnd_concurrent_queues_vl v.'P'. SELECT a. 'Suspended'. sum(decode(b.concurrent_queue_id fcq.not on hold AND r.0)) Pending_Normal.'Terminated'.0)) Running_Normal FROM FND_CONCURRENT_QUEUES_VL a.'Terminating'.'Waiting'.concurrent_queue_id fcqt.concurrent_queue_id(+) = fcq.to_run_application_id(+) far.'Stand by'.concurrent_queue_id GROUP BY v.PHASE_CODE. / Lists the Manager Names with the No.'E' .decode(b.request_id DESC.'T'.decode(b.'M'.'On Hold'.STATUS_CODE.user_concurrent_queue_name.hold_flag != 'Y' -.'Normal'.d AND AND AND AND AND AND AND AND ORDER BY far.0). decode(status_code.'R'.'Paused'.'Disabled'.'G'.'Cancelled'.concurrent_queue_id(+) = fcqc.'Q'.'X'.'F'.type_id(+) far.0).application_id(+) = fcq.1.concurrent_program_id = fcqc.'C'.'A'. FND_CONCURRENT_WORKER_REQUESTS b where a. status_code.PHASE_CODE.'W'.status_code order by count(*) desc. of Requests in Pending/Running: col "USER_CONCURRENT_QUEUE_NAME" format a40. COUNT(phase_code) pending FROM apps.concurrent_queue_id=v.decode(b.'R'.concurrent_program_id = fcps.'U'.phase_code.priority.1.

DECODE (NVL2 (cr.release_class_app_id. 'PERIODICALLY'.LANGUAGE = 'US' AND fcr.user_concurrent_program_name ) NAME.release_class_id. apps.resubmit_interval_unit_code || ' FROM ' || cr. --To see all the pending / Running requests per each manager wise SELECT request_id.requested_start_date > SYSDATE AND cp.type_id(+) = cp.queue_application_id. fu. 'EVERY ' || cr. 'ON SPECIFIC DAYS'.fnd_concurrent_queues_tl cq WHERE cqc. apps. DECODE (cp.release_class_id(+) = cr.application_id(+) = cr.user_id AND cr. NVL2 (cr. 'EVERY: ' || fcr. 'ONCE'.fnd_concurrent_programs_tl cp. Checking which manager is going to execute a program: SELECT user_concurrent_program_name.requested_start_date.concurrent_program_id AND cr.release_class_id. apps.description.MAX_PROCESSES.type_code(+) = 'P' AND cqc. 0) = cq.user_name. user_concurrent_queue_name FROM apps.program_application_id AND cp.user_concurrent_program_name = '&USER_CONCURRENT_PROGRAM_NAME' AND NVL (c qc. 'Report Set'.application_id = cr. Find the scheduled concurrent requests: SELECT cr.resubmit_interval. .fnd_user fu.requested_by = fu. phase_code.LANGUAGE = 'US' AND cp. apps.USER_CONCURRENT_QUEUE_NAME. NVL2 (cr. 'AT :' || TO_CHAR (cr. status_code.phase_code = 'P' AND cr.GROUP BY a.resubmit_interval.application_id AND cq. user_name.a.request_id. 'PERIODICALLY'.concurrent_program_id AND cqc.class_info ) schedule. 0) = cq.concurrent_queue_id. argument_text.concurrent_program_id = cr. apps. requested_start_date FROM apps.resubmit_interval || ' ' || cr.fnd_concurrent_programs_tl cp.fnd_conc_release_classes fcr WHERE cp.concurrent_queue_id AND NVL (cqc.resubmit_interval_type_code || ' OF PREV RUN'.application_id AND cqc. 'ONCE') ).release_class_id AND fcr. 'DD-MON-RR HH24:MI'). cp.type_application_id(+) = cp. 'ON SPECIFIC DAYS'.fnd_concurrent_requests cr. 'PERIODICALLY'.LANGUAGE = 'US'. 'ONCE') ) schedule_type.user_concurrent_program_name.include_flag(+) = 'I' AND cp.resubmit_interval.fnd_concurrent_queue_content cqc. cr. NVL2 (cr. 'Report Set:' || cr.

requested_start_date <= SYSDATE AND cwr.to_run_concurrent_program_id AND b2.queue_application_id = cq.application_id = cps.concurrent_program_id = cps. 'Request set'. a1.addr = s.fnd_concurrent_program_serial cps.running_application_id AND a1. v$ process p where f.sid .user_id ORDER BY 5.fnd_concurrent_queues_tl cq.application_id AND cq.LANGUAGE = 'US' AND cwr.fnd_user fu WHERE (cwr.application_name "Incompatible App".language = 'US' . Script to trace Concuurent request: select s.p.fnd_concurrent_worker_requests cwr. 'Request set'. 'UNKNOWN' ) incompatible_type FROM apps. apps.user_concurrent_queue_name FROM apps. Log on to the DB Tier â ¦. b1. DECODE (to_run_type.oracle_process_id = p.running_application_id AND b1.fnd_concurrent_programs_tl b1. b2.''). &serial. Check for the trace file <instance name>_ora_<SPID>. 'UNKNOWN' ) "Type".application_id = cps. SELECT a2.user_concurrent_program_name.paddr EXEC DBMS_SYSTEM.spid from fnd_concurrent_requests f.trc Terminated concurrent Request-Details: .phase_code = 'P' OR cwr.concurrent_queue_id AND cwr.10046.to_run_application_id AND b1.to_run_application_id AND a1. apps. s.serial# .phase_code = 'R') AND cwr.fnd_application_tl b2 WHERE a1.running_concurrent_program_id AND a2.application_name.request_id = and f.v$session s . 'Program'. apps.concurrent_queue_id = cq.SET_EV(&sid .requested_by = fu.application_id = cps.fnd_application_tl a2. apps.spid and p. 'P'. 'P'. apps. 12 .language = 'US' AND a2. 'S'. 'S'. apps. DECODE (running_type.concurrent_program_id = cps. 'Program'. Checking the incompatibilities between the programs: The below query can be used to find all incompatibilities in an application inst ance.fnd_concurrent_programs_tl a1.user_concurrent_program_name "Incompatible_Prog".language = 'US' AND b2.application_id = cps.language = 'US' AND b1.hold_flag != 'Y' AND cwr.

completion_text MESSAGE FROM apps.'W'. 'W'. parent_request_id PARENT.PHASE_CODE) PHASE_CODE. completion_text MESSAGE FROM apps.'R'. fnd_user fu WHERE 1=1 AND fcp.REQUEST_ID. . 'N'.status_code IN ('E'. 'E') = STATUS_CODE)) AND actual_completion_date > SYSDATE .fcr.actual_completion_date â decode (trunc(fcr.requested_start_date. 'E'.1.1.USER_CONCURRENT_PROGRAM_NAME.fcr.actual_completion_date.2 --AND requestor LIKE ('%AR_BTOGUSER%') ORDER BY REQUEST_ID DESC.CONCURRENT_PROGRAM_ID=fcp. request_id.description. DECODE(fcr.'DD/MM/YYYY HH24:MI:SS') start_time.53) PROGRAM. errors too. 'W'.requested_start_date.request_date.'R'.re quested_start_date))*60*24) WaitTimeMIN.'C'.1. program_short_name.'Warning'. fcr. SUBSTR(program.REQUEST_ID. STATUS_CODE.'C'. fcpt.PHASE_CODE.CO NCURRENT_PROGRAM_NAME. to_char(fcr. round((fcr. to_char(fcr. fnd_concurrent_programs fcp.'Running'.status_code.'Error'. request_id. SUBSTR(program.STATUS_CODE) STATUS_CODE.'Completed'.'Completed'.user_id AND trunc(fcr.FND_CONC_REQ_SUMMARY_V WHERE STATUS_CODE = 'E' AND actual_completion_date > SYSDATE .CONCURRENT_PROGRAM_NAME. 'G') = STATUS_COD E OR DECODE(IMPLICIT_CODE. to_char(fcr.FND_CONC_REQ_SUMMARY_V WHERE STATUS_CODE = 'E' AND ((DECODE(IMPLICIT_CODE.'DD/MM/YYYY HH24:MI:SS') complete_time FROM fnd_concurrent_requests fcr. fcp.CONCURRENT_PROGRAM_ID AND fcr. Not only users terminate request. fcp.fcr.'G') ORDER BY fcr.15) REQUESTOR.'DD/MM/YYYY HH24:MI:SS') request_date.'G '. fcpt.'Paused'.15) REQUESTOR.SELECT fu. fcr.53) PROGRAM. DECODE(fcr. fnd_concurrent_programs_tl fcpt.1.'E'. To find the terminated requests by users use this query: SELECT actual_completion_date TERMINATED.requested_by = fu.request_date). parent_request_id PARENT.request_date) BETWEEN sysdate â 1 AND sysdate AND fcr.CONCURRENT_PROGRAM_ID=fcr. SUBSTR(requestor.2 --AND requestor LIKE ('%KOSDIM%') --AND program_short_name = 'XXACC_OTEDUNN_PARALLEL' ORDER BY REQUEST_ID DESC.STATUS_CODE. fcr.request_date.fcr.CONCURRENT_PROGRAM_ID AND fcpt. SUBSTR(requestor.user_name.'E'.to get error terminated requests: SELECT actual_completion_date FAILED.'Running'.