srvctl add service -d orcl -s svc_test -pdb pdb1 -preferred orcl2 -available orcl3,orcl1 -clbgoal short -failovermethod basic -failovertype select -failoverretry 180 -failoverdelay 5 -tafpolicy basic -rlbgoal throughput
srvctl add service -d orcl -s svc_test -role primary -preferred orcl1 -available orcl2
srvctl remove service -d orcl -s svc_test
srvctl modify service -d orcl -s svc_test -oldinst orcl2 -newinst orcl1 -f
srvctl relocate service -d orcl -s svc_test -i orcl1 -t orcl2
This one brings in-doubt transactions:
This one prepares the rollback script for the transactions:
At last run the rollback with the transaction id:
alter session set nls_date_format='DD-MON-YYYY HH24:MI:SS';
set line 2222;
set pages 2222;
set long 6666;
select sl.sid, sl.opname,
to_char(100*(sofar/totalwork), '990.9')||'%' pct_done,
sysdate+(TIME_REMAINING/60/60/24) done_by
from v$session_longops sl, v$session s
where sl.sid = s.sid
and sl.serial# = s.serial#
and sl.sid in (select sid from v$session where module like 'backup%' or module like 'restore%' or module like 'rman%')
and sofar != totalwork
and totalwork > 0
/
Query to Monitor Backup restore speed
SET HEAD OFF SELECT 'RMAN Throughput : '|| ROUND(SUM(v.value/(power(2,30))),1) || ' GB so far ---> Per Second Throughput = ' || ROUND(SUM(v.value /(power(2,30)))/NVL((SELECT MIN(elapsed_seconds) FROM v$session_longops WHERE opname LIKE 'RMAN: aggregate input' AND sofar != TOTALWORK AND elapsed_seconds IS NOT NULL ),SUM(v.value /(power(2,30)))),2) || ' GB' FROM gv$sesstat v, v$statname n, gv$session s WHERE v.statistic# = n.statistic# AND n.name = 'physical write total bytes' AND v.sid = s.sid AND v.inst_id = s.inst_id AND s.program LIKE 'rman@%' GROUP BY n.name /
Query to check the progress of restoration of datafiles with status & %age complete
set line 190 pages 190 column FILENAME format a70 select sid,serial,filename,status,bytes/total_bytes*100 "Completed",EFFECTIVE_BYTES_PER_SECOND/1024/1024 "MB/S" from V$BACKUP_ASYNC_IO where type = 'OUTPUT' and bytes<>0 order by status;
Query to check the %age complete of RMAN backup / restore
SELECT SID, SERIAL#, CONTEXT, SOFAR, TOTALWORK, ROUND(SOFAR/TOTALWORK*100,2) "%_COMPLETE" FROM gV$SESSION_LONGOPS WHERE OPNAME LIKE 'RMAN%' AND OPNAME NOT LIKE '%aggregate%' AND TOTALWORK != 0 AND SOFAR != TOTALWORK order by 6 desc;
Query to check RMAN backup channels status
select s.inst_id, a.sid, CLIENT_INFO Ch, a.STATUS,
open_time, round(BYTES/1024/1024,2) "SOFAR Mb" , round(total_bytes/1024/1024,2)
TotMb, io_count,
round(BYTES/TOTAL_BYTES*100,2) "% Complete" , a.type, filename
from gv$backup_async_io a, gv$session s
where not a.STATUS in ('UNKNOWN') and s.status='ACTIVE' and a.STATUS <> 'FINISHED'
and a.sid=s.sid order by 6 desc,7;
I came across scenario where i had to restart the integrated extract from previous SCN / Timestamp and it was not starting from given scn or timestamp.
How Integrated extract works: SCN requires a valid dictionary build in the existing archive logs. Integrated Extract operates with a logminer dictionary.
Run below query to check the min scn present in dictionary:
COLUMN FIRST_CHANGE# HEADING 'First SCN' FORMAT 999999999
COLUMN NAME HEADING 'Log File Name' FORMAT A50
SELECT DISTINCT FIRST_CHANGE#, NAME FROM V$ARCHIVED_LOG
WHERE DICTIONARY_BEGIN = 'YES';
select sequence#,first_change#,next_change# from v$archived_log where &scn between first_change# and next_change#;
Ref: How to start an Integrated Extract At an Older SCN (Doc ID 2046981.1)
Ref: Integrated Extract Not Extracting From Selected Timestamp (Doc ID 1579032.1)
Below query can be run at Target to check upto which scn data has already applied at target. That scn should be considered to reset extract at source side. LOG_CMPLT_CSN shows log complete SCN upto which data has been replicated by replicat at target.
select GROUP_NAME,LOG_CSN,LOG_BSN,LOG_CMPLT_CSN from GGADMIN.checkpointtable where group_name in ('RORCL1','RORCL2');
GROUP_NA LOG_CSN LOG_BSN LOG_CMPLT_CSN
-------- ------------------------------ --------------------------------------------- ------------------------------
ROCRL1 54793963772 54793845236 54793963772
RORCL2 54793642029 54793845236 54793642029
mysql -h 127.0.0.1 -u root
select count(*) from information_schema.processlist;
select * from information_schema.processlist;
select USER,SUBSTRING(HOST, 1, 28) “SHOST”,COMMAND,count(*) from information_schema.processlist group by USER,SHOST,COMMAND order by 1,2,3,4;
SELECT VARIABLE_VALUE from information_schema.session_status WHERE VARIABLE_NAME=’THREADS_CONNECTED’;
show status like ‘Threads%’;
SELECT
pl.id
,pl.user
,pl.state
,it.trx_id
,it.trx_mysql_thread_id
,it.trx_query AS query
,it.trx_id AS blocking_trx_id
,it.trx_mysql_thread_id AS blocking_thread
,it.trx_query AS blocking_query
FROM information_schema.processlist AS pl
INNER JOIN information_schema.innodb_trx AS it
ON pl.id = it.trx_mysql_thread_id
INNER JOIN information_schema.innodb_lock_waits AS ilw
ON it.trx_id = ilw.requesting_trx_id
AND it.trx_id = ilw.blocking_trx_id;
Insert into a column that does not exist on the source side.
No changes should happen after the initial insert to the column.
Additional updates to the record should not change the value
of the additional column on the target side.
Delete should respond as usual and remove the record.
Cloned the scott.emp table into a testing schema and added the column “only_on_target_side” to the emp table on the target side.
On the source and target side, ctas scott.emp into a testing schema.
In this case the testing schema is testing1
CREATE TABLE TESTING1.EMP AS SELECT * FROM SCOTT.EMP;
On target side add the “only_on_target_side” column.
ALTER TABLE emp ADD ONLY_ON_TARGET_SIDE varchar2(20);
SOURCE
SQL> desc emp
Name Null? Type
----------- -------- ----------------
EMPNO NOT NULL NUMBER(4)
ENAME VARCHAR2(10)
JOB VARCHAR2(9)
MGR NUMBER(4)
HIREDATE DATE
SAL NUMBER(7,2)
COMM NUMBER(7,2)
DEPTNO NUMBER(2)
TARGET
SQL> desc emp
Name Null? Type
----------- -------- ----------------
EMPNO NOT NULL NUMBER(4)
ENAME VARCHAR2(10)
JOB VARCHAR2(9)
MGR NUMBER(4)
HIREDATE DATE
SAL NUMBER(7,2)
COMM NUMBER(7,2)
DEPTNO NUMBER(2)
ONLY_ON_TARGET_SIDE VARCHAR2(20)
Solution was to set up extract and pump as normal.
The “work” would be done replicat.
Note the map statement and the use of colmap.
The map statement is one line.
REPLICAT RTST
ASSUMETARGETDEFS
DISCARDFILE ./dirout/RTST.DSC, PURGE
USERID <USERID>, PASSWORD <PASSWORD>
map testing1.emp, target testing1.emp, colmap(usedefaults, ONLY_ON_TARGET_SIDE=@IF(@STREQ(@GETENV('GGHEADER', 'OPTYPE'), 'INSERT'), 'DEFAULT', @COLSTAT(MISSING)));
When a insert is issued to emp on the source side the value ‘default’ will now be inserted into the emp.only_on_target_side column of the target side.
Updates issued on the source side work as normal and do not effect the emp.only_on_target_side column of the target side. Deletes work as normal and removes the record on source and target.
This allows for a possible use of emp.only_on_target_side column on target side as a status column that can be updated without breaking replicat.
Ref: https://hiteshgondalia.wordpress.com/2014/07/04/monitoring-shared-pool-usage/
select 'You may need to increase the SHARED_POOL_RESERVED_SIZE' Description, 'Request Failures = '||REQUEST_FAILURES Logic from v$shared_pool_reserved where REQUEST_FAILURES > 0 and 0 != (select to_number(VALUE) from v$parameter where NAME = 'shared_pool_reserved_size') union select 'You may be able to decrease the SHARED_POOL_RESERVED_SIZE' Description, 'Request Failures = '||REQUEST_FAILURES Logic from v$shared_pool_reserved where REQUEST_FAILURES < 5 and 0 != ( select to_number(VALUE) from v$parameter where NAME = 'shared_pool_reserved_size');
select OWNER, NAME||' - '||TYPE object, SHARABLE_MEM
from v$db_object_cache
where SHARABLE_MEM > 10000
and type in ('PACKAGE','PACKAGE BODY','FUNCTION','PROCEDURE')
order by SHARABLE_MEM desc;
LOADS INTO SHARED POOL NOTES:
select OWNER, NAME||’ – ‘||TYPE object, LOADS
from v$db_object_cache
where LOADS > 3
and type in (‘PACKAGE’,’PACKAGE BODY’,’FUNCTION’,’PROCEDURE’)
order by LOADS desc;
SHARED POOL EXECUTION NOTES:
select OWNER, NAME||’ – ‘||TYPE object, EXECUTIONS
from v$db_object_cache
where EXECUTIONS > 100
and type in (‘PACKAGE’,’PACKAGE BODY’,’FUNCTION’,’PROCEDURE’)
order by EXECUTIONS desc;
SHARED POOL DETAIL NOTES:
select OWNER, NAME, DB_LINK, NAMESPACE, TYPE, SHARABLE_MEM,
LOADS, EXECUTIONS, LOCKS, PINS
from v$db_object_cache
order by OWNER, NAME;
SHARED POOL V$LIBRARYCACHE STATISTIC NOTES:
select NAMESPACE, GETS, GETHITS, round(GETHITRATIO*100,2) gethit_ratio,
PINS, PINHITS, round(PINHITRATIO*100,2) pinhit_ratio, RELOADS, INVALIDATIONS
from v$librarycache;
PINNED OBJECT NOTES:
select NAME,TYPE,KEPT
from v$db_object_cache
where KEPT = ‘YES’;
SHARED POOL RESERVED SIZE NOTES:
select NAME, VALUE
from v$parameter
where NAME like ‘%reser%’;
Script to Estimate Shared Pool Utilization
This script estimates Shared Pool utilization.
Sample Output
Copy Script to Clipboard
REM LOCATION: Database TuningShared Pool Reports
REM FUNCTION: Estimates shared pool utilization
REM TESTED ON: 7.3.3.5, 8.0.4.1, 8.1.5, 8.1.7, 9.0.1, 10.2.0.3, 11.1.0.6
REM PLATFORM: non-specific
REM REQUIRES: v$db_object_cache, v$sqlarea, v$sesstat, v$statname,
REM v$sgastat, v$parameter
REM
REM This is a part of the Knowledge Xpert for Oracle Administration library.
REM Copyright (C) 2008 Quest Software
REM All rights reserved.
REM
REM******************** Knowledge Xpert for Oracle Administration ********************
REM
REM NOTES: Based on current database usage. This should be
REM run during peak operation, after all stored
REM objects i.e. packages, views have been loaded.
REM
REM 08/02/08 Robert Freeman - Modified to use v$sgastat instead v$parameter for
REM shared pool size.
REM***********************************************************************************
REM
REM If running Shared Server uncomment the mts calculation and output commands.
SET serveroutput on;
DECLARE
object_mem NUMBER;
shared_sql NUMBER;
cursor_mem NUMBER;
mts_mem NUMBER;
used_pool_size NUMBER;
free_mem NUMBER;
pool_size VARCHAR2 (512); -- Now from V$SGASTAT
BEGIN
-- Stored objects (packages, views)
SELECT SUM (sharable_mem)
INTO object_mem
FROM v$db_object_cache;
-- Shared SQL -- need to have additional memory if dynamic SQL used
SELECT SUM (sharable_mem)
INTO shared_sql
FROM v$sqlarea;
-- User Cursor Usage -- run this during peak usage.
-- assumes 250 bytes per open cursor, for each concurrent user.
SELECT SUM (250 * users_opening)
INTO cursor_mem
FROM v$sqlarea;
-- For a test system -- get usage for one user, multiply by # users
-- select (250 * value) bytes_per_user
-- from v$sesstat s, v$statname n
-- where s.statistic# = n.statistic#
-- and n.name = 'opened cursors current'
-- and s.sid = 25; -- where 25 is the sid of the process
-- MTS memory needed to hold session information for shared server users
-- This query computes a total for all currently logged on users (run
-- multiply by # users.
SELECT SUM (VALUE)
INTO mts_mem
FROM v$sesstat s, v$statname n
WHERE s.statistic# = n.statistic# AND n.NAME = 'session uga memory max';
-- Free (unused) memory in the SGA: gives an indication of how much memory
-- is being wasted out of the total allocated.
SELECT BYTES
INTO free_mem
FROM v$sgastat
WHERE NAME = 'free memory' AND pool = 'shared pool';
-- For non-MTS add up object, shared sql, cursors and 20% overhead.
used_pool_size := ROUND (1.2 * (object_mem + shared_sql + cursor_mem));
-- For MTS mts contribution needs to be included (comment out previous line)
-- used_pool_size := round(1.2*(object_mem+shared_sql+cursor_mem+mts_mem));
SELECT SUM (BYTES)
INTO pool_size
FROM v$sgastat
WHERE pool = 'shared pool';
-- Display results
DBMS_OUTPUT.put_line ('Shared Pool Memory Utilization Report');
DBMS_OUTPUT.put_line ('Obj mem: ' || TO_CHAR (object_mem) || ' bytes');
DBMS_OUTPUT.put_line ('Shared sql: ' || TO_CHAR (shared_sql) || ' bytes');
DBMS_OUTPUT.put_line ('Cursors: ' || TO_CHAR (cursor_mem) || ' bytes');
-- dbms_output.put_line ('MTS session: '||to_char (mts_mem) || ' bytes');
DBMS_OUTPUT.put_line ( 'Free memory: '
|| TO_CHAR (free_mem)
|| ' bytes '
|| '('
|| TO_CHAR (ROUND (free_mem / 1024 / 1024, 2))
|| 'MB)'
);
DBMS_OUTPUT.put_line ( 'Shared pool utilization (total): '
|| TO_CHAR (used_pool_size)
|| ' bytes '
|| '('
|| TO_CHAR (ROUND (used_pool_size / 1024 / 1024, 2))
|| 'MB)'
);
DBMS_OUTPUT.put_line ( 'Shared pool allocation (actual): '
|| pool_size
|| ' bytes '
|| '('
|| TO_CHAR (ROUND (pool_size / 1024 / 1024, 2))
|| 'MB)'
);
DBMS_OUTPUT.put_line ( 'Percentage Utilized: '
|| TO_CHAR (ROUND (used_pool_size / pool_size * 100))
);
END;
/
Sample Output
Shared Pool Memory Utilization Report
Obj mem: 64949920 bytes
Shared sql: 21737236 bytes
Cursors: 14250 bytes
Free memory: 54037748 bytes (51.53MB)
Shared pool utilization (total): 104041687 bytes (99.22MB)
Shared pool allocation (actual): 180359768 bytes (172MB)
Percentage Utilized: 58
Script to find how much memory used by similar sql or sql that coming literals.
select inst_id,plan_hash_value,round(sum(S.SHARABLE_MEM)/(1024*1024)) as Memory_MB,count(1) from gv$sql s
group by inst_id,plan_hash_value
order by 3 desc
Script to find too many child of sql and high version count
select inst_id,sql_id,round(sum(S.SHARABLE_MEM)/(1024*1024),1) as Memory_MB,count(1) as CHILDCOUNT
from gv$sql s
group by inst_id,sql_id
order by 3 desc
Script to find sql version count
select
inst_id,sql_id,version_count
from
gv$sqlarea
order by version_count desc
Sql plan hash value list that has high version count. This script can be used on specific case. If versioncount > count there might be a problem.
set lines 500
select * from (
select
plan_hash_value,sum(version_count) as versioncount ,count(1)
from
v$sqlarea
group by plan_hash_value
order by sum(version_count) desc
) where rownum<11
;
Shared pool size by instance
select inst_id,round(sum(S.SHARABLE_MEM)/(1024*1024),1) as Memory_MB
from gv$sql s
group by inst_id
order by 2 desc;
Shared pool component size
select *
from gv$sgastat
where pool=’shared pool’
–and name=’free memory’
and inst_id=1
order by bytes desc;
Historical shared pool free memory in each instance.
select HS.BEGIN_INTERVAL_TIME,ss.*
from DBA_HIST_SGASTAT ss ,dba_hist_snapshot hs
where pool=’shared pool’ and name=’free memory’
and SS.SNAP_ID=HS.SNAP_ID
and SS.INSTANCE_NUMBER=HS.INSTANCE_NUMBER
and ss.instance_number=1
–and HS.BEGIN_INTERVAL_TIME between to_date(’17-09-2019 13:00:00′,’dd-mm-yyyy hh24:mi:ss’) and to_date(’17-09-2019 15:30:00′,’dd-mm-yyyy hh24:mi:ss’)
order by ss.snap_id desc;
Script to find the reasons why sql has high version count.
select version_count,a.sql_id,hash_value,parsing_schema_name,reason,sql_text from (
select
address,sql_id,”
||decode(max( UNBOUND_CURSOR),’Y’, ‘ UNBOUND_CURSOR’)
||decode(max( SQL_TYPE_MISMATCH),’Y’, ‘ SQL_TYPE_MISMATCH’)
||decode(max( OPTIMIZER_MISMATCH),’Y’, ‘ OPTIMIZER_MISMATCH’)
||decode(max( OUTLINE_MISMATCH),’Y’, ‘ OUTLINE_MISMATCH’)
||decode(max( STATS_ROW_MISMATCH),’Y’, ‘ STATS_ROW_MISMATCH’)
||decode(max( LITERAL_MISMATCH),’Y’, ‘ LITERAL_MISMATCH’)
–||decode(max( SEC_DEPTH_MISMATCH),’Y’, ‘ SEC_DEPTH_MISMATCH’)
||decode(max( EXPLAIN_PLAN_CURSOR),’Y’, ‘ EXPLAIN_PLAN_CURSOR’)
||decode(max( BUFFERED_DML_MISMATCH),’Y’, ‘ BUFFERED_DML_MISMATCH’)
||decode(max( PDML_ENV_MISMATCH),’Y’, ‘ PDML_ENV_MISMATCH’)
||decode(max( INST_DRTLD_MISMATCH),’Y’, ‘ INST_DRTLD_MISMATCH’)
||decode(max( SLAVE_QC_MISMATCH),’Y’, ‘ SLAVE_QC_MISMATCH’)
||decode(max( TYPECHECK_MISMATCH),’Y’, ‘ TYPECHECK_MISMATCH’)
||decode(max( AUTH_CHECK_MISMATCH),’Y’, ‘ AUTH_CHECK_MISMATCH’)
||decode(max( BIND_MISMATCH),’Y’, ‘ BIND_MISMATCH’)
||decode(max( DESCRIBE_MISMATCH),’Y’, ‘ DESCRIBE_MISMATCH’)
||decode(max( LANGUAGE_MISMATCH),’Y’, ‘ LANGUAGE_MISMATCH’)
||decode(max( TRANSLATION_MISMATCH),’Y’, ‘ TRANSLATION_MISMATCH’)
–||decode(max( ROW_LEVEL_SEC_MISMATCH),’Y’, ‘ ROW_LEVEL_SEC_MISMATCH’)
||decode(max( INSUFF_PRIVS),’Y’, ‘ INSUFF_PRIVS’)
||decode(max( INSUFF_PRIVS_REM),’Y’, ‘ INSUFF_PRIVS_REM’)
||decode(max( REMOTE_TRANS_MISMATCH),’Y’, ‘ REMOTE_TRANS_MISMATCH’)
||decode(max( LOGMINER_SESSION_MISMATCH),’Y’, ‘ LOGMINER_SESSION_MISMATCH’)
||decode(max( INCOMP_LTRL_MISMATCH),’Y’, ‘ INCOMP_LTRL_MISMATCH’)
||decode(max( OVERLAP_TIME_MISMATCH),’Y’, ‘ OVERLAP_TIME_MISMATCH’)
–||decode(max( SQL_REDIRECT_MISMATCH),’Y’, ‘ SQL_REDIRECT_MISMATCH’)
||decode(max( MV_QUERY_GEN_MISMATCH),’Y’, ‘ MV_QUERY_GEN_MISMATCH’)
||decode(max( USER_BIND_PEEK_MISMATCH),’Y’, ‘ USER_BIND_PEEK_MISMATCH’)
||decode(max( TYPCHK_DEP_MISMATCH),’Y’, ‘ TYPCHK_DEP_MISMATCH’)
||decode(max( NO_TRIGGER_MISMATCH),’Y’, ‘ NO_TRIGGER_MISMATCH’)
||decode(max( FLASHBACK_CURSOR),’Y’, ‘ FLASHBACK_CURSOR’)
||decode(max( ANYDATA_TRANSFORMATION),’Y’, ‘ ANYDATA_TRANSFORMATION’)
–||decode(max( INCOMPLETE_CURSOR),’Y’, ‘ INCOMPLETE_CURSOR’)
||decode(max( TOP_LEVEL_RPI_CURSOR),’Y’, ‘ TOP_LEVEL_RPI_CURSOR’)
||decode(max( DIFFERENT_LONG_LENGTH),’Y’, ‘ DIFFERENT_LONG_LENGTH’)
||decode(max( LOGICAL_STANDBY_APPLY),’Y’, ‘ LOGICAL_STANDBY_APPLY’)
||decode(max( DIFF_CALL_DURN),’Y’, ‘ DIFF_CALL_DURN’)
||decode(max( BIND_UACS_DIFF),’Y’, ‘ BIND_UACS_DIFF’)
||decode(max( PLSQL_CMP_SWITCHS_DIFF),’Y’, ‘ PLSQL_CMP_SWITCHS_DIFF’)
||decode(max( CURSOR_PARTS_MISMATCH),’Y’, ‘ CURSOR_PARTS_MISMATCH’)
||decode(max( STB_OBJECT_MISMATCH),’Y’, ‘ STB_OBJECT_MISMATCH’)
–||decode(max( ROW_SHIP_MISMATCH),’Y’, ‘ ROW_SHIP_MISMATCH’)
||decode(max( PQ_SLAVE_MISMATCH),’Y’, ‘ PQ_SLAVE_MISMATCH’)
||decode(max( TOP_LEVEL_DDL_MISMATCH),’Y’, ‘ TOP_LEVEL_DDL_MISMATCH’)
||decode(max( MULTI_PX_MISMATCH),’Y’, ‘ MULTI_PX_MISMATCH’)
||decode(max( BIND_PEEKED_PQ_MISMATCH),’Y’, ‘ BIND_PEEKED_PQ_MISMATCH’)
||decode(max( MV_REWRITE_MISMATCH),’Y’, ‘ MV_REWRITE_MISMATCH’)
||decode(max( ROLL_INVALID_MISMATCH),’Y’, ‘ ROLL_INVALID_MISMATCH’)
||decode(max( OPTIMIZER_MODE_MISMATCH),’Y’, ‘ OPTIMIZER_MODE_MISMATCH’)
||decode(max( PX_MISMATCH),’Y’, ‘ PX_MISMATCH’)
||decode(max( MV_STALEOBJ_MISMATCH),’Y’, ‘ MV_STALEOBJ_MISMATCH’)
||decode(max( FLASHBACK_TABLE_MISMATCH),’Y’, ‘ FLASHBACK_TABLE_MISMATCH’)
||decode(max( LITREP_COMP_MISMATCH),’Y’, ‘ LITREP_COMP_MISMATCH’)
reason
from
v$sql_shared_cursor –where sql_id=’1s4cu90p8sdab’
group by
address,sql_id
) a join v$sqlarea using(address) where version_count>10
order by version_count desc,address
;
overall=0
for status_file in /proc/[0-9]*/status; do
swap_mem=$(grep VmSwap “$status_file” | awk ‘{ print $2 }’)
if [ “$swap_mem” ] && [ “$swap_mem” -gt 0 ]; then
pid=$(grep Tgid “$status_file” | awk ‘{ print $2 }’)
name=$(grep Name “$status_file” | awk ‘{ print $2 }’)
printf “%s\t%s\t%s KB\n” “$pid” “$name” “$swap_mem”
fi
overall=$((overall+swap_mem))
done
printf “Total Swapped Memory: %14u KB\n” $overall
Ref: https://backendtales.blogspot.com/2023/02/santas-little-index-helper.html
An example of how one of my TPT scripts (ash_index_helper.sql) helps you to create appropriate indexes in Oracle, by displaying you all the relevant information for decision-making in one place:
orasolution 