support/oracle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2026-03-12 20:23:15

Browse Source
This commit is contained in:
root
2026-03-12 21:23:47 +01:00
parent eab4b36eca
commit 93039b8489
3332 changed files with 699614 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
csierra/cs_internal/cs_acs_internal.sql
+88
View File
@@ -0,0 +1,88 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL last_active_time FOR A19 HEA 'Last Active Time';
COL child_number FOR 999999 HEA 'Child|Number';
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
COL object_status FOR A14 HEA 'Object|Status';
COL is_obsolete FOR A8 HEA 'Is|Obsolete';
COL is_shareable FOR A9 HEA 'Is|Shareable';
COL is_bind_aware FOR A9 HEA 'Is Bind|Aware';
COL is_bind_sensitive FOR A9 HEA 'Is Bind|Sensitive';
COL bucket_id FOR 999999 HEA 'Bucket|ID';
COL count FOR 999999 HEA 'Count';
COL predicate FOR A20 HEA 'Predicate';
COL range_id FOR 99999 HEA 'Range|ID';
COL low HEA 'Low';
COL high HEA 'High';
COL high_low_avg HEA 'AVG' FOR A10;
--
BREAK ON con_id DUPL ON pdb_name DUPL ON last_active_time DUPL ON child_number SKIP 1 DUPL;
PRO
PRO ACS HISTOGRAM (v$sql_cs_histogram)
PRO ~~~~~~~~~~~~~
SELECT h.con_id,
c.name AS pdb_name,
TO_CHAR(s.last_active_time, '&&cs_datetime_full_format.') last_active_time,
h.child_number,
h.bucket_id,
h.count,
s.object_status,
s.is_obsolete,
s.is_shareable,
s.is_bind_sensitive,
s.is_bind_aware,
s.plan_hash_value
FROM v$sql_cs_histogram h,
v$sql s,
v$containers c
WHERE h.sql_id = '&&cs_sql_id.'
AND s.sql_id = h.sql_id
AND s.child_number = h.child_number
AND s.con_id = h.con_id
AND c.con_id = h.con_id
ORDER BY
h.con_id,
s.last_active_time,
h.child_number,
h.bucket_id
/
--
/* v$sql_cs_statistics not populated on 12c as per bug 24441377 */
--
BREAK ON con_id DUPL ON pdb_name DUPL ON last_active_time DUPL ON child_number SKIP 1 DUPL;
PRO
PRO ACS SELECTIVITY PROFILE (v$sql_cs_selectivity)
PRO ~~~~~~~~~~~~~~~~~~~~~~~
SELECT l.con_id,
c.name AS pdb_name,
TO_CHAR(s.last_active_time, '&&cs_datetime_full_format.') last_active_time,
l.child_number,
l.range_id,
l.predicate,
l.low,
-- TRIM(TO_CHAR(ROUND((TO_NUMBER(l.high) + TO_NUMBER(l.low)) / 2, 6), '0.000000')) high_low_avg,
l.high,
s.object_status,
s.is_obsolete,
s.is_shareable,
s.is_bind_sensitive,
s.is_bind_aware,
s.plan_hash_value
FROM v$sql_cs_selectivity l,
v$sql s,
v$containers c
WHERE l.sql_id = '&&cs_sql_id.'
AND s.sql_id = l.sql_id
AND s.child_number = l.child_number
AND s.con_id = l.con_id
AND c.con_id = l.con_id
ORDER BY
l.con_id,
s.last_active_time,
l.child_number,
l.range_id,
l.predicate,
l.low,
l.high
/
--
csierra/cs_internal/cs_active_sessions.sql
+59
View File
@@ -0,0 +1,59 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL sid_serial# FOR A12 HEA 'Sid,Serial#';
COL child_number FOR 999999 HEA 'Child|Number';
COL sql_exec_start FOR A19 HEA 'SQL Exec Start';
COL elapsed_seconds FOR 999,990 HEA 'Elapsed|Seconds';
COL current_timed_event FOR A80 HEA 'Current Timed Event';
--
PRO
PRO ACTIVE SESSIONS (v$session)
PRO ~~~~~~~~~~~~~~~
SELECT s.con_id,
c.name AS pdb_name,
s.machine,
s.state||CASE WHEN s.state LIKE 'WAITED%' THEN ' (avg of '||ROUND(AVG(s.wait_time_micro))||'us)' END||
CASE WHEN s.wait_class IS NOT NULL THEN ' on '||s.wait_class||CASE WHEN s.event IS NOT NULL THEN ' - '||s.event END END AS current_timed_event,
COUNT(*) AS sessions
FROM v$session s,
v$containers c
WHERE s.sql_id = '&&cs_sql_id.'
AND s.status = 'ACTIVE'
AND c.con_id = s.con_id
GROUP BY
s.con_id,
c.name,
s.machine,
s.state,
s.wait_class,
s.event
ORDER BY
s.con_id,
s.machine,
s.state,
s.wait_class,
s.event
/
--
--BREAK ON con_id ON pdb_name ON machine SKIP PAGE;
SELECT s.con_id,
c.name AS pdb_name,
machine,
s.sid||','||s.serial# AS sid_serial#,
s.sql_child_number AS child_number,
TO_CHAR(s.sql_exec_start, '&&cs_datetime_full_format.') sql_exec_start,
(SYSDATE - s.sql_exec_start) * 24 * 3600 AS elapsed_seconds,
s.state||CASE WHEN s.state LIKE 'WAITED%' THEN ' ('||s.wait_time_micro||'us)' END||
CASE WHEN s.wait_class IS NOT NULL THEN ' on '||s.wait_class||CASE WHEN s.event IS NOT NULL THEN ' - '||s.event END END AS current_timed_event
FROM v$session s,
v$containers c
WHERE s.sql_id = '&&cs_sql_id.'
AND s.status = 'ACTIVE'
AND c.con_id = s.con_id
ORDER BY
s.con_id,
s.machine,
s.sql_exec_start
/
--
--CLEAR BREAK;
csierra/cs_internal/cs_active_sessions_internal.sql
+120
View File
@@ -0,0 +1,120 @@
SET HEA ON LIN 2490 PAGES 100 TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON TRIM ON TI OFF TIMI OFF LONG 240000 LONGC 2400 NUM 20 SERVEROUT OFF;
SET PAGES 300 LONGC 120;
--
COL sid_nopri NOPRI;
COL rt_lc FOR A12 HEA 'rt:RunTime|lc:LastCall';
COL sql_id_phv FOR A16 HEA 's:SQL_ID|p:Plan Hash';
COL attributes FOR A65 HEA 'c:Container, u:UserName, h:Host, m:Module, a:Action, p:Program|i:ClientInfo, s:State, w:WaitEvent, s:Sid,Session, l:LogonSecs';
COL sql_fulltext FOR A80 HEA 'SQL Text';
COL execution_plan FOR A80 HEA 'Execution Plan';
--
BREAK ON sid_nopri SKIP PAGE;
PRO
PRO Active Sessions
PRO ~~~~~~~~~~~~~~~
--
WITH
FUNCTION execution_plan (p_sql_id IN VARCHAR2, p_child_number IN NUMBER)
RETURN VARCHAR2
IS
l_execution_plan VARCHAR2(32767) := NULL;
BEGIN
FOR i IN (SELECT plan_table_output FROM TABLE(DBMS_XPLAN.DISPLAY_CURSOR(p_sql_id, p_child_number, 'BASIC')) WHERE TRIM(plan_table_output) IS NOT NULL)
LOOP
IF i.plan_table_output LIKE 'Plan hash value: %' THEN l_execution_plan := NULL; END IF;
IF l_execution_plan IS NOT NULL THEN l_execution_plan := l_execution_plan||CHR(10); END IF;
IF LENGTH(l_execution_plan||SUBSTR(i.plan_table_output, 1, 79)) <= 4000 THEN
l_execution_plan := l_execution_plan||SUBSTR(i.plan_table_output, 1, 79);
ELSE
EXIT; -- avoid ORA-06502: PL/SQL: numeric or value error: character string buffer too small
END IF;
END LOOP;
RETURN l_execution_plan;
END execution_plan;
active_user_sessions
AS (
SELECT /*+ MATERIALIZE NO_MERGE */
e.con_id
, e.sql_exec_start
, e.last_call_et
, e.sql_id
, e.username
, e.osuser
, e.machine
, e.module
, e.action
, e.program
, e.client_info
, e.state
, e.wait_class
, e.event
, e.seconds_in_wait
, e.wait_time_micro
, e.sid
, e.serial#
, e.type
, e.logon_time
, e.sql_child_number
, e.audsid
, p.spid
, p.pname
FROM v$session e,
v$process p
WHERE e.status = 'ACTIVE'
-- AND e.type = 'USER'
AND e.sid <> SYS_CONTEXT('USERENV', 'SID') -- exclude myself
AND p.addr = e.paddr
)
SELECT e.sid AS sid_nopri
, 'rt:'||TRIM(TO_CHAR((SYSDATE - e.sql_exec_start) * 24 * 3600, '999,999,990'))||CASE WHEN e.sql_exec_start IS NOT NULL THEN 's' ELSE '<null>' END||
CHR(10)||'lc:'||TRIM(TO_CHAR(e.last_call_et, '999,999,990'))||'s' AS rt_lc
, CASE WHEN e.sql_id IS NOT NULL THEN 's:'||e.sql_id END||
CASE WHEN s.plan_hash_value IS NOT NULL THEN CHR(10)||'p:'||s.plan_hash_value END||
CASE WHEN s.sql_plan_baseline IS NOT NULL THEN CHR(10)||' spbl' END||
CASE WHEN s.sql_patch IS NOT NULL THEN CHR(10)||' spch' END||
CASE WHEN s.sql_profile IS NOT NULL THEN CHR(10)||' sprf' END
AS sql_id_phv
, 'c:'||SUBSTR(c.name, 1, 64)||
CHR(10)||'u:'||SUBSTR(NVL(e.username,'<null>'), 1, 64)||' os:'||SUBSTR(NVL(e.osuser,'<null>'), 1, 64)||
CHR(10)||'h:'||SUBSTR(NVL(e.machine,'<null>'), 1, 64)||
CASE WHEN e.module IS NOT NULL THEN CHR(10)||'m:'||SUBSTR(e.module, 1, 64) END||
CASE WHEN e.action IS NOT NULL THEN CHR(10)||'a:'||SUBSTR(e.action, 1, 64) END||
CASE WHEN e.program IS NOT NULL THEN CHR(10)||'p:'||SUBSTR(e.program, 1, 64) END||
CASE WHEN e.client_info IS NOT NULL THEN CHR(10)||'i:'||SUBSTR(e.client_info, 1, 64) END||
CHR(10)||'s:'||e.state||
CASE WHEN e.wait_time_micro > 0 THEN ' ('||TRIM(TO_CHAR(e.wait_time_micro,'999,999,999,990'))||'us)' END||
CASE WHEN e.seconds_in_wait > 0 THEN ' ('||TRIM(TO_CHAR(e.seconds_in_wait,'999,990'))||'s)' END||
CASE WHEN e.wait_class IS NOT NULL THEN CHR(10)||'w:'||e.wait_class||CASE WHEN e.event IS NOT NULL THEN ' - '||e.event END END||
CHR(10)||'os:'||e.spid||'('||NVL(e.pname,'ORA')||')'||
CHR(10)||'s:'||e.sid||','||e.serial#||'('||e.type||')'||
CHR(10)||'l:'||TRIM(TO_CHAR((SYSDATE - e.logon_time) * 24 * 3600, '999,999,990'))||'s'
AS attributes
, COALESCE(s.sql_fulltext, s2.sql_fulltext) AS sql_fulltext
, (SELECT execution_plan(e.sql_id, e.sql_child_number) FROM DUAL WHERE s.plan_hash_value > 0) AS execution_plan
FROM active_user_sessions e
OUTER APPLY (
SELECT s.plan_hash_value
, s.sql_plan_baseline
, s.sql_patch
, s.sql_profile
, s.sql_fulltext
FROM v$sql s
WHERE s.con_id = e.con_id
AND s.sql_id = e.sql_id
AND s.child_number = e.sql_child_number
AND s.object_status = 'VALID'
AND s.is_obsolete = 'N'
AND s.is_shareable = 'Y'
ORDER BY s.last_active_time DESC
FETCH FIRST ROW ONLY ) s
OUTER APPLY (
SELECT s.sql_fulltext
FROM v$sql s
WHERE s.sql_id = e.sql_id
FETCH FIRST ROW ONLY ) s2
, v$containers c
WHERE c.con_id = e.con_id
ORDER BY
e.sql_exec_start NULLS LAST,
e.last_call_et DESC
/
csierra/cs_internal/cs_active_sessions_peaks_internal_v5.sql
+319
View File
@@ -0,0 +1,319 @@
--SET HEA OFF PAGES 0 SERVEROUT ON;
SET HEA OFF PAGES 0;
DECLARE
l_line INTEGER := 0;
l_b1 VARCHAR2(300) := '| | Active || Top #1 SQL | || Top #1 Event | || Top #1 PDB | |'; -- begin line 1
l_b2 VARCHAR2(300) := '| Sample Time | Sessions || Sessions | Top #1 SQL || Sessions | Top #1 Timed Event || Sessions | Top #1 PDB |'; -- begin line 2
l_s1 VARCHAR2(300) := '+-------------------------+----------++------------+------------------------------------------------------------------++--------------+----------------------------------------------------++------------+-------------------------------------+'; -- spacer
l_l1 VARCHAR2(300); -- line
l_begin_peak DATE;
l_seconds NUMBER;
l_sessions_peak NUMBER;
l_sql_id_peak VARCHAR2(13);
l_con_id_peak NUMBER;
l_sql_text_peak VARCHAR2(1000);
l_session_state_peak VARCHAR2(30);
l_wait_class_peak VARCHAR2(255);
l_event_peak VARCHAR2(255);
l_pdb_name_peak VARCHAR2(128);
BEGIN
DELETE plan_table;
IF &&times_cpu_cores. = 0 THEN
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
END IF;
FOR i IN (
WITH
threshold AS (
SELECT /*+ MATERIALIZE NO_MERGE */ &&times_cpu_cores. * value AS value FROM v$osstat WHERE stat_name = 'NUM_CPU_CORES' AND ROWNUM >= 1 /* MATERIALIZE */
),
active_sessions_time_series AS (
SELECT /*+ MATERIALIZE NO_MERGE */
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"') AS sql_id,
COUNT(*) AS active_sessions
FROM dba_hist_active_sess_history h
WHERE 1 = 1
AND '&&include_hist.' = 'Y'
AND h.dbid = &&cs_dbid. AND h.instance_number = &&cs_instance_number. AND h.snap_id BETWEEN &&cs_snap_id_from. AND &&cs_snap_id_to.
-- AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND (TO_NUMBER('&&cs_con_id.') IN (0, 1, h.con_id) OR h.con_id IN (0, 1)) -- now we include CDB$ROOT samples when executed from a PDB
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"')
UNION
SELECT /*+ MATERIALIZE NO_MERGE */
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"') AS sql_id,
COUNT(*) AS active_sessions
FROM v$active_session_history h
WHERE 1 = 1
AND '&&include_mem.' = 'Y'
-- AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND (TO_NUMBER('&&cs_con_id.') IN (0, 1, h.con_id) OR h.con_id IN (0, 1)) -- now we include CDB$ROOT samples when executed from a PDB
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"')
),
time_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
SUM(active_sessions) AS active_sessions,
LAG(SUM(active_sessions)) OVER (ORDER BY sample_time) AS lag_active_sessions,
LEAD(SUM(active_sessions)) OVER (ORDER BY sample_time) AS lead_active_sessions
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time
),
t AS (
SELECT /*+ MATERIALIZE NO_MERGE */
t.sample_time,
t.active_sessions,
CASE WHEN t.active_sessions < threshold.value AND t.lead_active_sessions >= threshold.value THEN 'Y' END AS b,
CASE WHEN t.active_sessions >= threshold.value THEN 'Y' END AS p,
CASE WHEN t.active_sessions < threshold.value AND t.lag_active_sessions >= threshold.value THEN 'Y' END AS e
FROM threshold,
time_dim t
WHERE (t.active_sessions >= threshold.value OR t.lag_active_sessions >= threshold.value OR t.lead_active_sessions >= threshold.value)
AND ROWNUM >= 1 /* MATERIALIZE */
),
con_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
con_id,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
con_id
),
c AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
con_id,
active_sessions
FROM con_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
),
eve_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
session_state,
wait_class,
event,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
session_state,
wait_class,
event
),
e AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
session_state,
wait_class,
event,
active_sessions
FROM eve_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
),
sql_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
sql_id,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
sql_id
),
s AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
sql_id,
active_sessions
FROM sql_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
)
SELECT t.sample_time,
t.active_sessions,
t.b,
t.p,
t.e,
s.active_sessions AS s_active_sessions,
s.sql_id,
(SELECT /*+ NO_MERGE */ REPLACE(v.sql_text, CHR(39)) FROM v$sql v WHERE s.sql_id <> '"null"' AND v.sql_id = s.sql_id AND ROWNUM = 1 /* MATERIALIZE */) AS sql_text,
e.active_sessions AS e_active_sessions,
e.session_state,
e.wait_class,
e.event,
c.active_sessions AS c_active_sessions,
(SELECT /*+ NO_MERGE */ v.name FROM v$containers v WHERE v.con_id = c.con_id AND ROWNUM = 1 /* MATERIALIZE */) AS pdb_name,
c.con_id
FROM t, c, e, s
WHERE c.sample_time = t.sample_time
AND e.sample_time = t.sample_time
AND s.sample_time = t.sample_time
ORDER BY
t.sample_time
)
LOOP
l_line := l_line + 1;
l_l1 :=
'| '||TO_CHAR(i.sample_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')||
' | '||TO_CHAR(i.active_sessions, '999,990')||
' || '||TO_CHAR(i.s_active_sessions, '999,990')||
' | '||RPAD(i.sql_id, 13)||
' '||RPAD(COALESCE(i.sql_text, ' '), 50)||
' || '||TO_CHAR(i.e_active_sessions, '999,990')||
' | '||RPAD(CASE i.session_state WHEN 'ON CPU' THEN i.session_state ELSE i.wait_class||' - '||i.event END, 50)||
' || '||TO_CHAR(i.c_active_sessions, '999,990')||
' | '||RPAD(i.pdb_name||'('||i.con_id||')', 35)||
' | ';
IF i.e = 'Y' AND i.b = 'Y' THEN -- end of peak followed by begin of peak (same row is both)
DBMS_OUTPUT.put_line(l_l1);
l_seconds := ROUND((CAST(i.sample_time AS DATE) - l_begin_peak) * 24 * 3600);
-- DBMS_OUTPUT.put_line(TO_CHAR(l_begin_peak, 'YYYY-MM-DD"T"HH24:MI:SS')||' '||l_seconds||' '||l_sessions_peak);
INSERT INTO plan_table (timestamp, cost, cardinality, statement_id, plan_id, remarks, operation, options, object_node, object_owner, object_type)
VALUES (l_begin_peak, l_seconds, l_sessions_peak, l_sql_id_peak, l_con_id_peak, l_sql_text_peak, l_session_state_peak, l_wait_class_peak, l_event_peak, l_pdb_name_peak, 'GLOBAL');
DBMS_OUTPUT.put_line(l_s1);
END IF;
IF i.b = 'Y' THEN -- begin of peak
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
l_begin_peak := NULL; l_sessions_peak := 0; l_sql_id_peak := NULL; l_con_id_peak := NULL; l_sql_text_peak := NULL; l_session_state_peak := NULL; l_wait_class_peak := NULL; l_event_peak := NULL; l_pdb_name_peak := NULL;
END IF;
DBMS_OUTPUT.put_line(l_l1); -- line
IF i.active_sessions > l_sessions_peak THEN
l_sessions_peak := i.active_sessions;
l_sql_id_peak := i.sql_id;
l_con_id_peak := i.con_id;
l_sql_text_peak := i.sql_text;
l_session_state_peak := i.session_state;
l_wait_class_peak := i.wait_class;
l_event_peak := i.event;
l_pdb_name_peak := i.pdb_name;
END IF;
IF i.e IS NULL AND i.b IS NULL AND l_begin_peak IS NULL THEN -- first line after a begin-peak
l_begin_peak := CAST(i.sample_time AS DATE);
END IF;
IF i.e = 'Y' AND i.b IS NULL THEN -- end of peak
l_seconds := ROUND((CAST(i.sample_time AS DATE) - l_begin_peak) * 24 * 3600);
-- DBMS_OUTPUT.put_line(TO_CHAR(l_begin_peak, 'YYYY-MM-DD"T"HH24:MI:SS')||' '||l_seconds||' '||l_sessions_peak);
INSERT INTO plan_table (timestamp, cost, cardinality, statement_id, plan_id, remarks, operation, options, object_node, object_owner, object_type)
VALUES (l_begin_peak, l_seconds, l_sessions_peak, l_sql_id_peak, l_con_id_peak, l_sql_text_peak, l_session_state_peak, l_wait_class_peak, l_event_peak, l_pdb_name_peak, 'GLOBAL');
DBMS_OUTPUT.put_line(l_s1);
END IF;
IF &&times_cpu_cores. = 0 AND MOD(l_line, 100) = 0 THEN -- heading every 100 rows when executed requesting all sample times and not just peaks
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
END IF;
END LOOP;
IF &&times_cpu_cores. = 0 THEN
DBMS_OUTPUT.put_line(l_s1); -- separator when executed requesting all sample times and not just peaks
END IF;
COMMIT;
END;
/
SET HEA ON PAGES 5000 SERVEROUT OFF;
PRO NOTE: Sum of Active Sessions per AWR sampled time, when greater than &&times_cpu_cores.x NUM_CPU_CORES(&&cs_num_cpu_cores.). Report includes for each sampled time Top #1: SQL, Timed Event and PDB; with corresponding Sum of Active Sessions for each of these 3 dimensions.
/*
plan_table mapping
Name Null? Type
----------------------------------------- -------- ----------------------------
STATEMENT_ID VARCHAR2(30) sql_id
PLAN_ID NUMBER con_id
TIMESTAMP DATE begin_peak
REMARKS VARCHAR2(4000) sql_text
OPERATION VARCHAR2(30) session_state
OPTIONS VARCHAR2(255) wait_class
OBJECT_NODE VARCHAR2(128) event
OBJECT_OWNER VARCHAR2(128) pdb_name
OBJECT_NAME VARCHAR2(128)
OBJECT_ALIAS VARCHAR2(261)
OBJECT_INSTANCE NUMBER(38)
OBJECT_TYPE VARCHAR2(30) global
OPTIMIZER VARCHAR2(255)
SEARCH_COLUMNS NUMBER
ID NUMBER(38)
PARENT_ID NUMBER(38)
DEPTH NUMBER(38)
POSITION NUMBER(38)
COST NUMBER(38) seconds
CARDINALITY NUMBER(38) sessions_peak
BYTES NUMBER(38)
OTHER_TAG VARCHAR2(255)
PARTITION_START VARCHAR2(255)
PARTITION_STOP VARCHAR2(255)
PARTITION_ID NUMBER(38)
OTHER LONG
OTHER_XML CLOB
DISTRIBUTION VARCHAR2(30)
CPU_COST NUMBER(38)
IO_COST NUMBER(38)
TEMP_SPACE NUMBER(38)
ACCESS_PREDICATES VARCHAR2(4000)
FILTER_PREDICATES VARCHAR2(4000)
PROJECTION VARCHAR2(4000)
TIME NUMBER(38)
QBLOCK_NAME VARCHAR2(128)
SELECT TO_CHAR(timestamp, 'YYYY-MM-DD"T"HH24:MI:SS') AS begin_peak,
TO_CHAR(timestamp + (cost/3600/24), 'YYYY-MM-DD"T"HH24:MI:SS') AS end_peak,
cost AS seconds,
cardinality AS sessions_peak,
-- statement_id AS sql_id,
-- remarks AS sql_text,
statement_id||' '||SUBSTR(remarks, 1, 50) AS sql_statement,
-- operation AS session_state,
-- options AS wait_class,
-- object_node AS event,
CASE operation WHEN 'ON CPU' THEN operation ELSE options||' - '||object_node END AS timed_event,
-- object_owner AS pdb_name,
-- plan_id AS con_id
object_owner||'('||plan_id||')' AS pdb_name
FROM plan_table
ORDER BY 1;
*/
csierra/cs_internal/cs_active_sessions_peaks_internal_v5_s.sql
+293
View File
@@ -0,0 +1,293 @@
--SET HEA OFF PAGES 0 SERVEROUT ON;
SET HEA OFF PAGES 0;
DECLARE
l_line INTEGER := 0;
l_b1 VARCHAR2(300) := '| | Active || Top #1 SQL | || Top #1 Event | || Top #1 PDB | |'; -- begin line 1
l_b2 VARCHAR2(300) := '| Sample Time | Sessions || Sessions | Top #1 SQL || Sessions | Top #1 Timed Event || Sessions | Top #1 PDB |'; -- begin line 2
l_s1 VARCHAR2(300) := '+-------------------------+----------++------------+------------------------------------------------------------------++--------------+----------------------------------------------------++------------+-------------------------------------+'; -- spacer
l_l1 VARCHAR2(300); -- line
l_begin_peak DATE;
l_seconds NUMBER;
l_sessions_peak NUMBER;
l_sql_id_peak VARCHAR2(13);
l_con_id_peak NUMBER;
l_sql_text_peak VARCHAR2(1000);
l_session_state_peak VARCHAR2(30);
l_wait_class_peak VARCHAR2(255);
l_event_peak VARCHAR2(255);
l_pdb_name_peak VARCHAR2(128);
BEGIN
DELETE plan_table;
IF &&times_cpu_cores. = 0 THEN
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
END IF;
FOR i IN (
WITH
threshold AS (
SELECT /*+ MATERIALIZE NO_MERGE */ &&times_cpu_cores. * value AS value FROM v$osstat WHERE stat_name = 'NUM_CPU_CORES' AND ROWNUM >= 1 /* MATERIALIZE */
),
active_sessions_time_series AS (
SELECT /*+ MATERIALIZE NO_MERGE */
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"') AS sql_id,
COUNT(*) AS active_sessions
FROM &&ash_view. h
WHERE 1 = 1
-- AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND (TO_NUMBER('&&cs_con_id.') IN (0, 1, h.con_id) OR h.con_id IN (0, 1)) -- now we include CDB$ROOT samples when executed from a PDB
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
h.sample_time,
h.con_id,
h.session_state,
h.wait_class,
h.event,
COALESCE(h.sql_id, h.top_level_sql_id, '"null"')
),
time_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
SUM(active_sessions) AS active_sessions,
LAG(SUM(active_sessions)) OVER (ORDER BY sample_time) AS lag_active_sessions,
LEAD(SUM(active_sessions)) OVER (ORDER BY sample_time) AS lead_active_sessions
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time
),
t AS (
SELECT /*+ MATERIALIZE NO_MERGE */
t.sample_time,
t.active_sessions,
CASE WHEN t.active_sessions < threshold.value AND t.lead_active_sessions >= threshold.value THEN 'Y' END AS b,
CASE WHEN t.active_sessions >= threshold.value THEN 'Y' END AS p,
CASE WHEN t.active_sessions < threshold.value AND t.lag_active_sessions >= threshold.value THEN 'Y' END AS e
FROM threshold,
time_dim t
WHERE (t.active_sessions >= threshold.value OR t.lag_active_sessions >= threshold.value OR t.lead_active_sessions >= threshold.value)
AND ROWNUM >= 1 /* MATERIALIZE */
),
con_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
con_id,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
con_id
),
c AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
con_id,
active_sessions
FROM con_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
),
eve_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
session_state,
wait_class,
event,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
session_state,
wait_class,
event
),
e AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
session_state,
wait_class,
event,
active_sessions
FROM eve_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
),
sql_dim AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
sql_id,
SUM(active_sessions) AS active_sessions,
ROW_NUMBER() OVER (PARTITION BY sample_time ORDER BY SUM(active_sessions) DESC) AS rn
FROM active_sessions_time_series
WHERE ROWNUM >= 1 /* MATERIALIZE */
GROUP BY
sample_time,
sql_id
),
s AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_time,
sql_id,
active_sessions
FROM sql_dim
WHERE rn = 1
AND ROWNUM >= 1 /* MATERIALIZE */
)
SELECT t.sample_time,
t.active_sessions,
t.b,
t.p,
t.e,
s.active_sessions AS s_active_sessions,
s.sql_id,
(SELECT /*+ NO_MERGE */ REPLACE(v.sql_text, CHR(39)) FROM v$sql v WHERE s.sql_id <> '"null"' AND v.sql_id = s.sql_id AND ROWNUM = 1 /* MATERIALIZE */) AS sql_text,
e.active_sessions AS e_active_sessions,
e.session_state,
e.wait_class,
e.event,
c.active_sessions AS c_active_sessions,
(SELECT /*+ NO_MERGE */ v.name FROM v$containers v WHERE v.con_id = c.con_id AND ROWNUM = 1 /* MATERIALIZE */) AS pdb_name,
c.con_id
FROM t, c, e, s
WHERE c.sample_time = t.sample_time
AND e.sample_time = t.sample_time
AND s.sample_time = t.sample_time
ORDER BY
t.sample_time
)
LOOP
l_line := l_line + 1;
l_l1 :=
'| '||TO_CHAR(i.sample_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')||
' | '||TO_CHAR(i.active_sessions, '999,990')||
' || '||TO_CHAR(i.s_active_sessions, '999,990')||
' | '||RPAD(i.sql_id, 13)||
' '||RPAD(COALESCE(i.sql_text, ' '), 50)||
' || '||TO_CHAR(i.e_active_sessions, '999,990')||
' | '||RPAD(CASE i.session_state WHEN 'ON CPU' THEN i.session_state ELSE i.wait_class||' - '||i.event END, 50)||
' || '||TO_CHAR(i.c_active_sessions, '999,990')||
' | '||RPAD(i.pdb_name||'('||i.con_id||')', 35)||
' | ';
IF i.e = 'Y' AND i.b = 'Y' THEN -- end of peak followed by begin of peak (same row is both)
DBMS_OUTPUT.put_line(l_l1);
l_seconds := ROUND((CAST(i.sample_time AS DATE) - l_begin_peak) * 24 * 3600);
-- DBMS_OUTPUT.put_line(TO_CHAR(l_begin_peak, 'YYYY-MM-DD"T"HH24:MI:SS')||' '||l_seconds||' '||l_sessions_peak);
INSERT INTO plan_table (timestamp, cost, cardinality, statement_id, plan_id, remarks, operation, options, object_node, object_owner, object_type)
VALUES (l_begin_peak, l_seconds, l_sessions_peak, l_sql_id_peak, l_con_id_peak, l_sql_text_peak, l_session_state_peak, l_wait_class_peak, l_event_peak, l_pdb_name_peak, 'GLOBAL');
DBMS_OUTPUT.put_line(l_s1);
END IF;
IF i.b = 'Y' THEN -- begin of peak
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
l_begin_peak := NULL; l_sessions_peak := 0; l_sql_id_peak := NULL; l_con_id_peak := NULL; l_sql_text_peak := NULL; l_session_state_peak := NULL; l_wait_class_peak := NULL; l_event_peak := NULL; l_pdb_name_peak := NULL;
END IF;
DBMS_OUTPUT.put_line(l_l1); -- line
IF i.active_sessions > l_sessions_peak THEN
l_sessions_peak := i.active_sessions;
l_sql_id_peak := i.sql_id;
l_con_id_peak := i.con_id;
l_sql_text_peak := i.sql_text;
l_session_state_peak := i.session_state;
l_wait_class_peak := i.wait_class;
l_event_peak := i.event;
l_pdb_name_peak := i.pdb_name;
END IF;
IF i.e IS NULL AND i.b IS NULL AND l_begin_peak IS NULL THEN -- first line after a begin-peak
l_begin_peak := CAST(i.sample_time AS DATE);
END IF;
IF i.e = 'Y' AND i.b IS NULL THEN -- end of peak
l_seconds := ROUND((CAST(i.sample_time AS DATE) - l_begin_peak) * 24 * 3600);
-- DBMS_OUTPUT.put_line(TO_CHAR(l_begin_peak, 'YYYY-MM-DD"T"HH24:MI:SS')||' '||l_seconds||' '||l_sessions_peak);
INSERT INTO plan_table (timestamp, cost, cardinality, statement_id, plan_id, remarks, operation, options, object_node, object_owner, object_type)
VALUES (l_begin_peak, l_seconds, l_sessions_peak, l_sql_id_peak, l_con_id_peak, l_sql_text_peak, l_session_state_peak, l_wait_class_peak, l_event_peak, l_pdb_name_peak, 'GLOBAL');
DBMS_OUTPUT.put_line(l_s1);
END IF;
IF &&times_cpu_cores. = 0 AND MOD(l_line, 100) = 0 THEN -- heading every 100 rows when executed requesting all sample times and not just peaks
DBMS_OUTPUT.put_line(l_s1);
DBMS_OUTPUT.put_line(l_b1);
DBMS_OUTPUT.put_line(l_b2);
DBMS_OUTPUT.put_line(l_s1);
END IF;
END LOOP;
IF &&times_cpu_cores. = 0 THEN
DBMS_OUTPUT.put_line(l_s1); -- separator when executed requesting all sample times and not just peaks
END IF;
COMMIT;
END;
/
SET HEA ON PAGES 5000 SERVEROUT OFF;
PRO NOTE: Sum of Active Sessions per AWR sampled time, when greater than &&times_cpu_cores.x NUM_CPU_CORES(&&cs_num_cpu_cores.). Report includes for each sampled time Top #1: SQL, Timed Event and PDB; with corresponding Sum of Active Sessions for each of these 3 dimensions.
/*
plan_table mapping
Name Null? Type
----------------------------------------- -------- ----------------------------
STATEMENT_ID VARCHAR2(30) sql_id
PLAN_ID NUMBER con_id
TIMESTAMP DATE begin_peak
REMARKS VARCHAR2(4000) sql_text
OPERATION VARCHAR2(30) session_state
OPTIONS VARCHAR2(255) wait_class
OBJECT_NODE VARCHAR2(128) event
OBJECT_OWNER VARCHAR2(128) pdb_name
OBJECT_NAME VARCHAR2(128)
OBJECT_ALIAS VARCHAR2(261)
OBJECT_INSTANCE NUMBER(38)
OBJECT_TYPE VARCHAR2(30) global
OPTIMIZER VARCHAR2(255)
SEARCH_COLUMNS NUMBER
ID NUMBER(38)
PARENT_ID NUMBER(38)
DEPTH NUMBER(38)
POSITION NUMBER(38)
COST NUMBER(38) seconds
CARDINALITY NUMBER(38) sessions_peak
BYTES NUMBER(38)
OTHER_TAG VARCHAR2(255)
PARTITION_START VARCHAR2(255)
PARTITION_STOP VARCHAR2(255)
PARTITION_ID NUMBER(38)
OTHER LONG
OTHER_XML CLOB
DISTRIBUTION VARCHAR2(30)
CPU_COST NUMBER(38)
IO_COST NUMBER(38)
TEMP_SPACE NUMBER(38)
ACCESS_PREDICATES VARCHAR2(4000)
FILTER_PREDICATES VARCHAR2(4000)
PROJECTION VARCHAR2(4000)
TIME NUMBER(38)
QBLOCK_NAME VARCHAR2(128)
SELECT TO_CHAR(timestamp, 'YYYY-MM-DD"T"HH24:MI:SS') AS begin_peak,
TO_CHAR(timestamp + (cost/3600/24), 'YYYY-MM-DD"T"HH24:MI:SS') AS end_peak,
cost AS seconds,
cardinality AS sessions_peak,
-- statement_id AS sql_id,
-- remarks AS sql_text,
statement_id||' '||SUBSTR(remarks, 1, 50) AS sql_statement,
-- operation AS session_state,
-- options AS wait_class,
-- object_node AS event,
CASE operation WHEN 'ON CPU' THEN operation ELSE options||' - '||object_node END AS timed_event,
-- object_owner AS pdb_name,
-- plan_id AS con_id
object_owner||'('||plan_id||')' AS pdb_name
FROM plan_table
ORDER BY 1;
*/
csierra/cs_internal/cs_active_sessions_peaks_internal_v6.sql
+33
View File
@@ -0,0 +1,33 @@
PRO
PRO Active Sessions Peaks (when greater than &&times_cpu_cores.x NUM_CPU_CORES)
PRO ~~~~~~~~~~~~~~~~~~~~~
COL begin_peak FOR A19 HEA 'Aprox|Start Time';
COL end_peak FOR A19 HEA 'Aprox|End Time';
COL seconds FOR 999,990 HEA 'Aprox|Secs';
COL sessions_peak FOR 999,990 HEA 'Max|Sessions';
COL sql_statement FOR A64 HEA 'Top SQL Statement' TRUNC;
COL timed_event FOR A50 HEA 'Top Timed Event' TRUNC;
COL pdb_name FOR A35 HEA 'Top PDB Name(CON_ID)' TRUNC;
--
BREAK ON REPORT;
COMPUTE SUM OF seconds ON REPORT;
--
SELECT TO_CHAR(timestamp, 'YYYY-MM-DD"T"HH24:MI:SS') AS begin_peak,
TO_CHAR(timestamp + (cost/3600/24), 'YYYY-MM-DD"T"HH24:MI:SS') AS end_peak,
cost AS seconds,
cardinality AS sessions_peak,
-- statement_id AS sql_id,
-- remarks AS sql_text,
statement_id||' '||SUBSTR(remarks, 1, 50) AS sql_statement,
-- operation AS session_state,
-- options AS wait_class,
-- object_node AS event,
CASE operation WHEN 'ON CPU' THEN operation ELSE options||' - '||object_node END AS timed_event,
-- object_owner AS pdb_name,
-- plan_id AS con_id
object_owner||'('||plan_id||')' AS pdb_name
FROM plan_table
ORDER BY 1
/
--
PRO NOTE: Displayed values for 3 dimensions (SQL, Timed Event and PDB), correspond to sample time of Max Sessions
csierra/cs_internal/cs_ash_analytics_footer.sql
+15
View File
@@ -0,0 +1,15 @@
PRO <pre>
PRO #01 &&aas_01. &&series_01.
PRO #02 &&aas_02. &&series_02.
PRO #03 &&aas_03. &&series_03.
PRO #04 &&aas_04. &&series_04.
PRO #05 &&aas_05. &&series_05.
PRO #06 &&aas_06. &&series_06.
PRO #07 &&aas_07. &&series_07.
PRO #08 &&aas_08. &&series_08.
PRO #09 &&aas_09. &&series_09.
PRO #10 &&aas_10. &&series_10.
PRO #11 &&aas_11. &&series_11.
PRO #12 &&aas_12. &&series_12.
PRO #13 &&aas_13. &&series_13.
PRO </pre>
csierra/cs_internal/cs_ash_block_chains.sql
+178
View File
@@ -0,0 +1,178 @@
SET PAGES 0;
COL block_chain FOR A100 HEA 'Blocked Sessions and its Blockers Chain';
PRO
PRO Block Chains (when blocked sessions are over &&times_cpu_cores.x NUM_CPU_CORES, between &&cs_sample_time_from. and &&cs_sample_time_to. UTC)
PRO ~~~~~~~~~~~~
WITH
constants AS
(SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT o.value AS num_cpu_cores, d.name AS db_name, (SELECT /*+ MATERIALIZE NO_MERGE */ COUNT(*) FROM v$containers WHERE con_id > 2 AND ROWNUM >= 1) AS containers FROM v$osstat o, v$database d WHERE o.stat_name = 'NUM_CPU_CORES' AND ROWNUM >= 1
),
sess_proc AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sid, s.serial#, p.spid, p.pname FROM v$session s, v$process p WHERE p.addr = s.paddr AND ROWNUM >= 1
),
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sql_id, SUBSTR(s.sql_text, 1, 40) AS sql_text FROM v$sqlstats s WHERE ROWNUM >= 1
),
procedures AS (
SELECT /*+ OPT_PARAM('_px_cdb_view_enabled' 'FALSE') MATERIALIZE NO_MERGE */ DISTINCT p.con_id, p.object_id, p.subprogram_id, p.owner, p.object_name, p.procedure_name FROM cdb_procedures p WHERE ROWNUM >= 1
),
ash AS (
SELECT /*+ MATERIALIZE NO_MERGE */ h.sample_id, h.sample_time, h.session_state, h.wait_class, h.event, h.session_id, h.session_serial#, h.blocking_session, h.blocking_session_serial#, COALESCE(h.sql_id, h.top_level_sql_id) AS sql_id, h.module, h.machine, c.name AS pdb_name, h.con_id, h.plsql_entry_object_id, h.plsql_entry_subprogram_id
FROM dba_hist_active_sess_history h, v$containers c
WHERE 1 = 1
AND '&&include_hist.' = 'Y'
AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND h.dbid = TO_NUMBER('&&cs_dbid.')
AND h.instance_number = TO_NUMBER('&&cs_instance_number.')
AND h.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.')
AND c.con_id(+) = h.con_id
AND ROWNUM >= 1
UNION
SELECT /*+ MATERIALIZE NO_MERGE */ h.sample_id, h.sample_time, h.session_state, h.wait_class, h.event, h.session_id, h.session_serial#, h.blocking_session, h.blocking_session_serial#, COALESCE(h.sql_id, h.top_level_sql_id) AS sql_id, h.module, h.machine, c.name AS pdb_name, h.con_id, h.plsql_entry_object_id, h.plsql_entry_subprogram_id
FROM v$active_session_history h, v$containers c
WHERE 1 = 1
AND '&&include_mem.' = 'Y'
AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND c.con_id(+) = h.con_id
AND ROWNUM >= 1
),
ash_extended AS (
SELECT /*+ MATERIALIZE NO_MERGE ORDERED */
h0.sample_time, COUNT(*) AS sessions, h0.session_state||' on: "'||h0.wait_class||' - '||h0.event||'"' AS h0_timed_event,
--
h0.blocking_session||CASE WHEN h0.blocking_session IS NOT NULL THEN ',' END||h0.blocking_session_serial# AS h1_session_serial,
CASE h1.session_state WHEN 'ON CPU' THEN h1.session_state WHEN 'WAITING' THEN h1.session_state||' on: "'||h1.wait_class||' - '||h1.event||'"' END h1_timed_event,
h1.sql_id AS h1_sql_id, h1.module AS h1_module, h1.machine AS h1_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h0.blocking_session AND p.serial# = h0.blocking_session_serial#) AS h1_pname, s1.sql_text AS s1_sql_text,
p1.owner||CASE WHEN p1.object_name IS NOT NULL THEN '.'||p1.object_name END||CASE WHEN p1.procedure_name IS NOT NULL THEN '.'||p1.procedure_name END AS p1_proced_name,
--
h1.blocking_session||CASE WHEN h1.blocking_session IS NOT NULL THEN ',' END||h1.blocking_session_serial# AS h2_session_serial,
CASE h2.session_state WHEN 'ON CPU' THEN h2.session_state WHEN 'WAITING' THEN h2.session_state||' on: "'||h2.wait_class||' - '||h2.event||'"' END h2_timed_event,
h2.sql_id AS h2_sql_id, h2.module AS h2_module, h2.machine AS h2_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h1.blocking_session AND p.serial# = h1.blocking_session_serial#) AS h2_pname, s2.sql_text AS s2_sql_text,
p2.owner||CASE WHEN p2.object_name IS NOT NULL THEN '.'||p2.object_name END||CASE WHEN p2.procedure_name IS NOT NULL THEN '.'||p2.procedure_name END AS p2_proced_name,
--
h2.blocking_session||CASE WHEN h2.blocking_session IS NOT NULL THEN ',' END||h2.blocking_session_serial# AS h3_session_serial,
CASE h3.session_state WHEN 'ON CPU' THEN h3.session_state WHEN 'WAITING' THEN h4.session_state||' on: "'||h3.wait_class||' - '||h3.event||'"' END h3_timed_event,
h3.sql_id AS h3_sql_id, h3.module AS h3_module, h3.machine AS h3_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h2.blocking_session AND p.serial# = h2.blocking_session_serial#) AS h3_pname, s3.sql_text AS s3_sql_text,
p3.owner||CASE WHEN p3.object_name IS NOT NULL THEN '.'||p3.object_name END||CASE WHEN p3.procedure_name IS NOT NULL THEN '.'||p3.procedure_name END AS p3_proced_name,
--
h3.blocking_session||CASE WHEN h3.blocking_session IS NOT NULL THEN ',' END||h3.blocking_session_serial# AS h4_session_serial,
CASE h4.session_state WHEN 'ON CPU' THEN h4.session_state WHEN 'WAITING' THEN h1.session_state||' on: "'||h4.wait_class||' - '||h4.event||'"' END h4_timed_event,
h4.sql_id AS h4_sql_id, h4.module AS h4_module, h4.machine AS h4_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h3.blocking_session AND p.serial# = h3.blocking_session_serial#) AS h4_pname, s4.sql_text AS s4_sql_text,
p4.owner||CASE WHEN p4.object_name IS NOT NULL THEN '.'||p4.object_name END||CASE WHEN p4.procedure_name IS NOT NULL THEN '.'||p4.procedure_name END AS p4_proced_name
FROM ash h0, ash h1, ash h2, ash h3, ash h4, sqlstats s1, sqlstats s2, sqlstats s3, sqlstats s4, procedures p1, procedures p2, procedures p3, procedures p4
WHERE h0.session_state = 'WAITING'
AND h0.blocking_session IS NOT NULL
AND h0.blocking_session_serial# IS NOT NULL
--
AND h1.sample_id(+) = h0.sample_id
AND h1.session_id(+) = h0.blocking_session
AND h1.session_serial#(+) = h0.blocking_session_serial#
AND s1.sql_id(+) = h1.sql_id
--
AND h2.sample_id(+) = h1.sample_id
AND h2.session_id(+) = h1.blocking_session
AND h2.session_serial#(+) = h1.blocking_session_serial#
AND s2.sql_id(+) = h2.sql_id
--
AND h3.sample_id(+) = h2.sample_id
AND h3.session_id(+) = h2.blocking_session
AND h3.session_serial#(+) = h2.blocking_session_serial#
AND s3.sql_id(+) = h3.sql_id
--
AND h4.sample_id(+) = h3.sample_id
AND h4.session_id(+) = h3.blocking_session
AND h4.session_serial#(+) = h3.blocking_session_serial#
AND s4.sql_id(+) = h4.sql_id
--
AND p1.con_id(+) = h1.con_id
AND p1.object_id(+) = h1.plsql_entry_object_id
AND p1.subprogram_id(+) = h1.plsql_entry_subprogram_id
--
AND p2.con_id(+) = h2.con_id
AND p2.object_id(+) = h2.plsql_entry_object_id
AND p2.subprogram_id(+) = h2.plsql_entry_subprogram_id
--
AND p3.con_id(+) = h3.con_id
AND p3.object_id(+) = h3.plsql_entry_object_id
AND p3.subprogram_id(+) = h3.plsql_entry_subprogram_id
--
AND p4.con_id(+) = h4.con_id
AND p4.object_id(+) = h4.plsql_entry_object_id
AND p4.subprogram_id(+) = h4.plsql_entry_subprogram_id
--
AND ROWNUM >= 1
GROUP BY
h0.sample_time, h0.session_state, h0.wait_class, h0.event,
h0.blocking_session, h0.blocking_session_serial#, h1.session_state, h1.wait_class, h1.event, h1.sql_id, h1.module, h1.machine, s1.sql_text, h1.con_id, h1.plsql_entry_object_id, h1.plsql_entry_subprogram_id, p1.owner, p1.object_name, p1.procedure_name,
h1.blocking_session, h1.blocking_session_serial#, h2.session_state, h2.wait_class, h2.event, h2.sql_id, h2.module, h2.machine, s2.sql_text, h2.con_id, h2.plsql_entry_object_id, h2.plsql_entry_subprogram_id, p2.owner, p2.object_name, p2.procedure_name,
h2.blocking_session, h2.blocking_session_serial#, h3.session_state, h3.wait_class, h3.event, h3.sql_id, h3.module, h3.machine, s3.sql_text, h3.con_id, h3.plsql_entry_object_id, h3.plsql_entry_subprogram_id, p3.owner, p3.object_name, p3.procedure_name,
h3.blocking_session, h3.blocking_session_serial#, h4.session_state, h4.wait_class, h4.event, h4.sql_id, h4.module, h4.machine, s4.sql_text, h4.con_id, h4.plsql_entry_object_id, h4.plsql_entry_subprogram_id, p4.owner, p4.object_name, p4.procedure_name
),
final AS (
SELECT /*+ MATERIALIZE NO_MERGE */
'+----------------------------------------------------------------'||
CHR(10)||'| 1. On '||TO_CHAR(h.sample_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')||' ('||TRIM(TO_CHAR(h.sample_time, 'Day'))||')'||
CHR(10)||'| '||TRIM(TO_CHAR(h.sessions, '999,990'))||' Active Sessions'||
CHR(10)||'| from CDB '||c.db_name||', which hosts '||c.containers||' PDBs with '||c.num_cpu_cores||' CPU Cores'||
CHR(10)||'| '||h.h0_timed_event||
CASE WHEN h1_session_serial IS NOT NULL THEN
CHR(10)||'| *** were blocked by session below: ***'||
CHR(10)||'| 2. sid,ser: '||h1_session_serial||
CASE WHEN h1_pname IS NOT NULL THEN CHR(10)||'| process: '||h1_pname END||
CASE WHEN h1_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h1_sql_id||' '||s1_sql_text END||
CASE WHEN h1_module IS NOT NULL THEN CHR(10)||'| module : '||h1_module END||
CASE WHEN p1_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p1_proced_name END||
CASE WHEN h1_machine IS NOT NULL THEN CHR(10)||'| machine: '||h1_machine END||
CASE WHEN h1_timed_event IS NOT NULL THEN CHR(10)||'| '||h1_timed_event END
END||
CASE WHEN h2_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 3. sid,ser: '||h2_session_serial||
CASE WHEN h2_pname IS NOT NULL THEN CHR(10)||'| process: '||h2_pname END||
CASE WHEN h2_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h2_sql_id||' '||s2_sql_text END||
CASE WHEN h2_module IS NOT NULL THEN CHR(10)||'| module : '||h2_module END||
CASE WHEN p2_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p2_proced_name END||
CASE WHEN h2_machine IS NOT NULL THEN CHR(10)||'| machine: '||h2_machine END||
CASE WHEN h2_timed_event IS NOT NULL THEN CHR(10)||'| '||h2_timed_event END
END||
CASE WHEN h3_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 4. sid,ser: '||h3_session_serial||
CASE WHEN h3_pname IS NOT NULL THEN CHR(10)||'| process: '||h3_pname END||
CASE WHEN h3_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h3_sql_id||' '||s3_sql_text END||
CASE WHEN h3_module IS NOT NULL THEN CHR(10)||'| module : '||h3_module END||
CASE WHEN p3_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p3_proced_name END||
CASE WHEN h3_machine IS NOT NULL THEN CHR(10)||'| machine: '||h3_machine END||
CASE WHEN h3_timed_event IS NOT NULL THEN CHR(10)||'| '||h3_timed_event END
END||
CASE WHEN h4_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 5. sid,ser: '||h4_session_serial||
CASE WHEN h4_pname IS NOT NULL THEN CHR(10)||'| process: '||h4_pname END||
CASE WHEN h4_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h4_sql_id||' '||s4_sql_text END||
CASE WHEN h4_module IS NOT NULL THEN CHR(10)||'| module : '||h4_module END||
CASE WHEN p4_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p4_proced_name END||
CASE WHEN h4_machine IS NOT NULL THEN CHR(10)||'| machine: '||h4_machine END||
CASE WHEN h4_timed_event IS NOT NULL THEN CHR(10)||'| '||h4_timed_event END
END||
CHR(10)||'+----------------------------------------------------------------'
AS block_chain
FROM ash_extended h, constants c
WHERE h.sessions >= &&times_cpu_cores. * c.num_cpu_cores
AND ROWNUM >= 1
)
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
block_chain
FROM final
ORDER BY 1
/
SET PAGES 100;
csierra/cs_internal/cs_ash_block_chains_s.sql
+164
View File
@@ -0,0 +1,164 @@
SET PAGES 0;
COL block_chain FOR A100 HEA 'Blocked Sessions and its Blockers Chain';
PRO
PRO Block Chains (when blocked sessions are over &&times_cpu_cores.x NUM_CPU_CORES, between &&cs_sample_time_from. and &&cs_sample_time_to. UTC)
PRO ~~~~~~~~~~~~
WITH
constants AS
(SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT o.value AS num_cpu_cores, d.name AS db_name, (SELECT /*+ MATERIALIZE NO_MERGE */ COUNT(*) FROM v$containers WHERE con_id > 2 AND ROWNUM >= 1) AS containers FROM v$osstat o, v$database d WHERE o.stat_name = 'NUM_CPU_CORES' AND ROWNUM >= 1
),
sess_proc AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sid, s.serial#, p.spid, p.pname FROM v$session s, v$process p WHERE p.addr = s.paddr AND ROWNUM >= 1
),
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sql_id, SUBSTR(s.sql_text, 1, 40) AS sql_text FROM v$sqlstats s WHERE ROWNUM >= 1
),
procedures AS (
SELECT /*+ OPT_PARAM('_px_cdb_view_enabled' 'FALSE') MATERIALIZE NO_MERGE */ DISTINCT p.con_id, p.object_id, p.subprogram_id, p.owner, p.object_name, p.procedure_name FROM cdb_procedures p WHERE ROWNUM >= 1
),
ash AS (
SELECT /*+ MATERIALIZE NO_MERGE */ h.sample_id, h.sample_time, h.session_state, h.wait_class, h.event, h.session_id, h.session_serial#, h.blocking_session, h.blocking_session_serial#, COALESCE(h.sql_id, h.top_level_sql_id) AS sql_id, h.module, h.machine, c.name AS pdb_name, h.con_id, h.plsql_entry_object_id, h.plsql_entry_subprogram_id
FROM &&ash_view. h, v$containers c
WHERE 1 = 1
AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND c.con_id(+) = h.con_id
AND ROWNUM >= 1
),
ash_extended AS (
SELECT /*+ MATERIALIZE NO_MERGE ORDERED */
h0.sample_time, COUNT(*) AS sessions, h0.session_state||' on: "'||h0.wait_class||' - '||h0.event||'"' AS h0_timed_event,
--
h0.blocking_session||CASE WHEN h0.blocking_session IS NOT NULL THEN ',' END||h0.blocking_session_serial# AS h1_session_serial,
CASE h1.session_state WHEN 'ON CPU' THEN h1.session_state WHEN 'WAITING' THEN h1.session_state||' on: "'||h1.wait_class||' - '||h1.event||'"' END h1_timed_event,
h1.sql_id AS h1_sql_id, h1.module AS h1_module, h1.machine AS h1_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h0.blocking_session AND p.serial# = h0.blocking_session_serial#) AS h1_pname, s1.sql_text AS s1_sql_text,
p1.owner||CASE WHEN p1.object_name IS NOT NULL THEN '.'||p1.object_name END||CASE WHEN p1.procedure_name IS NOT NULL THEN '.'||p1.procedure_name END AS p1_proced_name,
--
h1.blocking_session||CASE WHEN h1.blocking_session IS NOT NULL THEN ',' END||h1.blocking_session_serial# AS h2_session_serial,
CASE h2.session_state WHEN 'ON CPU' THEN h2.session_state WHEN 'WAITING' THEN h2.session_state||' on: "'||h2.wait_class||' - '||h2.event||'"' END h2_timed_event,
h2.sql_id AS h2_sql_id, h2.module AS h2_module, h2.machine AS h2_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h1.blocking_session AND p.serial# = h1.blocking_session_serial#) AS h2_pname, s2.sql_text AS s2_sql_text,
p2.owner||CASE WHEN p2.object_name IS NOT NULL THEN '.'||p2.object_name END||CASE WHEN p2.procedure_name IS NOT NULL THEN '.'||p2.procedure_name END AS p2_proced_name,
--
h2.blocking_session||CASE WHEN h2.blocking_session IS NOT NULL THEN ',' END||h2.blocking_session_serial# AS h3_session_serial,
CASE h3.session_state WHEN 'ON CPU' THEN h3.session_state WHEN 'WAITING' THEN h4.session_state||' on: "'||h3.wait_class||' - '||h3.event||'"' END h3_timed_event,
h3.sql_id AS h3_sql_id, h3.module AS h3_module, h3.machine AS h3_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h2.blocking_session AND p.serial# = h2.blocking_session_serial#) AS h3_pname, s3.sql_text AS s3_sql_text,
p3.owner||CASE WHEN p3.object_name IS NOT NULL THEN '.'||p3.object_name END||CASE WHEN p3.procedure_name IS NOT NULL THEN '.'||p3.procedure_name END AS p3_proced_name,
--
h3.blocking_session||CASE WHEN h3.blocking_session IS NOT NULL THEN ',' END||h3.blocking_session_serial# AS h4_session_serial,
CASE h4.session_state WHEN 'ON CPU' THEN h4.session_state WHEN 'WAITING' THEN h1.session_state||' on: "'||h4.wait_class||' - '||h4.event||'"' END h4_timed_event,
h4.sql_id AS h4_sql_id, h4.module AS h4_module, h4.machine AS h4_machine,
(SELECT p.pname FROM sess_proc p WHERE p.sid = h3.blocking_session AND p.serial# = h3.blocking_session_serial#) AS h4_pname, s4.sql_text AS s4_sql_text,
p4.owner||CASE WHEN p4.object_name IS NOT NULL THEN '.'||p4.object_name END||CASE WHEN p4.procedure_name IS NOT NULL THEN '.'||p4.procedure_name END AS p4_proced_name
FROM ash h0, ash h1, ash h2, ash h3, ash h4, sqlstats s1, sqlstats s2, sqlstats s3, sqlstats s4, procedures p1, procedures p2, procedures p3, procedures p4
WHERE h0.session_state = 'WAITING'
AND h0.blocking_session IS NOT NULL
AND h0.blocking_session_serial# IS NOT NULL
--
AND h1.sample_id(+) = h0.sample_id
AND h1.session_id(+) = h0.blocking_session
AND h1.session_serial#(+) = h0.blocking_session_serial#
AND s1.sql_id(+) = h1.sql_id
--
AND h2.sample_id(+) = h1.sample_id
AND h2.session_id(+) = h1.blocking_session
AND h2.session_serial#(+) = h1.blocking_session_serial#
AND s2.sql_id(+) = h2.sql_id
--
AND h3.sample_id(+) = h2.sample_id
AND h3.session_id(+) = h2.blocking_session
AND h3.session_serial#(+) = h2.blocking_session_serial#
AND s3.sql_id(+) = h3.sql_id
--
AND h4.sample_id(+) = h3.sample_id
AND h4.session_id(+) = h3.blocking_session
AND h4.session_serial#(+) = h3.blocking_session_serial#
AND s4.sql_id(+) = h4.sql_id
--
AND p1.con_id(+) = h1.con_id
AND p1.object_id(+) = h1.plsql_entry_object_id
AND p1.subprogram_id(+) = h1.plsql_entry_subprogram_id
--
AND p2.con_id(+) = h2.con_id
AND p2.object_id(+) = h2.plsql_entry_object_id
AND p2.subprogram_id(+) = h2.plsql_entry_subprogram_id
--
AND p3.con_id(+) = h3.con_id
AND p3.object_id(+) = h3.plsql_entry_object_id
AND p3.subprogram_id(+) = h3.plsql_entry_subprogram_id
--
AND p4.con_id(+) = h4.con_id
AND p4.object_id(+) = h4.plsql_entry_object_id
AND p4.subprogram_id(+) = h4.plsql_entry_subprogram_id
--
AND ROWNUM >= 1
GROUP BY
h0.sample_time, h0.session_state, h0.wait_class, h0.event,
h0.blocking_session, h0.blocking_session_serial#, h1.session_state, h1.wait_class, h1.event, h1.sql_id, h1.module, h1.machine, s1.sql_text, h1.con_id, h1.plsql_entry_object_id, h1.plsql_entry_subprogram_id, p1.owner, p1.object_name, p1.procedure_name,
h1.blocking_session, h1.blocking_session_serial#, h2.session_state, h2.wait_class, h2.event, h2.sql_id, h2.module, h2.machine, s2.sql_text, h2.con_id, h2.plsql_entry_object_id, h2.plsql_entry_subprogram_id, p2.owner, p2.object_name, p2.procedure_name,
h2.blocking_session, h2.blocking_session_serial#, h3.session_state, h3.wait_class, h3.event, h3.sql_id, h3.module, h3.machine, s3.sql_text, h3.con_id, h3.plsql_entry_object_id, h3.plsql_entry_subprogram_id, p3.owner, p3.object_name, p3.procedure_name,
h3.blocking_session, h3.blocking_session_serial#, h4.session_state, h4.wait_class, h4.event, h4.sql_id, h4.module, h4.machine, s4.sql_text, h4.con_id, h4.plsql_entry_object_id, h4.plsql_entry_subprogram_id, p4.owner, p4.object_name, p4.procedure_name
),
final AS (
SELECT /*+ MATERIALIZE NO_MERGE */
'+----------------------------------------------------------------'||
CHR(10)||'| 1. On '||TO_CHAR(h.sample_time, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')||' ('||TRIM(TO_CHAR(h.sample_time, 'Day'))||')'||
CHR(10)||'| '||TRIM(TO_CHAR(h.sessions, '999,990'))||' Active Sessions'||
CHR(10)||'| from CDB '||c.db_name||', which hosts '||c.containers||' PDBs with '||c.num_cpu_cores||' CPU Cores'||
CHR(10)||'| '||h.h0_timed_event||
CASE WHEN h1_session_serial IS NOT NULL THEN
CHR(10)||'| *** were blocked by session below: ***'||
CHR(10)||'| 2. sid,ser: '||h1_session_serial||
CASE WHEN h1_pname IS NOT NULL THEN CHR(10)||'| process: '||h1_pname END||
CASE WHEN h1_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h1_sql_id||' '||s1_sql_text END||
CASE WHEN h1_module IS NOT NULL THEN CHR(10)||'| module : '||h1_module END||
CASE WHEN p1_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p1_proced_name END||
CASE WHEN h1_machine IS NOT NULL THEN CHR(10)||'| machine: '||h1_machine END||
CASE WHEN h1_timed_event IS NOT NULL THEN CHR(10)||'| '||h1_timed_event END
END||
CASE WHEN h2_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 3. sid,ser: '||h2_session_serial||
CASE WHEN h2_pname IS NOT NULL THEN CHR(10)||'| process: '||h2_pname END||
CASE WHEN h2_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h2_sql_id||' '||s2_sql_text END||
CASE WHEN h2_module IS NOT NULL THEN CHR(10)||'| module : '||h2_module END||
CASE WHEN p2_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p2_proced_name END||
CASE WHEN h2_machine IS NOT NULL THEN CHR(10)||'| machine: '||h2_machine END||
CASE WHEN h2_timed_event IS NOT NULL THEN CHR(10)||'| '||h2_timed_event END
END||
CASE WHEN h3_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 4. sid,ser: '||h3_session_serial||
CASE WHEN h3_pname IS NOT NULL THEN CHR(10)||'| process: '||h3_pname END||
CASE WHEN h3_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h3_sql_id||' '||s3_sql_text END||
CASE WHEN h3_module IS NOT NULL THEN CHR(10)||'| module : '||h3_module END||
CASE WHEN p3_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p3_proced_name END||
CASE WHEN h3_machine IS NOT NULL THEN CHR(10)||'| machine: '||h3_machine END||
CASE WHEN h3_timed_event IS NOT NULL THEN CHR(10)||'| '||h3_timed_event END
END||
CASE WHEN h4_session_serial IS NOT NULL THEN
CHR(10)||'| *** which was blocked by session below: ***'||
CHR(10)||'| 5. sid,ser: '||h4_session_serial||
CASE WHEN h4_pname IS NOT NULL THEN CHR(10)||'| process: '||h4_pname END||
CASE WHEN h4_sql_id IS NOT NULL THEN CHR(10)||'| sql_id : '||h4_sql_id||' '||s4_sql_text END||
CASE WHEN h4_module IS NOT NULL THEN CHR(10)||'| module : '||h4_module END||
CASE WHEN p4_proced_name IS NOT NULL THEN CHR(10)||'| library: '||p4_proced_name END||
CASE WHEN h4_machine IS NOT NULL THEN CHR(10)||'| machine: '||h4_machine END||
CASE WHEN h4_timed_event IS NOT NULL THEN CHR(10)||'| '||h4_timed_event END
END||
CHR(10)||'+----------------------------------------------------------------'
AS block_chain
FROM ash_extended h, constants c
WHERE h.sessions >= &&times_cpu_cores. * c.num_cpu_cores
AND ROWNUM >= 1
)
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
block_chain
FROM final
ORDER BY 1
/
SET PAGES 100;
csierra/cs_internal/cs_ash_sample_detail.sql
+196
View File
@@ -0,0 +1,196 @@
COL sql_text FOR A70 HEA 'SQL Text' TRUNC;
COL procedure_name FOR A70 HEA 'PL/SQL Library Entry Point' TRUNC &&cs_pl_sql_pri.;
COL module_action_program FOR A70 HEA 'Module Action Program' TRUNC;
COL sample_date_time FOR A23 HEA 'Sample Date and Time';
COL samples FOR 9999,999 HEA 'Active|Sessions';
COL on_cpu_or_wait_class FOR A14 HEA 'ON CPU or|Wait Class';
COL on_cpu_or_wait_event FOR A50 HEA 'ON CPU or Timed Event';
COL session_serial FOR A16 HEA 'Session,Serial';
COL machine FOR A60 HEA 'Machine or Application Server';
COL con_id FOR 999999;
COL plans FOR 99999 HEA 'Plans';
COL sessions FOR 9999,999 HEA 'Sessions|this SQL';
COL pdb_name FOR A30 HEA 'PDB Name' TRUNC;
COL sql_id FOR A13 HEA 'SQL_ID';
COL blocking_session_status FOR A11 HEA 'Blocker|Session|Status';
COL sql_plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
COL sql_plan_line_id FOR 9999 HEA 'Plan|Line';
COL sql_child_number FOR 999999 HEA 'Child|Number';
COL sql_exec_id FOR 99999999 HEA 'Exec ID';
COL xid FOR A16 HEA 'Transaction ID';
COL current_obj# FOR 9999999999 HEA 'Current|Obj#';
COL current_file# FOR 9999999999 HEA 'Current|File#';
COL current_block# FOR 9999999999 HEA 'Current|Block#';
COL current_row# FOR 9999999999 HEA 'Current|Row#';
COL in_connection_mgmt FOR A6 HEA 'In|Connec|Mgmt';
COL in_parse FOR A6 HEA 'In|Parse';
COL in_hard_parse FOR A6 HEA 'In|Hard|Parse';
COL in_sql_execution FOR A6 HEA 'In|SQL|Exec';
COL in_plsql_execution FOR A6 HEA 'In|PLSQL|Exec';
COL in_plsql_rpc FOR A6 HEA 'In|PLSQL|RPC';
COL in_plsql_compilation FOR A6 HEA 'In|PLSQL|Compil';
COL in_java_execution FOR A6 HEA 'In|Java|Exec';
COL in_bind FOR A6 HEA 'In|Bind';
COL in_cursor_close FOR A6 HEA 'In|Cursor|Close';
COL in_sequence_load FOR A6 HEA 'In|Seq|Load';
COL top_level_sql_id FOR A13 HEA 'Top Level|SQL_ID';
COL is_sqlid_current FOR A4 HEA 'Is|SQL|Exec';
COL blocking_session_serial FOR A16 HEA 'Blocker|Session,Serial';
COL blocking2_session_serial FOR A16 HEA 'Blocker(2)|Session,Serial';
COL blocking3_session_serial FOR A16 HEA 'Blocker(3)|Session,Serial';
COL blocking4_session_serial FOR A16 HEA 'Blocker(4)|Session,Serial';
COL blocking5_session_serial FOR A16 HEA 'Blocker(5)|Session,Serial';
COL blocking_machine FOR A60 HEA 'Machine or Application Server (blocker)';
COL deadlock FOR A4 HEA 'Dead|Lock';
COL lock_type FOR A4 HEA 'Lock';
COL lock_mode FOR A4 HEA 'Mode';
COL p1_p2_p3 FOR A100 HEA 'P1, P2, P3';
COL current_object_name FOR A40 HEA 'Current|Object Name (Object Type)' TRUNC;
COL secs_waited FOR 990.000 HEA 'Secs|Waited';
COL spid FOR A6;
COL pname FOR A5;
--
BREAK ON sample_date_time SKIP PAGE ON machine SKIP 1;
PRO
PRO ASH by sample time, appl server, session and SQL_ID
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
WITH /* cs_ash_sample_detail */
-- sess_proc AS (
-- SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sid, s.serial#, p.spid, p.pname FROM v$session s, v$process p WHERE p.addr = s.paddr AND ROWNUM >= 1
-- ),
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sql_id, s.sql_text FROM v$sqlstats s WHERE ROWNUM >= 1
),
procedures AS (
SELECT DISTINCT /*+ OPT_PARAM('_px_cdb_view_enabled' 'FALSE') MATERIALIZE NO_MERGE */ p.con_id, p.object_id, p.subprogram_id, p.owner, p.object_name, p.procedure_name FROM cdb_procedures p WHERE '&&cs_pl_sql.' = 'Y' AND ROWNUM >= 1
),
ash AS (
SELECT /*+ MATERIALIZE NO_MERGE */ h.*, c.name AS pdb_name
FROM &&ash_view. h, v$containers c
WHERE 1 = 1 &&ash_additional_predicate.
AND (TO_NUMBER('&&cs_con_id.') IN (0, 1, h.con_id) OR h.con_id IN (0, 1)) -- now we include CDB$ROOT samples when executed from a PDB
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ('&&cs2_machine.' IS NULL OR h.machine LIKE '%&&cs2_machine.%')
AND ('&&cs_sql_id.' IS NULL OR h.sql_id = '&&cs_sql_id.')
AND ('&&cs_only_dedup.' = 'N' OR (h.event = 'enq: TX - row lock contention' AND h.p1text LIKE 'name|mode%' AND h.p1 > 0 AND TO_CHAR(BITAND(h.p1, 65535)) = '4' AND h.current_obj# > 0 AND h.xid IS NOT NULL))
AND c.con_id(+) = h.con_id
AND ROWNUM >= 1
),
sess_proc AS (
SELECT /*+ MATERIALIZE NO_MERGE */ DISTINCT s.sid, s.serial#, p.spid, p.pname FROM v$session s, v$process p WHERE (s.sid, s.serial#) IN (SELECT DISTINCT session_id, session_serial# FROM ash) AND p.addr = s.paddr AND ROWNUM >= 1
),
sess AS (
SELECT /*+ MATERIALIZE NO_MERGE */
session_id,
session_serial#,
MAX(machine) machine
FROM ash
WHERE ROWNUM >= 1
GROUP BY
session_id,
session_serial#
)
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS ORDERED */
TO_CHAR(h.sample_time, '&&cs_timestamp_full_format.') sample_date_time,
h.machine,
h.con_id,
h.pdb_name,
sp.pname,
sp.spid,
's:'||h.session_id||','||h.session_serial# session_serial,
h.blocking_session_status,
CASE WHEN (h.session_id, h.session_serial#) IN ((b.blocking_session, b.blocking_session_serial#), (b2.blocking_session, b2.blocking_session_serial#)) THEN 'DL?' END deadlock,
CASE WHEN h.blocking_session IS NOT NULL THEN 'b:'||h.blocking_session||','||h.blocking_session_serial# END blocking_session_serial,
CASE WHEN b.blocking_session IS NOT NULL THEN 'b2:'||b.blocking_session||','||b.blocking_session_serial# END blocking2_session_serial,
CASE WHEN b2.blocking_session IS NOT NULL THEN 'b3:'||b2.blocking_session||','||b2.blocking_session_serial# END blocking3_session_serial,
CASE WHEN b3.blocking_session IS NOT NULL THEN 'b4:'||b3.blocking_session||','||b3.blocking_session_serial# END blocking4_session_serial,
CASE WHEN b4.blocking_session IS NOT NULL THEN 'b5:'||b4.blocking_session||','||b4.blocking_session_serial# END blocking5_session_serial,
CASE
WHEN b4.blocking_session IS NOT NULL THEN (SELECT s.machine FROM sess s WHERE s.session_id = b4.blocking_session AND s.session_serial# = b4.blocking_session_serial#)
WHEN b3.blocking_session IS NOT NULL THEN (SELECT s.machine FROM sess s WHERE s.session_id = b3.blocking_session AND s.session_serial# = b3.blocking_session_serial#)
WHEN b2.blocking_session IS NOT NULL THEN (SELECT s.machine FROM sess s WHERE s.session_id = b2.blocking_session AND s.session_serial# = b2.blocking_session_serial#)
WHEN b.blocking_session IS NOT NULL THEN (SELECT s.machine FROM sess s WHERE s.session_id = b.blocking_session AND s.session_serial# = b.blocking_session_serial#)
WHEN h.blocking_session IS NOT NULL THEN (SELECT s.machine FROM sess s WHERE s.session_id = h.blocking_session AND s.session_serial# = h.blocking_session_serial#)
END blocking_machine,
h.sql_id,
h.is_sqlid_current,
h.sql_plan_hash_value,
h.sql_plan_line_id,
h.sql_child_number,
h.sql_exec_id,
h.xid,
h.top_level_sql_id,
CASE h.session_state WHEN 'ON CPU' THEN h.session_state ELSE h.wait_class||' - '||h.event END on_cpu_or_wait_event,
st.sql_text,
pr.owner||
CASE WHEN pr.object_name IS NOT NULL THEN '.'||pr.object_name END||
CASE WHEN pr.procedure_name IS NOT NULL THEN '.'||pr.procedure_name END
AS procedure_name,
CASE WHEN TRIM(h.module) IS NOT NULL THEN 'm:'||TRIM(h.module)||' ' END||
CASE WHEN TRIM(h.action) IS NOT NULL THEN 'a:'||TRIM(h.action)||' ' END||
CASE WHEN TRIM(h.program) IS NOT NULL THEN 'p:'||TRIM(h.program) END
AS module_action_program,
h.current_obj#,
h.current_file#,
h.current_block#,
h.current_row#,
h.in_connection_mgmt,
h.in_parse,
h.in_hard_parse,
h.in_sql_execution,
h.in_plsql_execution,
h.in_plsql_rpc,
h.in_plsql_compilation,
h.in_java_execution,
h.in_bind,
h.in_cursor_close,
h.in_sequence_load,
CASE WHEN h.event LIKE 'enq:%' AND h.p1text LIKE 'name|mode%' AND h.p1 > 0 THEN CHR(BITAND(h.p1,-16777216)/16777215)||CHR(BITAND(h.p1, 16711680)/65535) END AS lock_type,
CASE WHEN h.event LIKE 'enq:%' AND h.p1text LIKE 'name|mode%' AND h.p1 > 0 THEN TO_CHAR(BITAND(h.p1, 65535)) END AS lock_mode,
NVL2(TRIM(h.p1text), h.p1text||':'||h.p1, NULL)||NVL2(TRIM(h.p2text), ', '||h.p2text||':'||h.p2, NULL)||NVL2(TRIM(h.p3text), ', '||h.p3text||':'||h.p3, NULL) p1_p2_p3
FROM ash h,
ash b,
ash b2,
ash b3,
ash b4,
sess_proc sp,
sqlstats st,
procedures pr
WHERE b.sample_id(+) = h.sample_id
AND b.session_id(+) = h.blocking_session
AND b.session_serial#(+) = h.blocking_session_serial#
AND b2.sample_id(+) = b.sample_id
AND b2.session_id(+) = b.blocking_session
AND b2.session_serial#(+) = b.blocking_session_serial#
AND b3.sample_id(+) = b2.sample_id
AND b3.session_id(+) = b2.blocking_session
AND b3.session_serial#(+) = b2.blocking_session_serial#
AND b4.sample_id(+) = b3.sample_id
AND b4.session_id(+) = b3.blocking_session
AND b4.session_serial#(+) = b3.blocking_session_serial#
AND ( '&&cs_sid_serial.' IS NULL
OR 's:'||h.session_id||','||h.session_serial# LIKE '%&&cs_sid_serial.%'
OR 'b:'||h.blocking_session||','||h.blocking_session_serial# LIKE '%&&cs_sid_serial.%'
OR 'b2:'||b.blocking_session||','||b.blocking_session_serial# LIKE '%&&cs_sid_serial.%'
OR 'b3:'||b2.blocking_session||','||b2.blocking_session_serial# LIKE '%&&cs_sid_serial.%'
OR 'b4:'||b3.blocking_session||','||b3.blocking_session_serial# LIKE '%&&cs_sid_serial.%'
OR 'b5:'||b4.blocking_session||','||b4.blocking_session_serial# LIKE '%&&cs_sid_serial.%'
)
AND sp.sid(+) = h.session_id
AND sp.serial#(+) = h.session_serial#
AND st.sql_id(+) = h.sql_id
AND pr.con_id(+) = h.con_id
AND pr.object_id(+) = h.plsql_entry_object_id
AND pr.subprogram_id(+) = h.plsql_entry_subprogram_id
ORDER BY
h.sample_time,
CASE WHEN h.machine LIKE '%iod-%' THEN 1 ELSE 2 END,
h.machine,
h.con_id,
h.session_id,
h.session_serial#,
h.sql_id
/
PRO
PRO Note: for furher details on a session, execute at PDB or CDB: SELECT h.* FROM &&ash_view h WHERE h.sample_time = TO_TIMESTAMP('&&double_ampersand.sample_date_and_time.', '&&cs_timestamp_full_format.') AND h.session_id = &&double_ampersand.session.&&ash_additional_predicate.; followed by @pr.sql
csierra/cs_internal/cs_bind_capture_hist.sql
+44
View File
@@ -0,0 +1,44 @@
--
/****************************************************************************************/
--
@@&&cs_set_container_to_cdb_root.
--
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL last_captured FOR A19 HEA 'Last Captured';
COL position FOR 990 HEA 'Pos';
COL datatype_string FOR A15 HEA 'Data Type';
COL name_and_value FOR A200 HEA 'Bind Name and Value';
COL max_length FOR 999999 HEA 'Max|Length';
--
BRE ON last_captured SKIP 1 ON con_id ON pdb_name;
--
PRO
PRO CAPTURED BINDS (dba_hist_sqlbind) - last &&cs_binds_days. day(s)
PRO ~~~~~~~~~~~~~~
SELECT DISTINCT
TO_CHAR(h.last_captured, '&&cs_datetime_full_format.') AS last_captured,
h.position,
h.datatype_string,
h.max_length,
h.name||' = '||h.value_string AS name_and_value,
c.name AS pdb_name,
h.con_id
FROM dba_hist_sqlbind h,
v$containers c
WHERE h.sql_id = '&&cs_sql_id.'
AND h.dbid = '&&cs_dbid.'
AND h.instance_number = '&&cs_instance_number.'
AND &&cs_con_id. IN (1, h.con_id)
AND h.last_captured BETWEEN SYSDATE - &&cs_binds_days. AND SYSDATE -- filter out bogus future dates such as 2106-02-07T06:13:16
AND c.con_id = h.con_id
ORDER BY
1, 2
/
--
CL BRE;
--
@@&&cs_set_container_to_curr_pdb.
--
/****************************************************************************************/
--
csierra/cs_internal/cs_bind_capture_mem.sql
+43
View File
@@ -0,0 +1,43 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL last_captured FOR A19 HEA 'Last Captured';
COL child_number FOR 999999 HEA 'Child|Number';
COL position FOR 990 HEA 'Pos';
COL datatype_string FOR A15 HEA 'Data Type';
COL name_and_value FOR A200 HEA 'Bind Name and Value';
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
COL max_length FOR 999999 HEA 'Max|Length';
--
BRE ON last_captured SKIP 1 ON con_id ON pdb_name ON plan_hash_value ON child_number;
--
PRO
PRO CAPTURED BINDS (v$sql_bind_capture)
PRO ~~~~~~~~~~~~~~
SELECT DISTINCT
TO_CHAR(c.last_captured, '&&cs_datetime_full_format.') AS last_captured,
c.child_number,
s.plan_hash_value,
c.position,
c.datatype_string,
c.max_length,
c.name||' = '||c.value_string AS name_and_value,
x.name AS pdb_name,
c.con_id
FROM v$sql_bind_capture c,
v$sql s,
v$containers x
WHERE c.sql_id = '&&cs_sql_id.'
AND c.last_captured < SYSDATE -- filter out bogus future dates such as 2106-02-07T06:13:16
AND s.address(+) = c.address
AND s.hash_value(+) = c.hash_value
AND s.sql_id(+) = c.sql_id
AND s.child_address(+) = c.child_address
AND s.child_number(+) = c.child_number
AND s.con_id(+) = c.con_id
AND x.con_id = c.con_id
ORDER BY
1, 2, 4
/
--
CL BRE;
--
csierra/cs_internal/cs_binds_xml.sql
+504
View File
@@ -0,0 +1,504 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL sum_seconds FOR 999,999,990 HEA 'Sum Dur Secs';
COL avg_seconds FOR 999,999,990 HEA 'Avg Dur Secs';
COL max_seconds FOR 999,999,990 HEA 'Max Dur Secs';
COL execs FOR 999,990 HEA 'Executions';
COL last_refresh_time FOR A19 HEA 'Last Captured';
COL con_id FOR 999 HEA 'Con|ID';
COL sql_plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
COL binds FOR A300 HEA 'Binds (:name=value :name=value ...)' TRUNC;
COL status FOR A19 HEA 'Status';
COL username FOR A30 HEA 'Username' TRUNC;
COL machine FOR A64 HEA 'Machine';
COL sid_serial# FOR A12 HEA 'Sid,Serial#';
COL avg_et_secs FOR 999,999,990.0 HEA 'Avg ET Secs';
COL avg_cpu_secs FOR 999,999,990.0 HEA 'Avg CPU Secs';
COL avg_buffer_gets FOR 999,999,999,990 HEA 'Avg Buffer Gets';
COL avg_disk_reads FOR 999,999,999,990 HEA 'Avg Disk Reads';
COL module_action_program FOR A100 HEA 'Module Action Program' TRUNC;
--
PRO
PRO SQL MONITOR BINDS by Sum Secs (v$sql_monitor) Top 100
PRO ~~~~~~~~~~~~~~~~~
--
WITH
mon AS (
SELECT s.con_id,
s.sql_plan_hash_value,
s.sql_exec_id,
s.sql_exec_start,
s.last_refresh_time,
s.binds_xml,
(s.last_refresh_time - s.sql_exec_start) * 24 * 3600 AS seconds,
s.status,
s.username,
s.sid,
s.session_serial# AS serial#,
(SELECT e.machine FROM v$session e WHERE e.sid = s.sid AND e.serial# = s.session_serial# AND e.machine IS NOT NULL AND ROWNUM = 1) AS machine,
s.elapsed_time,
s.cpu_time,
s.buffer_gets,
s.disk_reads,
s.module,
s.action,
s.program
FROM v$sql_monitor s
WHERE s.sql_id = '&&cs_sql_id.'
AND (s.last_refresh_time - s.sql_exec_start) * 24 * 3600 >= 0
AND s.binds_xml IS NOT NULL
),
bind AS (
SELECT mon.con_id,
mon.sql_plan_hash_value,
mon.sql_exec_id,
mon.sql_exec_start,
mon.last_refresh_time,
mon.seconds,
mon.status,
mon.username,
mon.sid,
mon.serial#,
mon.machine,
mon.elapsed_time,
mon.cpu_time,
mon.buffer_gets,
mon.disk_reads,
mon.module,
mon.action,
mon.program,
bv.name,
bv.pos,
bv.type,
bv.maxlen,
bv.len,
bv.value
FROM mon,
XMLTABLE( '/binds/bind'
PASSING XMLTYPE(REPLACE(REPLACE(ASCIISTR(mon.binds_xml), '\FFFF'), CHR(0)))
COLUMNS name VARCHAR2( 30 ) path '@name' ,
pos NUMBER path '@pos',
type VARCHAR2( 15 ) path '@dtystr' ,
maxlen NUMBER path '@maxlen',
len NUMBER path '@len',
value VARCHAR2( 4000 ) path '.'
) bv
),
execs AS (
SELECT con_id,
sql_plan_hash_value,
sql_exec_id,
sql_exec_start,
last_refresh_time,
seconds,
status,
username,
sid,
serial#,
machine,
elapsed_time,
cpu_time,
buffer_gets,
disk_reads,
module,
action,
program,
MAX(CASE pos WHEN 1 THEN name||'='||value END)||
MAX(CASE pos WHEN 2 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 3 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 4 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 5 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 6 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 7 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 8 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 9 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 10 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 11 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 12 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 13 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 14 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 15 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 16 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 17 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 18 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 19 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 20 THEN ' '||name||'='||value END)
AS binds
FROM bind
GROUP BY
con_id,
sql_plan_hash_value,
sql_exec_id,
sql_exec_start,
last_refresh_time,
seconds,
status,
username,
sid,
serial#,
machine,
elapsed_time,
cpu_time,
buffer_gets,
disk_reads,
module,
action,
program
)
SELECT SUM(seconds) AS sum_seconds,
ROUND(AVG(seconds)) AS avg_seconds,
MAX(seconds) AS max_seconds,
COUNT(*) AS execs,
ROUND(AVG(elapsed_time)/1e6, 1) AS avg_et_secs,
ROUND(AVG(cpu_time)/1e6, 1) AS avg_cpu_secs,
ROUND(AVG(buffer_gets)) AS avg_buffer_gets,
ROUND(AVG(disk_reads)) AS avg_disk_reads,
MAX(last_refresh_time) AS last_refresh_time,
con_id,
(SELECT c.name FROM v$containers c WHERE c.con_id = e.con_id) AS pdb_name,
sql_plan_hash_value,
binds
-- status,
-- sid||','||serial# AS sid_serial#,
-- --username,
-- machine,
-- TRIM(
-- CASE WHEN module IS NOT NULL THEN 'm:'||SUBSTR(module, 1, 64) END||
-- CASE WHEN action IS NOT NULL THEN ' a:'||SUBSTR(action, 1, 64) END||
-- CASE WHEN program IS NOT NULL THEN ' p:'||SUBSTR(program, 1, 64) END
-- ) AS module_action_program
FROM execs e
GROUP BY
con_id,
sql_plan_hash_value,
binds
-- status,
-- username,
-- sid,
-- serial#,
-- machine,
-- module,
-- action,
-- program
ORDER BY
1 DESC,
2 DESC,
3 DESC,
5
FETCH FIRST 100 ROWS ONLY
/
--
PRO
PRO SQL MONITOR BINDS by Last Captured (v$sql_monitor) Last 100
PRO ~~~~~~~~~~~~~~~~~
--
WITH
mon AS (
SELECT s.con_id,
s.sql_plan_hash_value,
s.sql_exec_id,
s.sql_exec_start,
s.last_refresh_time,
s.binds_xml,
(s.last_refresh_time - s.sql_exec_start) * 24 * 3600 AS seconds,
s.status,
s.username,
s.sid,
s.session_serial# AS serial#,
(SELECT e.machine FROM v$session e WHERE e.sid = s.sid AND e.serial# = s.session_serial# AND e.machine IS NOT NULL AND ROWNUM = 1) AS machine,
s.elapsed_time,
s.cpu_time,
s.buffer_gets,
s.disk_reads,
s.module,
s.action,
s.program
FROM v$sql_monitor s
WHERE s.sql_id = '&&cs_sql_id.'
AND (s.last_refresh_time - s.sql_exec_start) * 24 * 3600 >= 0
AND s.binds_xml IS NOT NULL
),
bind AS (
SELECT mon.con_id,
mon.sql_plan_hash_value,
mon.sql_exec_id,
mon.sql_exec_start,
mon.last_refresh_time,
mon.seconds,
mon.status,
mon.username,
mon.sid,
mon.serial#,
mon.machine,
mon.elapsed_time,
mon.cpu_time,
mon.buffer_gets,
mon.disk_reads,
mon.module,
mon.action,
mon.program,
bv.name,
bv.pos,
bv.type,
bv.maxlen,
bv.len,
bv.value
FROM mon,
XMLTABLE( '/binds/bind'
PASSING XMLTYPE(REPLACE(REPLACE(ASCIISTR(mon.binds_xml), '\FFFF'), CHR(0)))
COLUMNS name VARCHAR2( 30 ) path '@name' ,
pos NUMBER path '@pos',
type VARCHAR2( 15 ) path '@dtystr' ,
maxlen NUMBER path '@maxlen',
len NUMBER path '@len',
value VARCHAR2( 4000 ) path '.'
) bv
),
execs AS (
SELECT con_id,
sql_plan_hash_value,
sql_exec_id,
sql_exec_start,
last_refresh_time,
seconds,
status,
username,
sid,
serial#,
machine,
elapsed_time,
cpu_time,
buffer_gets,
disk_reads,
module,
action,
program,
MAX(CASE pos WHEN 1 THEN name||'='||value END)||
MAX(CASE pos WHEN 2 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 3 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 4 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 5 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 6 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 7 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 8 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 9 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 10 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 11 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 12 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 13 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 14 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 15 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 16 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 17 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 18 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 19 THEN ' '||name||'='||value END)||
MAX(CASE pos WHEN 20 THEN ' '||name||'='||value END)
AS binds
FROM bind
GROUP BY
con_id,
sql_plan_hash_value,
sql_exec_id,
sql_exec_start,
last_refresh_time,
seconds,
status,
username,
sid,
serial#,
machine,
elapsed_time,
cpu_time,
buffer_gets,
disk_reads,
module,
action,
program
),
top AS (
SELECT MAX(last_refresh_time) AS last_refresh_time,
SUM(seconds) AS sum_seconds,
ROUND(AVG(seconds)) AS avg_seconds,
MAX(seconds) AS max_seconds,
COUNT(*) AS execs,
ROUND(AVG(elapsed_time)/1e6, 1) AS avg_et_secs,
ROUND(AVG(cpu_time)/1e6, 1) AS avg_cpu_secs,
ROUND(AVG(buffer_gets)) AS avg_buffer_gets,
ROUND(AVG(disk_reads)) AS avg_disk_reads,
con_id,
(SELECT c.name FROM v$containers c WHERE c.con_id = e.con_id) AS pdb_name,
sql_plan_hash_value,
binds
-- status,
-- sid||','||serial# AS sid_serial#,
--username,
-- machine,
-- TRIM(
-- CASE WHEN module IS NOT NULL THEN 'm:'||SUBSTR(module, 1, 64) END||
-- CASE WHEN action IS NOT NULL THEN ' a:'||SUBSTR(action, 1, 64) END||
-- CASE WHEN program IS NOT NULL THEN ' p:'||SUBSTR(program, 1, 64) END
-- ) AS module_action_program
FROM execs e
GROUP BY
con_id,
sql_plan_hash_value,
binds
-- status,
-- username,
-- sid,
-- serial#,
-- machine,
-- module,
-- action,
-- program
ORDER BY
1 DESC
FETCH FIRST 100 ROWS ONLY
)
SELECT last_refresh_time,
sum_seconds,
avg_seconds,
max_seconds,
execs,
avg_et_secs,
avg_cpu_secs,
avg_buffer_gets,
avg_disk_reads,
con_id,
pdb_name,
sql_plan_hash_value,
binds
-- status,
-- sid_serial#,
--username,
-- machine,
-- module_action_program
FROM top
ORDER BY
last_refresh_time
/
--
PRO
PRO SQL MONITOR BINDS by Sum of Elapsed Time (v$sql_monitor) Top 100
PRO ~~~~~~~~~~~~~~~~~
--
COL sum_duration_secs FOR 999,990 HEA 'Sum|Duration|Seconds';
COL sum_elapsed_secs FOR 999,990 HEA 'Sum|Elapsed|Seconds';
COL sum_cpu_secs FOR 999,990 HEA 'Sum|CPU|Seconds';
COL sum_buffer_gets FOR 999,999,999,990 HEA 'Sum|Buffer|Gets';
COL sum_disk_reads FOR 999,999,999,990 HEA 'Sum|Disk|Reads';
COL avg_duration_secs FOR 999,990 HEA 'Avg|Duration|Seconds';
COL avg_elapsed_secs FOR 999,990 HEA 'Avg|Elapsed|Seconds';
COL avg_cpu_secs FOR 999,990 HEA 'Avg|CPU|Seconds';
COL avg_buffer_gets FOR 999,999,999,990 HEA 'Avg|Buffer|Gets';
COL avg_disk_reads FOR 999,999,999,990 HEA 'Avg|Disk|Reads';
COL max_duration_secs FOR 999,990 HEA 'Max|Duration|Seconds';
COL max_elapsed_secs FOR 999,990 HEA 'Max|Elapsed|Seconds';
COL max_cpu_secs FOR 999,990 HEA 'Max|CPU|Seconds';
COL max_buffer_gets FOR 999,999,999,990 HEA 'Max|Buffer|Gets';
COL max_disk_reads FOR 999,999,999,990 HEA 'Max|Disk|Reads';
COL cnt FOR 999,990 HEA 'Count';
COL name_and_value FOR A200 HEA 'Bind Name and Value';
COL min_sql_exec_start HEA 'Min SQL|Exec Start';
COL max_last_refresh_time HEA 'Max Last|Refresh Time';
COL d1 FOR A1 HEA '|';
COL d2 FOR A1 HEA '|';
COL d3 FOR A1 HEA '|';
COL d4 FOR A1 HEA '|';
--
WITH
mon AS (
SELECT s.key,
s.con_id,
s.sql_plan_hash_value,
s.sql_exec_id,
s.sql_exec_start,
s.last_refresh_time,
(s.last_refresh_time - s.sql_exec_start) * 24 * 3600 AS seconds,
s.status,
s.username,
s.sid,
s.session_serial# AS serial#,
s.elapsed_time,
s.cpu_time,
s.buffer_gets,
s.disk_reads,
s.module,
s.action,
s.program,
bv.pos,
bv.name,
bv.type,
bv.maxlen,
bv.len,
bv.value
FROM v$sql_monitor s,
xmltable( '/binds/bind'
passing xmltype(REPLACE(REPLACE(ASCIISTR(s.binds_xml), '\FFFF'), CHR(0)))
COLUMNS name VARCHAR2( 30 ) path '@name' ,
pos NUMBER path '@pos',
type VARCHAR2( 15 ) path '@dtystr' ,
maxlen NUMBER path '@maxlen',
len NUMBER path '@len',
value VARCHAR2( 4000 ) path '.'
) bv
WHERE s.sql_id = '&&cs_sql_id.'
AND s.status LIKE 'DONE%'
AND s.binds_xml IS NOT NULL
),
grp AS (
SELECT SUM(seconds) AS sum_duration_secs,
SUM(elapsed_time) / POWER(10, 6) AS sum_elapsed_secs,
SUM(cpu_time) / POWER(10, 6) AS sum_cpu_secs,
SUM(buffer_gets) AS sum_buffer_gets,
SUM(disk_reads) AS sum_disk_reads,
AVG(seconds) AS avg_duration_secs,
AVG(elapsed_time) / POWER(10, 6) AS avg_elapsed_secs,
AVG(cpu_time) / POWER(10, 6) AS avg_cpu_secs,
AVG(buffer_gets) AS avg_buffer_gets,
AVG(disk_reads) AS avg_disk_reads,
MAX(seconds) AS max_duration_secs,
MAX(elapsed_time) / POWER(10, 6) AS max_elapsed_secs,
MAX(cpu_time) / POWER(10, 6) AS max_cpu_secs,
MAX(buffer_gets) AS max_buffer_gets,
MAX(disk_reads) AS max_disk_reads,
COUNT(*) AS cnt,
MIN(sql_exec_start) AS min_sql_exec_start,
MAX(last_refresh_time) AS max_last_refresh_time,
name,
value
FROM mon
GROUP BY
name,
value
)
SELECT sum_duration_secs,
sum_elapsed_secs,
sum_cpu_secs,
sum_buffer_gets,
sum_disk_reads,
'|' AS d1,
avg_duration_secs,
avg_elapsed_secs,
avg_cpu_secs,
avg_buffer_gets,
avg_disk_reads,
'|' AS d2,
max_duration_secs,
max_elapsed_secs,
max_cpu_secs,
max_buffer_gets,
max_disk_reads,
'|' AS d3,
name||' = '||value AS name_and_value,
'|' AS d4,
cnt,
min_sql_exec_start,
max_last_refresh_time
FROM grp
ORDER BY
sum_duration_secs DESC,
name,
value
FETCH FIRST 100 ROWS ONLY
/
csierra/cs_internal/cs_blocked_sessions_ash_awr_internal.sql
+156
View File
@@ -0,0 +1,156 @@
WITH
FUNCTION num_format (p_number IN NUMBER, p_round IN NUMBER DEFAULT 0)
RETURN VARCHAR2 IS
BEGIN
IF p_number IS NULL OR ROUND(p_number, p_round) <= 0 THEN
RETURN 'null';
ELSE
RETURN TO_CHAR(ROUND(p_number, p_round));
END IF;
END num_format;
/****************************************************************************************/
ash AS (
SELECT /*+ MATERIALIZE NO_MERGE */
h.sample_id,
h.sample_time,
h.machine,
h.module,
h.session_id,
h.session_serial#,
h.blocking_session,
h.blocking_session_serial#,
h.session_state,
h.wait_class,
h.event,
h.sql_id,
h.top_level_sql_id
FROM dba_hist_active_sess_history h
WHERE 1 = 1
AND TO_NUMBER('&&cs_con_id.') IN (1, h.con_id)
AND h.sample_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND h.sample_time < TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND h.dbid = TO_NUMBER('&&cs_dbid.')
AND h.instance_number = TO_NUMBER('&&cs_instance_number.')
AND h.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.')
),
/****************************************************************************************/
inactive_sessions AS (
SELECT /*+ MATERIALIZE NO_MERGE */
DISTINCT
i.sample_id,
CAST(i.sample_time AS DATE) sample_time,
i.blocking_session session_id,
i.blocking_session_serial# session_serial#
FROM ash i
WHERE i.blocking_session IS NOT NULL
AND i.blocking_session_serial# IS NOT NULL
AND NOT EXISTS (
SELECT /*+ MATERIALIZE NO_MERGE */
NULL
FROM ash a
WHERE a.sample_id = i.sample_id
AND a.session_id = i.blocking_session
AND a.session_serial# = i.blocking_session_serial#
)),
/****************************************************************************************/
all_sessions AS (
SELECT /*+ MATERIALIZE NO_MERGE */
a.sample_id, CAST(a.sample_time AS DATE) sample_time, a.machine, a.module, a.session_id, a.session_serial#, a.blocking_session, a.blocking_session_serial#,
'ACTIVE' status, session_state, wait_class, event, sql_id, top_level_sql_id
FROM ash a
UNION ALL
SELECT /*+ MATERIALIZE NO_MERGE */
i.sample_id, i.sample_time, NULL machine, NULL module, i.session_id, i.session_serial#, TO_NUMBER(NULL), TO_NUMBER(NULL),
'INACTIVE or UNKNOWN' status, NULL session_state, NULL wait_class, NULL event, NULL sql_id, NULL top_level_sql_id
FROM inactive_sessions i
),
/****************************************************************************************/
sess_history AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_id, sample_time, machine, module, session_id, session_serial#, status, session_state, wait_class, event, sql_id, top_level_sql_id,
LEVEL lvl,
CONNECT_BY_ROOT machine blocker_machine,
CONNECT_BY_ROOT module blocker_module,
CONNECT_BY_ROOT session_id blocker_session,
CONNECT_BY_ROOT session_serial# blocker_session_serial#,
CONNECT_BY_ISLEAF AS leaf
FROM all_sessions
START WITH blocking_session IS NULL AND blocking_session_serial# IS NULL
CONNECT BY sample_id = PRIOR sample_id AND blocking_session = PRIOR session_id AND blocking_session_serial# = PRIOR session_serial#
),
/****************************************************************************************/
blockers AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_id, sample_time, status, session_state, wait_class, event, sql_id, top_level_sql_id, session_id, session_serial#
FROM sess_history
WHERE lvl = 1
),
/****************************************************************************************/
blockees AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sample_id, sample_time, status, wait_class, event, blocker_session, blocker_session_serial#, COUNT(*) cnt
FROM sess_history
WHERE lvl > 1
GROUP BY
sample_id, sample_time, status, wait_class, event, blocker_session, blocker_session_serial#
),
/****************************************************************************************/
machines AS (
SELECT /*+ MATERIALIZE NO_MERGE */
session_id, session_serial#, MAX(machine) machine
FROM sess_history
WHERE machine IS NOT NULL
GROUP BY
session_id, session_serial#
UNION
SELECT /*+ MATERIALIZE NO_MERGE */
sid session_id, serial# session_serial#, machine
FROM v$session
),
/****************************************************************************************/
modules AS (
SELECT /*+ MATERIALIZE NO_MERGE */
session_id, session_serial#, MAX(module) module
FROM sess_history
WHERE module IS NOT NULL
GROUP BY
session_id, session_serial#
UNION
SELECT /*+ MATERIALIZE NO_MERGE */
sid session_id, serial# session_serial#, module
FROM v$session
),
/****************************************************************************************/
blockers_and_blockees AS (
SELECT /*+ MATERIALIZE NO_MERGE */
b.sample_id,
b.sample_time time,
a.wait_class||' - '||a.event AS wait_class_event,
b.status blocker_status,
b.session_state blocker_session_state,
b.wait_class blocker_wait_class,
b.event blocker_event,
COALESCE(b.sql_id, b.top_level_sql_id) AS blocker_sql_id,
NVL(m.machine, 'unknown') machine,
NVL(m2.module, 'unknown') module,
b.session_id blocker_session_id,
b.session_serial# blocker_session_serial#,
NVL(a.cnt, 0) sessions_blocked,
CASE b.session_state WHEN 'ON CPU' THEN NVL(a.cnt, 0) ELSE 0 END AS active_on_cpu,
CASE b.session_state WHEN 'WAITING' THEN NVL(a.cnt, 0) ELSE 0 END AS active_waiting,
CASE b.status WHEN 'INACTIVE or UNKNOWN' THEN (CASE NVL(m.machine, 'unknown') WHEN '&&cs_host_name.' THEN 0 ELSE NVL(a.cnt, 0) END) ELSE 0 END AS inactive,
CASE b.status WHEN 'INACTIVE or UNKNOWN' THEN (CASE NVL(m.machine, 'unknown') WHEN '&&cs_host_name.' THEN NVL(a.cnt, 0) ELSE 0 END) ELSE 0 END AS unknown
FROM blockers b,
blockees a,
machines m,
modules m2
WHERE a.sample_id(+) = b.sample_id
AND a.sample_time(+) = b.sample_time
AND a.blocker_session(+) = b.session_id
AND a.blocker_session_serial#(+) = b.session_serial#
AND m.session_id(+) = b.session_id
AND m.session_serial#(+) = b.session_serial#
AND m2.session_id(+) = b.session_id
AND m2.session_serial#(+) = b.session_serial#
)
/****************************************************************************************/
csierra/cs_internal/cs_cdb_warn.sql
+19
View File
@@ -0,0 +1,19 @@
-- warn if executed from CDB$ROOT
SET SERVEROUT ON;
BEGIN
IF SYS_CONTEXT('USERENV', 'CON_NAME') = 'CDB$ROOT' THEN
DBMS_OUTPUT.put_line(CHR(10));
DBMS_OUTPUT.put_line('***');
DBMS_OUTPUT.put_line('*** On CDB$ROOT ***');
DBMS_OUTPUT.put_line('***');
DBMS_OUTPUT.put_line(CHR(10));
END IF;
END;
/
SET SERVEROUT OFF;
BEGIN
IF SYS_CONTEXT('USERENV', 'CON_NAME') = 'CDB$ROOT' THEN
DBMS_LOCK.sleep(1);
END IF;
END;
/
csierra/cs_internal/cs_cdb_warn2.sql
+21
View File
@@ -0,0 +1,21 @@
-- warn if executed from CDB$ROOT
SET SERVEROUT ON;
BEGIN
IF SYS_CONTEXT('USERENV', 'CON_NAME') = 'CDB$ROOT' THEN
DBMS_OUTPUT.put_line(CHR(10));
DBMS_OUTPUT.put_line('***');
DBMS_OUTPUT.put_line('*** On CDB$ROOT ***');
DBMS_OUTPUT.put_line('***');
DBMS_OUTPUT.put_line('*** This script is expeted to execute from a PDB ***');
DBMS_OUTPUT.put_line('***');
DBMS_OUTPUT.put_line(CHR(10));
END IF;
END;
/
SET SERVEROUT OFF;
BEGIN
IF SYS_CONTEXT('USERENV', 'CON_NAME') = 'CDB$ROOT' THEN
DBMS_LOCK.sleep(1);
END IF;
END;
/
csierra/cs_internal/cs_cursors_not_shared.sql
+36
View File
@@ -0,0 +1,36 @@
SET HEA OFF PAGES 0 TERM OFF;
SPO &&cs_file_dir.cursors_not_shared_dynamic.sql
SELECT CASE WHEN ROWNUM = 1 THEN '( ' ELSE ', ' END||column_name
FROM dba_tab_columns
WHERE owner = 'SYS'
AND table_name = 'V_$SQL_SHARED_CURSOR'
AND data_type = 'VARCHAR2'
AND data_length = 1
/
SPO OFF;
GET &&cs_file_dir.cursors_not_shared_dynamic.sql
I )
I )
I WHERE value = 'Y'
I AND sql_id = '&&cs_sql_id.'
I GROUP BY reason_not_shared, con_id )
I SELECT s.con_id, c.name AS pdb_name, s.cursors_count, s.reason_not_shared
I FROM s, v$containers c
I WHERE c.con_id = s.con_id
I ORDER BY s.con_id, s.cursors_count DESC, s.reason_not_shared
0 ( value FOR reason_not_shared IN
0 FROM v$sql_shared_cursor UNPIVOT
0 SELECT COUNT(*) AS cursors_count, reason_not_shared, con_id
0 WITH s AS (
L
!rm &&cs_file_dir.cursors_not_shared_dynamic.sql
SET HEA ON PAGES 100 TERM ON;
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL cursors_count FOR 999,990 HEA 'Cursors';
COL reason_not_shared FOR A30 HEA 'Reason not Shared';
SPO &&cs_file_name..txt APP
PRO
PRO CURSORS NOT SHARED (v$sql_shared_cursor)
PRO ~~~~~~~~~~~~~~~~~~
/
csierra/cs_internal/cs_dba_hist_sqlstat_daily.sql
+350
View File
@@ -0,0 +1,350 @@
-- cs_dba_hist_sqlstat_daily.sql: called by cs_sqlstat_report.sql, cs_planx.sql and cs_sqlperf.sql
@@cs_sqlstat_cols.sql
@@cs_sqlstat_compute.sql
PRO
PRO SQL STATS - HISTORY DAILY AGGREGATE (dba_hist_sqlstat) &&cs_scope_1.
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_dba_hist_sqlstat_daily */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqltext_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqltext_mv) */
dbid,
con_id,
sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(sql_text, '\[([[:digit:]]{4})\] ') ELSE sql_text END),100000),5,'0') AS sqlid,
get_sql_hv(sql_text) AS sqlid,
REPLACE(REPLACE(DBMS_LOB.substr(sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
sql_text AS sql_fulltext
FROM dba_hist_sqltext
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(DBMS_LOB.substr(sql_text, 1000)) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1
),
/****************************************************************************************/
snapshot_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(snapshot_mv) */
s.*
FROM dba_hist_snapshot s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
-- AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.end_interval_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND s.end_interval_time <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlstats_mv) */
*
FROM dba_hist_sqlstat
WHERE dbid = TO_NUMBER('&&cs_dbid.')
-- AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND &&cs_filter_1.
AND &&cs_filter_2.
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
s.snap_id,
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
x.sqlid,
x.sql_text,
x.sql_fulltext,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM snapshot_mv t,
sqlstats_mv s,
sqltext_mv x
WHERE s.snap_id = t.snap_id
AND s.dbid = t.dbid
AND s.instance_number = t.instance_number
AND x.dbid = s.dbid
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT --d.snap_id,
TRUNC(d.begin_timestamp, 'DD') AS day,
MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
AVG(d.optimizer_cost) AS optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time)/1e6 AS delta_elapsed_time,
SUM(d.delta_cpu_time)/1e6 AS delta_cpu_time,
SUM(d.delta_user_io_wait_time)/1e6 AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time)/1e6 AS delta_application_wait_time,
SUM(d.delta_concurrency_time)/1e6 AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time)/1e6 AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time)/1e6 AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time)/1e6 AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes)/1e6 AS delta_physical_read_mb,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes)/1e6 AS delta_physical_write_mb,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes)/1e6 AS delta_io_interconnect_mb,
SUM(d.delta_cell_offload_elig_bytes)/1e6 AS delta_cell_offload_elig_mb,
SUM(d.delta_cell_uncompressed_bytes)/1e6 AS delta_cell_uncompressed_mb,
SUM(d.delta_cell_offload_retrn_bytes)/1e6 AS delta_cell_offload_retrn_mb,
MAX(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
MAX(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
-- d.snap_id,
-- d.begin_timestamp,
-- d.end_timestamp,
TRUNC(d.begin_timestamp, 'DD'),
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
-- LPAD(s.snap_id, 7, '0') AS snap_id,
'!' AS sep0,
s.day,
s.begin_timestamp,
s.end_timestamp,
s.seconds,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
'!' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'!' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep4,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep5,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep6,
s.delta_elapsed_time,
s.delta_cpu_time,
s.delta_user_io_wait_time,
s.delta_application_wait_time,
s.delta_concurrency_time,
s.delta_plsql_exec_time,
s.delta_cluster_wait_time,
s.delta_java_exec_time,
'!' AS sep7,
s.delta_px_servers_executions,
s.delta_end_of_fetch_count,
s.delta_parse_calls,
s.delta_buffer_gets,
s.delta_disk_reads,
s.delta_direct_writes,
s.delta_physical_read_requests,
s.delta_physical_read_mb,
s.delta_physical_write_requests,
s.delta_physical_write_mb,
s.delta_fetch_count,
s.delta_sorts,
s.delta_io_interconnect_mb,
s.delta_cell_offload_elig_mb,
s.delta_cell_uncompressed_mb,
s.delta_cell_offload_retrn_mb,
'!' AS sep8,
s.version_count,
-- s.obsolete_count,
s.delta_loads,
s.delta_invalidations,
s.sharable_mem_mb,
'!' AS sep9,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sqlstats_metrics s
ORDER BY
-- s.snap_id,
s.day,
s.begin_timestamp,
s.end_timestamp,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_foot.sql
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_dba_hist_sqlstat_detailed.sql
+346
View File
@@ -0,0 +1,346 @@
-- cs_dba_hist_sqlstat_detailed.sql: called by cs_sqlstat_report.sql, cs_planx.sql and cs_sqlperf.sql
@@cs_sqlstat_cols.sql
@@cs_sqlstat_compute.sql
PRO
PRO SQL STATS - HISTORY DETAILED (dba_hist_sqlstat) &&cs_scope_1.
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_dba_hist_sqlstat_detailed */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqltext_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqltext_mv) */
dbid,
con_id,
sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(sql_text, '\[([[:digit:]]{4})\] ') ELSE sql_text END),100000),5,'0') AS sqlid,
get_sql_hv(sql_text) AS sqlid,
REPLACE(REPLACE(DBMS_LOB.substr(sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
sql_text AS sql_fulltext
FROM dba_hist_sqltext
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(DBMS_LOB.substr(sql_text, 1000)) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1
),
/****************************************************************************************/
snapshot_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(snapshot_mv) */
s.*
FROM dba_hist_snapshot s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
-- AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.end_interval_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND s.end_interval_time <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlstats_mv) */
*
FROM dba_hist_sqlstat
WHERE dbid = TO_NUMBER('&&cs_dbid.')
-- AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND &&cs_filter_1.
AND &&cs_filter_2.
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
s.snap_id,
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
x.sqlid,
x.sql_text,
x.sql_fulltext,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM snapshot_mv t,
sqlstats_mv s,
sqltext_mv x
WHERE s.snap_id = t.snap_id
AND s.dbid = t.dbid
AND s.instance_number = t.instance_number
AND x.dbid = s.dbid
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT d.snap_id,
d.begin_timestamp,
d.end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
AVG(d.optimizer_cost) AS optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time)/1e6 AS delta_elapsed_time,
SUM(d.delta_cpu_time)/1e6 AS delta_cpu_time,
SUM(d.delta_user_io_wait_time)/1e6 AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time)/1e6 AS delta_application_wait_time,
SUM(d.delta_concurrency_time)/1e6 AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time)/1e6 AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time)/1e6 AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time)/1e6 AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes)/1e6 AS delta_physical_read_mb,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes)/1e6 AS delta_physical_write_mb,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes)/1e6 AS delta_io_interconnect_mb,
SUM(d.delta_cell_offload_elig_bytes)/1e6 AS delta_cell_offload_elig_mb,
SUM(d.delta_cell_uncompressed_bytes)/1e6 AS delta_cell_uncompressed_mb,
SUM(d.delta_cell_offload_retrn_bytes)/1e6 AS delta_cell_offload_retrn_mb,
MAX(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
MAX(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
d.snap_id,
d.begin_timestamp,
d.end_timestamp,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
LPAD(s.snap_id, 7, '0') AS snap_id,
s.begin_timestamp,
s.end_timestamp,
s.seconds,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
'!' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'!' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep4,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep5,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep6,
s.delta_elapsed_time,
s.delta_cpu_time,
s.delta_user_io_wait_time,
s.delta_application_wait_time,
s.delta_concurrency_time,
s.delta_plsql_exec_time,
s.delta_cluster_wait_time,
s.delta_java_exec_time,
'!' AS sep7,
s.delta_px_servers_executions,
s.delta_end_of_fetch_count,
s.delta_parse_calls,
s.delta_buffer_gets,
s.delta_disk_reads,
s.delta_direct_writes,
s.delta_physical_read_requests,
s.delta_physical_read_mb,
s.delta_physical_write_requests,
s.delta_physical_write_mb,
s.delta_fetch_count,
s.delta_sorts,
s.delta_io_interconnect_mb,
s.delta_cell_offload_elig_mb,
s.delta_cell_uncompressed_mb,
s.delta_cell_offload_retrn_mb,
'!' AS sep8,
s.version_count,
-- s.obsolete_count,
s.delta_loads,
s.delta_invalidations,
s.sharable_mem_mb,
'!' AS sep9,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sqlstats_metrics s
ORDER BY
s.snap_id,
s.begin_timestamp,
s.end_timestamp,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_foot.sql
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_dba_hist_sqlstat_global.sql
+349
View File
@@ -0,0 +1,349 @@
-- cs_dba_hist_sqlstat_global.sql: called by cs_sqlstat_report.sql, cs_planx.sql and cs_sqlperf.sql
@@cs_sqlstat_cols.sql
PRO
PRO SQL STATS - HISTORY GLOBAL AGGREGATE (dba_hist_sqlstat) &&cs_scope_1.
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_dba_hist_sqlstat_global */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqltext_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqltext_mv) */
dbid,
con_id,
sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(sql_text, '\[([[:digit:]]{4})\] ') ELSE sql_text END),100000),5,'0') AS sqlid,
get_sql_hv(sql_text) AS sqlid,
REPLACE(REPLACE(DBMS_LOB.substr(sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
sql_text AS sql_fulltext
FROM dba_hist_sqltext
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(DBMS_LOB.substr(sql_text, 1000)) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1
),
/****************************************************************************************/
snapshot_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(snapshot_mv) */
s.*
FROM dba_hist_snapshot s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
-- AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.end_interval_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND s.end_interval_time <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlstats_mv) */
*
FROM dba_hist_sqlstat
WHERE dbid = TO_NUMBER('&&cs_dbid.')
-- AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND &&cs_filter_1.
AND &&cs_filter_2.
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
s.snap_id,
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
x.sqlid,
x.sql_text,
x.sql_fulltext,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM snapshot_mv t,
sqlstats_mv s,
sqltext_mv x
WHERE s.snap_id = t.snap_id
AND s.dbid = t.dbid
AND s.instance_number = t.instance_number
AND x.dbid = s.dbid
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT --d.snap_id,
-- TRUNC(d.begin_timestamp, 'DD') AS day,
MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
AVG(d.optimizer_cost) AS optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time)/1e6 AS delta_elapsed_time,
SUM(d.delta_cpu_time)/1e6 AS delta_cpu_time,
SUM(d.delta_user_io_wait_time)/1e6 AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time)/1e6 AS delta_application_wait_time,
SUM(d.delta_concurrency_time)/1e6 AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time)/1e6 AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time)/1e6 AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time)/1e6 AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes)/1e6 AS delta_physical_read_mb,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes)/1e6 AS delta_physical_write_mb,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes)/1e6 AS delta_io_interconnect_mb,
SUM(d.delta_cell_offload_elig_bytes)/1e6 AS delta_cell_offload_elig_mb,
SUM(d.delta_cell_uncompressed_bytes)/1e6 AS delta_cell_uncompressed_mb,
SUM(d.delta_cell_offload_retrn_bytes)/1e6 AS delta_cell_offload_retrn_mb,
MAX(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
MAX(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
-- d.snap_id,
-- d.begin_timestamp,
-- d.end_timestamp,
-- TRUNC(d.begin_timestamp, 'DD'),
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
-- LPAD(s.snap_id, 7, '0') AS snap_id,
-- s.day,
'!' AS sep0,
s.begin_timestamp,
s.end_timestamp,
s.seconds,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
'!' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'!' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep4,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep5,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep6,
s.delta_elapsed_time,
s.delta_cpu_time,
s.delta_user_io_wait_time,
s.delta_application_wait_time,
s.delta_concurrency_time,
s.delta_plsql_exec_time,
s.delta_cluster_wait_time,
s.delta_java_exec_time,
'!' AS sep7,
s.delta_px_servers_executions,
s.delta_end_of_fetch_count,
s.delta_parse_calls,
s.delta_buffer_gets,
s.delta_disk_reads,
s.delta_direct_writes,
s.delta_physical_read_requests,
s.delta_physical_read_mb,
s.delta_physical_write_requests,
s.delta_physical_write_mb,
s.delta_fetch_count,
s.delta_sorts,
s.delta_io_interconnect_mb,
s.delta_cell_offload_elig_mb,
s.delta_cell_uncompressed_mb,
s.delta_cell_offload_retrn_mb,
'!' AS sep8,
s.version_count,
-- s.obsolete_count,
s.delta_loads,
s.delta_invalidations,
s.sharable_mem_mb,
'!' AS sep9,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sqlstats_metrics s
ORDER BY
-- s.snap_id,
-- s.day,
s.begin_timestamp,
s.end_timestamp,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_foot.sql
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_dba_hist_sqlstat_hourly.sql
+350
View File
@@ -0,0 +1,350 @@
-- cs_dba_hist_sqlstat_hourly.sql: called by cs_sqlstat_report.sql, cs_planx.sql and cs_sqlperf.sql
@@cs_sqlstat_cols.sql
@@cs_sqlstat_compute.sql
PRO
PRO SQL STATS - HISTORY HOURLY AGGREGATE (dba_hist_sqlstat) &&cs_scope_1.
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_dba_hist_sqlstat_hourly */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqltext_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqltext_mv) */
dbid,
con_id,
sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(sql_text, '\[([[:digit:]]{4})\] ') ELSE sql_text END),100000),5,'0') AS sqlid,
get_sql_hv(sql_text) AS sqlid,
REPLACE(REPLACE(DBMS_LOB.substr(sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
sql_text AS sql_fulltext
FROM dba_hist_sqltext
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(DBMS_LOB.substr(sql_text, 1000)) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1
),
/****************************************************************************************/
snapshot_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(snapshot_mv) */
s.*
FROM dba_hist_snapshot s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
-- AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.end_interval_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND s.end_interval_time <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlstats_mv) */
*
FROM dba_hist_sqlstat
WHERE dbid = TO_NUMBER('&&cs_dbid.')
-- AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND &&cs_filter_1.
AND &&cs_filter_2.
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
s.snap_id,
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
x.sqlid,
x.sql_text,
x.sql_fulltext,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM snapshot_mv t,
sqlstats_mv s,
sqltext_mv x
WHERE s.snap_id = t.snap_id
AND s.dbid = t.dbid
AND s.instance_number = t.instance_number
AND x.dbid = s.dbid
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT --d.snap_id,
TRUNC(d.begin_timestamp, 'HH24') AS hour,
MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
AVG(d.optimizer_cost) AS optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time)/1e6 AS delta_elapsed_time,
SUM(d.delta_cpu_time)/1e6 AS delta_cpu_time,
SUM(d.delta_user_io_wait_time)/1e6 AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time)/1e6 AS delta_application_wait_time,
SUM(d.delta_concurrency_time)/1e6 AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time)/1e6 AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time)/1e6 AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time)/1e6 AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes)/1e6 AS delta_physical_read_mb,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes)/1e6 AS delta_physical_write_mb,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes)/1e6 AS delta_io_interconnect_mb,
SUM(d.delta_cell_offload_elig_bytes)/1e6 AS delta_cell_offload_elig_mb,
SUM(d.delta_cell_uncompressed_bytes)/1e6 AS delta_cell_uncompressed_mb,
SUM(d.delta_cell_offload_retrn_bytes)/1e6 AS delta_cell_offload_retrn_mb,
MAX(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
MAX(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
-- d.snap_id,
-- d.begin_timestamp,
-- d.end_timestamp,
TRUNC(d.begin_timestamp, 'HH24'),
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.optimizer_cost,
d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
-- d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
-- LPAD(s.snap_id, 7, '0') AS snap_id,
'!' AS sep0,
s.hour,
s.begin_timestamp,
s.end_timestamp,
s.seconds,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
'!' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'!' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep4,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep5,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep6,
s.delta_elapsed_time,
s.delta_cpu_time,
s.delta_user_io_wait_time,
s.delta_application_wait_time,
s.delta_concurrency_time,
s.delta_plsql_exec_time,
s.delta_cluster_wait_time,
s.delta_java_exec_time,
'!' AS sep7,
s.delta_px_servers_executions,
s.delta_end_of_fetch_count,
s.delta_parse_calls,
s.delta_buffer_gets,
s.delta_disk_reads,
s.delta_direct_writes,
s.delta_physical_read_requests,
s.delta_physical_read_mb,
s.delta_physical_write_requests,
s.delta_physical_write_mb,
s.delta_fetch_count,
s.delta_sorts,
s.delta_io_interconnect_mb,
s.delta_cell_offload_elig_mb,
s.delta_cell_uncompressed_mb,
s.delta_cell_offload_retrn_mb,
'!' AS sep8,
s.version_count,
-- s.obsolete_count,
s.delta_loads,
s.delta_invalidations,
s.sharable_mem_mb,
'!' AS sep9,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sqlstats_metrics s
ORDER BY
-- s.snap_id,
s.hour,
s.begin_timestamp,
s.end_timestamp,
s.sqlid,
s.sql_id,
s.instance_number,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_foot.sql
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_def.sql
+631
View File
@@ -0,0 +1,631 @@
DEF iod_user = 'C##IOD';
DEF odis_user = 'ADMIN';
--
COL ampersand NEW_V ampersand NOPRI;
COL double_ampersand NEW_V double_ampersand NOPRI;
SELECT CHR(38) AS ampersand, CHR(38)||CHR(38) AS double_ampersand FROM DUAL;
DEF hints_text = "FIRST_ROWS(1)";
DEF hints_text = "FIRST_ROWS(1) OPT_PARAM('_fix_control' '5922070:OFF')";
DEF cs_file_dir = '/tmp/';
DEF cs_temp_dir = '/u01/app/oracle/tools/tmp';
DEF cs_timestamp_full_format = 'YYYY-MM-DD"T"HH24:MI:SS.FF3';
DEF cs_datetime_full_format = 'YYYY-MM-DD"T"HH24:MI:SS';
DEF cs_datetime_display_format = 'yyyy-mm-ddThh:mi:ss';
DEF cs_datetime_short_format = 'YYYY-MM-DD"T"HH24.MI.SS';
DEF cs_datetime_hh24_format = 'YYYY-MM-DD"T"HH24';
DEF cs_datetime_dd_format = 'YYYY-MM-DD';
DEF cs_datetime_dense_format = 'YYYYMMDD_HH24MISS';
DEF cs_me_top = '10';
DEF cs_me_last = '10';
DEF cs_me_days = '30';
DEF cs_aas_on_cpu_per_sql = '2.5';
DEF cs_cpu_ms_per_row = '0.500';
DEF cs_buffer_gets_per_row = '25';
DEF cs_disk_reads_per_row = '1';
DEF cs_min_rows_per_exec_cap = '10';
DEF cs_default_reference = 'NULL';
DEF cs_reference_sanitized = '';
DEF cs_awr_days = '7';
DEF cs_binds_days = '1';
DEF cs_sqlmon_top = '100';
DEF chart_foot_note_0 = 'Notes:';
DEF chart_foot_note_1 = '<br>1) Drag to Zoom, and right click to reset Chart.';
DEF is_stacked = "isStacked: true,";
DEF cs_legend_position = 'right';
DEF vaxis_baseline = "";
DEF vaxis_viewwindow = "";
DEF hAxis_maxValue = "";
DEF cs_hAxis_maxValue = "";
DEF hAxis_maxValue_forecast = '0.375';
-- [{linear}|polynomial|exponential|none]
DEF cs_trendlines_types = '[{none}|linear|polynomial|exponential]'
DEF cs_trendlines_type = 'none';
DEF cs_trendlines_series = "";
DEF cs_trendlines = "";
DEF cs_chart_width = '1200px';
DEF cs_chart_height = '500px';
DEF cs_chartarea_left = '90';
DEF cs_chartarea_top = '75';
DEF cs_chartarea_width = '75%';
DEF cs_chartarea_height = '70%';
DEF cs_chart_option_explorer = '';
DEF cs_chart_option_pie = '//';
-- cs_chart_option_focustarget [{datum}|category]
DEF cs_chart_option_focustarget = 'datum';
DEF cs_chart_option_pointsize = '4';
DEF cs_chart_pie_slice_text = "// pieSliceText: 'percentage',";
DEF cs_oem_colors_series = '';
DEF cs_oem_colors_slices = '//';
DEF cs_curve_type = '//';
DEF cs_def_local_dir = '.';
DEF cs_local_dir = '';
--
DEF cs_realm = '';
DEF cs_rgn = '';
DEF cs_region = '';
DEF cs_locale = '';
DEF cs_other_acronym = '';
DEF cs_onsr = '';
DEF cs_dedicated = '';
DEF cs_odis = '';
DEF cs_skip = '';
DEF cs_dbid = '';
DEF cs_db_name = '';
DEF cs_db_name_u = '';
DEF cs_mysid = '';
DEF cs_con_id = '';
DEF cs_con_name = '';
DEF cs_instance_number = '';
DEF cs_db_version = '';
DEF cs_host_name = '';
DEF cs_startup_time = '';
DEF cs_startup_days = '';
DEF cs_date_time = '';
DEF cs_file_date_time = '';
DEF cs_file_timestamp = '';
DEF cs_current_schema = '';
DEF cs_containers_count = '';
DEF cs_cdb_availability_perc = '';
DEF cs_host_shape = '';
DEF cs_disk_config = '';
--
DEF cs_file_prefix = '';
DEF cs_file_name = '';
DEF cs_script_name = '';
DEF cs_script_acronym = '';
DEF spool_id_chart_footer_script = 'cs_null.sql';
DEF spool_chart_1st_column = 'Date Column';
--
DEF cs_min_snap_id = '';
DEF cs_min_snap_end_time = '';
DEF cs_snap_interval_seconds = '';
DEF cs_ash_interval_ms = '';
--
DEF cs_1h_snap_id = '';
DEF cs_1d_snap_id = '';
DEF cs_7d_snap_id = '';
DEF cs_30d_snap_id = '';
--
DEF cs_sql_id = '';
DEF cs_signature = '';
DEF cs_sql_handle = '';
DEF cs_plan_hash_value = '';
DEF cs_application_category = '';
DEF cs_sql_hv = '';
--
DEF cs_sample_time_from = '';
DEF cs_sample_time_to = '';
--
-- [{AUTO}|MANUAL]
DEF cs_snap_type = 'AUTO';
-- [{-666}|sid]
DEF cs_sid = '-666';
--
DEF pdb_creation = '';
--
COL cs_realm NEW_V cs_realm FOR A3 NOPRI;
COL cs_region NEW_V cs_region FOR A14 NOPRI;
COL cs_rgn NEW_V cs_rgn FOR A3 NOPRI;
COL cs_locale NEW_V cs_locale FOR A6 NOPRI;
COL cs_other_acronym NEW_V cs_other_acronym FOR A8 NOPRI;
COL cs_onsr NEW_V cs_onsr FOR A1 NOPRI;
COL cs_dedicated NEW_V cs_dedicated FOR A1 NOPRI;
COL cs_dbid NEW_V cs_dbid FOR A12 NOPRI;
COL cs_db_name NEW_V cs_db_name FOR A9 NOPRI;
COL cs_db_name_u NEW_V cs_db_name_u FOR A9 NOPRI;
COL cs_db_open_mode NEW_V cs_db_open_mode FOR A10 NOPRI;
COL cs_con_id NEW_V cs_con_id FOR A4 NOPRI;
COL cs_mysid NEW_V cs_mysid NOPRI;
COL cs_con_name NEW_V cs_con_name FOR A30 NOPRI;
COL cs_current_schema NEW_V cs_current_schema FOR A30 NOPRI;
COL cs_oracle_home NEW_V cs_oracle_home NOPRI;
COL cs_pdb_open_mode NEW_V cs_pdb_open_mode FOR A10 NOPRI;
COL cs_instance_number NEW_V cs_instance_number FOR A1 NOPRI;
COL cs_cpu_util_perc NEW_V cs_cpu_util_perc FOR A6 NOPRI;
COL cs_cpu_load NEW_V cs_cpu_load FOR A3 NOPRI;
COL cs_num_cpu_cores NEW_V cs_num_cpu_cores FOR A3 NOPRI;
COL cs_num_cpus NEW_V cs_num_cpus FOR A3 NOPRI;
COL cs_cpu_count NEW_V cs_cpu_count FOR A3 NOPRI;
DEF cs_allotted_cpu = '?';
COL cs_allotted_cpu NEW_V cs_allotted_cpu FOR A5 NOPRI;
DEF cs_resource_manager_plan = '?';
COL cs_resource_manager_plan NEW_V cs_resource_manager_plan FOR A30 NOPRI;
COL cs_db_version NEW_V cs_db_version FOR A17 NOPRI;
COL cs_startup_time NEW_V cs_startup_time FOR A19 NOPRI;
COL cs_startup_days NEW_V cs_startup_days FOR A5 NOPRI;
COL cs_date_time NEW_V cs_date_time FOR A19 NOPRI;
COL cs_file_date_time NEW_V cs_file_date_time FOR A19 NOPRI;
COL cs_file_timestamp NEW_V cs_file_timestamp FOR A15 NOPRI;
COL cs_easy_connect_string NEW_V cs_easy_connect_string FOR A132 NOPRI;
COL cs_containers_count NEW_V cs_containers_count NOPRI;
COL cs_cdb_availability_perc NEW_V cs_cdb_availability_perc FOR A3 NOPRI;
--
COL cs_file_prefix NEW_V cs_file_prefix NOPRI;
COL cs_file_name NEW_V cs_file_name NOPRI;
COL cs_script_name NEW_V cs_script_name NOPRI;
--
COL cs_min_snap_id NEW_V cs_min_snap_id FOR A6 NOPRI;
COL cs_min_snap_end_time NEW_V cs_min_snap_end_time FOR A19 NOPRI;
COL cs_snap_interval_seconds NEW_V cs_snap_interval_seconds FOR A4 NOPRI;
COL cs_ash_interval_ms NEW_V cs_ash_interval_ms FOR A5 NOPRI;
--
COL cs_1h_snap_id NEW_V cs_1h_snap_id FOR A6 NOPRI;
COL cs_1d_snap_id NEW_V cs_1d_snap_id FOR A6 NOPRI;
COL cs_7d_snap_id NEW_V cs_7d_snap_id FOR A6 NOPRI;
COL cs_30d_snap_id NEW_V cs_30d_snap_id FOR A6 NOPRI;
COL cs_startup_snap_id NEW_V cs_startup_snap_id FOR A6 NOPRI;
--
COL cs_signature NEW_V cs_signature FOR A20 NOPRI;
COL cs_sql_handle NEW_V cs_sql_handle FOR A20 NOPRI;
--
COL stgtab_sqlbaseline_script NEW_V stgtab_sqlbaseline_script NOPRI;
COL stgtab_sqlprofile_script NEW_V stgtab_sqlprofile_script NOPRI;
COL stgtab_sqlpatch_script NEW_V stgtab_sqlpatch_script NOPRI;
COL pdb_creation NEW_V pdb_creation NOPRI;
--
VAR cs_begin_total_time NUMBER;
VAR cs_begin_elapsed_time NUMBER;
EXEC :cs_begin_total_time := DBMS_UTILITY.get_time;
DEF cs_total_time = '';
DEF cs_elapsed_time = '';
COL cs_total_time NEW_V cs_total_time NOPRI;
COL cs_elapsed_time NEW_V cs_elapsed_time NOPRI;
--
VAR cs_signature NUMBER;
VAR cs_sql_text CLOB;
VAR cs_zapper_managed_sql_banner CLOB;
VAR kiev_metadata_date VARCHAR2(30);
--
SET TERM OFF;
--
SELECT SYS_CONTEXT('USERENV', 'SID') AS cs_mysid,
SYS_CONTEXT('USERENV', 'CON_ID') AS cs_con_id,
SYS_CONTEXT('USERENV', 'CON_NAME') AS cs_con_name,
SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') AS cs_current_schema,
SYS_CONTEXT('USERENV', 'ORACLE_HOME') AS cs_oracle_home,
TRIM(TO_CHAR(SYSDATE , '&&cs_datetime_full_format.')) AS cs_date_time,
TRIM(TO_CHAR(SYSDATE , '&&cs_datetime_short_format.')) AS cs_file_date_time,
TRIM(TO_CHAR(SYSDATE , '&&cs_datetime_dense_format.')) AS cs_file_timestamp
FROM DUAL
/
--
SELECT TRIM(TO_CHAR(d.dbid)) AS cs_dbid,
LOWER(d.name) AS cs_db_name,
UPPER(d.name) AS cs_db_name_u,
d.open_mode AS cs_db_open_mode
FROM v$database d
/
--
COL cs_host_name NEW_V cs_host_name FOR A64 NOPRI;
COL cs_odis NEW_V cs_odis FOR A1 NOPRI;
SELECT TRIM(TO_CHAR(i.instance_number)) AS cs_instance_number,
i.version AS cs_db_version,
NVL(i.host_name, 'HOSTNAME') AS cs_host_name,
CASE WHEN i.host_name IS NULL THEN 'Y' ELSE 'N' END AS cs_odis,
TO_CHAR(i.startup_time, '&&cs_datetime_full_format.') AS cs_startup_time,
TRIM(TO_CHAR(ROUND(SYSDATE - i.startup_time, 1), '990.0')) AS cs_startup_days
FROM v$instance i
/
--
COL cs_skip NEW_V cs_skip FOR A2 NOPRI;
COL list_sqlbaseline_script NEW_V list_sqlbaseline_script NOPRI;
COL list_dg_members_script NEW_V list_dg_members_script NOPRI;
COL cs_set_container_to_cdb_root NEW_V cs_set_container_to_cdb_root NOPRI;
COL cs_set_container_to_curr_pdb NEW_V cs_set_container_to_curr_pdb NOPRI;
COL cs_tools_schema NEW_V cs_tools_schema NOPRI;
COL cs_stgtab_owner NEW_V cs_stgtab_owner NOPRI;
COL cs_stgtab_prefix NEW_V cs_stgtab_prefix NOPRI;
COL cs_spbl_create_pre NEW_V cs_spbl_create_pre NOPRI;
COL cs_spbl_create_post NEW_V cs_spbl_create_post NOPRI;
COL cs_spbl_validate NEW_V cs_spbl_validate NOPRI;
COL cs_list_cbo_hints NEW_V cs_list_cbo_hints NOPRI;
COL cs_list_cbo_hints_b NEW_V cs_list_cbo_hints_b NOPRI;
COL cs_zapper_managed NEW_V cs_zapper_managed NOPRI;
DEF cs_zapper_managed_sql = 'N';
--
SELECT CASE WHEN '&&cs_odis.' = 'Y' THEN '--' END AS cs_skip,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_spbl_internal_list_simple.sql' ELSE 'cs_spbl_internal_list_debug.sql' END AS list_sqlbaseline_script,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_internal_list_dg_members.sql' END AS list_dg_members_script,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_set_container_to_cdb_root.sql' END AS cs_set_container_to_cdb_root,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_set_container_to_curr_pdb.sql' END AS cs_set_container_to_curr_pdb,
CASE WHEN '&&cs_odis.' = 'Y' THEN '&&odis_user.' ELSE '&&iod_user.' END AS cs_tools_schema,
CASE WHEN '&&cs_odis.' = 'Y' THEN '&&odis_user.' ELSE '&&iod_user.' END AS cs_stgtab_owner,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'odis' ELSE 'iod' END AS cs_stgtab_prefix,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_spbl_create_pre.sql' END AS cs_spbl_create_pre,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_spbl_create_post.sql' END AS cs_spbl_create_post,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_spbl_validate.sql' END AS cs_spbl_validate,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_list_cbo_hints.sql' END AS cs_list_cbo_hints,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_list_cbo_hints_b.sql' END AS cs_list_cbo_hints_b,
CASE WHEN '&&cs_odis.' = 'Y' THEN 'cs_null.sql' ELSE 'cs_zapper_managed.sql' END AS cs_zapper_managed
FROM DUAL
/
--
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_spbl_internal_stgtab_baseline.sql' ELSE 'cs_null.sql' END AS stgtab_sqlbaseline_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = UPPER('&&cs_stgtab_prefix._stgtab_baseline')
/
--
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_sprf_internal_stgtab_sqlprofile.sql' ELSE 'cs_null.sql' END AS stgtab_sqlprofile_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = UPPER('&&cs_stgtab_prefix._stgtab_sqlprof')
/
--
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_spch_internal_stgtab_sqlpatch.sql' ELSE 'cs_null.sql' END AS stgtab_sqlpatch_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = UPPER('&&cs_stgtab_prefix._stgtab_sqlpatch')
/
--
SELECT i.version_full AS cs_db_version -- 19c
FROM v$instance i
/
--
SELECT c.open_mode AS cs_pdb_open_mode
FROM v$containers c
WHERE c.con_id = SYS_CONTEXT('USERENV', 'CON_ID')
/
--
SELECT TRIM(TO_CHAR(ROUND(100 * os.busy_time / (os.busy_time + os.idle_time), 1), '990.0'))||'%' AS cs_cpu_util_perc
FROM (
SELECT NULLIF(GREATEST(busy_t2.value - busy_t1.value, 0), 0) AS busy_time, NULLIF(GREATEST(idle_t2.value - idle_t1.value, 0), 0) AS idle_time
FROM
(SELECT value FROM dba_hist_osstat WHERE stat_name = 'BUSY_TIME' ORDER BY snap_id DESC NULLS LAST FETCH FIRST 1 ROW ONLY) busy_t1,
(SELECT value FROM dba_hist_osstat WHERE stat_name = 'IDLE_TIME' ORDER BY snap_id DESC NULLS LAST FETCH FIRST 1 ROW ONLY) idle_t1,
(SELECT value FROM v$osstat WHERE stat_name = 'BUSY_TIME') busy_t2,
(SELECT value FROM v$osstat WHERE stat_name = 'IDLE_TIME') idle_t2
) os
/
--
SELECT TRIM(TO_CHAR(o.value)) AS cs_num_cpu_cores
FROM v$osstat o
WHERE o.stat_name = 'NUM_CPU_CORES'
/
--
SELECT TRIM(TO_CHAR(o2.value)) AS cs_num_cpus
FROM v$osstat o2
WHERE o2.stat_name = 'NUM_CPUS'
/
--
SELECT TRIM(TO_CHAR(ROUND(o3.value))) AS cs_cpu_load
FROM v$osstat o3
WHERE o3.stat_name = 'LOAD'
/
--
SELECT p.value AS cs_cpu_count
FROM v$parameter p
WHERE p.name = 'cpu_count'
/
--
SELECT TO_CHAR(h.op_timestamp, '&&cs_datetime_full_format') AS pdb_creation
FROM dba_pdb_history h
WHERE h.operation = 'CREATE'
/
--
COL dba_or_cdb NEW_V dba_or_cdb NOPRI;
SELECT CASE WHEN SYS_CONTEXT('USERENV', 'CON_NAME') = 'CDB$ROOT' THEN 'cdb' ELSE 'dba' END AS dba_or_cdb FROM DUAL
/
--
DEF cs_scope_1 = '';
DEF cs_sqlstat_days = '61';
@@cs_sample_time_boundaries.sql
@@cs_snap_id_from_and_to.sql
--
/****************************************************************************************/
--
ALTER SESSION SET container = CDB$ROOT;
--
SELECT 'CONTAINERS:'||TRIM(TO_CHAR(COUNT(*))) AS cs_containers_count FROM v$containers WHERE con_id > 2 AND open_mode = 'READ WRITE'
/
--
SELECT TO_CHAR(ROUND(100 * &&cs_tools_schema..PDB_CONFIG.get_cdb_availability), 'FM990') AS cs_cdb_availability_perc FROM DUAL
/
--
DEF cs_region = 'UNKNOWN_REGION';
SELECT CASE WHEN '&&cs_host_name.' = 'HOSTNAME' THEN 'UNKNOWN_REGION' ELSE &&cs_tools_schema..IOD_META_AUX.get_region('&&cs_host_name.') END AS cs_region FROM DUAL
/
--
SELECT REPLACE(&&cs_tools_schema..IOD_META_AUX.get_realm('&&cs_region.'), '?', 'X') AS cs_realm, REPLACE(&&cs_tools_schema..IOD_META_AUX.get_region_acronym('&&cs_region.'), '?', 'X') AS cs_rgn FROM DUAL
/
--
SELECT REPLACE(&&cs_tools_schema..IOD_META_AUX.get_other_acronym('&&cs_region.'), '?', 'X') AS cs_other_acronym, REPLACE(&&cs_tools_schema..IOD_META_AUX.get_onsr('&&cs_region.'), '?', 'X') AS cs_onsr, REPLACE(&&cs_tools_schema..IOD_META_AUX.get_dedicated('&&cs_region.'), '?', 'X') AS cs_dedicated FROM DUAL
/
--
SELECT &&cs_tools_schema..IOD_META_AUX.get_locale(value) AS cs_locale FROM v$parameter WHERE name = 'db_domain'
/
--
COL zapper_19_actions_script NEW_V zapper_19_actions_script NOPRI;
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_zapper_19_actions.sql' ELSE 'cs_null.sql' END AS zapper_19_actions_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = UPPER('zapper_log')
/
--
COL oem_me_sqlperf_script NEW_V oem_me_sqlperf_script NOPRI;
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_oem_me_sqlperf.sql' ELSE 'cs_null.sql' END AS oem_me_sqlperf_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = UPPER('alerts_hist')
/
--
SELECT /*+ OPT_PARAM('_px_cdb_view_enabled' 'FALSE') */
r.plan AS cs_resource_manager_plan,
CASE
WHEN '&&cs_con_name.' = 'CDB$ROOT' THEN '&&cs_cpu_count. (SAME AS CPU_COUNT)'
WHEN r.utilization_limit IS NULL OR '&&cs_cpu_count.' IS NULL THEN '?'
ELSE TRIM(TO_CHAR(ROUND(r.utilization_limit * TO_NUMBER('&&cs_cpu_count.') / 100, 1), '990.0'))||'('||r.utilization_limit||'% OF CPU_COUNT)' END AS cs_allotted_cpu
FROM v$parameter p, dba_cdb_rsrc_plan_directives r
WHERE p.name = 'resource_manager_plan'
AND r.directive_type(+) = 'PDB'
AND r.plan(+) = REPLACE(p.value, 'FORCE:')
AND r.pluggable_database(+) = '&&cs_con_name.'
/
--
SELECT /*+ OPT_PARAM('_px_cdb_view_enabled' 'FALSE') */
COALESCE('&&cs_resource_manager_plan.', r.plan) AS cs_resource_manager_plan,
CASE
WHEN '&&cs_con_name.' = 'CDB$ROOT' THEN '&&cs_cpu_count.'
WHEN r.utilization_limit IS NULL OR '&&cs_cpu_count.' IS NULL THEN '?'
WHEN '&&cs_allotted_cpu.' <> '?' THEN '&&cs_allotted_cpu.'
ELSE TRIM(TO_CHAR(ROUND(r.utilization_limit * TO_NUMBER('&&cs_cpu_count.') / 100, 1), '990.0'))||'('||r.utilization_limit||'% by Default)' END AS cs_allotted_cpu
FROM v$parameter p, dba_cdb_rsrc_plan_directives r
WHERE p.name = 'resource_manager_plan'
AND r.directive_type(+) = 'DEFAULT_DIRECTIVE'
AND r.plan(+) = REPLACE(p.value, 'FORCE:')
AND r.pluggable_database(+) = 'ORA$DEFAULT_PDB_DIRECTIVE'
/
--
COL blackout_dates_script NEW_V blackout_dates_script NOPRI;
SELECT CASE WHEN COUNT(*) > 0 THEN 'cs_blackout_internal.sql' ELSE 'cs_null.sql' END AS blackout_dates_script
FROM dba_tables
WHERE owner = UPPER('&&cs_stgtab_owner.')
AND table_name = 'BLACKOUT'
/
DEF cs_blackout_times = '';
@@&&blackout_dates_script.
--
DEF cs_avg_running_sessions_cdb = '?';
COL cs_avg_running_sessions_cdb NEW_V cs_avg_running_sessions_cdb NOPRI;
SELECT TRIM(TO_CHAR(ROUND(avg_running_sessions))) AS cs_avg_running_sessions_cdb FROM (
SELECT end_time, SUM(avg_running_sessions) AS avg_running_sessions, ROW_NUMBER() OVER (ORDER BY end_time DESC) AS rn
FROM &&cs_tools_schema..dbc_rsrcmgrmetric_history
WHERE /*consumer_group_name = 'OTHER_GROUPS' AND*/ end_time > SYSDATE - (1/24)
GROUP BY end_time
) WHERE rn = 1
/
DEF cs_avg_running_sessions_pdb = '?';
COL cs_avg_running_sessions_pdb NEW_V cs_avg_running_sessions_pdb NOPRI;
SELECT TRIM(TO_CHAR(ROUND(avg_running_sessions))) AS cs_avg_running_sessions_pdb FROM (
SELECT end_time, SUM(avg_running_sessions) AS avg_running_sessions, ROW_NUMBER() OVER (ORDER BY end_time DESC) AS rn
FROM &&cs_tools_schema..dbc_rsrcmgrmetric_history
WHERE pdb_name = '&&cs_con_name.' AND /*consumer_group_name = 'OTHER_GROUPS' AND*/ end_time > SYSDATE - (1/24)
GROUP BY end_time
) WHERE rn = 1
/
-- replaced due to performance concerns (it would take up to 8 seconds in some environments)
-- SELECT TRIM(TO_CHAR(ROUND(SUM(avg_running_sessions)))) AS cs_avg_running_sessions_cdb FROM v$rsrcmgrmetric WHERE consumer_group_name = 'OTHER_GROUPS'
-- /
--
COL cs_host_shape NEW_V cs_host_shape NOPRI;
COL cs_disk_config NEW_V cs_disk_config NOPRI;
SELECT 'SHAPE:'||host_shape AS cs_host_shape, 'DISK:'||disk_config AS cs_disk_config
FROM &&cs_tools_schema..dbc_system
ORDER BY
timestamp DESC
FETCH FIRST 1 ROW ONLY
/
--
BEGIN
FOR i IN (SELECT owner, table_name FROM dba_tables WHERE owner = UPPER('&&cs_tools_schema.') AND table_name = UPPER('kiev_ind_columns'))
LOOP
EXECUTE IMMEDIATE 'SELECT TO_CHAR(timestamp, ''&&cs_timestamp_full_format.'') AS kiev_metadata_date FROM '||i.owner||'.'||i.table_name||' WHERE ROWNUM = 1' INTO :kiev_metadata_date;
END LOOP;
END;
/
COL kiev_metadata_date NEW_V kiev_metadata_date NOPRI;
SELECT :kiev_metadata_date AS kiev_metadata_date FROM DUAL
/
--
-- time when host was rebooted (executed from CD$ROOT only)
DEF cs_system_boot_time = '';
COL cs_system_boot_time NEW_V cs_system_boot_time FOR A19 NOPRI;
SELECT TO_CHAR(MAX(system_boot_time), '&&cs_datetime_full_format.') AS cs_system_boot_time FROM &&cs_tools_schema..dbc_system;
--
-- phonebook, compartment_id and kiev_data_store
DEF cs_phonebook_pdb = '';
DEF cs_compartment_id_pdb = '';
DEF cs_kiev_store_name = '';
--
COL cs_phonebook_pdb NEW_V cs_phonebook_pdb FOR A256 NOPRI;
COL cs_compartment_id_pdb NEW_V cs_compartment_id_pdb FOR A128 NOPRI;
COL cs_kiev_store_name NEW_V cs_kiev_store_name FOR A128 NOPRI;
--
-- executed from CD$ROOT only
SELECT NVL(phonebook, 'UNKNOWN') AS cs_phonebook_pdb, -- out of horizon (oc1) else from kiev/dbpcs metadata
NVL(compartment_id, 'UNKNOWN') AS cs_compartment_id_pdb, -- out of kiev or dbcps metadata
NVL(kiev_store_name, 'N/A') AS cs_kiev_store_name -- null for kiev multi-schema pdbs
FROM &&cs_tools_schema..dbc_pdb_metadata_v
WHERE pdb_name = '&&cs_con_name.' -- from SYS_CONTEXT('USERENV', 'CON_NAME') when connected into PDB
/
--
ALTER SESSION SET CONTAINER = &&cs_con_name.;
--
/****************************************************************************************/
--
DEF cs_easy_connect_string = 'CONNECT_STRING';
WITH
service AS (
SELECT /*+ MATERIALIZWE NO_MERGE OPT_PARAM('_px_cdb_view_enabled' 'FALSE') */
CASE WHEN ds.pdb = 'CDB$ROOT' THEN 'oradb' WHEN ts.name = 'KIEV' THEN 'kiev' ELSE 'orapdb' END type,
ds.name||'.'||SYS_CONTEXT('USERENV','DB_DOMAIN') name,
vs.con_id, ds.pdb
FROM cdb_services ds,
v$active_services vs,
v$tablespace ts
WHERE 1 = 1
AND ds.pdb = SYS_CONTEXT ('USERENV', 'CON_NAME')
AND ds.name LIKE 's\_%' ESCAPE '\'
AND ds.name NOT LIKE '%\_ro' ESCAPE '\'
AND vs.con_name = ds.pdb
AND vs.name = ds.name
AND ts.con_id(+) = vs.con_id
AND ts.name(+) = 'KIEV'
)
SELECT --s.pdb,
--'jdbc:oracle:thin:@//'||
CASE
WHEN '&&cs_host_name.' = 'HOSTNAME' THEN 'CONNECT_STRING'
ELSE
s.type||'-'||
CASE
WHEN s.pdb = 'CDB$ROOT' THEN REPLACE(LOWER(SYS_CONTEXT('USERENV','DB_NAME')),'_','-')
ELSE REPLACE(LOWER(s.pdb),'_','-')
END||'.svc.'||
CASE
WHEN REGEXP_COUNT(REPLACE(REPLACE(LOWER(SYS_CONTEXT('USERENV','DB_DOMAIN')),'regional.',''),'.regional',''),'\.') = 0 THEN SUBSTR('&&cs_host_name.',INSTR('&&cs_host_name.','.',-1,1)+1)
ELSE SUBSTR('&&cs_host_name.',INSTR('&&cs_host_name.','.',-1,2)+1)
END||'/'||
s.name
END cs_easy_connect_string
FROM service s
/
--
SELECT TRIM(TO_CHAR(snap_id)) cs_min_snap_id,
TRIM(TO_CHAR(end_interval_time, '&&cs_datetime_full_format.')) cs_min_snap_end_time
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
ORDER BY
snap_id ASC
FETCH FIRST 1 ROW ONLY
/
--
@@cs_last_snap.sql
--
SELECT TRIM(TO_CHAR((24 * 3600 * EXTRACT(day FROM snap_interval)) + (3600 * EXTRACT(hour FROM snap_interval)) + (60 * EXTRACT(minute FROM snap_interval)) + EXTRACT(second FROM snap_interval))) cs_snap_interval_seconds
FROM dba_hist_wr_control
/
SELECT TRIM(TO_CHAR(sampling_interval)) cs_ash_interval_ms
FROM v$ash_info
/
--
SELECT TRIM(TO_CHAR(MIN(snap_id))) cs_1h_snap_id
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND end_interval_time > SYSDATE - (1/24)
/
SELECT TRIM(TO_CHAR(MIN(snap_id))) cs_1d_snap_id
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND end_interval_time > SYSDATE - 1
/
SELECT TRIM(TO_CHAR(MIN(snap_id))) cs_7d_snap_id
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND end_interval_time > SYSDATE - 7
/
SELECT TRIM(TO_CHAR(MIN(snap_id))) cs_30d_snap_id
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND end_interval_time > SYSDATE - 30
/
SELECT TRIM(TO_CHAR(MIN(snap_id))) cs_startup_snap_id
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND begin_interval_time > TO_DATE('&&cs_startup_time.', '&&cs_datetime_full_format.')
/
--
DEF cs_kiev_owner = '';
COL cs_kiev_owner NEW_V cs_kiev_owner NOPRI;
SELECT owner cs_kiev_owner FROM dba_tables WHERE table_name = 'KIEVDATASTOREMETADATA' AND num_rows > 0 ORDER BY num_rows
/
DEF cs_jason_value = '';
COL cs_jason_value NEW_V cs_jason_value NOPRI;
select JSON_VALUE(DATA, '$.transactorConfiguration.algorithmType') cs_jason_value
from &&cs_kiev_owner..kievdynamicconfiguration
where version=(select MAX(version) from &&cs_kiev_owner..kievdynamicconfiguration)
/
DEF cs_kiev_version = '';
COL cs_kiev_version NEW_V cs_kiev_version FOR A30 TRUNC NOPRI;
DEF cs_schema_name = '';
COL cs_schema_name NEW_V cs_schema_name FOR A30 TRUNC NOPRI;
SELECT CASE WHEN '&&cs_kiev_owner.' IS NULL THEN 'NOT_KIEV' ELSE NVL('&&cs_jason_value.', 'CLASSIC') END AS cs_kiev_version, NVL('&&cs_kiev_owner.', 'NOT_KIEV') AS cs_schema_name FROM DUAL
/
--
@@/tmp/cs_default_reference.sql
SET TERM ON;
--CLEAR SCREEN;
PRO
PRO Reference: [{&&cs_default_reference.}|DBPERF-nnnnn|IOD-nnnnn|NOC-nnnnn|PROJECT-nnnnn]
PRO Enter Reference: &&cs_reference.
COL cs_reference NEW_V cs_reference NOPRI;
SELECT UPPER(REPLACE(COALESCE('&&cs_reference.', '&&cs_default_reference.'), ' ')) AS cs_reference FROM DUAL;
COL cs_reference_sanitized NEW_V cs_reference_sanitized NOPRI;
SELECT TRANSLATE('&&cs_reference.', '*()@#$[]{}|/\".,?<>''', '___________________') cs_reference_sanitized FROM DUAL;
--
DEF target_local_directory = '&&cs_def_local_dir.';
COL cs_local_dir NEW_V cs_local_dir NOPRI;
SELECT NVL('&&target_local_directory.', '&&cs_def_local_dir.') cs_local_dir FROM DUAL;
--
DEF cs_extended_reference = '';
COL cs_extended_reference NEW_V cs_extended_reference NOPRI;
SELECT '&&cs_reference.'||
CASE '&&cs_odis.' WHEN 'N' THEN ' &&cs_realm. &&cs_region. &&cs_rgn. &&cs_locale.' END||
' &&cs_db_name..&&cs_con_name.'||
NVL2('&&cs_other_acronym.', ' &&cs_other_acronym.', NULL)||
CASE '&&cs_odis.' WHEN 'Y' THEN ' ODIS' END||
CASE '&&cs_onsr.' WHEN 'Y' THEN ' ONSR' END||
CASE '&&cs_dedicated.' WHEN 'Y' THEN ' DEDICATED' END AS cs_extended_reference
FROM DUAL
/
SPO /tmp/cs_default_reference.sql;
PRO DEF cs_default_reference = "&&cs_reference.";
SPO OFF;
--
SET TERM OFF;
VAR who_am_i CLOB;
!who am i > /tmp/get_who_am_i.txt
get /tmp/get_who_am_i.txt
.
999999 ]'; END;;
0 BEGIN :who_am_i := q'[
/
DEF who_am_i = 'oracle';
COL who_am_i NEW_V who_am_i NOPRI;
SELECT REGEXP_SUBSTR(:who_am_i, '[a-z]+') AS who_am_i FROM DUAL
/
DEF engineer_info = '';
COL engineer_info NEW_V engineer_info NOPRI;
SELECT SUBSTR('&&who_am_i. '||SUBSTR(REPLACE('&&cs_reference.', ' '), 1, 30)||' &&cs_date_time.', 1, 64) AS engineer_info FROM DUAL
/
-- V$SESSION.CLIENT_INFO
EXEC DBMS_APPLICATION_INFO.set_client_info(client_info => '&&engineer_info.');
-- V$SESSION.CLIENT_IDENTIFIER V$ACTIVE_SESSION_HISTORY.CLIENT_ID DBA_HIST_ACTIVE_SESS_HISTORY.CLIENT_ID
EXEC DBMS_SESSION.set_identifier(client_id => '&&engineer_info.');
SET TERM ON;
csierra/cs_internal/cs_dependency_index_columns.sql
+163
View File
@@ -0,0 +1,163 @@
COL table_owner FOR A30 HEA 'Table Owner';
COL table_name FOR A30 HEA 'Table Name';
COL index_name FOR A30 HEA 'Index Name';
COL visibility FOR A10 HEA 'Visibility';
COL partitioned FOR A4 HEA 'Part';
COL column_position FOR 999 HEA 'Pos';
COL column_name FOR A30 HEA 'Column Name';
COL data_type FOR A33 HEA 'Data Type';
COL data_length FOR 999,999,990 HEA 'Data Length';
COL nullable FOR A8 HEA 'Nullable';
COL data_default FOR A30 HEA 'Data Default';
COL num_distinct FOR 999,999,999,990 HEA 'Num Distinct';
COL low_value_translated FOR A64 HEA 'Low Value Translated';
COL high_value_translated FOR A64 HEA 'High Value Translated';
COL density FOR 0.000000000 HEA 'Density';
COL num_nulls FOR 999,999,999,990 HEA 'Num Nulls';
COL num_buckets FOR 999,990 HEA 'Buckets';
COL histogram FOR A15 HEA 'Histogram';
COL sample_size FOR 999,999,999,990 HEA 'Sample Size';
COL last_analyzed FOR A19 HEA 'Last Analyzed';
COL avg_col_len FOR 999,999,990 HEA 'Avg Col Len';
COL data_length FOR 999,999,990 HEA 'Data Length';
COL char_length FOR 999,999,990 HEA 'Char Length';
--
BRE ON table_owner ON table_name ON index_name SKIP 1 ON visibility ON partitioned;
--
PRO
PRO INDEX COLUMNS (dba_ind_columns)
PRO ~~~~~~~~~~~~~
WITH /* INDEXE COLUMNS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
AND ROWNUM >= 1
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
AND ROWNUM >= 1
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
DISTINCT
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
AND ROWNUM >= 1
),
ic AS (SELECT /*+ MATERIALIZE NO_MERGE */ * FROM dba_ind_columns WHERE (table_owner, table_name) IN (SELECT owner, table_name FROM dba_tables_m) AND ROWNUM >= 1),
tc AS (SELECT /*+ MATERIALIZE NO_MERGE */ * FROM dba_tab_cols WHERE (owner, table_name) IN (SELECT owner, table_name FROM dba_tables_m) AND ROWNUM >= 1),
ix AS (SELECT /*+ MATERIALIZE NO_MERGE */ * FROM dba_indexes WHERE (table_owner, table_name) IN (SELECT owner, table_name FROM dba_tables_m) AND ROWNUM >= 1)
SELECT /*+ QB_NAME(get_stats) */
i.table_owner,
i.table_name,
i.index_name,
x.visibility,
x.partitioned,
i.column_position,
c.column_name,
c.data_type,
c.data_length,
c.nullable,
c.data_default data_default,
c.num_distinct,
CASE WHEN c.data_type = 'NUMBER' THEN to_char(utl_raw.cast_to_number(c.low_value))
WHEN c.data_type IN ('VARCHAR2', 'CHAR') THEN SUBSTR(to_char(utl_raw.cast_to_varchar2(c.low_value)),1,64)
WHEN c.data_type IN ('NVARCHAR2','NCHAR') THEN SUBSTR(to_char(utl_raw.cast_to_nvarchar2(c.low_value)),1,64)
WHEN c.data_type = 'BINARY_DOUBLE' THEN to_char(utl_raw.cast_to_binary_double(c.low_value))
WHEN c.data_type = 'BINARY_FLOAT' THEN to_char(utl_raw.cast_to_binary_float(c.low_value))
WHEN c.data_type = 'DATE' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.low_value,1,2) ,'XX')-100) + (to_number(substr(c.low_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.low_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,13,2),'XX')-1,'00')))
WHEN c.data_type LIKE 'TIMESTAMP%' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.low_value,1,2) ,'XX')-100) + (to_number(substr(c.low_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.low_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,13,2),'XX')-1,'00'))||'.'||
to_number(substr(c.low_value,15,8),'XXXXXXXX'))
END low_value_translated,
CASE WHEN c.data_type = 'NUMBER' THEN to_char(utl_raw.cast_to_number(c.high_value))
WHEN c.data_type IN ('VARCHAR2', 'CHAR') THEN SUBSTR(to_char(utl_raw.cast_to_varchar2(c.high_value)),1,64)
WHEN c.data_type IN ('NVARCHAR2','NCHAR') THEN SUBSTR(to_char(utl_raw.cast_to_nvarchar2(c.high_value)),1,64)
WHEN c.data_type = 'BINARY_DOUBLE' THEN to_char(utl_raw.cast_to_binary_double(c.high_value))
WHEN c.data_type = 'BINARY_FLOAT' THEN to_char(utl_raw.cast_to_binary_float(c.high_value))
WHEN c.data_type = 'DATE' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.high_value,1,2) ,'XX')-100) + (to_number(substr(c.high_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.high_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,13,2),'XX')-1,'00')))
WHEN c.data_type LIKE 'TIMESTAMP%' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.high_value,1,2) ,'XX')-100) + (to_number(substr(c.high_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.high_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,13,2),'XX')-1,'00'))||'.'||
to_number(substr(c.high_value,15,8),'XXXXXXXX'))
END high_value_translated,
c.density,
c.num_nulls,
c.num_buckets,
c.histogram,
c.sample_size,
TO_CHAR(c.last_analyzed, '&&cs_datetime_full_format.') last_analyzed,
c.avg_col_len,
c.data_length,
c.char_length
FROM dba_tables_m t,
ic i,
tc c,
ix x
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND c.owner = i.table_owner
AND c.table_name = i.table_name
AND c.column_name = i.column_name
AND x.table_owner = i.table_owner
AND x.table_name = i.table_name
AND x.index_name = i.index_name
ORDER BY
i.table_owner,
i.table_name,
i.index_name,
i.column_position
/
--
CL BRE;
--
csierra/cs_internal/cs_dependency_indexes.sql
+245
View File
@@ -0,0 +1,245 @@
COL table_owner FOR A30 HEA 'Table Owner';
COL table_name FOR A30 HEA 'Table Name';
COL index_name FOR A30 HEA 'Index Name';
COL partitioned FOR A4 HEA 'Part';
COL orphaned_entries FOR A8 HEA 'Orphaned|Entries';
COL degree FOR A10 HEA 'Degree';
COL index_type FOR A27 HEA 'Index Type';
COL uniqueness FOR A10 HEA 'Uniqueness';
COL columns FOR 999,999 HEA 'Columns';
COL status FOR A8 HEA 'Status';
COL visibility FOR A10 HEA 'Visibility';
COL blevel FOR 99,990 HEA 'BLevel';
COL leaf_blocks FOR 999,999,990 HEA 'Leaf Blocks';
COL size_MiB FOR 999,999,990.000 HEA 'Size MiB';
COL seg_size_MiB FOR 999,999,990.000 HEA 'Seg Size MiB';
COL size_MB FOR 999,999,990.000 HEA 'Size MB';
COL seg_size_MB FOR 999,999,990.000 HEA 'Seg Size MB';
COL distinct_keys FOR 999,999,999,990 HEA 'Dist Keys';
COL clustering_factor FOR 999,999,999,990 HEA 'Clust Fact';
COL num_rows FOR 999,999,999,990 HEA 'Num Rows';
COL sample_size FOR 999,999,999,990 HEA 'Sample Size';
COL last_analyzed FOR A19 HEA 'Last Analyzed';
COL compression FOR A13 HEA 'Compression';
COL tablespace_name FOR A30 HEA 'Tablespace';
COL rn FOR 999;
--
PRO
PRO INDEXES (dba_indexes)
PRO ~~~~~~~
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT /*+ QB_NAME(get_stats) */
i.table_owner,
i.table_name,
i.index_name,
CASE i.partitioned WHEN 'YES' THEN (SELECT TRIM(TO_CHAR(COUNT(*))) FROM dba_ind_partitions ip WHERE ip.index_owner = i.owner AND ip.index_name = i.index_name) ELSE i.partitioned END AS partitioned,
i.orphaned_entries,
i.degree,
i.index_type,
i.uniqueness,
(SELECT COUNT(*) FROM dba_ind_columns ic WHERE ic.index_owner = i.owner AND ic.index_name = i.index_name) AS columns,
i.status,
i.visibility,
i.blevel,
i.leaf_blocks,
i.leaf_blocks * COALESCE(b.block_size, TO_NUMBER(p.value)) / POWER(10,6) AS size_MB,
(SELECT SUM(s.bytes) / POWER(10,6) FROM dba_segments s WHERE s.owner = i.owner AND s.segment_name = i.index_name AND s.segment_type LIKE 'INDEX%') AS seg_size_MB,
i.distinct_keys,
i.clustering_factor,
i.num_rows,
i.sample_size,
TO_CHAR(i.last_analyzed, '&&cs_datetime_full_format.') AS last_analyzed,
i.compression,
i.tablespace_name
FROM dba_tables_m t,
dba_indexes i,
dba_tablespaces b,
v$parameter p
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND b.tablespace_name(+) = i.tablespace_name
AND p.name = 'db_block_size'
ORDER BY
i.table_owner,
i.table_name,
i.index_name
/
--
COL object_type HEA 'Object Type';
COL object_id FOR 999999999 HEA 'Object ID';
COL object_name FOR A30 HEA 'Object Name';
COL subobject_name FOR A30 HEA 'Sub Object Name';
COL created FOR A23 HEA 'Created';
COL last_ddl_time FOR A23 HEA 'Last DDL Time';
--
PRO
PRO INDEX OBJECTS (dba_objects) up to 100
PRO ~~~~~~~~~~~~~
WITH /* OBJECTS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT o.object_type,
o.owner,
o.object_name,
o.subobject_name,
o.object_id,
TO_CHAR(o.created, '&&cs_datetime_full_format.') AS created,
TO_CHAR(o.last_ddl_time, '&&cs_datetime_full_format.') AS last_ddl_time
FROM dba_tables_m t,
dba_indexes i,
dba_objects o
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND o.owner = i.owner
AND o.object_name = i.index_name
AND o.object_type LIKE 'INDEX%'
ORDER BY
o.object_type,
o.owner,
o.object_name,
o.subobject_name
FETCH FIRST 100 ROWS ONLY
/
--
COL object_type HEA 'Object Type';
COL owner FOR A30 HEA 'Owner';
COL object_id FOR 999999999 HEA 'Object ID';
COL object_name FOR A30 HEA 'Object Name';
COL subobject_name FOR A30 HEA 'Sub Object Name';
COL created FOR A23 HEA 'Created';
COL last_ddl_time FOR A23 HEA 'Last DDL Time';
COL analyzetime FOR A19 HEA 'Analyze Time';
COL savtime FOR A23 HEA 'Saved Time';
COL rowcnt FOR 999,999,999,990 HEA 'Row Count';
COL blevel FOR 99,990 HEA 'BLevel';
COL leafcnt FOR 999,999,990 HEA 'Leaf Blocks';
COL distkey FOR 999,999,999,990 HEA 'Dist Keys';
COL samplesize FOR 999,999,999,990 HEA 'Sample Size';
--
BREAK ON object_id SKIP 1 ON owner ON object_name ON created ON last_ddl_time;
PRO
PRO CBO STAT INDEX HISTORY (wri$_optstat_ind_history) up to 25 per Index
PRO ~~~~~~~~~~~~~~~~~~~~~~
WITH /* OBJECTS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
),
dba_indexes_o AS (
SELECT o.owner,
o.object_name,
o.subobject_name,
o.object_id,
o.created,
o.last_ddl_time,
h.analyzetime,
h.savtime,
h.rowcnt,
h.blevel,
h.leafcnt,
h.distkey,
h.samplesize,
ROW_NUMBER() OVER (PARTITION BY o.object_id ORDER BY h.analyzetime DESC NULLS LAST, h.savtime DESC NULLS LAST) AS rn
FROM dba_tables_m t,
dba_indexes i,
dba_objects o,
wri$_optstat_ind_history h
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND o.owner = i.owner
AND o.object_name = i.index_name
AND o.object_type = 'INDEX'
AND h.obj# = o.object_id
)
SELECT DISTINCT
o.owner,
o.object_name,
o.subobject_name,
o.object_id,
TO_CHAR(o.created, '&&cs_datetime_full_format.') AS created,
TO_CHAR(o.last_ddl_time, '&&cs_datetime_full_format.') AS last_ddl_time,
TO_CHAR(o.analyzetime, '&&cs_datetime_full_format.') AS analyzetime,
TO_CHAR(o.savtime, '&&cs_timestamp_full_format.') AS savtime,
o.rowcnt,
o.blevel,
o.leafcnt,
o.distkey,
o.samplesize
FROM dba_indexes_o o
WHERE o.rn <= 25
ORDER BY 1, 2, 3, 4, 5, 6, 7 NULLS FIRST, 8 NULLS FIRST
/
--
CLEAR BREAK;
csierra/cs_internal/cs_dependency_lobs.sql
+116
View File
@@ -0,0 +1,116 @@
COL owner FOR A30 HEA 'Table Owner';
COL table_name FOR A30 HEA 'Table Name';
COL column_name FOR A30 HEA 'Column Name';
COL index_name FOR A30 HEA 'Index Name';
COL segment_name FOR A30 HEA 'Segment Name';
COL bytes FOR 999,999,999,999,990 HEA 'Bytes';
COL blocks FOR 999,999,990 HEA 'Blocks';
COL size_MiB FOR 999,999,990.000 HEA 'Size MiB';
COL size_MB FOR 999,999,990.000 HEA 'Size MB';
COL deduplication FOR A13 HEA 'Deduplication';
COL compression FOR A11 HEA 'Compression';
COL encrypt FOR A7 HEA 'Encrypt';
COL cache FOR A5 HEA 'Cache';
COL securefile FOR A10 HEA 'SecureFile';
COL in_row FOR A6 HEA 'In Row';
COL tablespace_name FOR A30 HEA 'Tablespace';
--
BRE ON owner ON table_name SKIP 1;
--
PRO
PRO LOBS (dba_lobs)
PRO ~~~~
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT /*+ QB_NAME(get_stats) */
t.owner,
t.table_name,
l.column_name,
SUM(s.bytes) AS bytes,
SUM(s.blocks) AS blocks,
--SUM(s.blocks) * COALESCE(b.block_size, TO_NUMBER(p.value)) / POWER(2,20) AS size_MiB,
SUM(s.blocks) * COALESCE(b.block_size, TO_NUMBER(p.value)) / POWER(10,6) AS size_MB,
l.deduplication,
l.compression,
l.encrypt,
l.cache,
l.securefile,
l.in_row,
l.index_name,
l.segment_name,
l.tablespace_name
FROM dba_tables_m t,
dba_lobs l,
dba_segments s,
dba_tablespaces b,
v$parameter p
WHERE l.owner = t.owner
AND l.table_name = t.table_name
AND s.owner = l.owner
AND s.segment_name = l.segment_name
AND s.segment_type IN ('LOBSEGMENT', 'LOB PARTITION')
AND b.tablespace_name(+) = l.tablespace_name
AND p.name = 'db_block_size'
GROUP BY
t.owner,
t.table_name,
l.column_name,
l.index_name,
l.segment_name,
l.deduplication,
l.compression,
l.encrypt,
l.cache,
l.securefile,
l.in_row,
l.tablespace_name,
b.block_size,
p.value
ORDER BY
t.owner,
t.table_name,
l.column_name
/
--
CL BRE;
--
csierra/cs_internal/cs_dependency_metadata.sql
+120
View File
@@ -0,0 +1,120 @@
DEF max_partitions = '1000';
--
COL owner FOR A30 HEA 'Owner';
COL table_name FOR A30 HEA 'Table Name';
COL index_name FOR A30 HEA 'Index Name';
COL metadata FOR A200 HEA 'Metadata';
--
BREAK ON table_name SKIP PAGE;
PRO
PRO TABLE METADATA DBMS_METADATA.get_ddl('TABLE', table_name, owner) only if up to &&max_partitions. partitions
PRO ~~~~~~~~~~~~~~
WITH /* TABLES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT owner, table_name, DBMS_METADATA.get_ddl('TABLE', table_name, owner) AS metadata
FROM dba_tables_m
ORDER BY
owner, table_name
/
--
BREAK ON index_name SKIP PAGE;
PRO
PRO INDEX METADATA DBMS_METADATA.get_ddl('INDEX', index_name, owner) only if up to &&max_partitions. partitions
PRO ~~~~~~~~~~~~~~
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT i.owner, i.table_name, i.index_name, DBMS_METADATA.get_ddl('INDEX', i.index_name, i.owner) AS metadata
FROM dba_tables_m t,
dba_indexes i
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND CASE i.partitioned WHEN 'YES' THEN -- include only indexes with up to &&max_partitions. partitions
CASE WHEN (SELECT COUNT(*) FROM dba_ind_partitions ip WHERE ip.index_owner = i.owner AND ip.index_name = i.index_name) <= &&max_partitions. THEN 1 ELSE 0 END
ELSE 1 END = 1
ORDER BY
i.owner,
i.table_name,
i.index_name
/
--
CLEAR BREAK;
csierra/cs_internal/cs_dependency_part_keys.sql
+95
View File
@@ -0,0 +1,95 @@
COL part_sub FOR A12 HEA 'LEVEL';
COL object_type FOR A5 HEA 'TYPE';
COL owner FOR A30 TRUNC;
COL name FOR A30 TRUNC;
COL column_position FOR 999 HEA 'POS';
COL column_name FOR A30 TRUNC;
--
PRO
PRO PARTITION KEYS (dba_part_key_columns and dba_subpart_key_columns)
PRO ~~~~~~~~~~~~~~
--
WITH /* PART_KEY_COLUMNS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
),
dba_indexes_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_indexes) */
i.owner,
i.index_name
FROM dba_tables_m t,
dba_indexes i
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
),
objects_m AS (
SELECT owner, table_name AS name, 'TABLE' AS object_type
FROM dba_tables_m
UNION
SELECT owner, index_name AS name, 'INDEX' AS object_type
FROM dba_indexes_m
)
SELECT 'PARTITION' AS part_sub,
p.object_type,
p.owner,
p.name,
p.column_position,
p.column_name
FROM dba_part_key_columns p,
objects_m o
WHERE o.owner = p.owner
AND o.name = p.name
AND o.object_type = p.object_type
UNION ALL
SELECT 'SUBPARTITION' AS part_sub,
p.object_type,
p.owner,
p.name,
p.column_position,
p.column_name
FROM dba_subpart_key_columns p,
objects_m o
WHERE o.owner = p.owner
AND o.name = p.name
AND o.object_type = p.object_type
ORDER BY
1 ASC, 2 DESC, 3, 4, 5
/
csierra/cs_internal/cs_dependency_segments.sql
+164
View File
@@ -0,0 +1,164 @@
COL owner FOR A30;
COL segment_name FOR A30;
COL partition_name FOR A30;
COL column_name FOR A30;
COL segments FOR 9,999,990;
--
COL mebibytes FOR 999,999,990.000 HEA 'Size MiB';
COL megabytes FOR 999,999,990.000 HEA 'Size MB';
COL tablespace_name FOR A30 HEA 'Tablespace';
BREAK ON REPORT;
COMPUTE SUM LABEL 'TOTAL' OF mebibytes megabytes segments ON REPORT;
--
PRO
PRO SEGMENTS (dba_segments) top 100
PRO ~~~~~~~~
-- do not use cdb views since they perform very poorly
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
),
s AS (
SELECT 1 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, NULL AS column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_segments s
WHERE s.owner = t.owner
AND s.segment_name = t.table_name
AND s.segment_type LIKE 'TABLE%'
UNION ALL
SELECT 2 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, NULL AS column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_indexes i, dba_segments s
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND s.owner = i.owner
AND s.segment_name = i.index_name
AND s.segment_type LIKE 'INDEX%'
UNION ALL
SELECT 3 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, l.column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_lobs l, dba_segments s
WHERE l.owner = t.owner
AND l.table_name = t.table_name
AND s.owner = l.owner
AND s.segment_name = l.segment_name
AND s.segment_type LIKE 'LOB%'
)
--SELECT ROUND(bytes/POWER(2,20),3) AS mebibytes, segment_type, owner, column_name, segment_name, partition_name, tablespace_name
SELECT ROUND(bytes/POWER(10,6),3) AS megabytes, segment_type, owner, column_name, segment_name, partition_name, tablespace_name
FROM s
ORDER BY bytes DESC, oby, segment_type, owner, column_name, segment_name, partition_name
FETCH FIRST 100 ROWS ONLY
/
--
PRO
PRO SEGMENT TYPE (dba_segments)
PRO ~~~~~~~~~~~~
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
),
s AS (
SELECT 1 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, NULL AS column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_segments s
WHERE s.owner = t.owner
AND s.segment_name = t.table_name
AND s.segment_type LIKE 'TABLE%'
UNION ALL
SELECT 2 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, NULL AS column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_indexes i, dba_segments s
WHERE i.table_owner = t.owner
AND i.table_name = t.table_name
AND s.owner = i.owner
AND s.segment_name = i.index_name
AND s.segment_type LIKE 'INDEX%'
UNION ALL
SELECT 3 AS oby, s.segment_type, s.owner, s.segment_name, s.partition_name, l.column_name, s.bytes, s.tablespace_name
FROM dba_tables_m t, dba_lobs l, dba_segments s
WHERE l.owner = t.owner
AND l.table_name = t.table_name
AND s.owner = l.owner
AND s.segment_name = l.segment_name
AND s.segment_type LIKE 'LOB%'
)
--SELECT segment_type, COUNT(*) AS segments, ROUND(SUM(bytes)/POWER(2,20),3) AS mebibytes, tablespace_name
SELECT segment_type, COUNT(*) AS segments, ROUND(SUM(bytes)/POWER(10,6),3) AS megabytes, tablespace_name
FROM s
GROUP BY oby, segment_type, tablespace_name
ORDER BY oby, segment_type, tablespace_name
/
--
CLEAR BREAK COMPUTE;
csierra/cs_internal/cs_dependency_table_columns.sql
+180
View File
@@ -0,0 +1,180 @@
COL owner FOR A30 HEA 'Table Owner';
COL table_name FOR A30 HEA 'Table Name';
COL column_id FOR 999 HEA 'ID';
COL column_name FOR A30 HEA 'Column Name';
COL data_type FOR A33 HEA 'Data Type';
COL data_length FOR 999,999,990 HEA 'Data Length';
COL nullable FOR A8 HEA 'Nullable';
COL data_default FOR A30 HEA 'Data Default';
COL num_distinct FOR 999,999,999,990 HEA 'Num Distinct';
COL low_value_translated FOR A64 HEA 'Low Value Translated';
COL high_value_translated FOR A64 HEA 'High Value Translated';
COL density FOR 0.000000000 HEA 'Density';
COL num_nulls FOR 999,999,999,990 HEA 'Num Nulls';
COL num_buckets FOR 999,990 HEA 'Buckets';
COL histogram FOR A15 HEA 'Histogram';
COL sample_size FOR 999,999,999,990 HEA 'Sample Size';
COL last_analyzed FOR A19 HEA 'Last Analyzed';
COL avg_col_len FOR 999,999,990 HEA 'Avg Col Len';
COL data_length FOR 999,999,990 HEA 'Data Length';
COL char_length FOR 999,999,990 HEA 'Char Length';
--
BRE ON owner ON table_name SKIP 1;
--
PRO
PRO TABLE COLUMNS (dba_tab_cols)
PRO ~~~~~~~~~~~~~
WITH /* INDEXES */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
-- o.to_hash, o.to_address
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
-- v_db_object_cache_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_cache) */
-- DISTINCT
-- SUBSTR(c.owner,1,30) AS object_owner,
-- SUBSTR(c.name,1,30) AS object_name
-- FROM v$db_object_cache c,
-- v_object_dependency_m d
-- WHERE c.type IN ('TABLE','VIEW')
-- AND c.hash_value = d.to_hash
-- AND c.addr = d.to_address
-- ),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
-- v_db_object_cache_m c
-- WHERE t.owner = c.object_owner
-- AND t.table_name = c.object_name
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT /*+ QB_NAME(get_stats) */
c.owner,
c.table_name,
c.column_id,
c.column_name,
c.data_type,
c.data_length,
c.nullable,
c.data_default data_default,
c.num_distinct,
CASE WHEN c.data_type = 'NUMBER' THEN to_char(utl_raw.cast_to_number(c.low_value))
WHEN c.data_type IN ('VARCHAR2', 'CHAR') THEN SUBSTR(to_char(utl_raw.cast_to_varchar2(c.low_value)),1,64)
WHEN c.data_type IN ('NVARCHAR2','NCHAR') THEN SUBSTR(to_char(utl_raw.cast_to_nvarchar2(c.low_value)),1,64)
WHEN c.data_type = 'BINARY_DOUBLE' THEN to_char(utl_raw.cast_to_binary_double(c.low_value))
WHEN c.data_type = 'BINARY_FLOAT' THEN to_char(utl_raw.cast_to_binary_float(c.low_value))
WHEN c.data_type = 'DATE' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.low_value,1,2) ,'XX')-100) + (to_number(substr(c.low_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.low_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,13,2),'XX')-1,'00')))
WHEN c.data_type LIKE 'TIMESTAMP%' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.low_value,1,2) ,'XX')-100) + (to_number(substr(c.low_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.low_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.low_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.low_value,13,2),'XX')-1,'00'))||'.'||
to_number(substr(c.low_value,15,8),'XXXXXXXX'))
END low_value_translated,
CASE WHEN c.data_type = 'NUMBER' THEN to_char(utl_raw.cast_to_number(c.high_value))
WHEN c.data_type IN ('VARCHAR2', 'CHAR') THEN SUBSTR(to_char(utl_raw.cast_to_varchar2(c.high_value)),1,64)
WHEN c.data_type IN ('NVARCHAR2','NCHAR') THEN SUBSTR(to_char(utl_raw.cast_to_nvarchar2(c.high_value)),1,64)
WHEN c.data_type = 'BINARY_DOUBLE' THEN to_char(utl_raw.cast_to_binary_double(c.high_value))
WHEN c.data_type = 'BINARY_FLOAT' THEN to_char(utl_raw.cast_to_binary_float(c.high_value))
WHEN c.data_type = 'DATE' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.high_value,1,2) ,'XX')-100) + (to_number(substr(c.high_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.high_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,13,2),'XX')-1,'00')))
WHEN c.data_type LIKE 'TIMESTAMP%' THEN rtrim(
ltrim(to_char(100*(to_number(substr(c.high_value,1,2) ,'XX')-100) + (to_number(substr(c.high_value,3,2) ,'XX')-100),'0000'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,5,2) ,'XX') ,'00'))||'-'||
ltrim(to_char( to_number(substr(c.high_value,7,2) ,'XX') ,'00'))||'T'||
ltrim(to_char( to_number(substr(c.high_value,9,2) ,'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,11,2),'XX')-1,'00'))||':'||
ltrim(to_char( to_number(substr(c.high_value,13,2),'XX')-1,'00'))||'.'||
to_number(substr(c.high_value,15,8),'XXXXXXXX'))
END high_value_translated,
c.density,
c.num_nulls,
c.num_buckets,
c.histogram,
c.sample_size,
TO_CHAR(c.last_analyzed, '&&cs_datetime_full_format.') last_analyzed,
c.avg_col_len,
c.data_length,
c.char_length
FROM dba_tables_m t,
dba_tab_cols c
WHERE c.owner = t.owner
AND c.table_name = t.table_name
ORDER BY
c.owner,
c.table_name,
c.column_id
/
--
CL BRE;
--
-- SET HEA OFF;
-- PRO
-- PRO COLUMN USAGE REPORT (dbms_stats.report_col_usage)
-- PRO ~~~~~~~~~~~~~~~~~~~
-- WITH /* OBJECTS */
-- v_sqlarea_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
-- DISTINCT
-- hash_value, address
-- FROM v$sqlarea
-- WHERE sql_id = '&&cs_sql_id.'
-- ),
-- v_object_dependency_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
-- DISTINCT
-- o.to_owner, o.to_name
-- -- o.to_hash, o.to_address
-- FROM v$object_dependency o,
-- v_sqlarea_m s
-- WHERE o.from_hash = s.hash_value
-- AND o.from_address = s.address
-- AND o.to_type = 2 -- table
-- ),
-- dba_tables_m AS (
-- SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
-- t.owner,
-- t.table_name
-- FROM dba_tables t,
-- v_object_dependency_m o
-- WHERE t.owner = o.to_owner
-- AND t.table_name = o.to_name
-- )
-- SELECT DBMS_STATS.report_col_usage(t.owner, t.table_name)
-- FROM dba_tables_m t
-- ORDER BY
-- t.owner, t.table_name
-- /
-- SET HEA ON;
--
csierra/cs_internal/cs_dependency_tables.sql
+233
View File
@@ -0,0 +1,233 @@
COL owner FOR A30 HEA 'Owner';
COL table_name FOR A30 HEA 'Table Name';
COL partitioned FOR A4 HEA 'Part';
COL degree FOR A10 HEA 'Degree';
COL temporary FOR A4 HEA 'Temp';
COL blocks FOR 999,999,990 HEA 'Blocks';
COL num_rows FOR 999,999,999,990 HEA 'Num Rows';
COL avg_row_len FOR 999,999,990 HEA 'Avg Row Len';
COL size_MiB FOR 999,999,990.000 HEA 'Size MiB';
COL seg_size_MiB FOR 999,999,990.000 HEA 'Seg Size MiB';
COL estimated_MiB FOR 999,999,990.000 HEA 'Estimated MiB';
COL size_MB FOR 999,999,990.000 HEA 'Size MB';
COL seg_size_MB FOR 999,999,990.000 HEA 'Seg Size MB';
COL estimated_MB FOR 999,999,990.000 HEA 'Estimated MB';
COL sample_size FOR 999,999,999,990 HEA 'Sample Size';
COL last_analyzed FOR A19 HEA 'Last Analyzed';
COL compression FOR A12 HEA 'Compression';
COL tablespace_name FOR A30 HEA 'Tablespace';
COL rn FOR 999;
--
PRO
PRO TABLES (dba_tables)
PRO ~~~~~~
WITH /* TABLES ACCESSED */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name,
CASE t.partitioned WHEN 'YES' THEN (SELECT TRIM(TO_CHAR(COUNT(*))) FROM dba_tab_partitions tp WHERE tp.table_owner = t.owner AND tp.table_name = t.table_name) ELSE t.partitioned END AS partitioned,
t.degree,
t.temporary,
t.blocks,
COALESCE(b.block_size, TO_NUMBER(p.value)) AS block_size,
(SELECT SUM(s.bytes) / POWER(10,6) FROM dba_segments s WHERE s.owner = t.owner AND s.segment_name = t.table_name AND s.segment_type LIKE 'TABLE%') AS seg_size_MB,
t.num_rows,
t.avg_row_len,
t.sample_size,
t.last_analyzed,
t.compression,
t.tablespace_name
FROM dba_tables t,
v_object_dependency_m o,
dba_tablespaces b,
v$parameter p
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
AND b.tablespace_name(+) = t.tablespace_name
AND p.name = 'db_block_size'
)
SELECT /*+ QB_NAME(get_stats) */
owner,
table_name,
partitioned,
degree,
temporary,
blocks,
blocks * block_size / POWER(10,6) AS size_MB,
seg_size_MB,
num_rows,
avg_row_len,
num_rows * avg_row_len / POWER(10,6) AS estimated_MB,
sample_size,
TO_CHAR(last_analyzed, '&&cs_datetime_full_format.') AS last_analyzed,
compression,
tablespace_name
FROM dba_tables_m
ORDER BY
owner,
table_name
/
--
COL object_type HEA 'Object Type' FOR A30;
COL owner FOR A30 HEA 'Owner';
COL object_id FOR 999999999 HEA 'Object ID';
COL object_name FOR A30 HEA 'Object Name';
COL subobject_name FOR A30 HEA 'Sub Object Name';
COL created FOR A23 HEA 'Created';
COL last_ddl_time FOR A23 HEA 'Last DDL Time';
--
PRO
PRO TABLE OBJECTS (dba_objects) up to 100
PRO ~~~~~~~~~~~~~
WITH /* OBJECTS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
)
SELECT o.object_type,
o.owner,
o.object_name,
o.subobject_name,
o.object_id,
TO_CHAR(o.created, '&&cs_datetime_full_format.') AS created,
TO_CHAR(o.last_ddl_time, '&&cs_datetime_full_format.') AS last_ddl_time
FROM dba_tables_m t,
dba_objects o
WHERE o.owner = t.owner
AND o.object_name = t.table_name
AND o.object_type LIKE 'TABLE%'
ORDER BY
o.object_type,
o.owner,
o.object_name,
o.subobject_name
FETCH FIRST 100 ROWS ONLY
/
--
COL object_type HEA 'Object Type';
COL owner FOR A30 HEA 'Owner';
COL object_id FOR 999999999 HEA 'Object ID';
COL object_name FOR A30 HEA 'Object Name';
COL subobject_name FOR A30 HEA 'Sub Object Name';
COL created FOR A23 HEA 'Created';
COL last_ddl_time FOR A23 HEA 'Last DDL Time';
COL analyzetime FOR A19 HEA 'Analyze Time';
COL savtime FOR A23 HEA 'Saved Time';
COL rowcnt FOR 999,999,999,990 HEA 'Row Count';
COL blkcnt FOR 999,999,990 HEA 'Block Count';
COL avgrln FOR 999,999,990 HEA 'Avg Row Len';
COL samplesize FOR 999,999,999,990 HEA 'Sample Size';
--
BREAK ON object_id SKIP 1 ON owner ON object_name ON created ON last_ddl_time;
--
PRO
PRO CBO STAT TABLE HISTORY (wri$_optstat_tab_history) up to 100 per Table
PRO ~~~~~~~~~~~~~~~~~~~~~~
WITH /* OBJECTS */
v_sqlarea_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlarea) */
DISTINCT
hash_value, address
FROM v$sqlarea
WHERE sql_id = '&&cs_sql_id.'
),
v_object_dependency_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(obj_dependency) */
DISTINCT
o.to_owner, o.to_name
FROM v$object_dependency o,
v_sqlarea_m s
WHERE o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.to_type = 2 -- table
),
dba_tables_m AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(dba_tables) */
t.owner,
t.table_name
FROM dba_tables t,
v_object_dependency_m o
WHERE t.owner = o.to_owner
AND t.table_name = o.to_name
),
dba_tables_o AS (
SELECT o.owner,
o.object_name,
o.subobject_name,
o.object_id,
o.created,
o.last_ddl_time,
h.analyzetime,
h.savtime,
h.rowcnt,
h.blkcnt,
h.avgrln,
h.samplesize,
ROW_NUMBER() OVER (PARTITION BY o.object_id ORDER BY h.analyzetime DESC NULLS LAST, h.savtime DESC NULLS LAST) AS rn
FROM dba_tables_m t,
dba_objects o,
wri$_optstat_tab_history h
WHERE o.owner = t.owner
AND o.object_name = t.table_name
AND o.object_type = 'TABLE'
AND h.obj# = o.object_id
)
SELECT DISTINCT
o.owner,
o.object_name,
o.subobject_name,
o.object_id,
TO_CHAR(o.created, '&&cs_datetime_full_format.') AS created,
TO_CHAR(o.last_ddl_time, '&&cs_datetime_full_format.') AS last_ddl_time,
TO_CHAR(o.analyzetime, '&&cs_datetime_full_format.') AS analyzetime,
TO_CHAR(o.savtime, '&&cs_timestamp_full_format.') AS savtime,
o.rowcnt,
o.blkcnt,
o.avgrln,
o.samplesize
FROM dba_tables_o o
WHERE o.rn <= 100
ORDER BY 1, 2, 3, 4, 5, 6, 7 NULLS FIRST, 8 NULLS FIRST
/
--
CLEAR BREAK;
csierra/cs_internal/cs_file_prefix.sql
+9
View File
@@ -0,0 +1,9 @@
SELECT '&&cs_file_dir.'||'&&cs_reference_sanitized._&&cs_file_date_time.Z_'||
CASE '&&cs_odis.' WHEN 'N' THEN UPPER('&&cs_realm._')||UPPER('&&cs_rgn._')||UPPER('&&cs_locale._') END||
UPPER('&&cs_db_name._')||UPPER(TRANSLATE('&&cs_con_name.', '*@#$"''', '_____'))||
UPPER(NVL2('&&cs_other_acronym.', '_&&cs_other_acronym.', NULL))||CASE '&&cs_onsr.' WHEN 'Y' THEN '_ONSR' END||CASE '&&cs_odis.' WHEN 'Y' THEN '_ODIS' END||CASE '&&cs_dedicated.' WHEN 'Y' THEN '_DEDICATED' END||
NVL2('&&who_am_i.', '_&&who_am_i.', NULL)
AS cs_file_prefix
FROM DUAL
/
--
csierra/cs_internal/cs_fs_internal_query_1.sql
+156
View File
@@ -0,0 +1,156 @@
-- cs_fs_internal_query_1.sql: called by cs_fs.sql
@@cs_sqlstat_cols.sql
PRO
PRO DB Latency (and DB Load) gv$sql (current)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~
WITH
FUNCTION /* cs_fs_internal_query_1 */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sql_metrics AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.*,
s.elapsed_time/GREATEST(s.executions,1)/1e3 AS et_ms_per_exec,
s.cpu_time/GREATEST(s.executions,1)/1e3 AS cpu_ms_per_exec,
s.user_io_wait_time/GREATEST(s.executions,1)/1e3 AS io_ms_per_exec,
s.application_wait_time/GREATEST(s.executions,1)/1e3 AS appl_ms_per_exec,
s.concurrency_wait_time/GREATEST(s.executions,1)/1e3 AS conc_ms_per_exec,
s.plsql_exec_time/GREATEST(s.executions,1)/1e3 AS plsql_ms_per_exec,
s.cluster_wait_time/GREATEST(s.executions,1)/1e3 AS cluster_ms_per_exec,
s.java_exec_time/GREATEST(s.executions,1)/1e3 AS java_ms_per_exec,
s.executions/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS execs_per_sec,
s.px_servers_executions/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS px_execs_per_sec,
s.end_of_fetch_count/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS end_of_fetch_per_sec,
s.parse_calls/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS parses_per_sec,
s.invalidations/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS inval_per_sec,
s.loads/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS loads_per_sec,
s.buffer_gets/GREATEST(s.executions,1) AS gets_per_exec,
s.disk_reads/GREATEST(s.executions,1) AS reads_per_exec,
s.direct_reads/GREATEST(s.executions,1) AS direct_reads_per_exec,
s.direct_writes/GREATEST(s.executions,1) AS direct_writes_per_exec,
s.physical_read_requests/GREATEST(s.executions,1) AS phy_read_req_per_exec,
s.physical_read_bytes/GREATEST(s.executions,1)/1e6 AS phy_read_mb_per_exec,
s.physical_write_requests/GREATEST(s.executions,1) AS phy_write_req_per_exec,
s.physical_write_bytes/GREATEST(s.executions,1)/1e6 AS phy_write_mb_per_exec,
s.fetches/GREATEST(s.executions,1) AS fetches_per_exec,
s.sorts/GREATEST(s.executions,1) AS sorts_per_exec,
s.rows_processed/GREATEST(s.executions,1) AS rows_per_exec,
s.elapsed_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS et_ms_per_row,
s.cpu_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS cpu_ms_per_row,
s.user_io_wait_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS io_ms_per_row,
s.buffer_gets/GREATEST(s.rows_processed,s.executions,1) AS gets_per_row,
s.disk_reads/GREATEST(s.rows_processed,s.executions,1) AS reads_per_row,
DBMS_LOB.GETLENGTH(s.sql_fulltext) AS sql_len,
get_sql_hv(s.sql_fulltext) AS sql_hv
FROM gv$sql s
WHERE 1 = 1
AND ('&&cs_include_sys.' = 'Y' OR (
s.sql_text NOT LIKE '/* SQL Analyze(%'
AND s.sql_text NOT LIKE '%/* cli_%'
AND s.sql_text NOT LIKE '%/* cs_%'
AND s.sql_text NOT LIKE '%FUNCTION application_category%'
AND s.sql_text NOT LIKE '%MATERIALIZE NO_MERGE%'
AND s.sql_text NOT LIKE '%NO_STATEMENT_QUEUING%'
AND s.sql_text NOT LIKE 'SELECT /* &&cs_script_name. */%'
))
AND CASE
WHEN LENGTH('&&cs_search_string.') = 5 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(get_sql_hv(s.sql_fulltext)) = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') = 13 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NOT NULL /* alpha */ AND LOWER('&&cs_search_string.') = '&&cs_search_string.' AND s.sql_id = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') BETWEEN 6 AND 10 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(s.plan_hash_value) = '&&cs_search_string.' THEN 1
WHEN UPPER(s.sql_fulltext) LIKE UPPER('%&&cs_search_string.%') THEN 1
END = 1
AND ('&&cs_include_sys.' = 'Y' OR NVL(s.parsing_schema_name, '-666') <> 'SYS')
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.last_active_time,
REPLACE(s.last_load_time, '/', 'T') AS last_load_time,
REPLACE(s.first_load_time, '/', 'T') AS first_load_time,
'!' AS sep1,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep2,
s.executions,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep4,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
-- '!' AS sep5,
-- s.loaded_versions AS version_count,
-- CASE s.is_obsolete WHEN 'Y' THEN 1 ELSE 0 END AS obsolete_count,
-- CASE s.is_shareable WHEN 'Y' THEN 1 ELSE 0 END AS shareable_count,
-- s.loads,
-- s.invalidations,
-- s.sharable_mem/1e6 AS sharable_mem_mb,
-- '!' AS sep8,
'!' AS sep9,
s.sql_hv,
s.sql_len,
s.sql_id,
s.inst_id,
s.child_number,
s.plan_hash_value,
CASE WHEN s.sql_plan_baseline IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_bl,
CASE WHEN s.sql_profile IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_prf,
CASE WHEN s.sql_patch IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_pch,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sql_metrics s
WHERE 1 = 1
ORDER BY
s.last_active_time,
s.sql_hv,
s.sql_id,
s.inst_id,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
csierra/cs_internal/cs_fs_internal_query_2.sql
+243
View File
@@ -0,0 +1,243 @@
-- cs_fs_internal_query_2.sql: called by cs_fs.sql
PRO
PRO DB Latency (and DB Load) v$sqlstats (last &&cs_last_snap_mins. minutes)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~
WITH
FUNCTION /* cs_fs_internal_query_2 */ get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.con_id,
s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 AS et_ms_per_exec,
s.delta_cpu_time/GREATEST(s.delta_execution_count,1)/1e3 AS cpu_ms_per_exec,
s.delta_user_io_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS io_ms_per_exec,
s.delta_application_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS appl_ms_per_exec,
s.delta_concurrency_time/GREATEST(s.delta_execution_count,1)/1e3 AS conc_ms_per_exec,
s.delta_plsql_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS plsql_ms_per_exec,
s.delta_cluster_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS cluster_ms_per_exec,
s.delta_java_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS java_ms_per_exec,
s.delta_elapsed_time/GREATEST(w.age_seconds,1)/1e6 AS et_aas,
s.delta_cpu_time/GREATEST(w.age_seconds,1)/1e6 AS cpu_aas,
s.delta_user_io_wait_time/GREATEST(w.age_seconds,1)/1e6 AS io_aas,
s.delta_application_wait_time/GREATEST(w.age_seconds,1)/1e6 AS appl_aas,
s.delta_concurrency_time/GREATEST(w.age_seconds,1)/1e6 AS conc_aas,
s.delta_plsql_exec_time/GREATEST(w.age_seconds,1)/1e6 AS plsql_aas,
s.delta_cluster_wait_time/GREATEST(w.age_seconds,1)/1e6 AS cluster_aas,
s.delta_java_exec_time/GREATEST(w.age_seconds,1)/1e6 AS java_aas,
s.delta_execution_count AS delta_execution_count,
s.delta_execution_count/GREATEST(w.age_seconds,1) AS execs_per_sec,
s.delta_px_servers_executions/GREATEST(w.age_seconds,1) AS px_execs_per_sec,
s.delta_end_of_fetch_count/GREATEST(w.age_seconds,1) AS end_of_fetch_per_sec,
s.delta_parse_calls/GREATEST(w.age_seconds,1) AS parses_per_sec,
s.delta_invalidations/GREATEST(w.age_seconds,1) AS inval_per_sec,
s.delta_loads/GREATEST(w.age_seconds,1) AS loads_per_sec,
s.delta_buffer_gets/GREATEST(s.delta_execution_count,1) AS gets_per_exec,
s.delta_disk_reads/GREATEST(s.delta_execution_count,1) AS reads_per_exec,
s.delta_direct_reads/GREATEST(s.delta_execution_count,1) AS direct_reads_per_exec,
s.delta_direct_writes/GREATEST(s.delta_execution_count,1) AS direct_writes_per_exec,
s.delta_physical_read_requests/GREATEST(s.delta_execution_count,1) AS phy_read_req_per_exec,
s.delta_physical_read_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_read_mb_per_exec,
s.delta_physical_write_requests/GREATEST(s.delta_execution_count,1) AS phy_write_req_per_exec,
s.delta_physical_write_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_write_mb_per_exec,
s.delta_fetch_count/GREATEST(s.delta_execution_count,1) AS fetches_per_exec,
s.delta_sorts/GREATEST(s.delta_execution_count,1) AS sorts_per_exec,
s.delta_rows_processed,
s.delta_rows_processed/GREATEST(s.delta_execution_count,1) AS rows_per_exec,
s.delta_elapsed_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS et_ms_per_row,
s.delta_cpu_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS cpu_ms_per_row,
s.delta_user_io_wait_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS io_ms_per_row,
s.delta_buffer_gets/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS gets_per_row,
s.delta_disk_reads/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS reads_per_row,
s.avg_hard_parse_time,
s.sql_id,
s.sql_text,
s.sql_fulltext,
DBMS_LOB.GETLENGTH(s.sql_fulltext) AS sql_len,
s.plan_hash_value,
s.last_active_child_address
FROM v$sqlstats s,
(SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
((86400 * EXTRACT(DAY FROM (SYSTIMESTAMP - MAX(end_interval_time))) + (3600 * EXTRACT(HOUR FROM (systimestamp - MAX(end_interval_time)))) + (60 * EXTRACT(MINUTE FROM (systimestamp - MAX(end_interval_time)))) + EXTRACT(SECOND FROM (systimestamp - MAX(end_interval_time))))) AS age_seconds
FROM dba_hist_snapshot
WHERE end_interval_time < SYSTIMESTAMP) w
WHERE 1 = 1
AND ('&&cs_include_sys.' = 'Y' OR (
s.sql_text NOT LIKE '/* SQL Analyze(%'
AND s.sql_text NOT LIKE '%/* cli_%'
AND s.sql_text NOT LIKE '%/* cs_%'
AND s.sql_text NOT LIKE '%FUNCTION application_category%'
AND s.sql_text NOT LIKE '%MATERIALIZE NO_MERGE%'
AND s.sql_text NOT LIKE '%NO_STATEMENT_QUEUING%'
AND s.sql_text NOT LIKE 'SELECT /* &&cs_script_name. */%'
))
AND CASE
WHEN LENGTH('&&cs_search_string.') = 5 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(get_sql_hv(s.sql_fulltext)) = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') = 13 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NOT NULL /* alpha */ AND LOWER('&&cs_search_string.') = '&&cs_search_string.' AND s.sql_id = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') BETWEEN 6 AND 10 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(s.plan_hash_value) = '&&cs_search_string.' THEN 1
WHEN UPPER(s.sql_fulltext) LIKE UPPER('%&&cs_search_string.%') THEN 1
END = 1
AND ROWNUM >= 1 -- materialize
),
sqlstats_extended AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
s.sql_id,
s.sql_len,
s.sql_text,
s.sql_fulltext,
s.plan_hash_value,
s.last_active_child_address,
s.con_id,
c.name AS pdb_name
FROM sqlstats s,
v$containers c
WHERE c.con_id = s.con_id
AND ROWNUM >= 1
)
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'|' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'|' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
'|' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'|' AS sep4,
s.delta_rows_processed,
s.rows_per_exec,
'|' AS sep5,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'|' AS sep6,
get_sql_hv(s.sql_fulltext) AS sql_hv,
s.sql_len,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
CASE '&&cs_con_name.' WHEN 'CDB$ROOT' THEN s.pdb_name ELSE v.parsing_schema_name END AS pdb_or_parsing_schema_name,
t.num_rows,
t.blocks
FROM sqlstats_extended s
OUTER APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch,
v.parsing_schema_name,
v.hash_value,
v.address
FROM v$sql v
WHERE 1 = 1
AND v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
AND v.child_address = s.last_active_child_address
ORDER BY
v.last_active_time DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) v
OUTER APPLY ( -- only works when executed within a PDB
SELECT t.num_rows, t.blocks
FROM v$object_dependency d, dba_users u, dba_tables t
WHERE d.from_hash = v.hash_value
AND d.from_address = v.address
AND d.to_type = 2 -- table
AND d.to_owner <> 'SYS'
AND d.con_id = s.con_id
AND u.username = d.to_owner
AND u.oracle_maintained = 'N'
AND u.common = 'NO'
AND t.owner = d.to_owner
AND t.table_name = d.to_name
ORDER BY
t.num_rows DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) t
WHERE 1 = 1
AND ('&&cs_include_sys.' = 'Y' OR NVL(v.parsing_schema_name, '-666') <> 'SYS')
ORDER BY
s.et_ms_per_exec DESC
/
csierra/cs_internal/cs_fs_internal_query_3.sql
+318
View File
@@ -0,0 +1,318 @@
-- cs_fs_internal_query_3.sql: called by cs_fs.sql
PRO
PRO DB Latency (and DB Load) dba_hist_sqlstat (last &&cs_awr_search_days. days)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_fs_internal_query_3 */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
get_sql_hv(x.sql_text) AS sql_hv,
REPLACE(REPLACE(DBMS_LOB.substr(x.sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
x.sql_text AS sql_fulltext,
DBMS_LOB.GETLENGTH(x.sql_text) AS sql_len,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM dba_hist_snapshot t,
dba_hist_sqlstat s,
dba_hist_sqltext x
WHERE 1 = 1
AND TO_NUMBER('&&cs_awr_search_days.') > 0
AND t.dbid = TO_NUMBER('&&cs_dbid.')
AND t.instance_number = TO_NUMBER('&&cs_instance_number.')
AND t.snap_id > TO_NUMBER('&&cs_min_snap_id.')
AND s.snap_id = t.snap_id
AND s.snap_id > TO_NUMBER('&&cs_min_snap_id.')
AND s.dbid = TO_NUMBER('&&cs_dbid.')
AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND x.dbid = TO_NUMBER('&&cs_dbid.')
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
AND x.dbid = TO_NUMBER('&&cs_dbid.')
AND ('&&cs_include_sys.' = 'Y' OR (
x.sql_text NOT LIKE '/* SQL Analyze(%'
AND x.sql_text NOT LIKE '%/* cli_%'
AND x.sql_text NOT LIKE '%/* cs_%'
AND x.sql_text NOT LIKE '%FUNCTION application_category%'
AND x.sql_text NOT LIKE '%MATERIALIZE NO_MERGE%'
AND x.sql_text NOT LIKE '%NO_STATEMENT_QUEUING%'
AND x.sql_text NOT LIKE 'SELECT /* &&cs_script_name. */%'
))
AND CASE
WHEN LENGTH('&&cs_search_string.') = 5 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(get_sql_hv(x.sql_text)) = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') = 13 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NOT NULL /* alpha */ AND LOWER('&&cs_search_string.') = '&&cs_search_string.' AND x.sql_id = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') BETWEEN 6 AND 10 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(s.plan_hash_value) = '&&cs_search_string.' THEN 1
WHEN UPPER(x.sql_text) LIKE UPPER('%&&cs_search_string.%') THEN 1
END = 1
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count) AS delta_execution_count2,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sql_hv,
d.sql_len,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
d.parsing_schema_name,
-- d.module,
-- d.action,
d.plan_hash_value,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time) AS delta_elapsed_time,
SUM(d.delta_cpu_time) AS delta_cpu_time,
SUM(d.delta_user_io_wait_time) AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time) AS delta_application_wait_time,
SUM(d.delta_concurrency_time) AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time) AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time) AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time) AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes) AS delta_physical_read_bytes,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes) AS delta_physical_write_bytes,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes) AS delta_io_interconnect_bytes,
SUM(d.delta_cell_offload_elig_bytes) AS delta_cell_offload_elig_bytes,
SUM(d.delta_cell_uncompressed_bytes) AS delta_cell_uncompressed_bytes,
SUM(d.delta_cell_offload_retrn_bytes) AS delta_cell_offload_retrn_bytes,
SUM(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
SUM(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE 1 = 1
AND TO_NUMBER('&&cs_awr_search_days.') > 0
AND d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
d.con_id,
d.sql_hv,
d.sql_len,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
d.parsing_schema_name,
-- d.module,
-- d.action,
d.plan_hash_value,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'|' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'|' AS sep2,
s.delta_execution_count2 AS delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'|' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'|' AS sep4,
s.delta_rows_processed,
s.rows_per_exec,
'|' AS sep5,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'|' AS sep6,
s.sql_hv,
s.sql_len,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
t.num_rows,
t.blocks,
s.begin_timestamp,
s.end_timestamp,
s.seconds
FROM sqlstats_metrics s
OUTER APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch,
-- v.parsing_schema_name,
v.hash_value,
v.address
FROM v$sql v
WHERE v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
OUTER APPLY ( -- only works when executed within a PDB
SELECT t.num_rows, t.blocks
FROM v$object_dependency d, dba_users u, dba_tables t
WHERE d.from_hash = v.hash_value
AND d.from_address = v.address
AND d.to_type = 2 -- table
AND d.to_owner <> 'SYS'
AND d.con_id = s.con_id
AND u.username = d.to_owner
AND u.oracle_maintained = 'N'
AND u.common = 'NO'
AND t.owner = d.to_owner
AND t.table_name = d.to_name
ORDER BY
t.num_rows DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) t
WHERE 1 = 1
AND TO_NUMBER('&&cs_awr_search_days.') > 0
AND ('&&cs_include_sys.' = 'Y' OR NVL(s.parsing_schema_name, '-666') <> 'SYS')
ORDER BY
s.et_ms_per_exec DESC
/
csierra/cs_internal/cs_fs_internal_query_4.sql
+145
View File
@@ -0,0 +1,145 @@
-- cs_fs_internal_query_4.sql: called by cs_fs.sql
SET HEA OFF PAGES 0;
PRO
PRO SQL Text v$sqlstats
PRO ~~~~~~~~
WITH
FUNCTION /* cs_fs_internal_query_4 */ get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
FUNCTION get_first_rows_candidacy (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_or_count NUMBER;
l_ic_count NUMBER;
l_ep_count NUMBER;
/**************************************************************************************/
FUNCTION get_or_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_or_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- returns count of OR predicates such as ' < :5 ) OR'
-- when > 0 then this is a pagination (continue) scan, and when = 0 then this is a begin scan
SELECT REGEXP_COUNT(p2_sqltext, '( >=? | <=? ):\d+ \) OR ?$', 1, 'cm') INTO l2_or_count FROM DUAL;
END IF;
RETURN l2_or_count;
END get_or_count;
/**************************************************************************************/
FUNCTION get_ic_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_ic_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- gets position of 1st character after 2nd ORDER BY
-- then counts columns referenced by the main query's ORDER BY
SELECT REGEXP_COUNT(p2_sqltext, ' (ASC|DESC)(,|$)', REGEXP_INSTR(p2_sqltext, 'ORDER BY', 1, 2, 1, 'c'), 'cm') INTO l2_ic_count FROM DUAL;
END IF;
RETURN l2_ic_count;
END get_ic_count;
/**************************************************************************************/
FUNCTION get_ep_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_ep_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- counts "greater than" (or "less than") operands
-- then computes position of first character ')' after bind reference of last "greater than" (or "less than") operand
-- returning the nunber of equality predicates on the prefix portion of the filters (i.e.: after all pagination predicates)
SELECT REGEXP_COUNT(p2_sqltext, '\(\w+ = :\d+ \)', GREATEST(REGEXP_INSTR(p2_sqltext, '( > | < ):\d+ ', 1, GREATEST(REGEXP_COUNT(p2_sqltext, '( > | < ):\d+ '), 1), 1), 1)) INTO l2_ep_count FROM DUAL;
END IF;
RETURN l2_ep_count;
END get_ep_count;
/**************************************************************************************/
BEGIN
IF p_sqltext NOT LIKE '%/* performScanQuery(%,%) %' THEN
RETURN 'Candidacy only applies to KIEV performScanQuery';
-- ELSIF p_sqltext LIKE '%(futureWork,resumptionTimestamp)%'
-- OR p_sqltext LIKE '%(leaseDecorators,ae_timestamp_index)%'
-- OR p_sqltext LIKE '%(WORK_PARTITIONS_BUCKET,WORK_PARTITIONS_BUCKETIdx)%' -- KIEV99A2 FLAMINGOCPDB d41w5f7gnhg2b
-- OR p_sqltext LIKE '%(LEASE,state_index)%' -- KIEV99RG IDENTITY_R1_ALPHA an1n9htmx7wss
-- THEN
-- RETURN 'Bad CANDIDATE: Known SQL, which requires a specific execution plan';
ELSIF p_sqltext LIKE '%AND (1 = 1)%' THEN
RETURN 'Good CANDIDATE: Non-prefixed begin scan (expect a leading full index scan)';
END IF;
--
l_or_count := get_or_count(p2_sqltext => p_sqltext);
l_ic_count := get_ic_count(p2_sqltext => p_sqltext);
l_ep_count := get_ep_count(p2_sqltext => p_sqltext);
--
IF l_or_count = 0 THEN
RETURN 'Good CANDIDATE: Prefixed begin scan or simple continue scan without or_operands (expect a leading range index scan)';
ELSIF l_ic_count = l_ep_count + 1 THEN
RETURN 'Good CANDIDATE: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (expect a leading range index scan)';
ELSIF l_ep_count > 0 THEN
RETURN 'Poor Candidate: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (a leading range index scan might be possible but not necessarily efficient)';
ELSIF l_ic_count <> l_ep_count + 1 THEN
RETURN 'Bad CANDIDATE: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (expect some suboptimal plan with a full scan)';
ELSE
RETURN 'Unexpected';
END IF;
END get_first_rows_candidacy;
/****************************************************************************************/
sqlstats AS (
SELECT s.sql_id,
get_sql_hv(s.sql_fulltext) AS sql_hv,
get_first_rows_candidacy(s.sql_fulltext) AS first_rows_candidacy,
s.sql_fulltext AS sql_text,
c.name AS pdb_name
FROM v$sqlstats s, v$containers c
OUTER APPLY ( -- slow!
SELECT v.parsing_schema_name
FROM v$sql v
WHERE 1 = 1
AND v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
AND v.child_address = s.last_active_child_address
ORDER BY
v.last_active_time DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) v
WHERE 1 = 1
AND ('&&cs_include_sys.' = 'Y' OR (
s.sql_text NOT LIKE '/* SQL Analyze(%'
AND s.sql_text NOT LIKE '%/* cli_%'
AND s.sql_text NOT LIKE '%/* cs_%'
AND s.sql_text NOT LIKE '%FUNCTION application_category%'
AND s.sql_text NOT LIKE '%MATERIALIZE NO_MERGE%'
AND s.sql_text NOT LIKE '%NO_STATEMENT_QUEUING%'
AND s.sql_text NOT LIKE 'SELECT /* &&cs_script_name. */%'
))
AND CASE
WHEN LENGTH('&&cs_search_string.') = 5 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(get_sql_hv(s.sql_fulltext)) = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') = 13 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NOT NULL /* alpha */ AND LOWER('&&cs_search_string.') = '&&cs_search_string.' AND s.sql_id = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') BETWEEN 6 AND 10 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(s.plan_hash_value) = '&&cs_search_string.' THEN 1
WHEN UPPER(s.sql_fulltext) LIKE UPPER('%&&cs_search_string.%') THEN 1
END = 1
AND ('&&cs_include_sys.' = 'Y' OR NVL(v.parsing_schema_name, '-666') <> 'SYS') -- slow!
AND c.con_id = s.con_id
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
CHR(10)||
'SQL_HV : '||sql_hv||CHR(10)||
'SQL_ID : '||sql_id||CHR(10)||
'FIRST_ROWS : '||first_rows_candidacy||CHR(10)||
'PDB_NAME : '||pdb_name||CHR(10)||
CHR(10)||sql_text AS pretty_unique_name
FROM sqlstats
ORDER BY
sql_hv, sql_id
/
--
SET HEA ON PAGES 100;
csierra/cs_internal/cs_fs_internal_query_5.sql
+147
View File
@@ -0,0 +1,147 @@
-- cs_fs_internal_query_5.sql: called by cs_fs.sql
SET HEA OFF PAGES 0;
PRO
PRO SQL Text dba_hist_sqltext (may include SYS parsing schema)
PRO ~~~~~~~~
WITH
FUNCTION /* cs_fs_internal_query_5 */ get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
FUNCTION get_first_rows_candidacy (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_or_count NUMBER;
l_ic_count NUMBER;
l_ep_count NUMBER;
/**************************************************************************************/
FUNCTION get_or_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_or_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- returns count of OR predicates such as ' < :5 ) OR'
-- when > 0 then this is a pagination (continue) scan, and when = 0 then this is a begin scan
SELECT REGEXP_COUNT(p2_sqltext, '( >=? | <=? ):\d+ \) OR ?$', 1, 'cm') INTO l2_or_count FROM DUAL;
END IF;
RETURN l2_or_count;
END get_or_count;
/**************************************************************************************/
FUNCTION get_ic_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_ic_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- gets position of 1st character after 2nd ORDER BY
-- then counts columns referenced by the main query's ORDER BY
SELECT REGEXP_COUNT(p2_sqltext, ' (ASC|DESC)(,|$)', REGEXP_INSTR(p2_sqltext, 'ORDER BY', 1, 2, 1, 'c'), 'cm') INTO l2_ic_count FROM DUAL;
END IF;
RETURN l2_ic_count;
END get_ic_count;
/**************************************************************************************/
FUNCTION get_ep_count (p2_sqltext IN CLOB)
RETURN NUMBER
IS
l2_ep_count NUMBER := TO_NUMBER(NULL);
BEGIN
IF p2_sqltext LIKE '%/* performScanQuery(%,%) %' THEN
-- counts "greater than" (or "less than") operands
-- then computes position of first character ')' after bind reference of last "greater than" (or "less than") operand
-- returning the nunber of equality predicates on the prefix portion of the filters (i.e.: after all pagination predicates)
SELECT REGEXP_COUNT(p2_sqltext, '\(\w+ = :\d+ \)', GREATEST(REGEXP_INSTR(p2_sqltext, '( > | < ):\d+ ', 1, GREATEST(REGEXP_COUNT(p2_sqltext, '( > | < ):\d+ '), 1), 1), 1)) INTO l2_ep_count FROM DUAL;
END IF;
RETURN l2_ep_count;
END get_ep_count;
/**************************************************************************************/
BEGIN
IF p_sqltext NOT LIKE '%/* performScanQuery(%,%) %' THEN
RETURN 'Candidacy only applies to KIEV performScanQuery';
-- ELSIF p_sqltext LIKE '%(futureWork,resumptionTimestamp)%'
-- OR p_sqltext LIKE '%(leaseDecorators,ae_timestamp_index)%'
-- OR p_sqltext LIKE '%(WORK_PARTITIONS_BUCKET,WORK_PARTITIONS_BUCKETIdx)%' -- KIEV99A2 FLAMINGOCPDB d41w5f7gnhg2b
-- OR p_sqltext LIKE '%(LEASE,state_index)%' -- KIEV99RG IDENTITY_R1_ALPHA an1n9htmx7wss
-- THEN
-- RETURN 'Bad CANDIDATE: Known SQL, which requires a specific execution plan';
ELSIF p_sqltext LIKE '%AND (1 = 1)%' THEN
RETURN 'Good CANDIDATE: Non-prefixed begin scan (expect a leading full index scan)';
END IF;
--
l_or_count := get_or_count(p2_sqltext => p_sqltext);
l_ic_count := get_ic_count(p2_sqltext => p_sqltext);
l_ep_count := get_ep_count(p2_sqltext => p_sqltext);
--
IF l_or_count = 0 THEN
RETURN 'Good CANDIDATE: Prefixed begin scan or simple continue scan without or_operands (expect a leading range index scan)';
ELSIF l_ic_count = l_ep_count + 1 THEN
RETURN 'Good CANDIDATE: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (expect a leading range index scan)';
ELSIF l_ep_count > 0 THEN
RETURN 'Poor Candidate: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (a leading range index scan might be possible but not necessarily efficient)';
ELSIF l_ic_count <> l_ep_count + 1 THEN
RETURN 'Bad CANDIDATE: Continue scan with: or_operands = '||TRIM(l_or_count)||', order-by_index_columns = '||TRIM(l_ic_count)||', prefixed_equality_predicates = '||TRIM(l_ep_count)||' (expect some suboptimal plan with a full scan)';
ELSE
RETURN 'Unexpected';
END IF;
END get_first_rows_candidacy;
/****************************************************************************************/
awr AS (
SELECT x.sql_id,
get_sql_hv(x.sql_text) AS sql_hv,
get_first_rows_candidacy(x.sql_text) AS first_rows_candidacy,
x.sql_text,
c.name AS pdb_name
FROM dba_hist_sqltext x, v$containers c
-- OUTER APPLY ( -- super slow!
-- SELECT v.parsing_schema_name
-- FROM dba_hist_sqlstat v
-- WHERE 1 = 1
-- AND v.sql_id = x.sql_id
-- AND v.con_id = x.con_id
-- AND v.dbid = x.dbid
-- AND v.instance_number = TO_NUMBER('&&cs_instance_number.')
-- AND v.optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
-- ORDER BY
-- v.snap_id DESC NULLS LAST
-- FETCH FIRST 1 ROW ONLY
-- ) v
WHERE 1 = 1
AND TO_NUMBER('&&cs_awr_search_days.') > 0
AND x.dbid = TO_NUMBER('&&cs_dbid.')
AND ('&&cs_include_sys.' = 'Y' OR (
x.sql_text NOT LIKE '/* SQL Analyze(%'
AND x.sql_text NOT LIKE '%/* cli_%'
AND x.sql_text NOT LIKE '%/* cs_%'
AND x.sql_text NOT LIKE '%FUNCTION application_category%'
AND x.sql_text NOT LIKE '%MATERIALIZE NO_MERGE%'
AND x.sql_text NOT LIKE '%NO_STATEMENT_QUEUING%'
AND x.sql_text NOT LIKE 'SELECT /* &&cs_script_name. */%'
))
AND CASE
WHEN LENGTH('&&cs_search_string.') = 5 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NULL /* number */ AND TO_CHAR(get_sql_hv(x.sql_text)) = '&&cs_search_string.' THEN 1
WHEN LENGTH('&&cs_search_string.') = 13 AND TRIM(TRANSLATE('&&cs_search_string.', ' 0123456789', ' ')) IS NOT NULL /* alpha */ AND LOWER('&&cs_search_string.') = '&&cs_search_string.' AND x.sql_id = '&&cs_search_string.' THEN 1
WHEN UPPER(x.sql_text) LIKE UPPER('%&&cs_search_string.%') THEN 1
END = 1
-- AND ('&&cs_include_sys.' = 'Y' OR NVL(v.parsing_schema_name, '-666') <> 'SYS') -- super slow!
AND c.con_id = x.con_id
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
CHR(10)||
'SQL_HV : '||sql_hv||CHR(10)||
'SQL_ID : '||sql_id||CHR(10)||
'FIRST_ROWS : '||first_rows_candidacy||CHR(10)||
'PDB_NAME : '||pdb_name||CHR(10)||
CHR(10)||sql_text AS pretty_unique_name
FROM awr
ORDER BY
sql_hv, sql_id
/
--
SET HEA ON PAGES 100;
csierra/cs_internal/cs_gv_sql_global.sql
+142
View File
@@ -0,0 +1,142 @@
-- cs_gv_sql_global.sql: called by cs_planx.sql, cs_sqlperf.sql and cs_purge_cursor.sql
@@cs_sqlstat_cols.sql
@@cs_sqlstat_compute.sql
PRO
PRO SQL STATS - CURRENT BY CHILD CURSOR (gv$sql) &&cs_scope_1.
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_gv_sql_global */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sql_metrics AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.*,
s.elapsed_time/GREATEST(s.executions,1)/1e3 AS et_ms_per_exec,
s.cpu_time/GREATEST(s.executions,1)/1e3 AS cpu_ms_per_exec,
s.user_io_wait_time/GREATEST(s.executions,1)/1e3 AS io_ms_per_exec,
s.application_wait_time/GREATEST(s.executions,1)/1e3 AS appl_ms_per_exec,
s.concurrency_wait_time/GREATEST(s.executions,1)/1e3 AS conc_ms_per_exec,
s.plsql_exec_time/GREATEST(s.executions,1)/1e3 AS plsql_ms_per_exec,
s.cluster_wait_time/GREATEST(s.executions,1)/1e3 AS cluster_ms_per_exec,
s.java_exec_time/GREATEST(s.executions,1)/1e3 AS java_ms_per_exec,
s.executions/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS execs_per_sec,
s.px_servers_executions/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS px_execs_per_sec,
s.end_of_fetch_count/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS end_of_fetch_per_sec,
s.parse_calls/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS parses_per_sec,
s.invalidations/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS inval_per_sec,
s.loads/GREATEST(((SYSDATE - TO_DATE(REPLACE(s.last_load_time, '/', 'T'), '&&cs_datetime_full_format.')) * 24 * 3600),1) AS loads_per_sec,
s.buffer_gets/GREATEST(s.executions,1) AS gets_per_exec,
s.disk_reads/GREATEST(s.executions,1) AS reads_per_exec,
s.direct_reads/GREATEST(s.executions,1) AS direct_reads_per_exec,
s.direct_writes/GREATEST(s.executions,1) AS direct_writes_per_exec,
s.physical_read_requests/GREATEST(s.executions,1) AS phy_read_req_per_exec,
s.physical_read_bytes/GREATEST(s.executions,1)/1e6 AS phy_read_mb_per_exec,
s.physical_write_requests/GREATEST(s.executions,1) AS phy_write_req_per_exec,
s.physical_write_bytes/GREATEST(s.executions,1)/1e6 AS phy_write_mb_per_exec,
s.fetches/GREATEST(s.executions,1) AS fetches_per_exec,
s.sorts/GREATEST(s.executions,1) AS sorts_per_exec,
s.rows_processed/GREATEST(s.executions,1) AS rows_per_exec,
s.elapsed_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS et_ms_per_row,
s.cpu_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS cpu_ms_per_row,
s.user_io_wait_time/GREATEST(s.rows_processed,s.executions,1)/1e3 AS io_ms_per_row,
s.buffer_gets/GREATEST(s.rows_processed,s.executions,1) AS gets_per_row,
s.disk_reads/GREATEST(s.rows_processed,s.executions,1) AS reads_per_row,
get_sql_hv(s.sql_fulltext) AS sqlid
FROM gv$sql s
WHERE &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(s.sql_text) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.last_active_time,
REPLACE(s.last_load_time, '/', 'T') AS last_load_time,
REPLACE(s.first_load_time, '/', 'T') AS first_load_time,
s.sqlid,
s.sql_id,
s.inst_id,
s.child_number,
s.plan_hash_value,
'!' AS sep1,
s.executions,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep2,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep4,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep5,
s.loaded_versions AS version_count,
CASE s.is_obsolete WHEN 'Y' THEN 1 ELSE 0 END AS obsolete_count,
CASE s.is_shareable WHEN 'Y' THEN 1 ELSE 0 END AS shareable_count,
s.loads,
s.invalidations,
s.sharable_mem/1e6 AS sharable_mem_mb,
'!' AS sep8,
CASE WHEN s.sql_plan_baseline IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_bl,
CASE WHEN s.sql_profile IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_prf,
CASE WHEN s.sql_patch IS NOT NULL THEN 'YES' ELSE 'NO' END AS sql_pch,
'!' AS sep9,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
s.optimizer_cost
FROM sql_metrics s
ORDER BY
s.last_active_time,
s.sqlid,
s.sql_id,
s.inst_id,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_gv_sql_stability.sql
+84
View File
@@ -0,0 +1,84 @@
-- cs_gv_sql_stability.sql: called by cs_planx.sql, cs_sqlperf.sql and cs_purge_cursor.sql
@@cs_sqlstat_cols.sql
PRO
PRO PLAN STABILITY - CURRENT BY CHILD CURSOR (gv$sql)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_gv_sql_stability */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sql_metrics AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.*,
get_sql_hv(s.sql_fulltext) AS sqlid
FROM gv$sql s
WHERE &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(s.sql_text) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.last_active_time,
REPLACE(s.last_load_time, '/', 'T') AS last_load_time,
REPLACE(s.first_load_time, '/', 'T') AS first_load_time,
s.sqlid,
s.sql_id,
s.inst_id,
s.child_number,
s.plan_hash_value,
s.full_plan_hash_value,
'!' AS sep1,
s.executions,
s.loaded_versions,
s.loads,
s.invalidations,
s.object_status,
'!' AS sep2,
s.is_obsolete,
s.is_shareable,
s.is_bind_sensitive,
s.is_bind_aware,
'!' AS sep3,
s.sql_plan_baseline,
CASE WHEN s.sql_plan_baseline IS NOT NULL THEN (SELECT p.created FROM dba_sql_plan_baselines p WHERE p.plan_name = s.sql_plan_baseline AND p.signature = :cs_signature AND ROWNUM = 1) END AS spbl_created,
s.sql_profile,
CASE WHEN s.sql_profile IS NOT NULL THEN (SELECT p.created FROM dba_sql_profiles p WHERE p.name = s.sql_profile AND p.signature = :cs_signature AND ROWNUM = 1) END AS sprf_created,
s.sql_patch,
CASE WHEN s.sql_patch IS NOT NULL THEN (SELECT p.created FROM dba_sql_patches p WHERE p.name = s.sql_patch AND p.signature = :cs_signature AND ROWNUM = 1) END AS spch_created,
'!' AS sep4,
s.sql_text,
s.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name
FROM sql_metrics s
ORDER BY
s.last_active_time,
s.sqlid,
s.sql_id,
s.inst_id,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END,
s.module
/
--
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_gv_sqlstat_global.sql
+211
View File
@@ -0,0 +1,211 @@
-- cs_gv_sqlstat_global.sql: called by cs_planx.sql and cs_sqlperf.sql
@@cs_sqlstat_cols.sql
PRO
PRO SQL STATS - CURRENT BY SQL (gv$sqlstats) since last AWR snapshot
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_gv_sqlstat_global */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats_metrics AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.*,
w.age_seconds AS seconds,
w.snap_id,
w.begin_timestamp,
w.end_timestamp,
s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 AS et_ms_per_exec,
s.delta_cpu_time/GREATEST(s.delta_execution_count,1)/1e3 AS cpu_ms_per_exec,
s.delta_user_io_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS io_ms_per_exec,
s.delta_application_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS appl_ms_per_exec,
s.delta_concurrency_time/GREATEST(s.delta_execution_count,1)/1e3 AS conc_ms_per_exec,
s.delta_plsql_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS plsql_ms_per_exec,
s.delta_cluster_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS cluster_ms_per_exec,
s.delta_java_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS java_ms_per_exec,
s.delta_elapsed_time/GREATEST(w.age_seconds,1)/1e6 AS et_aas,
s.delta_cpu_time/GREATEST(w.age_seconds,1)/1e6 AS cpu_aas,
s.delta_user_io_wait_time/GREATEST(w.age_seconds,1)/1e6 AS io_aas,
s.delta_application_wait_time/GREATEST(w.age_seconds,1)/1e6 AS appl_aas,
s.delta_concurrency_time/GREATEST(w.age_seconds,1)/1e6 AS conc_aas,
s.delta_plsql_exec_time/GREATEST(w.age_seconds,1)/1e6 AS plsql_aas,
s.delta_cluster_wait_time/GREATEST(w.age_seconds,1)/1e6 AS cluster_aas,
s.delta_java_exec_time/GREATEST(w.age_seconds,1)/1e6 AS java_aas,
s.delta_execution_count/GREATEST(w.age_seconds,1) AS execs_per_sec,
s.delta_px_servers_executions/GREATEST(w.age_seconds,1) AS px_execs_per_sec,
s.delta_end_of_fetch_count/GREATEST(w.age_seconds,1) AS end_of_fetch_per_sec,
s.delta_parse_calls/GREATEST(w.age_seconds,1) AS parses_per_sec,
s.delta_invalidations/GREATEST(w.age_seconds,1) AS inval_per_sec,
s.delta_loads/GREATEST(w.age_seconds,1) AS loads_per_sec,
s.delta_buffer_gets/GREATEST(s.delta_execution_count,1) AS gets_per_exec,
s.delta_disk_reads/GREATEST(s.delta_execution_count,1) AS reads_per_exec,
s.delta_direct_reads/GREATEST(s.delta_execution_count,1) AS direct_reads_per_exec,
s.delta_direct_writes/GREATEST(s.delta_execution_count,1) AS direct_writes_per_exec,
s.delta_physical_read_requests/GREATEST(s.delta_execution_count,1) AS phy_read_req_per_exec,
s.delta_physical_read_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_read_mb_per_exec,
s.delta_physical_write_requests/GREATEST(s.delta_execution_count,1) AS phy_write_req_per_exec,
s.delta_physical_write_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_write_mb_per_exec,
s.delta_fetch_count/GREATEST(s.delta_execution_count,1) AS fetches_per_exec,
s.delta_sorts/GREATEST(s.delta_execution_count,1) AS sorts_per_exec,
s.delta_rows_processed/GREATEST(s.delta_execution_count,1) AS rows_per_exec,
s.delta_elapsed_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS et_ms_per_row,
s.delta_cpu_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS cpu_ms_per_row,
s.delta_user_io_wait_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS io_ms_per_row,
s.delta_buffer_gets/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS gets_per_row,
s.delta_disk_reads/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS reads_per_row,
-- s.avg_hard_parse_time,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN s.sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(s.sql_text, '\[([[:digit:]]{4})\] ') ELSE s.sql_text END),100000),5,'0') AS sqlid
get_sql_hv(s.sql_fulltext) AS sqlid
FROM gv$sqlstats s,
(SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
((86400 * EXTRACT(DAY FROM (SYSTIMESTAMP - MAX(end_interval_time))) + (3600 * EXTRACT(HOUR FROM (systimestamp - MAX(end_interval_time)))) + (60 * EXTRACT(MINUTE FROM (systimestamp - MAX(end_interval_time)))) + EXTRACT(SECOND FROM (systimestamp - MAX(end_interval_time))))) AS age_seconds ,
MAX(snap_id) + 1 AS snap_id,
MAX(end_interval_time) AS begin_timestamp,
SYSTIMESTAMP AS end_timestamp
FROM dba_hist_snapshot
WHERE end_interval_time < SYSTIMESTAMP) w
WHERE &&cs_filter_1.
AND ('&&cs2_sql_text_piece.' IS NULL OR UPPER(s.sql_text) LIKE CHR(37)||UPPER('&&cs2_sql_text_piece.')||CHR(37))
AND ROWNUM >= 1 -- materialize
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
LPAD(s.snap_id, 7, '0') AS snap_id,
-- s.day,
s.begin_timestamp,
s.end_timestamp,
s.seconds,
s.sqlid,
s.sql_id,
s.inst_id,
s.plan_hash_value,
-- s.optimizer_cost,
'!' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'!' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
'!' AS sep3,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'!' AS sep4,
s.gets_per_exec,
s.reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'!' AS sep5,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'!' AS sep6,
s.delta_elapsed_time,
s.delta_cpu_time,
s.delta_user_io_wait_time,
s.delta_application_wait_time,
s.delta_concurrency_time,
s.delta_plsql_exec_time,
s.delta_cluster_wait_time,
s.delta_java_exec_time,
'!' AS sep7,
s.delta_px_servers_executions,
s.delta_end_of_fetch_count,
s.delta_parse_calls,
s.delta_buffer_gets,
s.delta_disk_reads,
s.delta_direct_writes,
s.delta_physical_read_requests,
s.delta_physical_read_bytes/1e6 AS delta_physical_read_mb,
s.delta_physical_write_requests,
s.delta_physical_write_bytes/1e6 AS delta_physical_write_mb,
s.delta_fetch_count,
s.delta_sorts,
s.delta_io_interconnect_bytes/1e6 AS delta_io_interconnect_mb,
s.delta_cell_offload_elig_bytes/1e6 AS delta_cell_offload_elig_mb,
s.delta_cell_uncompressed_bytes/1e6 AS delta_cell_uncompressed_mb,
-- s.delta_cell_offload_retrn_mb,
'!' AS sep8,
s.version_count,
-- s.obsolete_count,
s.delta_loads,
s.delta_invalidations,
s.sharable_mem/1e6 AS sharable_mem_mb,
'!' AS sep9,
s.sql_text,
v.module,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE v.parsing_schema_name END AS pdb_or_parsing_schema_name
FROM sqlstats_metrics s
OUTER APPLY (
SELECT v.module,
v.parsing_schema_name
FROM gv$sql v
WHERE v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.inst_id = s.inst_id
AND v.plan_hash_value = s.plan_hash_value
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
ORDER BY
s.snap_id,
-- s.day,
s.begin_timestamp,
s.end_timestamp,
s.sqlid,
s.sql_id,
s.inst_id,
s.plan_hash_value,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE v.parsing_schema_name END,
v.module
/
--
@@cs_sqlstat_foot.sql
@@cs_sqlstat_clear.sql
csierra/cs_internal/cs_internal_list_dg_members.sql
+16
View File
@@ -0,0 +1,16 @@
SET SERVEROUT ON;
BEGIN -- using pl/sql to avoid a blank line
FOR i IN (SELECT RPAD(r.role, 13, ' ')||': '||d.db_unique_name||' HOST:'||h.host_name||CASE h.host_name WHEN '&&cs_host_name.' THEN ' <-' END AS dg_members
FROM
(SELECT x.value db_unique_name, ROW_NUMBER() OVER (ORDER BY x.indx) AS rn FROM x$drc x WHERE x.attribute = 'DATABASE') d,
(SELECT x.value role, ROW_NUMBER() OVER (ORDER BY x.indx) AS rn FROM x$drc x WHERE x.attribute = 'role') r,
(SELECT x.value host_name, ROW_NUMBER() OVER (ORDER BY x.indx) AS rn FROM x$drc x WHERE x.attribute = 'host') h
WHERE r.rn = d.rn AND h.rn = d.rn
ORDER BY r.role DESC, d.db_unique_name
)
LOOP
DBMS_OUTPUT.put_line(i.dg_members);
END LOOP;
END;
/
SET SERVEROUT OFF;
csierra/cs_internal/cs_internal_purge_cursor.sql
+61
View File
@@ -0,0 +1,61 @@
DEF p_sql_id = '&1.';
UNDEF 1;
-- purge cursor
DECLARE
l_signature NUMBER;
l_sql_text CLOB;
l_name VARCHAR2(64);
BEGIN
-- get signature and sql_text
SELECT exact_matching_signature AS signature, sql_fulltext AS sql_text INTO l_signature, l_sql_text FROM v$sql WHERE sql_id = '&&p_sql_id.' AND ROWNUM = 1;
-- backup existing pacth
FOR i IN (SELECT name FROM dba_sql_patches WHERE signature = l_signature AND category = 'DEFAULT')
LOOP
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', value => 'PURGE'); -- 12c
$ELSE
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', attribute_value => 'PURGE'); -- 19c
$END
END LOOP;
-- create dummy patch
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
DBMS_SQLDIAG_INTERNAL.i_create_patch(sql_text => l_sql_text, hint_text => 'NULL', name => 'PURGE_&&p_sql_id.'); -- 12c
$ELSE
l_name := DBMS_SQLDIAG.create_sql_patch(sql_text => l_sql_text, hint_text => 'NULL', name => 'PURGE_&&p_sql_id.'); -- 19c
$END
-- drop dummy patch
DBMS_SQLDIAG.drop_sql_patch(name => 'PURGE_&&p_sql_id.');
-- restore backup patch
FOR i IN (SELECT name FROM dba_sql_patches WHERE signature = l_signature AND category = 'PURGE')
LOOP
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', value => 'DEFAULT'); -- 12c
$ELSE
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', attribute_value => 'DEFAULT'); -- 19c
$END
END LOOP;
-- report
DBMS_OUTPUT.put_line('&&p_sql_id. purged using a transient sql patch');
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.put_line('&&p_sql_id. not found in v$sql');
END;
/
-- purge cursor
DECLARE
l_name VARCHAR2(64);
BEGIN
SELECT address||','||hash_value INTO l_name FROM v$sqlarea WHERE sql_id = '&&p_sql_id.' AND ROWNUM = 1; -- there are cases where it comes back with > 1 row!!!
SYS.DBMS_SHARED_POOL.PURGE(name => l_name, flag => 'C', heaps => 1); -- not always does the job
-- report
DBMS_OUTPUT.put_line('&&p_sql_id. purged using an api on parent cursor');
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.put_line('&&p_sql_id. not found in v$sqlarea');
END;
/
--
UNDEF p_sql_id;
csierra/cs_internal/cs_last_snap.sql
+20
View File
@@ -0,0 +1,20 @@
DEF cs_max_snap_id = '';
COL cs_max_snap_id NEW_V cs_max_snap_id NOPRI;
DEF cs_max_snap_end_time = '';
COL cs_max_snap_end_time NEW_V cs_max_snap_end_time NOPRI;
DEF cs_last_snap_mins = '';
COL cs_last_snap_mins NEW_V cs_last_snap_mins NOPRI;
DEF cs_last_snap_secs = '';
COL cs_last_snap_secs NEW_V cs_last_snap_secs NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) cs_max_snap_id,
TRIM(TO_CHAR(end_interval_time, '&&cs_datetime_full_format.')) cs_max_snap_end_time,
TRIM(TO_CHAR(ROUND((SYSDATE - CAST(end_interval_time AS DATE)) * 24 * 60, 1), '99990.0')) AS cs_last_snap_mins,
TRIM(TO_CHAR(((86400 * EXTRACT(DAY FROM (SYSTIMESTAMP - end_interval_time)) + (3600 * EXTRACT(HOUR FROM (systimestamp - end_interval_time))) + (60 * EXTRACT(MINUTE FROM (systimestamp - end_interval_time))) + EXTRACT(SECOND FROM (systimestamp - end_interval_time)))), '9999990.000')) AS cs_last_snap_secs
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
csierra/cs_internal/cs_latency_hist_internal_1.sql
+155
View File
@@ -0,0 +1,155 @@
-- cs_latency_hist_internal_1: used by cs_latency_hist.sql and lah.sql
SET HEA ON LIN 2490 PAGES 100 TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON TRIM ON TI OFF TIMI OFF LONG 240000 LONGC 2400 NUM 20 SERVEROUT OFF;
SET PAGES 300 LONGC 120;
--
DEF cs_small_format = 'HH24:MI:SS';
--
COL cs_dbid NEW_V cs_dbid NOPRI;
COL cs_instance_number NEW_V cs_instance_number NOPRI;
SELECT TRIM(TO_CHAR(d.dbid)) AS cs_dbid, TRIM(TO_CHAR(i.instance_number)) AS cs_instance_number
FROM v$database d, v$instance i
/
--
@@cs_internal/cs_last_snap.sql
--
COL t_1_snap_id NEW_V t_1_snap_id NOPRI;
COL t_1_snap_begin NEW_V t_1_snap_begin NOPRI;
COL t_1_snap_end NEW_V t_1_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_1_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_1_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_1_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_0_snap_begin NEW_V t_0_snap_begin NOPRI;
COL t_0_snap_end NEW_V t_0_snap_end NOPRI;
SELECT '&&t_1_snap_end.' AS t_0_snap_begin,
TO_CHAR(SYSDATE, '&&cs_small_format.') AS t_0_snap_end
FROM DUAL
/
--
COL t_2_snap_id NEW_V t_2_snap_id NOPRI;
COL t_2_snap_begin NEW_V t_2_snap_begin NOPRI;
COL t_2_snap_end NEW_V t_2_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_2_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_2_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_2_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_1_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_3_snap_id NEW_V t_3_snap_id NOPRI;
COL t_3_snap_begin NEW_V t_3_snap_begin NOPRI;
COL t_3_snap_end NEW_V t_3_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_3_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_3_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_3_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_2_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_4_snap_id NEW_V t_4_snap_id NOPRI;
COL t_4_snap_begin NEW_V t_4_snap_begin NOPRI;
COL t_4_snap_end NEW_V t_4_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_4_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_4_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_4_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_3_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_5_snap_id NEW_V t_5_snap_id NOPRI;
COL t_5_snap_begin NEW_V t_5_snap_begin NOPRI;
COL t_5_snap_end NEW_V t_5_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_5_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_5_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_5_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_4_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_6_snap_id NEW_V t_6_snap_id NOPRI;
COL t_6_snap_begin NEW_V t_6_snap_begin NOPRI;
COL t_6_snap_end NEW_V t_6_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_6_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_6_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_6_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_5_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_7_snap_id NEW_V t_7_snap_id NOPRI;
COL t_7_snap_begin NEW_V t_7_snap_begin NOPRI;
COL t_7_snap_end NEW_V t_7_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_7_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_7_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_7_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_6_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_8_snap_id NEW_V t_8_snap_id NOPRI;
COL t_8_snap_begin NEW_V t_8_snap_begin NOPRI;
COL t_8_snap_end NEW_V t_8_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_8_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_8_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_8_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_7_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
COL t_9_snap_id NEW_V t_9_snap_id NOPRI;
COL t_9_snap_begin NEW_V t_9_snap_begin NOPRI;
COL t_9_snap_end NEW_V t_9_snap_end NOPRI;
SELECT TRIM(TO_CHAR(snap_id)) AS t_9_snap_id,
TRIM(TO_CHAR(begin_interval_time, '&&cs_small_format.')) AS t_9_snap_begin,
TRIM(TO_CHAR(end_interval_time, '&&cs_small_format.')) AS t_9_snap_end
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id < TO_NUMBER('&&t_8_snap_id.')
ORDER BY
snap_id DESC
FETCH FIRST 1 ROW ONLY
/
--
csierra/cs_internal/cs_latency_hist_internal_2.sql
+452
View File
@@ -0,0 +1,452 @@
-- cs_latency_hist_internal_2.sql: called by lah.sql and cs_latency_hist.sql
SET HEA ON LIN 2490 PAGES 100 TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON TRIM ON TI OFF TIMI OFF LONG 240000 LONGC 2400 NUM 20 SERVEROUT OFF;
SET PAGES 300 LONGC 120;
--
COL type FOR A2 HEA 'Ty';
COL t_9_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_9_snap_begin.-|&&t_9_snap_end.)';
COL t_8_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_8_snap_begin.-|&&t_8_snap_end.)';
COL t_7_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_7_snap_begin.-|&&t_7_snap_end.)';
COL t_6_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_6_snap_begin.-|&&t_6_snap_end.)';
COL t_5_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_5_snap_begin.-|&&t_5_snap_end.)';
COL t_4_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_4_snap_begin.-|&&t_4_snap_end.)';
COL t_3_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_3_snap_begin.-|&&t_3_snap_end.)';
COL t_2_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_2_snap_begin.-|&&t_2_snap_end.)';
COL t_1_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_1_snap_begin.-|&&t_1_snap_end.)';
COL t_0_cpu_ms_per_exec FOR A10 HEA 'CPU ms p/e|(&&t_0_snap_begin.-|&&t_0_snap_end.)';
COL execs FOR 999,990 HEA 'Executions|(&&t_0_snap_begin.-|&&t_0_snap_end.)';
COL sql_text FOR A60 TRUNC;
COL pdb_name FOR A28 TRUNC;
COL plan_hash_value FOR 9999999999 HEA 'Plan Hash';
COL has_baseline FOR A2 HEA 'BL';
COL has_profile FOR A2 HEA 'PR';
COL has_patch FOR A2 HEA 'PA';
COL regression FOR 999,990 HEA 'Regress|Perc %';
COL sqlid FOR A5 HEA 'SQL|HV';
--
BREAK ON type SKIP PAGE DUPL;
--
PRO
PRO CPU Latency - TOP &&cs_top. SQL for each Type (as per last &&cs_last_snap_mins. minutes and compared to recent AWR snapshots)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
WITH
FUNCTION application_category (
p_sql_text IN VARCHAR2,
p_command_name IN VARCHAR2 DEFAULT NULL
)
RETURN VARCHAR2
IS
k_appl_handle_prefix CONSTANT VARCHAR2(30) := CHR(37)||'/*'||CHR(37);
k_appl_handle_suffix CONSTANT VARCHAR2(30) := CHR(37)||'*/'||CHR(37);
BEGIN
IF p_sql_text LIKE k_appl_handle_prefix||'Transaction Processing'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'addTransactionRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkEndRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkStartRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'exists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch commit by idempotency token'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest transactions for cache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find lower commit id for transaction cache warm up'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'findMatchingRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionCommitID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNewTransactionID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getTransactionProgress'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockForCommit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockKievTransactor'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'putBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readTransactionsSince'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'recordTransactionState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'setValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SPM:CP'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateNextKievTransID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'upsert_transactor_state'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'writeTransactionKeys'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'QueryTransactorHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'WriteBucketValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch commit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch mutation log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetchAllIdentities'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_epoch'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readFromTxorStateBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'legacyGetDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getWithVersionOffsetSql'||k_appl_handle_suffix
OR LOWER(p_sql_text) LIKE CHR(37)||'lock table kievtransactions'||CHR(37)
--
OR p_sql_text LIKE k_appl_handle_prefix||'Set ddl lock timeout for session'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getForUpdate.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Drop partition'||k_appl_handle_suffix
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Read Only'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIndexSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketKeySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketValueSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countTransactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch snapshots'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get system time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAutoSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Lock row Bucket_Snapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'longFromDual'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performContinuedScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performFirstRowsScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSnapshotScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performStartScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest revisions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch max sequence for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Find High value for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find partitions for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Init lock name for snapshot'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'List snapshot tables.'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'Tail read bucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSegmentedScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listArchiveStatusByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listAssignmentsByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateHost'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateArchiveStatus'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateOperationLock'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KIEVWORKFLOWS table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetOldestLsn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetStreamRecords'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if another workflow is running'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete old workflows from'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getPriorWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeaseTypes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getHistoricalAssignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAllWorkflowDefinitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getVersionHistory'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find interval partitions for schema'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getStepInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getOldestGcWorkflowInstance'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextRecordID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseNonce'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getByKey.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRecordId.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if there are active rows for partition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRunningInstancesCount'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLatestWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.step_instances'||k_appl_handle_suffix
THEN RETURN 'RO'; /* Read Only */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Background'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Bootstrap snapshot table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIdentitySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkMissingTables'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKievTransactionRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKtkRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete garbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete rows from'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteBucketGarbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_leader_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventMaxId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventTryInsert'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get txn at time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getCurEndTime'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDBSchemaVersion'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getEndTimeOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getGCLogEntries'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSchemaMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSupportedLibVersions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashSnapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Populate workspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'populateBucketGCWorkspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'primeTxCache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyRoleExists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Row count between transactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'secondsSinceLastGcEvent'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'sync_leadership'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Test if table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Update snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateIfWorkspaceEmpty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'verify_is_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checking existence of Mutation Log Table'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONKEYS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KT'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KTK'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Insert dynamic config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createProxyUser'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createSequence'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deregister_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropAutoSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropBucketFromMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactionKeys table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactions table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get session count'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'initializeMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isKtPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'register_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateSchemaVersionInDB'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorks'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMinorVersionsAtAndAfter'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseDecorators'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeasesByFiFo'||k_appl_handle_suffix
THEN RETURN 'BG'; /* Background */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Ignore'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateKievPdbs'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getJDBCSuffix'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'MV_REFRESH'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'null'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectColumnsForTable'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectDatastoreMd'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SQL Analyze('||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateDataStoreId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countSequenceInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'iod-telemetry'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'OPT_DYN_SAMP'||k_appl_handle_suffix
THEN RETURN 'IG'; /* Ignore */
--
ELSIF p_command_name IN ('INSERT', 'UPDATE')
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_command_name = 'DELETE'
THEN RETURN 'BG'; /* Background */
--
ELSIF p_command_name = 'SELECT'
THEN RETURN 'RO'; /* Read Only */
--
ELSE RETURN 'UN'; /* Unknown */
END IF;
END application_category;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE */
s.con_id,
application_category(s.sql_text, /*v.command_name*/ 'UNKNOWN') AS type, -- passing UNKNOWN else KIEV envs would show a lot of unrelated SQL under RO
s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 AS et_ms_per_exec,
s.delta_cpu_time/GREATEST(s.delta_execution_count,1)/1e3 AS cpu_ms_per_exec,
s.delta_user_io_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS io_ms_per_exec,
s.delta_application_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS appl_ms_per_exec,
s.delta_concurrency_time/GREATEST(s.delta_execution_count,1)/1e3 AS conc_ms_per_exec,
s.delta_execution_count AS execs,
s.delta_rows_processed/GREATEST(s.delta_execution_count,1) AS rows_per_exec,
s.delta_buffer_gets/GREATEST(s.delta_execution_count,1) AS gets_per_exec,
s.delta_disk_reads/GREATEST(s.delta_execution_count,1) AS reads_per_exec,
s.delta_direct_writes/GREATEST(s.delta_execution_count,1) AS writes_per_exec,
s.delta_fetch_count/GREATEST(s.delta_execution_count,1) AS fetches_per_exec,
s.sql_id,
s.sql_text,
s.sql_fulltext,
s.plan_hash_value,
s.last_active_child_address
FROM v$sqlstats s
WHERE s.delta_elapsed_time > 0
AND ROWNUM >= 1
),
sqlstats_extended AS (
SELECT /*+ MATERIALIZE NO_MERGE */
s.type,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.execs,
s.rows_per_exec,
s.gets_per_exec,
s.reads_per_exec,
s.writes_per_exec,
s.fetches_per_exec,
s.sql_id,
s.sql_text,
s.sql_fulltext,
s.plan_hash_value,
s.last_active_child_address,
s.con_id,
c.name pdb_name,
ROW_NUMBER() OVER (PARTITION BY s.type ORDER BY s.cpu_ms_per_exec DESC) row_number
FROM sqlstats s,
v$containers c
WHERE s.type IN ('TP', 'RO', 'BG', 'UN')
AND c.con_id = s.con_id
AND ROWNUM >= 1
),
sqlstats_current AS (
SELECT CASE s.type WHEN 'TP' THEN 1 WHEN 'RO' THEN 2 WHEN 'BG' THEN 3 WHEN 'UN' THEN 4 ELSE 5 END AS type_order_by,
s.type,
s.row_number,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.execs,
s.rows_per_exec,
s.gets_per_exec,
s.reads_per_exec,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
s.sql_fulltext,
s.con_id,
s.pdb_name
FROM sqlstats_extended s
CROSS APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch
FROM v$sql v
WHERE s.plan_hash_value > 0
AND v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
AND v.child_address = s.last_active_child_address
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
WHERE s.row_number <= &&cs_top.
AND ROWNUM >= 1
),
sqlstats_hist AS (
SELECT /*+ MATERIALIZE NO_MERGE */
h.con_id,
h.sql_id,
h.snap_id,
SUM(h.elapsed_time_delta)/GREATEST(SUM(h.executions_delta),1)/1e3 AS et_ms_per_exec,
SUM(h.cpu_time_delta)/GREATEST(SUM(h.executions_delta),1)/1e3 AS cpu_ms_per_exec,
SUM(h.iowait_delta)/GREATEST(SUM(h.executions_delta),1)/1e3 AS io_ms_per_exec,
SUM(h.apwait_delta)/GREATEST(SUM(h.executions_delta),1)/1e3 AS appl_ms_per_exec,
SUM(h.ccwait_delta)/GREATEST(SUM(h.executions_delta),1)/1e3 AS conc_ms_per_exec,
SUM(h.executions_delta) AS execs,
SUM(h.rows_processed_delta)/GREATEST(SUM(h.executions_delta),1) AS rows_per_exec,
SUM(h.buffer_gets_delta)/GREATEST(SUM(h.executions_delta),1) AS gets_per_exec,
SUM(h.disk_reads_delta)/GREATEST(SUM(h.executions_delta),1) AS reads_per_exec,
SUM(h.fetches_delta)/GREATEST(SUM(h.executions_delta),1) AS fetches_per_exec,
MAX(SUM(h.cpu_time_delta)/GREATEST(SUM(h.executions_delta),1)/1e3) OVER (PARTITION BY h.con_id, h.sql_id) AS max_cpu_ms_per_exec
FROM dba_hist_sqlstat h
WHERE h.dbid = TO_NUMBER('&&cs_dbid.')
AND h.instance_number = TO_NUMBER('&&cs_instance_number.')
AND h.snap_id BETWEEN TO_NUMBER('&&t_9_snap_id.') AND TO_NUMBER('&&t_1_snap_id.')
AND (h.con_id, h.sql_id) IN (SELECT con_id, sql_id FROM sqlstats_current)
AND h.optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
GROUP BY
h.con_id,
h.sql_id,
h.snap_id
)
SELECT c.type,
LPAD(CASE WHEN t_9.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_9.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_9_cpu_ms_per_exec,
LPAD(CASE WHEN t_8.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_8.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_8_cpu_ms_per_exec,
LPAD(CASE WHEN t_7.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_7.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_7_cpu_ms_per_exec,
LPAD(CASE WHEN t_6.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_6.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_6_cpu_ms_per_exec,
LPAD(CASE WHEN t_5.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_5.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_5_cpu_ms_per_exec,
LPAD(CASE WHEN t_4.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_4.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_4_cpu_ms_per_exec,
LPAD(CASE WHEN t_3.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_3.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_3_cpu_ms_per_exec,
LPAD(CASE WHEN t_2.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_2.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_2_cpu_ms_per_exec,
LPAD(CASE WHEN t_1.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(t_1.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_1_cpu_ms_per_exec,
'|' AS "|",
LPAD(CASE WHEN c.cpu_ms_per_exec IS NULL THEN '-' ELSE TO_CHAR(c.cpu_ms_per_exec, '9,999,990') END, 10, ' ') AS t_0_cpu_ms_per_exec,
c.execs,
CASE WHEN c.cpu_ms_per_exec > 1.1 * t_1.max_cpu_ms_per_exec THEN 100 * ((c.cpu_ms_per_exec / t_1.max_cpu_ms_per_exec) - 1) END AS regression,
c.sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN c.sql_fulltext LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(c.sql_fulltext, '\[([[:digit:]]{4})\] ') ELSE c.sql_fulltext END),100000),5,'0') AS sqlid,
get_sql_hv(c.sql_fulltext) AS sqlid,
c.plan_hash_value,
c.has_baseline,
c.has_profile,
c.has_patch,
c.sql_text,
c.pdb_name
FROM sqlstats_current c,
sqlstats_hist t_1,
sqlstats_hist t_2,
sqlstats_hist t_3,
sqlstats_hist t_4,
sqlstats_hist t_5,
sqlstats_hist t_6,
sqlstats_hist t_7,
sqlstats_hist t_8,
sqlstats_hist t_9
WHERE 1 = 1
AND t_1.con_id(+) = c.con_id AND t_1.sql_id(+) = c.sql_id AND t_1.snap_id(+) = TO_NUMBER('&&t_1_snap_id.')
AND t_2.con_id(+) = c.con_id AND t_2.sql_id(+) = c.sql_id AND t_2.snap_id(+) = TO_NUMBER('&&t_2_snap_id.')
AND t_3.con_id(+) = c.con_id AND t_3.sql_id(+) = c.sql_id AND t_3.snap_id(+) = TO_NUMBER('&&t_3_snap_id.')
AND t_4.con_id(+) = c.con_id AND t_4.sql_id(+) = c.sql_id AND t_4.snap_id(+) = TO_NUMBER('&&t_4_snap_id.')
AND t_5.con_id(+) = c.con_id AND t_5.sql_id(+) = c.sql_id AND t_5.snap_id(+) = TO_NUMBER('&&t_5_snap_id.')
AND t_6.con_id(+) = c.con_id AND t_6.sql_id(+) = c.sql_id AND t_6.snap_id(+) = TO_NUMBER('&&t_6_snap_id.')
AND t_7.con_id(+) = c.con_id AND t_7.sql_id(+) = c.sql_id AND t_7.snap_id(+) = TO_NUMBER('&&t_7_snap_id.')
AND t_8.con_id(+) = c.con_id AND t_8.sql_id(+) = c.sql_id AND t_8.snap_id(+) = TO_NUMBER('&&t_8_snap_id.')
AND t_9.con_id(+) = c.con_id AND t_9.sql_id(+) = c.sql_id AND t_9.snap_id(+) = TO_NUMBER('&&t_9_snap_id.')
ORDER BY
c.type_order_by,
c.row_number
/
PRO
PRO Regress Perc %: When current CPU latency versus maximum latency from recent history is over 10% (regressions of < 10% are excluded)
--
-- CLEAR BREAK;
csierra/cs_internal/cs_latency_internal_cols.sql
+69
View File
@@ -0,0 +1,69 @@
--
COL sql_type FOR A4 HEA 'SQL|Type';
COL latency_rn FOR 990 HEA 'Lat|Top|#' NOPRINT;
COL load_rn FOR 9990 HEA 'Load|Top|#' NOPRINT;
COL et_ms_per_exec FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec';
COL cpu_ms_per_exec FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec';
COL io_ms_per_exec FOR 99,999,990.000 HEA 'I/O|Latency(ms)|Per Exec';
COL appl_ms_per_exec FOR 999,990.000 HEA 'Appl|Latency(ms)|Per Exec' &&cs_uncommon_col.;
COL conc_ms_per_exec FOR 999,990.000 HEA 'Conc|Latency(ms)|Per Exec' &&cs_uncommon_col.;
COL plsql_ms_per_exec FOR 999,990.000 HEA 'PL/SQL|Latency(ms)|Per Exec' &&cs_uncommon_col.;
COL cluster_ms_per_exec FOR 999,990.000 HEA 'Cluster|Latency(ms)|Per Exec' &&cs_uncommon_col.;
COL java_ms_per_exec FOR 999,990.000 HEA 'Java|Latency(ms)|Per Exec' &&cs_uncommon_col.;
COL et_aas FOR 9,990.000 HEA 'DB|Load(aas)';
COL cpu_aas FOR 9,990.000 HEA 'CPU|Load(aas)';
COL io_aas FOR 9,990.000 HEA 'I/O|Load(aas)';
COL appl_aas FOR 9,990.000 HEA 'Appl|Load(aas)' &&cs_uncommon_col.;
COL conc_aas FOR 9,990.000 HEA 'Conc|Load(aas)' &&cs_uncommon_col.;
COL plsql_aas FOR 9,990.000 HEA 'PL/SQL|Load(aas)' &&cs_uncommon_col.;
COL cluster_aas FOR 9,990.000 HEA 'Cluster|Load(aas)' &&cs_uncommon_col.;
COL java_aas FOR 9,990.000 HEA 'Java|Load(aas)' &&cs_uncommon_col.;
COL delta_execution_count FOR 999,999,999,990 HEA 'Executions|delta for|&&cs_execs_delta_h.';
COL execs_per_sec FOR 99,990.000 HEA 'Executions|Per Sec';
COL px_execs_per_sec FOR 99,990.000 HEA 'PX Execs|Per Sec' &&cs_uncommon_col.;
COL end_of_fetch_per_sec FOR 99,990.000 HEA 'End of|Fetch|Per Sec' &&cs_uncommon_col.;
COL parses_per_sec FOR 99,990.000 HEA 'Parses|Per Sec' &&cs_uncommon_col.;
COL avg_hard_parse_time FOR 9,999,990 HEA 'Avg|Hard Parse|Time(us)' &&cs_uncommon_col.;
COL inval_per_sec FOR 99,990.000 HEA 'Inval|Per Sec' &&cs_uncommon_col.;
COL loads_per_sec FOR 99,990.000 HEA 'Loads|Per Sec' &&cs_uncommon_col.;
COL gets_per_exec FOR 999,999,990 HEA 'Buffer|Gets|Per Exec';
COL reads_per_exec FOR 999,999,990 HEA 'Disk|Reads|Per Exec';
COL direct_reads_per_exec FOR 9,999,990 HEA 'Direct|Reads|Per Exec' &&cs_uncommon_col.;
COL direct_writes_per_exec FOR 9,999,990 HEA 'Direct|Writes|Per Exec' &&cs_uncommon_col.;
COL phy_read_req_per_exec FOR 999,990 HEA 'Physical|Read Reqs|Per Exec' &&cs_uncommon_col.;
COL phy_read_mb_per_exec FOR 999,990.000 HEA 'Physical|Read MB|Per Exec';
COL phy_write_req_per_exec FOR 999,990 HEA 'Physical|Write Reqs|Per Exec' &&cs_uncommon_col.;
COL phy_write_mb_per_exec FOR 999,990.000 HEA 'Physical|Write MB|Per Exec';
COL fetches_per_exec FOR 999,990 HEA 'Fetches|Per Exec' &&cs_uncommon_col.;
COL sorts_per_exec FOR 999,990 HEA 'Sorts|Per Exec' &&cs_uncommon_col.;
COL delta_rows_processed FOR 999,999,999,999,990 HEA 'Rows Processed|delta for|&&cs_execs_delta_h.';
COL rows_per_exec FOR 999,999,990.000 HEA 'Rows Processed|Per Exec';
COL et_ms_per_row FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Row Proc';
COL cpu_ms_per_row FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Row Proc';
COL io_ms_per_row FOR 99,999,990.000 HEA 'I/O|Latency(ms)|Per Row Proc';
COL gets_per_row FOR 999,999,990 HEA 'Buffer|Gets|Per Row Proc';
COL reads_per_row FOR 999,999,990 HEA 'Disk|Reads|Per Row Proc';
COL sql_text FOR A90 HEA 'SQL Text' TRUNC;
COL pdb_or_parsing_schema_name FOR A30 HEA 'PDB or Parsing Schema Name' TRUNC;
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash|Value';
COL has_baseline FOR A2 HEA 'BL';
COL has_profile FOR A2 HEA 'PR';
COL has_patch FOR A2 HEA 'PA';
COL sqlid FOR A5 HEA 'SQL|HV';
COL sql_hv FOR A5 HEA 'SQL|HV';
COL sql_len FOR 999,990 HEA 'SQL|Length';
COL begin_timestamp FOR A23 HEA 'Begin Timestamp' &&cs_uncommon_col.;
COL end_timestamp FOR A23 HEA 'End Timestamp' &&cs_uncommon_col.;
COL seconds FOR 9,999,990 HEA 'Seconds' &&cs_uncommon_col.;
COL num_rows FOR 9,999,999,990 HEA 'Table|Rows';
COL blocks FOR 999,999,990 HEA 'Table|Blocks';
COL sep0 FOR A2 HEA '+|!|!|!' PRI;
COL sep1 FOR A1 HEA '+|!|!|!' PRI;
COL sep2 FOR A1 HEA '+|!|!|!' PRI;
COL sep3 FOR A1 HEA '+|!|!|!' PRI;
COL sep4 FOR A1 HEA '+|!|!|!' PRI;
COL sep5 FOR A1 HEA '+|!|!|!' PRI;
COL sep6 FOR A1 HEA '+|!|!|!' PRI;
--
BREAK ON sql_type SKIP PAGE DUPL;
--
csierra/cs_internal/cs_latency_internal_foot.sql
+8
View File
@@ -0,0 +1,8 @@
PRO
PRO 1. Top &&cs_top_latency. active SQL per SQL Type as per DB Latency (iff DB AAS > &&cs_aas_threshold_latency.) UNION Top &&cs_top_load. active SQL per SQL Type as per DB Load (iff DB AAS > &&cs_aas_threshold_load.) ordered by DB Latency descending.
PRO 2. Includes only SQL with DB Latency > &&cs_ms_threshold_latency. milliseconds per execution, and which has been active recently.
PRO 3. For an extended output use le.sql (cs_latency_extended.sql). For a reduced output use l.sql (cs_latency.sql). For a reduced output without a report heading use la.sql.
PRO 4. For a time range use lr.sql (cs_latency_range.sql) OR lre.sql (cs_latency_range_extended.sql), both from AWR (15m granularity); or cs_latency_range_iod.sql and cs_latency_range_iod_extended.sql, both from IOD table (1m granularity).
PRO 5. For the last 1 minute use cs_latency_1m.sql OR cs_latency_1m_extended.sql.
PRO 6. For an interval of N seconds use cs_latency_snapshot.sql or cs_latency_snapshot_extended.sql.
PRO
csierra/cs_internal/cs_latency_internal_query_1.sql
+480
View File
@@ -0,0 +1,480 @@
-- cs_latency_internal_query_1.sql: called by cs_latency.sql and cs_latency_extended.sql
PRO
PRO TOP active SQL as per DB Latency (and DB Load) v$sqlstats as per last &&cs_last_snap_mins. minutes
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
WITH
FUNCTION /* cs_latency_internal_query_1 */ application_category (
p_sql_text IN VARCHAR2,
p_command_name IN VARCHAR2 DEFAULT NULL
)
RETURN VARCHAR2
IS
k_appl_handle_prefix CONSTANT VARCHAR2(30) := CHR(37)||'/*'||CHR(37);
k_appl_handle_suffix CONSTANT VARCHAR2(30) := CHR(37)||'*/'||CHR(37);
BEGIN
IF p_sql_text LIKE k_appl_handle_prefix||'Transaction Processing'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'addTransactionRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkEndRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkStartRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'exists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch commit by idempotency token'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest transactions for cache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find lower commit id for transaction cache warm up'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'findMatchingRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionCommitID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNewTransactionID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getTransactionProgress'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockForCommit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockKievTransactor'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'putBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readTransactionsSince'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'recordTransactionState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'setValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SPM:CP'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateNextKievTransID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'upsert_transactor_state'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'writeTransactionKeys'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'QueryTransactorHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'WriteBucketValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch commit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch mutation log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetchAllIdentities'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_epoch'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readFromTxorStateBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'legacyGetDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getWithVersionOffsetSql'||k_appl_handle_suffix
OR LOWER(p_sql_text) LIKE CHR(37)||'lock table kievtransactions'||CHR(37)
--
OR p_sql_text LIKE k_appl_handle_prefix||'Set ddl lock timeout for session'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getForUpdate.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Drop partition'||k_appl_handle_suffix
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Read Only'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIndexSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketKeySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketValueSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countTransactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch snapshots'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get system time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAutoSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Lock row Bucket_Snapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'longFromDual'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performContinuedScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performFirstRowsScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSnapshotScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performStartScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest revisions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch max sequence for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Find High value for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find partitions for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Init lock name for snapshot'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'List snapshot tables.'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'Tail read bucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSegmentedScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listArchiveStatusByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listAssignmentsByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateHost'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateArchiveStatus'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateOperationLock'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KIEVWORKFLOWS table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetOldestLsn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetStreamRecords'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if another workflow is running'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete old workflows from'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getPriorWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeaseTypes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getHistoricalAssignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAllWorkflowDefinitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getVersionHistory'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find interval partitions for schema'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getStepInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getOldestGcWorkflowInstance'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextRecordID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseNonce'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getByKey.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRecordId.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if there are active rows for partition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRunningInstancesCount'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLatestWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.step_instances'||k_appl_handle_suffix
THEN RETURN 'RO'; /* Read Only */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Background'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Bootstrap snapshot table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIdentitySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkMissingTables'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKievTransactionRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKtkRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete garbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete rows from'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteBucketGarbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_leader_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventMaxId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventTryInsert'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get txn at time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getCurEndTime'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDBSchemaVersion'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getEndTimeOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getGCLogEntries'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSchemaMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSupportedLibVersions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashSnapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Populate workspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'populateBucketGCWorkspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'primeTxCache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyRoleExists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Row count between transactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'secondsSinceLastGcEvent'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'sync_leadership'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Test if table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Update snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateIfWorkspaceEmpty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'verify_is_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checking existence of Mutation Log Table'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONKEYS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KT'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KTK'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Insert dynamic config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createProxyUser'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createSequence'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deregister_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropAutoSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropBucketFromMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactionKeys table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactions table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get session count'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'initializeMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isKtPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'register_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateSchemaVersionInDB'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorks'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMinorVersionsAtAndAfter'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseDecorators'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeasesByFiFo'||k_appl_handle_suffix
THEN RETURN 'BG'; /* Background */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Ignore'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateKievPdbs'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getJDBCSuffix'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'MV_REFRESH'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'null'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectColumnsForTable'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectDatastoreMd'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SQL Analyze('||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateDataStoreId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countSequenceInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'iod-telemetry'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'OPT_DYN_SAMP'||k_appl_handle_suffix
THEN RETURN 'IG'; /* Ignore */
--
ELSIF p_command_name IN ('INSERT', 'UPDATE')
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_command_name = 'DELETE'
THEN RETURN 'BG'; /* Background */
--
ELSIF p_command_name = 'SELECT'
THEN RETURN 'RO'; /* Read Only */
--
ELSE RETURN 'UN'; /* Unknown */
END IF;
END application_category;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.con_id,
application_category(s.sql_text, /*v.command_name*/ 'UNKNOWN') AS sql_type, -- passing UNKNOWN else KIEV envs would show a lot of unrelated SQL under RO
s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 AS et_ms_per_exec,
s.delta_cpu_time/GREATEST(s.delta_execution_count,1)/1e3 AS cpu_ms_per_exec,
s.delta_user_io_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS io_ms_per_exec,
s.delta_application_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS appl_ms_per_exec,
s.delta_concurrency_time/GREATEST(s.delta_execution_count,1)/1e3 AS conc_ms_per_exec,
s.delta_plsql_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS plsql_ms_per_exec,
s.delta_cluster_wait_time/GREATEST(s.delta_execution_count,1)/1e3 AS cluster_ms_per_exec,
s.delta_java_exec_time/GREATEST(s.delta_execution_count,1)/1e3 AS java_ms_per_exec,
s.delta_elapsed_time/GREATEST(w.age_seconds,1)/1e6 AS et_aas,
s.delta_cpu_time/GREATEST(w.age_seconds,1)/1e6 AS cpu_aas,
s.delta_user_io_wait_time/GREATEST(w.age_seconds,1)/1e6 AS io_aas,
s.delta_application_wait_time/GREATEST(w.age_seconds,1)/1e6 AS appl_aas,
s.delta_concurrency_time/GREATEST(w.age_seconds,1)/1e6 AS conc_aas,
s.delta_plsql_exec_time/GREATEST(w.age_seconds,1)/1e6 AS plsql_aas,
s.delta_cluster_wait_time/GREATEST(w.age_seconds,1)/1e6 AS cluster_aas,
s.delta_java_exec_time/GREATEST(w.age_seconds,1)/1e6 AS java_aas,
s.delta_execution_count AS delta_execution_count,
s.delta_execution_count/GREATEST(w.age_seconds,1) AS execs_per_sec,
s.delta_px_servers_executions/GREATEST(w.age_seconds,1) AS px_execs_per_sec,
s.delta_end_of_fetch_count/GREATEST(w.age_seconds,1) AS end_of_fetch_per_sec,
s.delta_parse_calls/GREATEST(w.age_seconds,1) AS parses_per_sec,
s.delta_invalidations/GREATEST(w.age_seconds,1) AS inval_per_sec,
s.delta_loads/GREATEST(w.age_seconds,1) AS loads_per_sec,
s.delta_buffer_gets/GREATEST(s.delta_execution_count,1) AS gets_per_exec,
s.delta_disk_reads/GREATEST(s.delta_execution_count,1) AS reads_per_exec,
s.delta_direct_reads/GREATEST(s.delta_execution_count,1) AS direct_reads_per_exec,
s.delta_direct_writes/GREATEST(s.delta_execution_count,1) AS direct_writes_per_exec,
s.delta_physical_read_requests/GREATEST(s.delta_execution_count,1) AS phy_read_req_per_exec,
s.delta_physical_read_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_read_mb_per_exec,
s.delta_physical_write_requests/GREATEST(s.delta_execution_count,1) AS phy_write_req_per_exec,
s.delta_physical_write_bytes/GREATEST(s.delta_execution_count,1)/1e6 AS phy_write_mb_per_exec,
s.delta_fetch_count/GREATEST(s.delta_execution_count,1) AS fetches_per_exec,
s.delta_sorts/GREATEST(s.delta_execution_count,1) AS sorts_per_exec,
s.delta_rows_processed,
s.delta_rows_processed/GREATEST(s.delta_execution_count,1) AS rows_per_exec,
s.delta_elapsed_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS et_ms_per_row,
s.delta_cpu_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS cpu_ms_per_row,
s.delta_user_io_wait_time/GREATEST(s.delta_rows_processed,s.delta_execution_count,1)/1e3 AS io_ms_per_row,
s.delta_buffer_gets/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS gets_per_row,
s.delta_disk_reads/GREATEST(s.delta_rows_processed,s.delta_execution_count,1) AS reads_per_row,
s.avg_hard_parse_time,
s.sql_id,
-- s.sql_text,
DBMS_LOB.substr(REGEXP_SUBSTR(s.sql_fulltext, '.*$', 1, 1, 'm'), 1000) AS sql_text,
s.sql_fulltext,
s.plan_hash_value,
s.last_active_child_address
FROM v$sqlstats s,
(SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
((86400 * EXTRACT(DAY FROM (SYSTIMESTAMP - MAX(end_interval_time))) + (3600 * EXTRACT(HOUR FROM (systimestamp - MAX(end_interval_time)))) + (60 * EXTRACT(MINUTE FROM (systimestamp - MAX(end_interval_time)))) + EXTRACT(SECOND FROM (systimestamp - MAX(end_interval_time))))) AS age_seconds
FROM dba_hist_snapshot
WHERE end_interval_time < SYSTIMESTAMP) w
WHERE s.last_active_time > SYSDATE - (1/24/60) -- select only sql that has been active during the last 1 minute
AND s.delta_elapsed_time > 0 -- select only sql that has reported time since las awr
AND s.delta_elapsed_time/GREATEST(w.age_seconds,1)/1e6 /*et_aas*/ >= LEAST(&&cs_aas_threshold_latency., &&cs_aas_threshold_load.) -- select only sql that generates some db load
AND s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 /*et_ms_per_exec*/ >= &&cs_ms_threshold_latency.
AND ROWNUM >= 1 -- materialize
),
sqlstats_extended AS (
SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
s.sql_type,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
s.delta_rows_processed,
s.rows_per_exec,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
s.sql_id,
s.sql_text,
s.sql_fulltext,
s.plan_hash_value,
s.last_active_child_address,
s.con_id,
c.name AS pdb_name,
ROW_NUMBER() OVER (PARTITION BY s.sql_type ORDER BY s.et_ms_per_exec DESC) AS latency_rn, -- top sql as per db latency
ROW_NUMBER() OVER (PARTITION BY s.sql_type ORDER BY s.et_aas DESC) AS load_rn -- top sql as per db load
FROM sqlstats s,
v$containers c
WHERE c.con_id = s.con_id
AND ROWNUM >= 1
)
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
CASE WHEN v.parsing_schema_name = 'SYS' THEN 'SYS' ELSE s.sql_type END AS sql_type,
s.latency_rn,
s.load_rn,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'|' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'|' AS sep2,
s.delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
'|' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'|' AS sep4,
s.delta_rows_processed,
s.rows_per_exec,
'|' AS sep5,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'|' AS sep6,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN s.sql_fulltext LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(s.sql_fulltext, '\[([[:digit:]]{4})\] ') ELSE s.sql_fulltext END),100000),5,'0') AS sqlid,
get_sql_hv(s.sql_fulltext) AS sqlid,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
CASE '&&cs_con_name.' WHEN 'CDB$ROOT' THEN s.pdb_name ELSE v.parsing_schema_name END AS pdb_or_parsing_schema_name,
t.num_rows,
t.blocks
FROM sqlstats_extended s
OUTER APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch,
v.parsing_schema_name,
v.hash_value,
v.address
FROM v$sql v
WHERE v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
AND v.child_address = s.last_active_child_address
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
OUTER APPLY ( -- only works when executed within a PDB
SELECT t.num_rows, t.blocks
FROM v$object_dependency d, dba_users u, dba_tables t
WHERE d.from_hash = v.hash_value
AND d.from_address = v.address
AND d.to_type = 2 -- table
AND d.to_owner <> 'SYS'
AND d.con_id = s.con_id
AND u.username = d.to_owner
AND u.oracle_maintained = 'N'
AND u.common = 'NO'
AND t.owner = d.to_owner
AND t.table_name = d.to_name
ORDER BY
t.num_rows DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) t
WHERE 1 = 1
AND ((s.latency_rn <= &&cs_top_latency. AND s.et_aas >= &&cs_aas_threshold_latency.) OR (s.load_rn <= &&cs_top_load. AND s.et_aas >= &&cs_aas_threshold_load.))
AND s.et_ms_per_exec >= &&cs_ms_threshold_latency.
ORDER BY
CASE WHEN v.parsing_schema_name = 'SYS' THEN 6 WHEN s.sql_type = 'TP' THEN 1 WHEN s.sql_type = 'RO' THEN 2 WHEN s.sql_type = 'BG' THEN 3 WHEN s.sql_type = 'UN' THEN 4 WHEN s.sql_type = 'IG' THEN 5 ELSE 9 END,
-- s.latency_rn
s.et_ms_per_exec DESC
/
csierra/cs_internal/cs_latency_internal_query_4.sql
+576
View File
@@ -0,0 +1,576 @@
-- cs_latency_internal_query_4.sql: called by cs_latency_range.sql and cs_latency_range_extended.sql
PRO
PRO TOP active SQL as per DB Latency (and DB Load) dba_hist_sqlstat between &&cs_begin_date_from. and &&cs_end_date_to. (&&cs_begin_end_seconds seconds)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_latency_internal_query_4 */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION application_category (
p_sql_text IN VARCHAR2,
p_command_name IN VARCHAR2 DEFAULT NULL
)
RETURN VARCHAR2
IS
k_appl_handle_prefix CONSTANT VARCHAR2(30) := CHR(37)||'/*'||CHR(37);
k_appl_handle_suffix CONSTANT VARCHAR2(30) := CHR(37)||'*/'||CHR(37);
BEGIN
IF p_sql_text LIKE k_appl_handle_prefix||'Transaction Processing'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'addTransactionRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkEndRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkStartRowValid'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'exists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch commit by idempotency token'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest transactions for cache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find lower commit id for transaction cache warm up'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'findMatchingRow'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionCommitID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNewTransactionID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getTransactionProgress'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockForCommit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'lockKievTransactor'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'putBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readTransactionsSince'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'recordTransactionState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'setValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SPM:CP'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateNextKievTransID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'upsert_transactor_state'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'writeTransactionKeys'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'QueryTransactorHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'WriteBucketValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch commit'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'batch mutation log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetchAllIdentities'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_epoch'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readFromTxorStateBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyBeginTxn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateTransactorState'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'legacyGetDataStoreMaxTransaction'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getWithVersionOffsetSql'||k_appl_handle_suffix
OR LOWER(p_sql_text) LIKE CHR(37)||'lock table kievtransactions'||CHR(37)
--
OR p_sql_text LIKE k_appl_handle_prefix||'Set ddl lock timeout for session'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'delete.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getForUpdate.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert.step_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Drop partition'||k_appl_handle_suffix
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Read Only'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIndexSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketKeySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketValueSelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countTransactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch snapshots'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get system time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAutoSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextIdentityValue'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Lock row Bucket_Snapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'longFromDual'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performContinuedScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performFirstRowsScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSnapshotScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performStartScanValues'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch latest revisions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch max sequence for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for'||k_appl_handle_suffix -- streaming
OR p_sql_text LIKE k_appl_handle_prefix||'Find High value for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find partitions for'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Init lock name for snapshot'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'List snapshot tables.'||k_appl_handle_suffix -- snapshot
OR p_sql_text LIKE k_appl_handle_prefix||'Tail read bucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'performSegmentedScanQuery'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listArchiveStatusByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listAssignmentsByIndexName'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'listHosts'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateHost'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateArchiveStatus'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateOperationLock'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KIEVWORKFLOWS table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetOldestLsn'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'GetStreamRecords'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if another workflow is running'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete old workflows from'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getPriorWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateLeaseTypes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getHistoricalAssignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getAllWorkflowDefinitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getVersionHistory'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Find interval partitions for schema'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getStepInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getOldestGcWorkflowInstance'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getNextRecordID'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.dataplane_alias'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseNonce'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases_types'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.leases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getByKey.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRecordId.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.historical_assignments'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitionDropDisabled'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Check if there are active rows for partition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getRunningInstancesCount'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_definitions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLatestWorkflowDefinition'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLast.step_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.workflow_instances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get.step_instances'||k_appl_handle_suffix
THEN RETURN 'RO'; /* Read Only */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Background'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Bootstrap snapshot table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'bucketIdentitySelect'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'checkMissingTables'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllBuckets'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countAllRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKievTransactionRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countKtkRows'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete garbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Delete rows from'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deleteBucketGarbage'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateSequences'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'fetch_leader_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventMaxId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'gcEventTryInsert'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Get txn at time'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getCurEndTime'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getDBSchemaVersion'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getEndTimeOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getGCLogEntries'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMaxTransactionOlderThan'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSchemaMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getSupportedLibVersions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashBucket'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'hashSnapshot'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Populate workspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'populateBucketGCWorkspace'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'primeTxCache'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'readOnlyRoleExists'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Row count between transactions'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'secondsSinceLastGcEvent'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'sync_leadership'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Test if table Kiev_S'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Update snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'update_heartbeat'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateIfWorkspaceEmpty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'verify_is_leader'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checking existence of Mutation Log Table'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONKEYS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Checks if KIEVTRANSACTIONS table is empty'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KT'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Fetch partition interval for KTK'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'Insert dynamic config'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createProxyUser'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'createSequence'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'deregister_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropAutoSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropBucketFromMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'dropSequenceMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactionKeys table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get KievTransactions table indexes'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'get session count'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'initializeMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isKtPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'isPartitioned'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'log'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'register_host'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'updateSchemaVersionInDB'||k_appl_handle_suffix
--
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeases'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getFutureWorks'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getMinorVersionsAtAndAfter'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getLeaseDecorators'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getUnownedLeasesByFiFo'||k_appl_handle_suffix
THEN RETURN 'BG'; /* Background */
--
ELSIF p_sql_text LIKE k_appl_handle_prefix||'Ignore'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'enumerateKievPdbs'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'getJDBCSuffix'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'MV_REFRESH'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'null'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectColumnsForTable'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'selectDatastoreMd'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'SQL Analyze('||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'validateDataStoreId'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countMetadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'countSequenceInstances'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'iod-telemetry'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'insert snapshot metadata'||k_appl_handle_suffix
OR p_sql_text LIKE k_appl_handle_prefix||'OPT_DYN_SAMP'||k_appl_handle_suffix
THEN RETURN 'IG'; /* Ignore */
--
ELSIF p_command_name IN ('INSERT', 'UPDATE')
THEN RETURN 'TP'; /* Transaction Processing */
--
ELSIF p_command_name = 'DELETE'
THEN RETURN 'BG'; /* Background */
--
ELSIF p_command_name = 'SELECT'
THEN RETURN 'RO'; /* Read Only */
--
ELSE RETURN 'UN'; /* Unknown */
END IF;
END application_category;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqltext_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqltext_mv) */
dbid,
con_id,
sql_id,
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN sql_text LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(sql_text, '\[([[:digit:]]{4})\] ') ELSE sql_text END),100000),5,'0') AS sqlid,
get_sql_hv(sql_text) AS sqlid,
application_category(DBMS_LOB.substr(sql_text, 1000), 'UNKNOWN') AS sql_type, -- passing UNKNOWN else KIEV envs would show a lot of unrelated SQL under RO
-- REPLACE(REPLACE(DBMS_LOB.substr(sql_text, 1000), CHR(10), CHR(32)), CHR(9), CHR(32)) AS sql_text,
DBMS_LOB.substr(REGEXP_SUBSTR(sql_text, '.*$', 1, 1, 'm'), 1000) AS sql_text,
sql_text AS sql_fulltext
FROM dba_hist_sqltext
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND ROWNUM >= 1
),
/****************************************************************************************/
snapshot_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(snapshot_mv) */
s.*
FROM dba_hist_snapshot s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.end_interval_time >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND s.end_interval_time <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_mv AS (
SELECT /*+ MATERIALIZE NO_MERGE QB_NAME(sqlstats_mv) */
s.*
FROM dba_hist_sqlstat s
WHERE s.dbid = TO_NUMBER('&&cs_dbid.')
AND s.instance_number = TO_NUMBER('&&cs_instance_number.')
AND s.snap_id BETWEEN TO_NUMBER('&&cs_snap_id_from.') AND TO_NUMBER('&&cs_snap_id_to.') + 1
AND s.optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND ROWNUM >= 1
),
/****************************************************************************************/
sqlstats_deltas AS (
SELECT /*+ MATERIALIZE(@sqltext_mv) MATERIALIZE(@snapshot_mv) MATERIALIZE(@sqlstats_mv) NO_MERGE(@sqltext_mv) NO_MERGE(@snapshot_mv) NO_MERGE(@sqlstats_mv) ORDERED */
t.begin_interval_time AS begin_timestamp,
t.end_interval_time AS end_timestamp,
(86400 * EXTRACT(DAY FROM (t.end_interval_time - t.begin_interval_time))) + (3600 * EXTRACT(HOUR FROM (t.end_interval_time - t.begin_interval_time))) + (60 * EXTRACT(MINUTE FROM (t.end_interval_time - t.begin_interval_time))) + EXTRACT(SECOND FROM (t.end_interval_time - t.begin_interval_time)) AS seconds,
s.instance_number,
s.parsing_schema_name,
s.module,
s.action,
s.sql_profile,
s.optimizer_cost,
s.con_id,
s.sql_id,
-- s.force_matching_signature,
s.plan_hash_value,
CASE s.parsing_schema_name WHEN 'SYS' THEN 'SYS' ELSE x.sql_type END AS sql_type,
x.sqlid,
x.sql_text,
x.sql_fulltext,
GREATEST(s.executions_delta, 0) AS delta_execution_count,
GREATEST(s.elapsed_time_delta, 0) AS delta_elapsed_time,
GREATEST(s.cpu_time_delta, 0) AS delta_cpu_time,
GREATEST(s.iowait_delta, 0) AS delta_user_io_wait_time,
GREATEST(s.apwait_delta, 0) AS delta_application_wait_time,
GREATEST(s.ccwait_delta, 0) AS delta_concurrency_time,
GREATEST(s.plsexec_time_delta, 0) AS delta_plsql_exec_time,
GREATEST(s.clwait_delta, 0) AS delta_cluster_wait_time,
GREATEST(s.javexec_time_delta, 0) AS delta_java_exec_time,
GREATEST(s.px_servers_execs_delta, 0) AS delta_px_servers_executions,
GREATEST(s.end_of_fetch_count_delta, 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls_delta, 0) AS delta_parse_calls,
GREATEST(s.invalidations_delta, 0) AS delta_invalidations,
GREATEST(s.loads_delta, 0) AS delta_loads,
GREATEST(s.buffer_gets_delta, 0) AS delta_buffer_gets,
GREATEST(s.disk_reads_delta, 0) AS delta_disk_reads,
GREATEST(s.direct_writes_delta, 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests_delta, 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes_delta, 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests_delta, 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes_delta, 0) AS delta_physical_write_bytes,
GREATEST(s.fetches_delta, 0) AS delta_fetch_count,
GREATEST(s.sorts_delta, 0) AS delta_sorts,
GREATEST(s.rows_processed_delta, 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes_delta, 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_offload_elig_bytes_delta, 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.cell_uncompressed_bytes_delta, 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_offload_return_bytes_delta, 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.obsolete_count
FROM snapshot_mv t,
sqlstats_mv s,
sqltext_mv x
WHERE s.snap_id = t.snap_id
AND s.dbid = t.dbid
AND s.instance_number = t.instance_number
AND x.dbid = s.dbid
AND x.sql_id = s.sql_id
AND x.con_id = s.con_id
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count) AS delta_execution_count2,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
ROW_NUMBER() OVER (PARTITION BY d.sql_type ORDER BY SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 /*et_ms_per_exec*/ DESC NULLS LAST) AS latency_rn, -- top sql as per db latency
ROW_NUMBER() OVER (PARTITION BY d.sql_type ORDER BY SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 /*et_aas*/ DESC NULLS LAST) AS load_rn, -- top sql as per db load
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_elapsed_time) AS delta_elapsed_time,
SUM(d.delta_cpu_time) AS delta_cpu_time,
SUM(d.delta_user_io_wait_time) AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time) AS delta_application_wait_time,
SUM(d.delta_concurrency_time) AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time) AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time) AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time) AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes) AS delta_physical_read_bytes,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes) AS delta_physical_write_bytes,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes) AS delta_io_interconnect_bytes,
SUM(d.delta_cell_offload_elig_bytes) AS delta_cell_offload_elig_bytes,
SUM(d.delta_cell_uncompressed_bytes) AS delta_cell_uncompressed_bytes,
SUM(d.delta_cell_offload_retrn_bytes) AS delta_cell_offload_retrn_bytes,
SUM(d.version_count) AS version_count,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
SUM(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
GROUP BY
d.con_id,
d.sqlid,
d.sql_id,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
d.parsing_schema_name,
d.module,
-- d.action,
d.plan_hash_value,
d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
s.sql_type,
s.latency_rn,
s.load_rn,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'|' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'|' AS sep2,
s.delta_execution_count2 AS delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.inval_per_sec,
s.loads_per_sec,
'|' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'|' AS sep4,
s.delta_rows_processed,
s.rows_per_exec,
'|' AS sep5,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'|' AS sep6,
s.sqlid,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE s.parsing_schema_name END AS pdb_or_parsing_schema_name,
t.num_rows,
t.blocks,
s.begin_timestamp,
s.end_timestamp,
s.seconds
FROM sqlstats_metrics s
OUTER APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch,
v.hash_value,
v.address
FROM v$sql v
WHERE v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
OUTER APPLY ( -- only works when executed within a PDB
SELECT t.num_rows, t.blocks
FROM v$object_dependency d, dba_users u, dba_tables t
WHERE d.from_hash = v.hash_value
AND d.from_address = v.address
AND d.to_type = 2 -- table
AND d.to_owner <> 'SYS'
AND d.con_id = s.con_id
AND u.username = d.to_owner
AND u.oracle_maintained = 'N'
AND u.common = 'NO'
AND t.owner = d.to_owner
AND t.table_name = d.to_name
ORDER BY
t.num_rows DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) t
WHERE ((s.latency_rn <= &&cs_top_latency. AND s.et_aas >= &&cs_aas_threshold_latency.) OR (s.load_rn <= &&cs_top_load. AND s.et_aas >= &&cs_aas_threshold_load.))
AND s.et_ms_per_exec >= &&cs_ms_threshold_latency.
ORDER BY
CASE s.sql_type WHEN 'TP' THEN 1 WHEN 'RO' THEN 2 WHEN 'BG' THEN 3 WHEN 'UN' THEN 4 WHEN 'IG' THEN 5 WHEN 'SYS' THEN 6 ELSE 9 END,
s.et_ms_per_exec DESC
/
csierra/cs_internal/cs_latency_internal_query_5.sql
+302
View File
@@ -0,0 +1,302 @@
-- cs_latency_internal_query_5.sql: called by cs_latency_range_iod.sql, cs_latency_range_iod_extended.sql, cs_latency_snapshot.sql, cs_latency_snapshot_extended.sql
PRO
PRO TOP active SQL as per DB Latency (and DB Load) &&cs_tools_schema..iod_sqlstats_t
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/****************************************************************************************/
WITH
FUNCTION /* cs_latency_internal_query_5 */ get_pdb_name (p_con_id IN VARCHAR2)
RETURN VARCHAR2
IS
l_pdb_name VARCHAR2(4000);
BEGIN
SELECT name
INTO l_pdb_name
FROM v$containers
WHERE con_id = TO_NUMBER(p_con_id);
--
RETURN l_pdb_name;
END get_pdb_name;
/****************************************************************************************/
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
/****************************************************************************************/
sqlstats_deltas AS (
SELECT LAG(s.snap_timestamp) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp) AS begin_timestamp,
s.snap_timestamp AS end_timestamp,
(86400 * EXTRACT(DAY FROM (s.snap_timestamp - LAG(s.snap_timestamp) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp)))) + (3600 * EXTRACT(HOUR FROM (s.snap_timestamp - LAG(s.snap_timestamp) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp)))) + (60 * EXTRACT(MINUTE FROM (s.snap_timestamp - LAG(s.snap_timestamp) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp)))) + EXTRACT(SECOND FROM (s.snap_timestamp - LAG(s.snap_timestamp) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp))) AS seconds,
s.con_id,
s.sql_id,
-- s.exact_matching_signature,
-- s.force_matching_signature,
s.plan_hash_value,
&&cs_tools_schema..iod_spm.application_category(s.sql_text, 'UNKNOWN') AS sql_type, -- passing UNKNOWN else KIEV envs would show a lot of unrelated SQL under RO
-- LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(CASE WHEN s.sql_fulltext LIKE '/* %(%,%)% [____] */%' THEN REGEXP_REPLACE(s.sql_fulltext, '\[([[:digit:]]{4})\] ') ELSE s.sql_fulltext END),100000),5,'0') AS sqlid,
get_sql_hv(s.sql_fulltext) AS sqlid,
-- s.sql_text,
DBMS_LOB.substr(REGEXP_SUBSTR(s.sql_fulltext, '.*$', 1, 1, 'm'), 1000) AS sql_text,
s.sql_fulltext,
GREATEST(s.executions - LAG(s.executions) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_execution_count,
GREATEST(s.elapsed_time - LAG(s.elapsed_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_elapsed_time,
GREATEST(s.cpu_time - LAG(s.cpu_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_cpu_time,
GREATEST(s.user_io_wait_time - LAG(s.user_io_wait_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_user_io_wait_time,
GREATEST(s.application_wait_time - LAG(s.application_wait_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_application_wait_time,
GREATEST(s.concurrency_wait_time - LAG(s.concurrency_wait_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_concurrency_time,
GREATEST(s.plsql_exec_time - LAG(s.plsql_exec_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_plsql_exec_time,
GREATEST(s.cluster_wait_time - LAG(s.cluster_wait_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_cluster_wait_time,
GREATEST(s.java_exec_time - LAG(s.java_exec_time) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_java_exec_time,
GREATEST(s.px_servers_executions - LAG(s.px_servers_executions) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_px_servers_executions,
GREATEST(s.avoided_executions - LAG(s.avoided_executions) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_avoided_executions,
GREATEST(s.end_of_fetch_count - LAG(s.end_of_fetch_count) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_end_of_fetch_count,
GREATEST(s.parse_calls - LAG(s.parse_calls) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_parse_calls,
GREATEST(s.invalidations - LAG(s.invalidations) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_invalidations,
GREATEST(s.loads - LAG(s.loads) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_loads,
GREATEST(s.buffer_gets - LAG(s.buffer_gets) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_buffer_gets,
GREATEST(s.disk_reads - LAG(s.disk_reads) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_disk_reads,
GREATEST(s.direct_reads - LAG(s.direct_reads) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_direct_reads,
GREATEST(s.direct_writes - LAG(s.direct_writes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_direct_writes,
GREATEST(s.physical_read_requests - LAG(s.physical_read_requests) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_physical_read_requests,
GREATEST(s.physical_read_bytes - LAG(s.physical_read_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_physical_read_bytes,
GREATEST(s.physical_write_requests - LAG(s.physical_write_requests) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_physical_write_requests,
GREATEST(s.physical_write_bytes - LAG(s.physical_write_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_physical_write_bytes,
GREATEST(s.fetches - LAG(s.fetches) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_fetch_count,
GREATEST(s.sorts - LAG(s.sorts) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_sorts,
GREATEST(s.rows_processed - LAG(s.rows_processed) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_rows_processed,
GREATEST(s.io_interconnect_bytes - LAG(s.io_interconnect_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_io_interconnect_bytes,
GREATEST(s.io_cell_offload_eligible_bytes - LAG(s.io_cell_offload_eligible_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_cell_offload_elig_bytes,
GREATEST(s.io_cell_uncompressed_bytes - LAG(s.io_cell_uncompressed_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_cell_uncompressed_bytes,
GREATEST(s.io_cell_offload_returned_bytes - LAG(s.io_cell_offload_returned_bytes) OVER (PARTITION BY s.snap_type, s.sid, s.con_id, s.sql_id ORDER BY s.snap_timestamp), 0) AS delta_cell_offload_retrn_bytes,
s.version_count,
s.sharable_mem,
s.total_sharable_mem,
s.avg_hard_parse_time,
s.obsolete_count,
s.serializable_aborts,
s.last_active_time
FROM &&cs_tools_schema..iod_sqlstats_t s
WHERE s.snap_timestamp >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.') - INTERVAL '2' MINUTE -- needed by cs_latency_range.sql because of LAG functions above
AND s.snap_timestamp <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.') + INTERVAL '1' SECOND -- needed by cs_latency_snapshot.sql
AND s.snap_type = '&&cs_snap_type.'
AND s.sid = TO_NUMBER('&&cs_sid.')
AND &&cs_filter_2.
),
/****************************************************************************************/
sqlstats_metrics AS (
SELECT MIN(d.begin_timestamp) AS begin_timestamp,
MAX(d.end_timestamp) AS end_timestamp,
SUM(d.seconds) AS seconds,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS et_ms_per_exec,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cpu_ms_per_exec,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS io_ms_per_exec,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS appl_ms_per_exec,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS conc_ms_per_exec,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS plsql_ms_per_exec,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS cluster_ms_per_exec,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 AS java_ms_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 AS et_aas,
SUM(d.delta_cpu_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cpu_aas,
SUM(d.delta_user_io_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS io_aas,
SUM(d.delta_application_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS appl_aas,
SUM(d.delta_concurrency_time)/NULLIF(SUM(d.seconds),0)/1e6 AS conc_aas,
SUM(d.delta_plsql_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS plsql_aas,
SUM(d.delta_cluster_wait_time)/NULLIF(SUM(d.seconds),0)/1e6 AS cluster_aas,
SUM(d.delta_java_exec_time)/NULLIF(SUM(d.seconds),0)/1e6 AS java_aas,
SUM(d.delta_execution_count) AS delta_execution_count,
SUM(d.delta_execution_count)/NULLIF(SUM(d.seconds),0) AS execs_per_sec,
SUM(d.delta_px_servers_executions)/NULLIF(SUM(d.seconds),0) AS px_execs_per_sec,
SUM(d.delta_end_of_fetch_count)/NULLIF(SUM(d.seconds),0) AS end_of_fetch_per_sec,
SUM(d.delta_parse_calls)/NULLIF(SUM(d.seconds),0) AS parses_per_sec,
SUM(d.delta_invalidations)/NULLIF(SUM(d.seconds),0) AS inval_per_sec,
SUM(d.delta_loads)/NULLIF(SUM(d.seconds),0) AS loads_per_sec,
SUM(d.delta_buffer_gets)/NULLIF(SUM(d.delta_execution_count),0) AS gets_per_exec,
SUM(d.delta_disk_reads)/NULLIF(SUM(d.delta_execution_count),0) AS reads_per_exec,
SUM(d.delta_direct_writes)/NULLIF(SUM(d.delta_execution_count),0) AS direct_writes_per_exec,
SUM(d.delta_physical_read_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_read_req_per_exec,
SUM(d.delta_physical_read_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_read_mb_per_exec,
SUM(d.delta_physical_write_requests)/NULLIF(SUM(d.delta_execution_count),0) AS phy_write_req_per_exec,
SUM(d.delta_physical_write_bytes)/NULLIF(SUM(d.delta_execution_count),0)/1e6 AS phy_write_mb_per_exec,
SUM(d.delta_fetch_count)/NULLIF(SUM(d.delta_execution_count),0) AS fetches_per_exec,
SUM(d.delta_sorts)/NULLIF(SUM(d.delta_execution_count),0) AS sorts_per_exec,
SUM(d.delta_rows_processed)/NULLIF(SUM(d.delta_execution_count),0) AS rows_per_exec,
SUM(d.delta_elapsed_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS et_ms_per_row,
SUM(d.delta_cpu_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS cpu_ms_per_row,
SUM(d.delta_user_io_wait_time)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0)/1e3 AS io_ms_per_row,
SUM(d.delta_buffer_gets)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS gets_per_row,
SUM(d.delta_disk_reads)/NULLIF(GREATEST(SUM(d.delta_rows_processed),SUM(d.delta_execution_count)),0) AS reads_per_row,
d.con_id,
d.sqlid,
d.sql_id,
-- d.exact_matching_signature,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
-- d.parsing_schema_name,
-- d.module,
-- d.action,
d.plan_hash_value,
d.sql_type,
d.sql_text,
-- d.sql_fulltext, -- not a GROUP BY column (CLOB)
ROW_NUMBER() OVER (PARTITION BY d.sql_type ORDER BY SUM(d.delta_elapsed_time)/NULLIF(SUM(d.delta_execution_count),0)/1e3 /*et_ms_per_exec*/ DESC NULLS LAST) AS latency_rn, -- top sql as per db latency
ROW_NUMBER() OVER (PARTITION BY d.sql_type ORDER BY SUM(d.delta_elapsed_time)/NULLIF(SUM(d.seconds),0)/1e6 /*et_aas*/ DESC NULLS LAST) AS load_rn, -- top sql as per db load
SUM(d.delta_execution_count) AS delta_execution_count2,
SUM(d.delta_elapsed_time) AS delta_elapsed_time,
SUM(d.delta_cpu_time) AS delta_cpu_time,
SUM(d.delta_user_io_wait_time) AS delta_user_io_wait_time,
SUM(d.delta_application_wait_time) AS delta_application_wait_time,
SUM(d.delta_concurrency_time) AS delta_concurrency_time,
SUM(d.delta_plsql_exec_time) AS delta_plsql_exec_time,
SUM(d.delta_cluster_wait_time) AS delta_cluster_wait_time,
SUM(d.delta_java_exec_time) AS delta_java_exec_time,
SUM(d.delta_px_servers_executions) AS delta_px_servers_executions,
SUM(d.delta_end_of_fetch_count) AS delta_end_of_fetch_count,
SUM(d.delta_parse_calls) AS delta_parse_calls,
SUM(d.delta_invalidations) AS delta_invalidations,
SUM(d.delta_loads) AS delta_loads,
SUM(d.delta_buffer_gets) AS delta_buffer_gets,
SUM(d.delta_disk_reads) AS delta_disk_reads,
SUM(d.delta_direct_writes) AS delta_direct_writes,
SUM(d.delta_physical_read_requests) AS delta_physical_read_requests,
SUM(d.delta_physical_read_bytes) AS delta_physical_read_bytes,
SUM(d.delta_physical_write_requests) AS delta_physical_write_requests,
SUM(d.delta_physical_write_bytes) AS delta_physical_write_bytes,
SUM(d.delta_fetch_count) AS delta_fetch_count,
SUM(d.delta_sorts) AS delta_sorts,
SUM(d.delta_rows_processed) AS delta_rows_processed,
SUM(d.delta_io_interconnect_bytes) AS delta_io_interconnect_bytes,
SUM(d.delta_cell_offload_elig_bytes) AS delta_cell_offload_elig_bytes,
SUM(d.delta_cell_uncompressed_bytes) AS delta_cell_uncompressed_bytes,
SUM(d.delta_cell_offload_retrn_bytes) AS delta_cell_offload_retrn_bytes,
SUM(d.version_count) AS version_count,
AVG(d.avg_hard_parse_time) AS avg_hard_parse_time,
MAX(d.sharable_mem)/1e6 AS sharable_mem_mb,
SUM(d.obsolete_count) AS obsolete_count
FROM sqlstats_deltas d
WHERE d.seconds > 1 -- avoid snaps less than 1 sec appart
AND d.end_timestamp >= TO_TIMESTAMP('&&cs_sample_time_from.', '&&cs_datetime_full_format.') -- needed because of LAG functions on sqlstats_deltas
AND d.end_timestamp <= TO_TIMESTAMP('&&cs_sample_time_to.', '&&cs_datetime_full_format.') + INTERVAL '1' SECOND -- needed by cs_latency_snapshot.sql
GROUP BY
d.con_id,
d.sqlid,
d.sql_id,
-- d.exact_matching_signature,
-- d.force_matching_signature,
-- d.sql_profile,
-- d.instance_number,
-- d.parsing_schema_name,
-- d.module,
-- d.action,
d.plan_hash_value,
d.sql_type,
d.sql_text
)
/****************************************************************************************/
SELECT /*+ MONITOR GATHER_PLAN_STATISTICS */
'!' AS sep0,
CASE WHEN v.parsing_schema_name = 'SYS' THEN 'SYS' ELSE s.sql_type END AS sql_type,
s.latency_rn,
s.load_rn,
s.et_ms_per_exec,
s.cpu_ms_per_exec,
s.io_ms_per_exec,
s.appl_ms_per_exec,
s.conc_ms_per_exec,
s.plsql_ms_per_exec,
s.cluster_ms_per_exec,
s.java_ms_per_exec,
'|' AS sep1,
s.et_aas,
s.cpu_aas,
s.io_aas,
s.appl_aas,
s.conc_aas,
s.plsql_aas,
s.cluster_aas,
s.java_aas,
'|' AS sep2,
s.delta_execution_count2 AS delta_execution_count,
s.execs_per_sec,
s.px_execs_per_sec,
s.end_of_fetch_per_sec,
s.parses_per_sec,
s.avg_hard_parse_time,
s.inval_per_sec,
s.loads_per_sec,
'|' AS sep3,
s.gets_per_exec,
s.reads_per_exec,
-- s.direct_reads_per_exec,
s.direct_writes_per_exec,
s.phy_read_req_per_exec,
s.phy_read_mb_per_exec,
s.phy_write_req_per_exec,
s.phy_write_mb_per_exec,
s.fetches_per_exec,
s.sorts_per_exec,
'|' AS sep4,
s.delta_rows_processed,
s.rows_per_exec,
'|' AS sep5,
s.et_ms_per_row,
s.cpu_ms_per_row,
s.io_ms_per_row,
s.gets_per_row,
s.reads_per_row,
'|' AS sep6,
s.sqlid,
s.sql_id,
s.plan_hash_value,
v.has_baseline,
v.has_profile,
v.has_patch,
s.sql_text,
CASE SYS_CONTEXT('USERENV', 'CON_ID') WHEN '1' THEN get_pdb_name(s.con_id) ELSE v.parsing_schema_name END AS pdb_or_parsing_schema_name,
t.num_rows,
t.blocks,
s.begin_timestamp,
s.end_timestamp,
s.seconds
FROM sqlstats_metrics s
OUTER APPLY (
SELECT CASE WHEN v.sql_plan_baseline IS NULL THEN 'N' ELSE 'Y' END AS has_baseline,
CASE WHEN v.sql_profile IS NULL THEN 'N' ELSE 'Y' END AS has_profile,
CASE WHEN v.sql_patch IS NULL THEN 'N' ELSE 'Y' END AS has_patch,
v.parsing_schema_name,
v.hash_value,
v.address
FROM v$sql v
WHERE v.sql_id = s.sql_id
AND v.con_id = s.con_id
AND v.plan_hash_value = s.plan_hash_value
ORDER BY
v.last_active_time DESC
FETCH FIRST 1 ROW ONLY
) v
OUTER APPLY ( -- only works when executed within a PDB
SELECT t.num_rows, t.blocks
FROM v$object_dependency d, dba_users u, dba_tables t
WHERE d.from_hash = v.hash_value
AND d.from_address = v.address
AND d.to_type = 2 -- table
AND d.to_owner <> 'SYS'
AND d.con_id = s.con_id
AND u.username = d.to_owner
AND u.oracle_maintained = 'N'
AND u.common = 'NO'
AND t.owner = d.to_owner
AND t.table_name = d.to_name
ORDER BY
t.num_rows DESC NULLS LAST
FETCH FIRST 1 ROW ONLY
) t
WHERE ((s.latency_rn <= &&cs_top_latency. AND s.et_aas >= &&cs_aas_threshold_latency.) OR (s.load_rn <= &&cs_top_load. AND s.et_aas >= &&cs_aas_threshold_load.))
AND s.et_ms_per_exec >= &&cs_ms_threshold_latency.
ORDER BY
CASE WHEN v.parsing_schema_name = 'SYS' THEN 6 WHEN s.sql_type = 'TP' THEN 1 WHEN s.sql_type = 'RO' THEN 2 WHEN s.sql_type = 'BG' THEN 3 WHEN s.sql_type = 'UN' THEN 4 WHEN s.sql_type = 'IG' THEN 5 ELSE 9 END,
s.et_ms_per_exec DESC
/
csierra/cs_internal/cs_latency_internal_snapshot.sql
+18
View File
@@ -0,0 +1,18 @@
-- sets the start point of search space
COL cs_sample_time_from NEW_V cs_sample_time_from NOPRI;
SELECT TO_CHAR(SYSDATE, '&&cs_datetime_full_format.') AS cs_sample_time_from FROM DUAL
/
--
VAR cs_time_cs_begin NUMBER;
EXEC :cs_time_cs_begin := DBMS_UTILITY.get_time;
PRO Begin Snapshot... please wait...
EXEC &&cs_tools_schema..iod_sqlstats.snapshot_sqlstats(p_snap_type => '&&cs_snap_type.', p_sid => TO_NUMBER('&&cs_sid.'));
PRO Sleeping &&cs_snapshot_seconds. seconds... please wait...
EXEC DBMS_LOCK.sleep(seconds => &&cs_snapshot_seconds. - LEAST(TRUNC((DBMS_UTILITY.get_time - :cs_time_cs_begin)/100), &&cs_snapshot_seconds.));
PRO End Snapshot... please wait...
EXEC &&cs_tools_schema..iod_sqlstats.snapshot_sqlstats(p_snap_type => '&&cs_snap_type.', p_sid => TO_NUMBER('&&cs_sid.'));
--
-- sets the end point of search space
COL cs_sample_time_to NEW_V cs_sample_time_to NOPRI;
SELECT TO_CHAR(SYSDATE, '&&cs_datetime_full_format.') AS cs_sample_time_to FROM DUAL
/
csierra/cs_internal/cs_list_cbo_hints.sql
+193
View File
@@ -0,0 +1,193 @@
PRO
PRO REFERENCED INDEXES (sqlobj$data)
PRO ~~~~~~~~~~~~~~~~~~
COL sql_id FOR A13;
COL signature FOR 99999999999999999999;
COL sql_handle FOR A20;
COL plan_name FOR A30;
COL plan_id FOR 9999999999;
-- COL plan_hash FOR 9999999999;
-- COL plan_hash2 FOR 9999999999;
-- COL plan_hash_full FOR 9999999999;
COL indexed_columns FOR A200;
COL table_owner FOR A30;
COL table_name FOR A30;
COL index_owner FOR A30;
COL index_name FOR A30;
COL sql_text FOR A100 TRUNC;
COL description FOR A100 HEA 'Description' WOR;
COL created FOR A23;
COL last_modified FOR A23;
COL last_executed FOR A23;
COL timestamp FOR A19;
BREAK ON plan_name SKIP PAGE ON plan_id ON description;
--
-- only works from PDB. do not use CONTAINERS(table_name) since it causes ORA-00600: internal error code, arguments: [kkdolci1], [], [], [], [], [], [],
WITH
FUNCTION compute_sql_id (sql_text IN CLOB)
RETURN VARCHAR2 IS
BASE_32 CONSTANT VARCHAR2(32) := '0123456789abcdfghjkmnpqrstuvwxyz';
l_raw_128 RAW(128);
l_hex_32 VARCHAR2(32);
l_low_16 VARCHAR(16);
l_q3 VARCHAR2(8);
l_q4 VARCHAR2(8);
l_low_16_m VARCHAR(16);
l_number NUMBER;
l_idx INTEGER;
l_sql_id VARCHAR2(13);
function_returned_an_error EXCEPTION;
PRAGMA EXCEPTION_INIT(function_returned_an_error, -28817); -- ORA-28817: PL/SQL function returned an error.
BEGIN
l_raw_128 := /* use md5 algorithm on sql_text and produce 128 bit hash */
SYS.DBMS_CRYPTO.hash(TRIM(CHR(0) FROM sql_text)||CHR(0), SYS.DBMS_CRYPTO.hash_md5);
l_hex_32 := RAWTOHEX(l_raw_128); /* 32 hex characters */
l_low_16 := SUBSTR(l_hex_32, 17, 16); /* we only need lower 16 */
l_q3 := SUBSTR(l_low_16, 1, 8); /* 3rd quarter (8 hex characters) */
l_q4 := SUBSTR(l_low_16, 9, 8); /* 4th quarter (8 hex characters) */
/* need to reverse order of each of the 4 pairs of hex characters */
l_q3 := SUBSTR(l_q3, 7, 2)||SUBSTR(l_q3, 5, 2)||SUBSTR(l_q3, 3, 2)||SUBSTR(l_q3, 1, 2);
l_q4 := SUBSTR(l_q4, 7, 2)||SUBSTR(l_q4, 5, 2)||SUBSTR(l_q4, 3, 2)||SUBSTR(l_q4, 1, 2);
/* assembly back lower 16 after reversing order on each quarter */
l_low_16_m := l_q3||l_q4;
/* convert to number */
SELECT TO_NUMBER(l_low_16_m, 'xxxxxxxxxxxxxxxx') INTO l_number FROM DUAL;
/* 13 pieces base-32 (5 bits each) make 65 bits. we do have 64 bits */
FOR i IN 1 .. 13
LOOP
l_idx := TRUNC(l_number / POWER(32, (13 - i))); /* index on BASE_32 */
l_sql_id := l_sql_id||SUBSTR(BASE_32, (l_idx + 1), 1); /* stitch 13 characters */
l_number := l_number - (l_idx * POWER(32, (13 - i))); /* for next piece */
END LOOP;
RETURN l_sql_id;
EXCEPTION
WHEN function_returned_an_error THEN
RETURN 'ORA-28817';
END compute_sql_id;
i AS (
SELECT ic.table_owner, ic.table_name, ic.index_owner, ic.index_name,
LISTAGG('"'||ic.table_name||'"."'||ic.column_name||'"', ' ' ON OVERFLOW TRUNCATE) WITHIN GROUP (ORDER BY ic.column_position) AS indexed_columns
FROM dba_ind_columns ic
GROUP BY
ic.table_owner, ic.table_name, ic.index_owner, ic.index_name
),
b AS (
SELECT p.signature,
t.sql_handle,
o.name AS plan_name,
p.plan_id,
-- TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.comp_data),'/*/info[@type = "plan_hash"]')) AS plan_hash, -- normal plan_hash_value
-- TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.comp_data),'/*/info[@type = "plan_hash_2"]')) AS plan_hash_2, -- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
-- TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.comp_data),'/*/info[@type = "plan_hash_full"]')) AS plan_hash_full, -- adaptive plan (must be different than plan_hash_2 on loaded plans)
DECODE(BITAND(o.flags, 1), 0, 'NO', 'YES') AS enabled,
-- DECODE(BITAND(o.flags, 2), 0, 'NO', 'YES') AS accepted,
-- DECODE(BITAND(o.flags, 4), 0, 'NO', 'YES') AS fixed,
-- DECODE(BITAND(o.flags, 64), 0, 'YES', 'NO') AS reproduced,
-- DECODE(BITAND(o.flags, 128), 0, 'NO', 'YES') AS autopurge,
-- DECODE(BITAND(o.flags, 256), 0, 'NO', 'YES') AS adaptive,
SUBSTR(x.outline_hint, INSTR(x.outline_hint, '(', 1, 2) + 1, INSTR(x.outline_hint, '))') - INSTR(x.outline_hint, '(', 1, 2) - 1) AS indexed_columns,
t.sql_text,
a.description,
a.origin,
a.created,
a.last_modified,
o.last_executed,
TO_DATE(NULL) AS timestamp
FROM sys.sqlobj$data p,
XMLTABLE('outline_data/hint' PASSING XMLTYPE(p.comp_data) COLUMNS outline_hint VARCHAR2(500) PATH '.') x,
sys.sqlobj$ o,
sys.sqlobj$auxdata a,
sys.sql$text t
WHERE p.signature = :cs_signature
AND p.category = 'DEFAULT'
AND p.obj_type = &&cs_obj_type. /* 1:profile, 2:baseline, 3:patch */
AND p.comp_data IS NOT NULL
AND x.outline_hint LIKE 'INDEX%(%(%))'
AND o.signature = p.signature
AND o.category = p.category
AND o.obj_type = p.obj_type
AND o.plan_id = p.plan_id
AND a.signature = o.signature
AND a.category = o.category
AND a.obj_type = o.obj_type
AND a.plan_id = o.plan_id
AND t.signature = a.signature
),
x AS (
SELECT DISTINCT
compute_sql_id(b.sql_text) AS sql_id,
b.sql_handle,
b.plan_name,
b.plan_id,
-- b.plan_hash,
-- b.plan_hash_2,
-- b.plan_hash_full,
b.enabled,
-- b.accepted,
-- b.fixed,
-- b.reproduced,
-- b.autopurge,
-- b.adaptive,
b.indexed_columns,
NVL(i.table_owner, '"missing"') AS table_owner,
NVL(i.table_name, '"missing"') AS table_name,
NVL(i.index_owner, '"missing"') AS index_owner,
NVL(i.index_name, '"missing"') AS index_name,
DBMS_LOB.SUBSTR(b.sql_text, 1000) AS sql_text,
b.description,
b.created,
b.last_modified,
b.last_executed,
b.timestamp
FROM b, i
WHERE i.indexed_columns(+) = b.indexed_columns
)
SELECT /* comment out unwanted columns */
-- x.sql_id,
-- x.sql_text,
-- x.sql_handle,
x.plan_name,
-- x.plan_id,
-- x.plan_hash,
-- x.plan_hash_2,
-- x.plan_hash_full,
x.enabled,
-- x.accepted,
-- x.fixed,
-- x.reproduced,
-- x.autopurge,
-- x.adaptive,
x.indexed_columns,
-- x.table_owner,
-- x.table_name,
x.index_owner,
x.index_name,
-- x.created,
-- x.last_modified,
-- x.last_executed,
-- x.timestamp,
x.description
FROM x
ORDER BY
-- x.sql_id,
x.plan_name,
x.indexed_columns,
x.table_owner,
x.table_name,
x.index_owner,
x.index_name
/
CLEAR BREAK;
PRO
PRO CBO_HINTS (sqlobj$data)
PRO ~~~~~~~~~
COL category FOR A10;
COL outline_hint FOR A300;
BREAK ON category SKIP PAGE;
SELECT d.category, x.outline_hint
FROM sys.sqlobj$data d,
XMLTABLE('/outline_data/hint' PASSING XMLTYPE(d.comp_data) COLUMNS outline_hint VARCHAR2(500) PATH '.') x
WHERE d.obj_type = &&cs_obj_type. /* 1:profile, 2:baseline, 3:patch */
AND d.signature = :cs_signature
/
CLEAR BREAK;
csierra/cs_internal/cs_list_cbo_hints_b.sql
+195
View File
@@ -0,0 +1,195 @@
PRO
PRO REFERENCED INDEXES (sqlobj$plan)
PRO ~~~~~~~~~~~~~~~~~~
COL sql_id FOR A13;
COL signature FOR 99999999999999999999;
COL sql_handle FOR A20;
COL plan_name FOR A30;
COL plan_id FOR 9999999999;
COL plan_hash FOR 9999999999;
COL plan_hash2 FOR 9999999999;
COL plan_hash_full FOR 9999999999;
COL indexed_columns FOR A200;
COL table_owner FOR A30;
COL table_name FOR A30;
COL index_owner FOR A30;
COL index_name FOR A30;
COL sql_text FOR A100 TRUNC;
COL description FOR A100 HEA 'Description' WOR;
COL created FOR A23;
COL last_modified FOR A23;
COL last_executed FOR A23;
COL timestamp FOR A19;
BREAK ON plan_name SKIP PAGE ON plan_id ON description;
--
-- only works from PDB. do not use CONTAINERS(table_name) since it causes ORA-00600: internal error code, arguments: [kkdolci1], [], [], [], [], [], [],
WITH
FUNCTION compute_sql_id (sql_text IN CLOB)
RETURN VARCHAR2 IS
BASE_32 CONSTANT VARCHAR2(32) := '0123456789abcdfghjkmnpqrstuvwxyz';
l_raw_128 RAW(128);
l_hex_32 VARCHAR2(32);
l_low_16 VARCHAR(16);
l_q3 VARCHAR2(8);
l_q4 VARCHAR2(8);
l_low_16_m VARCHAR(16);
l_number NUMBER;
l_idx INTEGER;
l_sql_id VARCHAR2(13);
function_returned_an_error EXCEPTION;
PRAGMA EXCEPTION_INIT(function_returned_an_error, -28817); -- ORA-28817: PL/SQL function returned an error.
BEGIN
l_raw_128 := /* use md5 algorithm on sql_text and produce 128 bit hash */
SYS.DBMS_CRYPTO.hash(TRIM(CHR(0) FROM sql_text)||CHR(0), SYS.DBMS_CRYPTO.hash_md5);
l_hex_32 := RAWTOHEX(l_raw_128); /* 32 hex characters */
l_low_16 := SUBSTR(l_hex_32, 17, 16); /* we only need lower 16 */
l_q3 := SUBSTR(l_low_16, 1, 8); /* 3rd quarter (8 hex characters) */
l_q4 := SUBSTR(l_low_16, 9, 8); /* 4th quarter (8 hex characters) */
/* need to reverse order of each of the 4 pairs of hex characters */
l_q3 := SUBSTR(l_q3, 7, 2)||SUBSTR(l_q3, 5, 2)||SUBSTR(l_q3, 3, 2)||SUBSTR(l_q3, 1, 2);
l_q4 := SUBSTR(l_q4, 7, 2)||SUBSTR(l_q4, 5, 2)||SUBSTR(l_q4, 3, 2)||SUBSTR(l_q4, 1, 2);
/* assembly back lower 16 after reversing order on each quarter */
l_low_16_m := l_q3||l_q4;
/* convert to number */
SELECT TO_NUMBER(l_low_16_m, 'xxxxxxxxxxxxxxxx') INTO l_number FROM DUAL;
/* 13 pieces base-32 (5 bits each) make 65 bits. we do have 64 bits */
FOR i IN 1 .. 13
LOOP
l_idx := TRUNC(l_number / POWER(32, (13 - i))); /* index on BASE_32 */
l_sql_id := l_sql_id||SUBSTR(BASE_32, (l_idx + 1), 1); /* stitch 13 characters */
l_number := l_number - (l_idx * POWER(32, (13 - i))); /* for next piece */
END LOOP;
RETURN l_sql_id;
EXCEPTION
WHEN function_returned_an_error THEN
RETURN 'ORA-28817';
END compute_sql_id;
i AS (
SELECT ic.table_owner, ic.table_name, ic.index_owner, ic.index_name,
LISTAGG('"'||ic.table_name||'"."'||ic.column_name||'"', ' ' ON OVERFLOW TRUNCATE) WITHIN GROUP (ORDER BY ic.column_position) AS indexed_columns
FROM dba_ind_columns ic
GROUP BY
ic.table_owner, ic.table_name, ic.index_owner, ic.index_name
),
b AS (
SELECT p.signature,
t.sql_handle,
o.name AS plan_name,
p.plan_id,
TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash"]')) AS plan_hash, -- normal plan_hash_value
TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash_2"]')) AS plan_hash_2, -- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash_full"]')) AS plan_hash_full, -- adaptive plan (must be different than plan_hash_2 on loaded plans)
DECODE(BITAND(o.flags, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(o.flags, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(o.flags, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(o.flags, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(o.flags, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(o.flags, 256), 0, 'NO', 'YES') AS adaptive,
SUBSTR(x.outline_hint, INSTR(x.outline_hint, '(', 1, 2) + 1, INSTR(x.outline_hint, '))') - INSTR(x.outline_hint, '(', 1, 2) - 1) AS indexed_columns,
t.sql_text,
a.description,
a.origin,
a.created,
a.last_modified,
o.last_executed,
p.timestamp
FROM sys.sqlobj$plan p,
XMLTABLE('other_xml/outline_data/hint' PASSING XMLTYPE(p.other_xml) COLUMNS outline_hint VARCHAR2(500) PATH '.') x,
sys.sqlobj$ o,
sys.sqlobj$auxdata a,
sys.sql$text t
WHERE p.signature = :cs_signature
AND p.category = 'DEFAULT'
AND p.obj_type = &&cs_obj_type. /* 1:profile, 2:baseline, 3:patch */
AND p.other_xml IS NOT NULL
AND x.outline_hint LIKE 'INDEX%(%(%))'
AND o.signature = p.signature
AND o.category = p.category
AND o.obj_type = p.obj_type
AND o.plan_id = p.plan_id
AND a.signature = o.signature
AND a.category = o.category
AND a.obj_type = o.obj_type
AND a.plan_id = o.plan_id
AND t.signature = a.signature
),
x AS (
SELECT DISTINCT
compute_sql_id(b.sql_text) AS sql_id,
b.sql_handle,
b.plan_name,
b.plan_id,
b.plan_hash,
b.plan_hash_2,
b.plan_hash_full,
b.enabled,
b.accepted,
b.fixed,
b.reproduced,
b.autopurge,
b.adaptive,
b.indexed_columns,
NVL(i.table_owner, '"missing"') AS table_owner,
NVL(i.table_name, '"missing"') AS table_name,
NVL(i.index_owner, '"missing"') AS index_owner,
NVL(i.index_name, '"missing"') AS index_name,
DBMS_LOB.SUBSTR(b.sql_text, 1000) AS sql_text,
b.description,
b.created,
b.last_modified,
b.last_executed,
b.timestamp
FROM b, i
WHERE i.indexed_columns(+) = b.indexed_columns
)
SELECT /* comment out unwanted columns */
-- x.sql_id,
-- x.sql_text,
-- x.sql_handle,
x.plan_name,
x.plan_id,
-- x.plan_hash,
-- x.plan_hash_2,
-- x.plan_hash_full,
x.enabled,
x.accepted,
-- x.fixed,
-- x.reproduced,
-- x.autopurge,
-- x.adaptive,
x.indexed_columns,
-- x.table_owner,
-- x.table_name,
x.index_owner,
x.index_name,
-- x.created,
-- x.last_modified,
-- x.last_executed,
-- x.timestamp,
x.description
FROM x
ORDER BY
-- x.sql_id,
x.plan_name,
x.indexed_columns,
x.table_owner,
x.table_name,
x.index_owner,
x.index_name
/
CLEAR BREAK;
PRO
PRO CBO_HINTS (sqlobj$plan)
PRO ~~~~~~~~~
COL plan_id FOR 99999999990;
COL category FOR A10;
COL outline_hint FOR A300;
-- only works from PDB. do not use CONTAINERS(table_name) since it causes ORA-00600: internal error code, arguments: [kkdolci1], [], [], [], [], [], [],
BREAK ON plan_id SKIP PAGE ON category;
SELECT d.plan_id, d.category, x.outline_hint
FROM sys.sqlobj$plan d, XMLTABLE('other_xml/outline_data/hint' PASSING XMLTYPE(d.other_xml) COLUMNS outline_hint VARCHAR2(500) PATH '.') x
WHERE d.obj_type = &&cs_obj_type. /* 1:profile, 2:baseline, 3:patch */
AND d.other_xml IS NOT NULL
AND d.signature = :cs_signature
/
CLEAR BREAK;
csierra/cs_internal/cs_load_per_machine.sql
+48
View File
@@ -0,0 +1,48 @@
COL machine FOR A64 HEA 'Machine (Application Server)';
COL load_percent FOR 990.0 HEA 'Load|Perc%';
BREAK ON REPORT;
COMPUTE SUM LABEL "TOTAL" OF load_percent ON REPORT;
--
PRO
PRO LOAD PER MACHINE (v$active_session_history)
PRO ~~~~~~~~~~~~~~~~
WITH
load AS (
SELECT h.machine,
COUNT(DISTINCT TO_CHAR(sql_exec_start, 'YYYYMMDDHH24MISS')||'.'||TO_CHAR(sql_exec_id)) AS executions
FROM v$active_session_history h
WHERE h.sql_id = '&&cs_sql_id.'
GROUP BY
h.machine
)
SELECT machine,
100 * executions / SUM(executions) OVER () AS load_percent
FROM load
ORDER BY
machine
/
--
PRO
PRO LOAD PER MACHINE 7d (dba_hist_active_sess_history)
PRO ~~~~~~~~~~~~~~~~~~~
WITH
load AS (
SELECT h.machine,
COUNT(DISTINCT TO_CHAR(sql_exec_start, 'YYYYMMDDHH24MISS')||'.'||TO_CHAR(sql_exec_id)) AS executions
FROM dba_hist_active_sess_history h
WHERE h.sql_id = '&&cs_sql_id.'
AND h.dbid = TO_NUMBER('&&cs_dbid.')
AND h.instance_number = TO_NUMBER('&&cs_instance_number.')
AND h.sample_time > SYSDATE - 7
AND h.snap_id >= &&cs_7d_snap_id.
GROUP BY
h.machine
)
SELECT machine,
100 * executions / SUM(executions) OVER () AS load_percent
FROM load
ORDER BY
machine
/
--
CLEAR BREAK COMPUTE;
csierra/cs_internal/cs_lobs_internal.sql
+36
View File
@@ -0,0 +1,36 @@
COL owner FOR A30;
COL table_name FOR A30;
COL tablespace_name FOR A30;
COL column_name FOR A30;
COL segment_name FOR A30;
COL index_name FOR A30;
COL encrypt FOR A8;
COL compression FOR A12;
COL deduplication FOR A14;
COL in_row FOR A7;
COL partitioned FOR A12;
COL securefile FOR A11;
--
SELECT l.owner,
l.table_name,
l.tablespace_name,
l.column_name,
l.segment_name,
l.index_name,
l.cache,
l.encrypt,
l.compression,
l.deduplication,
l.in_row,
l.partitioned,
l.securefile
FROM dba_lobs l
WHERE l.table_name = COALESCE('&&specific_table.', l.table_name)
AND l.owner = COALESCE('&&specific_owner.', l.owner)
ORDER BY
l.owner,
l.table_name,
l.tablespace_name,
l.column_name
/
csierra/cs_internal/cs_locks_internal.sql
+307
View File
@@ -0,0 +1,307 @@
----------------------------------------------------------------------------------------
--
-- File name: cs_locks_internal.sql
--
-- Purpose: Locks Summary and Details
--
-- Author: Carlos Sierra
--
-- Version: 2020/03/19
--
-- Usage: Execute connected to PDB or CDB.
--
-- Example: $ sqlplus / as sysdba
-- SQL> @cs_locks_internal.sql
--
-- Notes: Developed and tested on 12.1.0.2.
--
---------------------------------------------------------------------------------------
--
--SET HEA ON LIN 2490 PAGES 100 TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON TRIM ON TI OFF TIMI OFF LONG 240000 LONGC 2400 NUM 20 SERVEROUT OFF;
--ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD"T"HH24:MI:SS';
--ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD"T"HH24:MI:SS.FF6';
--ALTER SESSION SET STATISTICS_LEVEL = 'ALL';
--ALTER SESSION SET "_px_cdb_view_enabled" = FALSE;
--
COL cs9_current_time NEW_V cs9_current_time FOR A19 NOPRI;
SELECT TO_CHAR(SYSDATE) AS cs9_current_time FROM DUAL;
COL type FOR A4;
COL blocker FOR A16;
COL blockee FOR A16;
COL lmode FOR A15;
COL request FOR A15;
COL seconds_in_wait FOR 999,990 HEA 'SECONDS|IN WAIT';
COL object_name FOR A50 TRUNC;
COL line FOR A100 HEA 'Disconnect Command (just as reference, if needed)'TRUNC;
--
BREAK ON blocker SKIP PAGE ON line;
--
PRO
PRO TX/TM Locks Summary (gv$lock) as of &&cs9_current_time.
PRO ~~~~~~~~~~~~~~~~~~~
SELECT blocker_lock.sid||','||blocker_session.serial#||',@'||blocker_session.inst_id AS blocker,
blocker_lock.type,
blocker_lock.lmode||':'||CASE blocker_lock.lmode WHEN 0 THEN 'none' WHEN 1 THEN 'null (NULL)' WHEN 2 THEN 'row-S (SS)' WHEN 3 THEN 'row-X (SX)' WHEN 4 THEN 'share (S)' WHEN 5 THEN 'S/Row-X (SSX)' WHEN 6 THEN 'exclusive (X)' END AS lmode,
blockee_lock.sid||','||blockee_session.serial#||',@'||blockee_session.inst_id AS blockee,
blockee_lock.request||':'||CASE blockee_lock.request WHEN 0 THEN 'none' WHEN 1 THEN 'null (NULL)' WHEN 2 THEN 'row-S (SS)' WHEN 3 THEN 'row-X (SX)' WHEN 4 THEN 'share (S)' WHEN 5 THEN 'S/Row-X (SSX)' WHEN 6 THEN 'exclusive (X)' END AS request,
blockee_session.seconds_in_wait,
cdb_objects.object_type||' '||cdb_objects.owner||'.'||cdb_objects.object_name AS object_name,
CASE blocker_session.type WHEN 'USER' THEN 'ALTER SYSTEM DISCONNECT SESSION '''||blocker_lock.sid||','||blocker_session.serial#||',@'||blocker_lock.inst_id||''' IMMEDIATE;' END AS line
FROM gv$lock blocker_lock,
gv$lock blockee_lock,
gv$session blocker_session,
gv$session blockee_session,
gv$locked_object locked_object,
cdb_objects
WHERE blocker_lock.block = 1
AND blockee_lock.id1 = blocker_lock.id1
AND blockee_lock.id2 = blocker_lock.id2
AND blockee_lock.request > 0
AND blocker_session.sid = blocker_lock.sid
AND blocker_session.inst_id = blocker_lock.inst_id
AND blockee_session.sid = blockee_lock.sid
AND blockee_session.inst_id = blockee_lock.inst_id
AND blockee_session.blocking_session_status = 'VALID'
AND blocker_session.sid IN (blockee_session.blocking_session, blockee_session.final_blocking_session)
AND locked_object.session_id = blockee_session.sid
AND locked_object.inst_id = blockee_lock.inst_id
AND cdb_objects.object_id = locked_object.object_id
AND cdb_objects.con_id = locked_object.con_id
ORDER BY
blocker_session.seconds_in_wait DESC,
blockee_session.seconds_in_wait DESC
/
--
CLEAR BREAK;
--
SELECT TO_CHAR(SYSDATE) AS cs9_current_time FROM DUAL;
PRO All Locks Details (gv$session) as of &&cs9_current_time.
PRO ~~~~~~~~~~~~~~~~~
PRO
SET SERVEROUT ON;
VAR root_blockers NUMBER;
VAR blockees NUMBER;
DECLARE
l_value_max_length INTEGER := 100;
l_prefix VARCHAR2(4000) := '| | | ';
l_separator VARCHAR2(4000) := '+---+-----------------------------------+------------------------------------------------------+-'||RPAD('-', l_value_max_length, '-')||'-+';
l_separator2 VARCHAR2(4000) := '| L | sid,serial#,@inst_id | source.key(s) | '||RPAD(' value(s)', l_value_max_length, ' ')||' +';
--
PROCEDURE put_line (p_line IN VARCHAR2)
IS
BEGIN
IF p_line = l_prefix THEN
RETURN;
ELSE
DBMS_OUTPUT.put_line(p_line);
END IF;
END put_line;
--
FUNCTION key_value (p_key IN VARCHAR2, p_value IN VARCHAR2)
RETURN VARCHAR2
IS
BEGIN
IF p_value IS NULL THEN
RETURN NULL;
ELSE
RETURN LPAD(SUBSTR(p_key, 1, 52), 52, ' ')||' : '||RPAD(SUBSTR(p_value, 1, l_value_max_length), l_value_max_length, ' ')||' |';
END IF;
END key_value;
--
FUNCTION get_lmode_text (p_lmode IN NUMBER)
RETURN VARCHAR2
IS
BEGIN
IF p_lmode = 0 THEN RETURN 'none';
ELSIF p_lmode = 1 THEN RETURN 'null (NULL)';
ELSIF p_lmode = 2 THEN RETURN 'row-S (SS)';
ELSIF p_lmode = 3 THEN RETURN 'row-X (SX)';
ELSIF p_lmode = 4 THEN RETURN 'share (S)';
ELSIF p_lmode = 5 THEN RETURN 'S/Row-X (SSX)';
ELSIF p_lmode = 6 THEN RETURN 'exclusive (X)';
ELSE RETURN 'unknown (ERROR)';
END IF;
END get_lmode_text;
--
PROCEDURE cs_session (p_inst_id IN NUMBER, p_sid IN NUMBER, p_level IN NUMBER)
IS
l_blocker_or_blockee VARCHAR2(100);
l_session gv$session%ROWTYPE;
l_process gv$process%ROWTYPE;
l_transaction gv$transaction%ROWTYPE;
l_lock gv$lock%ROWTYPE;
l_sql gv$sql%ROWTYPE;
l_containers v$containers%ROWTYPE;
l_procedures dba_procedures%ROWTYPE;
l_objects cdb_objects%ROWTYPE;
BEGIN
IF p_level > 9 THEN
DBMS_OUTPUT.put_line('*** LVL > '||(p_level + 1));
RETURN;
ELSIF p_level = 0 THEN
l_blocker_or_blockee := 'ROOT BLOCKER';
ELSE
l_blocker_or_blockee := 'BLOCKEE';
:blockees := :blockees + 1;
END IF;
--
SELECT * INTO l_session FROM gv$session WHERE inst_id = p_inst_id AND sid = p_sid;
--
put_line(l_separator);
put_line('| '||(p_level + 1)||' |'||LPAD(' ', (2 * p_level) + 1, ' ')||RPAD(p_sid||','||l_session.serial#||',@'||p_inst_id, 15, ' ')||LPAD(' ', 2 * (9 - p_level) + 1, ' ')||'| '||key_value('gv$session.username (role)', l_session.username||' ('||l_blocker_or_blockee||')'));
put_line(l_prefix||key_value('gv$session.type - status', l_session.type||' - '||l_session.status));
--
FOR i IN (SELECT * FROM gv$lock WHERE inst_id = p_inst_id AND sid = p_sid AND type <> 'AE' ORDER BY ctime DESC, block DESC, type DESC, lmode DESC, request DESC)
LOOP
put_line(l_prefix||key_value('gv$lock.ctime block type[lmode][request] id1,id2', i.ctime||' '||i.block||' '||i.type||'['||i.lmode||':'||get_lmode_text(i.lmode)||']['||i.request||':'||get_lmode_text(i.request)||'] '||i.id1||','||i.id2));
END LOOP;
--
FOR i IN (SELECT * FROM gv$locked_object WHERE inst_id = p_inst_id AND session_id = p_sid ORDER BY object_id)
LOOP
BEGIN
SELECT * INTO l_objects FROM cdb_objects WHERE con_id = l_session.con_id AND object_id = i.object_id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_objects := NULL;
END;
put_line(l_prefix||key_value('gv$locked_object.id[lmode]', i.object_id||'['||i.locked_mode||':'||get_lmode_text(i.locked_mode)||'] '||l_objects.object_type||' '||l_objects.owner||'.'||l_objects.object_name));
END LOOP;
--
put_line(l_prefix||key_value('gv$session.machine', l_session.machine));
put_line(l_prefix||key_value('gv$session.program', l_session.program));
--
IF l_session.sql_id IS NOT NULL THEN
BEGIN
SELECT * INTO l_sql FROM gv$sql WHERE inst_id = p_inst_id AND sql_id = l_session.sql_id AND child_number = l_session.sql_child_number ORDER BY last_active_time DESC FETCH FIRST 1 ROW ONLY;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_sql := NULL;
END;
put_line(l_prefix||key_value('gv$session.sql_id,child_number sql_text', l_session.sql_id||','||l_session.sql_child_number||' '||l_sql.sql_text));
put_line(l_prefix||key_value('gv$session.sql_exec_start,exec_id', l_session.sql_exec_start||','||l_session.sql_exec_id));
END IF;
--
IF l_session.prev_sql_id IS NOT NULL THEN
BEGIN
SELECT * INTO l_sql FROM gv$sql WHERE inst_id = p_inst_id AND sql_id = l_session.prev_sql_id AND child_number = l_session.prev_child_number ORDER BY last_active_time DESC FETCH FIRST 1 ROW ONLY;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_sql := NULL;
END;
put_line(l_prefix||key_value('gv$session.prev_sql_id,prev_child_number sql_text', l_session.prev_sql_id||','||l_session.prev_child_number||' '||l_sql.sql_text));
put_line(l_prefix||key_value('gv$session.prev_exec_start,prev_exec_id', l_session.prev_exec_start||','||l_session.prev_exec_id));
END IF;
--
IF l_session.plsql_entry_object_id IS NOT NULL THEN
BEGIN
SELECT * INTO l_procedures FROM dba_procedures WHERE object_id = l_session.plsql_entry_object_id AND subprogram_id = l_session.plsql_entry_subprogram_id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_procedures := NULL;
END;
put_line(l_prefix||key_value('gv$session.plsql_entry_subprogram_id,plsql_entry_subprogram_id', l_session.plsql_entry_object_id||','||l_session.plsql_entry_subprogram_id||' ('||l_procedures.object_type||' '||l_procedures.owner||'.'||l_procedures.object_name||' '||l_procedures.procedure_name||')'));
END IF;
--
IF l_session.plsql_object_id IS NOT NULL THEN
BEGIN
SELECT * INTO l_procedures FROM dba_procedures WHERE object_id = l_session.plsql_object_id AND subprogram_id = l_session.plsql_subprogram_id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_procedures := NULL;
END;
put_line(l_prefix||key_value('gv$session.plsql_object_id,plsql_subprogram_id', l_session.plsql_object_id||','||l_session.plsql_subprogram_id||' ('||l_procedures.object_type||' '||l_procedures.owner||'.'||l_procedures.object_name||' '||l_procedures.procedure_name||')'));
END IF;
--
IF l_session.module||l_session.action IS NOT NULL THEN
put_line(l_prefix||key_value('gv$session.module - action', l_session.module||' - '||l_session.action));
END IF;
put_line(l_prefix||key_value('gv$session.client_info', l_session.client_info));
put_line(l_prefix||key_value('gv$session.client_identifier', l_session.client_identifier));
--
IF l_session.row_wait_obj# <> -1 THEN
BEGIN
SELECT * INTO l_objects FROM cdb_objects WHERE con_id = l_session.con_id AND object_id = l_session.row_wait_obj#;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_objects := NULL;
END;
put_line(l_prefix||key_value('gv$session.row_wait_obj#,file#,block#,row# object', l_session.row_wait_obj#||','||l_session.row_wait_file#||','||l_session.row_wait_block#||','||l_session.row_wait_row#||' '||l_objects.object_type||' '||l_objects.owner||'.'||l_objects.object_name));
END IF;
--
IF l_session.blocking_session_status = 'VALID' THEN
put_line(l_prefix||key_value('gv$session.blocking_session,@instance (status)', l_session.blocking_session||',@'||l_session.blocking_instance||' ('||l_session.blocking_session_status||') BLOCKER'));
END IF;
IF l_session.final_blocking_session_status = 'VALID' THEN
put_line(l_prefix||key_value('gv$session.final_blocking_session,@instance (status)', l_session.final_blocking_session||',@'||l_session.final_blocking_instance||' ('||l_session.final_blocking_session_status||') ROOT BLOCKER'));
END IF;
--
put_line(l_prefix||key_value('gv$session.state - wait_class - event', l_session.state||' - '||l_session.wait_class||' - '||l_session.event));
--
IF l_session.p1text <> '0' THEN
put_line(l_prefix||key_value('gv$session.p1text:p1', l_session.p1text||':'||l_session.p1));
END IF;
IF l_session.p2text <> '0' THEN
put_line(l_prefix||key_value('gv$session.p2text:p2', l_session.p2text||':'||l_session.p2));
END IF;
IF l_session.p3text <> '0' THEN
put_line(l_prefix||key_value('gv$session.p3text:p3', l_session.p3text||':'||l_session.p3));
END IF;
--
put_line(l_prefix||key_value('gv$session.logon_time (last_call_et)', l_session.logon_time||' ('||l_session.last_call_et||')'));
put_line(l_prefix||key_value('gv$session.wait_time_micro,wait_time,seconds_in_wait', l_session.wait_time_micro||','||l_session.wait_time||','||l_session.seconds_in_wait));
--
BEGIN
SELECT * INTO l_containers FROM v$containers WHERE con_id = l_session.con_id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_containers := NULL;
END;
--
put_line(l_prefix||key_value('v$containers.name(con_id)', l_containers.name||'('||l_session.con_id||')'));
--
IF l_session.paddr IS NOT NULL THEN
BEGIN
SELECT * INTO l_process FROM gv$process WHERE inst_id = p_inst_id AND addr = l_session.paddr;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_process := NULL;
END;
put_line(l_prefix||key_value('gv$process.spid', l_process.spid||' (paddr:'||l_session.paddr||')'));
END IF;
--
IF l_session.taddr IS NOT NULL THEN
BEGIN
SELECT * INTO l_transaction FROM gv$transaction WHERE inst_id = p_inst_id AND addr = l_session.taddr AND ses_addr = l_session.saddr;
EXCEPTION
WHEN NO_DATA_FOUND THEN
l_transaction := NULL;
END;
put_line(l_prefix||key_value('gv$transaction.start_time', l_transaction.start_time||' (taddr:'||l_session.taddr||')'));
END IF;
--
FOR i IN (SELECT inst_id, sid FROM gv$session WHERE blocking_session_status = 'VALID' AND blocking_instance = p_inst_id AND blocking_session = p_sid ORDER BY wait_time_micro DESC, inst_id, sid)
LOOP
cs_session(i.inst_id, i.sid, p_level + 1);
END LOOP;
EXCEPTION
WHEN NO_DATA_FOUND THEN
NULL;
END cs_session;
--
BEGIN
:root_blockers := 0;
:blockees := 0;
FOR i IN (SELECT MAX(wait_time_micro) AS max_wait_time_micro, final_blocking_instance, final_blocking_session FROM gv$session WHERE final_blocking_session_status = 'VALID' GROUP BY final_blocking_instance, final_blocking_session ORDER BY 1 DESC)
LOOP
:root_blockers := :root_blockers + 1;
put_line(l_separator);
put_line(l_separator2);
cs_session(i.final_blocking_instance, i.final_blocking_session, 0);
END LOOP;
IF :root_blockers > 0 THEN
put_line(l_separator);
END IF;
END;
/
SET SERVEROUT OFF;
--
csierra/cs_internal/cs_locks_mon_internal.sql
+1
View File
@@ -0,0 +1 @@
@@cs_locks_internal.sql
csierra/cs_internal/cs_max_ash_analytics_footer.sql
+15
View File
@@ -0,0 +1,15 @@
PRO <pre>
PRO #01 &&active_sessions_01. &&series_01.
PRO #02 &&active_sessions_02. &&series_02.
PRO #03 &&active_sessions_03. &&series_03.
PRO #04 &&active_sessions_04. &&series_04.
PRO #05 &&active_sessions_05. &&series_05.
PRO #06 &&active_sessions_06. &&series_06.
PRO #07 &&active_sessions_07. &&series_07.
PRO #08 &&active_sessions_08. &&series_08.
PRO #09 &&active_sessions_09. &&series_09.
PRO #10 &&active_sessions_10. &&series_10.
PRO #11 &&active_sessions_11. &&series_11.
PRO #12 &&active_sessions_12. &&series_12.
PRO #13 &&active_sessions_13. &&series_13.
PRO </pre>
csierra/cs_internal/cs_null.sql
View File
csierra/cs_internal/cs_oem_me_sqlperf.sql
+269
View File
@@ -0,0 +1,269 @@
@@&&cs_set_container_to_cdb_root.
--
COL uom FOR A6;
COL value FOR 999,999,990.0;
COL threshold_violation_factor FOR 999,990.0 HEA 'VIOLATION|FACTOR';
COL message FOR A200 TRUNC;
--
PRO
PRO HC SQL - ALERTS for past &&cs_me_days. days (&&cs_stgtab_owner..alerts_hist)
PRO ~~~~~~~~~~~~~~~
--
SELECT snap_time AS alert_time,
alert_type||CASE WHEN severity IS NOT NULL THEN ' ['||severity||'] ' END||key_value AS message,
threshold_violation_factor
FROM &&cs_stgtab_owner..alerts_hist
WHERE '&&cs_con_name.' IN (pdb_name, 'CDB$ROOT')
AND sql_id = '&&cs_sql_id.'
AND snap_time > SYSDATE - &&cs_me_days.
ORDER BY
alert_time,
alert_type
/
--
COL sql_exec_start FOR A19;
COL sql_exec_id FOR 99999999999;
COL sql_plan_hash_value FOR 9999999999 HEA 'PLAN|HASH_VALUE';
COL sql_plan_line_id FOR 99999 HEA 'PLAN|LINE';
COL last_update_time FOR A19;
COL elapsed_seconds FOR 999,990 HEA 'ELAPSED|SECONDS';
COL sid FOR 99999;
COL serial# FOR 9999999;
COL elapsed_seconds_threshold FOR 999,990 HEA 'SECONDS|THRESHOLD';
COL times_threshold FOR 999,990.0 HEA 'ELAPSED|FACTOR';
COL pdb_name FOR A30 TRUNC;
COL source FOR A6;
COL top FOR 990;
--
PRO
PRO HC SQL - LONG EXECUTIONS top &&cs_me_top. and last &&cs_me_last. for past &&cs_me_days. days (&&cs_stgtab_owner..longexecs_hist_v1)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~
--
WITH
snaps AS (
SELECT sql_exec_start,
sql_exec_id,
sql_plan_hash_value,
sql_plan_line_id,
last_update_time,
elapsed_seconds,
elapsed_seconds_threshold,
times_threshold,
source,
pdb_name,
sid,
serial#,
ROW_NUMBER() OVER (ORDER BY sql_exec_start DESC, sql_exec_id DESC, last_update_time DESC) AS rn1,
ROW_NUMBER() OVER (ORDER BY elapsed_seconds DESC, times_threshold DESC) AS rn2,
ROW_NUMBER() OVER (ORDER BY times_threshold DESC, elapsed_seconds DESC) AS rn3
FROM &&cs_stgtab_owner..longexecs_hist_v1
WHERE '&&cs_con_name.' IN (pdb_name, 'CDB$ROOT')
AND sql_id = '&&cs_sql_id.'
AND sql_exec_start > SYSDATE - &&cs_me_days.
)
SELECT sql_exec_start,
CASE WHEN rn2 <= &&cs_me_top. THEN rn2 END AS top,
sql_exec_id,
sql_plan_hash_value,
sql_plan_line_id,
last_update_time,
elapsed_seconds,
elapsed_seconds_threshold,
times_threshold,
source,
pdb_name,
sid,
serial#
FROM snaps
WHERE rn1 <= &&cs_me_last.
OR rn2 <= &&cs_me_top.
OR rn3 <= &&cs_me_top.
ORDER BY
sql_exec_start,
sql_exec_id
/
--
COL snap_time FOR A19;
COL awr_snapshot_end_time FOR A19 HEA 'AWR_SNAP_ENDTIME';
COL db_secs_per_exec_delta FOR 999,990.0 HEA 'SECONDS|PER_EXEC';
COL threshold_violation_factor FOR 999,990.0 HEA 'REGRESSION|FACTOR';
COL db_time_regression_01d FOR 999,990.0 HEA 'DB_TIME|REGR_01d|FACTOR';
COL db_time_regression_07d FOR 999,990.0 HEA 'DB_TIME|REGR_07d|FACTOR';
COL db_time_regression_30d FOR 999,990.0 HEA 'DB_TIME|REGR_30d|FACTOR';
COL db_time_regression_60d FOR 999,990.0 HEA 'DB_TIME|REGR_60d|FACTOR';
COL cpu_time_regression_01d FOR 999,990.0 HEA 'CPU_TIME|REGR_01d|FACTOR';
COL cpu_time_regression_07d FOR 999,990.0 HEA 'CPU_TIME|REGR_07d|FACTOR';
COL cpu_time_regression_30d FOR 999,990.0 HEA 'CPU_TIME|REGR_30d|FACTOR';
COL cpu_time_regression_60d FOR 999,990.0 HEA 'CPU_TIME|REGR_60d|FACTOR';
COL pdb_name FOR A30 TRUNC;
COL top FOR 990;
COL dummy FOR A2 HEA '';
--
PRO
PRO HC SQL - PERFORMANCE REGRESSION top &&cs_me_top. and last &&cs_me_last. for past &&cs_me_days. days (&&cs_stgtab_owner..regress_hist)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
WITH
snaps AS (
SELECT snap_time,
GREATEST(db_time_regression_01d, db_time_regression_07d, db_time_regression_30d, db_time_regression_60d, cpu_time_regression_01d, cpu_time_regression_07d, cpu_time_regression_30d, cpu_time_regression_60d) AS threshold_violation_factor,
db_time_regression_01d,
db_time_regression_07d,
db_time_regression_30d,
db_time_regression_60d,
cpu_time_regression_01d,
cpu_time_regression_07d,
cpu_time_regression_30d,
cpu_time_regression_60d,
pdb_name,
db_secs_per_exec_delta,
awr_snapshot_end_time,
ROW_NUMBER() OVER (ORDER BY snap_time DESC, pdb_name) AS rn1,
ROW_NUMBER() OVER (ORDER BY GREATEST(db_time_regression_01d, db_time_regression_07d, db_time_regression_30d, db_time_regression_60d, cpu_time_regression_01d, cpu_time_regression_07d, cpu_time_regression_30d, cpu_time_regression_60d) DESC, db_secs_per_exec_delta DESC) AS rn2
FROM &&cs_stgtab_owner..regress_hist
WHERE '&&cs_con_name.' IN (pdb_name, 'CDB$ROOT')
AND sql_id = '&&cs_sql_id.'
AND snap_time > SYSDATE - &&cs_me_days.
)
SELECT snap_time,
CASE WHEN rn2 <= &&cs_me_top. THEN rn2 END AS top,
threshold_violation_factor,
db_time_regression_01d,
CASE WHEN db_time_regression_01d = threshold_violation_factor THEN '<-' END AS dummy,
db_time_regression_07d,
CASE WHEN db_time_regression_07d = threshold_violation_factor THEN '<-' END AS dummy,
db_time_regression_30d,
CASE WHEN db_time_regression_30d = threshold_violation_factor THEN '<-' END AS dummy,
db_time_regression_60d,
CASE WHEN db_time_regression_60d = threshold_violation_factor THEN '<-' END AS dummy,
cpu_time_regression_01d,
CASE WHEN cpu_time_regression_01d = threshold_violation_factor THEN '<-' END AS dummy,
cpu_time_regression_07d,
CASE WHEN cpu_time_regression_07d = threshold_violation_factor THEN '<-' END AS dummy,
cpu_time_regression_30d,
CASE WHEN cpu_time_regression_30d = threshold_violation_factor THEN '<-' END AS dummy,
cpu_time_regression_60d,
CASE WHEN cpu_time_regression_60d = threshold_violation_factor THEN '<-' END AS dummy,
pdb_name,
awr_snapshot_end_time
FROM snaps
WHERE rn1 <= &&cs_me_last.
OR rn2 <= &&cs_me_top.
ORDER BY
snap_time,
pdb_name
/
--
COL snap_time FOR A19;
COL aas_tot FOR 999,990.0 HEA 'AAS|ON_DB';
COL aas_tot_threshold FOR 999,990.0 HEA 'AAS_ON_DB|THRESHOLD';
COL tot_times_threshold FOR 999,990.0 HEA 'AAS_ON_DB|FACTOR';
COL aas_cpu FOR 999,990.0 HEA 'AAS|ON_CPU';
COL aas_cpu_threshold FOR 999,990.0 HEA 'AAS_ON_CPU|THRESHOLD';
COL cpu_times_threshold FOR 999,990.0 HEA 'AAS_ON_CPU|FACTOR';
COL max_as_tot FOR 9,999,990 HEA 'MAX_CONC|SESSIONS|ON_DB';
COL max_as_cpu FOR 9,999,990 HEA 'MAX_CONC|SESSIONS|ON_CPU';
COL pdb_name FOR A30 TRUNC;
COL username FOR A30 TRUNC;
COL top FOR 990;
COL dummy FOR A2 HEA '';
--
PRO
PRO HC SQL - HIGH AVERAGE ACTIVE SESSIONS (AAS) top &&cs_me_top. and last &&cs_me_last. for past &&cs_me_days. days (&&cs_stgtab_owner..highaas_hist)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
WITH
snaps AS (
SELECT snap_time,
aas_tot,
aas_tot_threshold,
tot_times_threshold,
aas_cpu,
aas_cpu_threshold,
cpu_times_threshold,
max_as_tot,
max_as_cpu,
pdb_name,
username,
ROW_NUMBER() OVER (ORDER BY snap_time DESC, pdb_name) AS rn1,
ROW_NUMBER() OVER (ORDER BY aas_tot DESC, aas_cpu DESC, max_as_tot DESC, max_as_cpu DESC) AS rn2,
ROW_NUMBER() OVER (ORDER BY aas_cpu DESC, aas_tot DESC, max_as_cpu DESC, max_as_tot DESC) AS rn3
FROM &&cs_stgtab_owner..highaas_hist
WHERE '&&cs_con_name.' IN (pdb_name, 'CDB$ROOT')
AND sql_id = '&&cs_sql_id.'
AND snap_time > SYSDATE - &&cs_me_days.
)
SELECT snap_time,
CASE WHEN rn2 <= &&cs_me_top. THEN rn2 END AS top,
aas_tot,
aas_tot_threshold,
tot_times_threshold,
CASE WHEN tot_times_threshold > aas_tot_threshold AND rn2 <= &&cs_me_top. THEN '<-' END AS dummy,
aas_cpu,
aas_cpu_threshold,
cpu_times_threshold,
CASE WHEN cpu_times_threshold > aas_cpu_threshold AND rn3 <= &&cs_me_top. THEN '<-' END AS dummy,
max_as_tot,
max_as_cpu,
pdb_name,
username
FROM snaps
WHERE rn1 <= &&cs_me_last.
OR rn2 <= &&cs_me_top.
OR rn3 <= &&cs_me_top.
ORDER BY
snap_time,
pdb_name,
username
/
--
COL snap_time FOR A19;
COL ms_per_execution FOR 999,999,990 HEA 'MILLISECS|PER_EXEC';
COL ms_per_exec_threshold FOR 999,999,990 HEA 'MS_PE|THRESHOLD';
COL aas_tot FOR 999,990.0 HEA 'AAS|ON_DB';
COL aas_tot_threshold FOR 999,990.0 HEA 'AAS_ON_DB|THRESHOLD';
COL pdb_name FOR A30 TRUNC;
COL top FOR 990;
COL dummy FOR A2 HEA '';
--
PRO
PRO HC SQL - NON SCALABLE PLANS top &&cs_me_top. and last &&cs_me_last. for past &&cs_me_days. days (&&cs_stgtab_owner..non_scalable_plan_hist)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
WITH
snaps AS (
SELECT snap_time,
plan_hash_value,
ms_per_execution,
ms_per_exec_threshold,
aas_tot,
aas_tot_threshold,
pdb_name,
ROW_NUMBER() OVER (ORDER BY snap_time DESC, pdb_name) AS rn1,
ROW_NUMBER() OVER (ORDER BY ms_per_execution DESC, aas_tot DESC) AS rn2,
ROW_NUMBER() OVER (ORDER BY aas_tot DESC, ms_per_execution DESC) AS rn3
FROM &&cs_stgtab_owner..non_scalable_plan_hist
WHERE '&&cs_con_name.' IN (pdb_name, 'CDB$ROOT')
AND sql_id = '&&cs_sql_id.'
AND snap_time > SYSDATE - &&cs_me_days.
)
SELECT snap_time,
CASE WHEN rn2 <= &&cs_me_top. THEN rn2 END AS top,
plan_hash_value,
ms_per_execution,
ms_per_exec_threshold,
CASE WHEN ms_per_execution > ms_per_exec_threshold AND rn2 <= &&cs_me_top. THEN '<-' END AS dummy,
aas_tot,
aas_tot_threshold,
CASE WHEN aas_tot > aas_tot_threshold AND rn3 <= &&cs_me_top. THEN '<-' END AS dummy,
pdb_name
FROM snaps
WHERE rn1 <= &&cs_me_last.
OR rn2 <= &&cs_me_top.
OR rn3 <= &&cs_me_top.
ORDER BY
snap_time,
pdb_name
/
--
@@&&cs_set_container_to_curr_pdb.
csierra/cs_internal/cs_plans_awr_1.sql
+18
View File
@@ -0,0 +1,18 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL timestamp FOR A19 HEA 'Timestamp';
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
--
PRO
PRO AWR PLANS (dba_hist_sql_plan)
PRO ~~~~~~~~~
SELECT TO_CHAR(h.timestamp, '&&cs_datetime_full_format.') timestamp,
plan_hash_value
FROM dba_hist_sql_plan h
WHERE h.sql_id = '&&cs_sql_id.'
AND ('&&cs_plan_hash_value.' IS NULL OR h.plan_hash_value = TO_NUMBER('&&cs_plan_hash_value.'))
AND h.id = 0
AND h.dbid = TO_NUMBER('&&cs_dbid.')
ORDER BY
h.timestamp
/
csierra/cs_internal/cs_plans_awr_2.sql
+23
View File
@@ -0,0 +1,23 @@
PRO
PRO AWR PLANS - DISPLAY (dbms_xplan.display_awr)
PRO ~~~~~~~~~~~~~~~~~~~
SET HEA OFF PAGES 0;
WITH
plans_by_timestamp AS (
SELECT /*+ MATERIALIZE NO_MERGE */
h.sql_id,
h.plan_hash_value
FROM dba_hist_sql_plan h -- cannot use cdb_hist_sql_plan since DBMS_XPLAN only executes with a PDB (would need to use DBMS_SQL to execue from CDB$ROOT)
WHERE h.sql_id = '&&cs_sql_id.'
AND ('&&cs_plan_hash_value.' IS NULL OR h.plan_hash_value = TO_NUMBER('&&cs_plan_hash_value.'))
AND h.id = 0
AND h.dbid = TO_NUMBER('&&cs_dbid.')
ORDER BY
h.timestamp
)
SELECT p.plan_table_output
FROM plans_by_timestamp h,
TABLE(DBMS_XPLAN.display_awr(h.sql_id, h.plan_hash_value, NULL, 'ADVANCED')) p
/
SET HEA ON PAGES 100;
--
csierra/cs_internal/cs_plans_mem_0.sql
+24
View File
@@ -0,0 +1,24 @@
VAR cs_execution_plan CLOB;
EXEC :cs_execution_plan := NULL;
-- SET SERVEROUT ON;
BEGIN
FOR i IN (SELECT plan_table_output FROM TABLE(DBMS_XPLAN.display_cursor(sql_id => '&&cs_sql_id.', cursor_child_no => (SELECT child_number FROM v$sql WHERE sql_id = '&&cs_sql_id.' ORDER BY last_active_time DESC FETCH FIRST 1 ROW ONLY), format => 'TYPICAL -NOTE -PREDICATE')))
LOOP
IF :cs_execution_plan IS NOT NULL AND LENGTH(i.plan_table_output) > 1 THEN
-- DBMS_OUTPUT.put_line(i.plan_table_output);
DBMS_LOB.writeappend(:cs_execution_plan, LENGTH(i.plan_table_output) + 1, i.plan_table_output||CHR(10));
END IF;
IF i.plan_table_output LIKE 'Plan hash value:%' THEN
:cs_execution_plan := i.plan_table_output||CHR(10);
END IF;
END LOOP;
END;
/
PRO
PRO LATEST PLAN IN MEMORY - DISPLAY (dbms_xplan.display_cursor)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
PRO
SET HEA OFF PAGES 0;
PRINT :cs_execution_plan
SET HEA ON PAGES 100;
--
csierra/cs_internal/cs_plans_mem_1.sql
+62
View File
@@ -0,0 +1,62 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL last_active_time FOR A19 HEA 'Last Active Time';
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash Value';
COL child_number FOR 999999 HEA 'Child|Number';
COL object_status FOR A14 HEA 'Object Status';
COL is_obsolete FOR A8 HEA 'Is|Obsolete';
COL is_shareable FOR A9 HEA 'Is|Shareable';
COL is_bind_aware FOR A9 HEA 'Is Bind|Aware';
COL is_bind_sensitive FOR A9 HEA 'Is Bind|Sensitive';
COL parsing_schema_name FOR A30 HEA 'Parsing Schema Name';
--
PRO
PRO PLANS IN MEMORY (v$sql)
PRO ~~~~~~~~~~~~~~~
WITH
ranked_child_cursors AS (
SELECT /*+ MATERIALIZE NO_MERGE */
sql_id,
con_id,
child_number,
ROW_NUMBER () OVER (PARTITION BY con_id, plan_hash_value ORDER BY
CASE
WHEN object_status = 'VALID' AND is_obsolete = 'N' AND is_shareable = 'Y' THEN 1
WHEN object_status = 'VALID' AND is_obsolete = 'N' AND is_shareable = 'N' THEN 2
WHEN object_status = 'VALID' AND is_obsolete = 'Y' THEN 3
ELSE 4
END,
last_active_time DESC) AS row_number,
plan_hash_value,
last_active_time,
object_status,
is_obsolete,
is_shareable,
is_bind_sensitive,
is_bind_aware,
parsing_schema_name
FROM v$sql
WHERE sql_id = '&&cs_sql_id.'
AND ('&&cs_plan_hash_value.' IS NULL OR plan_hash_value = TO_NUMBER('&&cs_plan_hash_value.'))
)
SELECT TO_CHAR(r.last_active_time, '&&cs_datetime_full_format.') AS last_active_time,
r.con_id,
c.name AS pdb_name,
r.child_number,
r.object_status,
r.is_obsolete,
r.is_shareable,
r.is_bind_sensitive,
r.is_bind_aware,
r.parsing_schema_name,
r.plan_hash_value
FROM ranked_child_cursors r,
v$containers c
WHERE r.row_number <= 3 -- up to N most recently active child cursors per plan_hash_value
AND c.con_id = r.con_id
ORDER BY
r.last_active_time,
r.con_id,
r.child_number
/
--
csierra/cs_internal/cs_plans_mem_2.sql
+57
View File
@@ -0,0 +1,57 @@
PRO
PRO PLANS IN MEMORY - DISPLAY (dbms_xplan.display_cursor)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~
PRO
SET HEA OFF PAGES 0;
WITH
ranked_child_cursors AS (
SELECT /*+ MATERIALIZE NO_MERGE */
s.con_id,
sql_id,
child_number,
ROW_NUMBER () OVER (PARTITION BY plan_hash_value ORDER BY
CASE
WHEN object_status = 'VALID' AND is_obsolete = 'N' AND is_shareable = 'Y' THEN 1
WHEN object_status = 'VALID' AND is_obsolete = 'N' AND is_shareable = 'N' THEN 2
WHEN object_status = 'VALID' AND is_obsolete = 'Y' THEN 3
ELSE 4
END,
last_active_time DESC) row_number,
plan_hash_value,
last_active_time,
object_status,
is_obsolete,
is_shareable,
is_bind_sensitive,
is_bind_aware,
parsing_schema_name,
c.name AS pdb_name
FROM v$sql s, v$containers c
WHERE s.sql_id = '&&cs_sql_id.'
AND ('&&cs_plan_hash_value.' IS NULL OR s.plan_hash_value = TO_NUMBER('&&cs_plan_hash_value.'))
AND c.con_id = s.con_id
ORDER BY
s.last_active_time,
s.con_id,
s.child_number
)
SELECT CASE WHEN p.plan_table_output LIKE 'SQL_ID %'
THEN
'Last active time:'||TO_CHAR(r.last_active_time, '&&cs_datetime_full_format.')||
' '||REPLACE(REPLACE(p.plan_table_output, 'child number ', 'Child_Number:'), 'SQL_ID ', 'SQL_ID:')||
CASE WHEN r.object_status <> 'VALID' THEN ', Object_Status:'||r.object_status END||
CASE WHEN r.is_obsolete <> 'N' THEN ', Is_Obsolete' END||
CASE WHEN r.is_shareable <> 'Y' THEN ', Is_Not_Shareable' END||
CASE WHEN r.is_bind_aware = 'Y' THEN ', Is_Bind_Aware' END||
CASE WHEN r.is_bind_sensitive = 'Y' THEN ', Is_Bind_Sensitive' END||
', Con_ID:'||TRIM(TO_CHAR(r.con_id))||
', PDB_Name:'||r.pdb_name||
', Parsing_Schema:'||parsing_schema_name
ELSE p.plan_table_output
END AS plan_table_output
FROM ranked_child_cursors r,
TABLE(DBMS_XPLAN.display_cursor(r.sql_id, r.child_number, 'ADVANCED ALLSTATS LAST')) p
WHERE r.row_number <= 3 -- up to N most recently active child cursors per plan_hash_value
/
SET HEA ON PAGES 100;
--
csierra/cs_internal/cs_plans_performance.sql
+188
View File
@@ -0,0 +1,188 @@
-- cs_plans_performance.sql: called by multiple cs_sprf*, cs_spch*, cs_spbl*, and by: cs_planx.sql, cs_sqlperf.sql and cs_purge_cursor.sql
COL plan_hash_value FOR 9999999999 HEA 'Plan|Hash|Value';
COL et_ms_per_exec_awr FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|AWR';
COL et_ms_per_exec_mem FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|CUR';
COL cpu_ms_per_exec_awr FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|AWR';
COL cpu_ms_per_exec_mem FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|CUR';
COL gets_per_exec_awr FOR 999,999,990 HEA 'Buffer|Gets|Per Exec|AWR';
COL gets_per_exec_mem FOR 999,999,990 HEA 'Buffer|Gets|Per Exec|CUR';
COL rows_per_exec_awr FOR 999,999,990.000 HEA 'Rows|Processed|Per Exec|AWR';
COL rows_per_exec_mem FOR 999,999,990.000 HEA 'Rows|Processed|Per Exec|CUR';
COL executions_awr FOR 999,999,999,990 HEA 'Total|Executions|AWR';
COL executions_mem FOR 999,999,999,990 HEA 'Total|Executions|CUR';
COL min_optimizer_cost FOR 9999999999 HEA 'Optimizer|Cost|MIN';
COL max_optimizer_cost FOR 9999999999 HEA 'Optimizer|Cost|MAX';
COL nl FOR 999;
COL hj FOR 999;
COL mj FOR 999;
COL p100_et_ms_per_exec FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|MAX';
COL p99_et_ms_per_exec FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|p99 PCTL';
COL p97_et_ms_per_exec FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|p97 PCTL';
COL p95_et_ms_per_exec FOR 99,999,990.000 HEA 'DB|Latency(ms)|Per Exec|p95 PCTL';
COL p100_cpu_ms_per_exec FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|MAX';
COL p99_cpu_ms_per_exec FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|p99 PCTL';
COL p97_cpu_ms_per_exec FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|p97 PCTL';
COL p95_cpu_ms_per_exec FOR 99,999,990.000 HEA 'CPU|Latency(ms)|Per Exec|p95 PCTL';
COL pdb_name FOR A30 HEA 'PDB Name' TRUNC;
COL min_time FOR A23 HEA 'Begin Timestamp';
COL max_time FOR A23 HEA 'End Timestamp';
COL sep0 FOR A1 HEA '+|!|!|!';
COL sep1 FOR A1 HEA '+|!|!|!';
COL sep2 FOR A1 HEA '+|!|!|!';
COL sep3 FOR A1 HEA '+|!|!|!';
COL sep4 FOR A1 HEA '+|!|!|!';
COL sep5 FOR A1 HEA '+|!|!|!';
COL sep6 FOR A1 HEA '+|!|!|!';
--
PRO
PRO PLANS PERFORMANCE - SUMMARY (dba_hist_sqlstat AWR and gv$sql CUR)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~
WITH
pm AS (
SELECT con_id, plan_hash_value, operation,
CASE operation WHEN 'NESTED LOOPS' THEN COUNT(DISTINCT id) ELSE 0 END AS nl,
CASE operation WHEN 'HASH JOIN' THEN COUNT(DISTINCT id) ELSE 0 END AS hj,
CASE operation WHEN 'MERGE JOIN' THEN COUNT(DISTINCT id) ELSE 0 END AS mj
FROM gv$sql_plan
WHERE sql_id = '&&cs_sql_id.'
GROUP BY
con_id, plan_hash_value, operation
),
pa AS (
SELECT con_id, plan_hash_value, operation,
CASE operation WHEN 'NESTED LOOPS' THEN COUNT(DISTINCT id) ELSE 0 END AS nl,
CASE operation WHEN 'HASH JOIN' THEN COUNT(DISTINCT id) ELSE 0 END AS hj,
CASE operation WHEN 'MERGE JOIN' THEN COUNT(DISTINCT id) ELSE 0 END AS mj
FROM dba_hist_sql_plan
WHERE sql_id = '&&cs_sql_id.'
AND dbid = TO_NUMBER('&&cs_dbid.')
GROUP BY
con_id, plan_hash_value, operation
),
pm_pa AS (
SELECT con_id, plan_hash_value, MAX(nl) AS nl, MAX(hj) AS hj, MAX(mj) AS mj
FROM pm
GROUP BY
con_id, plan_hash_value
UNION
SELECT con_id, plan_hash_value, MAX(nl) AS nl, MAX(hj) AS hj, MAX(mj) AS mj
FROM pa
GROUP BY
con_id, plan_hash_value
),
p AS (
SELECT con_id, plan_hash_value, MAX(nl) AS nl, MAX(hj) AS hj, MAX(mj) AS mj
FROM pm_pa
GROUP BY
con_id, plan_hash_value
),
phv_perf AS (
SELECT con_id, plan_hash_value, snap_id,
SUM(elapsed_time_delta)/NULLIF(SUM(executions_delta), 0)/1e3 AS et_ms_per_exec,
SUM(cpu_time_delta)/NULLIF(SUM(executions_delta), 0)/1e3 AS cpu_ms_per_exec
FROM dba_hist_sqlstat
WHERE sql_id = '&&cs_sql_id.'
-- AND executions_delta > 0 -- not needed!
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
GROUP BY
con_id, plan_hash_value, snap_id
),
phv_stats AS (
SELECT con_id, plan_hash_value,
MAX(et_ms_per_exec) p100_et_ms_per_exec,
PERCENTILE_DISC(0.99) WITHIN GROUP (ORDER BY et_ms_per_exec) p99_et_ms_per_exec,
PERCENTILE_DISC(0.97) WITHIN GROUP (ORDER BY et_ms_per_exec) p97_et_ms_per_exec,
PERCENTILE_DISC(0.95) WITHIN GROUP (ORDER BY et_ms_per_exec) p95_et_ms_per_exec,
MAX(cpu_ms_per_exec) p100_cpu_ms_per_exec,
PERCENTILE_DISC(0.99) WITHIN GROUP (ORDER BY cpu_ms_per_exec) p99_cpu_ms_per_exec,
PERCENTILE_DISC(0.97) WITHIN GROUP (ORDER BY cpu_ms_per_exec) p97_cpu_ms_per_exec,
PERCENTILE_DISC(0.95) WITHIN GROUP (ORDER BY cpu_ms_per_exec) p95_cpu_ms_per_exec
FROM phv_perf
GROUP BY
con_id, plan_hash_value
),
m AS (
SELECT con_id, plan_hash_value,
SUM(elapsed_time)/NULLIF(SUM(executions), 0)/1e3 AS et_ms_per_exec,
SUM(cpu_time)/NULLIF(SUM(executions), 0)/1e3 AS cpu_ms_per_exec,
SUM(buffer_gets)/NULLIF(SUM(executions), 0) AS gets_per_exec,
SUM(rows_processed)/NULLIF(SUM(executions), 0) AS rows_per_exec,
SUM(executions) AS executions,
MIN(optimizer_cost) AS min_optimizer_cost,
MAX(optimizer_cost) AS max_optimizer_cost,
MIN(last_active_time) AS min_time,
MAX(last_active_time) AS max_time
FROM gv$sql
WHERE sql_id = '&&cs_sql_id.'
-- AND executions >= 0 -- not needed!
AND optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
GROUP BY
con_id, plan_hash_value
),
a AS (
SELECT h.con_id, h.plan_hash_value,
SUM(h.elapsed_time_delta)/NULLIF(SUM(h.executions_delta), 0)/1e3 AS et_ms_per_exec,
SUM(h.cpu_time_delta)/NULLIF(SUM(h.executions_delta), 0)/1e3 AS cpu_ms_per_exec,
SUM(h.buffer_gets_delta)/NULLIF(SUM(h.executions_delta), 0) AS gets_per_exec,
SUM(h.rows_processed_delta)/NULLIF(SUM(h.executions_delta), 0) AS rows_per_exec,
SUM(h.executions_delta) AS executions,
MIN(h.optimizer_cost) AS min_optimizer_cost,
MAX(h.optimizer_cost) AS max_optimizer_cost,
CAST(MIN(s.begin_interval_time) AS DATE) AS min_time,
CAST(MAX(s.end_interval_time) AS DATE) AS max_time
FROM dba_hist_sqlstat h,
dba_hist_snapshot s
WHERE h.dbid = TO_NUMBER('&&cs_dbid.')
-- AND h.instance_number = TO_NUMBER('&&cs_instance_number.')
AND h.sql_id = '&&cs_sql_id.'
-- AND h.executions_delta >= 0 -- not needed!
AND h.optimizer_cost > 0 -- if 0 or null then whole row is suspected bogus
AND s.snap_id = h.snap_id
AND s.dbid = h.dbid
AND s.instance_number = h.instance_number
GROUP BY
h.con_id, h.plan_hash_value
)
SELECT '!' AS sep0,
p.plan_hash_value,
'|' AS sep1,
a.et_ms_per_exec AS et_ms_per_exec_awr,
m.et_ms_per_exec AS et_ms_per_exec_mem,
a.cpu_ms_per_exec AS cpu_ms_per_exec_awr,
m.cpu_ms_per_exec AS cpu_ms_per_exec_mem,
'!' AS sep2,
a.executions AS executions_awr,
m.executions AS executions_mem,
'!' AS sep3,
a.gets_per_exec AS gets_per_exec_awr,
m.gets_per_exec AS gets_per_exec_mem,
a.rows_per_exec AS rows_per_exec_awr,
m.rows_per_exec AS rows_per_exec_mem,
'!' AS sep4,
s.p100_et_ms_per_exec,
s.p99_et_ms_per_exec,
s.p97_et_ms_per_exec,
s.p95_et_ms_per_exec,
s.p100_cpu_ms_per_exec,
s.p99_cpu_ms_per_exec,
s.p97_cpu_ms_per_exec,
s.p95_cpu_ms_per_exec,
'!' AS sep5,
LEAST(COALESCE(a.min_optimizer_cost, m.min_optimizer_cost), COALESCE(m.min_optimizer_cost, a.min_optimizer_cost))AS min_optimizer_cost,
GREATEST(COALESCE(a.max_optimizer_cost, m.max_optimizer_cost), COALESCE(m.max_optimizer_cost, a.max_optimizer_cost)) AS max_optimizer_cost,
p.nl,
p.hj,
p.mj,
'!' AS sep6,
c.name AS pdb_name,
LEAST(COALESCE(a.min_time, m.min_time), COALESCE(m.min_time, a.min_time)) AS min_time,
GREATEST(COALESCE(m.max_time, a.max_time), COALESCE(a.max_time, m.max_time)) AS max_time
FROM p, m, a, phv_stats s, v$containers c
WHERE p.plan_hash_value = m.plan_hash_value(+) AND p.con_id = m.con_id(+)
AND p.plan_hash_value = a.plan_hash_value(+) AND p.con_id = a.con_id(+)
AND p.plan_hash_value = s.plan_hash_value(+) AND p.con_id = s.con_id(+)
AND c.con_id = p.con_id
ORDER BY
LEAST(COALESCE(a.et_ms_per_exec, m.et_ms_per_exec), COALESCE(m.et_ms_per_exec, a.et_ms_per_exec))
/
--
csierra/cs_internal/cs_pr_internal.sql
+141
View File
@@ -0,0 +1,141 @@
----------------------------------------------------------------------------------------
--
-- File name: cs_pr_internal.sql
--
-- Purpose: Print Table (vertical display of result columns for last query)
--
-- Author: Carlos Sierra
--
-- Version: 2021/05/16
--
-- Usage: Execute connected to PDB or CDB.
--
-- Parameter options:
--
-- 1. directory_path/script_name.sql (with one query)
--
-- 2. one query
--
-- 3. null (assumes then last sql executed)
--
-- Examples: 1. SQL> @cs_pr_internal.sql "/tmp/carlos.sql"
--
-- 2. SQL> @cs_pr_internal.sql "SELECT * FROM v$database;"
--
-- 3. SQL> @cs_pr_internal.sql ""
--
-- Notes: When passing a query which contains single quotes then double them
-- e.g. SQL> @cs_pr_internal.sql "SELECT sid||'',''||serial# AS sid_serial FROM v$session"
--
-- Modified version of Tanel Poder pr.sql script, which is a mofified version
-- of Tom Kyte printtbl code.
--
---------------------------------------------------------------------------------------
--
-- https://github.com/tanelpoder/tpt-oracle/blob/master/pr.sql
-- Notes: This script is based on Tom Kyte's original printtbl code ( http://asktom.oracle.com )
-- For coding simplicity (read: lazyness) I'm using custom quotation marks ( q'\ ) so
-- this script works only from Oracle 10gR2 onwards
-- prompt Pivoting output using Tom Kyte's printtab....
--
SET TERM OFF;
-- added my_sid to avoid collisons accross concurrent executions of this script
COL my_sid NEW_V my_sid NOPRI;
SELECT SYS_CONTEXT('USERENV', 'SID') AS my_sid FROM DUAL
/
SPO &&cs_file_name..txt APP;
SPO OFF;
SAVE "/tmp/sql_pr_tmpfile_&&my_sid..sql" REPLACE;
STORE SET "/tmp/set_pr_tmpfile_&&my_sid..sql" REPLACE;
SET TERM ON HEA OFF TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON SERVEROUT ON SIZE UNL TRIM ON LIN 4050;
--
--PRO
--PRO 1. Enter [directory_path/script_name.sql|"query"|null]:
DEF cs_parameter = '&1.';
UNDEF 1;
SET TERM OFF;
--
COL cs_option NEW_V cs_option NOPRI;
COL cs_parameter NEW_V cs_parameter NOPRI;
SELECT CASE
WHEN LOWER(SUBSTR(TRIM(q'[&&cs_parameter.]'), -4, 4)) = '.sql' THEN '1'
WHEN TRIM(q'[&&cs_parameter.]') IS NULL THEN '3'
ELSE '2'
END AS cs_option,
CASE
WHEN LOWER(SUBSTR(TRIM(q'[&&cs_parameter.]'), -4, 4)) = '.sql' THEN TRIM(q'[&&cs_parameter.]')
WHEN TRIM(q'[&&cs_parameter.]') IS NULL THEN '/tmp/sql_pr_tmpfile_&&my_sid..sql'
ELSE TRIM(';' FROM TRIM('"' FROM TRIM(q'[&&cs_parameter.]')))
END AS cs_parameter
FROM DUAL
/
--
SPOOL "/tmp/sql2_pr_tmpfile_&&my_sid..sql";
PRO &&cs_parameter.
SPOOL OFF;
--
COL script_name NEW_V script_name NOPRI;
SELECT CASE '&&cs_option.'
WHEN '1' THEN q'[&&cs_parameter.]'
WHEN '2' THEN '/tmp/sql2_pr_tmpfile_&&my_sid..sql'
WHEN '3' THEN '/tmp/sql_pr_tmpfile_&&my_sid..sql'
END AS script_name
FROM DUAL
/
--
GET "&&script_name." NOLIST;
SAVE "/tmp/sql_pr_tmpfile_&&my_sid..sql" REPLACE;
--
0 c clob := q'\
0 declare
--
666666 \';;
666666 l_theCursor integer default dbms_sql.open_cursor;;
666666 l_columnValue varchar2(4000);;
666666 l_status integer;;
666666 l_descTbl dbms_sql.desc_tab;;
666666 l_colCnt number;;
666666 l_amount number;;
666666 begin
666666 IF DBMS_LOB.instr(c, ';') = 0 THEN
666666 l_amount := DBMS_LOB.getlength(c);;
666666 ELSE
666666 l_amount := DBMS_LOB.instr(c, ';') - 1;;
666666 END IF;;
666666 c := DBMS_LOB.substr(c, l_amount);;
666666 dbms_sql.parse( l_theCursor, c, dbms_sql.native );;
666666 dbms_sql.describe_columns( l_theCursor, l_colCnt, l_descTbl );;
666666 for i in 1 .. l_colCnt loop
666666 if l_descTbl(i).col_type not in (112, 113) then -- excludes blob and clob (see https://docs.oracle.com/cd/E11882_01/server.112/e41085/sqlqr06002.htm#SQLQR959)
666666 dbms_sql.define_column( l_theCursor, i,
666666 l_columnValue, 4000 );;
666666 end if;;
666666 end loop;;
666666 l_status := dbms_sql.execute(l_theCursor);;
666666 while ( dbms_sql.fetch_rows(l_theCursor) > 0 ) loop
666666 dbms_output.put_line( '+--------------------------------+' );;
666666 for i in 1 .. l_colCnt loop
666666 if l_descTbl(i).col_type not in (112, 113) then -- excludes blob and clob (see https://docs.oracle.com/cd/E11882_01/server.112/e41085/sqlqr06002.htm#SQLQR959)
666666 dbms_sql.column_value( l_theCursor, i,
666666 l_columnValue );;
666666 dbms_output.put_line
666666 ( '|'||lpad( lower(l_descTbl(i).col_name),
666666 31 ) || ' : ' || l_columnValue );;
666666 end if;;
666666 end loop;;
666666 end loop;;
666666 dbms_output.put_line( '+--------------------------------+' );;
666666 exception
666666 when others then
666666 dbms_output.put_line(dbms_utility.format_error_backtrace);;
666666 raise;;
666666 end;;
SET TERM ON;
SPO &&cs_file_name..txt APP;
/
--
@"/tmp/set_pr_tmpfile_&&my_sid..sql";
GET "&&script_name." NOLIST;
HOST rm "/tmp/set_pr_tmpfile_&&my_sid..sql" "/tmp/sql_pr_tmpfile_&&my_sid..sql" "/tmp/sql2_pr_tmpfile_&&my_sid..sql";
SET TERM ON;
--
csierra/cs_internal/cs_primary.sql
+8
View File
@@ -0,0 +1,8 @@
-- warn if executed not on MOUNTED or READ ONLY
SET TAB OFF FEED OFF ECHO OFF VER OFF;
COL open_mode NEW_V open_mode NOPRI;
COL database_role NEW_V database_role NOPRI;
COL dynamic_script NEW_V dynamic_script NOPRI;
SELECT open_mode, database_role, CASE WHEN open_mode = 'READ WRITE' AND database_role = 'PRIMARY' THEN 'cs_null.sql' ELSE 'cs_primary_warn.sql' END AS dynamic_script FROM v$database
/
@@&&dynamic_script.
csierra/cs_internal/cs_primary_warn.sql
+6
View File
@@ -0,0 +1,6 @@
PRO ***
PRO *** v$database.open_mode : &&open_mode.
PRO *** v$database.database_role: &&database_role.
PRO ***
PRO
PAUSE Hit "return" to continue; or "control-c" then "return" to exit:
csierra/cs_internal/cs_print_sql_text.sql
+4
View File
@@ -0,0 +1,4 @@
SET HEA OFF;
-- PRINT :cs_sql_text
PRINT :cs_zapper_managed_sql_banner
SET HEA ON;
csierra/cs_internal/cs_recent_sessions.sql
+37
View File
@@ -0,0 +1,37 @@
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL machine FOR A64 HEA 'Machine (Application Server)';
COL samples FOR 999,999 HEA 'Samples';
COL min_sample_time FOR A19 HEA 'Min Sample Time';
COL max_sample_time FOR A19 HEA 'Max Sample Time';
COL sid_serial# FOR A12 HEA 'Sid,Serial#';
--
BREAK ON con_id ON pdb_name ON machine SKIP 1;
--
PRO
PRO RECENT SESSIONS (v$active_session_history past 15 minutes)
PRO ~~~~~~~~~~~~~~~
SELECT h.con_id,
c.name AS pdb_name,
h.machine,
COUNT(*) samples,
TO_CHAR(MIN(h.sample_time), '&&cs_datetime_full_format.') AS min_sample_time,
TO_CHAR(MAX(h.sample_time), '&&cs_datetime_full_format.') AS max_sample_time,
h.session_id||','||h.session_serial# AS sid_serial#,
h.sql_plan_hash_value AS plan_hash_value
FROM v$active_session_history h,
v$containers c
WHERE h.sql_id = '&&cs_sql_id.'
AND h.sample_time > SYSDATE - (15/24/60)
AND c.con_id = h.con_id
GROUP BY
h.con_id,
c.name,
h.machine,
h.session_id||','||h.session_serial#,
h.sql_plan_hash_value
ORDER BY
1, 2, 3, 4 DESC, 5, 6
/
--
CLEAR BREAK;
csierra/cs_internal/cs_reset.sql
+6
View File
@@ -0,0 +1,6 @@
--SET HEA ON LIN 270 PAGES 60 TAB ON FEED ON ECHO OFF VER ON TRIMS OFF TRIM ON TI OFF TIMI OFF LONG 24000 LONGC 240 SERVEROUT OFF;
SET TERM OFF;
@"/tmp/cs_store_set.sql"
CLEAR BREAK COLUMNS COMPUTE;
SET TERM ON;
--
csierra/cs_internal/cs_sample_time_boundaries.sql
+4
View File
@@ -0,0 +1,4 @@
COL cs_sample_time_from NEW_V cs_sample_time_from NOPRI;
COL cs_sample_time_to NEW_V cs_sample_time_to NOPRI;
SELECT TO_CHAR(SYSDATE - &&cs_sqlstat_days., '&&cs_datetime_full_format.') AS cs_sample_time_from, TO_CHAR(SYSDATE, '&&cs_datetime_full_format.') AS cs_sample_time_to FROM DUAL
/
csierra/cs_internal/cs_sample_time_from_and_to.sql
+74
View File
@@ -0,0 +1,74 @@
--
PRO
COL cs_default_time_window NEW_V cs_default_time_window NOPRI;
SELECT CASE
WHEN TO_NUMBER('&&cs_hours_range_default.') / 24 = ROUND(TO_NUMBER('&&cs_hours_range_default.') / 24) THEN '-'||TRIM(ROUND(TO_NUMBER('&&cs_hours_range_default.') / 24))||'d'
ELSE '-&&cs_hours_range_default.h'
END cs_default_time_window
FROM DUAL
/
--
PRO
COL snap_id FOR 9999999;
COL cs_time_from_default NEW_V cs_time_from_default NOPRI;
COL cs_time_to_default NEW_V cs_time_to_default NOPRI;
SELECT TO_CHAR(SYSDATE-(&&cs_hours_range_default./24),'&&cs_datetime_full_format.') cs_time_from_default, TO_CHAR(SYSDATE,'&&cs_datetime_full_format.') cs_time_to_default FROM DUAL
/
--
PRO
PRO Current Date and Time is: &&cs_date_time.
PRO Default Time Window: "&&cs_default_time_window." (i.e. FROM="now&&cs_default_time_window." and TO="now")
PRO Time can be entered as: "now", "-Nd" (minus N days), "-Nh" (minus N hours), "-Nm" (minus N minutes), or on partial format "&&cs_datetime_display_format."
PRO
PRO 1. Enter Time FROM: [{&&cs_default_time_window.(&&cs_time_from_default.)}|-Nd|-Nh|-Nm|&&cs_datetime_display_format.]
DEF cs_entered_time_from = '&1.';
UNDEF 1;
COL cs_sample_time_from NEW_V cs_sample_time_from NOPRI;
SELECT CASE
WHEN '&cs_entered_time_from.' IS NULL THEN '&&cs_time_from_default.'
WHEN LOWER('&cs_entered_time_from.') LIKE '%d%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_from.'), ' '), '-'), 'd')), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_from.') LIKE '%h%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_from.'), ' '), '-'), 'h') / 24), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_from.') LIKE '%m%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_from.'), ' '), '-'), 'm') / 24 / 60), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_from.') LIKE '%now%' THEN TO_CHAR(SYSDATE, '&&cs_datetime_full_format.')
ELSE '&cs_entered_time_from.'
END cs_sample_time_from
FROM DUAL
/
PRO
PRO 2. Enter Time TO: [{now(&&cs_time_to_default.)}|-Nd|-Nh|-Nm|&&cs_datetime_display_format.]
DEF cs_entered_time_to = '&2.';
UNDEF 2;
COL cs_sample_time_to NEW_V cs_sample_time_to NOPRI;
SELECT CASE
WHEN '&cs_entered_time_to.' IS NULL THEN '&&cs_time_to_default.'
WHEN LOWER('&cs_entered_time_to.') LIKE '%d%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_to.'), ' '), '-'), 'd')), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_to.') LIKE '%h%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_to.'), ' '), '-'), 'h') / 24), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_to.') LIKE '%m%' THEN TO_CHAR(SYSDATE - TO_NUMBER(REPLACE(REPLACE(REPLACE(LOWER('&cs_entered_time_to.'), ' '), '-'), 'm') / 24 / 60), '&&cs_datetime_full_format.')
WHEN LOWER('&cs_entered_time_to.') LIKE '%now%' THEN TO_CHAR(SYSDATE, '&&cs_datetime_full_format.')
ELSE '&cs_entered_time_to.'
END cs_sample_time_to
FROM DUAL
/
--
COL cs_hAxis_maxValue NEW_V cs_hAxis_maxValue NOPRI;
WITH
max_value AS (
SELECT CASE
WHEN '&&cs_sample_time_to.' = '&&cs_time_to_default.' OR (SYSDATE - TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.')) / (SYSDATE - TO_DATE('&&cs_sample_time_from.', '&&cs_datetime_full_format.')) < 0.1 THEN
TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.') + ((TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.') - TO_DATE('&&cs_sample_time_from.', '&&cs_datetime_full_format.')) * TO_NUMBER('&&hAxis_maxValue_forecast.'))
END AS time
FROM DUAL
)
SELECT CASE
WHEN v.time IS NOT NULL THEN
'maxValue: new Date('||
TO_CHAR(v.time, 'YYYY')|| /* year */
','||(TO_NUMBER(TO_CHAR(v.time, 'MM')) - 1)|| /* month - 1 */
','||TO_CHAR(v.time, 'DD')|| /* day */
','||TO_CHAR(v.time, 'HH24')|| /* hour */
','||TO_CHAR(v.time, 'MI')|| /* minute */
','||TO_CHAR(v.time, 'SS')|| /* second */
'), '
END AS cs_hAxis_maxValue
FROM max_value v
/
csierra/cs_internal/cs_sessions_by_machine_footer.sql
+15
View File
@@ -0,0 +1,15 @@
PRO <pre>
PRO #01 &&series_01.
PRO #02 &&series_02.
PRO #03 &&series_03.
PRO #04 &&series_04.
PRO #05 &&series_05.
PRO #06 &&series_06.
PRO #07 &&series_07.
PRO #08 &&series_08.
PRO #09 &&series_09.
PRO #10 &&series_10.
PRO #11 &&series_11.
PRO #12 &&series_12.
PRO #13 &&series_13.
PRO </pre>
csierra/cs_internal/cs_set.sql
+18
View File
@@ -0,0 +1,18 @@
WHENEVER SQLERROR CONTINUE;
SET TERM OFF;
STORE SET "/tmp/cs_store_set.sql" REP;
SET TERM ON HEA ON LIN 2490 PAGES 100 TAB OFF FEED OFF ECHO OFF VER OFF TRIMS ON TRIM ON TI OFF TIMI OFF LONG 240000 LONGC 2400 NUM 20 SERVEROUT OFF;
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD"T"HH24:MI:SS';
ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD"T"HH24:MI:SS.FF3';
--ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT='YYYY-MM-DD"T"HH24:MI:SS.FF3 TZR';
ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT='YYYY-MM-DD"T"HH24:MI:SS.FF3';
ALTER SESSION SET STATISTICS_LEVEL = 'ALL';
-- ALTER SESSION SET "_px_cdb_view_enabled" = FALSE; -- set at CDB level on IOD (ODIS)
--
-- setting hidden parameter "_with_subquery" [{OPTIMIZER}|MATERIALIZE|INLINE]
-- workaround for bug: ORA-00600: internal error code, arguments: [qks3tGCL:1]: set to INLINE
-- ALTER SESSION SET "_with_subquery" = INLINE;
-- workaround for ORA-32036: unsupported case for inlining of query name in WITH clause" on DBMS_SQLTUNE.report_sql_monitor: set to MATERIALIZE (or OPTIMIZER)
-- ALTER SESSION SET "_with_subquery" = MATERIALIZE;
-- ALTER SESSION SET "_with_subquery" = OPTIMIZER; -- removing because of (ODIS)
--
csierra/cs_internal/cs_set_container_to_cdb_root.sql
+2
View File
@@ -0,0 +1,2 @@
COMMIT;
ALTER SESSION SET container = CDB$ROOT;
csierra/cs_internal/cs_set_container_to_curr_pdb.sql
+2
View File
@@ -0,0 +1,2 @@
COMMIT;
ALTER SESSION SET CONTAINER = &&cs_con_name.;
csierra/cs_internal/cs_set_quota_tools_owner.sql
+6
View File
@@ -0,0 +1,6 @@
-- gets tablespace
COL cs_default_tablespace NEW_V cs_default_tablespace NOPRI;
SELECT default_tablespace AS cs_default_tablespace FROM dba_users WHERE username = UPPER('&&cs_stgtab_owner.');
-- set unlimited quota
ALTER USER &&cs_stgtab_owner. QUOTA UNLIMITED ON &&cs_default_tablespace.;
--
csierra/cs_internal/cs_signature.sql
+216
View File
@@ -0,0 +1,216 @@
COL cs_signature NEW_V cs_signature FOR A20 NOPRI;
COL cs_sql_hv NEW_V cs_sql_hv FOR A5 NOPRI;
COL cs_sql_handle NEW_V cs_sql_handle FOR A20 NOPRI;
COL cs_zapper_managed_sql NEW_V cs_zapper_managed_sql NOPRI;
DEF cs_parsing_schema_name = '';
COL cs_parsing_schema_name NEW_V cs_parsing_schema_name FOR A128 NOPRI;
DEF cs_first_rows_candidacy = 'Candidacy only applies to KIEV performScanQuery';
COL cs_first_rows_candidacy NEW_V cs_first_rows_candidacy NOPRI;
DEF cs_application_category = 'UN';
COL cs_application_category NEW_V cs_application_category NOPRI;
--
VAR cs_signature NUMBER;
VAR cs_sql_id VARCHAR2(13);
VAR cs_sql_text CLOB;
VAR cs_sql_text_1000 VARCHAR2(1000);
VAR cs_parsing_schema_name VARCHAR2(128);
--
-- some times sql in v$sqlstats show a signature with value of 0 (e.g. /* populateBucketGCWorkspace */ KPT-35), so we get signature and sql_text from v$sql
BEGIN
IF :cs_signature IS NULL THEN
SELECT sql_id, exact_matching_signature, sql_fulltext, parsing_schema_name INTO :cs_sql_id, :cs_signature, :cs_sql_text, :cs_parsing_schema_name FROM v$sql WHERE sql_id = '&&cs_sql_id.' AND ROWNUM = 1;
IF :cs_signature = 0 THEN
:cs_signature := DBMS_SQLTUNE.SQLTEXT_TO_SIGNATURE(:cs_sql_text);
END IF;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
:cs_sql_id := NULL;
:cs_signature := NULL;
:cs_sql_text := NULL;
:cs_parsing_schema_name := NULL;
END;
/
-- sometimes sql is not in memory but on awr, so we get sql_text from awr and we compute signature
BEGIN
IF :cs_signature IS NULL THEN
SELECT sql_id, sql_text INTO :cs_sql_id, :cs_sql_text FROM dba_hist_sqltext WHERE sql_id = '&&cs_sql_id.' AND ROWNUM = 1;
:cs_signature := DBMS_SQLTUNE.SQLTEXT_TO_SIGNATURE(:cs_sql_text);
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
:cs_sql_id := NULL;
:cs_signature := NULL;
:cs_sql_text := NULL;
END;
/
-- most times sql is in memory, so we get signature and sql_text from v$sqlstats
-- some times sql in v$sqlstats show a signature with value of 0 (e.g. /* populateBucketGCWorkspace */ KPT-35), so we compute signature if 0
-- moving this block to end
BEGIN
IF :cs_signature IS NULL THEN
SELECT sql_id, exact_matching_signature, sql_fulltext INTO :cs_sql_id, :cs_signature, :cs_sql_text FROM v$sqlstats WHERE sql_id = '&&cs_sql_id.' AND ROWNUM = 1;
IF :cs_signature = 0 THEN
:cs_signature := DBMS_SQLTUNE.SQLTEXT_TO_SIGNATURE(:cs_sql_text);
END IF;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
:cs_sql_id := NULL;
:cs_signature := NULL;
:cs_sql_text := NULL;
END;
/
-- next we try to get signature from an existing sql plan baseline
BEGIN
IF :cs_signature IS NULL THEN
SELECT SUBSTR(description, INSTR(description, 'SQL_ID=') + 7, 13), signature, sql_text, parsing_schema_name INTO :cs_sql_id, :cs_signature, :cs_sql_text, :cs_parsing_schema_name FROM dba_sql_plan_baselines WHERE SUBSTR(description, INSTR(description, 'SQL_ID=') + 7, 13) = '&&cs_sql_id.' AND ROWNUM = 1;
IF :cs_signature = 0 THEN
:cs_signature := DBMS_SQLTUNE.SQLTEXT_TO_SIGNATURE(:cs_sql_text);
END IF;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
:cs_sql_id := NULL;
:cs_signature := NULL;
:cs_sql_text := NULL;
:cs_parsing_schema_name := NULL;
END;
/
-- remove trim spaces from sql_text and get first 1000 characters
BEGIN
:cs_sql_text := TRIM(:cs_sql_text);
:cs_sql_text_1000 := SUBSTR(REGEXP_REPLACE(:cs_sql_text, '[^[:print:]]', ''), 1, 1000);
END;
/
-- compute sql_hv (to be moved to "connects to cdb, execute iod apis, and reconnect to pdb")
WITH
FUNCTION get_sql_hv (p_sqltext IN CLOB)
RETURN VARCHAR2
IS
l_sqltext CLOB := REGEXP_REPLACE(p_sqltext, '/\* REPO_[A-Z0-9]{1,25} \*/ '); -- removes "/* REPO_IFCDEXZQGAYDAMBQHAYQ */ " DBPERF-8819
BEGIN
IF l_sqltext LIKE '%/* %(%,%)% [%] */%' THEN l_sqltext := REGEXP_REPLACE(l_sqltext, '\[([[:digit:]]{4,5})\] '); END IF; -- removes bucket_id "[1001] "
RETURN LPAD(MOD(DBMS_SQLTUNE.sqltext_to_signature(l_sqltext),100000),5,'0');
END get_sql_hv;
SELECT get_sql_hv(:cs_sql_text) AS cs_sql_hv FROM DUAL
/
--
-- get signature, sql_handle and parsing_schema into sql variables
SELECT TO_CHAR(:cs_signature) AS cs_signature FROM DUAL;
SELECT sql_handle AS cs_sql_handle FROM dba_sql_plan_baselines WHERE signature = :cs_signature AND ROWNUM = 1;
SELECT :cs_parsing_schema_name AS cs_parsing_schema_name FROM DUAL;
--
-- get first_rows optimzation candidacy for kiev scans
WITH
kiev_scan AS (
SELECT
-- returns count of OR predicates such as ' < :5 ) OR'
-- when > 0 then this is a pagination (continue) scan, and when = 0 then this is a begin scan
REGEXP_COUNT(:cs_sql_text, '( >=? | <=? ):\d+ \) OR ?$', 1, 'cm') AS or_count,
-- gets position of 1st character after 2nd ORDER BY
-- then counts columns referenced by the main query's ORDER BY
REGEXP_COUNT(:cs_sql_text, ' (ASC|DESC)(,|$)', REGEXP_INSTR(:cs_sql_text, 'ORDER BY', 1, 2, 1, 'c'), 'cm') AS ic_count,
-- counts "greater than" (or "less than") operands
-- then computes position of first character ')' after bind reference of last "greater than" (or "less than") operand
-- returning the nunber of equality predicates on the prefix portion of the filters (i.e.: after all pagination predicates)
REGEXP_COUNT(:cs_sql_text, '\(\w+ = :\d+ \)', GREATEST(REGEXP_INSTR(:cs_sql_text, '( > | < ):\d+ ', 1, GREATEST(REGEXP_COUNT(:cs_sql_text, '( > | < ):\d+ '), 1), 1), 1)) AS ep_count
FROM DUAL
WHERE :cs_sql_text LIKE '%/* performScanQuery(%,%) %'
)
SELECT CASE
-- WHEN :cs_sql_text LIKE '%(futureWork,resumptionTimestamp)%'
-- OR :cs_sql_text LIKE '%(leaseDecorators,ae_timestamp_index)%'
-- OR :cs_sql_text LIKE '%(WORK_PARTITIONS_BUCKET,WORK_PARTITIONS_BUCKETIdx)%' -- KIEV99A2 FLAMINGOCPDB d41w5f7gnhg2b
-- OR :cs_sql_text LIKE '%(LEASE,state_index)%' -- KIEV99RG IDENTITY_R1_ALPHA an1n9htmx7wss
-- THEN 'Bad CANDIDATE: Known SQL, which requires a specific execution plan'
WHEN :cs_sql_text LIKE '%AND (1 = 1)%' THEN 'Good CANDIDATE: Non-prefixed begin scan (expect a leading full index scan)'
WHEN or_count = 0 THEN 'Good CANDIDATE: Prefixed begin scan or simple continue scan without or_operands (expect a leading range index scan)'
WHEN ic_count = ep_count + 1 THEN 'Good CANDIDATE: Continue scan with: or_operands = '||TRIM(or_count)||', order-by_index_columns = '||TRIM(ic_count)||', prefixed_equality_predicates = '||TRIM(ep_count)||' (expect a leading range index scan)'
WHEN ep_count > 0 THEN 'Poor Candidate: Continue scan with: or_operands = '||TRIM(or_count)||', order-by_index_columns = '||TRIM(ic_count)||', prefixed_equality_predicates = '||TRIM(ep_count)||' (a leading range index scan might be possible but not necessarily efficient)'
WHEN ic_count <> ep_count + 1 THEN 'Bad CANDIDATE: Continue scan with: or_operands = '||TRIM(or_count)||', order-by_index_columns = '||TRIM(ic_count)||', prefixed_equality_predicates = '||TRIM(ep_count)||' (expect some suboptimal plan with a full scan)'
ELSE 'Unexpected'
END AS cs_first_rows_candidacy
FROM kiev_scan
/
--
COL dummy NOPRI;
--
-- connects to cdb, execute iod apis, and reconnect to pdb
--
@@&&cs_set_container_to_cdb_root.
SELECT dummy
&&cs_skip.,&&cs_tools_schema..IOD_SPM.application_category(p_sql_text => DBMS_LOB.substr(:cs_sql_text, 1000)) AS cs_application_category
&&cs_skip.,&&cs_tools_schema..IOD_SPM.first_rows_candidate(p_sql_text => :cs_sql_text) AS cs_first_rows_candidacy
&&cs_skip.,&&cs_tools_schema..IOD_SPM.get_sql_hv(p_sql_text => :cs_sql_text) AS cs_sql_hv,
CASE WHEN (SELECT COUNT(*) FROM &&cs_tools_schema..zapper_sql_plan_bank WHERE UPPER(:cs_sql_text) LIKE UPPER('%'||sql_text_string||'%')) > 0 THEN 'Y' ELSE 'N' END AS cs_zapper_managed_sql
FROM DUAL
WHERE :cs_sql_text IS NOT NULL
/
@@&&cs_set_container_to_curr_pdb.
--
-- gets banner message in case sql is ma managed by zapper
--
BEGIN
IF '&&cs_zapper_managed_sql.' = 'Y' THEN
:cs_zapper_managed_sql_banner := '***'||CHR(10)||'*** This SQL is managed by ZAPPER'||CHR(10)||'***'||CHR(10)||CHR(10)||:cs_sql_text;
ELSE
:cs_zapper_managed_sql_banner := :cs_sql_text;
END IF;
END;
/
--
-- get kiev table name parsing sql_text
DEF cs_kiev_table_name = '';
COL cs_kiev_table_name NEW_V cs_kiev_table_name NOPRI;
VAR cs_kiev_table_name VARCHAR2(128);
SELECT NVL(SUBSTR(:cs_sql_text, INSTR(:cs_sql_text, '(') + 1, LEAST(INSTR(:cs_sql_text||',', ','), INSTR(:cs_sql_text||')', ')')) - INSTR(:cs_sql_text, '(') - 1), 'null') AS cs_kiev_table_name FROM DUAL WHERE :cs_sql_text LIKE '%/* %(%) %*/%';
EXEC :cs_kiev_table_name := '&&cs_kiev_table_name.';
--
-- get table owner and name out of sql_area (object dependencies)
DEF table_owner = '';
DEF table_name = '';
COL table_owner NEW_V table_owner NOPRI;
COL table_name NEW_V table_name NOPRI;
SELECT owner AS table_owner, table_name FROM dba_tables WHERE table_name = UPPER('&&cs_kiev_table_name.') ORDER BY num_rows DESC NULLS LAST FETCH FIRST 1 ROW ONLY;
-- /* kiev SQL references one table (most of the cases). if SQL references more than one table then only was is returned */
-- SELECT d.to_owner AS table_owner,
-- d.to_name AS table_name
-- FROM v$sqlarea a,
-- v$object_dependency d
-- WHERE '&&table_owner.' IS NULL
-- AND a.con_id = TO_NUMBER('&&cs_con_id.')
-- AND a.sql_id = '&&cs_sql_id.'
-- AND d.from_hash = a.hash_value
-- AND d.from_address = a.address
-- AND d.con_id = a.con_id
-- AND d.to_type = 2
-- AND d.to_name <> 'KIEVGCTEMPTABLE' /* exclude this common kiev table */
-- ORDER BY d.to_owner, d.to_name -- to make this query deterministic when executed multiple times on same sql_id and con_id
-- FETCH FIRST 1 ROW ONLY;
--
WITH /* get_table_token */
v$metricname AS (
SELECT /*+ NO_MERGE */
hash_value, address
FROM v$sqlarea
WHERE '&&table_owner.' IS NULL
AND sql_id = '&&cs_sql_id.'
AND con_id = TO_NUMBER('&&cs_con_id.')
)
SELECT o.to_owner AS table_owner, o.to_name AS table_name
FROM v$object_dependency o,
v$metricname s
WHERE '&&table_owner.' IS NULL
AND o.from_hash = s.hash_value
AND o.from_address = s.address
AND o.con_id = TO_NUMBER('&&cs_con_id.')
AND o.to_type = 2 -- table
AND o.to_name <> 'KIEVGCTEMPTABLE' /* exclude this common kiev table */
ORDER BY o.to_owner, o.to_name -- to make this query deterministic when executed multiple times on same sql_id and con_id
/* kiev SQL references one table (most of the cases). if SQL references more than one table then only was is returned */
FETCH FIRST 1 ROW ONLY;
--
-- reset table_owner and table_name columns
COL table_owner PRI;
COL table_name PRI;
csierra/cs_internal/cs_snap_id_from_and_to.sql
+71
View File
@@ -0,0 +1,71 @@
--
DEF cs_snap_id_from = '';
DEF cs_snap_id_to = '';
COL cs_snap_id_from NEW_V cs_snap_id_from NOPRI;
COL cs_snap_id_to NEW_V cs_snap_id_to NOPRI;
--
SELECT TO_CHAR(snap_id) cs_snap_id_from
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND CAST(begin_interval_time AS DATE) <= TO_DATE('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND CAST(end_interval_time AS DATE) > TO_DATE('&&cs_sample_time_from.', '&&cs_datetime_full_format.')
AND begin_interval_time <> startup_time -- filter out bogus data
AND end_interval_time <> startup_time -- filter out bogus data
/
SELECT TO_CHAR(snap_id) cs_snap_id_to
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND CAST(begin_interval_time AS DATE) < TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND CAST(end_interval_time AS DATE) >= TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.')
AND begin_interval_time <> startup_time -- filter out bogus data
AND end_interval_time <> startup_time -- filter out bogus data
/
SELECT COALESCE('&&cs_snap_id_from.', TO_CHAR(MIN(snap_id))) AS cs_snap_id_from,
COALESCE('&&cs_snap_id_to.', TO_CHAR(MAX(snap_id))) AS cs_snap_id_to
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND begin_interval_time <> startup_time -- filter out bogus data
AND end_interval_time <> startup_time -- filter out bogus data
/
--
DEF cs_begin_date_from = '&&cs_sample_time_from.';
DEF cs_end_date_to = '&&cs_sample_time_to.';
COL cs_begin_date_from NEW_V cs_begin_date_from NOPRI;
COL cs_end_date_to NEW_V cs_end_date_to NOPRI;
--
SELECT TO_CHAR(begin_interval_time, '&&cs_datetime_full_format.') cs_begin_date_from
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id = TO_NUMBER('&&cs_snap_id_from.')
/
SELECT TO_CHAR(end_interval_time, '&&cs_datetime_full_format.') cs_end_date_to
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND snap_id = TO_NUMBER('&&cs_snap_id_to.')
/
--
COL cs_begin_end_seconds NEW_V cs_begin_end_seconds NOPRI;
SELECT TRIM(TO_CHAR(ROUND((TO_DATE('&&cs_end_date_to.', '&&cs_datetime_full_format.') - TO_DATE('&&cs_begin_date_from.', '&&cs_datetime_full_format.')) * 24 * 3600))) AS cs_begin_end_seconds FROM DUAL
/
--
COL cs_from_to_seconds NEW_V cs_from_to_seconds NOPRI;
SELECT TRIM(TO_CHAR(ROUND((TO_DATE('&&cs_sample_time_to.', '&&cs_datetime_full_format.') - TO_DATE('&&cs_sample_time_from.', '&&cs_datetime_full_format.')) * 24 * 3600))) AS cs_from_to_seconds FROM DUAL
/
--
COL cs_snap_id_max NEW_V cs_snap_id_max NOPRI;
COL cs_end_interval_time_max NEW_V cs_end_interval_time_max NOPRI;
SELECT TO_CHAR(snap_id) AS cs_snap_id_max, TO_CHAR(end_interval_time, '&&cs_timestamp_full_format.') AS cs_end_interval_time_max
FROM dba_hist_snapshot
WHERE dbid = TO_NUMBER('&&cs_dbid.')
AND instance_number = TO_NUMBER('&&cs_instance_number.')
AND end_interval_time < SYSTIMESTAMP
ORDER BY
snap_id DESC
FETCH FIRST 1 ROWS ONLY
/
--
csierra/cs_internal/cs_spbl_create_post.sql
+125
View File
@@ -0,0 +1,125 @@
---------------------------------------------------------------------------------------
--
-- disable baselines on this sql if metadata is corrupt (ORA-13831)
--
DECLARE
l_plans INTEGER;
l_plans_t INTEGER := 0;
l_description VARCHAR2(500);
BEGIN
FOR i IN (SELECT t.sql_handle,
o.name plan_name,
a.description
FROM sqlobj$plan p,
sqlobj$ o,
sqlobj$auxdata a,
sql$text t
WHERE p.signature = :cs_signature
AND p.obj_type = 2 /* 1=profile, 2=baseline, 3=patch */
AND p.id = 1
AND p.other_xml IS NOT NULL
-- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
AND p.plan_id <> TO_NUMBER(extractvalue(xmltype(p.other_xml),'/*/info[@type = "plan_hash_2"]'))
AND o.obj_type = 2 /* 1=profile, 2=baseline, 3=patch */
AND o.signature = p.signature
AND o.plan_id = p.plan_id
AND BITAND(o.flags, 1) = 1 /* enabled */
AND a.obj_type = 2 /* 1=profile, 2=baseline, 3=patch */
AND a.signature = p.signature
AND a.plan_id = p.plan_id
AND a.created > TO_DATE('&&creation_time.', '&&cs_datetime_full_format.') - 1/1440
AND t.signature = p.signature
ORDER BY
t.sql_handle,
o.name)
LOOP
l_plans := DBMS_SPM.alter_sql_plan_baseline(sql_handle => i.sql_handle, plan_name => i.plan_name, attribute_name => 'ENABLED', attribute_value => 'NO');
l_description := TRIM(i.description||' cs_spbl_create.sql ORA-13831 DISABLED='||TO_CHAR(SYSDATE, '&&cs_datetime_full_format.'));
DBMS_OUTPUT.put_line('disable baseline since metadata is corrupt (ORA-13831): '||i.sql_handle||' '||i.plan_name||' '||l_description);
l_plans := DBMS_SPM.alter_sql_plan_baseline(sql_handle => i.sql_handle, plan_name => i.plan_name, attribute_name => 'DESCRIPTION', attribute_value => l_description);
l_plans_t := l_plans_t + l_plans;
END LOOP;
END;
/
--
---------------------------------------------------------------------------------------
--
-- disable baselines on this sql if metadata is corrupt (ORA-06512)
--
DECLARE
l_plans INTEGER;
l_plans_t INTEGER := 0;
l_description VARCHAR2(500);
BEGIN
FOR i IN (SELECT t.sql_handle,
o.name plan_name,
a.description
FROM sys.sqlobj$ o,
sys.sql$text t,
sys.sqlobj$auxdata a
WHERE o.signature = :cs_signature
AND o.obj_type = 2 /* 1=profile, 2=baseline, 3=patch */
AND BITAND(o.flags, 1) = 1 /* enabled */
AND t.signature = o.signature
AND a.obj_type = o.obj_type
AND a.signature = o.signature
AND a.plan_id = o.plan_id
AND a.created > TO_DATE('&&creation_time.', '&&cs_datetime_full_format.') - 1/1440
AND NOT EXISTS
( SELECT NULL
FROM sys.sqlobj$plan p
WHERE p.signature = o.signature
AND p.obj_type = o.obj_type
AND p.plan_id = o.plan_id
)
ORDER BY
o.plan_id)
LOOP
l_plans := DBMS_SPM.alter_sql_plan_baseline(sql_handle => i.sql_handle, plan_name => i.plan_name, attribute_name => 'ENABLED', attribute_value => 'NO');
l_description := i.description||' cs_spbl_create.sql ORA-06512 DISABLED='||TO_CHAR(SYSDATE, '&&cs_datetime_full_format.');
DBMS_OUTPUT.put_line('disable baseline since metadata is corrupt (ORA-06512): '||i.sql_handle||' '||i.plan_name||' '||l_description);
l_plans := DBMS_SPM.alter_sql_plan_baseline(sql_handle => i.sql_handle, plan_name => i.plan_name, attribute_name => 'DESCRIPTION', attribute_value => l_description);
l_plans_t := l_plans_t + l_plans;
END LOOP;
END;
/
--
---------------------------------------------------------------------------------------
--
-- fix Corrupt Baseline (DBPERF-6822)
--
MERGE INTO sys.sqlobj$plan t
USING (SELECT o.signature,
o.category,
o.obj_type,
o.plan_id,
1 AS id
FROM sys.sqlobj$ o
WHERE o.category = 'DEFAULT'
AND o.obj_type = 2
AND o.signature = :cs_signature
AND NOT EXISTS (
SELECT NULL
FROM sys.sqlobj$plan p
WHERE p.signature = o.signature
AND p.category = o.category
AND p.obj_type = o.obj_type
AND p.plan_id = o.plan_id
AND p.id = 1
)
AND NOT EXISTS (
SELECT NULL
FROM sys.sqlobj$data d
WHERE d.signature = o.signature
AND d.category = o.category
AND d.obj_type = o.obj_type
AND d.plan_id = o.plan_id
AND d.comp_data IS NOT NULL
)) s
ON (t.signature = s.signature AND t.category = s.category AND t.obj_type = s.obj_type AND t.plan_id = s.plan_id AND t.id = s.id)
WHEN NOT MATCHED THEN
INSERT (signature, category, obj_type, plan_id, id)
VALUES (s.signature, s.category, s.obj_type, s.plan_id, s.id)
/
COMMIT
/
csierra/cs_internal/cs_spbl_create_pre.sql
+19
View File
@@ -0,0 +1,19 @@
---------------------------------------------------------------------------------------
--
-- cleaup unrelated outdated sql tuning sets (created by older versions of this script)
--
BEGIN
FOR i IN (SELECT created, owner, name FROM wri$_sqlset_definitions WHERE created < SYSDATE - 1 AND name LIKE 'S%' AND statement_count = 1 ORDER BY 1)
LOOP
DBMS_OUTPUT.put_line('dropping unrelated and outdated sts '||i.owner||' '||i.name||' created on '||TO_CHAR(i.created, '&&cs_datetime_full_format.'));
DBMS_SQLTUNE.drop_sqlset(sqlset_name => i.name, sqlset_owner => i.owner);
END LOOP;
END;
/
--
-- Oracle Support Document 1276524.1 (ORA-13757: Can't drop SQL Tuning Set) can be found at: https://support.oracle.com/epmos/faces/DocumentDisplay?id=1276524.1
-- in case of ORA-13757: "SQL Tuning Set" "SQL_DETAIL_1491025646579" owned by user "SYS" is active.
-- select description, created, owner from DBA_SQLSET_REFERENCES where sqlset_name = 'SQL_DETAIL_1491025646579';
-- exec DBMS_SQLTUNE.DROP_TUNING_TASK('SQL_TUNING_1491025649684'); -- take value from description (e.g.: "created by: SQL Tuning Advisor - task: SQL_TUNING_1491025649684")
-- exec dbms_sqltune.drop_sqlset('SQL_DETAIL_1491025646579','SYS');
--
csierra/cs_internal/cs_spbl_evolve_internal.sql
+668
View File
@@ -0,0 +1,668 @@
DECLARE
--
-- create staging table for baselines if it does not exist
--
l_count NUMBER;
l_tablespace_name VARCHAR2(128);
l_max_bytes NUMBER;
BEGIN
SELECT COUNT(*) INTO l_count FROM dba_tables WHERE owner = 'C##IOD' AND table_name = 'IOD_STGTAB_BASELINE';
IF l_count = 0 THEN
SELECT default_tablespace INTO l_tablespace_name FROM dba_users WHERE username = 'C##IOD';
SELECT NVL(MAX(max_bytes), 0) INTO l_max_bytes FROM dba_ts_quotas WHERE username = 'C##IOD' AND tablespace_name = l_tablespace_name;
IF l_max_bytes <> -1 THEN -- -1 means unlimited
EXECUTE IMMEDIATE 'ALTER USER C##IOD QUOTA UNLIMITED ON '||l_tablespace_name;
END IF;
DBMS_SPM.create_stgtab_baseline(table_name => 'IOD_STGTAB_BASELINE', table_owner => 'C##IOD', tablespace_name => l_tablespace_name);
END IF;
END;
/
--
VAR x_report CLOB;
EXEC :x_report := NULL;
SET SERVEROUT ON;
DECLARE
--
-- this pl/sql block does a spm plan evolution on a sql statement by creating first a whole fresh set of plans on plan history.
-- the core concept is that we need a fresh set of binds captured into their respective plans so the plan evolution has a chance of avoiding false positives.
-- a false positive is a plan which spm evolution suggests it performs better when evaluated using outdated binds (with currently no matching rows).
-- steps:
-- 0. validates the sql has executed at least 5 times since last awr, and that at least 5 seconds have passed since such last awr, then computes sleep between operations.
-- 1. create or recreate a sql plan baseline (enabled and accepted) for whatever is the current plan in use.
-- 2. drop all other plans on plan history (baselines other than current plan) as well as drop all sql profiles and sql patches.
-- 3. add fresh entries on plan history for known awr historical plans (enabled but not accepted) using staging sql profiles.
-- 4. add fresh entries on plan history for all iod historical plans using staging sql profiles.
-- 5. add fresh entries on plan history for known promising cbo hints (enabled but not accepted).
-- 6. execute spm plan evolution accepting plan(s) that perform better than current (while using fresh bind variable values).
-- 7. if some plan(s) was/were evolved then disable baseline for current plan so the evolved plan(s) is/are forced to be used.
-- 8. briefly monitor the performance of the new plan(s) and if it/them under-perform(s) prior plan then disable evolved plan(s) and restore basline for prior plan.
--
p_sql_id CONSTANT VARCHAR2(13) := :cs_sql_id;
p_signature CONSTANT NUMBER := :cs_signature;
p_sql_text CONSTANT CLOB := :cs_sql_text;
p_kiev_table_name VARCHAR2(128) := :cs_kiev_table_name;
--
k_begin_time CONSTANT TIMESTAMP(6) := SYSTIMESTAMP;
k_staging_name CONSTANT VARCHAR2(30) := TO_CHAR(k_begin_time, '"S"YYYYMMDD"T"HH24MISS')||'_'||UPPER(p_sql_id);
--
l_seconds_since_last_awr NUMBER;
l_sleep_seconds NUMBER;
l_current_et_ms_per_exec NUMBER;
l_current_delta_exec_count NUMBER;
l_current_sql_plan_baseline VARCHAR2(128);
l_current_plan_hash_value NUMBER;
l_current_sql_profile VARCHAR2(128);
l_current_sql_patch VARCHAR2(128);
l_basic_filter VARCHAR2(4000);
l_begin_snap NUMBER;
l_end_snap NUMBER;
l_plans PLS_INTEGER;
l_evolved_plans PLS_INTEGER;
l_devolved_plans PLS_INTEGER;
l_verified_plans PLS_INTEGER;
l_sql_handle VARCHAR2(128);
l_current_plan_name VARCHAR2(128);
l_index INTEGER;
l_pos INTEGER;
l_hint VARCHAR2(32767);
l_profile_attr SYS.SQLPROF_ATTR;
l_leading_clause_kiev VARCHAR2(256);
l_name VARCHAR2(128);
l_task_name VARCHAR2(30);
l_execution_name VARCHAR2(30);
l_last_active_time DATE;
--
PROCEDURE put_line (p_line IN VARCHAR2)
IS
BEGIN
DBMS_OUTPUT.put_line(TO_CHAR(SYSTIMESTAMP, 'YYYY-MM-DD"T"HH24:MI:SS.FF3')||' '||p_line);
END put_line;
BEGIN
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 0. validates the sql has executed at least 5 times since last awr, and that at least 5 seconds have passed since such last awr, then computes sleep between operations.
--
-- ****************************************************************************************************************************************************************************************************************
--
put_line('sql_id:'||p_sql_id);
put_line('signature:'||p_signature);
--
-- computes a reasonable sleep time in seconds as 5x the average interval between two execution
-- computes current performance as average milliseconds per execution during the past
--
SELECT w.age_seconds AS seconds_since_last_awr,
s.delta_elapsed_time/GREATEST(s.delta_execution_count,1)/1e3 AS current_et_ms_per_exec,
s.delta_execution_count AS current_delta_exec_count
INTO l_seconds_since_last_awr, l_current_et_ms_per_exec, l_current_delta_exec_count
FROM v$sqlstats s,
(SELECT /*+ MATERIALIZE NO_MERGE GATHER_PLAN_STATISTICS MONITOR */
((86400 * EXTRACT(DAY FROM (SYSTIMESTAMP - MAX(end_interval_time))) + (3600 * EXTRACT(HOUR FROM (systimestamp - MAX(end_interval_time)))) + (60 * EXTRACT(MINUTE FROM (systimestamp - MAX(end_interval_time)))) + EXTRACT(SECOND FROM (systimestamp - MAX(end_interval_time))))) AS age_seconds
FROM dba_hist_snapshot
WHERE end_interval_time < SYSTIMESTAMP) w
WHERE sql_id = p_sql_id;
put_line('seconds_since_last_awr:'||l_seconds_since_last_awr);
put_line('current_delta_exec_count:'||l_current_delta_exec_count);
put_line('current_et_ms_per_exec:'||ROUND(l_current_et_ms_per_exec, 3));
--
IF l_current_delta_exec_count < 5 THEN
put_line('*** not enough executions:'||l_current_delta_exec_count||' (min is 5)');
RETURN;
END IF;
IF l_seconds_since_last_awr < 5 THEN
put_line('*** too recent awr snapshot:'||l_seconds_since_last_awr||' seconds (min is 5)');
RETURN;
END IF;
--
l_sleep_seconds := CEIL(10 * l_seconds_since_last_awr / NULLIF(l_current_delta_exec_count, 0)); -- during these many seconds we would expect the sql to execute 10x on average
put_line('sleep_seconds (computed):'||l_sleep_seconds);
l_sleep_seconds := GREATEST(l_sleep_seconds, 10); -- sleep at least 10 seconds between changes
put_line('sleep_seconds (adjusted):'||l_sleep_seconds);
--
-- get current sql_plan_baseline if any, together with plan_hash_value, sql_profile and sql_patch
--
SELECT sql_plan_baseline, plan_hash_value, sql_profile, sql_patch, 'sql_id = '''||sql_id||''' AND plan_hash_value <> '||plan_hash_value AS basic_filter
INTO l_current_sql_plan_baseline, l_current_plan_hash_value, l_current_sql_profile, l_current_sql_patch, l_basic_filter
FROM v$sql
WHERE sql_id = p_sql_id
ORDER BY
last_active_time DESC
FETCH FIRST 1 ROW ONLY;
--
put_line('current_plan_hash_value:'||l_current_plan_hash_value);
put_line('current_sql_plan_baseline:'||l_current_sql_plan_baseline);
put_line('current_sql_profile:'||l_current_sql_profile);
put_line('current_sql_patch:'||l_current_sql_patch);
put_line('basic_filter:'||l_basic_filter);
put_line('staging_name:'||k_staging_name);
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 1. create or recreate a sql plan baseline (enabled and accepted) for whatever is the current plan in use.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- create or replace sql_plan_baseline
--
l_plans :=
DBMS_SPM.load_plans_from_cursor_cache (
sql_id => p_sql_id,
plan_hash_value => l_current_plan_hash_value
);
IF l_plans > 0 THEN
--
-- get details about new (or re-created) plan
--
SELECT sql_handle, plan_name
INTO l_sql_handle, l_current_plan_name
FROM dba_sql_Plan_baselines
WHERE signature = p_signature
AND created >= k_begin_time
AND origin = 'MANUAL-LOAD-FROM-CURSOR-CACHE'
AND description IS NULL;
--
put_line('current_sql_handle:'||l_sql_handle);
put_line('current_plan_name:'||l_current_plan_name);
--
-- update description for new (or re-created) plan
--
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => l_current_plan_name,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||l_current_plan_hash_value||' STG='||k_staging_name||' USR=&&who_am_i.'
);
END IF;
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 2. drop all other plans on plan history (baselines other than current plan) as well as drop all sql profiles and sql patches.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- drop all plans on plan history other than the one just created for current plan_hash_value
-- this is needed since on plan evolution a plan is executed together with the binds that were caputred at the time the plan was created into plan history, which could be months old
--
FOR i IN (SELECT sql_handle, plan_name
FROM dba_sql_Plan_baselines
WHERE signature = p_signature
AND created < k_begin_time)
LOOP
--
-- remove from staging table a possible old version of the plan to be deleted
--
DELETE C##IOD.IOD_STGTAB_BASELINE
WHERE signature = p_signature
AND sql_handle = i.sql_handle
AND obj_name = i.plan_name;
--
-- back up the plan to be deleted
--
l_plans :=
DBMS_SPM.pack_stgtab_baseline (
table_name => 'IOD_STGTAB_BASELINE',
table_owner => 'C##IOD',
sql_handle => i.sql_handle,
plan_name => i.plan_name
);
put_line('packed plan '||i.plan_name);
--
-- delete the plan
--
l_plans :=
DBMS_SPM.drop_sql_plan_baseline (
sql_handle => i.sql_handle,
plan_name => i.plan_name
);
put_line('dropped plan '||i.plan_name);
END LOOP;
--
-- drop all profiles
--
FOR i IN (SELECT name
FROM dba_sql_profiles
WHERE signature = p_signature)
LOOP
DBMS_SQLTUNE.drop_sql_profile (
name => i.name
);
put_line('dropped profile '||i.name);
END LOOP;
--
-- drop all patches
--
FOR i IN (SELECT name
FROM dba_sql_patches
WHERE signature = p_signature)
LOOP
DBMS_SQLDIAG.drop_sql_patch (
name => i.name
);
put_line('dropped patch '||i.name);
END LOOP;
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 3. add fresh entries on plan history for known awr historical plans (enabled but not accepted) using staging sql profiles.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- for known plans on awr, create a staging sql profile so it would produce a fresh non-accepted plan on plan history
--
FOR i IN (WITH
plans AS (
SELECT plan_hash_value, other_xml, ROW_NUMBER() OVER(PARTITION BY plan_hash_value ORDER BY id) AS rn
FROM dba_hist_sql_plan
WHERE sql_id = p_sql_id
AND plan_hash_value <> l_current_plan_hash_value
AND other_xml IS NOT NULL
)
SELECT plan_hash_value, other_xml
FROM plans
WHERE rn = 1)
LOOP
put_line('plan_hash_value:'||i.plan_hash_value);
l_index := 1;
l_profile_attr := SYS.SQLPROF_ATTR('BEGIN_OUTLINE_DATA');
FOR j IN (SELECT x.outline_hint
FROM XMLTABLE('other_xml/outline_data/hint' PASSING XMLTYPE(i.other_xml) COLUMNS outline_hint VARCHAR2(4000) PATH '.') x)
LOOP
l_hint := j.outline_hint;
WHILE l_hint IS NOT NULL
LOOP
l_index := l_index + 1;
l_profile_attr.EXTEND;
IF LENGTH(l_hint) <= 500 THEN
l_profile_attr(l_index) := l_hint;
l_hint := NULL;
ELSE
l_pos := INSTR(SUBSTR(l_hint, 1, 500), ' ', -1);
l_profile_attr(l_index) := SUBSTR(l_hint, 1, l_pos);
l_hint := SUBSTR(l_hint, l_pos);
END IF;
END LOOP;
END LOOP;
l_index := l_index + 1;
l_profile_attr.EXTEND;
l_profile_attr(l_index) := 'END_OUTLINE_DATA';
-- FOR j IN 1 .. l_index
-- LOOP
-- put_line(l_profile_attr(j));
-- END LOOP;
-- creates or replace sql_profile
DBMS_SQLTUNE.import_sql_profile(
sql_text => p_sql_text,
profile => l_profile_attr,
name => k_staging_name,
description => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||i.plan_hash_value||' USR=&&who_am_i.',
category => 'DEFAULT',
validate => TRUE,
replace => TRUE
);
put_line('created sql profile for:'||i.plan_hash_value);
--
-- sleeps a few seconds to allow a non-accepted sql plan baseline to be created out of a sql profile
--
DBMS_LOCK.sleep(l_sleep_seconds);
--
-- drop sql profile (after an expected non-accepted sql plan baseline were created)
--
DBMS_SQLTUNE.drop_sql_profile (
name => k_staging_name
);
put_line('dropped sql profile for:'||i.plan_hash_value);
END LOOP;
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 4. add fresh entries on plan history for all iod historical plans using staging sql profiles.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- for known plans on iod history, create a staging sql profile so it would produce a fresh non-accepted plan on plan history
--
FOR i IN (WITH
plans AS (
SELECT plan_id, other_xml, ROW_NUMBER() OVER(PARTITION BY plan_id ORDER BY id) AS rn
FROM C##IOD.IOD_STGTAB_BASELINE
WHERE signature = p_signature
AND obj_name NOT IN (SELECT plan_name FROM dba_sql_plan_baselines WHERE signature = p_signature)
AND other_xml IS NOT NULL
)
SELECT plan_id, other_xml
FROM plans
WHERE rn = 1)
LOOP
put_line('plan_id:'||i.plan_id);
l_index := 1;
l_profile_attr := SYS.SQLPROF_ATTR('BEGIN_OUTLINE_DATA');
FOR j IN (SELECT x.outline_hint
FROM XMLTABLE('other_xml/outline_data/hint' PASSING XMLTYPE(i.other_xml) COLUMNS outline_hint VARCHAR2(4000) PATH '.') x)
LOOP
l_hint := j.outline_hint;
WHILE l_hint IS NOT NULL
LOOP
l_index := l_index + 1;
l_profile_attr.EXTEND;
IF LENGTH(l_hint) <= 500 THEN
l_profile_attr(l_index) := l_hint;
l_hint := NULL;
ELSE
l_pos := INSTR(SUBSTR(l_hint, 1, 500), ' ', -1);
l_profile_attr(l_index) := SUBSTR(l_hint, 1, l_pos);
l_hint := SUBSTR(l_hint, l_pos);
END IF;
END LOOP;
END LOOP;
l_index := l_index + 1;
l_profile_attr.EXTEND;
l_profile_attr(l_index) := 'END_OUTLINE_DATA';
-- FOR j IN 1 .. l_index
-- LOOP
-- put_line(l_profile_attr(j));
-- END LOOP;
-- creates or replace sql_profile
DBMS_SQLTUNE.import_sql_profile(
sql_text => p_sql_text,
profile => l_profile_attr,
name => k_staging_name,
description => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PLAN_ID='||i.plan_id||' USR=&&who_am_i.',
category => 'DEFAULT',
validate => TRUE,
replace => TRUE
);
put_line('created sql profile for:'||i.plan_id);
--
-- sleeps a few seconds to allow a non-accepted sql plan baseline to be created out of a sql profile
--
DBMS_LOCK.sleep(l_sleep_seconds);
--
-- drop sql profile (after an expected non-accepted sql plan baseline were created)
--
FOR j IN (SELECT name -- using a cursor since some other process (i.e.: zapper) would have dropped the sql profile
FROM dba_sql_profiles
WHERE signature = p_signature)
LOOP
DBMS_SQLTUNE.drop_sql_profile (
name => j.name
);
put_line('dropped sql profile '||j.name||' for:'||i.plan_id);
END LOOP;
END LOOP;
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 5. add fresh entries on plan history for known promising cbo hints (enabled but not accepted).
--
-- ****************************************************************************************************************************************************************************************************************
--
-- prepares leading_clause_kiev
--
IF p_kiev_table_name IS NOT NULL THEN
l_leading_clause_kiev := ' LEADING(@SEL$1 '||p_kiev_table_name||')';
END IF;
--
-- for a set of known cbo hints, create staging sql patches to produce fresh non-accepted plan(s) on plan history
--
FOR i IN (SELECT 'FIRST_ROWS' AS cbo_hints FROM DUAL
UNION ALL
SELECT 'FIRST_ROWS(1)' AS cbo_hints FROM DUAL
UNION ALL
SELECT 'FIRST_ROWS(1) OPT_PARAM(''_fix_control'' ''5922070:OFF'')'||l_leading_clause_kiev||' OPT_PARAM(''_b_tree_bitmap_plans'' ''FALSE'') OPT_PARAM(''_no_or_expansion'' ''TRUE'')' AS cbo_hints FROM DUAL)
LOOP
put_line('cbo_hints: /*+ '||i.cbo_hints||' */');
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
DBMS_SQLDIAG_INTERNAL.i_create_patch (
sql_text => p_sql_text,
hint_text => i.cbo_hints,
name => k_staging_name,
description => 'cs_spbl_evolve.sql /*+ '||i.cbo_hints||' */ USR=&&who_am_i.'
); -- 12c
$ELSE
l_name :=
DBMS_SQLDIAG.create_sql_patch (
sql_text => p_sql_text,
hint_text => i.cbo_hints,
name => k_staging_name,
description => 'cs_spbl_evolve.sql /*+ '||i.cbo_hints||' */ USR=&&who_am_i.'
); -- 19c
$END
put_line('created sql patch '||k_staging_name||' for: /*+ '||i.cbo_hints||' */');
--
-- sleeps a few seconds to allow a non-accepted sql plan baseline to be created out of a sql patch
--
DBMS_LOCK.sleep(l_sleep_seconds);
--
-- drop sql patch (after an expected non-accepted sql plan baseline were created)
--
FOR j IN (SELECT name -- using a cursor since some other process (i.e.: zapper) would have dropped the sql patch
FROM dba_sql_patches
WHERE signature = p_signature)
LOOP
DBMS_SQLDIAG.drop_sql_patch (
name => j.name
);
put_line('dropped sql patch '||j.name||' for: /*+ '||i.cbo_hints||' */');
END LOOP;
END LOOP;
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 6. execute spm plan evolution accepting plan(s) that perform better than current (while using fresh bind variable values).
--
-- ****************************************************************************************************************************************************************************************************************
--
-- create spm evolve task
--
l_task_name :=
DBMS_SPM.create_evolve_task (
sql_handle => l_sql_handle,
time_limit => LEAST(100 * l_sleep_seconds, 1800), -- seconds
task_name => k_staging_name,
description => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' USR=&&who_am_i.'
);
put_line('task_name:'||l_task_name);
--
-- execute spm evolve task
--
l_execution_name :=
DBMS_SPM.execute_evolve_task (
task_name => l_task_name,
execution_name => k_staging_name,
execution_desc => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' USR=&&who_am_i.'
);
put_line('execution_name:'||l_execution_name);
--
-- gets report of executed evolve task
--
:x_report :=
DBMS_SPM.report_evolve_task (
task_name => l_task_name,
type => 'TEXT', -- TEXT, HTML, XML
level => 'TYPICAL', -- BASIC, TYPICAL, ALL
section => 'ALL', -- SUMMARY, FINDINGS, PLANS, INFORMATION, ERRORS, ALL
execution_name => l_execution_name
);
--
-- implement spm evolved plans
--
l_plans :=
DBMS_SPM.implement_evolve_task (
task_name => l_task_name,
execution_name => l_execution_name
);
put_line('implemented plans:'||l_plans||' (could be overstated)');
--
-- drop spm evolve task
--
DBMS_SPM.drop_evolve_task (
task_name => l_task_name
);
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 7. if some plan(s) was/were evolved then disable baseline for current plan so the evolved plan(s) is/are forced to be used.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- check if there are actually any evolved plans
--
SELECT COUNT(*)
INTO l_evolved_plans
FROM dba_sql_Plan_baselines
WHERE signature = p_signature
AND plan_name <> l_current_plan_name
AND created >= k_begin_time
AND origin <> 'MANUAL-LOAD-FROM-CURSOR-CACHE'
AND accepted = 'YES'
AND description IS NULL;
put_line('evolved_plans:'||l_evolved_plans);
--
-- if there were evolved plan(s) then disable current plan and verify performance of new plan(s)
--
IF l_evolved_plans > 0 THEN
l_last_active_time := SYSDATE;
--
-- disable current plan and sleep
--
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => l_current_plan_name,
attribute_name => 'enabled',
attribute_value => 'NO'
);
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => l_current_plan_name,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||l_current_plan_hash_value||' STG='||k_staging_name||' USR=&&who_am_i. DISABLED'
);
put_line('disabled current_plan_name:'||l_current_plan_name);
--
-- sleeps a few seconds to allow evolved plan(s) to spin some executions
--
DBMS_LOCK.sleep(2 * l_sleep_seconds);
--
-- ****************************************************************************************************************************************************************************************************************
--
-- 8. briefly monitor the performance of the new plan(s) and if it/them under-perform(s) prior plan then disable evolved plan(s) and restore basline for prior plan.
--
-- ****************************************************************************************************************************************************************************************************************
--
-- verifies the performance of evolved plans and if worse than current plan then disable (devolve)
--
l_devolved_plans := 0;
l_verified_plans := 0;
FOR i IN (SELECT sql_plan_baseline, plan_hash_value,
SUM(executions) AS executions,
SUM(elapsed_time)/GREATEST(SUM(executions),1)/1e3 AS et_ms_per_exec
FROM v$sql
WHERE sql_id = p_sql_id
AND sql_plan_baseline IS NOT NULL
AND sql_plan_baseline <> l_current_sql_plan_baseline
AND last_active_time >= l_last_active_time
GROUP BY
sql_plan_baseline, plan_hash_value)
LOOP
put_line('plan:'||i.sql_plan_baseline||' phv:'||i.plan_hash_value||' executions:'||i.executions||' et_ms_per_exec:'||i.et_ms_per_exec);
--
-- if new plan has no executions or its performance is worse than current then disable it
--
IF i.executions = 0 OR i.et_ms_per_exec > l_current_et_ms_per_exec THEN
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => i.sql_plan_baseline,
attribute_name => 'enabled',
attribute_value => 'NO'
);
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => i.sql_plan_baseline,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||i.plan_hash_value||'EXEC='||i.executions||' MS_PER_EXEC:'||ROUND(i.et_ms_per_exec, 3)||' USR=&&who_am_i. DISABLED'
);
put_line('disabled evolved_plan_name:'||i.sql_plan_baseline);
l_devolved_plans := l_devolved_plans + l_plans;
ELSE -- evolved plan had some executions and its performance is better than current
--
-- document this plan has been evolved (and verified)
--
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => i.sql_plan_baseline,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||i.plan_hash_value||' EXECS='||i.executions||' MS_PER_EXEC:'||ROUND(i.et_ms_per_exec, 3)||' USR=&&who_am_i. VERIFIED EVOLVED'
);
put_line('verified evolved_plan_name:'||i.sql_plan_baseline);
l_verified_plans := l_verified_plans + l_plans;
END IF;
END LOOP;
put_line('devolved_plans:'||l_devolved_plans);
put_line('verified_plans:'||l_verified_plans);
--
-- if none of the evolved plans passed verification then re-enable current plan
--
IF l_verified_plans = 0 THEN
--
-- re-enable current plan
--
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => l_current_plan_name,
attribute_name => 'enabled',
attribute_value => 'YES'
);
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => l_current_plan_name,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' PHV='||l_current_plan_hash_value||' STG='||k_staging_name||' USR=&&who_am_i. RE-ENABLED'
);
put_line('re-enabled current_plan_name:'||l_current_plan_name);
END IF;
--
-- disable any other evolved plan that was not verified
--
FOR i IN (SELECT plan_name
FROM dba_sql_Plan_baselines
WHERE signature = p_signature
AND created >= k_begin_time
AND plan_name <> l_current_plan_name
AND origin <> 'MANUAL-LOAD-FROM-CURSOR-CACHE'
AND description IS NULL
AND accepted = 'YES'
AND enabled = 'YES')
LOOP
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => i.plan_name,
attribute_name => 'enabled',
attribute_value => 'NO'
);
l_plans :=
DBMS_SPM.alter_sql_plan_baseline (
sql_handle => l_sql_handle,
plan_name => i.plan_name,
attribute_name => 'description',
attribute_value => 'cs_spbl_evolve.sql SQL_ID='||p_sql_id||' USR=&&who_am_i. UNVERIFIED DISABLED'
);
put_line('disabled unverified plan_name:'||i.plan_name);
END LOOP;
END IF;
END;
/
--
SET HEA OFF;
PRINT x_report;
SET HEA ON;
SET SERVEROUT OFF;
csierra/cs_internal/cs_spbl_internal_list.sql
+102
View File
@@ -0,0 +1,102 @@
@@&&stgtab_sqlbaseline_script.
--
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL created FOR A26 HEA 'Created';
COL plan_name FOR A30 HEA 'Plan Name';
COL origin FOR A29 HEA 'Origin';
COL ori FOR 999 HEA 'Ori';
COL timestamp FOR A19 HEA 'Timestamp';
COL last_executed FOR A19 HEA 'Last Executed';
COL last_modified FOR A19 HEA 'Last Modified';
COL last_verified FOR A19 HEA 'Last Verified';
COL description FOR A100 HEA 'Description' WOR;
COL executions FOR 999,999,990 HEA 'Executions';
COL et_per_exec_ms FOR 999,999,990.000 HEA 'Elapsed Time|AVG (ms)';
COL cpu_per_exec_ms FOR 999,999,990.000 HEA 'CPU Time|AVG (ms)';
COL buffers_per_exec FOR 999,999,999,990 HEA 'Buffer Gets|AVG';
COL reads_per_exec FOR 999,999,999,990 HEA 'Disk Reads|AVG';
COL rows_per_exec FOR 999,999,999,990 HEA 'Rows Processed|AVG';
COL elapsed_time FOR 999,999,999,999,990 HEA 'Elapsed Time|Total (us)';
COL cpu_time FOR 999,999,999,999,990 HEA 'CPU Time|Total (us)';
COL buffer_gets FOR 999,999,999,990 HEA 'Buffer Gets|Total';
COL disk_reads FOR 999,999,999,990 HEA 'Disk Reads|Total';
COL rows_processed FOR 999,999,999,990 HEA 'Rows Processed|Total';
COL category FOR A10 HEA 'Category' TRUNC;
COL obj_plan FOR A10 HEA 'Obj Plan';
COL comp_data FOR A10 HEA 'Comp Data';
COL enabled FOR A10 HEA 'Enabled';
COL accepted FOR A10 HEA 'Accepted';
COL fixed FOR A10 HEA 'Fixed' PRI;
COL reproduced FOR A10 HEA 'Reproduced';
COL autopurge FOR A10 HEA 'Autopurge';
COL adaptive FOR A10 HEA 'Adaptive';
COL plan_id FOR 999999999990 HEA 'Plan ID';
COL plan_hash_2 FOR 999999999990 HEA 'Plan Hash 2';
COL plan_hash FOR 999999999990 HEA 'Plan Hash';
COL plan_hash_full FOR 999999999990 HEA 'Plan Hash|Full';
COL outline_hint FOR A125 HEA 'CBO Hints';
--
PRO
PRO SQL PLAN BASELINES - LIST (dba_sql_plan_baselines)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(s.created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(s.last_modified, '&&cs_datetime_full_format.') AS last_modified,
TO_CHAR(s.last_executed, '&&cs_datetime_full_format.') AS last_executed,
TO_CHAR(s.last_verified, '&&cs_datetime_full_format.') AS last_verified,
s.con_id,
c.name AS pdb_name,
s.plan_name,
&&cs_skip. CASE WHEN s.con_id > 2 THEN (CASE WHEN (SELECT COUNT(*) FROM sys.sqlobj$ o, sys.sqlobj$plan p WHERE o.signature = s.signature AND o.obj_type = 2 AND o.name = s.plan_name AND p.signature = o.signature AND p.obj_type = o.obj_type AND p.plan_id = o.plan_id) = 0 THEN 'NO' ELSE 'YES' END) END AS obj_plan,
&&cs_skip. CASE WHEN s.con_id > 2 THEN (CASE WHEN (SELECT COUNT(*) FROM sys.sqlobj$ o, sys.sqlobj$data d WHERE o.signature = s.signature AND o.obj_type = 2 AND o.name = s.plan_name AND d.signature = o.signature AND d.obj_type = o.obj_type AND d.plan_id = o.plan_id AND d.comp_data IS NOT NULL) = 0 THEN 'NO' ELSE 'YES' END) END AS comp_data,
s.enabled, s.accepted, s.fixed, s.reproduced, s.autopurge, s.adaptive,
s.origin,
s.description
FROM cdb_sql_plan_baselines s,
v$containers c
WHERE s.signature = :cs_signature
AND c.con_id = s.con_id
ORDER BY
s.created, s.last_modified, s.last_executed, s.con_id, s.plan_name
/
PRO Note: If Obj Plan and Comp Data are both NO then Baseline is Corrupt
--
PRO
PRO SQL PLAN BASELINES - PERFORMANCE (dba_sql_plan_baselines)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(s.created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(s.last_modified, '&&cs_datetime_full_format.') AS last_modified,
s.con_id,
c.name AS pdb_name,
s.plan_name,
&&cs_skip. CASE WHEN s.con_id > 2 THEN (CASE WHEN (SELECT COUNT(*) FROM sys.sqlobj$ o, sys.sqlobj$plan p WHERE o.signature = s.signature AND o.obj_type = 2 AND o.name = s.plan_name AND p.signature = o.signature AND p.obj_type = o.obj_type AND p.plan_id = o.plan_id) = 0 THEN 'NO' ELSE 'YES' END) END AS obj_plan,
&&cs_skip. CASE WHEN s.con_id > 2 THEN (CASE WHEN (SELECT COUNT(*) FROM sys.sqlobj$ o, sys.sqlobj$data d WHERE o.signature = s.signature AND o.obj_type = 2 AND o.name = s.plan_name AND d.signature = o.signature AND d.obj_type = o.obj_type AND d.plan_id = o.plan_id AND d.comp_data IS NOT NULL) = 0 THEN 'NO' ELSE 'YES' END) END AS comp_data,
s.enabled, s.accepted, s.fixed, s.reproduced, s.autopurge, s.adaptive,
s.origin,
s.elapsed_time/GREATEST(s.executions,1)/1e3 AS et_per_exec_ms,
s.cpu_time/GREATEST(s.executions,1)/1e3 AS cpu_per_exec_ms,
s.buffer_gets/GREATEST(s.executions,1) AS buffers_per_exec,
s.disk_reads/GREATEST(s.executions,1) AS reads_per_exec,
s.rows_processed/GREATEST(s.executions,1) AS rows_per_exec,
s.executions,
s.elapsed_time,
s.cpu_time,
s.buffer_gets,
s.disk_reads,
s.rows_processed
FROM cdb_sql_plan_baselines s,
v$containers c
WHERE s.signature = :cs_signature
AND c.con_id = s.con_id
ORDER BY
s.created, s.last_modified, s.con_id, s.plan_name
/
PRO Note: If Obj Plan and Comp Data are both NO then Baseline is Corrupt
--
PRO
PRO SQL PLAN BASELINES - IDS (dba_sql_plan_baselines)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~
@@&&list_sqlbaseline_script.
--
DEF cs_obj_type = '2';
@@&&cs_list_cbo_hints_b.
csierra/cs_internal/cs_spbl_internal_list_debug.sql
+57
View File
@@ -0,0 +1,57 @@
-- only works from PDB. do not use CONTAINERS(table_name) since it causes ORA-00600: internal error code, arguments: [kkdolci1], [], [], [], [], [], [],
SELECT TO_CHAR(a.created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(a.last_modified, '&&cs_datetime_full_format.') AS last_modified,
o.name AS plan_name,
o.category,
CASE WHEN p.plan_hash_2 IS NULL THEN 'NO' ElSE 'YES' END AS obj_plan,
CASE WHEN d.comp_data IS NULL THEN 'NO' ElSE 'YES' END AS comp_data,
DECODE(BITAND(o.flags, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(o.flags, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(o.flags, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(o.flags, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(o.flags, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(o.flags, 256), 0, 'NO', 'YES') AS adaptive,
a.origin AS ori,
p.plan_hash, -- normal plan_hash_value
p.plan_hash_2, -- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
o.plan_id,
p.plan_hash_full, -- adaptive plan (must be different than plan_hash_2 on loaded plans)
TO_CHAR(p.timestamp, '&&cs_datetime_full_format.') AS timestamp,
a.description
FROM sys.sqlobj$ o,
sys.sqlobj$auxdata a,
sys.sql$text t
OUTER APPLY (
SELECT TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash"]')) AS plan_hash, -- normal plan_hash_value
TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash_2"]')) AS plan_hash_2, -- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
TO_NUMBER(EXTRACTVALUE(XMLTYPE(p.other_xml),'/*/info[@type = "plan_hash_full"]')) AS plan_hash_full, -- adaptive plan (must be different than plan_hash_2 on loaded plans)
p.timestamp
FROM sys.sqlobj$plan p
WHERE p.signature = o.signature
AND p.category = o.category
AND p.obj_type = o.obj_type
AND p.plan_id = o.plan_id
AND p.other_xml IS NOT NULL
AND ROWNUM = 1
) p
OUTER APPLY (
SELECT d.comp_data
FROM sys.sqlobj$data d
WHERE d.signature = o.signature
AND d.category = o.category
AND d.obj_type = o.obj_type
AND d.plan_id = o.plan_id
AND ROWNUM = 1
) d
WHERE o.signature = :cs_signature
AND o.category = 'DEFAULT'
AND o.obj_type = 2 /* 1:profile, 2:baseline, 3:patch */
AND a.signature = o.signature
AND a.category = o.category
AND a.obj_type = o.obj_type
AND a.plan_id = o.plan_id
AND t.signature = a.signature
ORDER BY
a.created, a.last_modified, o.name
/
PRO Note: If Obj Plan and Comp Data are both NO then Baseline is Corrupt
csierra/cs_internal/cs_spbl_internal_list_simple.sql
+16
View File
@@ -0,0 +1,16 @@
SELECT TO_CHAR(b.created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(b.last_modified, '&&cs_datetime_full_format.') AS last_modified,
b.plan_name,
b.enabled,
b.accepted,
b.fixed,
b.reproduced,
b.autopurge,
b.adaptive,
b.origin AS ori,
b.description
FROM dba_sql_plan_baselines b
WHERE b.signature = :cs_signature
ORDER BY
b.created, b.last_modified, b.plan_name
/
csierra/cs_internal/cs_spbl_internal_pack.sql
+16
View File
@@ -0,0 +1,16 @@
PRO
PRO Pack plan: "&&cs_plan_name."
DECLARE
l_plans INTEGER;
BEGIN
FOR i IN (SELECT sql_handle, plan_name
FROM dba_sql_plan_baselines
WHERE signature = TO_NUMBER('&&cs_signature.')
AND plan_name = COALESCE('&&cs_plan_name.', plan_name)
ORDER BY signature, plan_name)
LOOP
DELETE &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline WHERE sql_handle = i.sql_handle AND obj_name = i.plan_name;
l_plans := DBMS_SPM.pack_stgtab_baseline(table_name => '&&cs_stgtab_prefix._stgtab_baseline', table_owner => '&&cs_stgtab_owner.', sql_handle => i.sql_handle, plan_name => i.plan_name);
END LOOP;
END;
/
csierra/cs_internal/cs_spbl_internal_plan.sql
+7
View File
@@ -0,0 +1,7 @@
PRO
PRO SQL PLAN BASELINES - DISPLAY (dbms_xplan.display_sql_plan_baseline)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- only works from PDB.
SET HEA OFF PAGES 0;
SELECT * FROM TABLE(DBMS_XPLAN.display_sql_plan_baseline('&&cs_sql_handle.', NULL, 'ADVANCED')) WHERE '&&cs_sql_handle.' IS NOT NULL;
SET HEA ON PAGES 100;
csierra/cs_internal/cs_spbl_internal_stgtab.sql
+17
View File
@@ -0,0 +1,17 @@
@@cs_set_quota_tools_owner.sql
-- create staging table
DECLARE
l_exists NUMBER;
BEGIN
SELECT COUNT(*) INTO l_exists FROM dba_tables WHERE owner = UPPER('&&cs_stgtab_owner.') AND table_name = UPPER('&&cs_stgtab_prefix._stgtab_baseline');
IF l_exists = 0 THEN
DBMS_SPM.create_stgtab_baseline(table_name => UPPER('&&cs_stgtab_prefix._stgtab_baseline'), table_owner => UPPER('&&cs_stgtab_owner.'), tablespace_name => UPPER('&&cs_default_tablespace.'));
END IF;
END;
/
--
PRO
PRO &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT COUNT(*) AS "ROWS" FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
--
csierra/cs_internal/cs_spbl_internal_stgtab_baseline.sql
+109
View File
@@ -0,0 +1,109 @@
COL created FOR A26 HEA 'Created';
COL plan_name FOR A30 HEA 'Plan Name';
COL origin FOR A29 HEA 'Origin';
COL timestamp FOR A19 HEA 'Timestamp';
COL last_executed FOR A19 HEA 'Last Executed';
COL last_modified FOR A19 HEA 'Last Modified';
COL description FOR A100 HEA 'Description' WOR;
COL executions FOR 999,999,990 HEA 'Executions';
COL et_per_exec_ms FOR 999,999,990.000 HEA 'Elapsed Time|AVG (ms)';
COL cpu_per_exec_ms FOR 999,999,990.000 HEA 'CPU Time|AVG (ms)';
COL buffers_per_exec FOR 999,999,999,990 HEA 'Buffer Gets|AVG';
COL reads_per_exec FOR 999,999,999,990 HEA 'Disk Reads|AVG';
COL rows_per_exec FOR 999,999,999,990 HEA 'Rows Processed|AVG';
COL elapsed_time FOR 999,999,999,999,990 HEA 'Elapsed Time|Total (us)';
COL cpu_time FOR 999,999,999,999,990 HEA 'CPU Time|Total (us)';
COL buffer_gets FOR 999,999,999,990 HEA 'Buffer Gets|Total';
COL disk_reads FOR 999,999,999,990 HEA 'Disk Reads|Total';
COL rows_processed FOR 999,999,999,990 HEA 'Rows Processed|Total';
COL enabled FOR A10 HEA 'Enabled';
COL accepted FOR A10 HEA 'Accepted';
COL fixed FOR A10 HEA 'Fixed' PRI;
COL reproduced FOR A10 HEA 'Reproduced';
COL autopurge FOR A10 HEA 'Autopurge';
COL adaptive FOR A10 HEA 'Adaptive';
COL plan_id FOR 999999999990 HEA 'Plan ID';
COL plan_hash_2 FOR 999999999990 HEA 'Plan Hash 2';
COL plan_hash FOR 999999999990 HEA 'Plan Hash';
COL plan_hash_full FOR 999999999990 HEA 'Plan Hash|Full';
--
PRO
PRO SQL PLAN BASELINES ON STAGING TABLE - LIST (&&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(last_modified, '&&cs_datetime_full_format.') AS last_modified,
TO_CHAR(last_executed, '&&cs_datetime_full_format.') AS last_executed,
obj_name AS plan_name,
DECODE(BITAND(status, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(status, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(status, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(status, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(status, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(status, 256), 0, 'NO', 'YES') AS adaptive,
origin,
description
FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline
WHERE signature = :cs_signature
AND other_xml IS NOT NULL
ORDER BY
created, last_modified, last_executed, obj_name
/
--
PRO
PRO SQL PLAN BASELINES ON STAGING TABLE - PERFORMANCE (&&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(last_modified, '&&cs_datetime_full_format.') AS last_modified,
obj_name AS plan_name,
DECODE(BITAND(status, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(status, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(status, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(status, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(status, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(status, 256), 0, 'NO', 'YES') AS adaptive,
origin,
elapsed_time/GREATEST(executions,1)/1e3 AS et_per_exec_ms,
cpu_time/GREATEST(executions,1)/1e3 AS cpu_per_exec_ms,
buffer_gets/GREATEST(executions,1) AS buffers_per_exec,
disk_reads/GREATEST(executions,1) AS reads_per_exec,
rows_processed/GREATEST(executions,1) AS rows_per_exec,
executions,
elapsed_time,
cpu_time,
buffer_gets,
disk_reads,
rows_processed
FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline
WHERE signature = :cs_signature
AND other_xml IS NOT NULL
ORDER BY
created, last_modified, last_executed, obj_name
/
--
PRO
PRO SQL PLAN BASELINES ON STAGING TABLE - IDS (&&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- only works from PDB. do not use CONTAINERS(table_name) since it causes ORA-00600: internal error code, arguments: [kkdolci1], [], [], [], [], [], [],
SELECT TO_CHAR(created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(last_modified, '&&cs_datetime_full_format.') AS last_modified,
obj_name AS plan_name,
DECODE(BITAND(status, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(status, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(status, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(status, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(status, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(status, 256), 0, 'NO', 'YES') AS adaptive,
origin,
TO_NUMBER(extractvalue(xmltype(other_xml),'/*/info[@type = "plan_hash"]')) plan_hash, -- normal plan_hash_value
TO_NUMBER(extractvalue(xmltype(other_xml),'/*/info[@type = "plan_hash_2"]')) plan_hash_2, -- plan_hash_value ignoring transient object names (must be same than plan_id for a baseline to be used)
plan_id,
TO_NUMBER(extractvalue(xmltype(other_xml),'/*/info[@type = "plan_hash_full"]')) plan_hash_full, -- adaptive plan (must be different than plan_hash_2 on loaded plans)
TO_CHAR(timestamp, '&&cs_datetime_full_format.') timestamp,
description
FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline
WHERE signature = :cs_signature
AND other_xml IS NOT NULL
ORDER BY
created, last_modified, last_executed, obj_name
/
--
csierra/cs_internal/cs_spbl_internal_stgtab_delete.sql
+14
View File
@@ -0,0 +1,14 @@
PRO
PRO &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT COUNT(*) AS "ROWS" FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
--
PRO
PRO DELETE &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline WHERE signature = COALESCE(TO_NUMBER('&&cs_signature.'), signature) AND obj_name = COALESCE(TRIM('&&cs_plan_name.'), obj_name);
PRO ~~~~~~
DELETE &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline WHERE signature = COALESCE(TO_NUMBER('&&cs_signature.'), signature) AND obj_name = COALESCE(TRIM('&&cs_plan_name.'), obj_name);
PRO
PRO &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT COUNT(*) AS "ROWS" FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_baseline;
--
csierra/cs_internal/cs_spbl_validate.sql
+71
View File
@@ -0,0 +1,71 @@
PRO
PRO Validate plan: "&&cs_plan_name."
SET SERVEROUT ON;
WHENEVER SQLERROR EXIT FAILURE;
DECLARE
l_plans INTEGER;
BEGIN
FOR i IN (SELECT o.signature,
o.category,
o.obj_type,
o.plan_id,
o.name AS plan_name,
TO_CHAR(a.created, '&&cs_timestamp_full_format.') AS created,
TO_CHAR(a.last_modified, '&&cs_datetime_full_format.') AS last_modified,
DECODE(BITAND(o.flags, 1), 0, 'NO', 'YES') AS enabled,
DECODE(BITAND(o.flags, 2), 0, 'NO', 'YES') AS accepted,
DECODE(BITAND(o.flags, 4), 0, 'NO', 'YES') AS fixed,
DECODE(BITAND(o.flags, 64), 0, 'YES', 'NO') AS reproduced,
DECODE(BITAND(o.flags, 128), 0, 'NO', 'YES') AS autopurge,
DECODE(BITAND(o.flags, 256), 0, 'NO', 'YES') AS adaptive,
a.origin AS ori,
t.sql_handle,
t.sql_text,
a.description
FROM sys.sqlobj$ o,
sys.sqlobj$auxdata a,
sys.sql$text t
WHERE o.signature = :cs_signature
AND o.category = 'DEFAULT'
AND o.obj_type = 2 /* 1:profile, 2:baseline, 3:patch */
AND a.signature = o.signature
AND a.category = o.category
AND a.obj_type = o.obj_type
AND a.plan_id = o.plan_id
AND t.signature = o.signature
AND NOT EXISTS (
SELECT NULL
FROM sys.sqlobj$plan p
WHERE p.signature = o.signature
AND p.category = o.category
AND p.obj_type = o.obj_type
AND p.plan_id = o.plan_id
AND p.id = 1
AND ROWNUM = 1
)
AND NOT EXISTS (
SELECT NULL
FROM sys.sqlobj$data d
WHERE d.signature = o.signature
AND d.category = o.category
AND d.obj_type = o.obj_type
AND d.plan_id = o.plan_id
AND d.comp_data IS NOT NULL
AND ROWNUM = 1
)
ORDER BY
o.signature, o.category, o.obj_type, o.plan_id)
LOOP
IF i.enabled = 'YES' THEN
DBMS_OUTPUT.put_line('Disable Plan: '||i.plan_name);
l_plans := DBMS_SPM.alter_sql_plan_baseline(sql_handle => i.sql_handle, plan_name => i.plan_name, attribute_name => 'ENABLED', attribute_value => 'NO');
END IF;
DBMS_OUTPUT.put_line('Fixing Corrupt Plan: '||i.plan_name);
DELETE sys.sqlobj$plan WHERE signature = i.signature AND category = i.category AND obj_type = i.obj_type AND plan_id = i.plan_id AND id = 1;
INSERT INTO sys.sqlobj$plan (signature, category, obj_type, plan_id, id) VALUES (i.signature, i.category, i.obj_type, i.plan_id, 1);
END LOOP;
COMMIT;
END;
/
WHENEVER SQLERROR CONTINUE;
SET SERVEROUT OFF;
csierra/cs_internal/cs_spch_internal_category.sql
+16
View File
@@ -0,0 +1,16 @@
BEGIN
FOR i IN (SELECT name
FROM dba_sql_patches
WHERE signature = :cs_signature
AND name = NVL('&&cs_name.', name)
ORDER BY name)
LOOP
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', value => '&&cs_category.'); -- 12c
$ELSE
DBMS_SQLDIAG.alter_sql_patch(name => i.name, attribute_name => 'CATEGORY', attribute_value => '&&cs_category.'); -- 19c
$END
END LOOP;
END;
/
csierra/cs_internal/cs_spch_internal_create.sql
+16
View File
@@ -0,0 +1,16 @@
DECLARE
l_name VARCHAR2(64);
l_sql_text CLOB := :cs_sql_text; -- for some bizarre reason we cannot simply pass :cs_sql_text into DBMS_SQLDIAG.create_sql_patch!
BEGIN
-- see also PLSQL_CCFLAGS
$IF DBMS_DB_VERSION.ver_le_12_1
$THEN
--DBMS_SQLDIAG_INTERNAL.i_create_patch(sql_id => '&&cs_sql_id.', hint_text => q'[&&hints_text.]', name => 'cs_&&cs_sql_id.', description => q'[cs_spch_create.sql /*+ &&hints_text. */ &&cs_reference_sanitized. &&who_am_i.]'); -- 12c (this api requires the sql to be in memory)
DBMS_SQLDIAG_INTERNAL.i_create_patch(sql_text => l_sql_text, hint_text => q'[&&hints_text.]', name => 'cs_&&cs_sql_id._'||TO_CHAR(SYSDATE, 'MMDD_HH24MISS'), description => q'[cs_spch_create.sql /*+ &&hints_text. */ &&cs_reference_sanitized. &&who_am_i.]'); -- 12c
$ELSE
--l_name := DBMS_SQLDIAG.create_sql_patch(sql_id => '&&cs_sql_id.', hint_text => q'[&&hints_text.]', name => 'cs_&&cs_sql_id.', description => q'[cs_spch_create.sql /*+ &&hints_text. */ &&cs_reference_sanitized. &&who_am_i.]'); -- 19c (this api requires the sql to be in memory)
l_name := DBMS_SQLDIAG.create_sql_patch(sql_text => l_sql_text, hint_text => q'[&&hints_text.]', name => 'cs_&&cs_sql_id._'||TO_CHAR(SYSDATE, 'MMDD_HH24MISS'), description => q'[cs_spch_create.sql /*+ &&hints_text. */ &&cs_reference_sanitized. &&who_am_i.]'); -- 19c
$END
NULL;
END;
/
csierra/cs_internal/cs_spch_internal_drop.sql
+7
View File
@@ -0,0 +1,7 @@
BEGIN
FOR i IN (SELECT name FROM dba_sql_patches WHERE signature = &&cs_signature.)
LOOP
DBMS_SQLDIAG.drop_sql_patch(name => i.name);
END LOOP;
END;
/
csierra/cs_internal/cs_spch_internal_list.sql
+34
View File
@@ -0,0 +1,34 @@
@@&&stgtab_sqlpatch_script.
--
COL con_id FOR 999 HEA 'Con|ID';
COL pdb_name FOR A30 HEA 'PDB Name' FOR A30 TRUNC;
COL created FOR A23;
COL name FOR A30;
COL category FOR A30;
COL status FOR A8;
COL last_modified FOR A19;
COL description FOR A100 HEA 'Description' WOR;
COL outline_hint FOR A125;
--
PRO
PRO SQL PATCHES - LIST (dba_sql_patches)
PRO ~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(s.created, '&&cs_datetime_full_format.') AS created,
s.con_id,
c.name AS pdb_name,
s.name,
s.category,
s.status,
TO_CHAR(s.last_modified, '&&cs_datetime_full_format.') AS last_modified,
s.description
FROM cdb_sql_patches s,
v$containers c
WHERE s.signature = :cs_signature
AND c.con_id = s.con_id
ORDER BY
s.created, s.con_id, s.name
/
--
DEF cs_obj_type = '3';
@@&&cs_list_cbo_hints.
csierra/cs_internal/cs_spch_internal_pack.sql
+13
View File
@@ -0,0 +1,13 @@
PRO
PRO Pack SQL Patch:
BEGIN
FOR i IN (SELECT name, category
FROM dba_sql_patches
WHERE signature = :cs_signature
ORDER BY name)
LOOP
DELETE &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_sqlpatch WHERE obj_name = i.name AND category = i.category;
DBMS_SQLDIAG.pack_stgtab_sqlpatch(patch_name => i.name, patch_category => i.category, staging_table_name => '&&cs_stgtab_prefix._stgtab_sqlpatch', staging_schema_owner => '&&cs_stgtab_owner.');
END LOOP;
END;
/
csierra/cs_internal/cs_spch_internal_plan.sql
+7
View File
@@ -0,0 +1,7 @@
PRO
PRO SQL PATCH - DISPLAY (dbms_xplan.display_sql_patch_plan)
PRO ~~~~~~~~~~~~~~~~~~~
-- only works from PDB.
SET HEA OFF PAGES 0;
SELECT * FROM TABLE(DBMS_XPLAN.display_sql_patch_plan((SELECT name FROM dba_sql_patches WHERE signature = :cs_signature AND category = 'DEFAULT' AND ROWNUM = 1), 'ADVANCED'));
SET HEA ON PAGES 100;
csierra/cs_internal/cs_spch_internal_stgtab.sql
+17
View File
@@ -0,0 +1,17 @@
@@cs_set_quota_tools_owner.sql
-- create staging table
DECLARE
l_exists NUMBER;
BEGIN
SELECT COUNT(*) INTO l_exists FROM dba_tables WHERE owner = UPPER('&&cs_stgtab_owner.') AND table_name = UPPER('&&cs_stgtab_prefix._stgtab_sqlpatch');
IF l_exists = 0 THEN
DBMS_SQLDIAG.create_stgtab_sqlpatch(table_name => UPPER('&&cs_stgtab_prefix._stgtab_sqlpatch'), schema_name => UPPER('&&cs_stgtab_owner.'), tablespace_name => UPPER('&&cs_default_tablespace.'));
END IF;
END;
/
--
PRO
PRO &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_sqlpatch;
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT COUNT(*) AS "ROWS" FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_sqlpatch;
--
csierra/cs_internal/cs_spch_internal_stgtab_sqlpatch.sql
+21
View File
@@ -0,0 +1,21 @@
COL created FOR A23;
COL name FOR A30;
COL category FOR A30;
COL status FOR 99999999;
COL last_modified FOR A19;
COL description FOR A100 HEA 'Description' WOR;
--
PRO
PRO SQL PATCHES ON STAGING TABLE (&&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_sqlpatch)
PRO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SELECT TO_CHAR(created, '&&cs_datetime_full_format.') created,
obj_name name,
category,
status,
TO_CHAR(last_modified, '&&cs_datetime_full_format.') last_modified,
description
FROM &&cs_stgtab_owner..&&cs_stgtab_prefix._stgtab_sqlpatch
WHERE signature = :cs_signature
ORDER BY
created, obj_name
/

Some files were not shown because too many files have changed in this diff Show More