| SQL Id | SQL Text |
|---|
| 06g9mhm5ba7tt | begin :rept := dbms_report.get_report(:report_ref, :content, :comp); end; |
| 0bjbaw9270kjv |
DECLARE
l_last_full_time VARCHAR2(64);
l_last_full_age NUMBER;
l_last_full_size NUMBER;
l_last_exec_full_time VARCHAR2(64);
l_last_exec_full_status VARCHAR2(23);
l_last_incr_time VARCHAR2(64);
l_last_incr_age NUMBER;
l_last_incr_size NUMBER;
l_last_exec_incr_time VARCHAR2(64);
l_last_exec_incr_status VARCHAR2(23);
l_last_arch_time VARCHAR2(64);
l_last_arch_age NUMBER;
l_last_arch_size NUMBER;
l_last_exec_arch_time VARCHAR2(64);
l_last_exec_arch_status VARCHAR2(23);
l_last_complete_backup VARCHAR2(64);
l_recovery_window NUMBER;
l_unprotected_data_window NUMBER;
TYPE data_cursor_type IS REF CURSOR;
data_cursor data_cursor_type;
v_db_version VARCHAR2(10);
db_version_121 CONSTANT VARCHAR2(10) := '12.1.0.0.0';
BEGIN
SELECT LPAD(version, 10, '0') INTO v_db_version
FROM v$instance;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24, 2), input_bytes
INTO l_last_full_time, l_last_full_age, l_last_full_size
FROM (SELECT end_time, input_bytes
FR
OM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='DB FULL' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_full_time := NULL;
l_last_full_age := NULL;
l_last_full_size := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_full_time, l_last_exec_full_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='DB FULL' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_full_time := NULL;
l_last_exec_full_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24, 2), input_bytes
INTO l_last_incr_time, l_last_incr_age, l_last_incr_size
FROM (SELECT end_time, input
_bytes
FROM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='DB INCR' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_incr_time := NULL;
l_last_incr_age := NULL;
l_last_incr_size := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_incr_time, l_last_exec_incr_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='DB INCR' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_incr_time := NULL;
l_last_exec_incr_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24*60, 2), input_bytes
INTO l_last_arch_time, l_last_arch_age, l_last_arch_size
FROM (SELECT end
_time, input_bytes
FROM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='ARCHIVELOG' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_arch_time := NULL;
l_last_arch_age := NULL;
l_last_arch_size := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_arch_time, l_last_exec_arch_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='ARCHIVELOG' AND
output_device_type IN ('DISK', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_arch_time := NULL;
l_last_exec_arch_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
IF (v_db_version >= db_version_121) THEN
EXECUTE IMMEDIATE
'SELECT to_char(low_time, ''YYYY-MM-DD HH24:MI:SS'') as last_complete_backup,
ROUND((high_time-
low_time)*24*60*60, 2) as recovery_window,
ROUND((sysdate-high_time)*24*60*60, 2) as unprotected_data_window
FROM v$disk_restore_range rr1
WHERE rr1.high_time = (SELECT max(rr2.high_time)
FROM v$disk_restore_range rr2
WHERE rr1.db_id = rr2.db_id)'
INTO l_last_complete_backup,
l_recovery_window, l_unprotected_data_window;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_complete_backup := NULL;
l_recovery_window := NULL;
l_unprotected_data_window := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
OPEN data_cursor FOR
SELECT l_last_full_time, l_last_full_age, l_last_full_size,
l_last_exec_full_time, l_last_exec_full_status,
l_last_incr_time, l_last_incr_age, l_last_incr_size,
l_last_exec_incr_time, l_last_exec_incr_status,
l_last_arch_time, l_last_arch_age, l_last_arch_size,
l_last_exec_arch_time, l_last_exec_arch_status,
l_last_complete_backup,
l_recovery_window, l_unprotected_data_window
FROM dual;
:1 := data_cursor;
END;
|
| 0ctk7jpux5chm |
WITH RECINFO AS ( SELECT /*+ NO_MERGE */ FINDING_ID, COUNT(R.REC_ID) RECCOUNT, R.TYPE FROM DBA_ADVISOR_RECOMMENDATIONS R WHERE TASK_ID=:B1 GROUP BY R.FINDING_ID, R.TYPE ), F_CURR AS ( SELECT /*+ NO_MERGE */ DISTINCT FINDING_NAME FROM DBA_ADVISOR_FINDINGS WHERE TASK_ID=:B1 ), TASKS AS ( SELECT /*+ NO_MERGE */ T.TASK_ID, I.LOCAL_TASK_ID, T.END_TIME, T.BEGIN_TIME FROM DBA_ADDM_TASKS T, DBA_ADDM_INSTANCES I WHERE T.END_TIME>SYSDATE -1 AND T.TASK_ID=I.TASK_ID AND I.INSTANCE_NUMBER=SYS_CONTEXT('USERENV', 'INSTANCE') AND T.REQUESTED_ANALYSIS='INSTANCE' ), F_ALL AS ( SELECT /*+ NO_MERGE */ COUNT(FA.TASK_ID) FINDING_COUNT, FA.FINDING_NAME FROM TASKS, DBA_ADVISOR_FINDINGS FA WHERE FA.TASK_ID=TASKS.TASK_ID AND FA.TYPE<>'INFORMATION' AND FA.TYPE<>'WARNING' AND FA.PARENT=0 GROUP BY FA.FINDING_NAME ), HISTORY AS ( SELECT /*+ NO_MERGE */ FINDING_NAME, FINDING_COUNT FROM F_ALL JOIN F_CURR USING (FINDING_NAME) ) SELECT :B1 TASK_ID, F.FINDING_ID FINDING_ID, DECODE(RECINFO.TYPE
, NULL, 'Uncategorized', RECINFO.TYPE) REC_TYPE, RECINFO.RECCOUNT REC_COUNT, F.PERC_ACTIVE_SESS IMPACT_PCT, F.MESSAGE MESSAGE, TO_CHAR(TO_DATE(:B3 , 'MM-DD-YYYY HH24:MI:SS'), 'YYYY-MM-DD HH24:MI:SS') START_TIME, TO_CHAR(TO_DATE(:B2 , 'MM-DD-YYYY HH24:MI:SS'), 'YYYY-MM-DD HH24:MI:SS') END_TIME, HISTORY.FINDING_COUNT FINDING_COUNT, F.FINDING_NAME FINDING_NAME, F.ACTIVE_SESSIONS ACTIVE_SESSIONS FROM DBA_ADDM_FINDINGS F, RECINFO, HISTORY WHERE F.TASK_ID=:B1 AND F.TYPE<>'INFORMATION' AND F.TYPE<>'WARNING' AND F.FILTERED<>'Y' AND F.PARENT=0 AND F.FINDING_ID=RECINFO.FINDING_ID (+) AND F.FINDING_NAME=HISTORY.FINDING_NAME ORDER BY F.FINDING_ID |
| 0smupm8p2dhq7 | select count(*) num_windows, sum(case when jobs_started<>jobs_completed then 1 else 0 end) num_jobs_incomplete from dba_autotask_client_history where client_name = 'auto optimizer stats collection' |
| 0w26sk6t6gq98 | SELECT XMLTYPE(DBMS_REPORT.GET_REPORT_WITH_SUMMARY(:B1 )) FROM DUAL |
| 196mqnmxgxpv1 |
select sysStat.branchnodesplits
, sysStat.consistentreadchanges
, sysStat.consistentreadgets
, sysStat.crblks
, sysStat.crundorecs
, sysStat.dbblkchanges
, sysStat.dbblkgets
, sysStat.dbwrcheckpoints
, sysStat.sortsdisk
, sysStat.enqdeadlocks
, sysStat.enqreqs
, sysStat.enqtimeouts
, sysStat.enqwaits
, sysStat.indxscansfull
, sysStat.indxscansfullrowid
, sysStat.indxscansfulldirectread
, sysStat.executions
, sysStat.totalPhysicalReads
, sysStat.totalPhysicalWrites
, sysStat.phyreadtotalioreqs
, sysStat.phywritetotalioreqs
, sysStat.leafnodesplits
, sysStat.logreads
, sysStat.logons
, sysStat.tabscanslong
, sysStat.bytestoclientviasqlnet
, sysStat.bytesfromclientviasqlnet
, sysStat.bytestodblinkviasqlnet
, sysStat.bytesfromdblinkviasqlnet
, sysStat.bytestoclientviasqlnetvec
, sysStat.bytesfromclientviasqlnetvec
, sysStat.bytestodblinkviasqlnetvec
, sysStat.bytesfromdblinkviasqlnetvec
, sysStat.opncurs
, sysStat.failedparses
, sysStat.physreadslob
,
sysStat.physwriteslob
, sysStat.physreadsdir
, sysStat.physwritesdir
, sysStat.physicalreads
, sysStat.physicalwrites
, sysStat.redosize
, sysStat.redowrites
, sysStat.sortsmemory
, sysStat.sortsrows
, sysStat.parses
, sysStat.hardparses
, sysStat.indxscanstotal
, sysStat.usercalls
, sysStat.recurscalls
, sysStat.commits
, sysStat.rollbacks
, sysStat.userrollbackundorec
, sysStat.bgcheckpoints
, sysTM.dbCpu
, sysTM.dbTime
, sysTM.active_session
, iostat.smallsyncreadreqs
, iostat.smallsyncreadlatency
from
( select sum(decode(name, 'branch node splits', value, 0)) branchnodesplits
, sum(decode(name, 'consistent changes', value, 0)) consistentreadchanges
, sum(decode(name, 'consistent gets', value, 0)) consistentreadgets
, sum(decode(name, 'CR blocks created', value, 0)) crblks
, sum(decode(name, 'data blocks consistent reads - undo records applied', value, 0)) crundorecs
, sum(decode(name, 'db block changes', value, 0)) dbblkchanges
, sum(
decode(name, 'db block gets', value, 0)) dbblkgets
, sum(decode(name, 'DBWR checkpoints', value, 0)) dbwrcheckpoints
, sum(decode(name, 'sorts (disk)', value, 0)) sortsdisk
, sum(decode(name, 'enqueue deadlocks', value, 0)) enqdeadlocks
, sum(decode(name, 'enqueue requests', value, 0)) enqreqs
, sum(decode(name, 'enqueue timeouts', value, 0)) enqtimeouts
, sum(decode(name, 'enqueue waits', value, 0)) enqwaits
, sum(decode(name, 'index fast full scans (full)', value, 0)) indxscansfull
, sum(decode(name, 'index fast full scans (rowid ranges)', value, 0)) indxscansfullrowid
, sum(decode(name, 'index fast full scans (direct read)', value, 0)) indxscansfulldirectread
, sum(decode(name, 'execute count', value, 0)) executions
, sum(decode(name, 'physical read total bytes', value, 0)) totalPhysicalReads
, sum(decode(name, 'physical write total bytes', value, 0)) totalPhysicalWrites
, sum(decode(name, 'physical read total IO requests', value
, 0)) phyreadtotalioreqs
, sum(decode(name, 'physical write total IO requests', value, 0)) phywritetotalioreqs
, sum(decode(name, 'leaf node splits', value, 0)) leafnodesplits
, sum(decode(name, 'session logical reads', value, 0)) logreads
, sum(decode(name, 'logons cumulative', value, 0)) logons
, sum(decode(name, 'table scans (long tables)', value, 0)) tabscanslong
, sum(decode(name, 'bytes sent via SQL*Net to client', value, 0)) bytestoclientviasqlnet
, sum(decode(name, 'bytes received via SQL*Net from client', value, 0)) bytesfromclientviasqlnet
, sum(decode(name, 'bytes sent via SQL*Net to dblink', value, 0)) bytestodblinkviasqlnet
, sum(decode(name, 'bytes received via SQL*Net from dblink', value, 0)) bytesfromdblinkviasqlnet
, sum(decode(name, 'bytes via SQL*Net vector to client', value, 0)) bytestoclientviasqlnetvec
, sum(decode(name, 'bytes via SQL*Net vector from client', value, 0)) bytesfromclientviasqlnetvec
, sum(decode(name,
'bytes via SQL*Net vector to dblink', value, 0)) bytestodblinkviasqlnetvec
, sum(decode(name, 'bytes via SQL*Net vector from dblink', value, 0)) bytesfromdblinkviasqlnetvec
, sum(decode(name, 'opened cursors cumulative', value, 0)) opncurs
, sum(decode(name, 'parse count (failures)', value, 0)) failedparses
, sum(decode(name, 'physical reads direct (lob)', value, 0)) physreadslob
, sum(decode(name, 'physical writes direct (lob)', value, 0)) physwriteslob
, sum(decode(name, 'physical reads direct', value, 0)) physreadsdir
, sum(decode(name, 'physical writes direct', value, 0)) physwritesdir
, sum(decode(name, 'physical reads', value, 0)) physicalreads
, sum(decode(name, 'physical writes', value, 0)) physicalwrites
, sum(decode(name, 'redo size', value, 0)) redosize
, sum(decode(name, 'redo writes', value, 0)) redowrites
, sum(decode(name, 'sorts (memory)', value, 0)) sortsmemory
, sum(decode(name, 'sorts (rows)', value, 0)) sortsrows
, sum(decode(name, 'parse count (total)', value, 0)) parses
, sum(decode(name, 'parse count (hard)', value, 0)) hardparses
, sum(decode(name, 'index scans kdiixs1', value, 0)) indxscanstotal
, sum(decode(name, 'user calls', value, 0)) usercalls
, sum(decode(name, 'recursive calls', value, 0)) recurscalls
, sum(decode(name, 'user commits', value, 0)) commits
, sum(decode(name, 'user rollbacks', value, 0)) rollbacks
, sum(decode(name, 'rollback changes - undo records applied', value, 0)) userrollbackundorec
, sum(decode(name, 'background checkpoints completed', value, 0)) bgcheckpoints
from v$sysstat
) sysStat
, (select sum(decode(stat_name, 'DB CPU', value/10000, 0)) dbCpu
, sum(decode(stat_name, 'DB time', value/10000, 0)) dbTime
, sum(decode(stat_name, 'DB time', value/1000000, 0)) active_session
from v$sys_time_model
) sysTM
, ( select sum(small_sync_read_reqs) smallsyncreadreqs
, sum (small_sync_read_latency) smallsyncreadlaten
cy
from v$IOSTAT_FILE
) iostat
|
| 1rpgk59t8pvs6 | begin
dbms_output.get_line(:line, :status);
end; |
| 1y4f4wtu63797 |
WITH MONITOR_DATA AS (SELECT INST_ID, KEY, NVL2(PX_QCSID, NULL, STATUS) STATUS, FIRST_REFRESH_TIME, LAST_REFRESH_TIME, REFRESH_COUNT, PROCESS_NAME, SID, SQL_ID, SQL_EXEC_START, SQL_EXEC_ID, DBOP_NAME, DBOP_EXEC_ID, SQL_PLAN_HASH_VALUE, SQL_FULL_PLAN_HASH_VALUE, SESSION_SERIAL#, SQL_TEXT, IS_FULL_SQLTEXT, PX_SERVER#, PX_SERVER_GROUP, PX_SERVER_SET, PX_QCINST_ID, PX_QCSID, CASE WHEN ELAPSED_TIME < (CPU_TIME+ APPLICATION_WAIT_TIME+ CONCURRENCY_WAIT_TIME+ CLUSTER_WAIT_TIME+ USER_IO_WAIT_TIME+ QUEUING_TIME) THEN (CPU_TIME+ APPLICATION_WAIT_TIME+ CONCURRENCY_WAIT_TIME+ CLUSTER_WAIT_TIME+ USER_IO_WAIT_TIME+ QUEUING_TIME) ELSE ELAPSED_TIME END ELAPSED_TIME, QUEUING_TIME, CPU_TIME, APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, CASE WHEN ELAPSED_TIME < (CPU_TIME+ APPLICATION_WAIT_TIME+ CONCURRENCY_WAIT_TIME+ CLUSTER_WAIT_TIME+ USER_IO_WAIT_TIME+ QUEUING_TIME) THEN 0 ELSE ELAPSED_TIME - (CPU_TIME+ APPLICATION_WAIT_TIME+ C
ONCURRENCY_WAIT_TIME+ CLUSTER_WAIT_TIME+ USER_IO_WAIT_TIME+ QUEUING_TIME) END OTHER_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, FETCHES, BUFFER_GETS, IO_INTERCONNECT_BYTES IO_INTER_BYTES, PHYSICAL_READ_REQUESTS READ_REQS, PHYSICAL_READ_BYTES READ_BYTES, PHYSICAL_WRITE_REQUESTS WRITE_REQS, PHYSICAL_WRITE_BYTES WRITE_BYTES, NVL(PHYSICAL_READ_BYTES, 0) + NVL(PHYSICAL_WRITE_BYTES, 0) IO_BYTES, NVL(PHYSICAL_READ_REQUESTS, 0) + NVL(PHYSICAL_WRITE_REQUESTS, 0) IO_REQS, IO_CELL_UNCOMPRESSED_BYTES IO_UNC_BYTES, IO_CELL_OFFLOAD_ELIGIBLE_BYTES IO_ELIG_BYTES, IO_CELL_OFFLOAD_RETURNED_BYTES IO_RET_BYTES, USER# USERID, USERNAME, MODULE, ACTION, SERVICE_NAME, CLIENT_IDENTIFIER, CLIENT_INFO, PROGRAM, PLSQL_OBJECT_ID PL_OID, PLSQL_SUBPROGRAM_ID PL_PROGID, PLSQL_ENTRY_OBJECT_ID PL_ENTRY_OID, PLSQL_ENTRY_SUBPROGRAM_ID PL_ENTRY_PROGID, PX_MAXDOP MAX_DOP, PX_IS_CROSS_INSTANCE, PX_MAXDOP_INSTANCES MAX_DOP_INSTANCES, PX_SERVERS_REQUESTED SERVERS_REQUESTED, PX_SERVERS_ALLOCA
TED SERVERS_ALLOCATED, ERROR_NUMBER, ERROR_FACILITY, ERROR_MESSAGE, NVL2(OTHER_XML, 'Y', NULL) HAS_OTHER_XML, NVL2(BINDS_XML, 'Y', NULL) HAS_BINDS_XML, NVL2(RM_CONSUMER_GROUP, NVL2(RM_LAST_ACTION_TIME, TO_CHAR(RM_LAST_ACTION_TIME, :B12 ), '00/00/0000 00:00:01') || XMLELEMENT( "rminfo", XMLATTRIBUTES( RM_LAST_ACTION AS "rmlastact", RM_LAST_ACTION_REASON AS "rmlastreason", TO_CHAR(RM_LAST_ACTION_TIME, :B12 ) AS "rmlasttime", RM_CONSUMER_GROUP AS "rmcg")).GETSTRINGVAL(), '00/00/0000 00:00:00') RM_INFO, CON_NAME, CON_ID FROM GV$SQL_MONITOR MO1 WHERE MO1.INST_ID BETWEEN :B11 AND :B10 AND MO1.SQL_ID = NVL(:B9 , MO1.SQL_ID) AND MO1.SQL_EXEC_START = NVL(:B8 , MO1.SQL_EXEC_START) AND MO1.SQL_EXEC_ID = NVL(:B7 , MO1.SQL_EXEC_ID) OR (MO1.DBOP_NAME = NVL(:B6 , MO1.DBOP_NAME) AND MO1.DBOP_EXEC_ID = NVL(:B5 , MO1.DBOP_EXEC_ID)) AND ((:B4 = 1 AND MO1.PX_QCSID IS NULL) OR (MO1.PX_SERVER_GROUP = NVL(:B3 , MO1.PX_SERVER_GROUP)
AND MO1.PX_SERVER_SET = NVL(:B2 , MO1.PX_SERVER_SET) AND MO1.PX_SERVER# = NVL(:B1 , MO1.PX_SERVER#)))), MONITOR_AGG AS (SELECT MAX_PX_QCSID, MAX_KEY, MAX_INST_ID, MAX_SESSION_ID, MAX_SESSION_SERIAL, MAX_PX_DOP, MAX_PX_DOP_INSTANCES, MAX_PX_IS_CROSS_INSTANCE, SUM_SERVERS_REQUESTED, SUM_SERVERS_ALLOCATED, DIST_INST_COUNT, DIST_PX_GROUP_COUNT, DIST_PX_SET_COUNT, MAX_PLAN_HASH_VALUE, MAX_FULL_PLAN_HASH_VALUE, MAX_USERID, MAX_PROGRAM, MAX_USERNAME, MAX_MODULE, MAX_ACTION, MAX_SERVICE_NAME, MAX_CLIENT_ID, MAX_CLIENT_INFO, MAX_ERROR_NUMBER, MAX_ERROR_FACILITY, MAX_ERROR_MESSAGE, QC_HAS_OTHER_XML, QC_HAS_BINDS_XML, MAX_PL_OID, MAX_PL_PROGID, MAX_PL_ENTRY_OID, MAX_PL_ENTRY_PROGID, MAX_SQL_ID, MAX_SQL_EXEC_START, MAX_SQL_EXEC_ID, MAX_LAST_REFRESH_TIME, MAX_DBOP_NAME, MAX_DBOP_EXEC_ID, CASE WHEN MAX_PL_OID IS NOT NULL THEN NVL((SELECT P.OWNER || '.' || P.OBJECT_NAME || DECODE(P.PROCEDURE_NAME, NULL, '', '.' || P.PROCEDURE_NAME) FROM DBA_PROCEDURES P WH
ERE P.OBJECT_ID = MAX_PL_OID AND P.SUBPROGRAM_ID = MAX_PL_PROGID AND ROWNUM = 1), 'Unavailable') END MAX_PL_NAME, CASE WHEN MAX_PL_ENTRY_OID IS NOT NULL THEN NVL((SELECT P.OWNER || '.' || P.OBJECT_NAME || DECODE(P.PROCEDURE_NAME, NULL, '', '.' || P.PROCEDURE_NAME) FROM DBA_PROCEDURES P WHERE P.OBJECT_ID = MAX_PL_ENTRY_OID AND P.SUBPROGRAM_ID = MAX_PL_ENTRY_PROGID AND ROWNUM = 1), 'Unavailable') END MAX_PL_ENTRY_NAME, MAX_STATUS, SUM_REFRESH_COUNT, MIN_FIRST_REFRESH_TIME, IS_FULL_TEXT, SQLMON_TEXT, SUM_ELAPSED_TIME, MAX_ELAPSED_TIME, MAX_QUEUING_TIME, SUM_CPU_TIME, SUM_USER_IO_WAIT_TIME, SUM_APPLICATION_WAIT_TIME, SUM_CONCURRENCY_WAIT_TIME, SUM_CLUSTER_WAIT_TIME, SUM_PLSQL_EXEC_TIME, SUM_JAVA_EXEC_TIME, SUM_OTHER_WAIT_TIME, SUM_FETCHES, SUM_BUFFER_GETS, SUM_READ_REQS, SUM_READ_BYTES, SUM_WRITE_REQS, SUM_WRITE_BYTES, SUM_IO_BYTES, SUM_IO_INTER_BYTES, SUM_IO_UNC_BYTES, SUM_IO_ELIG_BYTES, SUM_IO_RET_BYTES, DECODE(:B14 , 1, 'db_name', DB.DB_UNIQUE_NAME)
DB_UNIQUE_NAME, DECODE(:B14 , 1, 'platform_name', DB.PLATFORM_NAME) PLATFORM_NAME, DECODE(:B14 , 1, 'host_name', INST.HOST_NAME) HOST_NAME, AGG_RM_INFO MAX_RM_INFO, MAX_CON_NAME, DECODE(MAX_CON_ID, 0, NULL, MAX_CON_ID) MAX_CON_ID FROM (SELECT MAX(PX_QCSID) MAX_PX_QCSID, MAX(CASE WHEN PX_QCSID IS NULL THEN KEY ELSE NULL END) MAX_KEY, MAX(CASE WHEN PX_QCSID IS NULL THEN INST_ID ELSE NULL END) MAX_INST_ID, MAX(CASE WHEN PX_QCSID IS NULL THEN SID ELSE NULL END) MAX_SESSION_ID, MAX(CASE WHEN PX_QCSID IS NULL THEN SESSION_SERIAL# ELSE NULL END) MAX_SESSION_SERIAL, MAX(MAX_DOP) MAX_PX_DOP, MAX(MAX_DOP_INSTANCES) MAX_PX_DOP_INSTANCES, MAX(PX_IS_CROSS_INSTANCE) MAX_PX_IS_CROSS_INSTANCE, SUM(SERVERS_REQUESTED) SUM_SERVERS_REQUESTED, SUM(SERVERS_ALLOCATED) SUM_SERVERS_ALLOCATED, COUNT(DISTINCT INST_ID) DIST_INST_COUNT, COUNT(DISTINCT PX_SERVER_GROUP) DIST_PX_GROUP_COUNT, COUNT(DISTINCT PX_SERVER_SET) DIST_PX_SET_COUNT, MAX(SQL_PLAN_HASH_VALUE) MAX_PLAN_HASH_VALUE, MAX(
SQL_FULL_PLAN_HASH_VALUE) MAX_FULL_PLAN_HASH_VALUE, MAX(USERID) MAX_USERID, MAX(PROGRAM) MAX_PROGRAM, MAX(USERNAME) MAX_USERNAME, MAX(MODULE) MAX_MODULE, MAX(ACTION) MAX_ACTION, MAX(SERVICE_NAME) MAX_SERVICE_NAME, MAX(CLIENT_IDENTIFIER) MAX_CLIENT_ID, MAX(CLIENT_INFO) MAX_CLIENT_INFO, MAX(ERROR_NUMBER) MAX_ERROR_NUMBER, MAX(ERROR_FACILITY) MAX_ERROR_FACILITY, MAX(ERROR_MESSAGE) MAX_ERROR_MESSAGE, MAX(NVL2(PX_QCSID, HAS_OTHER_XML, NULL)) QC_HAS_OTHER_XML, MAX(HAS_BINDS_XML) QC_HAS_BINDS_XML, MAX(PL_OID) MAX_PL_OID, MAX(PL_PROGID) MAX_PL_PROGID, MAX(PL_ENTRY_OID) MAX_PL_ENTRY_OID, MAX(PL_ENTRY_PROGID) MAX_PL_ENTRY_PROGID, MAX(SQL_ID) MAX_SQL_ID, MAX(SQL_EXEC_START) MAX_SQL_EXEC_START, MAX(SQL_EXEC_ID) MAX_SQL_EXEC_ID, MAX(LAST_REFRESH_TIME) MAX_LAST_REFRESH_TIME, MAX(STATUS) MAX_STATUS, SUM(REFRESH_COUNT) SUM_REFRESH_COUNT, MIN(FIRST_REFRESH_TIME) MIN_FIRST_REFRESH_TIME, MAX(DBOP_NAME) MAX_DBOP_NAME, MAX(DBOP_EXEC_ID) MAX_DBOP_EXEC_ID, CASE WHEN :B13 = 0 THEN
NULL ELSE MAX(SQL_TEXT) END SQLMON_TEXT, MAX(IS_FULL_SQLTEXT) IS_FULL_TEXT, SUM(ELAPSED_TIME) SUM_ELAPSED_TIME, MAX(ELAPSED_TIME) MAX_ELAPSED_TIME, MAX(QUEUING_TIME) MAX_QUEUING_TIME, SUM(CPU_TIME) SUM_CPU_TIME, SUM(USER_IO_WAIT_TIME) SUM_USER_IO_WAIT_TIME, SUM(APPLICATION_WAIT_TIME) SUM_APPLICATION_WAIT_TIME, SUM(CONCURRENCY_WAIT_TIME) SUM_CONCURRENCY_WAIT_TIME, SUM(CLUSTER_WAIT_TIME) SUM_CLUSTER_WAIT_TIME, SUM(PLSQL_EXEC_TIME) SUM_PLSQL_EXEC_TIME, SUM(JAVA_EXEC_TIME) SUM_JAVA_EXEC_TIME, SUM(OTHER_WAIT_TIME) SUM_OTHER_WAIT_TIME, SUM(FETCHES) SUM_FETCHES, SUM(BUFFER_GETS) SUM_BUFFER_GETS, SUM(READ_REQS) SUM_READ_REQS, SUM(READ_BYTES) SUM_READ_BYTES, SUM(WRITE_REQS) SUM_WRITE_REQS, SUM(WRITE_BYTES) SUM_WRITE_BYTES, NVL(SUM(READ_BYTES), 0) + NVL(SUM(WRITE_BYTES), 0) SUM_IO_BYTES, SUM(IO_INTER_BYTES) SUM_IO_INTER_BYTES, SUM(IO_UNC_BYTES) SUM_IO_UNC_BYTES, SUM(IO_ELIG_BYTES) SUM_IO_ELIG_BYTES, SUM(IO_RET_BYTES) SUM_IO_RET_BYTES, MAX(RM_INFO) AGG_RM_INFO, MAX(CON
_NAME) MAX_CON_NAME, MAX(CON_ID) MAX_CON_ID FROM MONITOR_DATA) MD, (SELECT HOST_NAME FROM V$INSTANCE) INST, (SELECT DB_UNIQUE_NAME, PLATFORM_NAME FROM V$DATABASE) DB), ASH_DATA AS (SELECT AD0.INST_ID, AD0.SESSION_ID, AD0.PLAN_LINE_ID, AD0.PLSQL_OBJECT_ID, AD0.PLSQL_SUBPROGRAM_ID, AD0.ACTIVITY_BUCKET_NUM, AD0.PLAN_ACTIVITY_BUCKET_NUM, AD0.SQL, AD0.TOP_LEVEL_SQL_ID, AD0.DBOP_NAME, AD0.IS_MONITORED_SQL, AD0.IS_PX_SLAVE, AD0.BUCKET_ACTIVITY_START, AD0.ACTIVITY_START, AD0.BUCKET_ACTIVITY_END, AD0.ACTIVITY_END, AD0.ACTIVITY_COUNT, AD0.ACTIVITY_TYPE, AD0.OTHER_SQL_ACTIVITY_TYPE, AD0.EVENT_NAME, AD0.IMQ_COUNT, AD0.WAIT_COUNT, AD0.CPU_COUNT, AD0.OTHER_SQL_COUNT, AD0.PX_SERVER_SET, AD0.PX_DFO_ACTIVITY_COUNT, AD0.DFO_MOST_ACTIVE_IID, AD0.DFO_MOST_ACTIVE_SID, (CASE WHEN AD0.DFO_MOST_ACTIVE_IID = AD0.INST_ID AND AD0.DFO_MOST_ACTIVE_SID = AD0.SESSION_ID AND (((AD0.PX_DFO_ACTIVITY_COUNT / AD0.DFO_MOST_ACTIVE_COUNT) >= AD0.PX_DOP * 1.05) OR ((AD0.PX_DFO_ACTIVITY_COU
NT / AD0.DFO_MOST_ACTIVE_COUNT) <= AD0.PX_DOP *0.95)) AND (AD0.DFO_DURATION * 100) > :B32 THEN AD0.ACTIVITY_COUNT ELSE NULL END) DFO_MOST_ACTIVE_COUNT, AD0.BUCKET_DISTINCT_SAMPLES, AD0.SQL_BUCKET_DISTINCT_SAMPLES, CASE WHEN AD0.PX_SERVER_GROUP IS NULL AND AD0.IS_PX_SLAVE = 1 THEN 1 ELSE AD0.PX_SERVER_GROUP END PX_SERVER_GROUP, AD0.PX_STEP_ID, AD0.PX_DFO_PAIR_TYPE, AD0.PX_DFO_PAIR_ID, AD0.PX_STEP_ARG, AD0.PX_DOP, CASE WHEN AD0.PX_DOP IS NOT NULL AND AD0.PX_DOP <> AD0.PX_MIN_DOP AND AD0.PX_MIN_DOP != 0 THEN PX_MIN_DOP ELSE NULL END PX_MIN_DOP FROM (SELECT /*+ use_hash(ash) leading(mo) */ ASH.INST_ID, ASH.IS_PX_SLAVE, ASH.SESSION_ID, ASH.PLAN_LINE_ID, ASH.PLSQL_OBJECT_ID, ASH.PLSQL_SUBPROGRAM_ID, ASH.ACTIVITY_BUCKET_NUM, ASH.PLAN_ACTIVITY_BUCKET_NUM, ASH.SQL, ASH.TOP_LEVEL_SQL_ID, ASH.DBOP_NAME, ASH.IS_MONITORED_SQL, ASH.BUCKET_ACTIVITY_START, ASH.ACTIVITY_START, ASH.BUCKET_ACTIVITY_END, ASH.ACTIVITY_END, ASH.ACTIVITY_COUNT, ASH.ACTIVITY_TYPE, ASH.OT
HER_SQL_ACTIVITY_TYPE, ASH.EVENT_NAME, ASH.IMQ_COUNT, ASH.WAIT_COUNT, ASH.CPU_COUNT, ASH.OTHER_SQL_COUNT, MO.PX_SERVER_SET, ASH.PX_DFO_ACTIVITY_COUNT, TRUNC(ASH.MOST_ACTIVE_IN_DFO / 10000000000) DFO_MOST_ACTIVE_COUNT, MOD(TRUNC(ASH.MOST_ACTIVE_IN_DFO / 1000000), 10000) DFO_MOST_ACTIVE_IID, MOD(ASH.MOST_ACTIVE_IN_DFO, 1000000) DFO_MOST_ACTIVE_SID, ASH.DFO_DURATION, ASH.BUCKET_DISTINCT_SAMPLES, ASH.SQL_BUCKET_DISTINCT_SAMPLES, MO.PX_SERVER_GROUP, ASH.PX_STEP_ID, ASH.PX_DFO_PAIR_TYPE, ASH.PX_DFO_PAIR_ID, ASH.PX_STEP_ARG, ASH.PX_DOP, ASH.PX_MIN_DOP FROM (SELECT /*+ no_merge */ MD.INST_ID, MD.SID, MD.SESSION_SERIAL#, MD.PX_SERVER_SET, MD.PX_SERVER_GROUP FROM MONITOR_DATA MD WHERE MD.SID IS NOT NULL OR :B31 = 1) MO, (SELECT /*+ no_merge */ GVTF.INST_ID, GVTF.GLOBAL_SAMPLE_ID, GVTF.IS_PX_SLAVE, GVTF.SESSION_ID, GVTF.PLAN_LINE_ID, GVTF.PLSQL_OBJECT_ID, GVTF.PLSQL_SUBPROGRAM_ID, GVTF.ACTIVITY_BUCKET_NUM, GVTF.PLAN_ACTIVITY_BUCKET_NUM, GVTF.SQL, GVTF.TOP_LEVE
L_SQL_ID, GVTF.DBOP_NAME, GVTF.IS_MONITORED_SQL, GVTF.BUCKET_ACTIVITY_START, GVTF.ACTIVITY_START, GVTF.BUCKET_ACTIVITY_END, GVTF.ACTIVITY_END, GVTF.ACTIVITY_COUNT, GVTF.ACTIVITY_TYPE, GVTF.OTHER_SQL_ACTIVITY_TYPE, GVTF.EVENT_NAME, GVTF.IMQ_COUNT, GVTF.WAIT_COUNT, GVTF.CPU_COUNT, GVTF.OTHER_SQL_COUNT, MAX(GVTF.PER_SERVER_DFO_COUNT * 10000000000 + GVTF.INST_ID * 1000000 + GVTF.SESSION_ID) OVER(PARTITION BY GVTF.PX_DFO_PAIR_TYPE, GVTF.PX_DFO_PAIR_ID) MOST_ACTIVE_IN_DFO, SUM(GVTF.ACTIVITY_COUNT) OVER(PARTITION BY GVTF.PX_DFO_PAIR_TYPE, GVTF.PX_DFO_PAIR_ID) PX_DFO_ACTIVITY_COUNT, GVTF.DFO_DURATION, GVTF.PX_STEP_ID, GVTF.PX_DFO_PAIR_TYPE, GVTF.PX_DFO_PAIR_ID, GVTF.PX_STEP_ARG, GVTF.PX_DOP, GVTF.PX_MIN_DOP, COUNT(DISTINCT GVTF.GLOBAL_SAMPLE_ID) OVER(PARTITION BY GVTF.ACTIVITY_BUCKET_NUM) BUCKET_DISTINCT_SAMPLES, COUNT(DISTINCT GVTF.GLOBAL_SAMPLE_ID) OVER(PARTITION BY GVTF.SQL, GVTF.ACTIVITY_BUCKET_NUM) SQL_BUCKET_DISTINCT_SAMPLES FROM TABLE(GV$(CURSOR( (SELECT USER
ENV('INSTANCE') INST_ID, ASH2.GLOBAL_SAMPLE_ID, CASE WHEN :B30 = 1 AND :B27 > 1 THEN BUCKET_NUM ELSE NULL END ACTIVITY_BUCKET_NUM, CASE WHEN :B29 = 1 AND :B27 > 1 THEN BUCKET_NUM ELSE NULL END PLAN_ACTIVITY_BUCKET_NUM, ASH2.SQL, ASH2.TOP_LEVEL_SQL_ID, ASH2.DBOP_NAME, ASH2.IS_MONITORED_SQL, ASH2.PLAN_LINE_ID, ASH2.PLSQL_OBJECT_ID, ASH2.PLSQL_SUBPROGRAM_ID, ASH2.ACTIVITY_TYPE, ASH2.OTHER_SQL_ACTIVITY_TYPE, ASH2.EVENT_NAME, ASH2.IS_PX_SLAVE, ASH2.SESSION_ID, ASH2.PX_STEP_ID, ASH2.PX_DFO_PAIR_TYPE, ASH2.PX_DFO_PAIR_ID, ASH2.PX_STEP_ARG, CASE WHEN ASH2.PX_DFO_PAIR_ID IS NOT NULL THEN DECODE(ASH2.PX_DOP, 0, :B28 , ASH2.PX_DOP) ELSE NULL END PX_DOP, ASH2.PX_MIN_DOP, :B20 + NUMTODSINTERVAL(:B26 * (ASH2.BUCKET_NUM-1), 'SECOND') BUCKET_ACTIVITY_START, :B20 + NUMTODSINTERVAL( :B26 * ASH2.BUCKET_NUM - 1, 'SECOND') BUCKET_ACTIVITY_END, ASH2.ACTIVITY_START, ASH2.ACTIVITY_END, ASH2.ACTIVITY_COUNT, ASH2.IMQ_COUNT, ASH2.WAIT_COUNT, ASH2.CPU_COUNT, ASH2.OTHER_SQL
_COUNT, SUM(ASH2.ACTIVITY_COUNT) OVER(PARTITION BY ASH2.PX_DFO_PAIR_ID, ASH2.PX_DFO_PAIR_TYPE, DECODE(ASH2.PX_DFO_PAIR_ID, NULL, NULL, ASH2.SESSION_ID)) PER_SERVER_DFO_COUNT, CEIL((MAX(ASH2.MAX_SAMPLE_DATE) OVER(PARTITION BY ASH2.PX_DFO_PAIR_ID, ASH2.PX_DFO_PAIR_TYPE) - MIN(ASH2.MIN_SAMPLE_DATE) OVER(PARTITION BY ASH2.PX_DFO_PAIR_ID, ASH2.PX_DFO_PAIR_TYPE)) * 3600 * 24) DFO_DURATION FROM (SELECT ASH1.BUCKET_NUM, ASH1.GLOBAL_SAMPLE_ID, ASH1.PLAN_LINE_ID, ASH1.PLSQL_OBJECT_ID, ASH1.PLSQL_SUBPROGRAM_ID, ASH1.ACTIVITY_TYPE, ASH1.OTHER_SQL_ACTIVITY_TYPE, ASH1.EVENT_NAME, ASH1.SESSION_ID, ASH1.PX_STEP_ID, ASH1.PX_STEP_ARG, MAX(ASH1.SQL) SQL, MAX(ASH1.IS_MONITORED_SQL) IS_MONITORED_SQL, MAX(ASH1.PX_DFO_PAIR_TYPE) PX_DFO_PAIR_TYPE, MAX(ASH1.PX_DFO_PAIR_ID) PX_DFO_PAIR_ID, MIN(SAMPLE_DATE) MIN_SAMPLE_DATE, MAX(SAMPLE_DATE) MAX_SAMPLE_DATE, MAX(ASH1.IS_PX_SLAVE) IS_PX_SLAVE, MAX(ASH1.PX_DOP) PX_DOP, MIN(ASH1.PX_DOP) PX_MIN_DOP, MIN(ASH1.SAMPLE_DATE) ACTIVITY_START,
MAX(ASH1.SAMPLE_DATE) ACTIVITY_END, COUNT(ASH1.SQL) ACTIVITY_COUNT, COUNT(CASE WHEN ASH1.ACTIVITY_TYPE = 'Cpu' AND ASH1.EVENT_NAME = 'in memory' THEN 1 ELSE NULL END) IMQ_COUNT, COUNT(CASE WHEN ASH1.ACTIVITY_TYPE != 'Other SQL Execution' AND ASH1.ACTIVITY_TYPE != 'Non SQL' AND ASH1.ACTIVITY_TYPE != 'Cpu' THEN 1 ELSE NULL END) WAIT_COUNT, COUNT(CASE WHEN ASH1.ACTIVITY_TYPE = 'Cpu' AND ASH1.EVENT_NAME IS NULL THEN 1 ELSE NULL END) CPU_COUNT, COUNT(CASE WHEN ASH1.ACTIVITY_TYPE = 'Other SQL Execution' AND ASH1.ACTIVITY_TYPE != 'Non SQL' THEN 1 ELSE NULL END) OTHER_SQL_COUNT, MAX(ASH1.TOP_LEVEL_SQL_ID) TOP_LEVEL_SQL_ID, MAX(ASH1.DBOP_NAME) DBOP_NAME FROM ( SELECT (CASE WHEN :B27 > 1 THEN (TRUNC(DELTA_TIME_SECONDS/ :B26 ) + 1) ELSE 1 END) BUCKET_NUM, ASH00.SQL, ASH00.SAMPLE_DATE, NVL2(DUP.C2, TRUNC(DELTA_TIME_SECONDS/ (:B25 )) + 1, NULL) GLOBAL_SAMPLE_ID, NVL2(DUP.C2, NULL, ASH00.IS_MONITORED_SQL) IS_MONITORED_SQL, NVL2(DUP.C2, NULL, ASH00.IN_INMEMORY_QUERY) IN_INMEMORY_
QUERY, NVL2(DUP.C2, NULL, ASH00.WAIT_CLASS) WAIT_CLASS, NVL2(DUP.C2, NULL, ASH00.ACTIVITY_TYPE) ACTIVITY_TYPE, NVL2(DUP.C2, NULL, ASH00.OTHER_SQL_ACTIVITY_TYPE) OTHER_SQL_ACTIVITY_TYPE, NVL2(DUP.C2, NULL, ASH00.EVENT_NAME) EVENT_NAME, NVL2(DUP.C2, NULL, ASH00.TOP_LEVEL_SQL_ID) TOP_LEVEL_SQL_ID, NVL2(DUP.C2, NULL, ASH00.DBOP_NAME) DBOP_NAME, NVL2(DUP.C2, NULL, ASH00.IS_PX_SLAVE) IS_PX_SLAVE, NVL2(DUP.C2, NULL, ASH00.SESSION_ID) SESSION_ID, NVL2(DUP.C2, NULL, ASH00.PLSQL_OBJECT_ID) PLSQL_OBJECT_ID, NVL2(DUP.C2, NULL, ASH00.PLSQL_SUBPROGRAM_ID) PLSQL_SUBPROGRAM_ID, NVL2(DUP.C2, NULL, ASH00.PLAN_LINE_ID) PLAN_LINE_ID, NVL2(DUP.C2, NULL, ASH00.PX_STEP_ID) PX_STEP_ID, NVL2(DUP.C2, NULL, ASH00.PX_STEP_ARG) PX_STEP_ARG, NVL2(DUP.C2, NULL, ASH00.PX_DFO_PAIR_ID) PX_DFO_PAIR_ID, NVL2(DUP.C2, NULL, ASH00.PX_DFO_PAIR_TYPE) PX_DFO_PAIR_TYPE, NVL2(DUP.C2, NULL, ASH00.PX_DOP) PX_DOP FROM (SELECT 1 C1, NULL C2 FROM V$TIMER UNION ALL SELECT 1 C1, 1 C2 FR
OM V$TIMER) DUP, (SELECT /*+ no_merge */ 1 C1, ASH000.SAMPLE_DATE, ASH000.IS_MONITORED_SQL, ((EXTRACT(SECOND FROM(DELTA_TIME)) + EXTRACT(MINUTE FROM(DELTA_TIME)) * 60 + EXTRACT(HOUR FROM(DELTA_TIME)) * 3600 + EXTRACT(DAY FROM(DELTA_TIME)) * 86400)) DELTA_TIME_SECONDS, ASH000.IN_INMEMORY_QUERY, ASH000.WAIT_CLASS, DECODE(ASH000.IS_MONITORED_SQL, 1, NVL(ASH000.WAIT_CLASS, 'Cpu'), DECODE(SQL_ID, NULL, 'Non SQL', 'Other SQL Execution')) ACTIVITY_TYPE, NVL(ASH000.WAIT_CLASS, 'Cpu') OTHER_SQL_ACTIVITY_TYPE, DECODE(:B24 , 1, CASE WHEN ASH000.IS_MONITORED_SQL = 1 THEN NVL(ASH000.EVENT, DECODE(ASH000.IN_INMEMORY_QUERY, 'Y', 'in memory', ASH000.EVENT)) WHEN ASH000.SQL_ID IS NOT NULL THEN 'sql_id: ' || ASH000.SQL_ID WHEN ASH000.CALL_NAME IS NOT NULL THEN 'call: ' || ASH000.CALL_NAME ELSE 'anonymous: '|| ASH000.EVENT END, NULL) EVENT_NAME, CASE WHEN ASH000.IS_MONITORED_SQL = 1 AND (NVL(ASH000.SQL_ID, :B9 ) = :B9 OR NVL(ASH000.DBOP_NAME, :B6 ) = :B6 ) THEN 'this' WHEN ASH0
00.IS_PX_SLAVE = 1 AND ASH000.SQL_ID IS NOT NULL AND ASH000.TOP_LEVEL_SQL_ID != ASH000.SQL_ID THEN ASH000.TOP_LEVEL_SQL_ID WHEN ASH000.SQL_ID IS NOT NULL THEN ASH000.SQL_ID ELSE NVL(CALL_NAME, 'anonymous') END SQL, CASE WHEN ASH000.IS_PX_SLAVE = 0 AND (ASH000.SQL_ID IS NULL OR ASH000.TOP_LEVEL_SQL_ID != ASH000.SQL_ID) THEN ASH000.TOP_LEVEL_SQL_ID END TOP_LEVEL_SQL_ID, ASH000.DBOP_NAME, ASH000.IS_PX_SLAVE, CASE WHEN ASH000.IS_PX_SLAVE = 1 AND ASH000.IS_MONITORED_SQL != 1 THEN 65536 ELSE ASH000.SESSION_ID END SESSION_ID, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.PLSQL_OBJECT_ID, NULL) PLSQL_OBJECT_ID, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.PLSQL_SUBPROGRAM_ID, NULL) PLSQL_SUBPROGRAM_ID, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.SQL_PLAN_LINE_ID, NULL) PLAN_LINE_ID, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.PX_STEP_ID, NULL) PX_STEP_ID, CASE WHEN ASH000.IS_PX_SLAVE = 1 AND ASH000.IS_MONITORED_SQL = 1 AND ASH000.PX_STEP_ID IN (1, 2, 3) THEN ASH000.PX_STEP_ARG ELS
E NULL END PX_DFO_PAIR_ID, CASE WHEN ASH000.IS_PX_SLAVE = 0 OR ASH000.IS_MONITORED_SQL != 1 THEN NULL WHEN ASH000.PX_STEP_ID = 1 THEN 1 WHEN ASH000.PX_STEP_ID IN (2, 3) THEN 0 ELSE NULL END PX_DFO_PAIR_TYPE, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.PX_STEP_ARG, NULL) PX_STEP_ARG, DECODE(ASH000.IS_MONITORED_SQL, 1, ASH000.PX_DOP, NULL) PX_DOP FROM (SELECT ASH0.*, CASE WHEN ASH0.IS_TARGET_SQL = 1 OR (ASH0.IS_PX_SLAVE = 1 AND ((NVL(ASH0.TOP_LEVEL_SQL_ID, ASH0.SQL_ID) IS NOT NULL AND NVL(ASH0.TOP_LEVEL_SQL_ID, ASH0.SQL_ID) = :B9 ) OR (SQL_ID IS NULL AND :B23 = 'Y'))) THEN 1 ELSE 0 END IS_MONITORED_SQL FROM (SELECT (CASE WHEN (ASH.SQL_ID = :B9 AND ASH.SQL_EXEC_ID = :B7 AND ASH.SQL_EXEC_START = :B8 ) THEN 1 ELSE 0 END) IS_TARGET_SQL, ASH.SQL_ID, ASH.SQL_PLAN_LINE_ID, ASH.PLSQL_OBJECT_ID, ASH.PLSQL_SUBPROGRAM_ID, ASH.TOP_LEVEL_SQL_ID, DECODE(ASH.SQL_ID, NULL, ASH.TOP_LEVEL_CALL_NAME, NULL) CALL_NAME, ASH.EVENT, ASH.IN_INMEMORY_QUERY, ASH.WAIT_CLASS, ASH.SQL_EXEC_ID,
ASH.SQL_EXEC_START, ASH.DBOP_NAME, ASH.DBOP_EXEC_ID, ASH.SESSION_ID, ASH.SESSION_SERIAL#, CASE WHEN QC_INSTANCE_ID IS NOT NULL AND (ASH.SESSION_ID != ASH.QC_SESSION_ID OR ASH.SESSION_SERIAL# != ASH.QC_SESSION_SERIAL# OR USERENV('instance') != ASH.QC_INSTANCE_ID) THEN 1 ELSE 0 END IS_PX_SLAVE, SAMPLE_TIME - CAST(:B20 AS TIMESTAMP) DELTA_TIME, CAST(FROM_TZ(ASH.SAMPLE_TIME, DBTIMEZONE) AS DATE) SAMPLE_DATE, TRUNC(MOD(PX_FLAGS/65536, 32)) PX_STEP_ID, MOD(PX_FLAGS, 65536) PX_STEP_ARG, TRUNC(PX_FLAGS/2097152) PX_DOP FROM V$ACTIVE_SESSION_HISTORY ASH WHERE ((ASH.SESSION_ID = :B19 AND ASH.SESSION_SERIAL# = :B18 AND USERENV('INSTANCE') = :B17 ) OR (ASH.QC_SESSION_ID IS NOT NULL AND ASH.QC_SESSION_ID = :B19 AND ASH.QC_SESSION_SERIAL# = :B18 AND ASH.QC_INSTANCE_ID = :B17 )) AND SAMPLE_TIME BETWEEN :B16 AND :B15 ) ASH0 WHERE (ASH0.SAMPLE_DATE BETWEEN :B20 + 1/24/3600 AND :B22 - 1/24/3600 OR (ASH0.SQL_ID = :B9 AND ASH0.SQL_EXEC_START = :B8 AND ASH0.SQL_EXEC_ID = :B7 ) OR (ASH0.DBOP_N
AME = :B6 AND ASH0.DBOP_EXEC_ID = :B5 )) AND (:B21 IS NULL OR ASH0.SQL_PLAN_LINE_ID = :B21 ) AND (ASH0.IS_PX_SLAVE = 0 OR ASH0.SQL_ID IS NOT NULL)) ASH000 ) ASH00 WHERE ASH00.C1 = DUP.C1) ASH1 WHERE ASH1.BUCKET_NUM > 0 AND ASH1.BUCKET_NUM <= :B27 GROUP BY USERENV('INSTANCE'), ASH1.GLOBAL_SAMPLE_ID, ASH1.BUCKET_NUM, ASH1.SESSION_ID, ASH1.PLAN_LINE_ID, ASH1.PLSQL_OBJECT_ID, ASH1.PLSQL_SUBPROGRAM_ID, ASH1.ACTIVITY_TYPE, ASH1.EVENT_NAME, ASH1.OTHER_SQL_ACTIVITY_TYPE, ASH1.PX_STEP_ID, ASH1.PX_STEP_ARG) ASH2)))) GVTF WHERE GVTF.INST_ID BETWEEN :B11 AND :B10 ) ASH WHERE ASH.GLOBAL_SAMPLE_ID IS NULL AND ASH.SESSION_ID = MO.SID(+) AND ASH.INST_ID = MO.INST_ID(+)) AD0), RESPONSE_TIME_DATA AS (SELECT ADH.BUCKET_NUM, ADH.SQL_ROWNUM, ADH.SQL, ADH.TOP_LEVEL_SQL_ID, ADH.DBOP_NAME, ADH.PX_ID, DECODE( ADH.PX_STEP_ID, NULL, NULL, 0, NULL, 1, 'PX Server(s) - Executing Parent DFO', 2, 'PX Server(s) - Executing Child DFO', 3, 'PX Server(s) - Sampling Child DFO', 4, 'PX S
erver(s) - Joining Group', 5, 'QC - Scheduling Child DFO', 6, 'QC - Scheduling Parent DFO', 7, 'QC - Initializing Objects', 8, 'QC - Flushing Objects', 9, 'QC - Allocating Slaves', 10, 'QC - Initializing Granules', 11, 'PX Server(s) - Parsing Cursor', 12, 'PX Server(s) - Executing Cursor', 13, 'PX Server(s) - Preparing Transaction', 14, 'PX Server(s) - Joining Transaction', 15, 'PX Server(s) - Load Commit', 16, 'PX Server(s) - Aborting Transaction', 17, 'QC - Executing Child DFO', 18, 'QC - Executing Parent DFO', 'PX Step - ' || PX_STEP_ID) PX_STEP_ID, ADH.PX_STEP_ARG, ADH.PX_DFO_PAIR_ID, ADH.PX_DOP, ADH.PX_MIN_DOP, ADH.DFO_MOST_ACTIVE_IID, ADH.DFO_MOST_ACTIVE_SID, ADH.DFO_MOST_ACTIVE_COUNT, ADH.ACTIVITY_START, ADH.ACTIVITY_END, ADH.ACTIVITY_TYPE, ADH.OTHER_SQL_ACTIVITY_TYPE, ADH.EVENT_NAME, ADH.PLAN_LINE_ID, ADH.PLSQL_OBJECT_ID, ADH.PLSQL_SUBPROGRAM_ID, CASE WHEN PLSQL_ROWNUM = 1 AND ADH.PLSQL_OBJECT_ID IS NOT NULL THEN NVL((SELECT P.OWNER
|| '.' || P.OBJECT_NAME || DECODE(P.PROCEDURE_NAME, NULL, '', '.' || P.PROCEDURE_NAME) FROM DBA_PROCEDURES P WHERE P.OBJECT_ID = ADH.PLSQL_OBJECT_ID AND P.SUBPROGRAM_ID = ADH.PLSQL_SUBPROGRAM_ID), 'Unavailable') ELSE NULL END PLSQL_NAME, ADH.ACTIVITY_COUNT, ADH.BUCKET_ACTIVE_SECONDS, ADH.BUCKET_IDLE_SECONDS, (CASE WHEN ADH.IS_MONITORED_SQL = 0 THEN ADH.ACTIVE_SECONDS WHEN ADH.PX_DFO_PAIR_ID IS NOT NULL AND ADH.DFO_PAIR_CPU_HEIGHT >= :B34 THEN DECODE(ADH.ACTIVITY_TYPE, 'Cpu', (ADH.DFO_PAIR_ACTIVITY_HEIGHT / ADH.DFO_PAIR_CPU_HEIGHT) * ADH.DFO_PAIR_TOTAL_SECONDS, 0) WHEN ADH.PX_DFO_PAIR_ID IS NOT NULL AND ADH.PX_DOP > :B34 THEN (ADH.DFO_PAIR_TOTAL_SECONDS * DECODE(ADH.ACTIVITY_TYPE, 'Cpu', ADH.DFO_PAIR_ACTIVITY_HEIGHT, (ADH.DFO_PAIR_ACTIVITY_HEIGHT * (:B34 - ADH.DFO_PAIR_CPU_HEIGHT)) / (ADH.DFO_PAIR_TOTAL_HEIGHT_ADJ - ADH.DFO_PAIR_CPU_HEIGHT))) / :B34 WHEN ADH.PX_DFO_PAIR_ID IS NOT NULL THEN (ADH.DFO_PAIR_TOTAL_SECONDS * ADH.DFO_PAIR_ACTIVITY_HEIGHT) / ADH.PX_DOP ELSE
ADH.ACTIVE_SECONDS END) RESP_TIME, (CASE WHEN ADH.PX_DFO_PAIR_ID IS NOT NULL AND ADH.DFO_PAIR_IDLE_HEIGHT > 0 AND ADH.PX_DOP > :B34 THEN (ADH.DFO_PAIR_TOTAL_SECONDS * (ADH.DFO_PAIR_IDLE_HEIGHT * (:B34 - ADH.DFO_PAIR_CPU_HEIGHT)) / (ADH.DFO_PAIR_TOTAL_HEIGHT_ADJ - ADH.DFO_PAIR_CPU_HEIGHT)) / :B34 WHEN ADH.PX_DFO_PAIR_ID IS NOT NULL AND ADH.DFO_PAIR_IDLE_HEIGHT > 0 THEN (ADH.DFO_PAIR_TOTAL_SECONDS * ADH.DFO_PAIR_IDLE_HEIGHT) / ADH.PX_DOP ELSE 0 END) DFO_PAIR_IDLE_RESP_TIME, ADH.DFO_PAIR_ACTIVITY_HEIGHT, ADH.DFO_PAIR_CPU_HEIGHT, ADH.DFO_PAIR_IDLE_HEIGHT, ADH.DFO_PAIR_TOTAL_HEIGHT, ADH.DFO_PAIR_CPU_ACTIVITY, ADH.DFO_PAIR_TOTAL_SECONDS FROM (SELECT ADH_1.*, (ROW_NUMBER() OVER(PARTITION BY ADH_1.PLSQL_OBJECT_ID, ADH_1.PLSQL_SUBPROGRAM_ID ORDER BY ADH_1.BUCKET_NUM, ADH_1.ACTIVITY_TYPE, ADH_1.EVENT_NAME)) PLSQL_ROWNUM, (ROW_NUMBER() OVER(PARTITION BY ADH_1.SQL ORDER BY ADH_1.BUCKET_NUM, ADH_1.ACTIVITY_TYPE, ADH_1.EVENT_NAME)) SQL_ROWNUM, (CASE WHEN ADH_1.PX_DFO_PAIR_ID
IS NOT NULL AND (ADH_1.DFO_PAIR_TOTAL_HEIGHT < ADH_1.PX_DOP) AND (ADH_1.DFO_PAIR_CPU_HEIGHT < :B34 ) THEN ADH_1.PX_DOP - ADH_1.DFO_PAIR_TOTAL_HEIGHT ELSE 0 END) DFO_PAIR_IDLE_HEIGHT, (CASE WHEN ADH_1.PX_DFO_PAIR_ID IS NOT NULL AND (ADH_1.DFO_PAIR_TOTAL_HEIGHT < ADH_1.PX_DOP) AND (ADH_1.DFO_PAIR_CPU_HEIGHT < :B34 ) THEN ADH_1.PX_DOP ELSE ADH_1.DFO_PAIR_TOTAL_HEIGHT END) DFO_PAIR_TOTAL_HEIGHT_ADJ FROM (SELECT ADH_0.*, (CASE WHEN ADH_0.DFO_PAIR_TOTAL_SECONDS > 0 THEN (ADH_0.DFO_PAIR_TOTAL_ACTIVITY * :B25 ) / ADH_0.DFO_PAIR_TOTAL_SECONDS ELSE 0 END) DFO_PAIR_TOTAL_HEIGHT, (CASE WHEN ADH_0.DFO_PAIR_TOTAL_SECONDS > 0 THEN (ADH_0.DFO_PAIR_CPU_ACTIVITY * :B25 ) / ADH_0.DFO_PAIR_TOTAL_SECONDS ELSE 0 END) DFO_PAIR_CPU_HEIGHT, (CASE WHEN ADH_0.PX_DFO_PAIR_ID IS NOT NULL AND ADH_0.DFO_PAIR_TOTAL_SECONDS > 0 THEN (ADH_0.ACTIVITY_COUNT * :B25 ) / ADH_0.DFO_PAIR_TOTAL_SECONDS ELSE 0 END) DFO_PAIR_ACTIVITY_HEIGHT FROM (SELECT AD3.*, (SUM(DECODE(AD3.PX_DFO_PAIR_ID, NULL, 0,
AD3.ACTIVE_SECONDS)) OVER(PARTITION BY DECODE(AD3.PX_DFO_PAIR_ID, NULL, NULL, AD3.BUCKET_NUM), DECODE(AD3.PX_DFO_PAIR_ID, NULL, NULL, AD3.PX_STEP_ARG))) DFO_PAIR_TOTAL_SECONDS FROM (SELECT AD2.*, CASE WHEN AD2.IS_MONITORED_SQL = 0 THEN SQL_BUCKET_DISTINCT_SAMPLES * :B25 WHEN AD2.PX_ID IS NULL THEN AD2.ACTIVITY_COUNT * :B25 WHEN AD2.BUCKET_PARALLEL_MON_ACTIVITY > 0 THEN (AD2.ACTIVITY_COUNT * AD2.BUCKET_PARALLEL_MON_SECONDS) / AD2.BUCKET_PARALLEL_MON_ACTIVITY ELSE 0 END ACTIVE_SECONDS, CASE WHEN AD2.BUCKET_INTERVAL > BUCKET_ACTIVE_SECONDS THEN AD2.BUCKET_INTERVAL - BUCKET_ACTIVE_SECONDS ELSE 0 END BUCKET_IDLE_SECONDS FROM (SELECT AD1.*, (AD1.BUCKET_SERIAL_MON_ACTIVITY * :B25 ) BUCKET_SERIAL_MON_SECONDS, (AD1.BUCKET_TOTAL_MON_ACTIVITY - AD1.BUCKET_SERIAL_MON_ACTIVITY) BUCKET_PARALLEL_MON_ACTIVITY, (AD1.BUCKET_ACTIVE_SECONDS - (AD1.BUCKET_OTHER_ACTIVITY + AD1.BUCKET_SERIAL_MON_ACTIVITY) * :B25 ) BUCKET_PARALLEL_MON_SECONDS, (AD1.BUCKET_OTHER_ACTIVITY * :B25 ) BUCKET_OTH
ER_SECONDS, DECODE(AD1.PX_DFO_PAIR_ID, NULL, NULL, SUM(AD1.ACTIVITY_COUNT) OVER(PARTITION BY DECODE(AD1.PX_DFO_PAIR_ID, NULL, NULL, AD1.BUCKET_NUM), AD1.PX_DFO_PAIR_ID)) DFO_PAIR_TOTAL_ACTIVITY, DECODE(AD1.PX_DFO_PAIR_ID, NULL, NULL, SUM(DECODE(AD1.ACTIVITY_TYPE, 'Cpu', AD1.ACTIVITY_COUNT, 0)) OVER(PARTITION BY DECODE(AD1.PX_DFO_PAIR_ID, NULL, NULL, AD1.BUCKET_NUM), AD1.PX_DFO_PAIR_ID)) DFO_PAIR_CPU_ACTIVITY FROM (SELECT AD01.*, NVL((SUM(DECODE(AD01.IS_MONITORED_SQL, 1, AD01.ACTIVITY_COUNT, NULL)) OVER(PARTITION BY AD01.BUCKET_NUM)), 0) BUCKET_TOTAL_MON_ACTIVITY, (NVL(SUM(CASE WHEN AD01.IS_MONITORED_SQL = 1 AND AD01.PX_ID IS NULL THEN AD01.ACTIVITY_COUNT ELSE NULL END) OVER(PARTITION BY AD01.BUCKET_NUM), 0)) BUCKET_SERIAL_MON_ACTIVITY, (NVL((SUM(DECODE(AD01.IS_MONITORED_SQL, 0, AD01.SQL_BUCKET_DISTINCT_SAMPLES, NULL)) OVER(PARTITION BY AD01.BUCKET_NUM)), 0)) BUCKET_OTHER_ACTIVITY, (NVL(AD01.BUCKET_DISTINCT_SAMPLES, 0) * :B25 ) BUCKET_ACTIVE_SECONDS, DE
CODE(AD01.BUCKET_NUM, :B27 , MOD(:B32 , :B26 ), :B26 ) BUCKET_INTERVAL FROM (SELECT AD0.ACTIVITY_BUCKET_NUM BUCKET_NUM, AD0.PX_ID, AD0.ACTIVITY_TYPE, AD0.OTHER_SQL_ACTIVITY_TYPE, AD0.EVENT_NAME, AD0.PLAN_LINE_ID, AD0.PX_STEP_ID, AD0.PX_STEP_ARG, AD0.PLSQL_OBJECT_ID, AD0.PLSQL_SUBPROGRAM_ID, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT, MIN(AD0.ACTIVITY_START) ACTIVITY_START, MAX(AD0.ACTIVITY_END) ACTIVITY_END, MAX(AD0.IS_MONITORED_SQL) IS_MONITORED_SQL, MAX(AD0.SQL) SQL, MAX(AD0.TOP_LEVEL_SQL_ID) TOP_LEVEL_SQL_ID, MAX(AD0.DBOP_NAME) DBOP_NAME, MAX(DECODE(AD0.DFO_MOST_ACTIVE_COUNT, NULL, NULL, AD0.DFO_MOST_ACTIVE_IID)) DFO_MOST_ACTIVE_IID, MAX(DECODE(AD0.DFO_MOST_ACTIVE_COUNT, NULL, NULL, AD0.DFO_MOST_ACTIVE_SID)) DFO_MOST_ACTIVE_SID, SUM(AD0.DFO_MOST_ACTIVE_COUNT) DFO_MOST_ACTIVE_COUNT, MAX(PX_DFO_PAIR_TYPE) PX_DFO_PAIR_TYPE, MAX(PX_DFO_PAIR_ID) PX_DFO_PAIR_ID, MAX(AD0.PX_DOP) PX_DOP, MIN(AD0.PX_MIN_DOP) PX_MIN_DOP, MAX(AD0.BUCKET_DISTINCT_SAMPLES) BUCKET_DI
STINCT_SAMPLES, MAX(AD0.SQL_BUCKET_DISTINCT_SAMPLES) SQL_BUCKET_DISTINCT_SAMPLES FROM (SELECT AD00.*, (CASE WHEN AD00.IS_MONITORED_SQL = 1 AND (AD00.SESSION_ID != :B19 OR AD00.INST_ID != :B17 ) THEN AD00.PX_SERVER_GROUP END) PX_ID FROM ASH_DATA AD00 WHERE :B33 = 1 ) AD0 GROUP BY AD0.ACTIVITY_BUCKET_NUM, AD0.PX_ID, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, AD0.OTHER_SQL_ACTIVITY_TYPE, AD0.PLAN_LINE_ID, AD0.PLSQL_OBJECT_ID, AD0.PLSQL_SUBPROGRAM_ID, AD0.PX_STEP_ID, AD0.PX_STEP_ARG ) AD01) AD1) AD2) AD3) ADH_0) ADH_1) ADH) SELECT /*+ no_monitor no_xml_query_rewrite */ XMLELEMENT( "sql_monitor_report", XMLATTRIBUTES(:B59 AS "version", TO_CHAR(:B58 , :B12 ) AS "sysdate"), XMLELEMENT( "report_parameters", NULL, CASE WHEN :B57 IS NOT NULL THEN XMLFOREST( :B57 AS "dbop_name", :B56 AS "dbop_exec_id") ELSE XMLFOREST( :B55 AS "sql_id", :B54 AS "sql_exec_id") END, XMLFOREST( :B53 AS "session_id",
:B52 AS "session_serial", TO_CHAR(:B51 , :B12 ) AS "sql_exec_start", :B27 AS "bucket_count", TO_CHAR(:B50 , :B12 ) AS "interval_start", TO_CHAR(:B22 , :B12 ) AS "interval_end", DECODE(:B49 , 'Y', :B48 , NULL) AS "auto_refresh", :B47 AS "base_path"), CASE WHEN :B23 = 'Y' AND :B46 IS NOT NULL AND NOT (:B4 = 1 AND :B3 IS NULL AND :B2 IS NULL AND :B1 IS NULL) THEN XMLELEMENT( "parallel_filter", NULL, XMLFOREST( DECODE(:B4 , 1, 'yes', 'no') AS "qc", :B3 AS "server_group", :B2 AS "server_set", :B1 AS "server_number")) ELSE NULL END), CASE WHEN :B14 = 1 THEN XMLELEMENT( "derived_parameters_testing", NULL, XMLFOREST(:B11 AS "instance_id_low", :B10 AS "instance_id_high", :B26 AS "bucket_interval_sec", :B32 AS "interval_second", :B27 AS "bucket_calc_count", :B45 AS "bucket_calc_max_co
unt", :B13 AS "sel_sqltext")) ELSE NULL END, (SELECT XMLCONCAT( CASE WHEN :B46 IS NULL AND :B60 IS NULL THEN XMLELEMENT( "target", XMLATTRIBUTES(:B17 AS "instance_id", :B19 AS "session_id", :B18 AS "session_serial", NVL2(:B6 , NULL, :B9 ) AS "sql_id", NVL2(:B6 , NULL, TO_CHAR(:B8 , :B12 )) AS "sql_exec_start", NVL2(:B6 , NULL, :B7 ) AS "sql_exec_id", NVL2(:B6 , :B6 , NULL) AS "dbop_name", NVL2(:B6 , :B5 , NULL) AS "dbop_exec_id", NVL2(:B6 , TO_CHAR(:B8 , :B12 ), NULL) AS "dbop_exec_start", NVL2(:B6 , NULL, MAX_PLAN_HASH_VALUE) AS "sql_plan_hash", NVL2(:B6 , NULL, MAX_FULL_PLAN_HASH_VALUE) AS "sql_full_plan_hash", MAGG.DB_UNIQUE_NAME AS "db_unique_name", MAGG.PLATFORM_NAME AS "db_platform_name", MAGG.HOST_NAME AS "report_host_name"), NVL2(SUM_SERVERS_REQUESTED, XMLELEMENT( "servers_re
quested", NULL, SUM_SERVERS_REQUESTED), NULL), NVL2(SUM_SERVERS_ALLOCATED, XMLELEMENT( "servers_allocated", NULL, SUM_SERVERS_ALLOCATED), NULL), NVL2(MAX_USERID, XMLELEMENT( "user_id", NULL, MAX_USERID), NULL), NVL2(MAX_USERNAME, XMLELEMENT( "user", NULL, MAX_USERNAME), NULL), NVL2(MAX_CON_ID, XMLELEMENT( "con_id", NULL, MAX_CON_ID), NULL), NVL2(MAX_CON_NAME, XMLELEMENT( "con_name", NULL, MAX_CON_NAME), NULL), NVL2(MAX_PROGRAM, XMLELEMENT( "program", NULL, MAX_PROGRAM), NULL), NVL2(MAX_MODULE, XMLELEMENT( "module", NULL, MAX_MODULE), NULL), NVL2(MAX_ACTION, XMLELEMENT( "action", NULL, MAX_ACTION), NULL), NVL2(MAX_SERVICE_NAME, XMLELEMENT( "service", NULL, MAX_SERVICE_NAME), NULL), NVL2(MAX_CLIENT_ID, XMLELEMENT( "client_id", NULL, MAX_CLIENT_ID), NULL), NVL2(MAX_CLIENT_INFO, XMLELEMENT( "client_info", NULL, MAX_CLIEN
T_INFO), NULL), NVL2(MAX_PL_ENTRY_OID, XMLELEMENT( "plsql_entry_object_id", NULL, MAX_PL_ENTRY_OID), NULL), NVL2(MAX_PL_ENTRY_PROGID, XMLELEMENT( "plsql_entry_subprogram_id", NULL, MAX_PL_ENTRY_PROGID), NULL), NVL2(MAX_PL_ENTRY_NAME, XMLELEMENT( "plsql_entry_name", NULL, MAX_PL_ENTRY_NAME), NULL), NVL2(MAX_PL_OID, XMLELEMENT( "plsql_object_id", NULL, MAX_PL_OID), NULL), NVL2(MAX_PL_PROGID, XMLELEMENT( "plsql_subprogram_id", NULL, MAX_PL_PROGID), NULL), NVL2(MAX_PL_NAME, XMLELEMENT( "plsql_name", NULL, MAX_PL_NAME), NULL), CASE WHEN (:B13 = 0 OR :B6 IS NOT NULL) THEN NULL ELSE XMLELEMENT( "sql_fulltext", XMLATTRIBUTES(NVL2(SQL_VTEXT, 'Y', IS_FULL_TEXT) AS "is_full"), NVL2(SQL_VTEXT, SQL_VTEXT, SQLMON_TEXT)) END, XMLELEMENT( "status", NULL, MAX_STATUS), XMLELEMENT( "refresh_count", NULL, SUM_REFRESH_COUNT), XMLELEMENT( "first_refresh_time
", NULL, TO_CHAR(MIN_FIRST_REFRESH_TIME, :B12 )), XMLELEMENT( "last_refresh_time", NULL, TO_CHAR(:B58 , :B12 )), XMLELEMENT( "duration", NULL, GREATEST(:B65 , LEAST(MAX_ELAPSED_TIME/1000000, 1), CEIL(MAX_QUEUING_TIME/1000000))), DECODE(MAX_RM_INFO, '00/00/0000 00:00:00', NULL, XMLTYPE(SUBSTR(MAX_RM_INFO, 20))), CASE WHEN (:B63 = 'Y') THEN XMLELEMENT( "adaptive_plan", XMLATTRIBUTES(:B64 AS "is_final"), :B63 ) ELSE NULL END, NVL((SELECT XMLFOREST( XMLAGG( XMLELEMENT( "param", XMLATTRIBUTES(E.NAME AS "name"), DECODE(:B14 , 1, 'XXXX', E.VALUE)) ORDER BY E.NAME) AS "optimizer_env") SQL_ENV FROM GV$SQL_OPTIMIZER_ENV E WHERE E.INST_ID = :B17 AND E.SQL_ID = :B9 AND E.CHILD_ADDRESS = HEXTORAW(:B66 ) AND (DECODE(:B14 , 1, 'YES', E.ISDEFAULT) = 'NO' OR E.ID IN (2, 12, 24, 35, 36, 37, 246, 256, 257, 274, 275, 289, 290))), (SELECT XMLELEMENT( "optimizer_env", XMLATTRIBUTE
S('sys' AS "type"), XMLAGG( XMLELEMENT( "param", XMLATTRIBUTES(E.NAME AS "name"), DECODE(:B14 , 1, 'XXXX', E.VALUE)) ORDER BY E.NAME)) SYS_ENV FROM V$SYS_OPTIMIZER_ENV E WHERE (DECODE(:B14 , 1, 'YES', E.ISDEFAULT) = 'NO' OR E.ID IN (2, 12, 24, 35, 36, 37, 246, 256, 257, 274, 275, 289, 290)))) ) END, XMLELEMENT( "stats", XMLATTRIBUTES('monitor' AS "type"), DECODE(NVL(SUM_ELAPSED_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('elapsed_time' AS "name"), SUM_ELAPSED_TIME)), DECODE(NVL(MAX_QUEUING_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('queuing_time' AS "name"), MAX_QUEUING_TIME)), DECODE(NVL(SUM_CPU_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cpu_time' AS "name"), SUM_CPU_TIME)), DECODE(NVL(SUM_USER_IO_WAIT_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_io_wait_time' AS "name
"), SUM_USER_IO_WAIT_TIME)), DECODE(NVL(SUM_APPLICATION_WAIT_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('application_wait_time' AS "name"), SUM_APPLICATION_WAIT_TIME)), DECODE(NVL(SUM_CONCURRENCY_WAIT_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('concurrency_wait_time' AS "name"), SUM_CONCURRENCY_WAIT_TIME)), DECODE(NVL(SUM_CLUSTER_WAIT_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cluster_wait_time' AS "name"), SUM_CLUSTER_WAIT_TIME)), DECODE(NVL(SUM_PLSQL_EXEC_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('plsql_exec_time' AS "name"), SUM_PLSQL_EXEC_TIME)), DECODE(NVL(SUM_JAVA_EXEC_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('java_exec_time' AS "name"), SUM_JAVA_EXEC_TIME)), DECODE(NVL(SUM_OTHER_WAIT_TIME, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('other_wait_time' AS "name
"), SUM_OTHER_WAIT_TIME)), DECODE(NVL(SUM_FETCHES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_fetch_count' AS "name"), SUM_FETCHES)), DECODE(NVL(SUM_BUFFER_GETS, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('buffer_gets' AS "name"), SUM_BUFFER_GETS)), DECODE(NVL(SUM_READ_REQS, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('disk_reads' AS "name"), SUM_READ_REQS)), DECODE(NVL(SUM_WRITE_REQS, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('direct_writes' AS "name"), SUM_WRITE_REQS)), DECODE(NVL(SUM_READ_REQS, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), SUM_READ_REQS)), DECODE(NVL(SUM_READ_BYTES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), SUM_READ_BYTES)), DECODE(NVL(SUM_WRITE_REQS, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_reqs'
AS "name"), SUM_WRITE_REQS)), DECODE(NVL(SUM_WRITE_BYTES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), SUM_WRITE_BYTES)), DECODE(NVL(SUM_IO_UNC_BYTES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('unc_bytes' AS "name"), SUM_IO_UNC_BYTES)), DECODE(NVL(SUM_IO_ELIG_BYTES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('elig_bytes' AS "name"), SUM_IO_ELIG_BYTES)), DECODE(NVL(SUM_IO_RET_BYTES, 0), 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('ret_bytes' AS "name"), SUM_IO_RET_BYTES)), CASE WHEN SUM_IO_INTER_BYTES IS NULL OR SUM_IO_BYTES = 0 OR SUM_IO_INTER_BYTES = SUM_IO_BYTES OR NVL(SUM_IO_ELIG_BYTES, 0) = 0 THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(SUM_IO_BYTES / DECODE(SUM_IO_INTER_BYTES, 0, 1, SUM_IO_INTER_BYTES), 2)) END, CASE WHEN NVL(SUM_IO_ELIG_BYTES, 0) = 0
OR SUM_IO_UNC_BYTES = SUM_IO_RET_BYTES THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency2' AS "name"), GREATEST(0, ROUND(100* (SUM_IO_UNC_BYTES - SUM_IO_RET_BYTES) / SUM_IO_ELIG_BYTES, 2))) END), CASE WHEN :B33 = 1 THEN (SELECT CASE WHEN SUM(ACTIVITY_COUNT) > 0 THEN XMLELEMENT( "activity_sampled", XMLAGG( XMLELEMENT( "activity", XMLATTRIBUTES( AD1.ACTIVITY_TYPE AS "class", AD1.EVENT_NAME AS "event"), AD1.ACTIVITY_COUNT) ORDER BY AD1.ACTIVITY_TYPE, AD1.EVENT_NAME)) ELSE NULL END FROM (SELECT AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT FROM ASH_DATA AD0 GROUP BY AD0.ACTIVITY_TYPE, AD0.EVENT_NAME) AD1) ELSE NULL END, NVL2(MAX_ERROR_NUMBER, XMLELEMENT( "error", XMLATTRIBUTES(MAX_ERROR_NUMBER AS "number", MAX_ERROR_FACILITY AS "facility"), MAX_ERROR_MESSAGE), NULL), CASE WHEN :B62 = 1 AND MAGG.QC_HAS_BINDS_XML = 'Y' THEN (SEL
ECT XMLTYPE(BINDS_XML) FROM GV$SQL_MONITOR MON WHERE MON.INST_ID = :B17 AND MON.KEY = MAGG.MAX_KEY AND MON.SID = MAGG.MAX_SESSION_ID AND MON.SQL_ID = :B9 AND MON.SQL_EXEC_START = :B8 AND MON.SQL_EXEC_ID = :B7 AND ROWNUM = 1) ELSE NULL END, CASE WHEN :B61 = 1 AND MAGG.QC_HAS_OTHER_XML = 'Y' THEN (SELECT XMLTYPE(OTHER_XML) FROM GV$SQL_MONITOR MON WHERE MON.INST_ID = MAGG.MAX_INST_ID AND MON.KEY = MAGG.MAX_KEY AND MON.SID = MAGG.MAX_SESSION_ID AND MON.SQL_ID = :B9 AND MON.SQL_EXEC_START = :B8 AND MON.SQL_EXEC_ID = :B7 AND ROWNUM = 1) ELSE NULL END) FROM (SELECT V.*, CASE WHEN :B13 = 2 AND IS_FULL_TEXT = 'N' AND :B46 IS NULL AND :B60 IS NULL THEN (SELECT SQL_FULLTEXT FROM GV$SQL SQ WHERE SQ.INST_ID BETWEEN :B11 AND :B10 AND SQ.SQL_ID = :B9 AND ROWNUM = 1) ELSE NULL END SQL_VTEXT FROM MONITOR_AGG V) MAGG), CASE WHEN :B44 = 1 THEN (SELECT CASE WHEN AT.ACTIVITY_COUNT > 0 THEN XMLELEMENT( "activity_sampled", XMLATTRIBUTES( :B41 AS "ash_missing_seconds", TO_CHAR(AT.A
CTIVITY_START, :B12 ) AS "first_sample_time", TO_CHAR(AT.ACTIVITY_END, :B12 ) AS "last_sample_time", ROUND((AT.ACTIVITY_END - AT.ACTIVITY_START) * 3600 * 24) + 1 AS "duration", AT.ACTIVITY_COUNT AS "count", AT.IMQ_COUNT AS "imq_count", AT.WAIT_COUNT AS "wait_count", AT.CPU_COUNT AS "cpu_count", DECODE(AT.OTHER_SQL_COUNT, 0, NULL, AT.OTHER_SQL_COUNT) AS "other_sql_count", :B40 AS "cpu_cores", :B39 AS "hyperthread"), AT.ACTIVITY_TOTAL, AH.GLOB_ACTIVITY_HISTO) WHEN :B41 IS NOT NULL THEN XMLELEMENT( "activity_sampled", XMLATTRIBUTES( DECODE( :B41 , -1, 'all', TO_CHAR( :B41 )) AS "ash_missing_seconds")) ELSE NULL END FROM (SELECT MIN(AD1.ACTIVITY_START) ACTIVITY_START, MAX(AD1.ACTIVITY_END) ACTIVITY_END, SUM(AD1.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD1.IMQ_COUNT) IMQ_COUNT, SUM(AD1.WAIT_COUNT) WAIT_COUNT, SUM(AD1.CPU_COUNT) CPU_COUNT, SUM(AD1.OTHER
_SQL_COUNT) OTHER_SQL_COUNT, SUBSTR(MAX(LPAD(AD1.ACTIVITY_COUNT, 10)|| AD1.ACTIVITY_TYPE), 11) MOST_ACTIVE, XMLAGG( XMLELEMENT( "activity", XMLATTRIBUTES( AD1.ACTIVITY_TYPE AS "class", AD1.EVENT_NAME AS "event"), AD1.ACTIVITY_COUNT) ORDER BY AD1.ACTIVITY_TYPE, AD1.EVENT_NAME) ACTIVITY_TOTAL FROM (SELECT AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, MIN(AD0.ACTIVITY_START) ACTIVITY_START, MAX(AD0.ACTIVITY_END) ACTIVITY_END, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD0.IMQ_COUNT) IMQ_COUNT, SUM(AD0.WAIT_COUNT) WAIT_COUNT, SUM(AD0.CPU_COUNT) CPU_COUNT, SUM(AD0.OTHER_SQL_COUNT) OTHER_SQL_COUNT FROM ASH_DATA AD0 GROUP BY AD0.ACTIVITY_TYPE, AD0.EVENT_NAME) AD1) AT, (SELECT CASE WHEN :B30 = 1 AND :B27 > 1 THEN XMLELEMENT( "activity_histogram", XMLATTRIBUTES( :B26 AS "bucket_interval", :B27 AS "bucket_count", TO_CHAR( :B20 , :B12 ) AS "start_time", TO_CHAR( :B22 , :B12 ) AS "end_time", ROUND(( :B
22 - :B20 ) *3600*24) + 1 AS "duration"), XMLAGG( XMLELEMENT( "bucket", XMLATTRIBUTES( AD2.BUCKET_NUM AS "number"), ACTIVITY_BUCKET) ORDER BY AD2.BUCKET_NUM)) ELSE NULL END GLOB_ACTIVITY_HISTO FROM (SELECT AD1.BUCKET_NUM, SUM(ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(IMQ_COUNT) IMQ_COUNT, SUM(WAIT_COUNT) WAIT_COUNT, SUM(CPU_COUNT) CPU_COUNT, SUM(OTHER_SQL_COUNT) OTHER_SQL_COUNT, MIN(AD1.ACTIVITY_START) ACTIVITY_START, MAX(AD1.ACTIVITY_END) ACTIVITY_END, MIN(AD1.BUCKET_ACTIVITY_START) BUCKET_ACTIVITY_START, MAX(AD1.BUCKET_ACTIVITY_END) BUCKET_ACTIVITY_END, SUBSTR(MAX(LPAD(AD1.ACTIVITY_COUNT, 10)|| AD1.ACTIVITY_TYPE), 11) MOST_ACTIVE, XMLAGG( XMLELEMENT( "activity", XMLATTRIBUTES( AD1.ACTIVITY_TYPE AS "class", AD1.EVENT_NAME AS "event"), AD1.ACTIVITY_COUNT) ORDER BY AD1.ACTIVITY_TYPE, AD1.EVENT_NAME) ACTIVITY_BUCKET FROM (SELECT AD0.ACTIVITY_BUCKET_NUM BUCKET_NUM, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, MIN(AD0.ACTIVI
TY_START) ACTIVITY_START, MAX(AD0.ACTIVITY_END) ACTIVITY_END, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD0.IMQ_COUNT) IMQ_COUNT, SUM(AD0.WAIT_COUNT) WAIT_COUNT, SUM(AD0.CPU_COUNT) CPU_COUNT, SUM(AD0.OTHER_SQL_COUNT) OTHER_SQL_COUNT, MIN(AD0.BUCKET_ACTIVITY_START) BUCKET_ACTIVITY_START, MAX(AD0.BUCKET_ACTIVITY_END) BUCKET_ACTIVITY_END FROM ASH_DATA AD0 GROUP BY AD0.ACTIVITY_BUCKET_NUM, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME) AD1 GROUP BY AD1.BUCKET_NUM) AD2) AH) ELSE NULL END, CASE WHEN :B33 = 1 THEN (SELECT CASE WHEN AH.ACTIVITY_COUNT > 0 THEN XMLELEMENT( "activity_detail", XMLATTRIBUTES( TO_CHAR( :B20 , :B12 ) AS "start_time", TO_CHAR( :B22 , :B12 ) AS "end_time", :B41 AS "ash_missing_seconds", TO_CHAR(AH.ACTIVITY_START, :B12 ) AS "first_sample_time", TO_CHAR(AH.ACTIVITY_END, :B12 ) AS "last_sample_time", ROUND((AH.ACTIVITY_END - AH.ACTIVITY_START) * 3600 * 24) + 1 AS "duration", :B25 AS
"sample_interval", :B26 AS "bucket_interval", :B27 AS "bucket_count", ROUND((:B22 - :B20 ) *3600*24) + 1 AS "bucket_duration", :B40 AS "cpu_cores", :B34 AS "total_cpu_cores", :B39 AS "hyperthread"), AH.GLOB_ACTIVITY_HISTO) WHEN :B41 IS NOT NULL THEN XMLELEMENT( "activity_detail", XMLATTRIBUTES( DECODE( :B41 , -1, 'all', TO_CHAR( :B41 )) AS "ash_missing_seconds")) ELSE NULL END FROM (SELECT MIN(AD2.ACTIVITY_START) ACTIVITY_START, MAX(AD2.ACTIVITY_END) ACTIVITY_END, SUM(AD2.ACTIVITY_COUNT) ACTIVITY_COUNT, XMLAGG( XMLELEMENT( "bucket", XMLATTRIBUTES( AD2.BUCKET_NUM AS "number"), ACTIVITY_BUCKET_XML) ORDER BY AD2.BUCKET_NUM) GLOB_ACTIVITY_HISTO FROM (SELECT AD1.BUCKET_NUM, MIN(AD1.ACTIVITY_START) ACTIVITY_START, MAX(AD1.ACTIVITY_END) ACTIVITY_END, SUM(AD1.ACTIVITY_COUNT) ACTIVITY_COUNT, MAX(AD1.BUCKET_IDLE_SECONDS) BUCKET_IDLE_SECONDS, XMLAGG( XMLCONCAT( CASE W
HEN AD1.DFO_PAIR_IDLE_RESP_TIME != 0 AND DFO_PAIR_ROWNUM = 1 THEN XMLELEMENT( "activity", XMLATTRIBUTES( 'Parallel Skew' AS "class", AD1.PX_STEP_ARG AS "line", AD1.PX_ID AS "px", ROUND(AD1.DFO_PAIR_IDLE_RESP_TIME, 2) AS "rt"), 0) ELSE NULL END, XMLELEMENT( "activity", XMLATTRIBUTES( NVL(AD1.OTHER_SQL, AD1.RPI) AS "sql", AD1.NON_SQL AS "non_sql", AD1.CLASS AS "class", AD1.OTHER_SQL_CLASS AS "other_sql_class", AD1.EVENT AS "event", AD1.PLAN_LINE_ID AS "line", NVL2(AD1.PLSQL_OBJECT_ID, AD1.PLSQL_OBJECT_ID||'.'|| AD1.PLSQL_SUBPROGRAM_ID, NULL) AS "plsql_id", AD1.PLSQL_NAME AS "plsql_name", CASE WHEN AD1.SQL_ROWNUM = 1 THEN AD1.TOP_LEVEL_SQL_ID END AS "top_sql_id", CASE WHEN AD1.DBOP_NAME IS NOT NULL THEN AD1.DBOP_NAME END AS "dbop_name", CASE WHEN AD1.DFO_MOST_ACTIVE_IID IS NOT NULL AND :B67 = 'Y' THEN AD1.DFO_M
OST_ACTIVE_IID END AS "skew_iid", DECODE(AD1.DFO_MOST_ACTIVE_COUNT, NULL, NULL, AD1.DFO_MOST_ACTIVE_SID) AS "skew_sid", AD1.DFO_MOST_ACTIVE_COUNT AS "skew_count", DECODE(AD1.PX_DOP, :B28 , NULL, AD1.PX_DOP) AS "dop", DECODE(AD1.PX_DOP, AD1.PX_MIN_DOP, NULL, AD1.PX_MIN_DOP) AS "min_dop", AD1.PX_ID AS "px", AD1.PX_STEP_ID AS "step", AD1.PX_STEP_ARG AS "arg", DECODE(AD1.ACTIVITY_COUNT, AD1.RESP_TIME, NULL, ROUND(AD1.RESP_TIME, 2)) AS "rt"), AD1.ACTIVITY_COUNT)) ORDER BY AD1.PX_STEP_ID, AD1.PX_STEP_ARG, AD1.DFO_PAIR_ROWNUM) ACTIVITY_BUCKET_XML FROM (SELECT AD01.*, CASE WHEN AD01.ACTIVITY_TYPE != 'Other SQL Execution' AND AD01.ACTIVITY_TYPE != 'Non SQL' THEN AD01.ACTIVITY_TYPE END CLASS, CASE WHEN (AD01.ACTIVITY_TYPE = 'Other SQL Execution' OR AD01.ACTIVITY_TYPE = 'Non SQL') THEN AD01.OTHER_SQL_ACTIVITY_TYPE END OTHER_SQL_CLASS, CASE WHEN AD01.ACTIVITY_TYPE != 'Other SQL Execu
tion' AND AD01.ACTIVITY_TYPE != 'Non SQL' THEN AD01.EVENT_NAME END EVENT, CASE WHEN AD01.SQL IN ('this', 'anonymous') THEN NULL ELSE AD01.SQL END RPI, DECODE(AD01.ACTIVITY_TYPE, 'Other SQL Execution', SUBSTR(AD01.EVENT_NAME, 9), NULL) OTHER_SQL, DECODE(AD01.ACTIVITY_TYPE, 'Non SQL', AD01.EVENT_NAME, NULL) NON_SQL, ROW_NUMBER() OVER(PARTITION BY AD01.BUCKET_NUM, AD01.PX_DFO_PAIR_ID ORDER BY AD01.ACTIVITY_TYPE, AD01.EVENT_NAME, AD01.PLAN_LINE_ID) DFO_PAIR_ROWNUM FROM RESPONSE_TIME_DATA AD01) AD1 GROUP BY AD1.BUCKET_NUM) AD2) AH) ELSE NULL END, CASE WHEN :B23 = 'Y' THEN (SELECT XMLELEMENT( "parallel_info", XMLATTRIBUTES( :B17 AS "qc_instance_id", MAX_PX_QCSID AS "qc_session_id", MAX_PX_IS_CROSS_INSTANCE AS "is_cross_instance", MAX_PX_DOP AS "dop", MAX_PX_DOP_INSTANCES AS "max_dop_instances", DIST_INST_COUNT AS "inst_count", DIST_PX_GROUP_COUNT AS "server_group_count", DIST_PX_SET_COUNT
AS "server_set_count"), CASE WHEN :B69 = 1 THEN PX_SESSIONS ELSE NULL END, CASE WHEN :B67 = 'Y' THEN DECODE(:B68 , 1, PX_INSTANCES, NULL) ELSE NULL END) FROM (SELECT MAX_PX_QCSID, MAX_PX_DOP, MAX_PX_DOP_INSTANCES, MAX_PX_IS_CROSS_INSTANCE, SUM_SERVERS_REQUESTED, SUM_SERVERS_ALLOCATED, DIST_INST_COUNT, DIST_PX_GROUP_COUNT, DIST_PX_SET_COUNT, (SELECT XMLELEMENT( "sessions", XMLATTRIBUTES(MAX(PX_SESSION.ACTIVITY_COUNT) AS "max_activity_count", MAX(PX_SESSION.IMQ_COUNT) AS "max_imq_count", MAX(PX_SESSION.CPU_COUNT) AS "max_cpu_count", MAX(PX_SESSION.WAIT_COUNT) AS "max_wait_count", MAX(PX_SESSION.OTHER_SQL_COUNT) AS "max_other_sql_count", MAX(PX_SESSION.MAX_IO_REQS) AS "max_io_reqs", MAX(PX_SESSION.MAX_IO_BYTES) AS "max_io_bytes", MAX(PX_SESSION.MAX_BUFFER_GETS) AS "max_buffer_gets", MAX(PX_SESSION.MAX_ELAPSED_TIME) AS "max_elapsed_time"), XMLAGG(PX_SESSION.
PX_SESSION_XML ORDER BY PX_SERVER_GROUP NULLS FIRST, PX_SERVER_SET, PX_SERVER#)) FROM (SELECT PX_SERVER_GROUP, PX_SERVER_SET, PX_SERVER#, MAX(PI.MAX_ELAPSED_TIME) MAX_ELAPSED_TIME, MAX(PI.MAX_IO_REQS) MAX_IO_REQS, MAX(PI.MAX_IO_BYTES) MAX_IO_BYTES, MAX(PI.MAX_BUFFER_GETS) MAX_BUFFER_GETS, SUM(PI.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(PI.IMQ_COUNT) IMQ_COUNT, SUM(PI.WAIT_COUNT) WAIT_COUNT, SUM(PI.CPU_COUNT) CPU_COUNT, SUM(PI.OTHER_SQL_COUNT) OTHER_SQL_COUNT, XMLELEMENT( "session", XMLATTRIBUTES( INST_ID AS "inst_id", PROCESS_NAME AS "process_name", SID AS "session_id", SESSION_SERIAL# AS "session_serial", PX_SERVER_GROUP AS "server_group", PX_SERVER_SET AS "server_set", PX_SERVER# AS "server_num"), XMLELEMENT( "stats", XMLATTRIBUTES( 'monitor' AS "type"), NVL2(MAX(ELAPSED_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('elapsed_time' AS "name"), MAX(EL
APSED_TIME)), NULL), NVL2(MAX(QUEUING_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('queuing_time' AS "name"), MAX(QUEUING_TIME)), NULL), NVL2(MAX(CPU_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('cpu_time' AS "name"), MAX(CPU_TIME)), NULL), NVL2(MAX(USER_IO_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('user_io_wait_time' AS "name"), MAX(USER_IO_WAIT_TIME)), NULL), NVL2(MAX(APPLICATION_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('application_wait_time' AS "name"), MAX(APPLICATION_WAIT_TIME)), NULL), NVL2(MAX(CONCURRENCY_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('concurrency_wait_time' AS "name"), MAX(CONCURRENCY_WAIT_TIME)), NULL), NVL2(MAX(CLUSTER_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('cluster_wait_time' AS "name"), MAX(CLUSTER_WAIT_TIME)), NULL), NVL2(MAX(PLSQL_EXEC_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('plsql_exe
c_time' AS "name"), MAX(PLSQL_EXEC_TIME)), NULL), NVL2(MAX(JAVA_EXEC_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('java_exec_time' AS "name"), MAX(JAVA_EXEC_TIME)), NULL), NVL2(MAX(OTHER_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES( 'other_wait_time' AS "name"), MAX(OTHER_WAIT_TIME)), NULL), NVL2(MAX(FETCHES), XMLELEMENT( "stat", XMLATTRIBUTES('user_fetch_count' AS "name"), MAX(FETCHES)), NULL), NVL2(MAX(BUFFER_GETS), XMLELEMENT( "stat", XMLATTRIBUTES('buffer_gets' AS "name"), MAX(BUFFER_GETS)), NULL), NVL2(MAX(READ_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('disk_reads' AS "name"), MAX(READ_REQS)), NULL), NVL2(MAX(WRITE_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('direct_writes' AS "name"), MAX(WRITE_REQS)), NULL), NVL2(MAX(READ_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), MAX(READ_REQS)),
NULL), NVL2(MAX(READ_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), MAX(READ_BYTES)), NULL), NVL2(MAX(WRITE_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('write_reqs' AS "name"), MAX(WRITE_REQS)), NULL), NVL2(MAX(WRITE_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), MAX(WRITE_BYTES)), NULL), NVL2(MAX(IO_UNC_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('unc_bytes' AS "name"), MAX(IO_UNC_BYTES)), NULL), NVL2(MAX(IO_ELIG_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('elig_bytes' AS "name"), MAX(IO_ELIG_BYTES)), NULL), NVL2(MAX(IO_RET_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('ret_bytes' AS "name"), MAX(IO_RET_BYTES)), NULL), CASE WHEN MAX(IO_INTER_BYTES) IS NULL OR NVL(MAX(IO_BYTES), 0) = 0 OR MAX(IO_INTER_BYTES) = MAX(IO_BYTES) OR NVL(MAX(IO_ELIG_BYTES), 0) = 0 THEN NULL ELSE XMLELEMENT( "stat", XM
LATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(MAX(IO_BYTES) / DECODE(MAX(IO_INTER_BYTES), 0, 1, MAX(IO_INTER_BYTES)), 2)) END, CASE WHEN NVL(MAX(IO_ELIG_BYTES), 0) = 0 OR MAX(IO_UNC_BYTES) = MAX(IO_RET_BYTES) THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency2' AS "name"), GREATEST(0, ROUND(100* (MAX(IO_UNC_BYTES) - MAX(IO_RET_BYTES)) / MAX(IO_ELIG_BYTES), 2))) END), CASE WHEN SUM(PI.ACTIVITY_COUNT) > 0 AND :B33 = 1 THEN XMLELEMENT( "activity_sampled", XMLATTRIBUTES( TO_CHAR(MIN(PI.ACTIVITY_START), :B12 ) AS "first_sample_time", TO_CHAR(MAX(PI.ACTIVITY_END), :B12 ) AS "last_sample_time", ROUND((MAX(PI.ACTIVITY_END) - MIN(PI.ACTIVITY_START)) * 3600 * 24) + 1 AS "duration", SUM(PI.ACTIVITY_COUNT) AS "count", SUM(PI.IMQ_COUNT) AS "imq_count", SUM(PI.CPU_COUNT) AS "cpu_count", SUM(PI.WAIT_COUNT) AS "wait_count", SUM(PI.OTHER
_SQL_COUNT)AS "other_sql_count", :B40 AS "cpu_cores", :B39 AS "hyperthread"), XMLAGG( NVL2(ACTIVITY_TYPE, XMLELEMENT( "activity", XMLATTRIBUTES( PI.ACTIVITY_TYPE AS "class", PI.EVENT_NAME AS "event"), ACTIVITY_COUNT), NULL) ORDER BY PI.ACTIVITY_TYPE, PI.EVENT_NAME)) ELSE NULL END, CASE WHEN :B61 = 1 AND PI.HAS_OTHER_XML = 'Y' THEN (SELECT XMLTYPE(OTHER_XML) FROM GV$SQL_MONITOR MON WHERE MON.INST_ID = PI.INST_ID AND MON.KEY = PI.KEY AND MON.SID = PI.SID AND MON.SQL_ID = :B9 AND MON.SQL_EXEC_START = :B8 AND MON.SQL_EXEC_ID = :B7 AND ROWNUM = 1) ELSE NULL END) PX_SESSION_XML FROM (SELECT MO.HAS_OTHER_XML, MO.KEY, MO.INST_ID, DECODE(MO.PROCESS_NAME, 'ora', 'PX Coordinator', MO.PROCESS_NAME) PROCESS_NAME, MO.SID, MO.SESSION_SERIAL#, MO.PX_SERVER_GROUP, MO.PX_SERVER_SET, MO.PX_SERVER#, ASH0.ACTIVITY_TYPE, ASH0.EVENT_NAME, MAX(MO.IO_REQS) MAX_IO_REQS, MAX(MO.IO_BYTES) MAX_IO_BYTES, MAX(MO.BUFFER_GETS) MAX_BU
FFER_GETS, MAX(MO.ELAPSED_TIME) MAX_ELAPSED_TIME, SUM(DECODE(ASH0.ACTIVITY_TYPE, NULL, NULL, ASH0.ACTIVITY_COUNT)) ACTIVITY_COUNT, SUM(DECODE(ASH0.ACTIVITY_TYPE, NULL, NULL, ASH0.IMQ_COUNT)) IMQ_COUNT, SUM(DECODE(ASH0.ACTIVITY_TYPE, NULL, NULL, ASH0.WAIT_COUNT)) WAIT_COUNT, SUM(DECODE(ASH0.ACTIVITY_TYPE, NULL, NULL, ASH0.CPU_COUNT)) CPU_COUNT, SUM(DECODE(ASH0.ACTIVITY_TYPE, NULL, NULL, ASH0.OTHER_SQL_COUNT)) OTHER_SQL_COUNT, MIN(ASH0.ACTIVITY_START) ACTIVITY_START, MAX(ASH0.ACTIVITY_END) ACTIVITY_END, MAX(DECODE(MO.ELAPSED_TIME, 0, NULL, MO.ELAPSED_TIME)) ELAPSED_TIME, MAX(DECODE(MO.QUEUING_TIME, 0, NULL, MO.QUEUING_TIME)) QUEUING_TIME, MAX(DECODE(MO.CPU_TIME, 0, NULL, CPU_TIME)) CPU_TIME, MAX(DECODE(MO.FETCHES, 0, NULL, FETCHES)) FETCHES, MAX(DECODE(MO.BUFFER_GETS, 0, NULL, MO.BUFFER_GETS)) BUFFER_GETS, MAX(DECODE(MO.IO_INTER_BYTES, 0, NULL, MO.IO_INTER_BYTES)) IO_INTER_BYTES, MAX(DECODE(MO.READ_REQS, 0, NULL, MO.READ_REQS)) READ_REQS
, MAX(DECODE(MO.READ_BYTES, 0, NULL, MO.READ_BYTES)) READ_BYTES, MAX(DECODE(MO.WRITE_REQS, 0, NULL, MO.WRITE_REQS)) WRITE_REQS, MAX(DECODE(MO.WRITE_BYTES, 0, NULL, MO.WRITE_BYTES)) WRITE_BYTES, MAX(DECODE(MO.IO_BYTES, 0, NULL, MO.IO_BYTES)) IO_BYTES, MAX(DECODE(MO.IO_UNC_BYTES, 0, NULL, MO.IO_UNC_BYTES)) IO_UNC_BYTES, MAX(DECODE(MO.IO_ELIG_BYTES, 0, NULL, MO.IO_ELIG_BYTES)) IO_ELIG_BYTES, MAX(DECODE(MO.IO_RET_BYTES, 0, NULL, MO.IO_RET_BYTES)) IO_RET_BYTES, MAX(DECODE(MO.APPLICATION_WAIT_TIME, 0, NULL, MO.APPLICATION_WAIT_TIME)) APPLICATION_WAIT_TIME, MAX(DECODE(MO.CONCURRENCY_WAIT_TIME, 0, NULL, MO.CONCURRENCY_WAIT_TIME)) CONCURRENCY_WAIT_TIME, MAX(DECODE(MO.CLUSTER_WAIT_TIME, 0, NULL, MO.CLUSTER_WAIT_TIME)) CLUSTER_WAIT_TIME, MAX(DECODE(MO.USER_IO_WAIT_TIME, 0, NULL, MO.USER_IO_WAIT_TIME)) USER_IO_WAIT_TIME, MAX(DECODE(PLSQL_EXEC_TIME, 0, NULL, PLSQL_EXEC_TIME)) PLSQL_EXEC_TIME, MAX(DECODE(MO.JAVA_EXEC_TIME, 0, NULL, MO.JAVA_EXEC_TIM
E)) JAVA_EXEC_TIME, MAX(DECODE(MO.OTHER_WAIT_TIME, 0, NULL, MO.OTHER_WAIT_TIME)) OTHER_WAIT_TIME FROM MONITOR_DATA MO, (SELECT ASH1.INST_ID, ASH1.SESSION_ID, ASH1.ACTIVITY_TYPE, ASH1.EVENT_NAME, SUM(ASH1.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(ASH1.IMQ_COUNT) IMQ_COUNT, SUM(ASH1.WAIT_COUNT) WAIT_COUNT, SUM(ASH1.CPU_COUNT) CPU_COUNT, SUM(ASH1.OTHER_SQL_COUNT)OTHER_SQL_COUNT, MIN(ASH1.ACTIVITY_START) ACTIVITY_START, MAX(ASH1.ACTIVITY_END) ACTIVITY_END FROM ASH_DATA ASH1 GROUP BY ASH1.INST_ID, ASH1.SESSION_ID, ASH1.ACTIVITY_TYPE, ASH1.EVENT_NAME) ASH0 WHERE MO.INST_ID = ASH0.INST_ID(+) AND MO.SID = ASH0.SESSION_ID(+) AND (:B69 = 1 OR :B68 = 1) GROUP BY MO.INST_ID, MO.KEY, MO.HAS_OTHER_XML, MO.PROCESS_NAME, MO.SID, MO.SESSION_SERIAL#, MO.PX_SERVER_GROUP, MO.PX_SERVER_SET, MO.PX_SERVER#, ASH0.ACTIVITY_TYPE, ASH0.EVENT_NAME) PI WHERE (:B69 = 1) GROUP BY PI.INST_ID, PI.KEY, PI.HAS_OTHER_XML, PI.SID, PI.PROCESS_NAME, PI.SESSION_SERIAL#, PI.PX_SERVER_GROUP, PI.PX_
SERVER_SET, PI.PX_SERVER#) PX_SESSION) PX_SESSIONS, (SELECT XMLELEMENT( "instances", XMLATTRIBUTES( MAX(PX_INSTANCE.ACTIVITY_COUNT) AS "max_activity_count", MAX(PX_INSTANCE.IMQ_COUNT) AS "max_imq_count", MAX(PX_INSTANCE.CPU_COUNT) AS "max_cpu_count", MAX(PX_INSTANCE.WAIT_COUNT) AS "max_wait_count", MAX(PX_INSTANCE.OTHER_SQL_COUNT) AS "max_other_sql_count", MAX(PX_INSTANCE.ELAPSED_TIME) AS "max_elapsed_time", MAX(PX_INSTANCE.BUFFER_GETS) AS "max_buffer_gets", MAX(PX_INSTANCE.IO_REQS) AS "max_io_reqs", MAX(PX_INSTANCE.IO_BYTES) AS "max_io_bytes"), XMLAGG(PX_INSTANCE.PX_INSTANCES_XML ORDER BY INST_ID)) FROM (SELECT PI.INST_ID, MAX(PI.ELAPSED_TIME) ELAPSED_TIME, MAX(PI.IO_REQS) IO_REQS, MAX(PI.IO_BYTES) IO_BYTES, MAX(PI.BUFFER_GETS) BUFFER_GETS, SUM(PI.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(PI.IMQ_COUNT) IMQ_COUNT, SUM(PI.WAIT_COUNT) WAIT_COUNT, SUM(PI.CPU_COUNT) CPU_COUNT,
SUM(PI.OTHER_SQL_COUNT) OTHER_SQL_COUNT, XMLELEMENT( "instance", XMLATTRIBUTES( INST_ID AS "inst_id"), XMLELEMENT( "stats", XMLATTRIBUTES( 'monitor' AS "type"), NVL2(MAX(ELAPSED_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('elapsed_time' AS "name"), MAX(ELAPSED_TIME)), NULL), NVL2(MAX(QUEUING_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('queuing_time' AS "name"), MAX(QUEUING_TIME)), NULL), NVL2(MAX(CPU_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('cpu_time' AS "name"), MAX(CPU_TIME)), NULL), NVL2(MAX(USER_IO_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('user_io_wait_time' AS "name"), MAX(USER_IO_WAIT_TIME)), NULL), NVL2(MAX(APPLICATION_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('application_wait_time' AS "name"), MAX(APPLICATION_WAIT_TIME)), NULL), NVL2(MAX(CONCURRENCY_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES
('concurrency_wait_time' AS "name"), MAX(CONCURRENCY_WAIT_TIME)), NULL), NVL2(MAX(CLUSTER_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('cluster_wait_time' AS "name"), MAX(CLUSTER_WAIT_TIME)), NULL), NVL2(MAX(PLSQL_EXEC_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('plsql_exec_time' AS "name"), MAX(PLSQL_EXEC_TIME)), NULL), NVL2(MAX(JAVA_EXEC_TIME), XMLELEMENT( "stat", XMLATTRIBUTES('java_exec_time' AS "name"), MAX(JAVA_EXEC_TIME)), NULL), NVL2(MAX(OTHER_WAIT_TIME), XMLELEMENT( "stat", XMLATTRIBUTES( 'other_wait_time' AS "name"), MAX(OTHER_WAIT_TIME)), NULL), NVL2(MAX(FETCHES), XMLELEMENT( "stat", XMLATTRIBUTES('user_fetch_count' AS "name"), MAX(FETCHES)), NULL), NVL2(MAX(BUFFER_GETS), XMLELEMENT( "stat", XMLATTRIBUTES('buffer_gets' AS "name"), MAX(BUFFER_GETS)), NULL), NVL2(MAX(READ_REQS), XMLELEMENT( "stat", XMLATTRI
BUTES('disk_reads' AS "name"), MAX(READ_REQS)), NULL), NVL2(MAX(WRITE_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('direct_writes' AS "name"), MAX(WRITE_REQS)), NULL), NVL2(MAX(READ_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), MAX(READ_REQS)), NULL), NVL2(MAX(READ_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), MAX(READ_BYTES)), NULL), NVL2(MAX(WRITE_REQS), XMLELEMENT( "stat", XMLATTRIBUTES('write_reqs' AS "name"), MAX(WRITE_REQS)), NULL), NVL2(MAX(WRITE_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), MAX(WRITE_BYTES)), NULL), NVL2(MAX(IO_UNC_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('unc_bytes' AS "name"), MAX(IO_UNC_BYTES)), NULL), NVL2(MAX(IO_ELIG_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('elig_bytes' AS "name"), MAX(IO_ELIG_BYTES)), NULL), NVL
2(MAX(IO_RET_BYTES), XMLELEMENT( "stat", XMLATTRIBUTES('ret_bytes' AS "name"), MAX(IO_RET_BYTES)), NULL), CASE WHEN MAX(IO_INTER_BYTES) IS NULL OR NVL(MAX(IO_BYTES), 0) = 0 OR MAX(IO_INTER_BYTES) = MAX(IO_BYTES) OR NVL(MAX(IO_ELIG_BYTES), 0) = 0 THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(MAX(IO_BYTES)/ DECODE(MAX(IO_INTER_BYTES), 0, 1, MAX(IO_INTER_BYTES)), 2)) END, CASE WHEN NVL(MAX(IO_ELIG_BYTES), 0) = 0 OR MAX(IO_UNC_BYTES) = MAX(IO_RET_BYTES) THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency2' AS "name"), GREATEST(0, ROUND(100* (MAX(IO_UNC_BYTES) - MAX(IO_RET_BYTES)) / MAX(IO_ELIG_BYTES), 2))) END), CASE WHEN :B33 = 1 AND SUM(PI.ACTIVITY_COUNT) > 0 THEN XMLELEMENT( "activity_sampled", XMLATTRIBUTES( TO_CHAR(MIN(PI.ACTIVITY_START), :B12 ) AS "start_time", TO_CHAR(MAX(PI.ACTIVITY_END), :B12 ) AS "end_
time", ROUND((MAX(PI.ACTIVITY_END) - MIN(PI.ACTIVITY_START)) * 3600 * 24) + 1 AS "duration", SUM(PI.ACTIVITY_COUNT) AS "count", SUM(PI.IMQ_COUNT) AS "imq_count", SUM(PI.WAIT_COUNT) AS "wait_count", SUM(PI.CPU_COUNT) AS "cpu_count", SUM(PI.OTHER_SQL_COUNT) AS "other_sql_count", :B40 AS "cpu_cores", :B39 AS "hyperthread"), XMLAGG( NVL2(ACTIVITY_TYPE, XMLELEMENT( "activity", XMLATTRIBUTES( PI.ACTIVITY_TYPE AS "class", PI.EVENT_NAME AS "event"), ACTIVITY_COUNT), NULL) ORDER BY PI.ACTIVITY_TYPE, PI.EVENT_NAME)) ELSE NULL END) PX_INSTANCES_XML FROM (SELECT MO.INST_ID, ASH.ACTIVITY_TYPE, ASH.EVENT_NAME, ASH.ACTIVITY_COUNT, ASH.IMQ_COUNT, ASH.WAIT_COUNT, ASH.CPU_COUNT, ASH.OTHER_SQL_COUNT, ASH.ACTIVITY_START, ASH.ACTIVITY_END, MO.ELAPSED_TIME, MO.QUEUING_TIME, MO.CPU_TIME, MO.APPLICATION_WAIT_TIME, MO.CONCURRENCY_WAIT_TIME, MO.CLUSTER_WAIT_TIME, MO.U
SER_IO_WAIT_TIME, MO.PLSQL_EXEC_TIME, MO.JAVA_EXEC_TIME, MO.OTHER_WAIT_TIME, MO.FETCHES, MO.BUFFER_GETS, MO.IO_INTER_BYTES, MO.IO_BYTES, MO.READ_REQS, MO.READ_BYTES, MO.WRITE_REQS, MO.WRITE_BYTES, MO.IO_REQS, MO.IO_UNC_BYTES, MO.IO_ELIG_BYTES, MO.IO_RET_BYTES FROM (SELECT MO0.INST_ID, SUM(MO0.ELAPSED_TIME) ELAPSED_TIME, SUM(MO0.QUEUING_TIME) QUEUING_TIME, SUM(MO0.CPU_TIME) CPU_TIME, SUM(MO0.FETCHES) FETCHES, SUM(MO0.BUFFER_GETS) BUFFER_GETS, SUM(MO0.IO_INTER_BYTES) IO_INTER_BYTES, SUM(MO0.IO_BYTES) IO_BYTES, SUM(MO0.READ_REQS) READ_REQS, SUM(MO0.READ_BYTES) READ_BYTES, SUM(MO0.WRITE_REQS) WRITE_REQS, SUM(MO0.WRITE_BYTES) WRITE_BYTES, SUM(MO0.IO_REQS) IO_REQS, SUM(MO0.IO_UNC_BYTES) IO_UNC_BYTES, SUM(MO0.IO_ELIG_BYTES) IO_ELIG_BYTES, SUM(MO0.IO_RET_BYTES) IO_RET_BYTES, SUM(MO0.APPLICATION_WAIT_TIME) APPLICATION_WAIT_TIME, SUM(MO0.CONCURRENCY_WAIT_TIME) CONCURRENCY_WAIT_TIME, SUM(MO0.CLUSTER_WAIT_TIME) CLUSTER_WAIT_TIME, SUM(MO0.USER_IO_WAIT_TIME) USER_IO
_WAIT_TIME, SUM(MO0.PLSQL_EXEC_TIME) PLSQL_EXEC_TIME, SUM(MO0.JAVA_EXEC_TIME) JAVA_EXEC_TIME, SUM(MO0.OTHER_WAIT_TIME) OTHER_WAIT_TIME FROM MONITOR_DATA MO0 GROUP BY MO0.INST_ID) MO, (SELECT ASH0.INST_ID, ASH0.ACTIVITY_TYPE, ASH0.EVENT_NAME, SUM(ASH0.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(ASH0.IMQ_COUNT) IMQ_COUNT, SUM(ASH0.WAIT_COUNT) WAIT_COUNT, SUM(ASH0.CPU_COUNT) CPU_COUNT, SUM(ASH0.OTHER_SQL_COUNT) OTHER_SQL_COUNT, MIN(ASH0.ACTIVITY_START) ACTIVITY_START, MAX(ASH0.ACTIVITY_END) ACTIVITY_END FROM ASH_DATA ASH0 GROUP BY ASH0.INST_ID, ASH0.ACTIVITY_TYPE, ASH0.EVENT_NAME) ASH, MONITOR_AGG WHERE MO.INST_ID = ASH.INST_ID(+) AND MONITOR_AGG.DIST_INST_COUNT > 0 ) PI GROUP BY PI.INST_ID)PX_INSTANCE) PX_INSTANCES FROM MONITOR_AGG)) ELSE NULL END, XPLAN_XML, CASE WHEN :B43 = 1 THEN (SELECT XMLELEMENT( "plan_monitor", XMLATTRIBUTES(MAX(PLI.MAX_LINE_ACTIVITY_COUNT) AS "max_activity_count", MAX(PLI.OVERALL_MAX_IO_REQS) AS "max_io_reqs", MAX(PLI
.OVERALL_MAX_IO_BYTES) AS "max_io_bytes", MAX(PLI.MAX_LINE_IMQ_COUNT) AS "max_imq_count", MAX(PLI.MAX_LINE_CPU_COUNT) AS "max_cpu_count", MAX(PLI.MAX_LINE_WAIT_COUNT) AS "max_wait_count", MAX(PLI.MAX_LINE_OTHER_SQL_COUNT) AS "max_other_sql_count"), XMLAGG( XMLELEMENT( "operation", XMLATTRIBUTES( PLI.PLAN_LINE_ID AS "id", PLI.PARENT_ID AS "parent_id", PLI.OPERATION AS "name", PLI.OPTIONS AS "options", PLI.DEPTH AS "depth", PLI.POSITION AS "position", PLI.INACTIVE AS "skp", PLI.PX_TYPE AS "px_type"), NVL2(PLI.OBJECT_NAME, XMLELEMENT( "object", XMLATTRIBUTES(PLI.OBJECT_TYPE AS "type"), XMLFOREST(PLI.OBJECT_OWNER AS "owner"), XMLFOREST(PLI.OBJECT_NAME AS "name")), NULL), XMLFOREST(PLI.PARTITION_START AS "partition_start", PLI.PARTITION_STOP AS "partition_stop"), CASE WHEN
PLI.CARDINALITY IS NULL AND PLI.BYTES IS NULL AND PLI.COST IS NULL AND PLI.TEMP_SPACE IS NULL AND PLI.TIME IS NULL THEN NULL ELSE XMLELEMENT( "optimizer", NULL, NVL2(PLI.CARDINALITY, XMLFOREST(PLI.CARDINALITY AS "cardinality"), NULL), NVL2(PLI.BYTES, XMLFOREST(PLI.BYTES AS "bytes"), NULL), NVL2(PLI.COST, XMLFOREST(PLI.COST AS "cost"), NULL), NVL2(PLI.CPU_COST, XMLFOREST(PLI.CPU_COST AS "cpu_cost"), NULL), NVL2(PLI.IO_COST, XMLFOREST(PLI.IO_COST AS "io_cost"), NULL), NVL2(PLI.TEMP_SPACE, XMLFOREST(PLI.TEMP_SPACE AS "temp"), NULL), NVL2(PLI.TIME, XMLFOREST(PLI.TIME AS "time"), NULL)) END, XMLELEMENT( "stats", XMLATTRIBUTES('plan_monitor' AS "type"), NVL2(PLI.FIRST_MOVE_TIME, XMLELEMENT( "stat", XMLATTRIBUTES('first_active' AS "name"), TO_CHAR(FIRST_MOVE_TIME, :B12 )), NULL), CASE WHEN PLI.FIRST_MOVE_TIME != PLI.FIRST_CHANGE_TIME THEN XMLE
LEMENT( "stat", XMLATTRIBUTES('first_row' AS "name"), TO_CHAR(FIRST_CHANGE_TIME, :B12 )) ELSE NULL END, NVL2(PLI.LAST_MOVE_TIME, XMLELEMENT( "stat", XMLATTRIBUTES('last_active' AS "name"), TO_CHAR(LAST_MOVE_TIME, :B12 )), NULL), CASE WHEN (PLI.FIRST_MOVE_TIME IS NULL OR PLI.LAST_MOVE_TIME IS NULL) THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('duration' AS "name"), ROUND((LAST_MOVE_TIME - FIRST_MOVE_TIME) * 3600 * 24)+1) END, CASE WHEN (PLI.OVERALL_LAST_MOVE_TIME IS NULL OR PLI.LAST_MOVE_TIME IS NULL) THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('from_most_recent' AS "name"), ROUND((PLI.OVERALL_LAST_MOVE_TIME - PLI.LAST_MOVE_TIME) * 3600 * 24)) END, NVL2(PLI.LAST_MOVE_TIME, XMLELEMENT( "stat", XMLATTRIBUTES( 'from_sql_exec_start' AS "name"), ROUND( (FIRST_MOVE_TIME - :B8 ) * 3600*24)), NULL), NVL2(PLI.PERCENT_COMPLETE, XMLELEMENT( "stat", XMLATTRIB
UTES('percent_complete' AS "name"), PLI.PERCENT_COMPLETE), NULL), NVL2(PLI.TIME_REMAINING, XMLELEMENT( "stat", XMLATTRIBUTES('time_left' AS "name"), PLI.TIME_REMAINING), NULL), CASE WHEN PLI.HAS_EXECUTED = 1 THEN XMLELEMENT( "stat", XMLATTRIBUTES('starts' AS "name"), PLI.STARTS) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.HAS_EXECUTED = 1 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_starts' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(MAX_STARTS/1000000), 10000), NULL) AS "iid", MOD(MAX_STARTS, 1000000) AS "sid"), TRUNC(PLI.MAX_STARTS/10000000000)) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.HAS_EXECUTED = 1 THEN XMLELEMENT( "stat", XMLATTRIBUTES('dop' AS "name"), PLI.DOP) ELSE NULL END, CASE WHEN NEED_ROWS IS NOT NULL AND PLI.FIRST_MOVE_TIME IS NOT NULL THEN XMLELEMENT( "stat", XMLATTRIBUTES('cardinality' AS "name"), PLI.OUTPUT_
ROWS) ELSE NULL END, CASE WHEN PLI.NEED_ROWS IS NOT NULL AND PLI.DOP > 0 AND PLI.MAX_OUTPUT_ROWS IS NOT NULL AND (PLI.FIRST_MOVE_TIME IS NOT NULL) THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_card' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(MAX_OUTPUT_ROWS/1000000), 10000), NULL) AS "iid", MOD(MAX_OUTPUT_ROWS, 1000000) AS "sid"), TRUNC(PLI.MAX_OUTPUT_ROWS/10000000000)) ELSE NULL END, CASE WHEN PLI.MEM > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('memory' AS "name"), PLI.MEM) ELSE NULL END, CASE WHEN PLI.MAX_MEM > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('max_memory' AS "name"), PLI.MAX_MEM) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MIN_MAX_MEM IS NOT NULL AND PLI.MAX_MEM > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'min_max_mem' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(MIN_MAX_MEM/1000000), 10000), NULL) AS "iid", MOD(MIN_MAX_MEM, 1000000) AS
"sid"), TRUNC(PLI.MIN_MAX_MEM/10000000000)) ELSE NULL END, CASE WHEN PLI.TEMP > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('temp' AS "name"), PLI.TEMP) ELSE NULL END, CASE WHEN PLI.MAX_TEMP > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('max_temp' AS "name"), PLI.MAX_TEMP) ELSE NULL END, CASE WHEN PLI.MAX_TEMP > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('spill_count' AS "name"), PLI.SPILL_COUNT) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_MAX_TEMP IS NOT NULL AND PLI.MAX_TEMP > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_max_temp' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(MAX_MAX_TEMP/1000000), 10000), NULL) AS "iid", MOD(MAX_MAX_TEMP, 1000000) AS "sid"), TRUNC(PLI.MAX_MAX_TEMP/10000000000)) ELSE NULL END, CASE WHEN PLI.READ_REQS > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), PLI.READ_REQS) ELSE NU
LL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_READ_REQS IS NOT NULL AND PLI.READ_REQS > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_read_reqs' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(PLI.MAX_READ_REQS/1000000), 10000), NULL) AS "iid", MOD(PLI.MAX_READ_REQS, 1000000) AS "sid"), TRUNC(PLI.MAX_READ_REQS/10000000000)) ELSE NULL END, CASE WHEN PLI.READ_BYTES > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), PLI.READ_BYTES) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_READ_BYTES IS NOT NULL AND PLI.READ_BYTES > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_read_bytes' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(PLI.MAX_READ_BYTES/1000000), 10000), NULL) AS "iid", MOD(PLI.MAX_READ_BYTES, 1000000) AS "sid"), TRUNC(PLI.MAX_READ_BYTES/10000000000)) ELSE NULL END, CASE WHEN PLI.WRITE_REQS > 0 THEN XMLELEMENT( "stat", XMLATTRIBUT
ES('write_reqs' AS "name"), PLI.WRITE_REQS) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_WRITE_REQS IS NOT NULL AND PLI.WRITE_REQS > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_write_reqs' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(PLI.MAX_WRITE_REQS/1000000), 10000), NULL) AS "iid", MOD(PLI.MAX_WRITE_REQS, 1000000) AS "sid"), TRUNC(PLI.MAX_WRITE_REQS/10000000000)) ELSE NULL END, CASE WHEN PLI.WRITE_BYTES > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), PLI.WRITE_BYTES) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_WRITE_BYTES IS NOT NULL AND PLI.WRITE_BYTES > 0 THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_write_bytes' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(PLI.MAX_WRITE_BYTES/1000000), 10000), NULL) AS "iid", MOD(PLI.MAX_WRITE_BYTES, 1000000) AS "sid"), TRUNC(PLI.MAX_WRITE_BYTES/10000000000)) ELSE NULL END, CA
SE WHEN PLI.IO_INTER_BYTES IS NOT NULL AND PLI.IO_BYTES > 0 AND PLI.IO_BYTES != PLI.IO_INTER_BYTES THEN XMLELEMENT( "stat", XMLATTRIBUTES('io_inter_bytes' AS "name"), PLI.IO_INTER_BYTES) ELSE NULL END, CASE WHEN PLI.DOP > 0 AND PLI.MAX_IO_INTER_BYTES IS NOT NULL AND PLI.IO_BYTES > 0 AND PLI.IO_BYTES != PLI.IO_INTER_BYTES THEN XMLELEMENT( "stat", XMLATTRIBUTES( 'max_io_inter_bytes' AS "name", DECODE(:B67 , 'Y', MOD(TRUNC(MAX_IO_INTER_BYTES/1000000), 10000), NULL) AS "iid", MOD(MAX_IO_INTER_BYTES, 1000000) AS "sid"), TRUNC(PLI.MAX_IO_INTER_BYTES/10000000000)) ELSE NULL END, CASE WHEN PLI.IO_INTER_BYTES IS NOT NULL AND PLI.IO_BYTES > 0 AND PLI.IO_BYTES != PLI.IO_INTER_BYTES THEN XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(PLI.IO_BYTES / DECODE(PLI.IO_INTER_BYTES, 0, 1, PLI.IO_INTER_BYTES), 2)) ELSE NULL END), NVL2(STAT_GID, XMLELEMENT( "rws
stats", XMLATTRIBUTES( PLI.STAT_GID AS "group_id"), DECODE(GID_ROWNUM, 1, (SELECT XMLELEMENT( "metadata", NULL, XMLAGG( XMLELEMENT( "stat", XMLATTRIBUTES( ROWNUM AS "id", NAME AS "name", DESCRIPTION AS "desc", TYPE AS "type", DECODE(FLAGS, 0, NULL, FLAGS) AS "flags"), NULL) ORDER BY ID)) FROM V$SQL_MONITOR_STATNAME WHERE GROUP_ID = PLI.STAT_GID), NULL), NVL2(STAT1_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(1 AS "id"), STAT1_VALUE), NULL), NVL2(STAT2_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(2 AS "id"), STAT2_VALUE), NULL), NVL2(STAT3_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(3 AS "id"), STAT3_VALUE), NULL), NVL2(STAT4_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(4 AS "id"), STAT4_VALUE), NULL), NVL2(STAT5_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(5 AS "id"), STAT5_VALUE),
NULL), NVL2(STAT6_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(6 AS "id"), STAT6_VALUE), NULL), NVL2(STAT7_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(7 AS "id"), STAT7_VALUE), NULL), NVL2(STAT8_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(8 AS "id"), STAT8_VALUE), NULL), NVL2(STAT9_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(9 AS "id"), STAT9_VALUE), NULL), NVL2(STAT10_VALUE, XMLELEMENT( "stat", XMLATTRIBUTES(10 AS "id"), STAT10_VALUE), NULL)), NULL), CASE WHEN PLI.LINE_ACTIVITY_COUNT > 0 AND :B33 = 1 THEN XMLELEMENT( "activity_sampled", XMLATTRIBUTES( TO_CHAR(PLI.LINE_ACTIVITY_START, :B12 ) AS "start_time", TO_CHAR(PLI.LINE_ACTIVITY_END, :B12 ) AS "end_time", ROUND((PLI.LINE_ACTIVITY_END - PLI.LINE_ACTIVITY_START) * 3600*24) + 1 AS "duration", PLI.LINE_ACTIVITY_COUNT AS "count", PLI.LINE_IMQ_COUNT AS "imq_cou
nt", PLI.LINE_WAIT_COUNT AS "wait_count", PLI.LINE_CPU_COUNT AS "cpu_count", PLI.LINE_OTHER_SQL_COUNT AS "other_sql_count", :B40 AS "cpu_cores", :B39 AS "hyperthread"), PLI.ACTIVITY_TOTAL, PLI.PLAN_ACTIVITY_HISTO) ELSE NULL END) ORDER BY PLI.PLAN_LINE_ID) ) FROM (SELECT AT.MAX_LINE_ACTIVITY_COUNT, PM.OVERALL_MAX_IO_REQS, PM.OVERALL_MAX_IO_BYTES, AT.MAX_LINE_IMQ_COUNT, AT.MAX_LINE_CPU_COUNT, AT.MAX_LINE_WAIT_COUNT, AT.LINE_OTHER_SQL_COUNT, AT.MAX_LINE_OTHER_SQL_COUNT, PM.PLAN_LINE_ID, PM.PARENT_ID, PM.OPERATION, PM.OPTIONS, PM.DEPTH, PM.POSITION, PM.INACTIVE, CASE WHEN PM.OPERATION = 'PX COORDINATOR' AND :B23 = 'Y' AND (PM.PX_SERVER_SET IS NOT NULL OR AH.PX_SERVER_SET IS NOT NULL) THEN 'QC' WHEN PM.PX_SERVER_SET IS NOT NULL THEN TO_CHAR(PM.PX_SERVER_SET) WHEN AH.PX_SERVER_SET IS NOT NULL THEN TO_CHAR(AH.PX_SERVER_SET) WHEN (:B23 = 'N' OR (PM.LAST_CHANGE_TIME IS NULL AND AT.LINE_ACTIVITY_END IS NULL)) THEN NULL
ELSE 'QC' END PX_TYPE, PM.FIRST_CHANGE_TIME, AT.LINE_ACTIVITY_START, PM.LAST_CHANGE_TIME, PM.OVERALL_LAST_CHANGE_TIME, AT.LINE_ACTIVITY_END, AT.OVERALL_LINE_ACTIVITY_END, LEAST(NVL(AT.LINE_ACTIVITY_START, PM.FIRST_CHANGE_TIME), NVL(PM.FIRST_CHANGE_TIME, AT.LINE_ACTIVITY_START)) FIRST_MOVE_TIME, GREATEST(NVL(AT.LINE_ACTIVITY_END, PM.LAST_CHANGE_TIME), NVL(PM.LAST_CHANGE_TIME, AT.LINE_ACTIVITY_END)) LAST_MOVE_TIME, GREATEST(NVL(AT.OVERALL_LINE_ACTIVITY_END, PM.OVERALL_LAST_CHANGE_TIME), NVL(PM.OVERALL_LAST_CHANGE_TIME, AT.OVERALL_LINE_ACTIVITY_END)) OVERALL_LAST_MOVE_TIME, CASE WHEN PM.STARTS IS NOT NULL AND PM.STARTS > 0 THEN 1 ELSE 0 END HAS_EXECUTED, PM.OBJECT_NAME, PM.OBJECT_TYPE, PM.OBJECT_OWNER, PM.PARTITION_START, PM.PARTITION_STOP, PM.CARDINALITY, PM.BYTES, PM.COST, PM.TEMP_SPACE, PM.TIME, PM.CPU_COST, PM.IO_COST, LO.PERCENT_COMPLETE, LO.TIME_REMAINING, PM.STARTS, PM.DOP, PM.MAX_STARTS, PM.OUTPUT_ROWS, PM.NEED_ROWS, PM.MAX_OUTPUT_ROWS, P
M.MEM, PM.MAX_MEM, PM.MIN_MAX_MEM, PM.TEMP, PM.MAX_TEMP, PM.SPILL_COUNT, PM.MAX_MAX_TEMP, PM.READ_REQS, PM.MAX_READ_REQS, PM.READ_BYTES, PM.MAX_READ_BYTES, PM.WRITE_REQS, PM.MAX_WRITE_REQS, PM.WRITE_BYTES, PM.MAX_WRITE_BYTES, PM.IO_INTER_BYTES, PM.IO_BYTES, PM.MAX_IO_INTER_BYTES, AT.LINE_ACTIVITY_COUNT, AT.LINE_IMQ_COUNT, AT.LINE_WAIT_COUNT, AT.LINE_CPU_COUNT, AT.ACTIVITY_TOTAL, AH.PLAN_ACTIVITY_HISTO, PM.STAT_GID, PM.GID_ROWNUM, PM.STAT1_VALUE, PM.STAT2_VALUE, PM.STAT3_VALUE, PM.STAT4_VALUE, PM.STAT5_VALUE, PM.STAT6_VALUE, PM.STAT7_VALUE, PM.STAT8_VALUE, PM.STAT9_VALUE, PM.STAT10_VALUE FROM (SELECT AT0.*, MAX(LINE_ACTIVITY_END) OVER() OVERALL_LINE_ACTIVITY_END, MAX(LINE_ACTIVITY_COUNT) OVER() MAX_LINE_ACTIVITY_COUNT, MAX(LINE_IMQ_COUNT) OVER() MAX_LINE_IMQ_COUNT, MAX(LINE_CPU_COUNT) OVER() MAX_LINE_CPU_COUNT, MAX(LINE_WAIT_COUNT) OVER() MAX_LINE_WAIT_COUNT, MAX(LINE_OTHER_SQL_COUNT) OVER() MAX_LINE_OTHER_SQL_COUNT FROM (SELECT AD1.PLAN_LINE_ID,
MIN(AD1.LINE_ACTIVITY_START) LINE_ACTIVITY_START, MAX(AD1.LINE_ACTIVITY_END) LINE_ACTIVITY_END, SUM(AD1.ACTIVITY_COUNT) LINE_ACTIVITY_COUNT, SUM(AD1.IMQ_COUNT) LINE_IMQ_COUNT, SUM(AD1.WAIT_COUNT) LINE_WAIT_COUNT, SUM(AD1.OTHER_SQL_COUNT) LINE_OTHER_SQL_COUNT, SUM(AD1.CPU_COUNT) LINE_CPU_COUNT, SUBSTR(MAX(LPAD(AD1.ACTIVITY_COUNT, 10)|| AD1.ACTIVITY_TYPE), 11) MOST_ACTIVE, XMLAGG(XMLELEMENT( "activity", XMLATTRIBUTES( AD1.ACTIVITY_TYPE AS "class", AD1.EVENT_NAME AS "event"), AD1.ACTIVITY_COUNT) ORDER BY AD1.ACTIVITY_TYPE, AD1.EVENT_NAME) ACTIVITY_TOTAL FROM (SELECT AD0.PLAN_LINE_ID, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, MIN(AD0.ACTIVITY_START) LINE_ACTIVITY_START, MAX(AD0.ACTIVITY_END) LINE_ACTIVITY_END, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD0.IMQ_COUNT) IMQ_COUNT, SUM(AD0.WAIT_COUNT) WAIT_COUNT, SUM(AD0.CPU_COUNT) CPU_COUNT, SUM(AD0.OTHER_SQL_COUNT) OTHER_SQL_COUNT, MAX(AD0.DFO_MOST_ACTIVE_IID) DFO_MOST_ACTIVE_IID, MAX(AD0.DFO
_MOST_ACTIVE_SID) DFO_MOST_ACTIVE_SID, SUM(AD0.DFO_MOST_ACTIVE_COUNT) DFO_MOST_ACTIVE_COUNT FROM ASH_DATA AD0 WHERE AD0.PLAN_LINE_ID IS NOT NULL GROUP BY AD0.PLAN_LINE_ID, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME) AD1 GROUP BY AD1.PLAN_LINE_ID) AT0) AT, (SELECT AD2.PLAN_LINE_ID, MIN(AD2.PX_SERVER_SET) PX_SERVER_SET, MIN(AD2.LINE_ACTIVITY_START) LINE_ACTIVITY_START, MAX(AD2.LINE_ACTIVITY_END) LINE_ACTIVITY_END, SUM(AD2.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD2.IMQ_COUNT) IMQ_COUNT, SUM(AD2.WAIT_COUNT) WAIT_COUNT, SUM(AD2.CPU_COUNT) CPU_COUNT, SUM(AD2.OTHER_SQL_COUNT) OTHER_SQL_COUNT, CASE WHEN :B29 = 1 AND SUM(AD2.ACTIVITY_COUNT) > 0 THEN XMLELEMENT( "activity_histogram", XMLATTRIBUTES( :B26 AS "bucket_interval", :B27 AS "bucket_count", TO_CHAR( :B20 , :B12 ) AS "start_time", TO_CHAR(:B22 , :B12 ) AS "end_time", ROUND((:B22 -:B20 ) *3600*24) + 1 AS "duration"), XMLAGG(XMLELEMENT( "bucket", XMLATTRIBUTE
S( AD2.BUCKET_NUM AS "number"), AD2.ACTIVITY_BUCKET) ORDER BY AD2.BUCKET_NUM)) ELSE NULL END PLAN_ACTIVITY_HISTO FROM (SELECT AD1.PLAN_LINE_ID, AD1.BUCKET_NUM, MIN(AD1.PX_SERVER_SET) PX_SERVER_SET, MIN(AD1.LINE_ACTIVITY_START) LINE_ACTIVITY_START, MAX(AD1.LINE_ACTIVITY_END) LINE_ACTIVITY_END, MIN(AD1.BUCKET_ACTIVITY_START) BUCKET_ACTIVITY_START, MAX(AD1.BUCKET_ACTIVITY_END) BUCKET_ACTIVITY_END, SUM(AD1.ACTIVITY_COUNT) ACTIVITY_COUNT, SUM(AD1.IMQ_COUNT) IMQ_COUNT, SUM(AD1.WAIT_COUNT) WAIT_COUNT, SUM(AD1.CPU_COUNT) CPU_COUNT, SUM(AD1.OTHER_SQL_COUNT) OTHER_SQL_COUNT, SUBSTR(MAX(LPAD(AD1.ACTIVITY_COUNT, 10)|| AD1.ACTIVITY_TYPE), 11) MOST_ACTIVE, XMLAGG(NVL2(AD1.ACTIVITY_TYPE, XMLELEMENT( "activity", XMLATTRIBUTES( AD1.ACTIVITY_TYPE AS "class", AD1.EVENT_NAME AS "event"), AD1.ACTIVITY_COUNT), NULL) ORDER BY AD1.ACTIVITY_TYPE, AD1.EVENT_NAME) ACTIVITY_BUCKET FROM (SELECT AD0.PLAN_LINE_ID, AD0.PLAN_ACTIVITY_BUCKET_NUM BUCKET_NUM,
AD0.ACTIVITY_TYPE, AD0.EVENT_NAME, MIN(NVL2(AD0.ACTIVITY_START, AD0.PX_SERVER_SET, NULL)) PX_SERVER_SET, MIN(AD0.ACTIVITY_START) LINE_ACTIVITY_START, MAX(AD0.ACTIVITY_END) LINE_ACTIVITY_END, MIN(AD0.BUCKET_ACTIVITY_START) BUCKET_ACTIVITY_START, MAX(AD0.BUCKET_ACTIVITY_END) BUCKET_ACTIVITY_END, SUM(AD0.IMQ_COUNT) IMQ_COUNT, SUM(AD0.CPU_COUNT) CPU_COUNT, SUM(AD0.WAIT_COUNT) WAIT_COUNT, SUM(AD0.OTHER_SQL_COUNT) OTHER_SQL_COUNT, SUM(AD0.ACTIVITY_COUNT) ACTIVITY_COUNT FROM ASH_DATA AD0 GROUP BY AD0.PLAN_LINE_ID, AD0.PLAN_ACTIVITY_BUCKET_NUM, AD0.ACTIVITY_TYPE, AD0.EVENT_NAME) AD1 GROUP BY AD1.PLAN_LINE_ID, AD1.BUCKET_NUM) AD2 GROUP BY AD2.PLAN_LINE_ID) AH, (SELECT LO.SQL_PLAN_LINE_ID PLAN_LINE_ID, DECODE(SUM(LO.TOTALWORK), 0, NULL, ROUND(SUM(LO.SOFAR)*100/SUM(LO.TOTALWORK))) PERCENT_COMPLETE, MAX(LO.TIME_REMAINING) TIME_REMAINING FROM GV$SESSION_LONGOPS LO, MONITOR_DATA MO WHERE (:B49 = 'Y' OR :B70 = 'DONE (ERROR)') AND LO.SQL_ID = :B9 AND LO.SQL_EXEC_START = :B8 AN
D LO.SQL_EXEC_ID = :B7 AND LO.INST_ID = MO.INST_ID AND LO.SID = MO.SID GROUP BY LO.SQL_PLAN_LINE_ID) LO, (SELECT PM0.*, CASE WHEN PM0.STARTS IS NULL OR PM0.STARTS = 0 OR PM0.OUTPUT_ROWS IS NULL THEN NULL ELSE 1 END NEED_ROWS, ROW_NUMBER() OVER(PARTITION BY PM0.STAT_GID ORDER BY PM0.PLAN_LINE_ID ) GID_ROWNUM, MAX(LAST_CHANGE_TIME) OVER() OVERALL_LAST_CHANGE_TIME, MAX(MAX_IO_REQS) OVER() OVERALL_MAX_IO_REQS, MAX(MAX_IO_BYTES) OVER() OVERALL_MAX_IO_BYTES FROM (SELECT /*+ leading(mo) use_hash(plm) */ PLM.PLAN_LINE_ID PLAN_LINE_ID, PLM.PLAN_OPERATION OPERATION, PLM.PLAN_OPTIONS OPTIONS, MAX(PLM.PLAN_PARENT_ID) PARENT_ID, MAX(PLM.PLAN_DEPTH) DEPTH, MAX(PLM.PLAN_POSITION) POSITION, MAX(PLM.PLAN_OPERATION_INACTIVE) INACTIVE, MAX(PLM.PLAN_OBJECT_OWNER) OBJECT_OWNER, MAX(PLM.PLAN_OBJECT_NAME) OBJECT_NAME, MAX(PLM.PLAN_OBJECT_TYPE) OBJECT_TYPE, MAX(PLM.PLAN_COST) COST, MAX(PLM.PLAN_CARDINALITY) CARDINALITY, MAX(PLM.PLAN_BYTES) BYTES, MAX(PLM.PLAN_CPU_COST) CPU_COST, MAX(PLM.PL
AN_IO_COST) IO_COST, MAX(PLM.PLAN_TEMP_SPACE) TEMP_SPACE, MAX(PLM.PLAN_TIME) TIME, MAX(PLM.PLAN_PARTITION_START) PARTITION_START, MAX(PLM.PLAN_PARTITION_STOP) PARTITION_STOP, MIN(PLM.FIRST_CHANGE_TIME) FIRST_CHANGE_TIME, MAX(PLM.LAST_CHANGE_TIME) LAST_CHANGE_TIME, MIN(PLM.LAST_CHANGE_TIME) MIN_LAST_CHANGE_TIME, MIN(NVL2(PLM.FIRST_CHANGE_TIME, MO.PX_SERVER_SET, NULL)) PX_SERVER_SET, COUNT(CASE WHEN PLM.PAR IS NOT NULL AND PLM.STARTS IS NOT NULL AND PLM.STARTS > 0 AND PLM.PLAN_LINE_ID != 0 AND PLM.PLAN_OPERATION != 'PX COORDINATOR' THEN 1 ELSE NULL END) DOP, SUM(PLM.STARTS) STARTS, MAX(NVL2(PAR, PLM.STARTS * 10000000000 + PLM.ES, NULL)) MAX_STARTS, SUM(PLM.OUTPUT_ROWS) OUTPUT_ROWS, MAX(NVL2(PAR, PLM.OUTPUT_ROWS * 10000000000 +PLM.ES, NULL)) MAX_OUTPUT_ROWS, SUM(PLM.WORKAREA_MEM) MEM, SUM(PLM.WORKAREA_MAX_MEM) MAX_MEM, MIN(NVL2(PAR, PLM.WORKAREA_MAX_MEM * 10000000000 + PLM.ES, NULL)) MIN_MAX_MEM, SUM(PLM.WORKAREA_TEMPSEG) TEMP, SUM(PLM.WORKAREA_MAX_TEMPSEG) MA
X_TEMP, MAX(NVL2(PAR, PLM.WORKAREA_MAX_TEMPSEG * 10000000000 + PLM.ES, NULL)) MAX_MAX_TEMP, COUNT(PLM.WORKAREA_MAX_TEMPSEG) SPILL_COUNT, SUM(PLM.PHYSICAL_READ_REQUESTS) READ_REQS, MAX(NVL2(PAR, PLM.PHYSICAL_READ_REQUESTS * 10000000000 + PLM.ES, NULL)) MAX_READ_REQS, SUM(PLM.PHYSICAL_READ_BYTES) READ_BYTES, MAX(NVL2(PAR, PLM.PHYSICAL_READ_BYTES * 10000000000 + PLM.ES, NULL)) MAX_READ_BYTES, SUM(PLM.PHYSICAL_WRITE_REQUESTS) WRITE_REQS, MAX(NVL2(PAR, PLM.PHYSICAL_WRITE_REQUESTS * 10000000000 + PLM.ES, NULL)) MAX_WRITE_REQS, SUM(PLM.PHYSICAL_WRITE_BYTES) WRITE_BYTES, MAX(NVL2(PAR, PLM.PHYSICAL_WRITE_BYTES * 10000000000 + PLM.ES, NULL)) MAX_WRITE_BYTES, NVL(SUM(PLM.PHYSICAL_READ_BYTES), 0) + NVL(SUM(PLM.PHYSICAL_WRITE_BYTES), 0) IO_BYTES, SUM(NVL(PLM.PHYSICAL_READ_REQUESTS, 0) + NVL(PLM.PHYSICAL_WRITE_REQUESTS, 0)) MAX_IO_REQS, SUM(NVL(PLM.PHYSICAL_READ_BYTES, 0) + NVL(PLM.PHYSICAL_WRITE_BYTES, 0)) MAX_IO_BYTES, SUM(PLM.IO_INTERCONNECT_BYTES) IO_INTER_BYTES, M
AX(NVL2(PAR, PLM.IO_INTERCONNECT_BYTES * 10000000000 + PLM.ES, NULL)) MAX_IO_INTER_BYTES, MAX(OTHERSTAT_GROUP_ID) STAT_GID, NVL(DECODE(MAX(OTHERSTAT_1_TYPE), 3, MAX(OTHERSTAT_1_VALUE), 4, MAX(OTHERSTAT_1_VALUE), 6, MIN(OTHERSTAT_1_VALUE), 7, MIN(OTHERSTAT_1_VALUE), NULL), SUM(DECODE(OTHERSTAT_1_TYPE, 1, OTHERSTAT_1_VALUE, 2, OTHERSTAT_1_VALUE, NULL))) STAT1_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_2_TYPE), 3, MAX(OTHERSTAT_2_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_2_VALUE), 7, MIN(RMAX1 + OTHERSTAT_2_VALUE), NULL), 6, MIN(OTHERSTAT_2_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_2_TYPE, 1, OTHERSTAT_2_VALUE, 2, OTHERSTAT_2_VALUE, NULL))) STAT2_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_3_TYPE), 3, MAX(OTHERSTAT_3_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_3_VALUE), 7, MIN(RMAX1 + OTHERSTAT_3_VALUE), NULL), 6, MIN(OTHERSTAT_3_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_3_
TYPE, 1, OTHERSTAT_3_VALUE, 2, OTHERSTAT_3_VALUE, NULL))) STAT3_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_4_TYPE), 3, MAX(OTHERSTAT_4_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_4_VALUE), 7, MIN(RMAX1 + OTHERSTAT_4_VALUE), NULL), 6, MIN(OTHERSTAT_4_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_4_TYPE, 1, OTHERSTAT_4_VALUE, 2, OTHERSTAT_4_VALUE, NULL))) STAT4_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_5_TYPE), 3, MAX(OTHERSTAT_5_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_5_VALUE), 7, MIN(RMAX1 + OTHERSTAT_5_VALUE), NULL), 6, MIN(OTHERSTAT_5_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_5_TYPE, 1, OTHERSTAT_5_VALUE, 2, OTHERSTAT_5_VALUE, NULL))) STAT5_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_6_TYPE), 3, MAX(OTHERSTAT_6_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_6_VALUE), 7, MIN(RMAX1 + OTHERSTAT_6_VALUE), NULL), 6, MIN(OTHERSTAT_6_VALUE), NULL)), 100000000
00000000), SUM(DECODE(OTHERSTAT_6_TYPE, 1, OTHERSTAT_6_VALUE, 2, OTHERSTAT_6_VALUE, NULL))) STAT6_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_7_TYPE), 3, MAX(OTHERSTAT_7_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_7_VALUE), 7, MIN(RMAX1 + OTHERSTAT_7_VALUE), NULL), 6, MIN(OTHERSTAT_7_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_7_TYPE, 1, OTHERSTAT_7_VALUE, 2, OTHERSTAT_7_VALUE, NULL))) STAT7_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_8_TYPE), 3, MAX(OTHERSTAT_8_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_8_VALUE), 7, MIN(RMAX1 + OTHERSTAT_8_VALUE), NULL), 6, MIN(OTHERSTAT_8_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_8_TYPE, 1, OTHERSTAT_8_VALUE, 2, OTHERSTAT_8_VALUE, NULL))) STAT8_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_9_TYPE), 3, MAX(OTHERSTAT_9_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_9_VALUE), 7, MIN(RMAX1 + OTHERSTAT_9_VALUE), NULL), 6, MIN(OTHE
RSTAT_9_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_9_TYPE, 1, OTHERSTAT_9_VALUE, 2, OTHERSTAT_9_VALUE, NULL))) STAT9_VALUE, NVL(MOD((DECODE(MAX(OTHERSTAT_10_TYPE), 3, MAX(OTHERSTAT_10_VALUE), 5, DECODE(MAX(OTHERSTAT_1_TYPE), 4, MAX(RMAX1 + OTHERSTAT_10_VALUE), 7, MIN(RMAX1 + OTHERSTAT_10_VALUE), NULL), 6, MIN(OTHERSTAT_10_VALUE), NULL)), 10000000000000000), SUM(DECODE(OTHERSTAT_10_TYPE, 1, OTHERSTAT_10_VALUE, 2, OTHERSTAT_10_VALUE, NULL))) STAT10_VALUE FROM (SELECT A.*, OTHERSTAT_1_VALUE * 10000000000000000 RMAX1, A.INST_ID * 1000000 + A.SID ES, DECODE(A.PROCESS_NAME, 'ora', NULL, 1) PAR FROM GV$SQL_PLAN_MONITOR A) PLM, MONITOR_DATA MO WHERE PLM.SQL_ID = :B9 AND PLM.SQL_EXEC_START = :B8 AND PLM.SQL_EXEC_ID = :B7 AND PLM.INST_ID = MO.INST_ID AND PLM.INST_ID BETWEEN :B11 AND :B10 AND PLM.KEY = MO.KEY GROUP BY PLM.PLAN_LINE_ID, PLM.PLAN_OPERATION, PLM.PLAN_OPTIONS) PM0) PM WHERE AH.PLAN_LINE_ID(+) = PM.PLAN_LINE_ID AND AT.PLAN_LINE_ID(+)
= PM.PLAN_LINE_ID AND LO.PLAN_LINE_ID(+) = PM.PLAN_LINE_ID AND (:B21 IS NULL OR PM.PLAN_LINE_ID = :B21 )) PLI) ELSE NULL END, CASE WHEN :B42 = 1 THEN DBMS_SQLTUNE.BUILD_STASH_XML( SESSION_ID=>:B19 , SESSION_SERIAL=>:B18 , SESSION_INST_ID=>:B17 , PX_MODE=>'yes', START_TIME=>:B20 , END_TIME=>:B22 , MISSING_SECONDS=> :B41 , INSTANCE_LOW_FILTER=>:B11 , INSTANCE_HIGH_FILTER=>:B10 , BUCKET_MAX_COUNT=>NULL, BUCKET_INTERVAL=>:B26 , REPORT_LEVEL=>'typical', CPU_CORES=>:B40 , IS_HYPER=>:B39 ) ELSE NULL END), (CASE WHEN :B38 = 1 THEN (SELECT XMLELEMENT( "skewed_sessions", XMLATTRIBUTES( DECODE(MIN(INST_ID), NULL, :B17 , MIN(INST_ID)) AS "min_iid", DECODE(MAX(INST_ID), NULL, :B17 , MAX(INST_ID)) AS "max_iid"), XMLAGG( XMLELEMENT( "s", XMLATTRIBUTES( INST_ID AS "i"), SESSION_ID) ORDER BY INST_ID, SESSION_ID)) FROM (SELECT SESS.* FROM (SELECT DECODE(AD.DFO_MOST_ACTIVE_IID, :B17 ,
NULL, AD.DFO_MOST_ACTIVE_IID) INST_ID, AD.DFO_MOST_ACTIVE_SID SESSION_ID FROM ASH_DATA AD WHERE AD.DFO_MOST_ACTIVE_COUNT IS NOT NULL GROUP BY AD.DFO_MOST_ACTIVE_IID, AD.DFO_MOST_ACTIVE_SID ORDER BY MAX(AD.DFO_MOST_ACTIVE_COUNT) DESC) SESS WHERE ROWNUM <= 100)) ELSE NULL END), (CASE WHEN :B37 = 1 THEN (SELECT XMLELEMENT( "report_repository_summary", CASE WHEN MA.MAX_DBOP_NAME IS NOT NULL THEN XMLELEMENT( "dbop", XMLATTRIBUTES('F' AS "detail", MA.MAX_DBOP_NAME AS "dbop_name", TO_CHAR(MA.MIN_FIRST_REFRESH_TIME, :B12 ) AS "dbop_exec_start", MA.MAX_DBOP_EXEC_ID AS "dbop_exec_id"), XMLFOREST( MA.MAX_STATUS AS "status", TO_CHAR(NVL(MA.MAX_SQL_EXEC_START, MA.MIN_FIRST_REFRESH_TIME), :B12 )AS "first_refresh_time", TO_CHAR(MA.MAX_LAST_REFRESH_TIME, :B12 )AS "last_refresh_time", MA.SUM_REFRESH_COUNT AS "refresh_count", MA.MAX_INST_ID AS "inst_id", MA.MAX_SESSION_ID A
S "session_id", MA.MAX_SESSION_SERIAL AS "session_serial", MA.MAX_USERID AS "user_id", MA.MAX_USERNAME AS "user", MA.MAX_CON_ID AS "con_id", MA.MAX_CON_NAME AS "con_name", MA.MAX_MODULE AS "module", MA.MAX_ACTION AS "action", MA.MAX_SERVICE_NAME AS "service", MA.MAX_CLIENT_ID AS "client_id", MA.MAX_CLIENT_INFO AS "client_info", MA.MAX_PROGRAM AS "program", MA.MAX_PL_ENTRY_OID AS "plsql_entry_object_id", MA.MAX_PL_ENTRY_PROGID AS "plsql_entry_subprogram_id", MA.MAX_PL_OID AS "plsql_object_id", MA.MAX_PL_PROGID AS "plsql_subprogram_id", MA.MAX_PX_IS_CROSS_INSTANCE AS "is_cross_instance", MA.MAX_PX_DOP AS "dop", MA.MAX_PX_DOP_INSTANCES AS "instances"), CASE WHEN MA.MAX_ERROR_NUMBER IS NULL THEN NULL ELSE XMLELEMENT( "error", XMLATTRIBUTES(MA.MAX_ERROR_NUMBER AS "numbe
r", MA.MAX_ERROR_FACILITY AS "facility"), MA.MAX_ERROR_MESSAGE) END, XMLELEMENT( "stats", XMLATTRIBUTES('monitor' AS "type"), XMLELEMENT( "stat", XMLATTRIBUTES('duration' AS "name"), GREATEST(ROUND((MA.MAX_LAST_REFRESH_TIME- NVL(MA.MAX_SQL_EXEC_START, MA.MIN_FIRST_REFRESH_TIME))*86400), LEAST(MA.SUM_ELAPSED_TIME/1000000, 1), CEIL(MA.MAX_QUEUING_TIME/1000000))), DECODE(MA.SUM_ELAPSED_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('elapsed_time' AS "name"), MA.SUM_ELAPSED_TIME)), DECODE(MA.MAX_QUEUING_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('queuing_time' AS "name"), MA.MAX_QUEUING_TIME)), DECODE(MA.SUM_CPU_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cpu_time' AS "name"), MA.SUM_CPU_TIME)), DECODE(MA.SUM_USER_IO_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_io_wait_time' AS "name"), MA.SUM_
USER_IO_WAIT_TIME)), DECODE(MA.SUM_APPLICATION_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('application_wait_time' AS "name"), MA.SUM_APPLICATION_WAIT_TIME)), DECODE(MA.SUM_CONCURRENCY_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('concurrency_wait_time' AS "name"), MA.SUM_CONCURRENCY_WAIT_TIME)), DECODE(MA.SUM_CLUSTER_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cluster_wait_time' AS "name"), MA.SUM_CLUSTER_WAIT_TIME)), DECODE(MA.SUM_PLSQL_EXEC_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('plsql_exec_time' AS "name"), MA.SUM_PLSQL_EXEC_TIME)), DECODE(MA.SUM_JAVA_EXEC_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('java_exec_time' AS "name"), MA.SUM_JAVA_EXEC_TIME)), DECODE(MA.SUM_OTHER_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('other_wait_time' AS "name"), MA.SUM_OTHER_WAIT_TIME)), DEC
ODE(MA.SUM_FETCHES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_fetch_count' AS "name"), MA.SUM_FETCHES)), DECODE(MA.SUM_BUFFER_GETS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('buffer_gets' AS "name"), MA.SUM_BUFFER_GETS)), DECODE(MA.SUM_READ_REQS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), MA.SUM_READ_REQS)), DECODE(MA.SUM_READ_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), MA.SUM_READ_BYTES)), DECODE(MA.SUM_WRITE_REQS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_reqs' AS "name"), MA.SUM_WRITE_REQS)), DECODE(MA.SUM_WRITE_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), MA.SUM_WRITE_BYTES)), CASE WHEN MA.SUM_IO_INTER_BYTES IS NULL OR MA.SUM_IO_INTER_BYTES = MA.SUM_IO_BYTES OR MA.SUM_IO_BYTES = 0 OR NVL(MA.SUM_IO_ELIG_BYTES, 0) = 0 THEN NULL E
LSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(MA.SUM_IO_BYTES / DECODE(MA.SUM_IO_INTER_BYTES, 0, 1, MA.SUM_IO_INTER_BYTES), 2)) END, CASE WHEN NVL(MA.SUM_IO_ELIG_BYTES, 0) = 0 OR MA.SUM_IO_UNC_BYTES = MA.SUM_IO_RET_BYTES THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency2' AS "name"), GREATEST(0, ROUND(100 * (MA.SUM_IO_UNC_BYTES - MA.SUM_IO_RET_BYTES) / MA.SUM_IO_ELIG_BYTES, 2))) END) ) ELSE XMLELEMENT( "sql", XMLATTRIBUTES( MA.MAX_SQL_ID AS "sql_id", TO_CHAR(MA.MAX_SQL_EXEC_START, :B12 ) AS "sql_exec_start", MA.MAX_SQL_EXEC_ID AS "sql_exec_id"), XMLFOREST(MA.MAX_STATUS AS "status", SUBSTR(MA.SQLMON_TEXT, 1, 100) AS "sql_text", TO_CHAR(MA.MIN_FIRST_REFRESH_TIME, :B12 ) AS "first_refresh_time", TO_CHAR(MA.MAX_LAST_REFRESH_TIME, :B12 ) AS "last_refresh_time", MA.SUM_REFRESH_COUNT AS
"refresh_count", MA.MAX_INST_ID AS "inst_id", MA.MAX_SESSION_ID AS "session_id", MA.MAX_SESSION_SERIAL AS "session_serial", MA.MAX_USERID AS "user_id", MA.MAX_USERNAME AS "user", MA.MAX_CON_ID AS "con_id", MA.MAX_CON_NAME AS "con_name", MA.MAX_MODULE AS "module", MA.MAX_ACTION AS "action", MA.MAX_SERVICE_NAME AS "service", MA.MAX_CLIENT_ID AS "client_id", MA.MAX_CLIENT_INFO AS "client_info", MA.MAX_PROGRAM AS "program", MA.MAX_PLAN_HASH_VALUE AS "plan_hash", MA.MAX_PL_ENTRY_OID AS "plsql_entry_object_id", MA.MAX_PL_ENTRY_PROGID AS "plsql_entry_subprogram_id", MA.MAX_PL_OID AS "plsql_object_id", MA.MAX_PL_PROGID AS "plsql_subprogram_id", MA.MAX_PX_IS_CROSS_INSTANCE AS "is_cross_instance", MA.MAX_PX_DOP AS "dop", MA.MAX_PX_DOP_INSTANCES AS "instances"
, MA.SUM_SERVERS_REQUESTED AS "px_servers_requested", MA.SUM_SERVERS_ALLOCATED AS "px_servers_allocated"), XMLELEMENT( "stats", XMLATTRIBUTES('monitor' AS "type"), XMLELEMENT( "stat", XMLATTRIBUTES('duration' AS "name"), GREATEST(ROUND((MA.MAX_LAST_REFRESH_TIME- MA.MAX_SQL_EXEC_START) * 86400), LEAST(MA.SUM_ELAPSED_TIME/1000000, 1), CEIL(MA.MAX_QUEUING_TIME/1000000))), DECODE(MA.SUM_ELAPSED_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('elapsed_time' AS "name"), MA.SUM_ELAPSED_TIME)), DECODE(MA.MAX_QUEUING_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('queuing_time' AS "name"), MA.MAX_QUEUING_TIME)), DECODE(MA.SUM_CPU_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cpu_time' AS "name"), MA.SUM_CPU_TIME)), DECODE(MA.SUM_USER_IO_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_io_wait_time' AS "name
"), MA.SUM_USER_IO_WAIT_TIME)), DECODE(MA.SUM_APPLICATION_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('application_wait_time' AS "name"), MA.SUM_APPLICATION_WAIT_TIME)), DECODE(MA.SUM_CONCURRENCY_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('concurrency_wait_time' AS "name"), MA.SUM_CONCURRENCY_WAIT_TIME)), DECODE(MA.SUM_CLUSTER_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('cluster_wait_time' AS "name"), MA.SUM_CLUSTER_WAIT_TIME)), DECODE(MA.SUM_PLSQL_EXEC_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('plsql_exec_time' AS "name"), MA.SUM_PLSQL_EXEC_TIME)), DECODE(MA.SUM_JAVA_EXEC_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('java_exec_time' AS "name"), MA.SUM_JAVA_EXEC_TIME)), DECODE(MA.SUM_OTHER_WAIT_TIME, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('other_wait_time' AS "name"), MA.SUM_OTHER_
WAIT_TIME)), DECODE(MA.SUM_FETCHES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('user_fetch_count' AS "name"), MA.SUM_FETCHES)), DECODE(MA.SUM_BUFFER_GETS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('buffer_gets' AS "name"), MA.SUM_BUFFER_GETS)), DECODE(MA.SUM_READ_REQS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_reqs' AS "name"), MA.SUM_READ_REQS)), DECODE(MA.SUM_READ_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('read_bytes' AS "name"), MA.SUM_READ_BYTES)), DECODE(MA.SUM_WRITE_REQS, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_reqs' AS "name"), MA.SUM_WRITE_REQS)), DECODE(MA.SUM_WRITE_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('write_bytes' AS "name"), MA.SUM_WRITE_BYTES)), DECODE(MA.SUM_IO_UNC_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('unc_bytes' AS "name"), MA.SUM_IO_UNC_BYT
ES)), DECODE(MA.SUM_IO_ELIG_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('elig_bytes' AS "name"), MA.SUM_IO_ELIG_BYTES)), DECODE(MA.SUM_IO_RET_BYTES, 0, NULL, XMLELEMENT( "stat", XMLATTRIBUTES('ret_bytes' AS "name"), MA.SUM_IO_RET_BYTES)), CASE WHEN MA.SUM_IO_INTER_BYTES IS NULL OR MA.SUM_IO_INTER_BYTES = MA.SUM_IO_BYTES OR MA.SUM_IO_BYTES = 0 OR NVL(MA.SUM_IO_ELIG_BYTES, 0) = 0 THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency' AS "name"), ROUND(MA.SUM_IO_BYTES / DECODE(MA.SUM_IO_INTER_BYTES, 0, 1, MA.SUM_IO_INTER_BYTES), 2)) END, CASE WHEN NVL(MA.SUM_IO_ELIG_BYTES, 0) = 0 OR MA.SUM_IO_UNC_BYTES = MA.SUM_IO_RET_BYTES THEN NULL ELSE XMLELEMENT( "stat", XMLATTRIBUTES('cell_offload_efficiency2' AS "name"), GREATEST(0, ROUND(100 * (MA.SUM_IO_UNC_BYTES - MA.SUM_IO_RET_BYTES) / MA.SUM_IO_ELIG_BYTES, 2))) END) ) END) FROM MONITOR_AGG MA) ELSE NULL END) FROM (
SELECT CASE WHEN V1.XPLAN_XML IS NULL OR V1.XPLAN_XML.EXISTSNODE('/error') > 0 THEN NULL ELSE V1.XPLAN_XML END XPLAN_XML FROM (SELECT CASE WHEN :B36 = 1 THEN DBMS_XPLAN.BUILD_PLAN_XML( TABLE_NAME=>'gv$sql_plan', PLAN_TAG=>'plan', FILTER_PREDS=>:B35 , FORMAT=>'-PROJECTION +ALIAS +ADAPTIVE') ELSE NULL END XPLAN_XML FROM DUAL) V1) CONST_VIEW |
| 21qu4mvf0zjgs | SELECT to_char(low_time, 'YYYY-MM-DD HH24:MI:SS') as last_complete_backup,
ROUND((high_time-low_time)*24*60*60, 2) as recovery_window,
ROUND((sysdate-high_time)*24*60*60, 2) as unprotected_data_window
FROM v$disk_restore_range rr1
WHERE rr1.high_time = (SELECT max(rr2.high_time)
FROM v$disk_restore_range rr2
WHERE rr1.db_id = rr2.db_id) |
| 2h17hjq001cq8 | SELECT SUM("A1"."VOLIN"+"A1"."VOLOUT"), "A1"."POSTPRE", "A1"."MSISDN", SYSDATE@!-2, SYSDATE@!-92, SYSDATE@!-2 FROM "MOBILE_DATA" "A1" WHERE "A1"."TIME_TRUNC">=SYSDATE@!-92 AND "A1"."TIME_TRUNC"<=SYSDATE@!-2 AND SYSDATE@!-2>=SYSDATE@!-92 GROUP BY "A1"."POSTPRE", "A1"."MSISDN" |
| 2p9fv35c7zxtg |
select /* KSXM:LOAD_DML_INF *//*+ leading(o) index(m) use_nl(m) */ nvl(m.inserts, 0) ins, nvl(m.updates, 0) upd, nvl(m.deletes, 0) del, nvl(m.drop_segments, 0) dropseg, nvl(m.flags, 0) flags, nvl(rowcnt, 0) rowcnt, o.pobjn pobjn from (select :objn objn, 0 pobjn, rowcnt from tab$ t where t.obj# = :objn union all select :objn objn, tp.bo# pobjn, rowcnt from tabpart$ tp where tp.obj# = :objn union all
select :objn objn, tcp.bo# pobjn, rowcnt from tabcompart$ tcp where tcp.obj# = :objn union all select :objn objn, tsp.pobj# pobjn, rowcnt from tabsubpart$ tsp where tsp.obj# = :objn) o, sys.mon_mods_all$ m where o.objn = m.obj#(+) and rownum < 2 |
| 340chgpg8x78v | select count(*) from optstat_hist_control$ where sname = :1 and spare4 = :2 |
| 3c7hdm5185rx6 |
-- SQL building XML for tablespaces
select
xmlelement(
"tablespaces",
xmlelement(
"report_tablespaces",
null,
xmlforest(
:p_level as "level",
:p_tbs_name as "tbs_name",
:v_oracle_managed as "oracle_managed",
:v_compatible as "compatible")),
xmlagg(
xmlelement(
"tbs",
xmlattributes(
tbs.tablespace_name as "name",
case
when max(decode(tbs.contents, 'TEMPORARY', 'T', null)) = 'T'
then
(select tg.group_name
from dba_tablespace_groups tg
where tg.tablespace_name = tbs.tablespace_name)
else
null
end
as "group",
max(tbs.block_size) as "bsz",
max(decode(tbs.status,
'ONLINE', null,
'OFFLINE', 'O',
tbs.status)) as "st",
max(decode(tbs.contents,
'PERMANENT', 'P',
'TEMPORARY', 'T',
'UNDO', 'U',
tbs.contents)) as "co",
max(decode(tbs.logging,
'LOGGING', null,
'NOLOGGING', 'N',
tbs.logging)) as "log",
max(decode(tbs.force_logging,
'NO', null,
force_logging)) as "flog",
max(decode(tbs.extent_management,
'LOCAL', 'L',
'DICTIONARY', 'D',
tbs.extent_management)) as "em",
max(decode(tbs.allocation_type,
'USER', 'US',
'SYSTEM', 'S',
'UNIFORM', 'U',
tbs.allocation_type)) as "at",
max(decode(tbs.plugged_in,
'NO', null,
tbs.plugged_in)) as "pl",
max(decode(tbs.segment_space_management,
'MANUAL', 'M',
'AUTO', 'A',
tbs.segment_space_management)) as "sm",
max(decode(tbs.def_tab_compression,
'DISABLED', null,
'ENABLED', 'E',
tbs.def_tab_compression)) as "tc",
max(decode(tbs.retention,
'NOT APPLY', null,
'GUARANTEE', 'G',
'NOGUARANTEE', 'NG',
tbs.retention)) as "ret",
max(decode(tbs.bigfile,
'NO', null,
tbs.bigfile)) as "big",
max(decode(tbs.predicate_evaluation,
'HOST', null,
'STORAGE', 'S',
tbs.predicate_evaluation)) as "pe",
max(decode(tbs.encrypted,
'NO', null,
tbs.encrypted)) as "enc",
max(tbs.compress_for) as "comp",
max(decode(tbs.def_inmemory,
'DISABLED', null,
'ENABLED', 'Y',
tbs.def_inmemory)) as "im"),
xmlagg(
xmlelement(
"df",
xmlattributes(
decode(fi.status,
'AVAILABLE', null,
fi.status) as "st",
fi.autoextensible as "ae",
round(
decode(fi.maxbytes,
34359721984, null,
fi.maxbytes/1024)) as "mkb",
round(fi.bytes/1024) as "kb",
round(fi.free_bytes/1024) as "fkb",
fi.increment_by as "ib",
fi.user_bytes/1024 as "ukb",
decode(fi.online_status,
'ONLINE', null,
'OFFLINE', 'O',
fi.online_status) as "os"),
fi.file_name) order by fi.relative_fno))
order
by tbs.tablespace_name))
from dba_tablespaces tbs,
(select fi0.tablespace_name, fi0.file_name, fi0.relative_fno,
fi0.bytes, fi0.status,
fi0.autoextensible, fi0.maxbytes, fi0.increment_by,
fi0.user_bytes, fi0.online_status,
nvl(fs.free_bytes,
nvl((fi0.bytes - fs.used_bytes), fi0.user_bytes)) free_bytes
from
(select df.tablespace_name, df.relative_fno, df.file_name,
df.bytes, df.status, df.autoextensible, df.maxbytes,
df.increment_by, df.user_bytes, df.online_status
from dba_data_files df
where df.tablespace_name = nvl(:b_tbs_name, df.tablespace_name)
union all
select tf.tablespace_name, tf.relative_fno, tf.file_name,
tf.bytes, tf.status, tf.autoextensible,
tf.maxbytes, tf.increment_by, tf.user_byt
es,
null online_status
from dba_temp_files tf
where tf.tablespace_name =
nvl(:b_tbs_name, tf.tablespace_name)) fi0,
(select dfs.tablespace_name, dfs.relative_fno,
sum(dfs.bytes) free_bytes,
NULL used_bytes
from dba_free_space dfs
where dfs.tablespace_name = nvl(:b_tbs_name, dfs.tablespace_name)
group by dfs.tablespace_name, dfs.relative_fno
union all
select min(ss.tablespace_name) tablespace_name,
(select min(RFILE#)
from v$tempfile tmpf
where tmpf.ts# = ss.ts#) relative_fno,
NULL free_bytes,
sum(ss.used_blocks) *
(select min(block_size)
from v$tempfile tmpf2
where tmpf2.ts# = ss.ts#) used_bytes
from v$sort_segment ss
where ss.tablespace_name = nvl(:b_tbs_name, ss.tablespace_name)
group by ss.ts#) fs
where fi0.tablespace_name = fs.tablespace_name(+)
and fi0.relative_fno = fs.relative_fno(+)) fi
where tbs.tablespace_name = fi.tablespace_name
and tbs.tablespace_name = nvl(:b_tbs_name, tbs.tablespace_name)
group by tbs.tablespace_name
|
| 3dbzmtf9ahvzt |
merge /* KSXM:OPTIM_DML_INF */ into sys.mon_mods_all$ m using dual on (m.obj# = :objn and (:pobjn = 0 or m.obj# = :pobjn or m.obj# in (select obj# from tabpart$ where bo# = :pobjn and obj# = :objn union all select obj# from tabcompart$ where bo# = :pobjn and obj# = :objn union all select ts
p.obj# from tabsubpart$ tsp, tabcompart$ tcp where tsp.pobj# = tcp.obj# and (tcp.bo# = :pobjn or tcp.obj# = :pobjn) and tsp.obj# = :objn))) when matched then update set inserts = decode(:reset, 1, 0, inserts) + :ins, updates = decode(:reset, 1, 0, updates) + :upd, deletes = decode(:reset, 1, 0, deletes) + :del, flags = decode(:reset, 1, 0, flags - bitand(flags, :flag)) + :flag, drop_segments = decode(:reset, 1, 0, drop_segments) + :dropseg, timestamp = :time when NOT matched then
insert (obj#, inserts, updates, deletes, timestamp, flags, drop_segments) values (:objn, :ins, :upd, :del, :time, :flag, :dropseg) where :ins != 0 or :upd != 0 or :del != 0 or :flag != 0 or :dropseg !=0 |
| 3kqrku32p6sfn |
MERGE /*+ OPT_PARAM('_parallel_syspls_obey_force' 'false') */ INTO OPTSTAT_USER_PREFS$ D USING ( SELECT * FROM (SELECT O.OBJ#, SYSTIMESTAMP CHGTIME, ROUND(MAX(S.DELTA_READ_IO_BYTES/S.DELTA_TIME), 3) SCANRATE FROM GV$ACTIVE_SESSION_HISTORY S, GV$SQL_PLAN P, OBJ$ O, USER$ U WHERE S.INST_ID = P.INST_ID AND S.SQL_ID = P.SQL_ID AND S.SQL_PLAN_HASH_VALUE = P.PLAN_HASH_VALUE AND S.SQL_PLAN_LINE_ID = P.ID AND P.OBJECT_NAME = O.NAME AND (:B4 IS NULL OR O.OBJ# = :B4 ) AND O.OWNER# = U.USER# AND P.OBJECT_OWNER = U.NAME AND O.TYPE# = 2 AND S.CON_ID = SYS_CONTEXT('userenv', 'con_id') AND P.CON_ID = SYS_CONTEXT('userenv', 'con_id') AND S.SQL_PLAN_OPERATION = 'TABLE ACCESS' AND P.OPERATION = 'TABLE ACCESS' AND S.DELTA_TIME > 0 AND S.DELTA_READ_IO_BYTES > 0 AND FROM_TZ(S.SAMPLE_TIME, :B3 ) > :B2 AND (:B1 = 'ON' OR (:B1 = 'HADOOP_ONLY' AND EXISTS ( SELECT NULL FROM SYS.EXTERNAL_TAB$ ET WHERE ET.OBJ# = O.OBJ# AND TYPE$ IN ('ORACLE_HIVE', 'ORACLE_HDFS', 'ORACLE_BIGDATA')))) GROUP BY O
.OBJ#) C WHERE NOT EXISTS (SELECT NULL FROM OPTSTAT_USER_PREFS$ PR WHERE PNAME = 'SCAN_RATE' AND C.OBJ# = PR.OBJ# AND (PR.SPARE1 IS NULL OR C.SCANRATE <= TO_NUMBER(PR.VALCHAR))) ) SRC ON (D.OBJ#=SRC.OBJ# AND D.PNAME = 'SCAN_RATE') WHEN MATCHED THEN UPDATE SET D.VALCHAR= TO_CHAR(SRC.SCANRATE), D.CHGTIME=SRC.CHGTIME, D.SPARE1=1 WHEN NOT MATCHED THEN INSERT (OBJ#, PNAME, VALCHAR, CHGTIME, SPARE1) VALUES(SRC.OBJ#, 'SCAN_RATE', TO_CHAR(SRC.SCANRATE), SRC.CHGTIME, 1) |
| 3ms7w0c6ph91t | insert /* KSXM:FLUSH COL */ into sys.col_usage$ (obj#, intcol#, equality_preds, equijoin_preds, nonequijoin_preds, range_preds, like_preds, null_preds, flags, timestamp) values ( :objn, :coln, decode(bitand(:flag, 1), 0, 0, 1), decode(bitand(:flag, 2), 0, 0, 1), decode(bitand(:flag, 4), 0, 0, 1), decode(bitand(:flag, 8), 0, 0, 1), decode(bitand(:flag, 16), 0, 0, 1), decode(bitand(:flag, 32), 0, 0, 1), :flag, :time) |
| 3wdfx2m4ufsaa |
insert into wrh$_tablespace_stat (dbid, per_pdb, con_dbid, snap_id, instance_number, ts#, tsname, contents, status, segment_space_management, extent_management, is_backup ) select :dbid, 0 per_pdb, :srcdbid con_dbid, :snap_id, :instance_number, ts.ts#, ts.name as tsname, decode(ts.contents$, 0, (decode(bitand(ts.flags, 16), 16, 'UNDO', 'PERMANENT')), 1, 'TEMPORARY') as contents, decode(ts.online$, 1, 'ONLINE', 2, 'OFFLINE', 4, 'READ ONLY', 'UNDEFINED') as status, decode(bitand(ts.flags, 32), 32, 'AUTO', 'MANUAL') as segspace_mgmt, decode(ts.bitmapped, 0, 'DICTIONARY', 'LOCAL') as extent_management, (case when b.active_count > 0 then 'TRUE' else 'FALSE' end) as is_backup from sys.ts$ ts, (select dfile.ts#, sum( case when bkup.status = 'ACTIVE' then 1 else 0 end ) as active_count
from v$backup bkup, file$ dfile where bkup.file# = dfile.file# and dfile.status$ = 2 group by dfile.ts#) b where ts.online$ != 3 and bitand(ts.flags, 2048) != 2048 and ts.ts# = b.ts# |
| 3wxdxn3a3t0tm |
SELECT MIN(LOW_SCN) FROM (SELECT AL.FIRST_CHANGE# LOW_SCN FROM V$ARCHIVED_LOG AL, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT :B1 RESETLOGS_TIME, :B2 RESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE AL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND AL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D2.NEXT_RESETLOGS_CHANGE# IS NULL OR (AL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND AL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND AL.FIRST_CHANGE# > :B4 AND AL.DELETED = 'NO' AND AL.ARCHIVED = 'YES' AND AL.STANDBY_DEST = 'NO' AND (:B3 IN ('DISK', 'ANY')) UNION ALL SELECT BRL.FIRST_CHANGE# LOW_SCN FROM V$BACKUP_REDOLOG BRL, V$BACKUP_PIECE BP, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START
WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT :B1 RESETLOGS_TIME, :B2 RESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE BRL.SET_STAMP = BP.SET_STAMP AND BRL.SET_COUNT = BP.SET_COUNT AND BRL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND BRL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D2.NEXT_RESETLOGS_CHANGE# IS NULL OR (BRL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND BRL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND BRL.FIRST_CHANGE# > :B4 AND BP.DELETED = 'NO' AND ((:B3 = 'DISK' AND BP.DEVICE_TYPE = 'DISK') OR (:B3 = 'SBT' AND BP.DEVICE_TYPE = 'SBT_TAPE') OR :B3 = 'ANY') UNION ALL SELECT XAL.FIRST_CHANGE# LOW_SCN FROM V$PROXY_ARCHIVEDLOG XAL, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT
:B1 RESETLOGS_TIME, :B2 RESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE XAL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND XAL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D2.NEXT_RESETLOGS_CHANGE# IS NULL OR (XAL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND XAL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND XAL.FIRST_CHANGE# > :B4 AND XAL.DELETED = 'NO' AND (:B3 IN ('SBT', 'ANY'))) |
| 3zz0h6cr4wbyw |
select /*jskqjobqlod1*/ /*+ no_monitor no_statement_queuing */ /**/ CON_ID, OBJOID, CLSOID, RUNTIME, PRI, JOBTYPE, /**/ SCHLIM, WT, INST, RUNNOW, ENQ_SCHLIM from ( /**/ select nvl(a.con_id, 0) CON_ID, a.obj# OBJOID, a.class_oid CLSOID, /**/ decode(bitand(a.flags, 16384), 0, a.next_run_date, /**/ a.last_enabled_time) RUNTIME, /**/ (2*a.priority + /**/ decode(bitand(a.job_status, 4), 0, 0, /**/ decode(a.running_instance, :1, -1, 1))) PRI, /**/ 1 JOBTYPE, /**/ decode(a.schedule_limit, NULL, /**/ decode(bitand(a.flags, 4194304), 4194304, p.schedule_limit, NULL), /**/ a.schedule_limit) SCHLIM, /**/ a.job_weight WT,
/**/ decode(a.running_instance, NULL, 0, a.running_instance) INST, /**/ decode(bitand(a.flags, 16384), 0, 0, 1) RUNNOW, /**/ decode(bitand(a.job_status, 8388608), 0, 0, 1) ENQ_SCHLIM /**/ from sys.scheduler$_cdb_job a, sys.scheduler$_cdb_class b, /**/ sys.scheduler$_cdb_program p /**/ where a.program_oid = p.obj#(+) /**/ and a.class_oid = b.obj#(+) /**/ and bitand(a.job_status, 515) = 1 /**/ and bitand(a.flags, 1048576) = 0 /**/ and ((bitand(a.flags, 134217728 + 268435456) = 0) or /**/ (bitand(a.job_status, 1024) <> 0)) /**/ and bitand(a.flags, 4096) = 0 /**/ and (a.next_run_date <= :2
/**/ or bitand(a.flags, 16384) <> 0) /**/ and a.instance_id is null /**/ and (a.class_oid is null /**/ or (a.class_oid is not null /**/ and b.affinity is null and /**/ nvl(b.con_id, 0) = nvl(a.con_id, 0))) /**/ and (p.con_id is NULL or (nvl(a.con_id, 0) = nvl(p.con_id, 0))) /**/ and ( (a.database_role = :3) /**/ or (a.database_role = 'ALL') /**/ or (a.database_role is null and :4 = 'PRIMARY')) /**/ and (:5 <> 'ALL' or a.database_role = 'ALL') /**/ union all /**/ select nvl(l.con_id, 0), l.obj#, l.class_oid, /**/ decode(bitand(l.flags,
16384), 0, l.next_run_date, /**/ l.last_enabled_time), /**/ (2*decode(bitand(l.flags, 8589934592), 0, q.priority, pj.priority) + /**/ decode(bitand(l.job_status, 4), 0, 0, /**/ decode(l.running_instance, :6, -1, 1))), 1, /**/ decode(bitand(l.flags, 8589934592), 0, q.schedule_limit, /**/ decode(pj.schedule_limit, NULL, q.schedule_limit, pj.schedule_limit)), /**/ decode(bitand(l.flags, 8589934592), 0, q.job_weight, pj.job_weight), /**/ decode(l.running_instance, NULL, 0, l.running_instance), /**/ decode(bitand(l.flags, 16384), 0, 0, 1), /**/ decode(bitand(l.job_status, 8388608), 0, 0, 1) /**/ from sys.scheduler$_cdb_comb_lw_job l, sys.scheduler$_cdb_class w, /**/ sys.scheduler$_cdb_program q, /**/ (select nvl(sl.c
on_id, 0) con_id, sl.obj# obj#, /**/ decode(bitand(sl.flags, 8589934592), 0, sl.program_oid, /**/ spj.program_oid) program_oid, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.priority) priority, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.job_weight) job_weight, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.schedule_limit) schedule_limit /**/ from sys.scheduler$_cdb_comb_lw_job sl, scheduler$_cdb_job spj /**/ where sl.program_oid = spj.obj#(+) and /**/ (spj.con_id is NULL or (nvl(sl.con_id, 0) = nvl(spj.con_id, 0)))) pj /**/ where pj.obj# = l.obj# /**/ and l.class_oid = w.obj#(+)
/**/ and pj.program_oid = q.obj#(+) /**/ and (:7 = 0 or l.running_instance = :8) /**/ and bitand(l.job_status, 515) = 1 /**/ and ((bitand(l.flags, 134217728 + 268435456) = 0) or /**/ (bitand(l.job_status, 1024) <> 0)) /**/ and bitand(l.flags, 4096) = 0 /**/ and (l.next_run_date <= :9 /**/ or bitand(l.flags, 16384) <> 0) /**/ and l.instance_id is null /**/ and (l.class_oid is null /**/ or (l.class_oid is not null /**/ and w.affinity is null and /**/ nvl(w.con_id, 0) = nvl(l.con_id, 0))) /**/ and (pj.con_
id is NULL or (nvl(l.con_id, 0) = nvl(pj.con_id, 0))) /**/ and (q.con_id is NULL or (nvl(l.con_id, 0) = nvl(q.con_id, 0))) /**/ union all /**/ select nvl(c.con_id, 0), c.obj#, 0, c.next_start_date, 0, 2, c.duration, 1, 0, 0, 0 /**/ from sys.scheduler$_cdb_window c /**/ where bitand(c.flags, 1) <> 0 /**/ and bitand(c.flags, 2) = 0 /**/ and bitand(c.flags, 64) = 0 /**/ and c.next_start_date <= :10 /**/ union all /**/ select nvl(d.con_id, 0), d.obj#, 0, d.next_start_date + d.duration, /**/ 0, 4, numtodsinterval(0, 'minute'), 1, 0, 0, 0 /**/ from sys.scheduler$_cdb_window d /**/ where bitand(d.flags,
1) <> 0 /**/ and bitand(d.flags, 2) = 0 /**/ and bitand(d.flags, 64) = 0 /**/ and d.next_start_date <= :11 union all select nvl(f.con_id, 0), f.object_id, 0, e.attr_tstamp, 0, decode(bitand(e.flags, 131072), 0, 2, 3), e.attr_intv, 1, 0, 0, 0 from sys.scheduler$_cdb_global_attrib e, sys.cdb_objects f where (nvl(e.con_id, 0), e.obj#) in ((0, 19047)) and f.owner = 'SYS' and e.value = f.object_name and f.object_type = 'WINDOW' and e.attr_tstamp is not null and e.attr_intv is not null and nvl(e.con_id, 0) = nvl(f.con_id, 0) union all select nvl(i.con_id, 0), i.object_id, 0, h.attr_tstamp + h.attr_intv, 0, decode(bitand(h.flags, 131072), 0, 4, 5), numtodsinterval(0, 'minute'), 1, 0, 0, 0 from sys.scheduler$_cdb_global_attrib h, sys.cdb_o
bjects i where (nvl(h.con_id, 0), h.obj#) in ((0, 19047)) and i.owner = 'SYS' and h.value = i.object_name and i.object_type = 'WINDOW' and h.attr_tstamp is not null and h.attr_intv is not null and nvl(h.con_id, 0) = nvl(i.con_id, 0))/*jskqjobqlod1*/ /**/ order by RUNTIME, JOBTYPE, CLSOID, PRI, WT DESC, OBJOID |
| 42wvnhv3f6tj3 | insert into wrh$_sysmetric_history (dbid, per_pdb, con_dbid, snap_id, instance_number, begin_time, end_time, intsize, group_id, metric_id, value) select :dbid, 0 per_pdb, :srcdbid con_dbid, :snap_id, :instance_number, begtime, endtime, intsize_csec, groupid, metricid, value FROM x$kewmdrmv drmv WHERE (1 = 1) |
| 4d43by1zzjfna |
with last_run as
(
SELECT all_runs.OWNER,
all_runs.JOB_NAME,
all_runs.STATUS
FROM DBA_SCHEDULER_JOB_RUN_DETAILS all_runs,
(SELECT OWNER,
JOB_NAME,
MAX(ACTUAL_START_DATE) AS START_DATE
FROM DBA_SCHEDULER_JOB_RUN_DETAILS GROUP BY OWNER, JOB_NAME) latest_runs
WHERE all_runs.OWNER= latest_runs.OWNER
AND all_runs.JOB_NAME= latest_runs.JOB_NAME
AND all_runs.ACTUAL_START_DATE=latest_runs.START_DATE
)
SELECT SUM(broken), SUM(failed)
FROM (SELECT DECODE(broken, 'N', 0, 1) broken,
DECODE(NVL(failures, 0), 0, 0, 1) failed
FROM dba_jobs
UNION ALL
SELECT DECODE(STATE, 'BROKEN', 1, 0) broken,
DECODE(STATUS , 'FAILED', DECODE(STATE, 'BROKEN', 0, 'DISABLED', 0, 1), 0) failed
FROM (SELECT all_jobs.OWNER,
all_jobs.JOB_NAME,
last_run.STATUS,
all_jobs.STATE
FROM last_run,
DBA_SCHEDULER_JOBS all_jobs
WHERE last_run.OWNER=all_jobs.OWNER
AND last_run.JOB_NAME=all_jobs.JOB_NAME))
|
| 4hu1rrb1y1c97 | SELECT to_char(low_time, 'YYYY-MM-DD HH24:MI:SS') as last_complete_backup,
ROUND((high_time-low_time)*24*60*60, 2) as recovery_window,
ROUND((sysdate-high_time)*24*60*60, 2) as unprotected_data_window
FROM v$sbt_restore_range rr1
WHERE rr1.high_time = (SELECT max(rr2.high_time)
FROM v$sbt_restore_range rr2
WHERE rr1.db_id = rr2.db_id) |
| 5c24r2fm4b9rh |
SELECT /*jskqjobqlod2*/ /*+ no_monitor no_statement_queuing */ /**/ CON_ID, OBJOID, CLSOID, DECODE(BITAND(FLAGS, 16384), 0, RUNTIME, LETIME), /**/ (2*PRI + /**/ DECODE(BITAND(STATUS, 4), 0, 0, /**/ decode(INST, :1, -1, 1))), /**/ JOBTYPE, SCHLIM, WT, INST, RUNNOW, ENQ_SCHLIM, INST_ID /**/ FROM ( /**/ select nvl(a.con_id, 0) CON_ID, a.obj# OBJOID, a.class_oid CLSOID, a.next_run_date RUNTIME, /**/ a.last_enabled_time LETIME, a.flags FLAGS, a.job_status STATUS, /**/ 1 JOBTYPE, a.priority PRI, /**/ decode(a.schedule_limit, NULL, /**/ decode(bitand(a.flags, 4194304), 4194304, /**/
b.schedule_limit, NULL), /**/ a.schedule_limit) SCHLIM, /**/ a.job_weight WT, /**/ decode(a.running_instance, NULL, 0, a.running_instance) INST, /**/ decode(bitand(a.flags, 16384), 0, 0, 1) RUNNOW, /**/ decode(bitand(a.job_status, 8388608), 0, 0, 1) ENQ_SCHLIM, /**/ a.instance_id INST_ID /**/ from (select ta.con_id, ta.obj#, ta.class_oid, ta.next_run_date, ta.flags, /**/ ta.priority, ta.job_status, ta.instance_id, ta.running_instance, /**/ ta.job_weight, ta.schedule_limit, ta.last_enabled_time, /**/ ta.database_role, ta.program_oid /**/ from sys.scheduler$_cdb_job ta , sys.scheduler$_cdb_class e where /**/ (ta.next_run
_date <= :2 OR BITAND(ta.flags, 16384) <> 0) and /**/ ta.class_oid=e.obj#(+) and ((ta.class_oid is not null and ta.instance_id is null and /**/ (bitand(e.flags, :3) <> 0 and lower(e.affinity) = lower(:4) /**/ and nvl(e.con_id, 0) = nvl(ta.con_id, 0) and lower(e.affinity) not in /**/ (select name from cdb_service$ where bitand(flags, 128) = 128)) /**/ ) or ta.instance_id is not null and ta.instance_id = :5 ) /**/ ) a, /**/ sys.scheduler$_cdb_program b /**/ where a.program_oid = b.obj#(+) /**/ and (b.con_id is NULL or (nvl(a.con_id, 0) = nvl(b.con_id, 0))) /**/ and ( (a.database_role = :6) /**/ or (a.database_role = 'ALL') /**/ or (a.database_role
is null and :7 = 'PRIMARY') ) /**/ and (:8 <> 'ALL' or a.database_role = 'ALL') /**/ union all /**/ select nvl(c.con_id, 0), c.obj#, c.class_oid, c.next_run_date, /**/ c.last_enabled_time, c.flags, c.job_status, 1, /**/ decode(bitand(c.flags, 8589934592), 0, d.priority, pj.priority), /**/ decode(bitand(c.flags, 8589934592), 0, d.schedule_limit, /**/ decode(pj.schedule_limit, NULL, d.schedule_limit, /**/ pj.schedule_limit)), /**/ decode(bitand(c.flags, 8589934592), 0, d.job_weight, pj.job_weight), /**/ decode(c.running_instance, NULL, 0, c.running_instance), /**/ decode(bitand(c.flags, 16384), 0, 0, 1) RUNNOW, /**/ decode(bitand(c.job_stat
us, 8388608), 0, 0, 1) ENQ_SCHLIM, /**/ c.instance_id INST_ID /**/ from sys.scheduler$_cdb_comb_lw_job c, sys.scheduler$_cdb_program d, /**/ (select nvl(sl.con_id, 0) con_id, sl.obj# obj#, /**/ decode(bitand(sl.flags, 8589934592), 0, sl.program_oid, /**/ spj.program_oid) program_oid, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.priority) priority, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.job_weight) job_weight, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.schedule_limit) schedule_limit /**/ from (select ta.con_id, ta.obj#, ta.class_oid,
ta.next_run_date, ta.flags, /**/ ta.job_status, ta.instance_id, ta.running_instance, /**/ ta.last_enabled_time, ta.program_oid /**/ from sys.scheduler$_cdb_comb_lw_job ta, sys.scheduler$_cdb_class e /**/ where (ta.next_run_date <= :9 OR BITAND(ta.flags, 16384) <> 0) and /**/ ta.class_oid=e.obj#(+) and ((ta.class_oid is not null and ta.instance_id is null and /**/ (bitand(e.flags, :10) <> 0 and lower(e.affinity) = lower(:11) and /**/ nvl(e.con_id, 0) = nvl(ta.con_id, 0) and lower(e.affinity) not in /**/ (select name from cdb_service$ where bitand(flags, 128) = 128)) /**/ ) or ta.instance_id is not null and ta.instance_id = :12 ) /**/ ) sl, /**/ scheduler$_cdb_job spj /**/ where sl.program_oid = spj.obj#(+) and
/**/ (spj.con_id is NULL or (nvl(sl.con_id, 0) = nvl(spj.con_id, 0)))) pj /**/ where pj.obj# = c.obj# /**/ and pj.program_oid = d.obj#(+) /**/ and (pj.con_id is NULL or (nvl(c.con_id, 0) = nvl(pj.con_id, 0))) /**/ and (d.con_id is NULL or (nvl(c.con_id, 0) = nvl(d.con_id, 0))) /**/ and (:13 = 0 or c.running_instance = :14)) m /**/ WHERE BITAND(STATUS, 515) = 1 /**/ AND BITAND(FLAGS, 1048576) = 0 /**/ AND ((BITAND(FLAGS, 134217728 + 268435456) = 0) OR /**/ (BITAND(STATUS, 1024) <> 0)) /**/ AND BITAND(FLAGS, 4096) = 0 /**/ ORDER BY 4, 3, 5, 8 DESC, 2
|
| 5j7xryzqzqcbk |
SELECT /*jskqjobqlod3*//*+ no_monitor no_statement_queuing */ /**/ CON_ID, OBJOID, CLSOID, /**/ DECODE(BITAND(FLAGS, 16384), 0, RUNTIME, /**/ LETIME), /**/ (2*PRI + /**/ DECODE(BITAND(STATUS, 4), 0, 0, /**/ decode(INST, :1, -1, 1))), /**/ JOBTYPE, SCHLIM, WT, INST, RUNNOW, ENQ_SCHLIM, INST_ID, SRVNAME /**/ FROM ( /**/ select nvl(a.con_id, 0) CON_ID, a.obj# OBJOID, a.class_oid CLSOID, a.next_run_date RUNTIME, /**/ a.last_enabled_time LETIME, a.flags FLAGS, a.job_status STATUS, /**/ 1 JOBTYPE, a.priority PRI, /**/
decode(a.schedule_limit, NULL, /**/ decode(bitand(a.flags, 4194304), 4194304, /**/ b.schedule_limit, NULL), /**/ a.schedule_limit) SCHLIM, /**/ a.job_weight WT, /**/ decode(a.running_instance, NULL, 0, a.running_instance) INST, /**/ decode(bitand(a.flags, 16384), 0, 0, 1) RUNNOW, /**/ decode(bitand(a.job_status, 8388608), 0, 0, 1) ENQ_SCHLIM, /**/ a.instance_id INST_ID , a.affinity SRVNAME /**/ from (select ta.con_id, ta.obj#, ta.class_oid, ta.next_run_date, ta.flags, /**/ ta.priority, ta.job_status, ta.instance_id, ta.running_instance, /**/ ta.job_weight, ta.schedule_limit, ta.last_enabled_time, /**/ ta.database
_role, ta.program_oid, e.affinity /**/ from sys.scheduler$_cdb_job ta, sys.scheduler$_cdb_class e where /**/ (ta.next_run_date <= :2 OR BITAND(ta.flags, 16384) <> 0) and /**/ ta.class_oid=e.obj#(+) and ((ta.class_oid is not null and ta.instance_id is null and /**/ (bitand(e.flags, :3) <> 0 and /**/ (lower(e.affinity) = lower(:4) or lower(e.affinity) in /**/ (select name from cdb_service$ where bitand(flags, 128) = 128)) /**/ and nvl(e.con_id, 0) = nvl(ta.con_id, 0) ) /**/ ) or ta.instance_id is not null and ta.instance_id = :5 ) /**/ ) a, /**/ sys.scheduler$_cdb_program b /**/ where a.program_oid = b.obj#(+) /**/ and (b.con_id is NULL or
(nvl(a.con_id, 0) = nvl(b.con_id, 0))) /**/ and ( (a.database_role = :6) /**/ or (a.database_role = 'ALL') /**/ or (a.database_role is null and :7 = 'PRIMARY') ) /**/ and (:8 <> 'ALL' or a.database_role = 'ALL') /**/ union all /**/ select nvl(c.con_id, 0), c.obj#, c.class_oid, c.next_run_date, /**/ c.last_enabled_time, c.flags, c.job_status, 1, /**/ decode(bitand(c.flags, 8589934592), 0, d.priority, pj.priority), /**/ decode(bitand(c.flags, 8589934592), 0, d.schedule_limit, /**/ decode(pj.schedule_limit, NULL, d.schedule_limit, /**/ pj.schedule_limit)), /**/ decode(bitand(c.flags, 8589934592), 0,
d.job_weight, pj.job_weight), /**/ decode(c.running_instance, NULL, 0, c.running_instance), /**/ decode(bitand(c.flags, 16384), 0, 0, 1) RUNNOW, /**/ decode(bitand(c.job_status, 8388608), 0, 0, 1) ENQ_SCHLIM, /**/ c.instance_id INST_ID, pj.affinity /**/ from sys.scheduler$_cdb_comb_lw_job c, sys.scheduler$_cdb_program d, /**/ (select nvl(sl.con_id, 0) con_id, sl.obj# obj#, /**/ decode(bitand(sl.flags, 8589934592), 0, sl.program_oid, /**/ spj.program_oid) program_oid, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.priority) priority, /**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.job_weight) job_weight,
/**/ decode(bitand(sl.flags, 8589934592), 0, NULL, /**/ spj.schedule_limit) schedule_limit, sl.affinity /**/ from (select ta.con_id, ta.obj#, ta.class_oid, ta.next_run_date, ta.flags, /**/ ta.job_status, ta.instance_id, ta.running_instance, /**/ ta.last_enabled_time, ta.program_oid , e.affinity /**/ from sys.scheduler$_cdb_comb_lw_job ta, sys.scheduler$_cdb_class e where /**/ (ta.next_run_date <= :9 OR BITAND(ta.flags, 16384) <> 0) and /**/ ta.class_oid=e.obj#(+) and ((ta.class_oid is not null and ta.instance_id is null and /**/ (bitand(e.flags, :10) <> 0 and /**/ (lower(e.affinity) = lower(:11) or lower(e.affinity) in /**/ (select name from cdb_service$ where bitand(flags, 128) = 128)) /**/ and nvl(e.con_id, 0) = nvl(ta.con_id, 0)
) /**/ ) or ta.instance_id is not null and ta.instance_id = :12 ) /**/ ) sl, /**/ scheduler$_cdb_job spj /**/ where sl.program_oid = spj.obj#(+) and /**/ (spj.con_id is NULL or (nvl(sl.con_id, 0) = nvl(spj.con_id, 0)))) pj /**/ where pj.obj# = c.obj# /**/ and pj.program_oid = d.obj#(+) /**/ and (pj.con_id is NULL or (nvl(c.con_id, 0) = nvl(pj.con_id, 0))) /**/ and (d.con_id is NULL or (nvl(c.con_id, 0) = nvl(d.con_id, 0))) /**/ and (:13 = 0 or c.running_instance = :14)) m /**/ WHERE BITAND(STATUS, 515) = 1 /**/ AND BITAND(FLAGS, 1048576) = 0 /**/ AND ((
BITAND(FLAGS, 134217728 + 268435456) = 0) OR /**/ (BITAND(STATUS, 1024) <> 0)) /**/ AND BITAND(FLAGS, 4096) = 0 /**/ ORDER BY 4, 3, 5, 8 DESC, 2 |
| 5k5207588w9ry | SELECT DBMS_REPORT.GET_REPORT(:B1 ) FROM DUAL |
| 5mt72u2h7tack | SELECT SUM("A1"."VOLIN"+"A1"."VOLOUT"), "A1"."POSTPRE", "A1"."MSISDN", SYSDATE@!-2, SYSDATE@!-92, SYSDATE@!-2 FROM "MOBILE_DATA" "A1" WHERE "A1"."TIME_TRUNC">=SYSDATE@!-92 AND "A1"."TIME_TRUNC"<=SYSDATE@!-2 GROUP BY "A1"."POSTPRE", "A1"."MSISDN" |
| 5pj6mtazkhmdd | BEGIN /* KSXM:FLUSH DML_MON */ dbms_stats_internal.gather_scan_rate_by_mmon; END; |
| 5qdptu5gnkayq |
SELECT m.tablespace_name,
ROUND(m.used_percent, 2),
ROUND((m.tablespace_size - m.used_space)*t.block_size/1024/1024, 3) mb_free
FROM dba_tablespace_usage_metrics m, dba_tablespaces t, v$parameter p
WHERE p.name='statistics_level' and p.value!='BASIC'
AND t.contents NOT IN ('TEMPORARY', 'UNDO')
AND t.tablespace_name = m.tablespace_name
|
| 657ywpfpygruv |
WITH binds as
(select :dbid as dbid
, :inst_id_low as instIdLow
, :inst_id_high as instIdHigh
, :begin_snap as beginSnap
, :end_snap as endSnap
, :begin_time as beginTime
, :end_time as endTime
, :disk_begin_time as diskBeginTime
, :disk_end_time as diskEndTime
, :mem_begin_time as memBeginTime
, :mem_end_time as memEndTime
, :bucket_count as bucketCount
, :bucket_interval as bucketInterval
, :mem_enable as memEnable
, :disk_enable as diskEnable
, :disk_filter_ratio as filterRatio, :filter_action as filter_action, :filter_blocking_session as filter_blocking_session, :filter_capture_id
as filter_capture_id, :filter_client_id as filter_client_id, :filter_consumer_group_id as filter_consumer_group_id, :filter_dbop as filter_dbop, :filter_ecid as filter_ecid, :filter_event as filter_event, :filter_instance_number as filter_instance_number, :filter_is_captured as filter_is_captured, :filter_is_filtered_out as filter_is_filtered_out, :filter_is_nc_background as filter_is_nc_background, :filter_is_replayed as filter_is_replayed, :filter_machine as filter_machine, :filter_machine_port as filter_machine_port, :filter_module as filter_module, :filter_object as filter_object, :filter_pdb as filter_pdb, :filter_physical_session as filter_physical_session, :filter_pl_sql as filter_pl_sql, :filter_pl_sql_top as filter_pl_sql_top, :filter_program as filter_program, :filter_px_process as filter_px_process, :filter_service_hash as filter_service_hash, :filter_session_type as filter_session_type, :filter_sql_fms as filter_sql_fms, :filter_sql_id_top as filter
_sql_id_top, :filter_sql_opcode as filter_sql_opcode, :filter_sql_opcode_top as filter_sql_opcode_top, :filter_sql_rws as filter_sql_rws, :filter_sql_rws_line as filter_sql_rws_line, :filter_sqlid as filter_sqlid, :filter_sqlid_fullphv as filter_sqlid_fullphv, :filter_sqlid_phv as filter_sqlid_phv, :filter_user_id as filter_user_id, :filter_wait_class as filter_wait_class, :filter_xid as filter_xid from dual) , unified_ash as
(SELECT a.sample_id
, a.sample_time
, a.session_id
, a.session_serial#
, a.session_type
, a.session_state
, a.flags
, a.user_id
, a.sql_id
, a.sql_opcode
, a.sql_opname
, a.top_level_sql_id
, a.top_level_sql_opcode
, a.sql_child_number
, a.sql_plan_hash_value
, a.sql_full_plan_hash_value
, a.sql_plan_line_id
, a.sql_plan_operation
, a.sql_plan_options
, a.sql_exec_id
, a.force_
matching_signature
, a.plsql_entry_object_id
, a.plsql_entry_subprogram_id
, a.plsql_object_id
, a.plsql_subprogram_id
, a.service_hash
, a.qc_session_id
, a.qc_instance_id
, a.qc_session_serial#
, nvl(a.event,
CASE WHEN bitand(a.time_model, power(2, 19)) > 0
THEN 'CPU: IM Populate'
WHEN bitand(a.time_model, power(2, 20)) > 0
THEN 'CPU: IM Prepopulate'
WHEN bitand(a.time_model, power(2, 21)) > 0
THEN 'CPU: IM Repopulate'
WHEN bitand(a.time_model, power(2, 22)) > 0
THEN 'CPU: IM Trickle Repop'
WHEN bitand(a.time_model, power(2, 18)) > 0
THEN 'CPU: IM Query'
ELSE 'CPU + Wait for CPU' END) as event
, nvl(a.event_id, 1)
as event_id
, nvl(a.wait_class, 'CPU')
as wait_class
, nvl(a.wait_class_id, 9999)
as wait_class_id
, a.seq#
, a.p1
, a.p1text
, a.p2
, a.p2text
, a.p3
, a.p3text
, a.wait_time
, a.time_waited
, rawtohex(a.xid) as xid
, a.blocking_session
, a.blocking_session_serial#
, a.blocking_session_status
, a.blocking_inst_id
, a.current_obj#
, a.current_file#
, a.current_block#
, a.top_level_call#
, a.top_level_call_name
, a.program
, a.module
, a.action
, a.client_id
, a.remote_instance#
, a.ecid
, a.consumer_group_id
, a.machine
, a.port
, a.in_connection_mgmt
, a.in_parse
, a.in_hard_parse
, a.in_sql_execution
, a.in_plsql_execution
, a.in_plsql_rpc
, a.in_plsql_compilation
, a.in_java_execution
, a.in_bind
, a.in_cursor_close
, a.in_sequence_load
, a.is_captured
, a.is_replayed
, a.dbreplay_file_id
, a.dbop_name
, a.con_dbid, decode(binds.diskEnable, 0, 1, binds.filterRatio)
as sample_count
, inst_id as instance_number
FROM gv$active_session_history a, binds
WHERE binds.memEnable = 1
AND ( binds.diskEnable = 0
OR ( binds.diskEnable = 1
AND a.is_awr_sample = 'Y'
AND bitand(a.flags, 128) = 0 ) )
AND a.inst_id between
binds.instIdLow
and binds.instIdHigh
AND a.sample_time between
binds.beginTime
and binds.endTime
UNION ALL
SELECT a.sample_id
, a.sample_time
, a.session_id
, a.
session_serial#
, a.session_type
, a.session_state
, a.flags
, a.user_id
, a.sql_id
, a.sql_opcode
, a.sql_opname
, a.top_level_sql_id
, a.top_level_sql_opcode
, a.sql_child_number
, a.sql_plan_hash_value
, a.sql_full_plan_hash_value
, a.sql_plan_line_id
, a.sql_plan_operation
, a.sql_plan_options
, a.sql_exec_id
, a.force_matching_signature
, a.plsql_entry_object_id
, a.plsql_entry_subprogram_id
, a.plsql_object_id
, a.plsql_subprogram_id
, a.service_hash
, a.qc_session_id
, a.qc_instance_id
, a.qc_session_serial#
, nvl(a.event,
CASE WHEN bitand(a.time_model, power(2, 19)) > 0
THEN 'CPU: IM Populate'
WHEN bitand(a.time_model, power(2, 20)) > 0
THEN 'CPU: IM Prepopulate'
WHEN bitand(a
.time_model, power(2, 21)) > 0
THEN 'CPU: IM Repopulate'
WHEN bitand(a.time_model, power(2, 22)) > 0
THEN 'CPU: IM Trickle Repop'
WHEN bitand(a.time_model, power(2, 18)) > 0
THEN 'CPU: IM Query'
ELSE 'CPU + Wait for CPU' END) as event
, nvl(a.event_id, 1)
as event_id
, nvl(a.wait_class, 'CPU')
as wait_class
, nvl(a.wait_class_id, 9999)
as wait_class_id
, a.seq#
, a.p1
, a.p1text
, a.p2
, a.p2text
, a.p3
, a.p3text
, a.wait_time
, a.time_waited
, rawtohex(a.xid) as xid
, a.blocking_session
, a.blocking_session_serial#
, a.blocking_session_status
, a.blocking_inst_id
, a.current_obj#
, a.current_file#
, a.current_block#
, a.top_level_call#
, a.top_level_call_name
, a.program
, a.module
, a.action
, a.client_id
, a.remote_instance#
, a.ecid
, a.consumer_group_id
, a.machine
, a.port
, a.in_connection_mgmt
, a.in_parse
, a.in_hard_parse
, a.in_sql_execution
, a.in_plsql_execution
, a.in_plsql_rpc
, a.in_plsql_compilation
, a.in_java_execution
, a.in_bind
, a.in_cursor_close
, a.in_sequence_load
, a.is_captured
, a.is_replayed
, a.dbreplay_file_id
, a.dbop_name
, a.con_dbid, binds.filterRatio as sample_count
, instance_number as instance_number
FROM AWR_ROOT_active_sess_history a,
binds
WHERE binds.diskEnable = 1
AND a.dbid = binds.dbid
AND a.instance_number between
binds.instId
Low
and binds.instIdHigh
AND a.snap_id between
binds.beginSnap
and binds.endSnap + 1
AND a.sample_time between
binds.beginTime
and binds.endTime
), logical_ash as
(select sample_id
, sample_time
, sample_count
, instance_number as inst_id, wait_class as global_hist_wc, event as event, instance_number || ':' || session_id || ', ' || session_serial# as physical_session, sql_id as sqlid, wait_class as wait_class, xid as xid, instance_number as instance_number, user_id as user_id, program as program from unified_ash) , bucketized_ash as
(SELECT ash0.*,
(case when binds.bucketCount > 1
then trunc( ( (24 * 60 * 60 *
extract(day from sample_time
- binds.beginTime))
+ (60 * 60 *
extract(hour from sample_time
- binds.beginTime))
+ (60 *
extract(minute from sample_time
- binds.beginTime))
+ (1 *
extract(second from sample_time
- binds.beginTime))
) / binds.bucketInterval
) + 1
else 1
end) as bucket_number
FROM logical_ash ash0, binds), filter_xml as
(SELECT xmlconcat(xmlelement("filters" )
, xmlelement("report_t
ime", xmlattributes(
to_char(o.begintime, 'HH24:MI:SS MM/DD/YYYY') as "begin_time",
to_char(o.endtime, 'HH24:MI:SS MM/DD/YYYY') as "end_time"))) as xml_frag FROM
(select binds.*, nvl(to_number(filter_pdb), 0) as con_dbid from binds) o) , filtered_ash as
(SELECT ash.*,
(case when 1=1 then 1 else 0 end) filtered
FROM bucketized_ash ash, binds), grouped_ash as
(SELECT ash.*, (CASE WHEN nvl(filtered, 2) = 1
THEN 0 -- target / no histogram
ELSE 1 -- totals/global
END) AS bucket_type FROM (SELECT filtered, event, physical_session, sqlid, wait_class, bucket_number , grouping_id(filtered, event, physical_session, sqlid, wait_class, bucket_number) as gid , global_hist_wc , max(inst_id) as inst_id
, sum(sample_count) as sample_count
, count(distinct sqlid) as uniq_sqlids
, count(distinct xid) as uniq_xids
, count(distinct physical_session)
as uniq_sessions
, count(distinct instance_number)
as uniq_instances, max(user_id) as user_id, max(program) as program from filtered_ash
group by grouping sets( (bucket_number, global_hist_wc) , ( bucket_number, wait_class, filtered), (wait_class, filtered), (sqlid, wait_class, filtered), (physical_session, wait_class, filtered), (wait_class, event, filtered)) ) ash -- eliminate rows with filtered = 0
-- keep filtered and from global/total
WHERE (nvl(filtered, 2) != 0)), component_1_treemap as
(s
elect dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
from (select max(case when mem_rank <= 13
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 13
then mem_rank
else (13
+ 1)
end) as mem_rank
, max(case when mem_rank <= 13
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 13
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 13
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 13
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select wait_class as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, wait_class) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 29
and wait_class is not null)
group by (case when mem_rank <= 13
then dim_val
else null
end)
) left ) , component_1_histogram as
(select bucket_number
, sum(sample_count) as sample_count
, max(case when mem_rank <= 13
then mem_rank
when mem_rank is not null
then (13 + 1)
end) as mem_rank
, bucket_type
from (select g1.bucket_number
, g1.sample_count as sample_count
, (case when g1.wait_class = g2.dim_val
then to_char(g2.dim_val)
-- global/totals
when g1.buck
et_type = 1
then g1.global_hist_wc
else null
end) as dim_val
, (case when g1.wait_class = g2.dim_val
then g2.mem_rank
when g1.bucket_type = 1 then NULL
else (13 + 1)
end) as mem_rank
, g1.bucket_type
from grouped_ash g1,
component_1_treemap g2
where -- both filtered and global
(g1.gid = 28 AND
g1.wait_class is not null OR
g1.bucket_type = 1)
and g1.wait_class = g2.dim_val(+)
-- join filtered rows only
and g1.bucket_type = g2.bucket_type(+)
)
group by bucket_number
, dim_val
, bucket_type
) , component_1_xml as
(select xmlelement("item"
, xmlattributes('wait_class' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , xmlconcat(
topmems.topmems_frag
, histogram.histogram_xml)) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 13
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_session
s"
, uniq_instances as "uniq_instances")
)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 13
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 13
then 0
else num_mem
end) as num_others
from (component_1_treemap) t
) topmems , (SELECT xmlagg(
xmlelement(
"histogram"
, xmlattributes(
(case when bucket_type = 1 then 'all'
else 'target'
end) AS "type"
, max(binds.bucketCount) as "bucket_count"
, max(binds.bucketInterval) as "bucket_interval")
, xmlagg(bucket_xml
order by
bucket_type,
bucket_number asc)
)
) as histogram_xml
FROM (SELECT bucket_type
, bucket_number
, xmlelement(
"bucket"
, xmlattributes(bucket_number as "number"
, su
m(sample_count) as "count")
, (case
when bucket_type = 0 then -- filtered rows
xmlelement(
"top_mems"
, xmlattributes(
sum(case when mem_rank <= 13
then sample_count
else 0
end) as "count")
, xmlagg(
xmlelement(
"mem"
, xmlattributes(
mem_rank as "id"
, sample_count as "count"))
order by mem_rank asc))
end)) as bucket_xml
FROM (component_1_histogram)
GROUP BY bucket_number, bucket_type), binds
GROUP by bucket_type) histogram ), component_2_xml as
(select xmlelement(
"item"
, xmlattributes(
'sqlid, wait_class' as "item")
, xmlelement(
"top_mems"
, xmlagg(
xmlelement(
"mem"
, xmlattributes(
dim1_value as "dim1_value"
, dim1_nummem as "dim1_nummem"
, dim1_rank as "dim1_rank"
,
dim2_value as "dim2_value"
, dim12_nummem as "dim2_nummem"
, dim12_rank as "dim2_rank"
, dim12_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances"
)
, NVL2(sql_text1,
xmlelement("info"
, xmlattributes('dim1_name' as "type")
, sql_text1), NULL)
, NVL2(NULL,
xmlelement("info"
, xmlattributes('dim2_name' as "type")
, NULL), NULL)
)
order by dim1_rank, dim12_rank
)
)
) as dim_frag
from
(select dim_data.*
, NVL((SELECT replace(substr(v.sql_text, 1, 100), CHR(0), '') as sql_text
FROM gv$sql v
WHERE v.sql_id = dim_data.dim1_value
AND v.inst_id = dim_data.inst_id
AND rownum < 2 ), ( SELECT replace(dbms_lob.substr(v.sql_text, 100, 1), CHR(0), '')
as sql_text
FROM AWR_ROOT_sqltext v, binds b
WHERE v.dbid = b.dbid
AND v.sql_id = dim_data.dim1_value
AND rownum < 2)) as sql_text1
from (select
max(case when dim1_rank <= 10
then dim1_val
else null
end) as dim1_value
, max(case when dim1_rank <= 10
then dim2_val
else null
end) as dim2_value
, sum(dim12_count) as dim12_count
, max(case when dim1_rank <= 10
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when dim1_rank <= 10
then uniq
_xids
else 0
end) as uniq_xids
, max(case when dim1_rank <= 10
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim1_rank <= 10
then uniq_instances
else 0
end) as uniq_instances
, count(distinct dim1_val) as dim1_nummem
, sum(dim12_nummem) as dim12_nummem
, max(case when dim1_rank <= 10
then dim1_rank
else (10 + 1)
end)
as dim1_rank
, max(case when dim1_rank <= 10
then dim12_rank
else (10 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select dim1_val
, max(case when dim12_rank <= 13
then dim2_val
else null
end) as dim2_val
, dim1_count
, sum(dim12_count) as dim12_count
, max(case when dim12_rank <= 13
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when dim12_rank <= 13
then uniq_xids
else 0
end) as uniq_xids
, max(case when dim12_rank <= 13
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim12_rank <= 13
then uniq_instances
else 0
end) as uniq_instances
, count(*) as dim12_nummem
, dense_rank() over
(order by dim1_count desc
, dim1_val
) as dim1_rank
, max(case when dim12_rank <= 13
then dim12_rank
else (13 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select sqlid as dim1_val
, wait_class as dim2_val
, sample_count as dim12_count
, dense_rank() over
(partition by sqlid
order by
sample_count desc
, wait_class
) as dim12_rank
, sum(sample_count) over
(partition by sqlid
) as dim1_count
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 25
and sqlid is not nu
ll
and wait_class is not null )
group by dim1_val
, dim1_count
, (case when dim12_rank <= 13
then dim2_val
else null
end)
)
group by (case when dim1_rank <= 10
then dim1_val
else null
end)
, (case when dim1_rank <= 10
then dim2_val
else null
end)
) dim_data
) t
), component_3_xml as
(select xmlelement(
"item"
, xmlattributes(
'physical_session, wait_class' as "item")
, xmlelement(
"top_mems"
, xmlagg(
xmlelement(
"mem"
, xmlattributes(
dim1_value as "dim1_value"
, dim1_nummem as "dim1_nummem"
, dim1_rank as "dim1_rank"
, dim2_value as "dim2_value"
, dim12_nummem as "dim2_nummem"
, dim12_rank as "dim2_rank"
, dim12_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances"
)
, NVL2(NULL,
xmlelement("info"
, xmlattributes('dim1_name' as "type")
, NULL), NULL)
, NVL2(NULL,
xmlelement("info"
, xmlattributes('dim2_name' as "type")
, NULL),
NULL)
)
order by dim1_rank, dim12_rank
)
)
) as dim_frag
from
(select dim_data.*
from (select
max(case when dim1_rank <= 10
then dim1_val
else null
end) as dim1_value
, max(case when dim1_rank <= 10
then dim2_val
else null
end) as dim2_value
, sum(dim12_count) as dim12_count
, max(case when dim1_rank <= 10
then uniq_sqli
ds
else 0
end) as uniq_sqlids
, max(case when dim1_rank <= 10
then uniq_xids
else 0
end) as uniq_xids
, max(case when dim1_rank <= 10
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim1_rank <= 10
then uniq_instances
else 0
end) as uniq_instances
, count(distinct dim1_val) as dim1_nummem
, sum(dim12_nummem) as dim12_nu
mmem
, max(case when dim1_rank <= 10
then dim1_rank
else (10 + 1)
end) as dim1_rank
, max(case when dim1_rank <= 10
then dim12_rank
else (10 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select dim1_val
, max(case when dim12_rank <= 13
then dim2_val
else null
end) as dim2_val
, dim1_count
, sum(dim12_count)
as dim12_count
, max(case when dim12_rank <= 13
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when dim12_rank <= 13
then uniq_xids
else 0
end) as uniq_xids
, max(case when dim12_rank <= 13
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim12_rank <= 13
then uniq_instances
else 0
end) as uniq_instances
, count(*) as dim12_nummem
, dense_rank() over
(order by dim1_count desc
, dim1_val
) as dim1_rank
, max(case when dim12_rank <= 13
then dim12_rank
else (13 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select physical_session as dim1_val
, wait_class as dim2_val
, sample_count as dim12_count
, dense_rank() over
(partition by physical_session
order by sample_count desc
, wait_class
) as dim12_rank
, sum(sample_count) over
(partition by physical_session
) as dim1_count
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 21
and physical_session is not null
and wait_class is not null )
group by dim1_val
, dim1_count
, (case when dim12_rank <= 13
then dim2_val
else null
end)
)
group by (case when dim1_rank <= 10
then dim1_val
else null
end)
, (case when dim1_rank <= 10
then dim2_val
else null
end)
) dim_data
) t
), component_4_xml as
(select xmlelement(
"item"
, xmlattributes(
'wait_class, event' as "item")
, xmlelement(
"top_mems"
, xmlagg(
xmlelement(
"mem"
, xmlattributes(
dim1_value as "dim1_value"
, dim1_nummem as "dim1_nummem"
, dim1_rank as "dim1_rank"
, dim2_value as "dim2_value"
, dim12_nummem as "dim2_nummem"
, dim12_rank as "dim2_rank"
, dim12_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances"
)
, NVL2(NULL,
xmlelement("info"
, xmlattributes('dim1_name' as "type")
,
NULL), NULL)
, NVL2(NULL,
xmlelement("info"
, xmlattributes('dim2_name' as "type")
, NULL), NULL)
)
order by dim1_rank, dim12_rank
)
)
) as dim_frag
from
(select dim_data.*
from (select
max(case when dim1_rank <= 13
then dim1_val
else null
end) as dim1_value
, max(case when dim1_rank <= 13
then dim2_val
else null
end) as dim2_value
, sum(dim12_count) as dim12_count
, max(case when dim1_rank <= 13
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when dim1_rank <= 13
then uniq_xids
else 0
end) as uniq_xids
, max(case when dim1_rank <= 13
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim1_rank <= 13
then uniq_instances
else 0
end) as uniq_instances
, count(distinct dim1_val) as dim1_nummem
, sum(dim12_nummem) as dim12_nummem
, max(case when dim1_rank <= 13
then dim1_rank
else (13 + 1)
end) as dim1_rank
, max(case when dim1_rank <= 13
then dim12_rank
else (13 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select dim1_val
, max(case when dim12_rank <= 10
then dim2_val
else null
end) as dim2_val
, dim1_count
, sum(dim12_count) as dim12_count
, max(case when dim12_rank <= 10
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when dim12_rank <= 10
then uniq_xids
else 0
end) as uniq_xids
, max(case when dim12_rank <= 10
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when dim12_rank <= 10
then uniq_instances
else 0
end) as uniq_instances
, count(*) as dim12_nummem
, dense_rank() over
(order by dim1_count desc
, dim1_val
) as dim1_rank
, max(case when dim12_rank <= 10
then dim12_rank
else (10 + 1)
end) as dim12_rank
, max(inst_id) as inst_id
from (select wait_class as dim1_val
, event as dim2_val
, sample_count as dim12_count
, dense_rank() over
(partition by wait_class
order by sample_count desc
, event
) as dim12_rank
, sum(sample_count) over
(partition by wait_class
) as dim1_count
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 13
and wait_class is not null
and event is not null )
group by dim1_val
, dim1_count
, (case when dim12_rank <= 10
then dim2_val
else null
end)
)
gr
oup by (case when dim1_rank <= 13
then dim1_val
else null
end)
, (case when dim1_rank <= 13
then dim2_val
else null
end)
) dim_data
) t
)select xmlconcat((select xml_frag from filter_xml),
xmlelement("dim_list",
xmlconcat((select dim_frag from component_1_xml), (select dim_frag from component_2_xml), (select dim_frag from component_3_xml), (select dim_frag from component_4_xml)))
) from dual |
| 69k5bhm12sz98 |
SELECT dbin.instance_number, dbin.db_name, dbin.instance_name, dbin.host_name, dbin.version, CASE WHEN s1.startup_time = s2.startup_time THEN 0 ELSE 1 END as bounce, CAST(s1.end_interval_time AS DATE) as begin_time, CAST(s2.end_interval_time AS DATE) as end_time, ROUND((cast( (case when s2.end_interval_time > s1.end_interval_time then s2.end_interval_time else s1.end_interval_time end) as date) - cast(s1.end_interval_time as date)) * 86400) as int_secs, CASE WHEN (s1.status <> 0 OR s2.status <> 0) THEN 1 ELSE 0 END as err_detect, round( greatest( (extract(day from s2.flush_elapsed) * 86400) + (extract(hour from s2.flush_elapsed) * 3600) + (extract(minute from s2.flush_elapsed) * 60) + extract(second from s2.flush_elapsed), (extract(day from s1.flush_elapsed) *
86400) + (extract(hour from s1.flush_elapsed) * 3600) + (extract(minute from s1.flush_elapsed) * 60) + extract(second from s1.flush_elapsed), 0 )) as max_flush_secs FROM WRM$_SNAPSHOT s1 , WRM$_DATABASE_INSTANCE dbin , WRM$_SNAPSHOT s2 WHERE s1.dbid = :dbid AND s2.dbid = :dbid AND s1.instance_number = s2.instance_number AND dbin.instance_number = s1.instance_number AND s1.snap_id = :bid AND s2.snap_id = :eid AND dbin.dbid = s1.dbid AND dbin.startup_time = s1.startup_time and dbin.instance_number = :inst |
| 6hnhqahphpk8n | select free_mb from v$asm_diskgroup_stat where name=:1 |
| 6xvp6nxs4a9n4 | select nvl(sum(space), 0) from recyclebin$ where ts# = :1 |
| 72c9db35xdv5d |
SELECT /*+ordered*/ FENUM DFNUMBER, FECRC_SCN DFCREATIONSCN, TO_DATE(FECRC_TIM, 'MM/DD/RR HH24:MI:SS', 'NLS_CALENDAR=Gregorian') DFCREATIONTIME, FN.FNNAM FILENAME, TS.TSNAM TSNAME, FE.FETSN TSNUMBER, NULL STATUS, FECSZ BLOCKS, FEBSZ BLOCKSIZE, FECSZ * FEBSZ / 1024 KBYTES, NULL UNRECOVSCN, TO_NUMBER(FE.FESTS) STOPSCN, :B3 READONLY, FERFN RFNUMBER, DECODE(BITAND(TS.TSFLG, 2), 2, 0, 1) INBACKUP, DECODE(FE.FEPAX, 0 , NULL, 65535, NULL, FNAUX.FNNAM) AUXNAME, TO_NUMBER(NULL) DBINCKEY, TO_NUMBER(FEOFS) DFOFFLINESCN, TO_NUMBER(FEONC_SCN) DFONLINESCN, TO_DATE(NVL(FE.FEONC_TIM, '01/01/88 00:01:01'), 'MM/DD/RR HH24:MI:SS', 'NLS_CALENDAR=Gregorian') DFONLINETIME, DECODE(BITAND(TS.TSFLG, 16+32), 16, 1, 32, 2, 3) ENCRYPT, FE.FEPDI FOREIGNDBID, FE.FEFDB PLUGGEDRONLY, FE.FEPLUS PLUGINSCN, FE.FEPRLS PLUGINRLGSCN, FE.FEPRLT PLUGINRLGTIME, DECODE(FE.FEPLUS, 0, TO_NUMBER(FE.FECRC_SCN), FE.FEPLUS) NEWDFCREATIONSCN, FE.FECRC_THR CREATION_THREAD, FE.FECSZ CR
EATION_SIZE, FE.CON_ID PDBID, FE.CON_ID PDBKEY, NULL PDBNAME, CASE WHEN FE.CON_ID > 1 THEN DECODE(BITAND(FE.FESTA, (4096+128)), 0, 0, DECODE(FE.FECPS, FE1.PDBSTOPSCN, 1, 0)) ELSE 0 END PDBCLOSED, FE.FEPFDI PDBFOREIGNDBID, DECODE(BITAND(PDB.PDBFLG, 4096), 4096, 1, 0) NOBACKUPPDB FROM X$KCCTS TS, X$KCCFE FE LEFT OUTER JOIN X$KCCPDB PDB ON PDB.CON_ID > 1 AND (PDB.PDBSTA != 3 OR BITAND(PDB.PDBFLG, 8192)=8192) AND PDB.PDBCRS > 0 AND FE.CON_ID = PDB.CON_ID LEFT OUTER JOIN X$KCCFN FNAUX ON FNAUX.FNTYP = 22 AND FE.FEPAX=FNAUX.FNNUM, X$KCCFN FN, (SELECT FE.CON_ID, MIN(DECODE(BITAND(FE.FESTA, (4096+128)), 0, 0, FE.FECPS)) PDBSTOPSCN FROM X$KCCFE FE WHERE FE.FETSN = 0 AND FE.FEDUP != 0 AND (FE.FEFDB = 0 OR FE.FEPRLS != 0) GROUP BY FE.CON_ID) FE1 WHERE FE.FETSI=TS.TSRNO AND FE.CON_ID = TS.CON_ID AND FE.CON_ID = FE1.CON_ID AND FN.FNFNO=FE.FENUM AND FE.FEFNH=FN.FNNUM AND FN.FNTYP=4 AND FN.FNNAM IS NOT NULL AND BITAND(FN.FNFLG, 4) != 4 AND (:B2 = :B1 OR FE.FEFDB =
0) AND (FE.FEFDB = 0 OR FE.FEPRLS != 0) UNION SELECT DISTINCT DCDFP DFNUMBER, DCCRS DFCREATIONSCN, TO_DATE(DCCRT, 'MM/DD/RR HH24:MI:SS', 'NLS_CALENDAR=Gregorian') DFCREATIONTIME, TO_CHAR(NULL) FILENAME, TO_CHAR(NULL) TSNAME, TO_NUMBER(NULL) TSNUMBER, TO_NUMBER(NULL) STATUS, DCBCT BLOCKS, DCBSZ BLOCKSIZE, DCBCT * DCBSZ / 1024 KBYTES, TO_NUMBER(NULL) UNRECOVSCN, TO_NUMBER(DCAFS) STOPSCN, :B3 READONLY, DCRFN RFNUMBER, 1 INBACKUP, TO_CHAR(NULL) AUXNAME, TO_NUMBER(NULL) DBINCKEY, TO_NUMBER(NULL) DFOFFLINESCN, TO_NUMBER(NULL) DFONLINESCN, TO_DATE(NULL) DFONLINETIME, 3 ENCRYPT, DCFDI FOREIGNDBID, DECODE(BITAND(DCFLG, 16384), 0, 0, 1) PLUGGEDRONLY, DCPLUS PLUGINSCN, DCPRLS PLUGINRLGSCN, DCPRLT PLUGINRLGTIME, DECODE(DCPLUS, 0, TO_NUMBER(DCCRS), DCPLUS) NEWDFCREATIONSCN, TO_NUMBER(NULL) CREATION_THREAD, TO_NUMBER(NULL) CREATION_SIZE, DC.CON_ID PDBID, DC.CON_ID PDBKEY, SUBSTR(PDB.PDBDBN, 1, PDB.PDBNLN) PDBNAME, 0 PDBCLOSED, 0 PDBFOREIGNDBID, DECODE(BIT
AND(PDB.PDBFLG, 4096), 4096, 1, 0) NOBACKUPPDB FROM X$KCCDC DC LEFT OUTER JOIN X$KCCPDB PDB ON PDB.CON_ID > 1 AND (PDB.PDBSTA != 3 OR BITAND(PDB.PDBFLG, 8192)=8192) AND PDB.PDBCRS > 0 AND DC.CON_ID = PDB.CON_ID WHERE DCDFP <> 0 AND (:B2 = :B1 OR BITAND(DCFLG, 16384) = 0) UNION SELECT DISTINCT BFDFP DFNUMBER, BFCRS DFCREATIONSCN, TO_DATE(BFCRT, 'MM/DD/RR HH24:MI:SS', 'NLS_CALENDAR=Gregorian') DFCREATIONTIME, TO_CHAR(NULL) FILENAME, TO_CHAR(NULL) TSNAME, TO_NUMBER(NULL) TSNUMBER, TO_NUMBER(NULL) STATUS, BFBCT BLOCKS, BFBSZ BLOCKSIZE, BFBCT * BFBSZ / 1024 KBYTES, TO_NUMBER(NULL) UNRECOVSCN, TO_NUMBER(BFAFS) STOPSCN, :B3 READONLY, 0 RFNUMBER, 1 INBACKUP, TO_CHAR(NULL) AUXNAME, TO_NUMBER(NULL) DBINCKEY, TO_NUMBER(NULL) DFOFFLINESCN, TO_NUMBER(NULL) DFONLINESCN, TO_DATE(NULL) DFONLINETIME, 3 ENCRYPT, BFFDI FOREIGNDBID, DECODE(BITAND(BFFLG, 32), 0, 0, 1) PLUGGEDRONLY, BFPLUS PLUGINSCN, BFPRLS PLUGINRLGSCN, BFPRLT PLUGINRLGTIME, DECODE(BFPLUS,
0, TO_NUMBER(BFCRS), BFPLUS) NEWDFCREATIONSCN, TO_NUMBER(NULL) CREATION_THREAD, TO_NUMBER(NULL) CREATION_SIZE, BF.CON_ID PDBID, BF.CON_ID PDBKEY, SUBSTR(PDB.PDBDBN, 1, PDB.PDBNLN) PDBNAME, 0 PDBCLOSED, 0 PDBFOREIGNDBID, DECODE(BITAND(PDB.PDBFLG, 4096), 4096, 1, 0) NOBACKUPPDB FROM X$KCCBF BF LEFT OUTER JOIN X$KCCPDB PDB ON PDB.CON_ID > 1 AND (PDB.PDBSTA != 3 OR BITAND(PDB.PDBFLG, 8192)=8192) AND PDB.PDBCRS > 0 AND BF.CON_ID = PDB.CON_ID WHERE BFDFP <> 0 AND (:B2 = :B1 OR BITAND(BFFLG, 32) = 0) UNION SELECT DISTINCT PDDFP DFNUMBER, PDCRS DFCREATIONSCN, TO_DATE(PDCRT, 'MM/DD/RR HH24:MI:SS', 'NLS_CALENDAR=Gregorian') DFCREATIONTIME, TO_CHAR(NULL) FILENAME, TO_CHAR(NULL) TSNAME, TO_NUMBER(NULL) TSNUMBER, TO_NUMBER(NULL) STATUS, PDFSZ BLOCKS, PDBSZ BLOCKSIZE, PDFSZ * PDBSZ / 1024 KBYTES, TO_NUMBER(NULL) UNRECOVSCN, TO_NUMBER(PDAFS) STOPSCN, :B3 READONLY, 0 RFNUMBER, 1 INBACKUP, TO_CHAR(NULL) AUXNAME, TO_NUMBER(NULL) DBINCKEY, TO_NUMBER(NULL)
DFOFFLINESCN, TO_NUMBER(NULL) DFONLINESCN, TO_DATE(NULL) DFONLINETIME, 3 ENCRYPT, PCFDI FOREIGNDBID, DECODE(BITAND(PDFLG, 16), 0, 0, 1) PLUGGEDRONLY, PCPLUS PLUGINSCN, PCPRLS PLUGINRLGSCN, PCPRLT PLUGINRLGTIME, DECODE(PCPLUS, 0, TO_NUMBER(PDCRS), PCPLUS) NEWDFCREATIONSCN, TO_NUMBER(NULL) CREATION_THREAD, TO_NUMBER(NULL) CREATION_SIZE, PD.CON_ID PDBID, PD.CON_ID PDBKEY, SUBSTR(PDB.PDBDBN, 1, PDB.PDBNLN) PDBNAME, 0 PDBCLOSED, 0 PDBFOREIGNDBID, DECODE(BITAND(PDB.PDBFLG, 4096), 4096, 1, 0) NOBACKUPPDB FROM X$KCCPD PD LEFT OUTER JOIN X$KCCPDB PDB ON PDB.CON_ID > 1 AND (PDB.PDBSTA != 3 OR BITAND(PDB.PDBFLG, 8192)=8192) AND PDB.PDBCRS > 0 AND PD.CON_ID = PDB.CON_ID WHERE PDDFP <> 0 AND (:B2 = :B1 OR BITAND(PDFLG, 16) = 0) ORDER BY DFNUMBER, NEWDFCREATIONSCN DESC, FILENAME |
| 8fgdzmkchnn1a |
INSERT /*+ APPEND LEADING(@"SEL$F5BB74E1" "H"@"SEL$2" "A"@"SEL$1") USE_NL(@"SEL$F5BB74E1" "A"@"SEL$1") */ INTO WRH$_ACTIVE_SESSION_HISTORY ( snap_id, dbid, instance_number , sample_id, sample_time, sample_time_utc, usecs_per_row , session_id, session_serial#, session_type , flags , user_id , sql_id, sql_child_number, sql_opcode, force_matching_signature , top_level_sql_id, top_level_sql_opcode , sql_plan_hash_value, sql_full_plan_hash_value , sql_adaptive_plan_resolved , sql_plan_line_id , sql_plan_operation#, sql_plan_options# , sql_exec_id, sql_exec_start , plsql_entry_object_id, plsql_entry_subprogram_id , plsql_object_id, plsql_subprogram_id , qc_instance_id, qc_session_id, qc_session_serial#, px_flags , event_id, seq#, p1, p2, p3 , wait_time, time_waited , blocking_session, blocking_session_serial#, blocking_inst_id , current_obj#, current_f
ile#, current_block#, current_row# , top_level_call#, consumer_group_id, xid, remote_instance#, time_model , service_hash, program, module, action, client_id, machine, port, ecid , dbreplay_file_id, dbreplay_call_counter , con_dbid, per_pdb , tm_delta_time, tm_delta_cpu_time, tm_delta_db_time, delta_time, delta_read_io_requests, delta_write_io_requests, delta_read_io_bytes, delta_write_io_bytes, delta_interconnect_io_bytes, pga_allocated, temp_space_allocated , dbop_name, dbop_exec_id ) (SELECT /*+ PARAM('_module_action_old_length', 0) */:snap_id, :dbid, :instance_number , a.sample_id, a.sample_time, a.sample_time_utc , a.usecs_per_row * :disk_filter_ratio , a.session_id, a.session_serial#, a.session_type , decode(a.flags, 0, to_number(NULL), a.flags) , a.user_id , a.sql_id, a.sql_child_number, a.sql_opcode, a.force_matching_signature , a.top_level_sql_id, a.top_level_sql_opcode , a.sql_plan_hash_value, a.sql_full_plan_hash_value
, a.sql_adaptive_plan_resolved , a.sql_plan_line_id , a.sql_plan_operation#, a.sql_plan_options# , a.sql_exec_id, a.sql_exec_start , a.plsql_entry_object_id, a.plsql_entry_subprogram_id , a.plsql_object_id, a.plsql_subprogram_id , a.qc_instance_id, a.qc_session_id, a.qc_session_serial#, a.px_flags , a.event_id, a.seq#, a.p1, a.p2, a.p3 , a.wait_time, a.time_waited , a.blocking_session, a.blocking_session_serial#, a.blocking_inst_id , a.current_obj#, a.current_file#, a.current_block#, a.current_row# , a.top_level_call#, a.consumer_group_id, a.xid, a.remote_instance# , a.time_model , a.service_hash , substrb(a.program, 1, 64) , a.module, a.action, a.client_id, a.machine, a.port, a.ecid , a.dbreplay_file_id, a.dbreplay_call_counter , a.con_dbid, a.con_id , decode(a.tm_delta_time, 0, to_number(null), a.tm_delta_time), decode(a.tm_delta_time, 0, to_number(null), a.tm_delta_cpu_time), decode(a.tm_delta_time, 0, to_number(null),
a.tm_delta_db_time), decode(a.delta_time, 0, to_number(null), a.delta_time), decode(a.delta_time, 0, to_number(null), decode(a.delta_read_io_requests, 0, to_number(null), a.delta_read_io_requests)), decode(a.delta_time, 0, to_number(null), decode(a.delta_write_io_requests, 0, to_number(null), a.delta_write_io_requests)), decode(a.delta_time, 0, to_number(null), decode(a.delta_read_io_bytes, 0, to_number(null), a.delta_read_io_bytes)), decode(a.delta_time, 0, to_number(null), decode(a.delta_write_io_bytes, 0, to_number(null), a.delta_write_io_bytes)), decode(a.delta_time, 0, to_number(null), decode(a.delta_interconnect_io_bytes, 0, to_number(null), a.delta_interconnect_io_bytes)), decode(a.pga_allocated, 0, to_number(null), a.pga_allocated), decode(a.pga_allocated, 0, to_number(null), decode(a.temp
_space_allocated, 0, to_number(null), a.temp_space_allocated)) , a.dbop_name, a.dbop_exec_id FROM x$ash a, (SELECT h.sample_addr, h.sample_id FROM x$kewash h WHERE ( (h.sample_id >= :begin_flushing) and (h.sample_id < :latest_sample_id) ) and (nlssort(h.is_awr_sample, 'nls_sort=BINARY') = nlssort('Y', 'nls_sort=BINARY')) ) shdr WHERE (1 = 1) and shdr.sample_addr = a.sample_addr and shdr.sample_id = a.sample_id and nlssort(a.need_awr_sample, 'nls_sort=BINARY') = nlssort('Y', 'nls_sort=BINARY')) |
| 8mdz49zkajhw3 |
SELECT /*+ OPT_PARAM('_fix_control' '16391176:1') */ GROUP_TYPE, BUCKET_START, BUCKET_END, TM_GROUP_TYPE, TM_BUCKET_START, TM_BUCKET_END, SUM(TM_CPU_FIRST_BUCKET_VALUE) TM_CPU_FIRST_BUCKET_VALUE, SUM(TM_CPU_MIDDLE_BUCKETS_VALUE) TM_CPU_MIDDLE_BUCKETS_VALUE, SUM(TM_CPU_LAST_BUCKET_VALUE) TM_CPU_LAST_BUCKET_VALUE, SUM(TM_DB_FIRST_BUCKET_VALUE) TM_DB_FIRST_BUCKET_VALUE, SUM(TM_DB_MIDDLE_BUCKETS_VALUE) TM_DB_MIDDLE_BUCKETS_VALUE, SUM(TM_DB_LAST_BUCKET_VALUE) TM_DB_LAST_BUCKET_VALUE, SUM(RREQS_FIRST_BUCKET_VALUE) RREQS_FIRST_BUCKET_VALUE, SUM(RREQS_MIDDLE_BUCKETS_VALUE) RREQS_MIDDLE_BUCKETS_VALUE, SUM(RREQS_LAST_BUCKET_VALUE) RREQS_LAST_BUCKET_VALUE, SUM(WREQS_FIRST_BUCKET_VALUE) WREQS_FIRST_BUCKET_VALUE, SUM(WREQS_MIDDLE_BUCKETS_VALUE) WREQS_MIDDLE_BUCKETS_VALUE, SUM(WREQS_LAST_BUCKET_VALUE) WREQS_LAST_BUCKET_VALUE, SUM(RBYTES_FIRST_BUCKET_VALUE) RBYTES_FIRST_BUCKET_VALUE, SUM(RBYTES_MIDDLE_BUCKETS_VALUE) RBYTES_MIDDLE_BUCKETS_VALUE, SUM(RBYTES_LAST_BUCKET_VALUE) RBYTES
_LAST_BUCKET_VALUE, SUM(WBYTES_FIRST_BUCKET_VALUE) WBYTES_FIRST_BUCKET_VALUE, SUM(WBYTES_MIDDLE_BUCKETS_VALUE) WBYTES_MIDDLE_BUCKETS_VALUE, SUM(WBYTES_LAST_BUCKET_VALUE) WBYTES_LAST_BUCKET_VALUE, SUM(IBYTES_FIRST_BUCKET_VALUE) IBYTES_FIRST_BUCKET_VALUE, SUM(IBYTES_MIDDLE_BUCKETS_VALUE) IBYTES_MIDDLE_BUCKETS_VALUE, SUM(IBYTES_LAST_BUCKET_VALUE) IBYTES_LAST_BUCKET_VALUE, SUM(CRBYTES_FIRST_BUCKET_VALUE) CRBYTES_FIRST_BUCKET_VALUE, SUM(CRBYTES_MIDDLE_BUCKETS_VALUE) CRBYTES_MIDDLE_BUCKETS_VALUE, SUM(CRBYTES_LAST_BUCKET_VALUE) CRBYTES_LAST_BUCKET_VALUE, SUM(PGA_ALLOC_FIRST_BUCKET_VALUE) PGA_ALLOC_FIRST_BUCKET_VALUE, SUM(PGA_ALLOC_MIDDLE_BUCKETS_VALUE) PGA_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(PGA_ALLOC_LAST_BUCKET_VALUE) PGA_ALLOC_LAST_BUCKET_VALUE, SUM(TMP_ALLOC_FIRST_BUCKET_VALUE) TMP_ALLOC_FIRST_BUCKET_VALUE, SUM(TMP_ALLOC_MIDDLE_BUCKETS_VALUE) TMP_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(TMP_ALLOC_LAST_BUCKET_VALUE) TMP_ALLOC_LAST_BUCKET_VALUE FROM ( SELECT GROUP_TYPE, BUCKET_START, TM
_BUCKET_START, TM_BUCKET_END, BUCKET_END, TM_GROUP_TYPE, SUM(GVTF.TM_CPU_FIRST_BUCKET_VALUE) TM_CPU_FIRST_BUCKET_VALUE, SUM(GVTF.TM_CPU_MIDDLE_BUCKETS_VALUE) TM_CPU_MIDDLE_BUCKETS_VALUE, SUM(GVTF.TM_CPU_LAST_BUCKET_VALUE) TM_CPU_LAST_BUCKET_VALUE, SUM(GVTF.TM_DB_FIRST_BUCKET_VALUE) TM_DB_FIRST_BUCKET_VALUE, SUM(GVTF.TM_DB_MIDDLE_BUCKETS_VALUE) TM_DB_MIDDLE_BUCKETS_VALUE, SUM(GVTF.TM_DB_LAST_BUCKET_VALUE) TM_DB_LAST_BUCKET_VALUE, SUM(GVTF.RREQS_FIRST_BUCKET_VALUE) RREQS_FIRST_BUCKET_VALUE, SUM(GVTF.RREQS_MIDDLE_BUCKETS_VALUE) RREQS_MIDDLE_BUCKETS_VALUE, SUM(GVTF.RREQS_LAST_BUCKET_VALUE) RREQS_LAST_BUCKET_VALUE, SUM(GVTF.WREQS_FIRST_BUCKET_VALUE) WREQS_FIRST_BUCKET_VALUE, SUM(GVTF.WREQS_MIDDLE_BUCKETS_VALUE) WREQS_MIDDLE_BUCKETS_VALUE, SUM(GVTF.WREQS_LAST_BUCKET_VALUE) WREQS_LAST_BUCKET_VALUE, SUM(GVTF.RBYTES_FIRST_BUCKET_VALUE) RBYTES_FIRST_BUCKET_VALUE, SUM(GVTF.RBYTES_MIDDLE_BUCKETS_VALUE) RBYTES_MIDDLE_BUCKETS_VALUE, SUM(GVTF.RBYTES_LAST_BUCKET_VALUE) RBYTES_LAST_BU
CKET_VALUE, SUM(GVTF.WBYTES_FIRST_BUCKET_VALUE) WBYTES_FIRST_BUCKET_VALUE, SUM(GVTF.WBYTES_MIDDLE_BUCKETS_VALUE) WBYTES_MIDDLE_BUCKETS_VALUE, SUM(GVTF.WBYTES_LAST_BUCKET_VALUE) WBYTES_LAST_BUCKET_VALUE, SUM(GVTF.IBYTES_FIRST_BUCKET_VALUE) IBYTES_FIRST_BUCKET_VALUE, SUM(GVTF.IBYTES_MIDDLE_BUCKETS_VALUE) IBYTES_MIDDLE_BUCKETS_VALUE, SUM(GVTF.IBYTES_LAST_BUCKET_VALUE) IBYTES_LAST_BUCKET_VALUE, SUM(GVTF.CRBYTES_FIRST_BUCKET_VALUE) CRBYTES_FIRST_BUCKET_VALUE, SUM(GVTF.CRBYTES_MIDDLE_BUCKETS_VALUE) CRBYTES_MIDDLE_BUCKETS_VALUE, SUM(GVTF.CRBYTES_LAST_BUCKET_VALUE) CRBYTES_LAST_BUCKET_VALUE, SUM(GVTF.PGA_ALLOC_FIRST_BUCKET_VALUE) PGA_ALLOC_FIRST_BUCKET_VALUE, SUM(GVTF.PGA_ALLOC_MIDDLE_BUCKETS_VALUE) PGA_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(GVTF.PGA_ALLOC_LAST_BUCKET_VALUE) PGA_ALLOC_LAST_BUCKET_VALUE, SUM(GVTF.TMP_ALLOC_FIRST_BUCKET_VALUE) TMP_ALLOC_FIRST_BUCKET_VALUE, SUM(GVTF.TMP_ALLOC_MIDDLE_BUCKETS_VALUE) TMP_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(GVTF.TMP_ALLOC_LAST_BUCKET_VALUE) TMP_A
LLOC_LAST_BUCKET_VALUE FROM TABLE(SYS.GV$(CURSOR( SELECT INST_ID, GROUP_TYPE, BUCKET_START, TM_BUCKET_START, TM_BUCKET_END, BUCKET_END, TM_GROUP_TYPE, SUM(TM_DELTA_CPU_TIME * TM_FIRST_BUCKET_RATIO) TM_CPU_FIRST_BUCKET_VALUE, SUM(TM_DELTA_CPU_TIME * TM_MIDDLE_BUCKETS_RATIO) TM_CPU_MIDDLE_BUCKETS_VALUE, SUM(TM_DELTA_CPU_TIME * TM_LAST_BUCKET_RATIO) TM_CPU_LAST_BUCKET_VALUE, SUM(TM_DELTA_DB_TIME * TM_FIRST_BUCKET_RATIO) TM_DB_FIRST_BUCKET_VALUE, SUM(TM_DELTA_DB_TIME * TM_MIDDLE_BUCKETS_RATIO) TM_DB_MIDDLE_BUCKETS_VALUE, SUM(TM_DELTA_DB_TIME * TM_LAST_BUCKET_RATIO) TM_DB_LAST_BUCKET_VALUE, SUM(DELTA_READ_REQUESTS * FIRST_BUCKET_RATIO) RREQS_FIRST_BUCKET_VALUE, SUM(DELTA_READ_REQUESTS * MIDDLE_BUCKETS_RATIO) RREQS_MIDDLE_BUCKETS_VALUE, SUM(DELTA_READ_REQUESTS * LAST_BUCKET_RATIO) RREQS_LAST_BUCKET_VALUE, SUM(DELTA_WRITE_REQUESTS * FIRST_BUCKET_RATIO) WREQS_FIRST_BUCKET_VALUE, SUM(DELTA_WRITE_REQUESTS * MIDDLE_BUCKETS_RATIO) WREQS_MIDDLE_BUCKETS_VALUE, SUM(DELTA_WRITE_REQUE
STS * LAST_BUCKET_RATIO) WREQS_LAST_BUCKET_VALUE, SUM(DELTA_READ_BYTES * FIRST_BUCKET_RATIO) RBYTES_FIRST_BUCKET_VALUE, SUM(DELTA_READ_BYTES * MIDDLE_BUCKETS_RATIO) RBYTES_MIDDLE_BUCKETS_VALUE, SUM(DELTA_READ_BYTES * LAST_BUCKET_RATIO) RBYTES_LAST_BUCKET_VALUE, SUM(DELTA_WRITE_BYTES * FIRST_BUCKET_RATIO) WBYTES_FIRST_BUCKET_VALUE, SUM(DELTA_WRITE_BYTES * MIDDLE_BUCKETS_RATIO) WBYTES_MIDDLE_BUCKETS_VALUE, SUM(DELTA_WRITE_BYTES * LAST_BUCKET_RATIO) WBYTES_LAST_BUCKET_VALUE, SUM(DELTA_INTERCONNECT_BYTES * FIRST_BUCKET_RATIO) IBYTES_FIRST_BUCKET_VALUE, SUM(DELTA_INTERCONNECT_BYTES * MIDDLE_BUCKETS_RATIO) IBYTES_MIDDLE_BUCKETS_VALUE, SUM(DELTA_INTERCONNECT_BYTES * LAST_BUCKET_RATIO) IBYTES_LAST_BUCKET_VALUE, SUM(DELTA_READ_MEM_BYTES * FIRST_BUCKET_RATIO) CRBYTES_FIRST_BUCKET_VALUE, SUM(DELTA_READ_MEM_BYTES * MIDDLE_BUCKETS_RATIO) CRBYTES_MIDDLE_BUCKETS_VALUE, SUM(DELTA_READ_MEM_BYTES * LAST_BUCKET_RATIO) CRBYTES_LAST_BUCKET_VALUE, SUM(PGA_ALLOCATED * LENGTH_SEG * FIRST_BUCKET_R
ATIO) PGA_ALLOC_FIRST_BUCKET_VALUE, SUM(PGA_ALLOCATED * LENGTH_SEG * MIDDLE_BUCKETS_RATIO) PGA_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(PGA_ALLOCATED * LENGTH_SEG * LAST_BUCKET_RATIO) PGA_ALLOC_LAST_BUCKET_VALUE, SUM(TEMP_SPACE_ALLOCATED * LENGTH_SEG * FIRST_BUCKET_RATIO) TMP_ALLOC_FIRST_BUCKET_VALUE, SUM(TEMP_SPACE_ALLOCATED * LENGTH_SEG * MIDDLE_BUCKETS_RATIO) TMP_ALLOC_MIDDLE_BUCKETS_VALUE, SUM(TEMP_SPACE_ALLOCATED * LENGTH_SEG * LAST_BUCKET_RATIO) TMP_ALLOC_LAST_BUCKET_VALUE FROM ( SELECT USERENV('INSTANCE') INST_ID, ROW_ID, SID, SAMPLE_TIME, CASE WHEN BUCKET_END IS NULL OR BUCKET_START IS NULL THEN NULL WHEN BUCKET_START = TM_BUCKET_START AND BUCKET_START = BUCKET_END THEN 'CO' WHEN BUCKET_START = TM_BUCKET_START THEN 'CM' WHEN BUCKET_START = BUCKET_END THEN 'SO' ELSE 'SM' END GROUP_TYPE, CASE WHEN TM_BUCKET_START IS NULL OR BUCKET_END IS NULL OR (TM_BUCKET_START = BUCKET_START) THEN NULL WHEN TM_BUCKET_START = BUCKET_END THEN 'O' ELSE 'M' END TM_GROUP_TYPE, START_SEG, BUCKET_S
TART, BUCKET_START_OFFSET, TM_START_SEG, CASE WHEN TM_BUCKET_START IS NULL OR (TM_BUCKET_START = BUCKET_START) THEN NULL ELSE TM_BUCKET_START END TM_BUCKET_START, CASE WHEN TM_BUCKET_START IS NULL OR (TM_BUCKET_START = BUCKET_START) THEN NULL ELSE BUCKET_END END TM_BUCKET_END, TM_BUCKET_START_OFFSET, LENGTH_SEG, TM_LENGTH_SEG, END_SEG, BUCKET_END, BUCKET_END_OFFSET, CASE WHEN BUCKET_START != BUCKET_END THEN (:B7 - BUCKET_START_OFFSET) / LENGTH_SEG ELSE 1 END FIRST_BUCKET_RATIO, CASE WHEN BUCKET_END >= BUCKET_START + 2 THEN :B7 / LENGTH_SEG ELSE NULL END MIDDLE_BUCKETS_RATIO, CASE WHEN BUCKET_START != BUCKET_END THEN BUCKET_END_OFFSET / LENGTH_SEG ELSE NULL END LAST_BUCKET_RATIO, CASE WHEN TM_BUCKET_START != BUCKET_END THEN (:B7 - TM_BUCKET_START_OFFSET) / TM_LENGTH_SEG ELSE 1 END TM_FIRST_BUCKET_RATIO, CASE WHEN BUCKET_END >= TM_BUCKET_START + 2 THEN :B7 / TM_LENGTH_SEG ELSE NULL END TM_MIDDLE_BUCKETS_RATIO, CASE WHEN TM_BUCKET_START != BUCKET_END THEN BUCKET_END_
OFFSET / TM_LENGTH_SEG ELSE NULL END TM_LAST_BUCKET_RATIO, TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_READ_IO_REQUESTS DELTA_READ_REQUESTS, DELTA_WRITE_IO_REQUESTS DELTA_WRITE_REQUESTS, DELTA_READ_IO_BYTES DELTA_READ_BYTES, DELTA_WRITE_IO_BYTES DELTA_WRITE_BYTES, DELTA_INTERCONNECT_IO_BYTES DELTA_INTERCONNECT_BYTES, DELTA_READ_MEM_BYTES DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELECT ROW_ID, SID, SAMPLE_TIME, START_SEG, TRUNC(START_SEG / :B7 ) BUCKET_START, MOD(START_SEG, :B7 ) BUCKET_START_OFFSET, TM_START_SEG, TRUNC(TM_START_SEG/:B7 ) TM_BUCKET_START, MOD(TM_START_SEG, :B7 ) TM_BUCKET_START_OFFSET, TRUNC(END_SEG/:B7 ) BUCKET_END, MOD(END_SEG, :B7 ) BUCKET_END_OFFSET, END_SEG, LENGTH_SEG, TM_LENGTH_SEG, TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_READ_IO_REQUESTS, DELTA_WRITE_IO_REQUESTS, DELTA_READ_IO_BYTES, DELTA_WRITE_IO_BYTES, DELTA_INTERCONNECT_IO_BYTES, DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELEC
T ROW_ID, SID, SAMPLE_TIME, TIME_INTERVAL, CASE WHEN START_SEG < 0 THEN 0 ELSE START_SEG END START_SEG, CASE WHEN TM_START_SEG < 0 THEN 0 ELSE TM_START_SEG END TM_START_SEG, CASE WHEN END_SEG > TIME_INTERVAL THEN TIME_INTERVAL ELSE END_SEG END END_SEG, (LENGTH_SEG - (CASE WHEN START_SEG < 0 THEN -START_SEG ELSE 0 END + CASE WHEN END_SEG > TIME_INTERVAL THEN END_SEG - TIME_INTERVAL ELSE 0 END)) LENGTH_SEG, (TM_LENGTH_SEG - (CASE WHEN TM_START_SEG < 0 THEN -TM_START_SEG ELSE 0 END + CASE WHEN END_SEG > TIME_INTERVAL THEN END_SEG - TIME_INTERVAL ELSE 0 END)) TM_LENGTH_SEG, TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_READ_IO_REQUESTS, DELTA_WRITE_IO_REQUESTS, DELTA_READ_IO_BYTES, DELTA_WRITE_IO_BYTES, DELTA_INTERCONNECT_IO_BYTES, DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELECT ROW_ID, SID, SAMPLE_TIME, TIME_INTERVAL, LENGTH_SEG, TM_LENGTH_SEG, END_SEG - TM_LENGTH_SEG TM_START_SEG, END_SEG - LENGTH_SEG START_SEG, END_SEG,
TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_READ_IO_REQUESTS, DELTA_WRITE_IO_REQUESTS, DELTA_READ_IO_BYTES, DELTA_WRITE_IO_BYTES, DELTA_INTERCONNECT_IO_BYTES, DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELECT ROW_ID, SID, SAMPLE_TIME, EXTRACT(SECOND FROM REL_SAMPLE_TIME_INT) + EXTRACT(MINUTE FROM REL_SAMPLE_TIME_INT)*60 + EXTRACT(HOUR FROM REL_SAMPLE_TIME_INT)*3600 + EXTRACT(DAY FROM REL_SAMPLE_TIME_INT)*3600*24 END_SEG, TIME_INTERVAL, DELTA_TIME/1000000 LENGTH_SEG, TM_DELTA_TIME/1000000 TM_LENGTH_SEG, TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_READ_IO_REQUESTS, DELTA_WRITE_IO_REQUESTS, DELTA_READ_IO_BYTES, DELTA_WRITE_IO_BYTES, DELTA_INTERCONNECT_IO_BYTES, DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELECT ROWNUM ROW_ID, SESSION_ID SID, CAST(FROM_TZ(SAMPLE_TIME, DBTIMEZONE) AS DATE) SAMPLE_DATE, SAMPLE_TIME, (SAMPLE_TIME - CAST(:B6 AS TIMESTAMP)) REL_SAMPLE_TIME_INT, TRUNC((:B5 - :B6 ) * 3600 * 24) TIME_INTERVAL,
:B6 AS BND_START_INTERVAL , :B5 AS BND_END_INTERVAL , TM_DELTA_TIME, TM_DELTA_CPU_TIME, TM_DELTA_DB_TIME, DELTA_TIME, DELTA_READ_IO_REQUESTS, DELTA_WRITE_IO_REQUESTS, DELTA_READ_IO_BYTES, DELTA_WRITE_IO_BYTES, DELTA_INTERCONNECT_IO_BYTES, DELTA_READ_MEM_BYTES, PGA_ALLOCATED, TEMP_SPACE_ALLOCATED FROM (SELECT ASH0.* FROM V$ACTIVE_SESSION_HISTORY ASH0 WHERE ((SESSION_ID = :B2 AND SESSION_SERIAL# = :B1 AND USERENV('INSTANCE') = :B3 ) OR (:B4 = 'yes' AND QC_INSTANCE_ID = :B3 AND QC_SESSION_ID = :B2 AND QC_SESSION_SERIAL# = :B1 ))) ) ASH1 WHERE SAMPLE_DATE >= BND_START_INTERVAL AND SAMPLE_DATE <= BND_END_INTERVAL + 120/3600/24 ) ) WHERE START_SEG <= TIME_INTERVAL ) WHERE (LENGTH_SEG IS NOT NULL AND LENGTH_SEG > 0) OR (TM_LENGTH_SEG IS NOT NULL AND TM_LENGTH_SEG > 0)) ) GROUP BY INST_ID, GROUP_TYPE, BUCKET_START, BUCKET_END, TM_GROUP_TYPE, TM_BUCKET_START, TM_BUCKET_END))) GVTF WHERE INST_ID >= :B9 AND INST_ID <= :B8 GROUP BY GROUP_TYPE, BUCKET_START
, BUCKET_END, TM_GROUP_TYPE, TM_BUCKET_START, TM_BUCKET_END ) GROUP BY GROUPING SETS ( (GROUP_TYPE, BUCKET_START, BUCKET_END), (TM_GROUP_TYPE, TM_BUCKET_START, TM_BUCKET_END) ) |
| 8mqsmaqrn9w5w |
SELECT THREAD#, SEQUENCE#, RESETLOGS_CHANGE#, NEXT_CHANGE#, NEXT_TIME, RESETLOGS_TIME FROM (SELECT RESETLOGS_CHANGE#, THREAD#, SEQUENCE#, NEXT_CHANGE#, NEXT_TIME, RESETLOGS_TIME, LEAD(SEQUENCE#, 1, SEQUENCE#+1) OVER (PARTITION BY THREAD#, RESETLOGS_CHANGE#, RESETLOGS_TIME ORDER BY SEQUENCE#) NEXTSEQ FROM (SELECT AL.THREAD#, AL.SEQUENCE#, AL.RESETLOGS_CHANGE#, AL.RESETLOGS_TIME, (CASE WHEN AL.NEXT_CHANGE# > D2.NEXT_RESETLOGS_CHANGE# THEN D2.NEXT_RESETLOGS_CHANGE# ELSE AL.NEXT_CHANGE# END) NEXT_CHANGE#, AL.NEXT_TIME FROM V$ARCHIVED_LOG AL, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT :B1 RESETLOGS_TIME, :B2 RESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE AL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND AL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D
2.NEXT_RESETLOGS_CHANGE# IS NULL OR (AL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND AL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND AL.FIRST_CHANGE# >= :B5 AND (:B4 IS NULL OR AL.FIRST_CHANGE# < :B4 ) AND AL.DELETED = 'NO' AND AL.ARCHIVED = 'YES' AND AL.STANDBY_DEST = 'NO' AND (:B3 IN ('DISK', 'ANY')) UNION ALL SELECT BRL.THREAD#, BRL.SEQUENCE#, BRL.RESETLOGS_CHANGE#, BRL.RESETLOGS_TIME, (CASE WHEN BRL.NEXT_CHANGE# > D2.NEXT_RESETLOGS_CHANGE# THEN D2.NEXT_RESETLOGS_CHANGE# ELSE BRL.NEXT_CHANGE# END) NEXT_CHANGE#, BRL.NEXT_TIME FROM V$BACKUP_REDOLOG BRL, V$BACKUP_PIECE BP, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT :B1 RESETLOGS_TIME, :B2 RESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE BRL.SET_STAMP = BP.SET_STAMP AND BRL.SET_COUNT = BP.SET_
COUNT AND BRL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND BRL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D2.NEXT_RESETLOGS_CHANGE# IS NULL OR (BRL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND BRL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND BRL.FIRST_CHANGE# >= :B5 AND (:B4 IS NULL OR BRL.FIRST_CHANGE# < :B4 ) AND BP.DELETED = 'NO' AND ((:B3 = 'DISK' AND BP.DEVICE_TYPE = 'DISK') OR (:B3 = 'SBT' AND BP.DEVICE_TYPE = 'SBT_TAPE') OR :B3 = 'ANY') UNION ALL SELECT XAL.THREAD#, XAL.SEQUENCE#, XAL.RESETLOGS_CHANGE#, XAL.RESETLOGS_TIME, (CASE WHEN XAL.NEXT_CHANGE# > D2.NEXT_RESETLOGS_CHANGE# THEN D2.NEXT_RESETLOGS_CHANGE# ELSE XAL.NEXT_CHANGE# END) NEXT_CHANGE#, XAL.NEXT_TIME FROM V$PROXY_ARCHIVEDLOG XAL, (SELECT RESETLOGS_TIME, RESETLOGS_CHANGE#, PRIOR RESETLOGS_CHANGE# NEXT_RESETLOGS_CHANGE# FROM V$DATABASE_INCARNATION START WITH RESETLOGS_CHANGE# = :B2 AND RESETLOGS_TIME = :B1 CONNECT BY PRIOR PRIOR_INCARNATION# = INCARNATION# UNION ALL SELECT :B1 RESETLOGS_TIME, :B2 R
ESETLOGS_CHANGE#, NULL NEXT_RESETLOGS_CHANGE# FROM DUAL) D2 WHERE XAL.RESETLOGS_CHANGE# = D2.RESETLOGS_CHANGE# AND XAL.RESETLOGS_TIME = D2.RESETLOGS_TIME AND (D2.NEXT_RESETLOGS_CHANGE# IS NULL OR (XAL.FIRST_CHANGE# >= D2.RESETLOGS_CHANGE# AND XAL.FIRST_CHANGE# < D2.NEXT_RESETLOGS_CHANGE#)) AND XAL.FIRST_CHANGE# >= :B5 AND (:B4 IS NULL OR XAL.FIRST_CHANGE# < :B4 ) AND XAL.DELETED = 'NO' AND (:B3 IN ('LOCAL_SBT', 'LOCAL_ANY'))) ) WHERE NEXTSEQ NOT IN (SEQUENCE#, SEQUENCE#+1) AND ROWNUM = 1 |
| 9w50hgp8akpz5 | SELECT /*+ OPT_PARAM('_parallel_syspls_obey_force' 'false') */ NVL(SPARE6, SVAL2) FROM OPTSTAT_HIST_CONTROL$ WHERE SNAME = 'SCAN_RATE' |
| a0qc12302fzfk | begin dbms_application_info.set_module(:1 , :2 ); end;
|
| aaz3bayav0jwj | update /* KSXM:FLUSH COL */ sys.col_usage$ set equality_preds = equality_preds + decode(bitand(:flag, 1), 0, 0, 1), equijoin_preds = equijoin_preds + decode(bitand(:flag, 2), 0, 0, 1), nonequijoin_preds = nonequijoin_preds + decode(bitand(:flag, 4), 0, 0, 1), range_preds = range_preds + decode(bitand(:flag, 8), 0, 0, 1), like_preds = like_preds + decode(bitand(:flag, 16), 0, 0, 1), null_preds = null_preds + decode(bitand(:flag, 32), 0, 0, 1), flags = :flag, timestamp = :time where obj# = :objn and intcol# = :coln |
| ajkubg7upg9pu | update /* KSXM:TIME_UPD */ optstat_hist_control$ set sval2 = systimestamp where sname = :param_name |
| b9nbhsbx8tqz5 | SELECT /*+ OPT_PARAM('_parallel_syspls_obey_force' 'false') */ SPARE4 FROM SYS.OPTSTAT_HIST_CONTROL$ WHERE SNAME = :B1 |
| c695745x2sy6n | SELECT COUNT(1) FROM SYS.DBA_PROPAGATION |
| c888jmh3f6qfq |
--
-- SQL building XML for all resources (cpu, active sessions, memory and
-- space)
--
select
xmlelement(
"resources",
xmlattributes(
(select count(*) from gv$instance
where inst_id between :b_inst_id_low and :b_inst_id_high)
as "inst_cnt"),
xmlconcat(
--
-- CPU resource - for non-CDB and root
--
(select
xmlelement(
"cpu",
xmlattributes(
other_perc as "other",
bg_perc as "bg",
fg_perc as "fg",
least(pdb_perc, fg_perc) as "pdb"),
null)
from
(
select round(avg(host_perc - cpu_perc), 2) other_perc,
round(avg(cpu_perc - bg_perc), 2) fg_perc,
round(avg(bg_perc), 2) bg_perc,
round(avg(bdb_perc), 2) pdb_perc
from (-- percentages
-- enforce cpu <= host_cpu and bg_cpu <= cpu and pdb_cpu <= cpu
select ((cpu/greatest(host_cpu, cpu)) * host_perc) cpu_perc,
((least(bg_cpu, cpu) /
greatest(host_cpu, cpu)) * host_perc) bg_perc,
((least(pdb_cpu, cpu) /
greatest(host_cpu, cpu)) * host_perc) bdb_perc,
host_perc
from
(
--
-- compute by host name since several DB instances can run
-- on the same host (this is during our testing)
--
select host_name,
avg(decode(metric_id, 2057, value, null))
host_perc,
sum(decode(metric_id, 2075, value, null)) cpu,
sum(decode(metric_id, 2153, value, null)) bg_cpu,
max(decode(metric_id, 2155, value, null)) host_cpu,
sum(decode(metric_id, -1, value, null)) pdb_cpu
from table(gv$(cursor
(-- with inst_id, host_name
select userenv('INSTANCE') inst_id,
(select host_name from v$instance) host_name,
v0.*
from (
select metric_id, value
from v$sysmetric
-- assume that metric_id are fixed...
where metric_id in (2057, 2075, 2153, 2155)
and group_id = 2 -- 60s interval
) v0
)))
where inst_id between :b_inst_id_low and :b_inst_id_high
group by host_name
)
)
)
),
--
-- active sessions
--
case
-- for non-CDB and root
when :b_con_id in (0, 1) then
(select xmlelement(
"activity",
xmlattributes(
round(sum(decode(activity_type, 'Cpu',
activity_count, null)), 2) as "cpu",
round(sum(decode(activity_type, 'User I/O',
activity_count, null)), 2) as "io",
round(sum(decode(activity_type, 'Cluster',
activity_count, null)), 2) as "cluster",
round(sum(decode(activity_type, 'Wait',
activity_count,
null)), 2) as "wait"),
null)
from table(gv$(cursor
(
select userenv('INSTANCE') inst_id,
decode(wc.wait_class, 'Cluster', 'Cluster',
'User I/O', 'User I/O', 'Wait') activity_type,
wm.average_waiter_count activity_count
from v$waitclassmetric wm,
v$system_wait_class wc
where wc.WAIT_CLASS# = wm.WAIT_CLASS#
and wc.wait_class != 'Idle'
union all
select userenv('INSTANCE') inst_id,
'Cpu' activity_type,
value/100 activity_count
from v$sysmetric
where metric_id = 2075
and group_id = 2
)))
where inst_id between :b_inst_id_low and :b_inst_id_high
)
-- else for CDB PDB
else
(select xmlelement(
"activity",
xmlattributes(
round(sum(decode(activity_type, 'Cpu',
activity_count, null)), 2) as "cpu",
round(sum(decode(activity_type, 'User I/O',
activity_count, null)), 2) as "io",
round(sum(decode(activity_type, 'Cluster',
activity_count, null)), 2) as "cluster",
round(sum(decode(activity_type, 'Wait',
activity_count, null)), 2) as "wait"),
null)
from table(gv$(cursor
(select userenv('INSTANCE') inst_id,
activity_type, sum(samples)/60 activity_count
from (
select decode(
nvl(va.wait_class, 'Cpu'),
'Cpu', 'Cpu
',
'Cluster', 'Cluster',
'User I/O', 'User I/O',
'Wait') activity_type,
vi.sampling_interval/1000 samples
from v$active_session_history va,
v$ash_info vi
where va.sample_time < sysdate
and va.sample_time >= sysdate-1/1440)
group by activity_type
)))
where inst_id between :b_inst_id_low and :b_inst_id_high
)
end,
--
-- memory
--
case
-- for non-CDB and root
when :b_con_id in (0, 1) then
(select
xmlelement(
"memory",
null,
xmlagg(
xmlelement(
"comp",
xmlattributes(
component as "name"),
round(sum(
size_mb), 2))))
from table(gv$(cursor
(
select * from
(
select userenv('INSTANCE') inst_id,
case when component = 'DEFAULT buffer cache'
then 'buffer cache'
when component like 'DEFAULT % buffer cache'
then 'buffer cache'
else component
end component,
current_size/1024/1024 size_mb
from v$sga_dynamic_components
where current_size > 0
)
-- only the known components
where component in
(
'shared pool',
'large pool',
'java pool',
'streams pool',
'buffer cache',
'Shared IO Pool',
'Data Transfer Cache',
'ASM Buffer Cache
',
'other buffer cache(s)',
'In-Memory Area'
)
union all
select userenv('INSTANCE') inst_id,
decode(name, 'aggregate PGA target parameter', 'target_pga',
'total_pga') component,
value/1024/1024 size_mb
from v$pgastat
where name in ('aggregate PGA target parameter',
'total PGA allocated')
union all
select userenv('INSTANCE') inst_id,
'total_sga' component,
sum(value)/1024/1024 size_mb
from v$sga
)))
where inst_id between :b_inst_id_low and :b_inst_id_high
group by component)
else
-- for CDB-PDB
-- get inst_cnt which is instance count
-- where the pdb is open.
(select
xmlelement(
"memory",
xmlattributes(
max(inst#) as "pdb_inst_cnt"),
xmlagg(comp_xml))
from
(select sum(1) inst#,
xmlelement(
"comp",
xmlattributes(
component as "name"),
round(sum(size_mb), 2)) comp_xml
from table(gv$(cursor
(
select userenv('INSTANCE') inst_id,
'total_pga' component,
sum(pga_alloc_mem)/1024/1024 size_mb
from v$process
where con_id = :b_con_id
union all
select userenv('INSTANCE') inst_id,
'total_sga' component,
sum(bytes)/1024/1024 size_mb
from v$sgastat
where con_id = :b_con_id
and pool != ' '
and name not like 'free memory'
)))
where inst_id between :b_inst_id_low and :b_
inst_id_high
group by component)
)end,
--
-- storage: for non-CDB and PDB
--
case when :b_con_id != 1 then
(select xmlelement(
"space",
xmlattributes(
round(sum(sum(ts_size)), 2) as "total"),
xmlagg(
xmlelement(
"comp",
xmlattributes(
ts_type as "name"),
round(sum(ts_size), 2))))
from
(
select case when ts.tablespace_name = 'SYSTEM'
then 'SYSTEM'
when ts.tablespace_name = 'SYSAUX'
then 'SYSAUX'
when ts.contents = 'PERMANENT'
then 'USER'
else ts.contents
end ts_type,
ts_space.ts_size ts_size
from
(
select df.tablespace_name,
sum(df.BYTES)/1024/1024 ts_size
from dba_data_files df
group by tablespace_name
) ts_space,
dba_tablespaces ts
where ts.tablespace_name = ts_space.tablespace_name
union all
select 'TEMPORARY' ts_type,
sum(BYTES)/1024/1024
from dba_temp_files ts_size
union all
select 'LOGS' ts_type,
sum(BYTES)/1024/1024
from v$log
)
group by ts_type) end,
--
-- storage: for CDB from root
-- total size by pdbs
case when :b_con_id = 1 then
(select xmlelement(
"space",
xmlattributes(
round(sum(cont_size), 2) as "to
tal"),
xmlagg(
xmlelement(
"comp",
xmlattributes(
cont_name as "name"),
round(cont_size, 2))))
from
(select cont_name, max(cont_size)/1024/1024 cont_size
from table(gv$(cursor(
select name cont_name,
total_size cont_size
from v$pdbs
where con_id > 2
))) group by cont_name)
)
end,
null))
from dual
|
| c8h20n1d0k95m | select /*+ no_parallel */ spare4 from sys.optstat_hist_control$ where sname=:1 |
| csnp95dz2r8ss | select file#, block# from recyclebin$ where ts# = :1 and file# != 0 and block# != 0 and space = 0 |
| ct8x0g7nvbu8h |
DECLARE
l_last_full_time VARCHAR2(64);
l_last_full_age NUMBER;
l_last_full_size NUMBER;
l_last_full_session_key NUMBER;
l_last_full_session_recid NUMBER;
l_last_full_session_stamp NUMBER;
l_last_full_media VARCHAR2(65) := NULL;
l_last_exec_full_time VARCHAR2(64);
l_last_exec_full_status VARCHAR2(23);
l_last_incr_time VARCHAR2(64);
l_last_incr_age NUMBER;
l_last_incr_size NUMBER;
l_last_incr_session_key NUMBER;
l_last_incr_session_recid NUMBER;
l_last_incr_session_stamp NUMBER;
l_last_incr_media VARCHAR2(65) := NULL;
l_last_exec_incr_time VARCHAR2(64);
l_last_exec_incr_status VARCHAR2(23);
l_last_arch_time VARCHAR2(64);
l_last_arch_age NUMBER;
l_last_arch_size NUMBER;
l_last_arch_session_key NUMBER;
l_last_arch_session_recid NUMBER;
l_last_arch_session_stamp NUMBER;
l_last_arch_media VARCHAR2(65) := NULL;
l_last_exec_arch_time VARCHAR2(64);
l_last_exec_arch_status VARCHAR2(23);
l_last_complete_backup VARCHAR2(64);
l_recovery_window NUMBER;
l_unprotected_data_window NUMBER;
TYPE
data_cursor_type IS REF CURSOR;
data_cursor data_cursor_type;
v_db_version VARCHAR2(10);
db_version_121 CONSTANT VARCHAR2(10) := '12.1.0.0.0';
BEGIN
SELECT LPAD(version, 10, '0') INTO v_db_version
FROM v$instance;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24, 2), input_bytes,
session_key, session_recid, session_stamp
INTO l_last_full_time, l_last_full_age, l_last_full_size,
l_last_full_session_key, l_last_full_session_recid, l_last_full_session_stamp
FROM (SELECT end_time, input_bytes, session_key, session_recid, session_stamp
FROM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='DB FULL' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_full_time := NULL;
l_last_full_age := NULL;
l_last_full_size := NULL;
l_last_full_session_key := NULL;
l_last_full_session_recid := NULL;
l_last_full_session_stamp := NULL;
WHEN OTHERS THEN
dbms
_output.put_line(SQLERRM);
END;
BEGIN
IF ((l_last_full_session_key IS NOT NULL) AND
(l_last_full_session_recid IS NOT NULL) AND
(l_last_full_session_stamp IS NOT NULL)) THEN
SELECT media into l_last_full_media
FROM v$backup_piece_details
WHERE session_key=l_last_full_session_key AND
session_recid=l_last_full_session_recid AND
session_stamp=l_last_full_session_stamp AND
device_type = 'SBT_TAPE' AND
rownum = 1;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_full_media := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_full_time, l_last_exec_full_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='DB FULL' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_full_time := NULL;
l_last_exec_full_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(S
QLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24, 2), input_bytes,
session_key, session_recid, session_stamp
INTO l_last_incr_time, l_last_incr_age, l_last_incr_size,
l_last_incr_session_key, l_last_incr_session_recid, l_last_incr_session_stamp
FROM (SELECT end_time, input_bytes, session_key, session_recid, session_stamp
FROM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='DB INCR' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_incr_time := NULL;
l_last_incr_age := NULL;
l_last_incr_size := NULL;
l_last_incr_session_key := NULL;
l_last_incr_session_recid := NULL;
l_last_incr_session_stamp := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
IF ((l_last_incr_session_key IS NOT NULL) AND
(l_last_incr_session_recid IS NOT NULL) AND
(l_last_incr_session_stamp IS NOT NULL)) THEN
SELECT media into l_last_in
cr_media
FROM v$backup_piece_details
WHERE session_key=l_last_incr_session_key AND
session_recid=l_last_incr_session_recid AND
session_stamp=l_last_incr_session_stamp AND
device_type = 'SBT_TAPE' AND
rownum = 1;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_incr_media := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_incr_time, l_last_exec_incr_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='DB INCR' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_incr_time := NULL;
l_last_exec_incr_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), ROUND((sysdate-end_time)*24*60, 2), input_bytes,
session_key, session_recid, session_stamp
INTO l_last_arch_time, l_last_ar
ch_age, l_last_arch_size,
l_last_arch_session_key, l_last_arch_session_recid, l_last_arch_session_stamp
FROM (SELECT end_time, input_bytes, session_key, session_recid, session_stamp
FROM v$rman_backup_job_details
WHERE status LIKE 'COMPLETED%' AND
input_type='ARCHIVELOG' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_arch_time := NULL;
l_last_arch_age := NULL;
l_last_arch_size := NULL;
l_last_arch_session_key := NULL;
l_last_arch_session_recid := NULL;
l_last_arch_session_stamp := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
IF ((l_last_arch_session_key IS NOT NULL) AND
(l_last_arch_session_recid IS NOT NULL) AND
(l_last_arch_session_stamp IS NOT NULL)) THEN
SELECT media into l_last_arch_media
FROM v$backup_piece_details
WHERE session_key=l_last_arch_session_key AND
session_recid=l_last_arch_session_recid AND
session_stamp=l_last_arch_session_stamp AND
device_type = 'SBT_TAPE'
AND
rownum = 1;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_arch_media := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
SELECT to_char(end_time, 'YYYY-MM-DD HH24:MI:SS'), status
INTO l_last_exec_arch_time, l_last_exec_arch_status
FROM (SELECT end_time, status
FROM v$rman_backup_job_details
WHERE status NOT LIKE 'RUNNING%' AND
input_type='ARCHIVELOG' AND
output_device_type IN ('SBT_TAPE', '*')
ORDER BY end_time DESC)
WHERE rownum = 1;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_exec_arch_time := NULL;
l_last_exec_arch_status := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
BEGIN
IF (v_db_version >= db_version_121) THEN
EXECUTE IMMEDIATE
'SELECT to_char(low_time, ''YYYY-MM-DD HH24:MI:SS'') as last_complete_backup,
ROUND((high_time-low_time)*24*60*60, 2) as recovery_window,
ROUND((sysdate-high_time)*24*60*60, 2) as unprotected_data_window
FROM v$sbt_restore_range rr1
WHERE rr1.high_time = (SELECT max(rr2.high_time)
FROM v$sbt_restore_range rr
2
WHERE rr1.db_id = rr2.db_id)'
INTO l_last_complete_backup,
l_recovery_window, l_unprotected_data_window;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_last_complete_backup := NULL;
l_recovery_window := NULL;
l_unprotected_data_window := NULL;
WHEN OTHERS THEN
dbms_output.put_line(SQLERRM);
END;
OPEN data_cursor FOR
SELECT l_last_full_time, l_last_full_age, l_last_full_size, l_last_full_media,
l_last_exec_full_time, l_last_exec_full_status,
l_last_incr_time, l_last_incr_age, l_last_incr_size, l_last_incr_media,
l_last_exec_incr_time, l_last_exec_incr_status,
l_last_arch_time, l_last_arch_age, l_last_arch_size, l_last_arch_media,
l_last_exec_arch_time, l_last_exec_arch_status,
l_last_complete_backup,
l_recovery_window, l_unprotected_data_window
FROM dual;
:1 := data_cursor;
END;
|
| dsfnfxkbbvxha | INSERT INTO WRP$_REPORTS_DETAILS(SNAP_ID, DBID, INSTANCE_NUMBER, CON_DBID, SESSION_ID, SESSION_SERIAL#, REPORT_ID, GENERATION_TIME, REPORT_COMPRESSED) VALUES(:B9 , :B8 , :B7 , :B6 , :B5 , :B4 , :B3 , :B2 , :B1 ) |
| f705bwx3q0ydq | select count(*) from dba_autotask_window_clients c, (select window_name, max(log_date) max_log_date from dba_scheduler_window_log where operation = 'OPEN' group by window_name) wo, (select window_name, max(log_date) max_log_date from dba_scheduler_window_log where operation = 'CLOSE' group by window_name) wc where c.window_name = wo.window_name and c.optimizer_stats = 'ENABLED' and wo.window_name = wc.window_name and wo.max_log_date < wc.max_log_date and wc.window_name not in (select h.window_name from dba_autotask_job_history h where h.client_name = 'auto optimizer stats collection' and h.job_start_time between wo.max_log_date and wc.max_log_date) |
| fhf8upax5cxsz | BEGIN sys.dbms_auto_report_internal.i_save_report (:rep_ref, :snap_id, :pr_class, :rep_id, :suc); END; |
| g4gp07gt2z920 | update sys.scheduler$_job set last_start_date = :1, running_instance = :2, running_slave = :3, job_status = :4 where obj# = :5 |
| g6px76dmjv1jy | select count(*) from wri$_optstat_opr o, wri$_optstat_opr_tasks t where o.id = t.op_id(+) and o.operation = 'gather_database_stats (auto)' and (not regexp_like( extract(xmltype('<notes>' || o.notes || '</notes>'), '//error'), '^<error>ORA-200[0-9][0-9]') or not regexp_like( extract(xmltype('<notes>' || t.notes || '</notes>'), '//error'), '^<error>ORA-200[0-9][0-9]')) |
| gct0dppp1rstr |
WITH binds as
(select :dbid as dbid
, :inst_id_low as instIdLow
, :inst_id_high as instIdHigh
, :begin_snap as beginSnap
, :end_snap as endSnap
, :begin_time as beginTime
, :end_time as endTime
, :disk_begin_time as diskBeginTime
, :disk_end_time as diskEndTime
, :mem_begin_time as memBeginTime
, :mem_end_time as memEndTime
, :bucket_count as bucketCount
, :bucket_interval as bucketInterval
, :mem_enable as memEnable
, :disk_enable as diskEnable
, :disk_filter_ratio as filterRatio, :filter_action as filter_action, :filter_blocking_session as filter_blocking_session, :filter_capture_id
as filter_capture_id, :filter_client_id as filter_client_id, :filter_consumer_group_id as filter_consumer_group_id, :filter_dbop as filter_dbop, :filter_ecid as filter_ecid, :filter_event as filter_event, :filter_instance_number as filter_instance_number, :filter_is_captured as filter_is_captured, :filter_is_filtered_out as filter_is_filtered_out, :filter_is_nc_background as filter_is_nc_background, :filter_is_replayed as filter_is_replayed, :filter_machine as filter_machine, :filter_machine_port as filter_machine_port, :filter_module as filter_module, :filter_object as filter_object, :filter_pdb as filter_pdb, :filter_physical_session as filter_physical_session, :filter_pl_sql as filter_pl_sql, :filter_pl_sql_top as filter_pl_sql_top, :filter_program as filter_program, :filter_px_process as filter_px_process, :filter_service_hash as filter_service_hash, :filter_session_type as filter_session_type, :filter_sql_fms as filter_sql_fms, :filter_sql_id_top as filter
_sql_id_top, :filter_sql_opcode as filter_sql_opcode, :filter_sql_opcode_top as filter_sql_opcode_top, :filter_sql_rws as filter_sql_rws, :filter_sql_rws_line as filter_sql_rws_line, :filter_sqlid as filter_sqlid, :filter_sqlid_fullphv as filter_sqlid_fullphv, :filter_sqlid_phv as filter_sqlid_phv, :filter_user_id as filter_user_id, :filter_wait_class as filter_wait_class, :filter_xid as filter_xid from dual) , unified_ash as
(SELECT a.sample_id
, a.sample_time
, a.session_id
, a.session_serial#
, a.session_type
, a.session_state
, a.flags
, a.user_id
, a.sql_id
, a.sql_opcode
, a.sql_opname
, a.top_level_sql_id
, a.top_level_sql_opcode
, a.sql_child_number
, a.sql_plan_hash_value
, a.sql_full_plan_hash_value
, a.sql_plan_line_id
, a.sql_plan_operation
, a.sql_plan_options
, a.sql_exec_id
, a.force_
matching_signature
, a.plsql_entry_object_id
, a.plsql_entry_subprogram_id
, a.plsql_object_id
, a.plsql_subprogram_id
, a.service_hash
, a.qc_session_id
, a.qc_instance_id
, a.qc_session_serial#
, nvl(a.event,
CASE WHEN bitand(a.time_model, power(2, 19)) > 0
THEN 'CPU: IM Populate'
WHEN bitand(a.time_model, power(2, 20)) > 0
THEN 'CPU: IM Prepopulate'
WHEN bitand(a.time_model, power(2, 21)) > 0
THEN 'CPU: IM Repopulate'
WHEN bitand(a.time_model, power(2, 22)) > 0
THEN 'CPU: IM Trickle Repop'
WHEN bitand(a.time_model, power(2, 18)) > 0
THEN 'CPU: IM Query'
ELSE 'CPU + Wait for CPU' END) as event
, nvl(a.event_id, 1)
as event_id
, nvl(a.wait_class, 'CPU')
as wait_class
, nvl(a.wait_class_id, 9999)
as wait_class_id
, a.seq#
, a.p1
, a.p1text
, a.p2
, a.p2text
, a.p3
, a.p3text
, a.wait_time
, a.time_waited
, rawtohex(a.xid) as xid
, a.blocking_session
, a.blocking_session_serial#
, a.blocking_session_status
, a.blocking_inst_id
, a.current_obj#
, a.current_file#
, a.current_block#
, a.top_level_call#
, a.top_level_call_name
, a.program
, a.module
, a.action
, a.client_id
, a.remote_instance#
, a.ecid
, a.consumer_group_id
, a.machine
, a.port
, a.in_connection_mgmt
, a.in_parse
, a.in_hard_parse
, a.in_sql_execution
, a.in_plsql_execution
, a.in_plsql_rpc
, a.in_plsql_compilation
, a.in_java_execution
, a.in_bind
, a.in_cursor_close
, a.in_sequence_load
, a.is_captured
, a.is_replayed
, a.dbreplay_file_id
, a.dbop_name
, a.con_dbid, decode(binds.diskEnable, 0, 1, binds.filterRatio)
as sample_count
, inst_id as instance_number
FROM gv$active_session_history a, binds
WHERE binds.memEnable = 1
AND ( binds.diskEnable = 0
OR ( binds.diskEnable = 1
AND a.is_awr_sample = 'Y'
AND bitand(a.flags, 128) = 0 ) )
AND a.inst_id between
binds.instIdLow
and binds.instIdHigh
AND a.sample_time between
binds.beginTime
and binds.endTime
UNION ALL
SELECT a.sample_id
, a.sample_time
, a.session_id
, a.
session_serial#
, a.session_type
, a.session_state
, a.flags
, a.user_id
, a.sql_id
, a.sql_opcode
, a.sql_opname
, a.top_level_sql_id
, a.top_level_sql_opcode
, a.sql_child_number
, a.sql_plan_hash_value
, a.sql_full_plan_hash_value
, a.sql_plan_line_id
, a.sql_plan_operation
, a.sql_plan_options
, a.sql_exec_id
, a.force_matching_signature
, a.plsql_entry_object_id
, a.plsql_entry_subprogram_id
, a.plsql_object_id
, a.plsql_subprogram_id
, a.service_hash
, a.qc_session_id
, a.qc_instance_id
, a.qc_session_serial#
, nvl(a.event,
CASE WHEN bitand(a.time_model, power(2, 19)) > 0
THEN 'CPU: IM Populate'
WHEN bitand(a.time_model, power(2, 20)) > 0
THEN 'CPU: IM Prepopulate'
WHEN bitand(a
.time_model, power(2, 21)) > 0
THEN 'CPU: IM Repopulate'
WHEN bitand(a.time_model, power(2, 22)) > 0
THEN 'CPU: IM Trickle Repop'
WHEN bitand(a.time_model, power(2, 18)) > 0
THEN 'CPU: IM Query'
ELSE 'CPU + Wait for CPU' END) as event
, nvl(a.event_id, 1)
as event_id
, nvl(a.wait_class, 'CPU')
as wait_class
, nvl(a.wait_class_id, 9999)
as wait_class_id
, a.seq#
, a.p1
, a.p1text
, a.p2
, a.p2text
, a.p3
, a.p3text
, a.wait_time
, a.time_waited
, rawtohex(a.xid) as xid
, a.blocking_session
, a.blocking_session_serial#
, a.blocking_session_status
, a.blocking_inst_id
, a.current_obj#
, a.current_file#
, a.current_block#
, a.top_level_call#
, a.top_level_call_name
, a.program
, a.module
, a.action
, a.client_id
, a.remote_instance#
, a.ecid
, a.consumer_group_id
, a.machine
, a.port
, a.in_connection_mgmt
, a.in_parse
, a.in_hard_parse
, a.in_sql_execution
, a.in_plsql_execution
, a.in_plsql_rpc
, a.in_plsql_compilation
, a.in_java_execution
, a.in_bind
, a.in_cursor_close
, a.in_sequence_load
, a.is_captured
, a.is_replayed
, a.dbreplay_file_id
, a.dbop_name
, a.con_dbid, binds.filterRatio as sample_count
, instance_number as instance_number
FROM AWR_ROOT_active_sess_history a,
binds
WHERE binds.diskEnable = 1
AND a.dbid = binds.dbid
AND a.instance_number between
binds.instId
Low
and binds.instIdHigh
AND a.snap_id between
binds.beginSnap
and binds.endSnap + 1
AND a.sample_time between
binds.beginTime
and binds.endTime
), logical_ash as
(select sample_id
, sample_time
, sample_count
, instance_number as inst_id, action as action, event as event, instance_number as instance_number, module as module, instance_number || ':' || session_id || ', ' || session_serial# as physical_session, service_hash as service_hash, sql_id as sqlid, wait_class as wait_class, xid as xid, user_id as user_id, program as program from unified_ash) , bucketized_ash as
(SELECT ash0.*,
(case when binds.bucketCount > 1
then trunc( ( (24 * 60 * 60 *
extract(day from sample_time
- binds.beginTime))
+ (60 * 60 *
extract(hour from sample_time
- binds.beginTime))
+ (60 *
extract(minute from sample_time
- binds.beginTime))
+ (1 *
extract(second from sample_time
- binds.beginTime))
) / binds.bucketInterval
) + 1
else 1
end) as bucket_number
FROM logical_ash ash0, binds), filter_xml as
(SELECT xmlconcat(xmlelement("filters" )
, xmlelement("report_time", xmlattributes(
to_char(o.begintime, 'HH24:MI:SS MM/DD/YYYY') as "begin_time",
to_char(o.endtime, 'HH24:MI:SS MM/DD/YYYY') as "end_time"))) as xml_frag FROM
(select binds.*, nvl(to_number(filter_pdb), 0) as con_dbid from binds) o) , filtered_ash as
(SELECT ash.*,
1 filtered
FROM bucketized_ash ash, binds WHERE 1=1 ), grouped_ash as
(SELECT ash.*, 0 AS bucket_type FROM (SELECT sqlid, physical_session, action, module, service_hash, instance_number, event, wait_class , grouping_id(sqlid, physical_session, action, module, service_hash, instance_number, event, wait_class) as gid , max(inst_id) as inst_id
, sum(sample_count) as sample_count
, count(distinct sqlid) as uniq_sqlids
, count(distinct xid)
as uniq_xids
, count(distinct physical_session)
as uniq_sessions
, count(distinct instance_number)
as uniq_instances, max(user_id) as user_id, max(program) as program from filtered_ash
group by grouping sets( (wait_class), (sqlid), (module), (event), (action), (instance_number), (physical_session), (service_hash)) ) ash ), component_1_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
from (select max(case when mem_rank <= 13
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 13
then mem_rank
else (13 + 1)
end) as mem_rank
, max(case when mem_rank <= 13
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 13
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 13
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 13
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select wait_class as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, wait_class) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 254
and wait_class is not null)
group by (case when mem_rank <= 13
then dim_val
else null
end)
) left ) , component_1_xml as
(select xmlelement("item"
, xmlattributes('wait_class' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 13
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 13
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 13
then 0
else num_mem
end) as num_othe
rs
from (component_1_treemap) t
) topmems), component_2_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select event as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, event) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 253
and event is not null)
group by (case when mem_r
ank <= 5
then dim_val
else null
end)
) left ) , component_2_xml as
(select xmlelement("item"
, xmlattributes('event' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_2_treemap) t
) topmems), component_3_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instan
ces
, 0 AS bucket_type --target(not global)/filtered bucket
, NVL((SELECT instance_name
FROM gv$instance v
WHERE v.instance_number = left.dim_val
AND rownum < 2 ), ( SELECT instance_name
FROM AWR_ROOT_database_instance v, binds b
WHERE v.dbid = b.dbid
AND v.instance_number = left.dim_val
AND rownum < 2)) as instance_name
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(ins
t_id) as inst_id
from (select instance_number as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, instance_number) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 251
and instance_number is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_3_xml as
(select xmlelement("item"
, xmlattributes('instance_number' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
, instance_name)
order by sample_count desc))
as topmems_frag
, sum(case w
hen mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_3_treemap) t
) topmems), component_4_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucke
t
, NVL((SELECT name
FROM gv$active_services v
WHERE v.name_hash = left.dim_val
AND v.inst_id = left.inst_id
AND rownum < 2 ), ( SELECT service_name
FROM AWR_ROOT_service_name v, binds b
WHERE v.dbid = b.dbid
AND v.service_name_hash = left.dim_val
AND rownum < 2)) as service_name
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) a
s mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select service_hash as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, service_hash) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 247
and service_hash is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_4_xml as
(select xmlelement("item"
, xmlattributes('service_hash' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank
as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
, service_name)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_4_treemap) t
) topmems), component_5_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end)
as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select module as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, module) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 239
and module is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_5_xml as
(select xmlelement("item"
, xmlattributes('module' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.t
opmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq
_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_5_treemap) t
) topmems), co
mponent_6_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as
uniq_instances
, max(inst_id) as inst_id
from (select action as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, action) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 223
and action is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_6_xml as
(select xmlelement("item"
, xmlattributes('action' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
)
order by sample_count desc))
as topmems_frag
, sum(ca
se when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_6_treemap) t
) topmems), component_7_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, 0 AS bucket_type --target(not global)/filtered b
ucket
, user_id, program
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*) as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
, max(case when mem_rank <= 5
then user_id else null
end) as user_id, max(case when mem_rank <= 5
then program else null
end) as program
from (select physical_session as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, physical_session) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
, user_id, program
from grouped_ash
where gid = 191
and physical_session is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_7_xml as
(select xmlelement("item"
, xmlattributes('physical_session' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as
"id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
, xmlconcat(xmlelement("info", xmlattributes('user_id' as "name"), user_id), xmlelement("info", xmlattributes('program' as "name"), program))
)
order by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_7_treemap) t
) topmems), component_8_treemap as
(select dim_val
, inst_id
, sample_count
, num_mem
, mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, un
iq_instances
, 0 AS bucket_type --target(not global)/filtered bucket
, NVL((SELECT replace(substr(v.sql_text, 1, 100), CHR(0), '') as sql_text
FROM gv$sql v
WHERE v.sql_id = left.dim_val
AND v.inst_id = left.inst_id
AND rownum < 2 ), ( SELECT replace(dbms_lob.substr(v.sql_text, 100, 1), CHR(0), '')
as sql_text
FROM AWR_ROOT_sqltext v, binds b
WHERE v.dbid = b.dbid
AND v.sql_id = left.dim_val
AND rownum < 2)) as sql_text
from (select max(case when mem_rank <= 5
then dim_val
else null
end) as dim_val
, sum(sample_count) as sample_count
, count(*)
as num_mem
, max(case when mem_rank <= 5
then mem_rank
else (5 + 1)
end) as mem_rank
, max(case when mem_rank <= 5
then uniq_sqlids
else 0
end) as uniq_sqlids
, max(case when mem_rank <= 5
then uniq_xids
else 0
end) as uniq_xids
, max(case when mem_rank <= 5
then uniq_sessions
else 0
end) as uniq_sessions
, max(case when mem_rank <= 5
then uniq_instances
else 0
end) as uniq_instances
, max(inst_id) as inst_id
from (select sqlid as dim_val
, sample_count
, dense_rank() over
(order by sample_count desc
, sqlid) as mem_rank
, uniq_sqlids
, uniq_xids
, uniq_sessions
, uniq_instances
, inst_id
from grouped_ash
where gid = 127
and sqlid is not null)
group by (case when mem_rank <= 5
then dim_val
else null
end)
) left ) , component_8_xml as
(select xmlelement("item"
, xmlattributes('sqlid' as "id"
, topmems.cnt_all as "count"
, topmems.num_mem as "num_mem"
, topmems.num_others as "num_others") , topmems.topmems_frag) as dim_frag from (select xmlelement(
"top_mems"
, xmlattributes(sum(case when mem_rank <= 5
then sample_count
else 0
end
) as "count")
, xmlagg(xmlelement(
"mem"
, xmlattributes(mem_rank as "id"
, dim_val as "name"
, sample_count as "count"
, uniq_sqlids as "uniq_sqlids"
, uniq_xids as "uniq_xids"
, uniq_sessions as "uniq_sessions"
, uniq_instances as "uniq_instances")
, sql_text)
order
by sample_count desc))
as topmems_frag
, sum(case when mem_rank <= 5
then 1
else 0
end) as num_mem
, sum(sample_count) as cnt_all
, max(case when mem_rank <= 5
then 0
else num_mem
end) as num_others
from (component_8_treemap) t
) topmems)select
xmlconcat((select xml_frag from filter_xml),
xmlelement("dim_list",
xmlelement("item",
xmlattributes('top_dimensions' as "id"),
xmlelement("subdim", xmlconcat((select dim_f
rag from component_1_xml), (select dim_frag from component_2_xml), (select dim_frag from component_3_xml), (select dim_frag from component_4_xml), (select dim_frag from component_5_xml), (select dim_frag from component_6_xml), (select dim_frag from component_7_xml), (select dim_frag from component_8_xml)))),
xmltype('
<item type="separator" />'),
xmltype('
<item id="sql_cat">
<subdim>
<item id="sqlid" />
<item id="sql_id_top" />
<item id="sql_fms" />
<item id="sqlid_phv" />
<item id="sqlid_fullphv"/>
<item id="sql_rws" />
<item id="sql_rws_line" />
<item id="sql_opcode" />
<item id="sql_opcode_top" />
</subdim>
</item>'),
xmltype('
<item id="pl_sql_cat">
<subdim>
<item id="pl_sql" />
<item id="pl_sql_top" />
</subdim>
</item>'),
xmltype('
<item id="resource_consumption_cat">
<subdim>
<item id="wait_class" />
<item id="event" />
<item id="object" />
<item id="blocking_session" />
</subdim>
</item>'),
xmltype('
<item id="session_identifiers_cat">
<subdim>
<item id="instance_number" /> <item id="service_hash" />
<item id="physical_session" />
<item i
d="px_process" />
<item id="user_id" />
<item id="program" />
<item id="session_type" />
</subdim>
</item>'),
xmltype('
<item id="session_attributes_cat">
<subdim>
<item id="consumer_group_id" />
<item id="module" />
<item id="action" />
<item id="client_id" />
<item id="machine" />
<item id="machine_port" />
<item id="xid" />
<item id="ecid" />
<item id="dbop" />
</subdim>
</item>'))
) from dual |
| gj5r9jj2xad7f |
SELECT 1, status, '', archiver, database_status, active_state FROM v$instance
|
| gjaap3w3qbf8c | select count(*) from ilmobj$ where rownum = 1 |