Oracle System Views
Source code for Oracle SYS Views
| GO$SQL_BIND_CAPTURE | select INST_ID, KQLFBC_PADD, KQLFBC_HASH, KQLFBC_SQLID, KQLFBC_CADD, KQLFBC_CHNO, substr(KQLFBC_NAME, 1, 30), KQLFBC_POS, to_number(decode(KQLFBC_DUPPOS, 65535, NULL, KQLFBC_DUPPOS)), KQLFBC_OACDTY, substr(KQLFBC_DTYSTR, 1, 15), decode(KQLFBC_OACCSI, 0, to_number(null), KQLFBC_OACCSI), decode(KQLFBC_OACPRE, 0, to_number(null), KQLFBC_OACPRE), decode(KQLFBC_OACSCL, 0, to_number(null), KQLFBC_OACSCL), KQLFBC_OACMXL, decode(KQLFBC_WCAP, 0, ‘NO’, ‘YES’), decode(KQLFBC_WCAP, 0, to_date(NULL), KQLFBC_LCAP), KQLFBC_STRVAL, decode(KQLFBC_WCAP, 0, NULL, sys.sys$rawtoany(KQLFBC_BINVAL, KQLFBC_OACDTY, KQLFBC_OACCSF, KQLFBC_OACCSI)) from x$kqlfbc |
| GV$ACCESS | select distinct s.inst_id,s.ksusenum,o.kglnaown,o.kglnaobj, decode(o.kglobtyp, 0, ‘CURSOR’, 1, ‘INDEX’, 2, ‘TABLE’, 3, ‘CLUSTER’, 4, ‘VIEW’, 5, ‘SYNONYM’, 6, ‘SEQUENCE’, 7, ‘PROCEDURE’, 8, ‘FUNCTION’, 9, ‘PACKAGE’, 10,’NON-EXISTENT’, 11,’PACKAGE BODY’, 12,’TRIGGER’, 13,’TYPE’, 14,’TYPE BODY’, 15,’OBJECT’, 16,’USER’, 17,’DBLINK’, 18,’PIPE’, 19,’TABLE PARTITION’, 20,’INDEX PARTITION’, 21,’LOB’, 22,’LIBRARY’, 23,’DIRECTORY’, 24,’QUEUE’, 25,’INDEX-ORGANIZED TABLE’, 26,’REPLICATION OBJECT GROUP’, 27,’REPLICATION PROPAGATOR’, 28,’JAVA SOURCE’, 29,’JAVA CLASS’, 30,’JAVA RESOURCE’, 31,’JAVA JAR’, ‘INVALID TYPE’) from x$ksuse s,x$kglob o,x$kgldp d,x$kgllk l where l.kgllkuse=s.addr and l.kgllkhdl=d.kglhdadr and l.kglnahsh=d.kglnahsh and o.kglnahsh=d.kglrfhsh and o.kglhdadr=d.kglrfhdl |
| GV$ACTIVE_INSTANCES | select inst_id, ksiminum, rpad(ksimstr,60) from x$ksimsi |
| GV$ACTIVE_SERVICES | select inst_id, kswsastabsi, kswsastabnm, kswsastabnmh, kswsastabnn, kswsastabcd, kswsastabcdh, decode(kswsastabgoal, -1, NULL, 0, ‘NONE’, 1, ‘SERVICE_TIME’, 2, ‘THROUGHPUT’, NULL) kswsastabgoal, decode(bitand(kswsastabpflg, 2), 2, ‘Y’, ‘N’), decode(bitand(kswsastabgflg, 1), 1, ‘YES’, ‘NO’), decode(bitand(kswsastabpflg, 4), 4, ‘YES’, ‘NO’), decode(bitand(kswsastabpflg, 8), 8, ‘LONG’, ‘SHORT’) from x$kswsastab where kswsastabact = 1 |
| GV$ACTIVE_SESSION_HISTORY | SELECT /*+ no_merge ordered use_nl(s,a) */ a.inst_id, s.sample_id, s.sample_time, a.session_id, a.session_serial#, a.user_id, a.sql_id, a.sql_child_number, a.sql_plan_hash_value, a.force_matching_signature, a.sql_opcode, a.service_hash, decode(a.session_type, 1,’FOREGROUND’, 2,’BACKGROUND’, ‘UNKNOWN’), decode(a.wait_time, 0, ‘WAITING’, ‘ON CPU’), decode(a.qc_session_id, 0, to_number(NULL), a.qc_session_id), decode(a.qc_session_id, 0, to_number(NULL), a.qc_instance_id), (case when a.blocking_session between 4294967291 and 4294967295 then to_number(NULL) else a.blocking_session end), (case when a.blocking_session = 4294967295 then ‘UNKNOWN’ when a.blocking_session = 4294967294 then ‘GLOBAL’ when a.blocking_session = 4294967293 then ‘UNKNOWN’ when a.blocking_session = 4294967292 then ‘NO HOLDER’ when a.blocking_session = 4294967291 then ‘NOT IN WAIT’ else ‘VALID’ end), (case when a.blocking_session between 4294967291 and 4294967295 then to_number(NULL) else a.blocking_session_serial# end), decode(a.wait_time, 0, a.event, NULL), decode(a.wait_time, 0, a.event_id, NULL), decode(a.wait_time, 0, a.event#, NULL), a.seq#, a.p1text, a.p1, a.p2text, a.p2, a.p3text, a.p3, decode(a.wait_time, 0, a.wait_class, NULL), decode(a.wait_time, 0, a.wait_class_id, NULL), a.wait_time, a.time_waited, a.xid, a.current_obj#, a.current_file#, a.current_block#, a.program, a.module, a.action, a.client_id from x$kewash s, x$ash a where s.sample_addr = a.sample_addr and s.sample_id = a.sample_id and s.sample_time = a.sample_time |
| GV$ACTIVE_SESS_POOL_MTH | select inst_id, policy_name_kgskasp from x$kgskasp |
| GV$ADVISOR_PROGRESS | select inst_id, ksulosno, ksulosrn, ksulounm, ksulopna, ksuloif5d, ksuloctx, ksulotde, ksulosfr, ksulotot, ksulouni, ksuloif3, ksuloif4, ksuloif0, ksuloif1, ksuloif2, to_date(ksulostm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(ksulolut,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), ksuloetm, decode(ksuloif6d, null, to_number(null), ksuloif6), ksuloif6d from x$ksulop where ksulopna in (‘Advisor’) |
| GV$ALERT_TYPES | SELECT t.inst_id, rid_keltsd, typnam_keltosd, decode(typ_keltsd, 1, ‘Stateful’, ‘Stateless’), nam_keltgsd, decode(scp_keltsd, 1, ‘Database’, ‘Instance’), mtn_keltsd, mtc_keltsd from x$keltsd t, x$keltosd, x$keltgsd where grp_keltsd = id_keltgsd AND otyp_keltsd = typid_keltosd |
| GV$AQ1 | select INST_ID, KWQSIQID , KWQSINWT, KWQSINRD, KWQSINEX, KWQSINCO, KWQSITWT, DECODE(KWQSINCO, 0, 0, KWQSITWT/KWQSINCO) from X$KWQSI |
| GV$ARCHIVE | select le.inst_id,le.lenum,le.lethr,le.leseq, decode(bitand(le.leflg,8),0,’NO’,'YES’), decode(bitand(le.leflg,8),0,’NO’,'YES’), to_number(le.lelos) from x$kccle le,x$kccdi di where bitand(di.diflg,1)!=0 and le.ledup!=0 and bitand(le.leflg,1)=0 and (to_number(le.lelos)<=to_number(di.difas) or bitand(le.leflg,8)=0) |
| GV$ARCHIVED_LOG | select inst_id,alrid,alstm,alnam,aldst,althp,alseq,to_number(alrls),to_date(alrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(alxlc),to_number(allos),to_date(allot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(alnxs),to_date(alnxt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),albct,albsz,decode(bitand(alflg, 16+32+64+128+256), 16, ‘ARCH’, 32, ‘FGRD’, 64, ‘RMAN’, 128,’SRMN’, 256,’LGWR’, ‘UNKNOWN’),decode(bitand(alflg, 4), 4, ‘RFS’, decode(bitand(alflg, 16+32+64+128+256), 16, ‘ARCH’, 32, ‘FGRD’, 64, ‘RMAN’, 128,’SRMN’, 256,’LGWR’, ‘UNKNOWN’)),decode(bitand(alflg, 8),0,’NO’,'YES’),decode(bitand(alflg, 2),0,’NO’,'YES’),decode(bitand(alflg, 1024),0,’NO’,'YES’),decode(bitand(alflg, 1),0,’NO’,'YES’),decode(bitand(alflg, 1+2048+4096), 0, ‘A’, 1, ‘D’, 2048,’X', 4096,’U', ‘?’),to_date(altsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(alflg,8192),0,’NO’,'YES’),decode(bitand(alflg,16384),0,’NO’,'YES’), decode(bitand(alflg,32768),0,’NO’,'YES’), to_number(bitand(alfl2,15)), altoa,alacd,decode(bitand(alfl2,64),0,’NO’,'YES’), decode(bitand(alfl2,128),0,’NO’,'YES’), decode(bitand(alflg,512),0,’NO’,'YES’), decode(bitand(alfl2,256+512+1024), 256, ‘TERMINAL’, 512, ‘ACTIVATION’, 1024, ‘RESETLOGS’, decode(bitand(alflg,32768),0,”,’SWITCHOVER’))from x$kccal |
| GV$ARCHIVE_DEST | select inst_id, to_number(ADDID), ADDXX, decode(ADSTS,1,’VALID’, 2,’INACTIVE’, 3,’DEFERRED’, 4,’ERROR’, 5,’DISABLED’, 6,’BAD PARAM’, 7,’ALTERNATE’, 8,’FULL’, ‘UNKNOWN’), decode(ADMND,0,’OPTIONAL’,'MANDATORY’), decode(ADSES,0,’SYSTEM’,'SESSION’), decode(ADRMT,0,’PRIMARY’, 1,’STANDBY’, 2,’LOCAL’, 3,’REMOTE’, ‘UNKNOWN’), decode(ADPRC,0,’ARCH’, 1,’LGWR’, 2,’FOREGROUND’, 3,’RFS’, 4,’ONDEMAND’, ‘UNKNOWN’), decode(ADSCH,0,’INACTIVE’, 1,’PENDING’, 2,’ACTIVE’, 3,’LATENT’, ‘UNKNOWN’), decode(ADOMF, 0, ADDNM, ‘USE_DB_RECOVERY_FILE_DEST’), to_number(ADLSQ), to_number(ADROP), to_number(ADDLY), to_number(ADMCS), to_number(ADNTT), decode(ADWHO,0,’ARCH’, 1,’LGWR’, 2,’FOREGROUND’, 3,’RFS’, 4,’ONDEMAND’, ‘UNKNOWN’), decode(ADREG,0,’NO’,'YES’), to_date(ADFDT,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(ADFSQ), to_number(ADFBK), to_number(ADFCT), to_number(ADMXF), ADFER, ADALT, ADDPD, ADRFT, to_number(ADQSZ), to_number(ADQSD), ADMID, decode(ADLAB,0, decode(ADPAR,0,’SYNCHRONOUS’, ‘PARALLELSYNC’), ‘ASYNCHRONOUS’), to_number(ADLAB), decode(ADAFF,0,’NO’,'YES’), decode(ADDTG,0,’PUBLIC’,'PRIVATE’), decode(ADNOW,1,’YES’, 2,’WRONG VALID_TYPE’, 3,’WRONG VALID_ROLE’, 4,’INACTIVE’, ‘UNKNOWN’), decode(ADVLD,11,’ONLINE_LOGFILE’, 12,’ONLINE_LOGFILE’, 13,’ONLINE_LOGFILE’, 21,’STANDBY_LOGFILE’, 22,’STANDBY_LOGFILE’, 23,’STANDBY_LOGFILE’, 31,’ALL_LOGFILES’, 32,’ALL_LOGFILES’, 33,’ALL_LOGFILES’, ‘UNKNOWN’), decode(ADVLD,11,’PRIMARY_ROLE’, 12,’STANDBY_ROLE’, 13,’ALL_ROLES’, 21,’PRIMARY_ROLE’, 22,’STANDBY_ROLE’, 23,’ALL_ROLES’, 31,’PRIMARY_ROLE’, 32,’STANDBY_ROLE’, 33,’ALL_ROLES’, ‘UNKNOWN’), ADDBUN, decode(ADVER,0,’NO’,'YES’) from x$kcrrdest |
| GV$ARCHIVE_DEST_STATUS | select inst_id, to_number(DSDID), DSDXX, decode(DSSTS,1,’VALID’, 2,’INACTIVE’, 3,’DEFERRED’, 4,’ERROR’, 5,’DISABLED’, 6,’BAD PARAM’, ‘UNKNOWN’), decode(DSTYP,1,’LOCAL’, 2,’PHYSICAL’, 3,’LOGICAL’, 4,’CROSS-INSTANCE’, ‘UNKNOWN’), decode(DSDMD,1,’STARTED’, 2,’MOUNTED’, 3,’MOUNTED-STANDBY’, 4,’OPEN’, 5,’OPEN_READ-ONLY’, ‘UNKNOWN’), decode(DSRMD,1,’IDLE’, 2,’MANUAL’, 3,’MANAGED’, 4,’MANAGED REAL TIME APPLY’, 5,’LOGICAL REAL TIME APPLY’, ‘UNKNOWN’), decode(DSPRT,0,’MAXIMUM PERFORMANCE’, 1,’MAXIMUM PROTECTION’, 2,’MAXIMUM AVAILABILITY’, 3,’RESYNCHRONIZATION’, ‘UNKNOWN’),DSDNM, to_number(DSCNT), to_number(DSACT), to_number(DSLTA), to_number(DSLSA), to_number(DSLTR), to_number(DSLSR), DSERR, decode(DSSRL,0,’NO’, ‘YES’), DSDBUN, decode(DSPRC, 1, ‘CHECK CONFIGURATION’, 2, ‘CHECK STANDBY REDO LOG’, 3, ‘CHECK NETWORK’, 4, ‘DESTINATION HAS A GAP’, 5, ‘OK’, ‘STATUS NOT AVAILABLE’), decode(DSPRT, 1, ‘YES’, 2, ‘YES’, ‘NO’) from x$kcrrdstat |
| GV$ARCHIVE_GAP | select USERENV(‘Instance’), high.thread#, low.lsq, high.hsq from (select a.thread#, rcvsq, min(a.sequence#)-1 hsq from v$archived_log a, (select thread#, max(sequence#) rcvsq from v$log_history group by thread#) b where a.thread# = b.thread# and a.sequence# > rcvsq group by a.thread#, rcvsq) high, (select thread#, min(sequence#)+1 lsq from v$log_history, v$datafile where checkpoint_change# <= next_change# and checkpoint_change# >= first_change# and enabled = ‘READ WRITE’ group by thread#) low where low.thread# = high.thread# and lsq < = hsq and hsq > rcvsq |
| GV$ARCHIVE_PROCESSES | select inst_id, to_number(kcrrxpid), decode(kcrrxsts, 1,’SCHEDULED’, 2,’STARTING’, 3,’ACTIVE’, 4,’STOPPING’, 5,’TERMINATED’, 6,’INITING’, ‘STOPPED’), to_number(kcrrxseq), decode(kcrrxsta, 1,’BUSY’, ‘IDLE’) from x$kcrrarch |
| GV$ASM_ALIAS | select inst_id, name_kfals, group_kfals, number_kfals, incarn_kfals, entnum_kfals, entinc_kfals, parent_kfals, refer_kfals, decode(bitand(entflg_kfals, 12), 4, ‘Y’, 8, ‘Y’, ‘N’), decode(bitand(entflg_kfals, 15), 1, ‘N’, 2, ‘Y’, 4, ‘Y’, 8, ‘N’) from x$kfals where decode(bitand(entflg_kfals, 12), 4, ‘Y’, 8, ‘Y’, ‘N’) = ‘Y’ OR decode(bitand(entflg_kfals, 16), 16, ‘Y’, ‘N’) = ‘Y’ |
| GV$ASM_CLIENT | select inst_id, gn_kfncl, instname_kfncl, dbname_kfncl, decode(status_kfncl, 1, ‘CONNECTED’, 2, ‘DISCONNECTED’, 3, ‘BROKEN’), softver_kfncl, compver_kfncl from x$kfncl |
| GV$ASM_DISK | select d.inst_id, d.grpnum_kfdsk, d.number_kfdsk, d.compound_kfdsk, d.incarn_kfdsk, decode(d.mntsts_kfdsk, 1, ‘MISSING’, 2, ‘CLOSED’, 3, ‘OPENED’, 4, ‘CACHED’, 5, ‘IGNORED’, 6, ‘IGNORED’, 7, ‘CLOSING’, ‘INVALID’), decode(d.hdrsts_kfdsk, 1, ‘UNKNOWN’, 2, ‘CANDIDATE’, 3, ‘MEMBER’, 4, ‘FORMER’, 5, ‘CONFLICT’, 6, ‘INCOMPATIBLE’, 7, ‘PROVISIONED’, 8, ‘FOREIGN’, ‘INVALID’), decode(d.mode_kfdsk, 0, ‘UNKNOWN’, 4, ‘OFFLINE’, 5, ‘PROTECT’, 6, ‘PENDING’, 7, ‘ONLINE’, ‘INVALID’), decode(d.state_kfdsk, 1, ‘UNKNOWN’, 2, ‘NORMAL’, 3, ‘FAILING’, 4, ‘DROPPING’, 5, ‘HUNG’, 6, ‘FORCING’, 7, ‘DROPPED’, 8, ‘ADDING’, ‘INVALID’), decode(d.redun_kfdsk, 16, ‘UNPROT’, 17, ‘UNPROT’, 18, ‘MIRROR’, 19, ‘MIRROR’, 20, ‘MIRROR’, 21, ‘MIRROR’, 22, ‘MIRROR’, 23, ‘MIRROR’, 32, ‘PARITY’, 33, ‘PARITY’, 34, ‘PARITY’, 35, ‘PARITY’, 36, ‘PARITY’, 37, ‘PARITY’, 38, ‘PARITY’, 39, ‘PARITY’, ‘UNKNOWN’), d.libnam_kfdsk, d.totmb_kfdsk, d.totmb_kfdsk – d.usedmb_kfdsk, d.asmname_kfdsk, d.failname_kfdsk, d.label_kfdsk, d.path_kfdsk, d.udid_kfdsk, d.product_kfdsk, d.crdate_kfdsk, d.mtdate_kfdsk, d.timer_kfdsk, k.read_kfkid, k.write_kfkid, k.rerr_kfkid, k.werr_kfkid, k.rtime_kfkid/1000000, k.wtime_kfkid/1000000, k.bytesr_kfkid, k.bytesw_kfkid from x$kfdsk d, x$kfkid k where d.mntsts_kfdsk != 0 and d.kfkid_kfdsk = k.idptr_kfkid(+) |
| GV$ASM_DISKGROUP | select g.inst_id, g.number_kfgrp, g.name_kfgrp, g.sector_kfgrp, g.blksize_kfgrp, g.ausize_kfgrp, decode(g.state_kfgrp, 0, ‘INVALID’, 1, ‘UNKNOWN’, 2, ‘DISMOUNTED’, 3, ‘CREATING’, 4, ‘MOUNTING’, 5, ‘MOUNTED’, 6, ‘DISMOUNTING’, 7, ‘CONNECTED’, 8, ‘BROKEN’, 9, ‘CONNECTING’, 10, ‘BREAKING’, 11, ‘DROPPING’), decode(g.type_kfgrp, 1, ‘EXTERN’, 2, ‘NORMAL’, 3, ‘HIGH’), g.totmb_kfgrp, g.freemb_kfgrp, g.minspc_kfgrp, g.usable_kfgrp, g.offline_kfgrp, decode(g.unbal_kfgrp, 0, ‘N’, ‘Y’), g.compat_kfgrp, g.dbcompat_kfgrp from x$kfgrp g where state_kfgrp != 0 |
| GV$ASM_DISKGROUP_STAT | select g.inst_id, g.number_kfgrp, g.name_kfgrp, g.sector_kfgrp, g.blksize_kfgrp, g.ausize_kfgrp, decode(g.state_kfgrp, 0, ‘INVALID’, 1, ‘UNKNOWN’, 2, ‘DISMOUNTED’, 3, ‘CREATING’, 4, ‘MOUNTING’, 5, ‘MOUNTED’, 6, ‘DISMOUNTING’, 7, ‘CONNECTED’, 8, ‘BROKEN’, 9, ‘CONNECTING’, 10, ‘BREAKING’, 11, ‘DROPPING’), decode(g.type_kfgrp, 1, ‘EXTERN’, 2, ‘NORMAL’, 3, ‘HIGH’), g.totmb_kfgrp, g.freemb_kfgrp, g.minspc_kfgrp, g.usable_kfgrp, g.offline_kfgrp, decode(g.unbal_kfgrp, 0, ‘N’, ‘Y’), g.compat_kfgrp, g.dbcompat_kfgrp from x$kfgrp_stat g where state_kfgrp != 0 |
| GV$ASM_DISK_STAT | select d.inst_id, d.grpnum_kfdsk, d.number_kfdsk, d.compound_kfdsk, d.incarn_kfdsk, decode(d.mntsts_kfdsk, 1, ‘MISSING’, 2, ‘CLOSED’, 3, ‘OPENED’, 4, ‘CACHED’, 5, ‘IGNORED’, 6, ‘IGNORED’, 7, ‘CLOSING’, ‘INVALID’), decode(d.hdrsts_kfdsk, 1, ‘UNKNOWN’, 2, ‘CANDIDATE’, 3, ‘MEMBER’, 4, ‘FORMER’, 5, ‘CONFLICT’, 6, ‘INCOMPATIBLE’, 7, ‘PROVISIONED’, 8, ‘FOREIGN’, ‘INVALID’), decode(d.mode_kfdsk, 0, ‘UNKNOWN’, 4, ‘OFFLINE’, 5, ‘PROTECT’, 6, ‘PENDING’, 7, ‘ONLINE’, ‘INVALID’), decode(d.state_kfdsk, 1, ‘UNKNOWN’, 2, ‘NORMAL’, 3, ‘FAILING’, 4, ‘DROPPING’, 5, ‘HUNG’, 6, ‘FORCING’, 7, ‘DROPPED’, 8, ‘ADDING’, ‘INVALID’), decode(d.redun_kfdsk, 16, ‘UNPROT’, 17, ‘UNPROT’, 18, ‘MIRROR’, 19, ‘MIRROR’, 20, ‘MIRROR’, 21, ‘MIRROR’, 22, ‘MIRROR’, 23, ‘MIRROR’, 32, ‘PARITY’, 33, ‘PARITY’, 34, ‘PARITY’, 35, ‘PARITY’, 36, ‘PARITY’, 37, ‘PARITY’, 38, ‘PARITY’, 39, ‘PARITY’, ‘UNKNOWN’), d.libnam_kfdsk, d.totmb_kfdsk, d.totmb_kfdsk – d.usedmb_kfdsk, d.asmname_kfdsk, d.failname_kfdsk, d.label_kfdsk, d.path_kfdsk, d.udid_kfdsk, d.product_kfdsk, d.crdate_kfdsk, d.mtdate_kfdsk, d.timer_kfdsk, k.read_kfkid, k.write_kfkid, k.rerr_kfkid, k.werr_kfkid, k.rtime_kfkid/1000000, k.wtime_kfkid/1000000, k.bytesr_kfkid, k.bytesw_kfkid from x$kfdsk_stat d, x$kfkid k where d.mntsts_kfdsk != 0 and d.kfkid_kfdsk = k.idptr_kfkid(+) |
| GV$ASM_FILE | select inst_id, group_kffil, number_kffil, compound_kffil, incarn_kffil, blksiz_kffil, blkcnt_kffil, filsiz_kffil, filspc_kffil, sftype_kffil, decode(redun_kffil, 17, ‘UNPROT’, 18, ‘MIRROR’, 19, ‘HIGH’, 35, ‘PARITY’, 36, ‘PARITY’, 37, ‘PARITY’, 38, ‘PARITY’), decode(bitand(fdflg_kffil, 2), 2, ‘FINE’, ‘COARSE’), crdate_kffil, mddate_kffil, decode(thinned_kffil, 0, ‘U’, 4294967295, ‘N’, ‘Y’) from x$kffil where incarn_kffil <> 0 and number_kffil > 255 |
| GV$ASM_OPERATION | select inst_id, number_kfgmg, decode(bitand(op_kfgmg, 64), 64, ‘EXPEL’, decode(bitand(op_kfgmg, 32), 32, ‘RFRSH’, decode(bitand(op_kfgmg, 16), 16, ‘ACD’, decode(bitand(op_kfgmg, 8), 8, ‘DSCV’, decode(bitand(op_kfgmg, 4), 4, ‘SYNC’, decode(bitand(op_kfgmg, 2), 2, ‘COD’, decode(bitand(op_kfgmg, 1), 1, ‘REBAL’, ‘NONE’))))))), decode(state_kfgmg, 1, ‘WAIT’, 2, ‘RUN’, 3, ‘REAP’, 4, ‘WAIT’, 5, ‘HALT’, 6, ‘ERRS’), power_kfgmg, actual_kfgmg, sofar_kfgmg, work_kfgmg, rate_kfgmg, time_kfgmg from x$kfgmg |
| GV$ASM_TEMPLATE | select inst_id, group_kftmta, entry_kftmta, decode(redundancy_kftmta, 17, ‘UNPROT’, 18, ‘MIRROR’, 19, ‘HIGH’, 35, ‘PARITY’, 36, ‘PARITY’, 37, ‘PARITY’, 38, ‘PARITY’), decode(bitand(flags_kftmta, 1), 1, ‘FINE’, ‘COARSE’), decode(bitand(flags_kftmta, 4), 4, ‘Y’, ‘N’), name_kftmta from x$kftmta |
| GV$AW_AGGREGATE_OP | select inst_id, name_xsagopft as name, desc_xsagopft as longname, case when weight_xsagopft >= 0 then weight_xsagopft else null end as default_weight from x$xsagop where not bitand(flags_xsagopft, 32) = 0 |
| GV$AW_ALLOCATE_OP | select inst_id, name_xsagopft as name, desc_xsagopft as longname from x$xsagop where not bitand(flags_xsagopft, 64) = 0 |
| GV$AW_CALC | select inst_id, session_id, agcachhit, agcachmiss, scachesuccess, scachefailure, pgcachhit, pgcachmiss, pgnewpage, pgscrounge, pgcachewrite, pgpoolsize, cdmlcmd, pdmlcmd, aggr_func_logical_na, aggr_func_precompute, aggr_func_calcs from x$xsaggr |
| GV$AW_LONGOPS | select inst_id, session_id, cursor_name, decode(command, 1, ‘FETCH’, 2, ‘IMPORT’, 3, ‘EXECUTE’, ‘?’), decode(status, 4, ‘EXECUTING’, 5, ‘FETCHING’, 6, ‘FINISHED’, ‘?’), rows_processed, start_time from x$xslongops |
| GV$AW_OLAP | select a.inst_id, s.ksusenum, a.awnum, decode(mod(a.at_mode, 128), 1, ‘READ WRITE’, ‘READ ONLY’), a.gen_xsawso, a.temp_lob_count, a.temp_lob_read, a.perm_lob_read, a.changed_cache, a.unchanged_cache from x$ksuse s, x$xsawso a where s.addr = a.KSSOBOWN and a.at_mode < 128 |
| GV$AW_SESSION_INFO | select inst_id, session_id, client, state, sesshandle, userid, tottrns, trntime/1000000, tottrntime/1000000, (tottrntime/tottrns)/1000000, trncputime/1000000, tottrncputime/1000000, (tottrncputime/tottrns)/1000000 from x$xssinfo |
| GV$BACKUP | select inst_id,hxfil, decode(hxerr, 0,decode(bitand(fhsta, 1), 0,’NOT ACTIVE’,'ACTIVE’), 1,’FILE MISSING’, 2,’OFFLINE NORMAL’, 3,’NOT VERIFIED’, 4,’FILE NOT FOUND’, 5,’CANNOT OPEN FILE’, 6,’CANNOT READ HEADER’, 7,’CORRUPT HEADER’, 8,’WRONG FILE TYPE’, 9,’WRONG DATABASE’, 10,’WRONG FILE NUMBER’, 11,’WRONG FILE CREATE’, 12,’WRONG FILE CREATE’, 16,’DELAYED OPEN’, ‘UNKNOWN ERROR’), to_number(fhbsc), to_date(fhbti,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kcvfhonl |
| GV$BACKUP_ASYNC_IO | select inst_id, sid, ser, setid, rman_status_recid, rman_status_stamp, devtype, decode(type, 1, ‘INPUT’, 2, ‘OUTPUT’, 3, ‘AGGREGATE’, ‘UNKNOWN’), decode(status, 1, ‘NOT STARTED’, 2, ‘IN PROGRESS’, 3, ‘FINISHED’, ‘UNKNOWN’), filename, set_count, set_stamp, block_size * buffer_size, buffer_count, decode(total_blocks, 0, null, total_blocks) * block_size, to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), abs((to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) – to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)) * 8640000),decode(aggregate_count, 0, null, aggregate_count) * 1, blocks * block_size, decode(instr(open_time,close_time), 1, null, round((blocks * block_size) / abs(((to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) – to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)) * 86400)))) * 1, async_short_count + async_long_count + async_ready, async_ready, async_short_count, async_short_tottime, async_short_maxtime, async_long_count, async_long_tottime, async_long_maxtime from x$ksfqp where bitand(flags,2) = 2 |
| GV$BACKUP_CORRUPTION | select inst_id,fcrid,fcstm,fcbss,fcbsc,fcpno,fcdfp,fcblk,fccnt,to_number(fcscn),decode(bitand(fcflg,1),1,’YES’,'NO’),decode(bitand(fcflg,30),2,’ALL ZERO’,4,’FRACTURED’,8,’CHECKSUM’, 16,’CORRUPT’, decode(to_number(fcscn),0,’UNKNOWN’,'LOGICAL’)) from x$kccfc |
| GV$BACKUP_DATAFILE | select inst_id,bfrid,bfstm,bfbss,bfbsc,bfdfp,to_number(bfcrs),to_date(bfcrt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(bfrls),to_date(bfrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(bfflg,1+8),1,bflvl,NULL),to_number(bfics),to_number(bfcps),to_date(bfcpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(bfafs),bfncb,bfmcb,bflcb,bffsz,bfbct,bfbsz,bflor,to_date(bftsm, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bfdfp, 0, decode(bitand(bfflg,2),2,’S',’B'), NULL), decode(bitand(bfflg,4),4,’YES’,'NO’),bfbrd, decode(bitand(bfflg,16),16,’YES’,'NO’) from x$kccbf |
| GV$BACKUP_DEVICE | select inst_id, devtype, devname from x$ksfqdvnt |
| GV$BACKUP_PIECE | select inst_id,bprid,bpstm,bpbss,bpbsc,bpnum,bitand(bpflg, 12)/4 + (bitand(bpext, 64-1) * 4) + 1,bpdev,bphdl,bpcmt,bpmdh,bitand(bpflg, 4080) / 16,decode(bitand(bpflg,2),1,’YES’,'NO’),bptag,decode(bitand(bpflg, 1+4096+8192),0,’A',1,’D',4096,’X',8192,’U',’?'),decode(bitand(bpflg,1),1,’YES’,'NO’),to_date(bptsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_date(bptim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),abs((to_date(bptim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)- to_date(bptsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’))*86400),((floor(bpext/512) * 4294967296) + bpsz1) * 512, decode(bitand(bpflg, 16384),0,’NO’,'YES’), bprsi,bprst,decode(bitand(bpext, 64),64,’YES’,'NO’) from x$kccbp |
| GV$BACKUP_REDOLOG | select inst_id,blrid,blstm,blbss,blbsc,blthp,blseq,to_number(blrls),to_date(blrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(bllos),to_date(bllot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(blnxs),to_date(blnxt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),blbct,blbsz from x$kccbl |
| GV$BACKUP_SET | select inst_id,bsrid,bsstm,bsbss,bsbsc,decode(bitand(bstyp,11),1,’D',2,’I',8,’L'),decode(bitand(bstyp,4+64),4,’YES’,68,’SBY’,'NO’),decode(bitand(bstyp,16+8192),16,bslvl,NULL),bspct,to_date(bsbst,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(bstyp, 4096),4096, to_date(bsbst,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(bstsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)),decode(bitand(bstyp, 4096),4096,0, abs((to_date(bstsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)- to_date(bsbst,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’))*86400)),bsbsz, decode(bitand(bstyp,128),128,’YES’,'NO’), decode(bitand(bstyp, 1792), 0, ‘NO’, ‘YES’), to_date(bskpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(bstyp, 1792), 256, ‘LOGS’, 512, ‘NOLOGS’, 1024, ‘CONSISTENT’, NULL) from x$kccbs where bitand(bstyp,32) != 32 |
| GV$BACKUP_SPFILE | select inst_id,birid,bistm,bibss,bibsc, to_date(bimdt, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) , bifsz, to_date(bitsm, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccbi |
| GV$BACKUP_SYNC_IO | select inst_id, sid, ser, setid, rman_status_recid, rman_status_stamp, devtype, decode(type, 1, ‘INPUT’, 2, ‘OUTPUT’, 3, ‘AGGREGATE’, ‘UNKNOWN’), decode(status, 1, ‘NOT STARTED’, 2, ‘IN PROGRESS’, 3, ‘FINISHED’, ‘UNKNOWN’), filename, set_count, set_stamp, block_size * buffer_size, buffer_count, decode(total_blocks, 0, null, total_blocks) * block_size, to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), abs((to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) – to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)) * 8640000),decode(aggregate_count, 0, null, aggregate_count) * 1, blocks * block_size, decode(instr(open_time,close_time), 1, null, round((blocks * block_size) / abs(((to_date(close_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) – to_date(open_time, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)) * 86400)))) * 1, sync_count, sync_tottime, sync_maxtime, decode(sync_tottime, 0, NULL, round((blocks * block_size) / sync_tottime * 100)) * 1 from x$ksfqp where bitand(flags,2) = 0 |
| GV$BGPROCESS | select p.inst_id, p.ksbdppro,p.ksbdpser,p.ksbdpnam,d.ksbdddsc,p.ksbdperr from x$ksbdp p,x$ksbdd d where p.indx=d.indx and p.ksbdpnam not like ‘TEST%’ |
| GV$BH | select bh.inst_id, file#, dbablk, class, decode(state,0,’free’,1,’xcur’,2,’scur’,3,’cr’, 4,’read’,5,’mrec’,6,’irec’,7,’write’,8,’pi’, 9,’memory’,10,’mwrite’,11,’donated’), 0, 0, 0, bh.le_addr, name,le_class, decode(bitand(flag,1), 0, ‘N’, ‘Y’), decode(bitand(flag,16), 0, ‘N’, ‘Y’), decode(bitand(flag,1536), 0, ‘N’, ‘Y’), decode(bitand(flag,16384), 0, ‘N’, ‘Y’), decode(bitand(flag,65536), 0, ‘N’, ‘Y’), ‘N’, obj, ts# from x$bh bh, x$le le where bh.le_addr = le.le_addr (+) |
| GV$BLOCKING_QUIESCE | select inst_id, sid_kgskvft from x$kgskvft where active_kgskvft = 1 and mapped_cg_name_kgskvft <> ‘SYS_GROUP’ |
| GV$BSP | select inst_id, reqcr, reqcur, reqdata, requndo, reqtx, rescur, respriv, reszero, resdisk, resfail, fairdc, faircl, 0, flush, 0, flushf, flushmx, light, signal from x$kclcrst |
| GV$BUFFERED_PUBLISHERS | select inst_id, queue_id, queue_schema, queue_name, sender_name, sender_address, sender_protocol, num_msgs, cnum_msgs, last_enqueued_msg, unbrowsed_msgs, overspilled_msgs, memory_usage, decode(bitand(publisher_flags, 7), 1, ‘IN FLOW CONTROL: TOO MANY UNBROWSED MESSAGES’, 2, ‘IN FLOW CONTROL: OVERSPILLED MESSAGES’, 4, ‘IN FLOW CONTROL: INSUFFICIENT MEMORY AND UNBROWSED MESSAGES’, 0, ‘PUBLISHING MESSAGES’) from x$buffered_publishers |
| GV$BUFFERED_QUEUES | select inst_id, queue_id, queue_schema, queue_name, startup_time, num_msgs, spill_msgs, cnum_msgs, cspill_msgs, expired_msgs from x$buffered_queues where bitand(flags, 16) = 0 |
| GV$BUFFERED_SUBSCRIBERS | select s.inst_id, s.queue_id, q.queue_schema, q.queue_name, s.subscriber_id, s.subscriber_name, s.subscriber_address, s.protocol, s.subscriber_type, q.startup_time, s.last_browsed_seq, s.last_browsed_num, s.last_dequeued_seq, s.last_dequeued_num, s.current_enq_seq, s.num_msgs, s.cnum_msgs, s.total_dequeued_msg, s.total_spilled_msg, s.expired_msgs from x$buffered_subscribers s, x$buffered_queues q where s.inst_id = q.inst_id and s.queue_id = q.queue_id and bitand(q.flags, 16) = 0 |
| GV$BUFFER_POOL | select inst_id, bp_id, bp_name, bp_blksz, decode(bp_state, 0, ‘STATIC’, 1, ‘ALLOCATING’, 2, ‘ACTIVATING’, 3, ‘SHRINKING’), bp_currgrans * bp_gransz, bp_size, bp_tgtgrans * bp_gransz, bp_tgtgrans * bp_bufpergran, bp_prevgrans * bp_gransz, bp_prevgrans * bp_bufpergran, 0, 0, bp_lo_sid, bp_hi_sid, bp_set_ct from x$kcbwbpd where bp_id > 0 and bp_currgrans > 0 and bp_tgtgrans > 0 |
| GV$BUFFER_POOL_STATISTICS | select kcbwbpd.inst_id, kcbwbpd.bp_id, kcbwbpd.bp_name, kcbwbpd.bp_blksz, sum(kcbwds.cnum_set),sum(kcbwds.cnum_repl), sum(kcbwds.cnum_write), sum(kcbwds.cnum_set), sum(kcbwds.buf_got), sum(kcbwds.sum_wrt), sum(kcbwds.sum_scn), sum(kcbwds.fbwait), sum(kcbwds.wcwait), sum(kcbwds.bbwait), sum(kcbwds.fbinsp), sum(kcbwds.dbinsp), sum(kcbwds.dbbchg), sum(kcbwds.dbbget), sum(kcbwds.conget), sum(kcbwds.pread), sum(kcbwds.pwrite) from x$kcbwds kcbwds, x$kcbwbpd kcbwbpd where kcbwds.set_id >= kcbwbpd.bp_lo_sid and kcbwds.set_id <= kcbwbpd.bp_hi_sid and kcbwbpd.bp_size != 0 group by kcbwbpd.inst_id, kcbwbpd.bp_id, kcbwbpd.bp_name, kcbwbpd.bp_blksz |
| GV$CIRCUIT | select inst_id,kmcvcadr,kmcvcdpc,decode(kmcvcpro,kmcvcdpc, hextoraw(’00′),kmcvcpro),kmcvcwat,kmcvcses,kmcvcsta,kmcvcque,kmcvcsz0, kmcvcsz1,kmcvcsz2,kmcvcsz3,kmcvcnmg,kmcvcnmb,kmcvcbrk,kmcvcpre,kmcvcpvc from x$kmcvc where bitand(ksspaflg,1) != 0 |
| GV$CLASS_CACHE_TRANSFER | select 0, ‘data block’, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from dual |
| GV$CLASS_PING | select 0, ‘data block’, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from dual |
| GV$CLIENT_STATS | select c.inst_id, c.clsnam, m.extid, m.sname, c.statval from x$kewecls c, x$kewssmap m where c.clspos = m.offst and m.aggid = 5 |
| GV$CLUSTER_INTERCONNECTS | SELECT INST_ID, NAME_SKGXPIA, IP_SKGXPIA, decode(PUB_SKGXPIA, ‘Y’, ‘YES’, ‘N’, ‘NO’), decode(PICKED_SKGXPIA, ‘OSD’, ‘OS dependent software’, ‘OCR’, ‘Oracle Cluster Repository’, ‘CI’, ‘cluster_interconnects parameter’) from X$SKGXPIA |
| GV$CONFIGURED_INTERCONNECTS | SELECT INST_ID, NAME_KSXPIA, IP_KSXPIA, decode(PUB_KSXPIA, ‘Y’, ‘YES’, ‘N’, ‘NO’), decode(PICKED_KSXPIA, ‘OSD’, ‘OS dependent software’, ‘OCR’, ‘Oracle Cluster Repository’, ‘CI’, ‘cluster_interconnects parameter’) from X$KSXPIA |
| GV$CONTEXT | select namespace, attribute, value from x$context |
| GV$CONTROLFILE | select inst_id,decode(bitand(cfflg,1),0,”,1,’INVALID’),cfnam, decode(bitand(cffl2,1),0,’NO’,'YES’), cfbsz, cffsz from x$kcccf |
| GV$CONTROLFILE_RECORD_SECTION | select inst_id,decode(indx,0,’DATABASE’,1, ‘CKPT PROGRESS’, 2, ‘REDO THREAD’,3,’REDO LOG’,4,’DATAFILE’,5,’FILENAME’,6,’TABLESPACE’,7,’TEMPORARY FILENAME’,8,’RMAN CONFIGURATION’,9,’LOG HISTORY’,10,’OFFLINE RANGE’,11,’ARCHIVED LOG’,12,’BACKUP SET’,13,’BACKUP PIECE’,14,’BACKUP DATAFILE’,15, ‘BACKUP REDOLOG’,16,’DATAFILE COPY’,17,’BACKUP CORRUPTION’,18,’COPY CORRUPTION’,19,’DELETED OBJECT’,20,’PROXY COPY’,21,’BACKUP SPFILE’,23,’DATABASE INCARNATION’,24,’FLASHBACK LOG’,25, ‘RECOVERY DESTINATION’, 26,’INSTANCE SPACE RESERVATION’, 27, ‘REMOVABLE RECOVERY FILES’, 28, ‘RMAN STATUS’, 29, ‘THREAD INSTANCE NAME MAPPING’, 30, ‘MTTR’, 31, ‘DATAFILE HISTORY’, 32, ‘STANDBY DATABASE MATRIX’, 33, ‘GUARANTEED RESTORE POINT’, 34, ‘RESTORE POINT’, ‘UNKNOWN’),rsrsz,rsnum,rsnus,rsiol,rsilw,rsrlw from x$kccrs where indx not in (22) |
| GV$COPY_CORRUPTION | select inst_id,ccrid,ccstm,ccdcp,ccdcs,ccdfp,ccblk,cccnt,to_number(ccscn),decode(bitand(ccflg,1),1,’YES’,'NO’),decode(bitand(ccflg,30),2,’ALL ZERO’,4,’FRACTURED’,8,’CHECKSUM’, 16,’CORRUPT’, decode(to_number(ccscn),0,’UNKNOWN’,'LOGICAL’)) from x$kcccc |
| GV$CR_BLOCK_SERVER | select inst_id, reqcr, reqcur, reqdata, requndo, reqtx, rescur, respriv, reszero, resdisk, resfail, fairdc, faircl, 0, flush, 0, flushf, flushmx, light, signal from x$kclcrst |
| GV$CURRENT_BLOCK_SERVER | select inst_id, pin1, pin10, pin100, pin1000, pin10000, flush1, flush10, flush100, flush1000, flush10000, write1, write10, write100, write1000, write10000 from x$kclcurst |
| GV$DATABASE | select di.inst_id,di.didbi,di.didbn,to_date(di.dicts,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(di.dirls),to_date(di.dirlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(di.diprs),to_date(di.diprc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(di.dimla,0,’NOARCHIVELOG’,1,’ARCHIVELOG’,'MANUAL’),to_number(di.discn),to_number(di.difas),decode(bitand(di.diflg,256),256,’CREATED’,decode(bitand(di.diflg,1024),1024,’STANDBY’,decode(bitand(di.diflg,32768),32768,’CLONE’,decode(bitand(di.diflg,4096),4096,’BACKUP’,'CURRENT’)))),to_date(di.dicct,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),di.dicsq,to_number(di.dickp_scn),to_date(di.dickp_tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(di.diflg,4),4,’REQUIRED’,decode(di.diirs,0,’NOT ALLOWED’,'ALLOWED’)),to_date(di.divts,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(di.didor,0,’MOUNTED’,decode(di.didor,1,’READ WRITE’,'READ ONLY’)),decode(bitand(di.diflg,65536),65536,’MAXIMUM PROTECTION’,decode(bitand(di.diflg,128),128,’MAXIMUM AVAILABILITY’,decode(bitand(di.diflg,134217728),134217728,’RESYNCHRONIZATION’,decode(bitand(di.diflg,8),8,’UNPROTECTED’,'MAXIMUM PERFORMANCE’)))),decode(di.diprt,1,’MAXIMUM PROTECTION’,2,’MAXIMUM AVAILABILITY’,3,’RESYNCHRONIZATION’,4,’MAXIMUM PERFORMANCE’,5,’UNPROTECTED’, ‘UNKNOWN’),decode(di.dirae,0,’DISABLED’,1,’SEND’,2,’RECEIVE’,3,’ENABLED’,'UNKNOWN’),to_number(di.diacid),to_number(di.diacid),decode(bitand(di.diflg,33554432),33554432,’LOGICAL STANDBY’,decode(bitand(di.diflg,1024),1024,’PHYSICAL STANDBY’,'PRIMARY’)),to_number(di.diars),decode(bitand(difl2,1),1,’ENABLED’,'DISABLED’),decode(di.disos,0,’IMPOSSIBLE’,1,’NOT ALLOWED’,2,’SWITCHOVER LATENT’,3,’SWITCHOVER PENDING’,4,’TO PRIMARY’,5,’TO STANDBY’,6,’RECOVERY NEEDED’,7,’SESSIONS ACTIVE’,8,’PREPARING SWITCHOVER’,9,’PREPARING DICTIONARY’,10,’TO LOGICAL STANDBY’,'UNKNOWN’),decode(di.didgd,0,’DISABLED’,'ENABLED’),decode(bitand(di.diflg,1048576),1048576,’ALL’,decode(bitand(di.diflg,2097152),2097152,’STANDBY’,'NONE’)),decode(bitand(diflg,1073741824),1073741824, ‘YES’, decode(bitand(diflg, 131072 + 262144 + 524288),0, decode(bitand(difl2,2), 0,’NO’,'IMPLICIT’), ‘IMPLICIT’)),decode(bitand(di.diflg,131072),131072,’YES’,'NO’),decode(bitand(di.diflg,262144),262144,’YES’,'NO’),decode(bitand(di.diflg,268435456),268435456,’YES’,'NO’),di.diplid, di.dipln, di2.di2rdi, di2.di2inc,to_number(di.dicur_scn),decode(bitand(di2.di2flag,1),1,’YES’, decode(di2.di2rsp_oldest,0,’NO’,'RESTORE POINT ONLY’)),decode(bitand(diflg,524288),524288,’YES’,'NO’),decode(bitand(difl2,2),2,’YES’,'NO’),di.didbun, to_number(di2.di2actiscn), decode(di.difsts,0,’DISABLED’,1,’BYSTANDER’,2,’SYNCHRONIZED’,3,’UNSYNCHRONIZED’,4,’SUSPENDED’,5,’STALLED’,6,’LOADING DICTIONARY’,7,’PRIMARY UNOBSERVED’,8,’REINSTATE REQUIRED’,9,’REINSTATE IN PROGRESS’,10,’REINSTATE FAILED’,”), di.diftgt, di.difths,decode(di.difopr,1,’YES’,2,’NO’,3,’UNKNOWN’,”), di.difobs from x$kccdi di, x$kccdi2 di2 |
| GV$DATABASE_BLOCK_CORRUPTION | select distinct userenv(‘Instance’), file#, block#, blocks, corruption_change#, corruption_type from ( select file#, block#, blocks, corruption_change#, copy_stamp stamp, corruption_type from v$copy_corruption union select file#, block#, blocks, corruption_change#, bs.stamp, corruption_type from v$backup_corruption bc, v$backup_set bs where bc.set_count = bs.set_count and bc.set_stamp = bs.set_stamp ) outer where not exists ( select 1 from v$datafile_copy where scanned = ‘YES’ and outer.file# = file# and outer.stamp < stamp union select 1 from v$backup_datafile bdf, v$backup_set bs where bdf.set_count = bs.set_count and bdf.set_stamp = bs.set_stamp and outer.file# = file# and outer.stamp < bs.stamp and (datafile_blocks = blocks_read or (nvl(bdf.incremental_level, 0) = 0 and used_optimization = ‘YES’)) ) |
| GV$DATABASE_INCARNATION | select userenv(‘Instance’), icrid, to_number(icrls), to_date(icrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(icprs), to_date(icprc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), decode(icflg, 1,’ORPHAN’, 2, ‘CURRENT’, 0, ‘PARENT’, null), icrlc_i, icpinc, icalw from x$kccic |
| GV$DATAFILE | select /*+ rule */ fe.inst_id,fe.fenum,to_number(fe.fecrc_scn), to_date(fe.fecrc_tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), fe.fetsn,fe.ferfn, decode(fe.fetsn,0,decode(bitand(fe.festa,2),0,’SYSOFF’,'SYSTEM’), decode(bitand(fe.festa,18),0,’OFFLINE’,2,’ONLINE’,'RECOVER’)), decode(fe.fedor,2,’READ ONLY’, decode(bitand(fe.festa, 12), 0,’DISABLED’,4,’READ ONLY’,12,’READ WRITE’,'UNKNOWN’)), to_number(fe.fecps), to_date(fe.fecpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(fe.feurs), to_date(fe.feurt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(fe.fests), decode(fe.fests,NULL,to_date(NULL), to_date(fe.festt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)), to_number(fe.feofs),to_number(fe.feonc_scn), to_date(fe.feonc_tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), fh.fhfsz*fe.febsz,fh.fhfsz,fe.fecsz*fe.febsz,fe.febsz,fn.fnnam, fe.fefdb,fn.fnbof, decode(fe.fepax, 0, ‘UNKNOWN’, 65535, ‘NONE’, fnaux.fnnam), to_number(fh.fhfirstunrecscn), to_date(fh.fhfirstunrectime,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccfe fe, x$kccfn fn, x$kccfn fnaux, x$kcvfh fh where ((fe.fepax!=65535 and fe.fepax!=0 and fe.fepax=fnaux.fnnum) or ((fe.fepax=65535 or fe.fepax=0) and fe.fenum=fnaux.fnfno and fnaux.fntyp=4 and fnaux.fnnam is not null and bitand(fnaux.fnflg, 4) != 4 and fe.fefnh=fnaux.fnnum)) and fn.fnfno=fe.fenum and fn.fnfno=fh.hxfil and fe.fefnh=fn.fnnum and fe.fedup!=0 and fn.fntyp=4 and fn.fnnam is not null and bitand(fn.fnflg, 4) != 4 |
| GV$DATAFILE_COPY | select inst_id,dcrid,dcstm,dcnam,dctag,dcdfp,dcrfn,to_number(dccrs),to_date(dccrt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(dcrls),to_date(dcrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(dcflg,8),8,0,NULL),to_number(dccps),to_date(dccpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(dcafs),to_number(dcrfs),to_date(dcrft,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(dcflg, 2),0,’NO’,'YES’),decode(bitand(dcflg, 4),0,’NO’,'YES’),dcncb,dcmcb,dclcb,dcbct,dcbsz,dclor,decode(bitand(dcflg, 1),0,’NO’,'YES’),decode(bitand(dcflg, 1+32+64),0,’A',1,’D',32,’X',64,’U',’?'),to_date(dctsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), decode(dcdfp, 0, decode(bitand(dcflg, 16),16,’S',’B'),NULL), decode(bitand(dcflg, 1792), 0, ‘NO’, ‘YES’), to_date(dckpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(dcflg, 1792), 256, ‘LOGS’, 512, ‘NOLOGS’, 1024, ‘CONSISTENT’, NULL), decode(bitand(dcflg, 128),0,’NO’,'YES’), decode(bitand(dcflg, 2048),0,’NO’,'YES’), dcrsi, dcrst from x$kccdc |
| GV$DATAFILE_HEADER | select inst_id,hxfil,decode(hxons, 0, ‘OFFLINE’, ‘ONLINE’),decode(hxerr, 0, NULL, 1,’FILE MISSING’,2,’OFFLINE NORMAL’, 3,’NOT VERIFIED’, 4,’FILE NOT FOUND’,5,’CANNOT OPEN FILE’, 6,’CANNOT READ HEADER’, 7,’CORRUPT HEADER’,8,’WRONG FILE TYPE’, 9,’WRONG DATABASE’, 10,’WRONG FILE NUMBER’,11,’WRONG FILE CREATE’, 12,’WRONG FILE CREATE’, 16,’DELAYED OPEN’,14, ‘WRONG RESETLOGS’, 15,’OLD CONTROLFILE’, ‘UNKNOWN ERROR’),hxver,decode(hxnrcv, 0,’NO’, 1,’YES’, NULL),decode(hxifz, 0,’NO’, 1,’YES’, NULL),to_number(fhcrs),to_date(fhcrt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),fhtnm,fhtsn,fhrfn,to_number(fhrls),to_date(fhrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(fhscn),to_date(fhtim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),fhcpc,fhfsz*fhbsz,fhfsz,hxfnm, decode(hxlmdba, 0, NULL, hxlmdba), decode(hxlmld_scn, ’0′, NULL, hxlmld_scn) from x$kcvfh |
| GV$DATAGUARD_CONFIG | select DGCDBUN from x$kcrrdgc |
| GV$DATAGUARD_STATUS | select inst_id, decode(agfac,1,’Crash Recovery’, 2,’Log Transport Services’, 3,’Log Apply Services’, 4,’Role Management Services’, 5,’Remote File Server’, 6,’Fetch Archive Log’, 7,’Data Guard’, 8,’Network Services’, ‘UNKNOWN’), decode(agsev,1,’Informational’, 2,’Warning’, 3,’Error’, 4,’Fatal’, 5,’Control’, ‘UNKNOWN’), agdid, agseq, agoer, decode(bitand(agflg, 1),0,’NO’,'YES’), to_date(agdat,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), agtxt from x$kcrralg order by agseq |
| GV$DATAPUMP_JOB | SELECT inst_id, kupvjid, kupvjjob, kupvjowner, kupvjctrlque, kupvjstatque, kupvjoperation, kupvjmode, kupvjmasterid, kupvjstate, kupvjworkers, kupvjflags from x$kupvj |
| GV$DATAPUMP_SESSION | SELECT inst_id, kupvaid, kupvajobid, kupvasesaddr, decode(kupvasestype,1,’DBMS_DATAPUMP’,2,’MASTER’,3,’WORKER’, 4,’EXTERNAL TABLE’,'OTHER’) from x$kupva |
| GV$DBFILE | select inst_id,fnfno,fnnam from x$kccfn where fnnam is not null and bitand(fnflg, 4) != 4 and fntyp=4 |
| GV$DBLINK | select inst_id,nconam, ncouid, decode(bitand(hstflg, 32), 0, ‘NO’, ‘YES’), decode(bitand(hstflg, 8), 0, ‘NO’, ‘YES’), decode(hstpro, 1, ‘V5′, 2, ‘V6′, 3, ‘V6_NLS’, 4, ‘V7′, ‘UNKN’), ncouct, decode(bitand(ncoflg, 2), 0, ‘NO’, ‘YES’), decode(bitand(ncoflg, 8), 0, ‘NO’, ‘YES’), nco2pstr from x$uganco where bitand(hstflg, 1) != 0 |
| GV$DB_CACHE_ADVICE | select A.inst_id, A.bpid, B.bp_name, A.blksz, decode (A.status, 2, ‘ON’, ‘OFF’), A.poolsz, round((A.poolsz / A.actual_poolsz), 4), A.nbufs, decode (A.base_preads, 0, to_number(null), round((A.preads / A.base_preads), 4)), decode (A.base_preads, 0, A.actual_preads, round((A.preads * (A.actual_preads / A.base_preads)), 0)), A.estd_time_for_disk_reads, decode (A.total_db_time, 0, A.estd_time_for_disk_reads, round((100 * A.estd_time_for_disk_reads / A.total_db_time), 1)), A.estd_rac_reads, A.estd_rac_time from x$kcbsc A, x$kcbwbpd B where A.bpid = B.bp_id and A.inst_id = B.inst_id order by A.inst_id, A.bpid, A.poolsz |
| GV$DB_OBJECT_CACHE | select inst_id,kglnaown,kglnaobj,kglnadlk, decode(kglhdnsp,0,’CURSOR’,1,’TABLE/PROCEDURE’,2,’BODY’,3,’TRIGGER’, 4,’INDEX’,5,’CLUSTER’,6,’OBJECT’,13,’JAVA SOURCE’,14,’JAVA RESOURCE’, 15,’REPLICATED TABLE OBJECT’,16,’REPLICATION INTERNAL PACKAGE’, 17,’CONTEXT POLICY’,18,’PUB_SUB’,19,’SUMMARY’,20,’DIMENSION’, 21,’APP CONTEXT’,22,’STORED OUTLINE’,23,’RULESET’,24,’RSRC PLAN’, 25,’RSRC CONSUMER GROUP’,26,’PENDING RSRC PLAN’,27,’PENDING RSRC CONSUMER GROUP’, 28,’SUBSCRIPTION’,29,’LOCATION’,30,’REMOTE OBJECT’, 31,’SNAPSHOT METADATA’,32,’JAVA SHARED DATA’,33,’SECURITY PROFILE’, ‘INVALID NAMESPACE’), decode(bitand(kglobflg,3),0,’NOT LOADED’,2,’NON-EXISTENT’,3,’INVALID STATUS’, decode(kglobtyp, 0,’CURSOR’,1,’INDEX’,2,’TABLE’,3,’CLUSTER’,4,’VIEW’, 5,’SYNONYM’,6,’SEQUENCE’,7,’PROCEDURE’,8,’FUNCTION’,9,’PACKAGE’,10, ‘NON-EXISTENT’,11,’PACKAGE BODY’,12,’TRIGGER’,13,’TYPE’,14,’TYPE BODY’, 15,’OBJECT’,16,’USER’,17,’DBLINK’,18,’PIPE’,19,’TABLE PARTITION’, 20,’INDEX PARTITION’,21,’LOB’,22,’LIBRARY’,23,’DIRECTORY’,24,’QUEUE’, 25,’INDEX-ORGANIZED TABLE’,26,’REPLICATION OBJECT GROUP’, 27,’REPLICATION PROPAGATOR’, 28,’JAVA SOURCE’,29,’JAVA CLASS’,30,’JAVA RESOURCE’,31,’JAVA JAR’, 32,’INDEX TYPE’,33, ‘OPERATOR’,34,’TABLE SUBPARTITION’,35,’INDEX SUBPARTITION’, 36, ‘REPLICATED TABLE OBJECT’,37,’REPLICATION INTERNAL PACKAGE’, 38,’CONTEXT POLICY’,39,’PUB_SUB’,40,’LOB PARTITION’,41,’LOB SUBPARTITION’, 42,’SUMMARY’,43,’DIMENSION’,44,’APP CONTEXT’,45,’STORED OUTLINE’,46,’RULESET’, 47,’RSRC PLAN’,48,’RSRC CONSUMER GROUP’,49,’PENDING RSRC PLAN’, 50,’PENDING RSRC CONSUMER GROUP’,51,’SUBSCRIPTION’,52,’LOCATION’, 53,’REMOTE OBJECT’,54,’SNAPSHOT METADATA’,55,’IFS’, 56,’JAVA SHARED DATA’,57,’SECURITY PROFILE’,'INVALID TYPE’)), kglobhs0+kglobhs1+kglobhs2+kglobhs3+kglobhs4+kglobhs5+kglobhs6, kglhdldc,kglhdexc,kglhdlkc,kglobpc0,decode(kglhdkmk,0,’NO’,'YES’),kglhdclt, kglhdivc from x$kglob |
| GV$DB_PIPES | select inst_id,decode(kglobt00,1,kglobt17,null),kglnaobj, decode(kglobt00,1,’PRIVATE’,'PUBLIC’), kglobhs0+kglobhs1+kglobhs2+kglobhs3+kglobhs4+kglobhs5+kglobhs6 from x$kglob where kglhdnsp=7 and kglobsta != 0 |
| GV$DB_TRANSPORTABLE_PLATFORM | select INST_ID, PLATFORM_ID, PLATFORM_NAME, decode(endian_format, 1,’Big’ ,0,’Little’,'UNKNOWN FORMAT’) from x$kcpxpl where endian_format = (select endian_format from x$kcpxpl pl, x$kccdi di where pl.platform_id = di.diplid) |
| GV$DELETED_OBJECT | select inst_id,dlrid,dlstm,decode(dltyp,11,’ARCHIVED LOG’,13,’BACKUP PIECE’,16,’DATAFILE COPY’,20,’PROXY COPY’,255,’BACKUP PIECE AVAILABLE’,254,’BACKUP PIECE EXPIRED’,253,’PROXY COPY AVAILABLE’,252,’PROXY COPY EXPIRED’,251,’BACKUP PIECE UNAVAILABLE’,250,’PROXY COPY UNAVAILABLE’,249,’DATAFILE COPY AVAILABLE’,248,’DATAFILE COPY EXPIRED’,247,’DATAFILE COPY UNAVAILABLE’,246,’ARCHIVED LOG AVAILABLE’,245,’ARCHIVED LOG EXPIRED’,244,’ARCHIVED LOG UNAVAILABLE’,243,’BACKUP SET KEEP OPTIONS’,242,’BACKUP SET KEEP UNTIL’,241,’PROXY COPY KEEP OPTIONS’,240,’PROXY COPY KEEP UNTIL’,239,’DATAFILE COPY KEEP OPTIONS’,238,’DATAFILE COPY KEEP UNTIL’,237,’DATAFILE RENAME ON RESTORE’,236,’TEMPFILE RENAME’,'UNKNOWN’),dlobp,dlosm,dltsd from x$kccdl |
| GV$DISPATCHER | select inst_id,kmmdinam,kmmdiadd,kmmdipro,kmmdista, decode(kmmdiacc,0,’NO’,'YES’),kmmdinmg,kmmdinmb,kmmdibrk, kmmdinvo,kmmditnc,kmmdiidl,kmmdibsy,kmmdiler,kmmdidci from x$kmmdi where kmmdiflg != 0 |
| GV$DISPATCHER_CONFIG | select inst_id, indx, kmmdpnet, kmmdpopt, kmmdpcon, kmmdpses, decode(bitand(kmmdpflg, 3), 0, ‘OFF’, 1, ‘IN’, 2, ‘OUT’, ‘BOTH’), kmmdptck, kmmdptin, kmmdptou, decode(bitand(kmmdpflg, 12), 0, ‘OFF’, 4, ‘IN’, 8, ‘OUT’, ‘BOTH’), kmmdplsn,kmmdpsnm from x$kmmdp |
| GV$DISPATCHER_RATE | select inst_id,kmmdinam,kmmdipro,kmmdicrle,kmmdicre,kmmdicepl,kmmdicrm, kmmdicrus,kmmdicrys,kmmdicyus,kmmdicruc,kmmdicryc,kmmdicyuc,kmmdicru, kmmdicry,kmmdicyu,kmmdicic,kmmdicoc,kmmdicrr,kmmdimrle,kmmdimre,kmmdimepl, kmmdimrm,kmmdimrus,kmmdimrys,kmmdimyus,kmmdimruc,kmmdimryc,kmmdimyuc, kmmdimru,kmmdimry,kmmdimyu,kmmdimic,kmmdimoc,kmmdimrr,kmmdiarle,kmmdiare, kmmdiaepl,kmmdiarm,kmmdiarus,kmmdiarys,kmmdiayus,kmmdiaruc,kmmdiaryc, kmmdiayuc,kmmdiaru,kmmdiary,kmmdiayu,kmmdiaic,kmmdiaoc,kmmdiarr, kmmdinrle,kmmdinrm,kmmdinrus,kmmdinruc,kmmdinru,kmmdinic,kmmdinoc,kmmdinrr, kmmdisrle,kmmdisrm,kmmdisrus,kmmdisruc,kmmdisru,kmmdisic,kmmdisoc,kmmdisrr from x$kmmdi where kmmdiflg!=0 |
| GV$DLM_ALL_LOCKS | select USERENV(‘Instance’), HANDLE, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, STATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from V$GES_ENQUEUE |
| GV$DLM_CONVERT_LOCAL | select inst_id, kjicvtnam, kjicvtalt, kjicvtalc from x$kjicvt |
| GV$DLM_CONVERT_REMOTE | select inst_id, kjicvtnam, kjicvtart, kjicvtarc from x$kjicvt |
| GV$DLM_LATCH | select USERENV(‘Instance’), addr, latch#, level#, name, gets, misses, sleeps,immediate_gets, immediate_misses, waiters_woken, waits_holding_latch, spin_gets, sleep1, sleep2, sleep3, sleep4, sleep5, sleep6, sleep7, sleep8, sleep9, sleep10, sleep11, wait_time from V$LATCH where NAME like ‘ges %’ or NAME like ‘gcs %’ |
| GV$DLM_LOCKS | select USERENV(‘Instance’), HANDLE, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, STATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from V$GES_BLOCKING_ENQUEUE |
| GV$DLM_MISC | select inst_id, indx, kjisftdesc, kjisftval from x$kjisft |
| GV$DLM_RESS | select inst_id, kjirftrp, kjirftrn, kjirftcq, kjirftgq, kjirftpr, kjirftmn, kjirftncl, kjirftvs, kjirftvb from x$kjirft union all select inst_id, kjbrresp, kjbrname, decode(kjbrcvtq, ’00′, 0, 1), decode(kjbrgrantq, ’00′, 0, 1), 1, kjbrmaster, kjbrncvl, ‘KJUSERVS_NOVALUE’, ’0×0′ from x$kjbr |
| GV$DLM_TRAFFIC_CONTROLLER | select inst_id, kjitrftlid, kjitrftrid, kjitrftrrd, kjitrftinc, kjitrftta, kjitrfttl, kjitrfttr, decode(kjitrfttw,0, ‘NO ‘, ‘YES ‘), kjitrftss, kjitrftsr, kjitrftsql, kjitrftsqm, kjitrftsqt, kjitrftqtb, kjitrftqtw, kjitrftst, kjitrftpxy from x$kjitrft |
| GV$ENABLEDPRIVS | select inst_id,-kzsprprv from x$kzspr |
| GV$ENQUEUE_LOCK | select s.inst_id,l.addr,l.ksqlkadr,s.ksusenum,r.ksqrsidt, r.ksqrsid1,r.ksqrsid2, l.ksqlkmod, l.ksqlkreq,l.ksqlkctim,l.ksqlklblk from x$ksqeq l,x$ksuse s,x$ksqrs r where l.ksqlkses=s.addr and bitand(l.kssobflg,1)!=0 and (l.ksqlkmod!=0 or l.ksqlkreq!=0) and l.ksqlkres=r.addr |
| GV$ENQUEUE_STAT | select inst_id, ksqsttyp, sum(ksqstreq), sum(ksqstwat), sum(ksqstsgt), sum(ksqstfgt), sum(ksqstwtm) from X$KSQST group by inst_id, ksqsttyp having sum(ksqstreq) > 0 |
| GV$ENQUEUE_STATISTICS | select st.inst_id, eqt.name, st.ksqsttyp, st.ksqstrsn, st.ksqstreq, st.ksqstwat, st.ksqstsgt, st.ksqstfgt, st.ksqstwtm, st.ksqstexpl, st.ksqstevidx from X$KSQST st, X$KSQEQTYP eqt where (st.inst_id = eqt.inst_id) and (st.ksqsttyp = eqt.resname) and (st.indx > 0) |
| GV$EVENTMETRIC | SELECT inst_id, begtime, endtime, intsize_csec, wait#, wait_id, nsess_wait, time_waited, wait_count from x$kewmevmv where flag1 = 1 AND GROUPID = 0 |
| GV$EVENT_HISTOGRAM | select d.inst_id, d.indx, d.kslednam, s.kslsesmaxdur, s.kslsesval from x$kslseshist s, x$ksled d where s.kslsesenum = d.indx |
| GV$EVENT_NAME | select inst_id, indx, ksledhash, kslednam, ksledp1, ksledp2, ksledp3, ksledclassid, ksledclass#, ksledclass from x$ksled |
| GV$EXECUTION | select inst_id, pid, val0, func, decode(id,1,’call’,2,’return’,3,’longjmp’), nvals, val2, val3, seqh, seql from x$kstex where op=10 |
| GV$FAST_START_SERVERS | SELECT inst_id, state, wdone, pid, xid from x$ktprxrs |
| GV$FAST_START_TRANSACTIONS | SELECT inst_id, usn, slt, seq, state, wkd, twk, pid, etime, parentusn, parentslt, parentseq, xid, pxid, svrs from x$ktprxrt UNION ALL SELECT inst_id, usn, slt, seq, state, twk-wkl, twk, NULL, etime, NULL, NULL, NULL, xid, NULL, svrs from x$kturhist |
| GV$FILEMETRIC | SELECT inst_id, begtime, endtime, intsize_csec, fileid, creationtime, avrdtime, avwrtime, phyread, phywrite, phybkrd, phybkwr from x$kewmflmv where flag1 = 1 |
| GV$FILEMETRIC_HISTORY | SELECT inst_id, begtime, endtime, intsize_csec, fileid, creationtime, avrdtime, avwrtime, phyread, phywrite, phybkrd, phybkwr from x$kewmflmv |
| GV$FILESPACE_USAGE | SELECT inst_id, KTTEFINFOTSN, KTTEFINFOFNO, KTTEFINFOUSP, KTTEFINFOSIZE, KTTEFINFOMSIZE, KTTEFINFOSCNB, KTTEFINFOSCNW, KTTEFINFOFLAG from X$KTTEFINFO |
| GV$FILESTAT | select k.inst_id, k.kcfiofno,k.kcfiopyr,k.kcfiopyw,k.kcfiopbr,k.kcfiopbw, k.kcfiosbr,k.kcfioprt,k.kcfiopwt,k.kcfiosbt,k.kcfioavg,k.kcfiolst,k.kcfiomin, k.kcfiormx,k.kcfiowmx from x$kcfio k,x$kccfe f where f.fedup <> 0 and f.fenum=k.kcfiofno |
| GV$FILE_CACHE_TRANSFER | select x.inst_id, kcfiofno, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from x$kcfio x, x$kccfe fe where x.kcfiofno = fe.fenum |
| GV$FILE_HISTOGRAM | select k.inst_id, k.kcfiofno,k.kcfiomaxdur,k.kcfioval from x$kcfiohist k,x$kccfe f where f.fedup <> 0 and f.fenum=k.kcfiofno |
| GV$FILE_PING | select x.inst_id, kcfiofno, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from x$kcfio x, x$kccfe fe where x.kcfiofno = fe.fenum |
| GV$FIXED_TABLE | select inst_id,kqftanam, kqftaobj, ‘TABLE’, indx from x$kqfta union all select inst_id,kqfvinam, kqfviobj, ‘VIEW’, 65537 from x$kqfvi union all select inst_id,kqfdtnam, kqfdtobj, ‘TABLE’, 65537 from x$kqfdt |
| GV$FIXED_VIEW_DEFINITION | select i.inst_id,kqfvinam,kqftpsel from x$kqfvi i, x$kqfvt t where i.indx = t.indx |
| GV$FLASHBACK_DATABASE_LOG | select inst_id, to_number(fblogscn), to_date(fblogtim, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), fblogretn, totsize, to_number(fblogesiz) from x$krfblog, ( select sum(flebsz * flenblks) totsize from x$kccfle where fledup != 0 ) |
| GV$FLASHBACK_DATABASE_LOGFILE | select fn.inst_id, fn.fnnam, fle.flelno, fle.flethr, fle.fleseq, fle.flenblks * fle.flebsz, to_number(fle.flelscn), to_date(fle.fleltim, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccfn fn, x$kccfle fle where (fn.fntyp = 24) and (fn.fnnum = fle.flefnh) and (fle.fledup != 0) |
| GV$FLASHBACK_DATABASE_STAT | select inst_id, to_date(btime, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(etime, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), fbw*512, dbw*512, redow*512, to_number(fbsz) from x$krfgstat |
| GV$GCSHVMASTER_INFO | select inst_id, KJDRPCMHVID, KJDRPCMHVCMAS, KJDRPCMHVPMAS, KJDRPCMHVRMCNT from x$kjdrpcmhv |
| GV$GCSPFMASTER_INFO | select inst_id, KJDRPCMPFID, KJDRPCMPOID, KJDRPCMPFCMAS, KJDRPCMPFPMAS, KJDRPCMPFRMCNT from x$kjdrpcmpf |
| GV$GC_ELEMENT | select inst_id, le_addr, indx, le_class, name, le_mode, le_blks, le_rls, le_acq, le_write, le_recovery, le_local, le_flags from x$le |
| GV$GC_ELEMENTS_WITH_COLLISIONS | select USERENV(‘Instance’), lock_element_addr from v$bh where (forced_writes + forced_reads) > 10 group by lock_element_addr having count(*) >= 2 |
| GV$GES_BLOCKING_ENQUEUE | select USERENV(‘Instance’), HANDLE, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, STATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from V$GES_ENQUEUE where (REQUEST_LEVEL != ‘KJUSERNL’) and (BLOCKED = 1 or BLOCKER = 1) |
| GV$GES_ENQUEUE | select inst_id, kjilkftlkp, kjilkftgl, kjilkftrl, kjilkftrn1, kjilkftrn2, kjilkftpid, kjilkftxid0, kjilkftxid1, kjilkftgid, kjilkftoodd, kjilkftoopt, kjilkftoopo, kjilkftoonxid, kjilkftcogv, kjilkftcopv, kjilkftconv, kjilkftcodv, kjilkftconq, kjilkftcoep, kjilkftconddw, kjilkftconddb, kjilkftwq, kjilkftls, kjilkftaste0, kjilkfton, kjilkftblked, kjilkftblker from x$kjilkft union all select inst_id, kjbllockp, kjblgrant, kjblrequest, kjblname, kjblname2, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, kjblqueue, kjbllockst, 0, kjblowner, kjblblocked, kjblblocker from x$kjbl |
| GV$GLOBALCONTEXT | select namespace, attribute, value, username,clientidentifier from x$globalcontext where upper(namespace) not like ‘SYS_%’ |
| GV$GLOBAL_BLOCKED_LOCKS | select USERENV(‘instance’), addr, kaddr, sid, type, id1, id2, lmode,request,ctime from v$lock l where exists (select * from v$dlm_locks d where substr(d.resource_name2,1,instr(d.resource_name2, ‘,’,1,1)-1) = id1 and substr(d.resource_name2,instr(d.resource_name2,’,',1,1)+1, instr(d.resource_name2 , ‘,’,1,2)-instr(d.resource_name2, ‘,’,1,1)-1) = id2 and substr(d.resource_name2,instr(d.resource_name2, ‘,’,-1,1)+1,2) = type) |
| GV$GLOBAL_TRANSACTION | select inst_id, K2GTIFMT, K2GTITID_EXT, K2GTIBID, K2GTECNT, K2GTERCT, K2GTDPCT, decode (K2GTDFLG, 0, ‘ACTIVE’, 1, ‘COLLECTING’, 2, ‘FINALIZED’, 4, ‘FAILED’, 8, ‘RECOVERING’, 16, ‘UNASSOCIATED’, 32, ‘FORGOTTEN’, 64, ‘READY FOR RECOVERY’, ‘COMBINATION’), K2GTDFLG, decode (K2GTETYP, 0, ‘FREE’, 1, ‘LOOSELY COUPLED’, 2, ‘TIGHTLY COUPLED’) from X$K2GTE2 |
| GV$HS_AGENT | select unique INST_ID, AGENT_ID, MACHINE, PROCESS, PROGRAM, OSUSER, AGT_STARTTIME, AGENT_TYPE, decode( AGENT_TYPE, 1, to_number(NULL), FDS_CLASS_ID), decode( AGENT_TYPE, 1, to_number(NULL), FDS_INST_ID) from X$HS_SESSION |
| GV$HS_PARAMETER | select A.INST_ID, HS_SESSION_ID, PARAMETER, VALUE, SOURCE, ENV from X$HS_SESSION A, X$HOFP B where A.FDS_INST_ID = B.FDS_INST_ID |
| GV$HS_SESSION | select INST_ID, HS_SESSION_ID, AGENT_ID, SID, decode( AGENT_TYPE, 1, NULL, DB_LINK), decode( AGENT_TYPE, 1, to_number(NULL), DB_LINK_OWNER), SES_STARTTIME from X$HS_SESSION |
| GV$HVMASTER_INFO | select inst_id, KJDRHVID, KJDRHVCMAS, KJDRHVPMAS, KJDRHVRMCNT from x$kjdrhv |
| GV$INDEXED_FIXED_COLUMN | select c.inst_id,kqftanam, kqfcoidx, kqfconam, kqfcoipo from x$kqfco c, x$kqfta t where t.indx = c.kqfcotab and kqfcoidx != 0 |
| GV$INSTANCE | select ks.inst_id,ksuxsins,ksuxssid,ksuxshst,ksuxsver,ksuxstim,decode(ksuxssts,0,’STARTED’,1,’MOUNTED’,2,’OPEN’,3,’OPEN MIGRATE’,'UNKNOWN’),decode(ksuxsshr,0,’NO’,1,’YES’,2,NULL),ksuxsthr,decode(ksuxsarc,0,’STOPPED’,1,’STARTED’,'FAILED’),decode(ksuxslsw,0,NULL,2,’ARCHIVE LOG’,3,’CLEAR LOG’,4,’CHECKPOINT’, 5,’REDO GENERATION’),decode(ksuxsdba,0,’ALLOWED’,'RESTRICTED’),decode(ksuxsshp,0,’NO’,'YES’),decode(kvitval,0,’ACTIVE’,2147483647,’SUSPENDED’,'INSTANCE RECOVERY’),decode(ksuxsrol,1,’PRIMARY_INSTANCE’,2,’SECONDARY_INSTANCE’,'UNKNOWN’), decode(qui_state,0,’NORMAL’,1,’QUIESCING’,2,’QUIESCED’,'UNKNOWN’), decode(bitand(ksuxsdst, 1), 0, ‘NO’, 1, ‘YES’, ‘NO’) from x$ksuxsinst ks, x$kvit kv, x$quiesce qu where kvittag = ‘kcbwst’ |
| GV$INSTANCE_CACHE_TRANSFER | select inst_id, instance, decode(class,1,’data block’,2,’sort block’,3,’save undo block’, 4,’segment header’,5,’save undo header’,6,’free list’,7,’extent map’, 8,’1st level bmb’,9,’2nd level bmb’,10,’3rd level bmb’, 11,’bitmap block’,12,’bitmap index block’,13,’file header block’,14,’unused’, 15,’undo header’,16,’undo block’), cr_block, cr_busy, cr_congested, current_block, current_busy, current_congested from x$instance_cache_transfer |
| GV$INSTANCE_LOG_GROUP | select USERENV(‘Instance’), THREAD# , STATUS , ENABLED , GROUPS , INSTANCE , OPEN_TIME , CURRENT_GROUP# , SEQUENCE# , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ENABLE_CHANGE# , ENABLE_TIME , DISABLE_CHANGE# , DISABLE_TIME from V$THREAD |
| GV$INSTANCE_RECOVERY | select T.INST_ID, to_number(decode(CUR_EST_RCV_READS, -1, NULL, CUR_EST_RCV_READS)), to_number(decode(ACTUAL_REDO_BLKS, -1, NULL, ACTUAL_REDO_BLKS)), to_number(decode(MIN_LAG, 0, NULL, MIN_LAG)), to_number(decode(LOGFILESZ, 0, NULL, LOGFILESZ)), to_number(decode(CT_LAG, 0, NULL, CT_LAG)), to_number(decode(CI_LAG, 0, NULL, CI_LAG)), to_number(decode(ACTUAL_REDO_BLKS, 0, NULL, NULL)), INUSE_EST_MTTR_SEC, CUR_EST_MTTR_SEC, (select ksusgstv – (select ksusgstv from X$KSUSGSTA where ksusdnam=’physical writes non checkpoint’ and inst_id=t.inst_id) from X$KSUSGSTA where ksusdnam = ‘physical writes’ and inst_id=t.inst_id), (select logfile_size from x$kctlax where indx=0 and inst_id=t.inst_id), to_number(decode(CUR_EST_MTTCA_SEC, -1, NULL, CUR_EST_MTTCA_SEC)), MTTR_WRITES, LOGFILE_SIZE_WRITES, CKPT_SETTING_WRITES, OTHER_WRITES, AUTO_WRITES, FULL_WRITES from X$TARGETRBA T, X$ESTIMATED_MTTR E, X$KCTICW W where T.INST_ID=E.INST_ID AND T.INST_ID=W.INST_ID |
| GV$JAVAPOOL | select inst_id, ksmchcom, sum(ksmchsiz) from x$ksmjch group by inst_id, ksmchcom order by ksmchcom |
| GV$JAVA_LIBRARY_CACHE_MEMORY | select inst_id, decode(kgljsim_namespace, 0,’SQL AREA’, 1,’TABLE/PROCEDURE’, 2,’BODY’, 3,’TRIGGER’, 4,’INDEX’, 5,’CLUSTER’, 6,’OBJECT’, 7,’PIPE’, 13,’JAVA SOURCE’, 14,’JAVA RESOURCE’, 32,’JAVA DATA’, ‘?’), kgljsim_pincnt, kgljsim_pinmem, kgljsim_unpincnt, kgljsim_unpinmem from x$kgljmem where kgljsim_namespace<8 or kgljsim_namespace=13 or kgljsim_namespace=14 or kgljsim_namespace=32 union select inst_id, ‘OTHER/SYSTEM’, sum(kgljsim_pincnt) sum_pincnt, sum(kgljsim_pinmem) sum_pinmem, sum(kgljsim_unpincnt) sum_unpincnt, sum(kgljsim_unpinmem) sum_unpinmem from x$kgljmem where not (kgljsim_namespace<8 or kgljsim_namespace=13 or kgljsim_namespace=14 or kgljsim_namespace=32) group by inst_id |
| GV$JAVA_POOL_ADVICE | select inst_id, java_size, round(java_size / basejava_size, 4), kgljsim_size, kgljsim_objs, kgljsim_timesave, decode(kgljsim_basetimesave, 0, to_number(null), round(kgljsim_timesave / kgljsim_basetimesave, 4)), kgljsim_parsetime, decode(kgljsim_baseparsetime, 0, to_number(null), round(kgljsim_parsetime / kgljsim_baseparsetime, 4)), kgljsim_hits from x$kgljsim |
| GV$LATCH | select d.inst_id,d.kslldadr,la.latch#,d.kslldlvl,d.kslldnam,d.kslldhsh, la.gets,la.misses, la.sleeps,la.immediate_gets,la.immediate_misses,la.waiters_woken, la.waits_holding_latch,la.spin_gets,la.sleep1,la.sleep2, la.sleep3,la.sleep4,la.sleep5,la.sleep6,la.sleep7,la.sleep8,la.sleep9, la.sleep10, la.sleep11, la.wait_time from x$kslld d, (select kslltnum latch#, sum(kslltwgt) gets,sum(kslltwff) misses,sum(kslltwsl) sleeps, sum(kslltngt) immediate_gets,sum(kslltnfa) immediate_misses, sum(kslltwkc) waiters_woken,sum(kslltwth) waits_holding_latch, sum(ksllthst0) spin_gets,sum(ksllthst1) sleep1,sum(ksllthst2) sleep2, sum(ksllthst3) sleep3,sum(ksllthst4) sleep4,sum(ksllthst5) sleep5, sum(ksllthst6) sleep6,sum(ksllthst7) sleep7,sum(ksllthst8) sleep8, sum(ksllthst9) sleep9,sum(ksllthst10) sleep10,sum(ksllthst11) sleep11, sum(kslltwtt) wait_time from x$ksllt group by kslltnum) la where la.latch# = d.indx |
| GV$LATCHHOLDER | select inst_id,ksuprpid,ksuprsid,ksuprlat,ksuprlnm,ksulagts from x$ksuprlat |
| GV$LATCHNAME | select inst_id,indx, kslldnam, kslldhsh from x$kslld |
| GV$LATCH_CHILDREN | select t.inst_id,t.addr,t.kslltnum,t.kslltcnm,n.kslldlvl, n.kslldnam,n.kslldhsh, t.kslltwgt,t.kslltwff,t.kslltwsl,t.kslltngt,t.kslltnfa, t.kslltwkc,t.kslltwth,t.ksllthst0,t.ksllthst1, t.ksllthst2,t.ksllthst3,t.ksllthst4,t.ksllthst5, t.ksllthst6,t.ksllthst7,t.ksllthst8, t.ksllthst9,t.ksllthst10, t.ksllthst11, t.kslltwtt from x$ksllt t, x$kslld n where t.kslltcnm > 0 and t.kslltnum = n.indx |
| GV$LATCH_MISSES | select t1.inst_id,t1.ksllasnam, t2.ksllwnam, t1.kslnowtf, t1.kslsleep, t1.kslwscwsl, t1.kslwsclthg, t2.ksllwnam from x$ksllw t2, x$kslwsc t1 where t2.indx = t1.indx |
| GV$LATCH_PARENT | select t.inst_id,t.addr,t.kslltnum,n.kslldlvl,n.kslldnam,n.kslldhsh, t.kslltwgt,t.kslltwff,t.kslltwsl,t.kslltngt,t.kslltnfa, t.kslltwkc,t.kslltwth,t.ksllthst0,t.ksllthst1, t.ksllthst2,t.ksllthst3,t.ksllthst4,t.ksllthst5, t.ksllthst6,t.ksllthst7,t.ksllthst8, t.ksllthst9,t.ksllthst10, t.ksllthst11, t.kslltwtt from x$ksllt t, x$kslld n where t.kslltcnm = 0 and t.kslltnum = n.indx |
| GV$LIBRARYCACHE | select inst_id, decode(indx,0,’SQL AREA’,1,’TABLE/PROCEDURE’,2,’BODY’,3,’TRIGGER’, 4,’INDEX’,5,’CLUSTER’,6,’OBJECT’,7,’PIPE’, 13,’JAVA SOURCE’,14,’JAVA RESOURCE’,32,’JAVA DATA’,'?’), kglstget,kglstght, decode(kglstget,0,1,kglstght/kglstget),kglstpin,kglstpht, decode(kglstpin,0,1,kglstpht/kglstpin),kglstrld,kglstinv, kglstlrq,kglstprq,kglstprl,kglstirq,kglstmiv from x$kglst where indx<8 or indx=13 or indx=14 or indx=32 |
| GV$LIBRARY_CACHE_MEMORY | select inst_id, decode(kglsim_namespace, 0,’SQL AREA’, 1,’TABLE/PROCEDURE’, 2,’BODY’, 3,’TRIGGER’, 4,’INDEX’, 5,’CLUSTER’, 6,’OBJECT’, 7,’PIPE’, 13,’JAVA SOURCE’, 14,’JAVA RESOURCE’, 32,’JAVA DATA’, ‘?’), kglsim_pincnt, kglsim_pinmem, kglsim_unpincnt, kglsim_unpinmem from x$kglmem where kglsim_namespace<8 or kglsim_namespace=13 or kglsim_namespace=14 or kglsim_namespace=32 union select inst_id, ‘OTHER/SYSTEM’, sum(kglsim_pincnt) sum_pincnt, sum(kglsim_pinmem) sum_pinmem, sum(kglsim_unpincnt) sum_unpincnt, sum(kglsim_unpinmem) sum_unpinmem from x$kglmem where not (kglsim_namespace<8 or kglsim_namespace=13 or kglsim_namespace=14 or kglsim_namespace=32) group by inst_id |
| GV$LICENSE | select inst_id,ksullms,ksullws,ksullcs,ksullhs,ksullmu,cpu_count, decode(cpu_core_count,0,to_number(null),cpu_core_count), decode(cpu_socket_count,0,to_number(null),cpu_socket_count), cpu_count_hwm, decode(cpu_core_count_hwm,0,to_number(null),cpu_core_count_hwm), decode(cpu_socket_count_hwm,0,to_number(null),cpu_socket_count_hwm) from x$ksull |
| GV$LOADISTAT | select inst_id,klcieon,klcietn,klciein,klcieisn,klciemno,klciemsg from x$klcie |
| GV$LOADPSTAT | select inst_id,klcpxon,klcpxtn,klcpxpn,klcpxrld from x$klpt |
| GV$LOCK | select s.inst_id, l.laddr, l.kaddr, s.ksusenum, r.ksqrsidt, r.ksqrsid1, r.ksqrsid2, l.lmode, l.request,l.ctime, decode(l.lmode, 0, 0, l.block) from v$_lock l,x$ksuse s,x$ksqrs r where l.saddr=s.addr and l.raddr=r.addr |
| GV$LOCKED_OBJECT | select x.inst_id,x.kxidusn, x.kxidslt, x.kxidsqn, l.ktadmtab, s.indx, s.ksuudlna, s.ksuseunm, s.ksusepid, l.ksqlkmod from x$ktcxb x, x$ktadm l, x$ksuse s where x.ktcxbxba = l.kssobown and x.ktcxbses = s.addr |
| GV$LOCKS_WITH_COLLISIONS | select USERENV(‘Instance’), lock_element_addr from v$bh where (forced_writes + forced_reads) > 10 group by lock_element_addr having count(*) >= 2 |
| GV$LOCK_ACTIVITY | select 0, ‘NULL’, ‘S’, ‘Lock buffers for read’, 0 from dual |
| GV$LOCK_ELEMENT | select inst_id, le_addr, indx, le_class, name, le_mode, le_blks, le_rls, le_acq, 0, le_flags from x$le |
| GV$LOCK_TYPE | select rest.inst_id, rest.resname, rest.name, rest.id1, rest.id2, decode(bitand(eqt.flags, 1), 1, ‘YES’, ‘NO’), rest.expl from X$KSIRESTYP rest, X$KSQEQTYP eqt where (rest.inst_id = eqt.inst_id) and (rest.indx = eqt.indx) and (rest.indx > 0) |
| GV$LOG | select le.inst_id, le.lenum, le.lethr, le.leseq, le.lesiz*le.lebsz, ledup, decode(bitand(le.leflg,1),0,’NO’,'YES’), decode(bitand(le.leflg,24), 8, ‘CURRENT’, 16,’CLEARING’, 24,’CLEARING_CURRENT’, decode(sign(leseq),0,’UNUSED’, decode(sign((to_number(rt.rtckp_scn)-to_number(le.lenxs))* bitand(rt.rtsta,2)),-1,’ACTIVE’,'INACTIVE’))), to_number(le.lelos), to_date(le.lelot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccle le, x$kccrt rt where le.ledup!=0 and le.lethr=rt.rtnum and le.inst_id = rt.inst_id |
| GV$LOGFILE | select inst_id,fnfno, decode(fnflg,0,”, decode(bitand(fnflg,1),1,’INVALID’, decode(bitand(fnflg,2),2,’STALE’, decode(bitand(fnflg,4),4,’DELETED’, decode(bitand(fnflg,8+32),8,”,32,”,40,”,’UNKNOWN’))))), decode(bitand(fnflg,8),0,’ONLINE’,'STANDBY’), fnnam, decode(bitand(fnflg, 32),0,’NO’,'YES’) from x$kccfn where fnnam is not null and fntyp=3 |
| GV$LOGHIST | select inst_id,lhthp,lhseq,to_number(lhlos), to_date(lhlot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(lhnxs) from x$kcclh |
| GV$LOGMNR_CALLBACK | select inst_id, session_id, function_id, description, decode(type, 0, ‘MISSING_LOGFILE’, 1, ‘ERROR’, 2, ‘OBJECT_FILTER’, 3, ‘CHGVEC_READ’, 4, ‘COMPLETE_LCR’, 5, ‘TXN_COMMIT’, 6, ‘PROCESS_STATE’, ‘UNKNOWN’) from x$logmnr_callback |
| GV$LOGMNR_CONTENTS | select INST_ID, SCN, CSCN, TIMESTAMP, COMMIT_TIMESTAMP,THREAD#, LOG_ID, XIDUSN, XIDSLT, XIDSQN, PXIDUSN, PXIDSLT, PXIDSQN, RBASQN, RBABLK, RBABYTE, UBAFIL, UBABLK, UBAREC, UBASQN, ABS_FILE#,REL_FILE#, DATA_BLK#, DATA_OBJ#, DATA_OBJD#, SEG_OWNER, SEG_NAME, TABLE_NAME, SEG_TYPE, SEG_TYPE_NAME, TABLE_SPACE, ROW_ID, SESSION#, SERIAL#, USERNAME, SESSION_INFO, TX_NAME, ROLLBACK, OPERATION,OPERATION_CODE, SQL_REDO, SQL_UNDO, RS_ID, SEQUENCE#, SSN, CSF, INFO, STATUS, REDO_VALUE, UNDO_VALUE, SQL_COLUMN_TYPE, SQL_COLUMN_NAME, REDO_LENGTH, REDO_OFFSET, UNDO_LENGTH, UNDO_OFFSET, DATA_OBJV#, SAFE_RESUME_SCN, XID, PXID, AUDIT_SESSIONID from x$logmnr_contents where ROW_TYPE = 0 |
| GV$LOGMNR_DICTIONARY | select INST_ID, DB_NAME, DB_ID, DB_CREATED, TIMESTAMP, RESET_SCN, RESET_SCN_TIME, DB_VERSION_TIME, DB_CHARACTER_SET, DB_VERSION, DB_STATUS, DICTIONARY_SCN, ENABLED_THREAD_MAP, DB_TXN_SCN, FILENAME, INFO, STATUS from x$logmnr_dictionary |
| GV$LOGMNR_DICTIONARY_LOAD | select inst_id, session_id, logmnr_uid, action#, opcode, command, current_state, completed_actions, total_actions, loaded, percent_done from x$logmnr_dictionary_load |
| GV$LOGMNR_LATCH | select inst_id, session_id, name, child_addr, decode(state, 0, ‘UNINIT’, 1, ‘READY’) state from x$logmnr_latch |
| GV$LOGMNR_LOGFILE | select inst_id, log_id, filename, low_time, next_time, db_id, db_name, reset_scnwrp, reset_scnbas, reset_scn_time, thread_id, thread_sqn, low_scnwrp, low_scnbas, next_scnwrp, next_scnbas, decode(state, 0, ‘FILE_NOT_OPEN’, 1, ‘FILE_OPEN’, 2, ‘DONE’) from x$logmnr_logfile |
| GV$LOGMNR_LOGS | select INST_ID, LOG_ID, FILENAME, LOW_TIME, HIGH_TIME, DB_ID, DB_NAME, RESET_SCN, RESET_SCN_TIME, THREAD_ID, THREAD_SQN, LOW_SCN, NEXT_SCN, DICTIONARY_BEGIN, DICTIONARY_END, TYPE, BLOCKSIZE, FILESIZE, INFO, STATUS from x$logmnr_logs |
| GV$LOGMNR_PARAMETERS | select INST_ID, START_DATE, REQUIRED_START_DATE, END_DATE, START_SCN, REQUIRED_START_SCN, END_SCN, OPTIONS, INFO, STATUS from x$logmnr_parameters |
| GV$LOGMNR_PROCESS | select a.inst_id, a.session_id, a.pid, a.role, a.work_microsec, a.overhead_microsec, b.spid, b.username, b.latchwait, b.latchspin, c.sid, c.serial# from x$logmnr_process a, v$process b, v$session c where a.pid = b.pid and b.spid = c.process |
| GV$LOGMNR_REGION | select inst_id, memstate, decode(state, 0, ‘INIT’, 1, ‘AVAIL’, 2, ‘ASSIGNED’, 3, ‘PREPARED’, 4, ‘ASSEMBLED’), owning_process from x$logmnr_region |
| GV$LOGMNR_SESSION | select INST_ID, session_id, session_name, decode(state, 1, ‘READY’, 2, ‘STARTED’, 3, ‘ACTIVE’, 4, ‘DISCARDED’, 5, ‘DETACHED’, ‘UNKNOWN’), db_name, db_id, reset_scn, reset_timestamp, num_process, chunk_size, start_scn, end_scn, spill_scn, processed_scn, prepared_scn, read_scn, low_mark_scn, consumed_scn, max_memory_size, used_memory_size, prepared_work_size, available_work_size, available_txn, available_committed_txn, delivered_txn, delivered_committed_txn, pinned_txn, pinned_committed_txn, checkpoint_interval from x$logmnr_session |
| GV$LOGMNR_STATS | select inst_id, session_id, name, value from x$krvxsv where flags = 0 |
| GV$LOGMNR_TRANSACTION | select inst_id, session_id, xid, xidusn, xidslt, xidsqn, parentxid, parent_xidusn, parent_xidslt, parent_xidsqn, starttimestamp, startscn, chunk, totalchunks, redothread, lowts, lowscn, committimestamp, commitscn, numchangerecord, numlcrspilled, dflag, mflag, mflag2, state, type, mining_status, queue from x$krvxtx |
| GV$LOGSTDBY | select inst_id,serial#,logstdby_id,pid,type,status_code,status,high_scn from x$krvslv where exists (select 1 from v$session s, x$knstacr x where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$LOGSTDBY_PROCESS | select inst_id, sid, serial#,logstdby_id,pid,type,status_code,status,high_scn from x$krvslv where exists (select 1 from v$session s, x$knstacr x where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$LOGSTDBY_PROGRESS | select inst_id,applied_scn,applied_time,restart_scn,restart_time,latest_scn, latest_time,mining_scn, mining_time from x$krvslvpg |
| GV$LOGSTDBY_STATE | select inst_id, primary_dbid,session_id,realtime_apply,state from x$krvslvst |
| GV$LOGSTDBY_STATS | select inst_id, name,value from (select inst_id, name,value from x$krvslvs where name != ‘LMNR_SID’ union all select inst_id, name,to_char(value) from ( select inst_id, session_id, name, value from x$krvxsv where flags = 0)where session_id = (select value from x$krvslvs where name = ‘LMNR_SID’)) where exists (select 1 from v$session s, x$knstacr x where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$LOGSTDBY_TRANSACTION | select lt.inst_id, lt.xid, lt.startscn, lt.starttimestamp, lt.parentxid, lt.mining_status, case when sas.sid is null then ‘NONE’ else ‘ACTIVE’ end, sas.sid, sas.serial# from x$krvslvs ls, x$krvxtx lt, v$streams_apply_server sas where (ls.name = ‘LMNR_SID’ and ls.value = lt.session_id) and (lt.chunk = 0 and (lt.xidusn != 0 and lt.xidslt != 0 and lt.xidsqn != 0)) and (lt.xidusn = sas.xidusn(+) and lt.xidslt = sas.xidslt(+) and lt.xidsqn = sas.xidsqn(+)) |
| GV$LOG_HISTORY | select x$kcclh.inst_id,lhrid,lhstm,lhthp,lhseq,to_number(lhlos),to_date(lhlot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(lhnxs), to_number(lhrls), to_date(lhrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kcclh |
| GV$MANAGED_STANDBY | select inst_id, decode(MSTYP, 1,’RFS’, 2,’MRP0′, 3,’MR(fg)’, 4,’ARCH’, 5,’FGRD’, 6,’LGWR’, 7,’RFS(FAL)’, 8,’RFS(NEXP)’, 9,’LNS’, ‘UNKNOWN’), to_number(MSPID), decode(MSSTS, 0,’UNUSED’, 1,’ALLOCATED’, 2,’CONNECTED’, 3,’ATTACHED’, 4,’IDLE’, 5,’ERROR’, 6,’OPENING’, 7,’CLOSING’, 8,’WRITING’, 9,’RECEIVING’, 10,’ANNOUNCING’, 11,’REGISTERING’, 12,’WAIT_FOR_LOG’, 13,’WAIT_FOR_GAP’, 14,’APPLYING_LOG’, ‘UNKNOWN’), decode(MSPAR, 0,’N/A’, 4,’ARCH’, 5,’Archival’, 6,’LGWR’, 9,’LNS’, ‘UNKNOWN’), decode(MSPPID, 0,’N/A’, to_number(MSPPID)), decode(MSDBID, 0,’N/A’, to_number(MSDBID)), decode(MSLNO, 0,’N/A’, to_number(MSLNO)), to_number(MSRLC), to_number(MSTHR), to_number(MSSEQ), to_number(MSBNO), to_number(MSBCT), to_number(MSDLY), to_number(MSRCLT), to_number(MSACLT) from x$kcrrms |
| GV$MAP_COMP_LIST | select inst_id,elem_idx,num_comp,comp1_name, comp1_val,comp2_name,comp2_val,comp3_name, comp3_val,comp4_name,comp4_val,comp5_name,comp5_val from x$ksfmcompl |
| GV$MAP_ELEMENT | select inst_id,elem_name,elem_idx,elem_cfgid, decode(elem_type,1,’MIRROR’,2,’STRIPE’,3,’RAID5′, 4,’CONCATENATED’,5,’PARTITION’,6,’DISK’,7,’NONE’), to_number(decode(elem_size,4294967295,NULL,elem_size)), elem_nsubelem,elem_descr,stripe_size, to_number(decode(lib_idx,4294967295,NULL,lib_idx)) from x$ksfmelem |
| GV$MAP_EXT_ELEMENT | select inst_id,elem_idx,num_attrb,attrb1_name, attrb1_val,attrb2_name,attrb2_val,attrb3_name, attrb3_val,attrb4_name,attrb4_val,attrb5_name,attrb5_val from x$ksfmextelem |
| GV$MAP_FILE | select inst_id,file_idx,file_cfgid,decode(file_status,1, ‘VALID’,2,’INVALID’ ),file_name,decode(file_type,1,’DATAFILE’, 2,’SPFILE’,3,’TEMPFILE’,4,’CONTROLFILE’,5,’LOGFILE’,6,’ARCHIVEFILE’), decode(file_struct,1,’FILE’,2,’RAWVOLUME’,3,’RAWDEVICE’,4,’NONE’), file_size,file_nexts,to_number(decode(lib_idx,4294967295,NULL,lib_idx)) from x$ksfmfile |
| GV$MAP_FILE_EXTENT | select inst_id,file_idx,ext_num,ext_dev_off, ext_size,ext_file_off,decode(ext_type,1,’DATA’, 2,’PARITY’,3,’NONE’),elem_idx from x$ksfmfileext where elem_idx != 4294967295 |
| GV$MAP_FILE_IO_STACK | select inst_id,file_idx,depth,elem_idx,cu_size,stride,num_cu, dev_offset,to_number(decode(file_offset,4294967295,NULL,file_offset)), decode(data_type,1,’DATA’,2,’PARITY’,3,’DATA AND PARITY’),parity_pos, parity_perd,row_id,prow_id from x$ksfmiost |
| GV$MAP_LIBRARY | select inst_id,lib_idx,lib_name,vendor_name,protocol_num, version_num,path_name,decode(bitand(cap_file,1),0,’N',1,’Y'), decode(bitand(cap_file, 6),0,’NONE’,6,’PERSISTENT’,2,’NONPERSISTENT’), decode(bitand(cap_elem, 1),0,’N',1,’Y'),decode(bitand(cap_elem,6),0,’NONE’, 6,’PERSISTENT’,4,’NONPERSISTENT’),decode(cap_other,0,’N',1,’Y') from x$ksfmlib |
| GV$MAP_SUBELEMENT | select inst_id,child_idx,parent_idx,sub_num, to_number(decode(sub_size,4294967295,NULL,sub_size)), to_number(decode(elem_offset,4294967295,NULL,elem_offset)),sub_flags from x$ksfmsubelem where child_idx != 4294967295 |
| GV$MAX_ACTIVE_SESS_TARGET_MTH | select inst_id, policy_name_kgskasp from x$kgskasp |
| GV$METRIC | SELECT inst_id, begtime, endtime, intsize_csec, groupid, eid, eidsq, metricid, name, value, unit from x$kewmdrmv where flag1 = 1 |
| GV$METRICGROUP | SELECT inst_id, groupid, name, intsize, maxintv from x$kewmgsm |
| GV$METRICNAME | SELECT d.inst_id, d.groupid, g.name, d.metricid, d.name, d.unit from x$kewmdsm d, x$kewmgsm g where d.groupid = g.groupid |
| GV$METRIC_HISTORY | SELECT inst_id, begtime, endtime, intsize_csec, groupid, eid, eidsq, metricid, name, value, unit from x$kewmdrmv |
| GV$MTTR_TARGET_ADVICE | select distinct inst_id, mttr_v, decode(status, 0, ‘OFF’, 4, ‘ON’, ‘READY’), decode(dirty_limit, 0, to_number(NULL), dirty_limit), decode(factored_sim_writes, -1, to_number(NULL), factored_sim_writes), decode(base_real_nondirect_writes, 0, to_number(NULL), decode(factored_sim_writes, -1, to_number(NULL), round((factored_sim_writes / base_real_nondirect_writes), 4))), decode(total_writes, -1, to_number(NULL), total_writes), decode(base_total_writes, 0, to_number(NULL), decode(total_writes, -1, to_number(NULL), round((total_writes / base_total_writes), 4))), decode(total_ios, -1, to_number(NULL), total_ios), decode(base_total_ios, 0, to_number(NULL), decode(total_ios, -1, to_number(NULL), round((total_ios / base_total_ios), 4))) from x$kcbmmav |
| GV$MUTEX_SLEEP | select INST_ID, MUTEX_TYPE, LOCATION, SLEEPS, WAIT_TIME from x$MUTEX_SLEEP |
| GV$MUTEX_SLEEP_HISTORY | select INST_ID, SLEEP_TIMESTAMP, MUTEX_TYPE, GETS, SLEEPS, REQUESTING_SESSION, BLOCKING_SESSION, LOCATION, MUTEX_VALUE, P1, P1RAW, P2, P3, P4, P5 from x$MUTEX_SLEEP_HISTORY |
| GV$MVREFRESH | select inst_id, sid_knst, serial_knst, currmvowner_knstmvr, currmvname_knstmvr from x$knstmvr x where type_knst=6 and exists (select 1 from v$session s where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$MYSTAT | select inst_id,ksusenum,ksusestn,ksusestv from x$ksumysta where bitand(ksspaflg,1)!=0 and bitand(ksuseflg,1)!=0 and ksusestn<(select ksusgstl from x$ksusgif) |
| GV$NLS_PARAMETERS | select inst_id,parameter, value from x$nls_parameters where parameter != ‘NLS_SPECIAL_CHARS’ |
| GV$NLS_VALID_VALUES | select inst_id,parameter, value, decode (isdeprecated, 0, ‘FALSE’, ‘TRUE’) from x$ksulv |
| GV$OBJECT_DEPENDENCY | select d.inst_id,d.kglhdpar, d.kglnahsh, o.kglnaown, o.kglnaobj, o.kglhdadr, o.kglnahsh, o.kglobtyp from x$kglob o, x$kgldp d where o.kglnahsh = d.kglrfhsh and o.kglhdadr = d.kglrfhdl |
| GV$OBSOLETE_PARAMETER | select inst_id,kspponm,decode(ksppoval,0,’FALSE’,'TRUE’) from x$ksppo |
| GV$OFFLINE_RANGE | select x$kccor.inst_id,orrid,orstm,ordfp,to_number(orofs),to_number(orons), to_date(oront,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(orrls), to_date(orrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccor |
| GV$OPEN_CURSOR | select inst_id,kgllkuse, kgllksnm, user_name, kglhdpar, kglnahsh, kgllksqlid, kglnaobj from x$kgllk where kglhdnsp = 0 and kglhdpar != kgllkhdl |
| GV$OPTION | select inst_id,parameter, value from x$option |
| GV$OSSTAT | select INST_ID,KSUCPUSTATNAME, decode(KSUCPUSTATID, 15, KSUCPUSTATVALUE/1024, KSUCPUSTATVALUE), KSUCPUSTATID from X$KSUCPUSTAT union all select INST_ID,KSUVMSTATNAME,KSUVMSTATVALUE,KSUVMSTATID from X$KSUVMSTAT |
| GV$PARALLEL_DEGREE_LIMIT_MTH | select inst_id, policy_name_kgskdopp from x$kgskdopp |
| GV$PARAMETER | select x.inst_id,x.indx+1,ksppinm,ksppity,ksppstvl, ksppstdvl, ksppstdf, decode(bitand(ksppiflg/256,1),1,’TRUE’,'FALSE’), decode(bitand(ksppiflg/65536,3),1,’IMMEDIATE’,2,’DEFERRED’, 3,’IMMEDIATE’,'FALSE’), decode(bitand(ksppiflg,4),4,’FALSE’, decode(bitand(ksppiflg/65536,3), 0, ‘FALSE’, ‘TRUE’)), decode(bitand(ksppstvf,7),1,’MODIFIED’,4,’SYSTEM_MOD’,'FALSE’), decode(bitand(ksppstvf,2),2,’TRUE’,'FALSE’), decode(bitand(ksppilrmflg/64, 1), 1, ‘TRUE’, ‘FALSE’), ksppdesc, ksppstcmnt, ksppihash from x$ksppi x, x$ksppcv y where (x.indx = y.indx) and ((translate(ksppinm,’_',’#') not like ‘##%’) and ((translate(ksppinm,’_',’#') not like ‘#%’) or (ksppstdf = ‘FALSE’) or (bitand(ksppstvf,5) > 0))) |
| GV$PARAMETER2 | select x.inst_id,kspftctxpn,ksppinm,ksppity,kspftctxvl, kspftctxdvl, kspftctxdf, decode(bitand(ksppiflg/256,1),1,’TRUE’,'FALSE’), decode(bitand(ksppiflg/65536,3),1,’IMMEDIATE’,2,’DEFERRED’, 3,’IMMEDIATE’,'FALSE’), decode(bitand(ksppiflg,4),4,’FALSE’, decode(bitand(ksppiflg/65536,3), 0, ‘FALSE’, ‘TRUE’)), decode(bitand(kspftctxvf,7),1,’MODIFIED’,4,’SYSTEM_MOD’,'FALSE’), decode(bitand(kspftctxvf,2),2,’TRUE’,'FALSE’), decode(bitand(ksppilrmflg/64, 1), 1, ‘TRUE’, ‘FALSE’), ksppdesc, kspftctxvn, kspftctxct from x$ksppi x, x$ksppcv2 y where ((x.indx+1) = kspftctxpn) and ((translate(ksppinm,’_',’#') not like ‘##%’) and ((translate(ksppinm,’_',’#') not like ‘#%’) or (kspftctxdf = ‘FALSE’) or (bitand(kspftctxvf,5) > 0))) |
| GV$PARAMETER_VALID_VALUES | SELECT INST_ID, PARNO_KSPVLD_VALUES, NAME_KSPVLD_VALUES, ORDINAL_KSPVLD_VALUES, VALUE_KSPVLD_VALUES, ISDEFAULT_KSPVLD_VALUES from X$KSPVLD_VALUES where TRANSLATE(NAME_KSPVLD_VALUES,’_',’#') NOT LIKE ‘#%’ |
| GV$PGASTAT | select INST_ID, QESMMSGANM, decode( QESMMSGAUN, 3, (QESMMSGAVL*QESMMSGAMU)/100, QESMMSGAVL*QESMMSGAMU), decode( QESMMSGAUN, 0, ‘bytes’, 1, ‘microseconds’, 3, ‘percent’, ”) from X$QESMMSGA where QESMMSGAVS = 1 |
| GV$PGA_TARGET_ADVICE | select INST_ID, PAT_PRED * 1024, round(PAT_PRED/PAT_CURR, 4), decode(status, 0, ‘OFF’, ‘ON’), BYTES_PROCESSED * 1024, EXTRA_BYTES_RW * 1024, round(decode(BYTES_PROCESSED+EXTRA_BYTES_RW, 0, 0, (BYTES_PROCESSED*100)/(BYTES_PROCESSED+EXTRA_BYTES_RW))), OVERALLOC from X$QESMMAPADV |
| GV$PGA_TARGET_ADVICE_HISTOGRAM | select INST_ID, PAT_PRED * 1024, round(PAT_PRED/PAT_CURR, 4), decode(status, 0, ‘OFF’, ‘ON’), LOWBND * 1024, (HIBND * 1024)-1, OPTIMAL, ONEPASS, MPASS, MPASS+ONEPASS+OPTIMAL, IGNORED from X$QESMMAHIST |
| GV$PQ_SESSTAT | select inst_id, kxfpssnam, kxfpssval, kxfpsstot from x$kxfpsst |
| GV$PQ_SLAVE | select inst_id,kxfpdpnam, decode(bitand(kxfpdpflg, 16), 0, ‘BUSY’, ‘IDLE’), kxfpdpses, floor(kxfpdpcit / 6000), floor(kxfpdpcbt / 6000), floor(kxfpdpcct / 100), kxfpdpclsnt + kxfpdpcrsnt, kxfpdpclrcv + kxfpdpcrrcv, floor((kxfpdptit + kxfpdpcit) / 6000), floor((kxfpdptbt + kxfpdpcbt) / 6000), floor((kxfpdptct + kxfpdpcct) / 100), kxfpdptlsnt + kxfpdpclsnt + kxfpdptrsnt + kxfpdpcrsnt, kxfpdptlrcv + kxfpdpclrcv + kxfpdptrrcv + kxfpdpcrrcv from x$kxfpdp where bitand(kxfpdpflg, 8) != 0 |
| GV$PQ_SYSSTAT | select inst_id, rpad(kxfpysnam,30), kxfpysval from x$kxfpys |
| GV$PQ_TQSTAT | select inst_id, kxfqsqn, kxfqsid, rpad(kxfqsty,10), kxfqscnt, kxfqslen, kxfqset, kxfqsavl, kxfqsdw, kxfqsdt, rpad(kxfqssid,10), kxfqsiid from x$kxfqsrow |
| GV$PROCESS | select inst_id, addr,indx,ksuprpid,ksuprunm,ksuprser,ksuprtid,ksuprpnm, ksuprtfi, decode(bitand(ksuprflg,2),0,null,1), decode(ksllawat,hextoraw(’00′),null,ksllawat), decode(ksllaspn,hextoraw(’00′),null,ksllaspn), ksuprpum,ksuprpnam+ksuprpram,ksuprpfm, case when ksuprpnam+ksuprpram > ksuprpmm then ksuprpnam+ksuprpram else ksuprpmm end from x$ksupr where bitand(ksspaflg,1)!=0 |
| GV$PROCESS_MEMORY | select inst_id, ksmpgst_pid, ksmpgst_ser, ksmpgst_catname, ksmpgst_alloc, decode(ksmpgst_used, 0, to_number(null), 1, 0, ksmpgst_used), decode(ksmpgst_maxal, 0, to_number(null), 1, 0, ksmpgst_maxal) from x$ksmpgst where bitand(ksmpgst_paflg,1)!=0 and (ksmpgst_alloc > 0 or ksmpgst_used > 1 or ksmpgst_maxal > 1) order by inst_id, ksmpgst_pid, ksmpgst_catidx |
| GV$PROCESS_MEMORY_DETAIL | select inst_id, ksmpgdst_pid, ksmpgdst_ser, ksmpgdst_catname, ksmpgdst_comment, ksmpgdst_heapname, ksmpgdst_bytes_alloc, ksmpgdst_num_alloc, ksmpgdst_ds, ksmpgdst_parent_ds from x$ksmpgdst where bitand(ksmpgdst_paflg,1)!=0 and (ksmpgdst_bytes_alloc > 0) order by inst_id, ksmpgdst_pid, ksmpgdst_bytes_alloc |
| GV$PROCESS_MEMORY_DETAIL_PROG | select inst_id, ksmpgdp_pid, ksmpgdp_ser, ksmpgdp_status from x$ksmpgdp where bitand(ksmpgdp_paflg,1)!=0 order by inst_id, ksmpgdp_pid |
| GV$PROPAGATION_RECEIVER | select inst_id, kwqpdsqs, kwqpdsqn, kwqpddbn, decode(bitand(max(kwqpdflg), 1), 1, max(kwqpddqs), null), decode(bitand(max(kwqpdflg), 1), 1, max(kwqpddqn), null), min(kwqpdtim), max(kwqpdhwm), min(kwqpdack), max(kwqpdmsg), min(kwqpdupc), min(kwqpdrul), min(kwqpdenq) – min(kwqpdupc) – min(kwqpdrul) from x$kwqpd group by inst_id, kwqpdsqs, kwqpdsqn, kwqpddbn |
| GV$PROPAGATION_SENDER | select s.inst_id, s.kwqpsqid, q.queue_schema, q.queue_name, s.kwqpsdqs, s.kwqpsdqn, s.kwqpstim, s.kwqpsdbn, s.kwqpshwm, s.kwqpsack, s.kwqpsstt, s.kwqpsmsg, s.kwqpsbyt, s.kwqpsdeq, s.kwqpspic, s.kwqpsprp – s.kwqpsdeq – s.kwqpspic, s.kwqpsmmsg, s.kwqpsmbyt from x$kwqps s, x$buffered_queues q where s.inst_id = q.inst_id and s.kwqpsqid = q.queue_id and bitand(q.flags, 16) = 0 |
| GV$PROXY_ARCHIVEDLOG | select inst_id,pcrid,pcstm,pcdev,pchdl,pccmt,pcmdh,pcmpl,pctag,decode(bitand(pcflg, 1+2+4),0,’A',1,’D',2,’X',4,’U',’?'),decode(bitand(pcflg,1),1,’YES’,'NO’),pathp,paseq,to_number(parls),to_date(parlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(palos),to_date(palot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(panxs),to_date(panxt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),pabct,pabsz,to_date(pctsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_date(pctim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),abs((to_date(pctim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)- to_date(pctsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’))*86400), pcrsi, pcrst from x$kccpa |
| GV$PROXY_DATAFILE | select inst_id,pcrid,pcstm,pcdev,pchdl,pccmt,pcmdh,pcmpl,pctag,decode(bitand(pcflg, 1+2+4),0,’A',1,’D',2,’X',4,’U',’?'),decode(bitand(pcflg,1),1,’YES’,'NO’),pddfp,to_number(pdcrs),to_date(pdcrt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(pdrls),to_date(pdrlc,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(pdcps),to_date(pdcpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_number(pdafs),to_number(pdrfs),to_date(pdrft,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(pdflg, 1),1,0,NULL),decode(bitand(pdflg, 2),0,’NO’,'YES’),decode(bitand(pdflg, 4),0,’NO’,'YES’),pdfsz,pdbsz,pdlor,to_date(pctsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),to_date(pctim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),abs((to_date(pctim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)- to_date(pctsm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’))*86400), decode(pddfp, 0, decode(bitand(pcflg,8),8,’S',’B'), NULL), decode(bitand(pdflg, 1792), 0, ‘NO’, ‘YES’), to_date(pdkpt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’),decode(bitand(pdflg, 1792), 256, ‘LOGS’, 512, ‘NOLOGS’, 1024, ‘CONSISTENT’, NULL), pcrsi, pcrst from x$kccpd |
| GV$PWFILE_USERS | select inst_id,username,decode(sysdba,1,’TRUE’,'FALSE’), decode(sysoper,1,’TRUE’,'FALSE’) from x$kzsrt where valid=1 and username != ‘INTERNAL’ |
| GV$PX_BUFFER_ADVICE | select inst_id, rpad(kxfpnsnam,30), kxfpnsval from x$kxfpns where indx = 4 or indx >= 14 |
| GV$PX_PROCESS | select a.inst_id, a.kxfpdpnam, decode(bitand(a.kxfpdpflg, 16), 0, ‘IN USE’, ‘AVAILABLE’), b.pid, a.kxfpdpspid, c.sid, c.serial# from x$kxfpdp a, V$PROCESS b, V$SESSION c where bitand(kxfpdpflg, 8) != 0 and a.kxfpdpspid = b.SPID and a.kxfpdpspid = c.PROCESS(+) |
| GV$PX_PROCESS_SYSSTAT | select inst_id, rpad(kxfpnsnam,30), kxfpnsval from x$kxfpns where indx < 15 |
| GV$PX_SESSION | select a.inst_id, a.addr, a.indx, a.ksuseser, decode(b.kxfpdpqcsid,NULL,a.indx,b.kxfpdpqcsid), b.kxfpdpqcser, b.kxfpdpcin, b.kxfpdpsvgrp, b.kxfpdpsvset, b.kxfpdpsvnum, b.kxfpdpadg, b.kxfpdprdg from x$ksuse a, x$kxfpdp b where bitand(a.ksspaflg,1)!=0 and bitand(a.ksuseflg,1)!=0 and a.ksuseqcsid > 0 and a.ksusepro = b.kxfpdppro(+) |
| GV$PX_SESSTAT | select a.inst_id, a.addr, a.indx, a.ksuseser, decode(b.kxfpdpqcsid,NULL,a.indx,b.kxfpdpqcsid), b.kxfpdpqcser, b.kxfpdpcin, b.kxfpdpsvgrp, b.kxfpdpsvset, b.kxfpdpsvnum, b.kxfpdpadg, b.kxfpdprdg, c.ksusestn, c.ksusestv from x$ksuse a, x$kxfpdp b, x$ksusesta c where bitand(a.ksspaflg,1)!=0 and bitand(a.ksuseflg,1)!=0 and a.KSUSEQCSID > 0 and a.ksusepro = b.kxfpdppro(+) and a.indx = c.ksusenum and c.ksusestn < (select ksusgstl from x$ksusgif) |
| GV$QUEUE | select inst_id,kmcqspro,decode(indx,0,’COMMON’,'DISPATCHER’), kmcqsncq,kmcqswat,kmcqstnc from x$kmcqs where indx=0 or kmcqspro!=hextoraw(’00′) |
| GV$QUEUEING_MTH | select inst_id, policy_name_kgskquep from x$kgskquep |
| GV$RECOVERY_FILE_STATUS | select fn.inst_id, fn.fnfno, fn.fnnam, decode(nvl(mf.cps, 0), 0, ‘NOT RECOVERED’, 281474976710655, ‘CURRENT’, ‘IN RECOVERY’) from x$kcrmx mx, x$kccfn fn, x$kccfe fe, x$kcrmf mf where fn.fntyp = 4 and mf.fno(+) = fn.fnfno and ((bitand(mx.flg,2) != 0 and fe.fedup != 0) or mf.fno = fn.fnfno) and fe.fenum = fn.fnfno |
| GV$RECOVERY_LOG | select inst_id,lhthp,lhseq, to_date(lhlot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), nvl(lhnam, alnam) from x$kcclh, (select althp, alseq, alrls, alrlc, alnam /* filter out duplicate al */ from (select althp, alseq, alrls, alrlc, alnam, alstm, alrid, max(alstm) over /* get latest archivelog */ (partition by althp, alseq, alrls, alrlc) almstm, max(alrid) over /* filter out duplicate stamp */ (partition by althp, alseq, alrls, alrlc, alstm) almrid from x$kccal where bitand(alflg, 8) = 0 /* standby_dest = NO */ and bitand(alflg, 2) = 2 /* archived = YES */ and bitand(alflg, 1) = 0) /* deleted = NO */ where alrid = almrid and alstm = almstm) where lhthp = althp (+) and lhseq = alseq (+) and lhrls = alrls (+) and lhrlc = alrlc (+) and to_number(lhnxs) > (select min(to_number(fhscn)) from x$kcvfhmrr where hxerr = 0) and lhseq not in (select leseq from x$kccle where lethr = lhthp) and to_number(lhlos) < (select max(to_number(hxsts)) from x$kcvfhmrr where hxerr = 0) |
| GV$RECOVERY_PROGRESS | select inst_id, to_date(ksulostm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), ksulopna, ksulotde, ksulouni, ksulosfr, ksulotot, to_date(ksuloinft, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$ksulop where ksulopna like ‘% Recovery’ order by 1, 2 DESC, 5 ASC, 4 ASC |
| GV$RECOVERY_STATUS | select fx.inst_id, to_date(mx.ckptim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), mx.thr, mx.seq, mx.los, to_date(mx.tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), nvl(mx.nam, ‘NONE’), decode(bitand(mx.mrs, 256 + 128 + 64 + 8), 8, ‘RELEASE’, 64, ‘WRONG LOG’, 128, ‘MISSING NAME’, 256, ‘UNNEEDED NAME’, ‘NONE’), decode(nvl(fx.err, 3), 1, ‘NEED LOG’, 3, ‘END OF THREAD’, 4, ‘LOG REUSED’, ‘UNKNOWN’) from x$kcrmx mx, x$kcrfx fx where fx.thr(+) = mx.thr |
| GV$RECOVER_FILE | select inst_id,hxfil, decode(hxons, 0, ‘OFFLINE’, ‘ONLINE’),decode(hxons, 0, ‘OFFLINE’, ‘ONLINE’), decode(hxerr, 0,”,1,’FILE MISSING’, 2,’OFFLINE NORMAL’, 3,’NOT VERIFIED’, 4,’FILE NOT FOUND’,5,’CANNOT OPEN FILE’, 6,’CANNOT READ HEADER’, 7,’CORRUPT HEADER’,8,’WRONG FILE TYPE’, 9,’WRONG DATABASE’, 10,’WRONG FILE NUMBER’,11,’WRONG FILE CREATE’, 12,’WRONG FILE CREATE’, 16,’DELAYED OPEN’,'UNKNOWN ERROR’), to_number(fhscn), to_date(fhtim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kcvfhmrr |
| GV$REPLPROP | select inst_id, sid_knst, serial_knst, decode(type_knst, 3, ‘Replication Parallel Prop Slave’|| slavenum_knstrpp, 4, ‘Replication Parallel Prop Coordinator’), dblink_knstrpp, decode(state_knstrpp, 0, NULL, 1, ‘WAIT’, 2, ‘SLEEP’, 3, ‘PUSH’, 4, ‘PURGE’ , 5, ‘CREATE ERROR’, 6, ‘SCHEDULE TXN’), decode(type_knst, 4, NULL, xid_knstrpp), sequence_knstrpp from x$knstrpp x where type_knst in (3,4) and exists (select 1 from v$session s where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$REPLQUEUE | select inst_id, txns_enqueued_knstrqu, calls_enqueued_knstrqu, txns_purged_knstrqu, last_enqueue_time_knstrqu,last_purge_time_knstrqu from x$knstrqu |
| GV$REQDIST | select inst_id,kmmrdbuc,sum(kmmrdcnt) from x$kmmrd where kmmrdpro!=hextoraw(’00′) group by inst_id,kmmrdbuc |
| GV$RESERVED_WORDS | select inst_id, keyword, length, decode(mod(trunc(type/2),2),0,’N',1,’Y',’?') reserved, decode(mod(trunc(type/4),2),0,’N',1,’Y',’?') res_type, decode(mod(trunc(type/8),2),0,’N',1,’Y',’?') res_attr, decode(mod(trunc(type/16),2),0,’N',1,’Y',’?') res_semi, decode(mod(trunc(type/32),2),0,’N',1,’Y',’?') duplicate from x$kwddef |
| GV$RESOURCE | select inst_id,addr,ksqrsidt,ksqrsid1,ksqrsid2 from x$ksqrs where bitand(ksqrsflg,2)!=0 |
| GV$RESOURCE_LIMIT | select inst_id, ksurlmnm, ksurlmcv, ksurlmmv, LPAD(decode(bitand(ksurlmfg, 1), 0, to_char(ksurlmia), ‘UNLIMITED’),10), LPAD(decode(bitand(ksurlmfg, 2), 0, to_char(ksurlmlv), ‘UNLIMITED’),10) from x$ksurlmt |
| GV$RESTORE_POINT | select rsp.inst_id, to_number(rsp.rspscn), rsp.rspincarn, ‘YES’, rsp.rsplgsz, to_timestamp(rsp.rsptime, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), rsp.rspname from x$kccrsp rsp where bitand(rsp.rspflags, 2) != 0 union all select rsp.inst_id, to_number(rsp.nrsscn), rsp.nrsincarn, ‘NO’, 0, to_timestamp(rsp.nrstime, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), rsp.nrsname from x$kccnrs rsp where bitand(rsp.nrsflags, 2) != 0 |
| GV$RESUMABLE | select inst_id, ktrsfaddr, ktrsfsid, decode (bitand(ktrsfflg, 1), 0, ‘NO’, ‘YES’), decode (ktrsfsta, 0, ‘NORMAL’, 1, ‘SUSPENDED’, 2, ‘TIMEOUT’, 3, ‘ERROR’, 4, ‘ABORTED’, ”), ktrsftmo, ktrsfspt, ktrsfrst, ktrsfnam, ktrsferr, ktrsfep1, ktrsfep2, ktrsfep3, ktrsfep4, ktrsfep5, ktrsfems from x$ktrso |
| GV$RFS_THREAD | select INST_ID, THREAD#, RESETLOG_SCN, RESETLOG#, LAST_REDO_SEQ#, LAST_REDO_BLK#, LAST_REDO_TIME, LOW_GAP_SCN, LOW_GAP_TIME, LAST_PING_TIME from x$krfsthrd |
| GV$RMAN_CONFIGURATION | select INST_ID, RMRNO, RMNAM, RMVAL from X$KCCRM where RMNAM is not null |
| GV$RMAN_ENCRYPTION_ALGORITHMS | select inst_id, id, algname, algdesc, decode(isdefault, 0, ‘NO’, ‘YES’), decode(restore_only, 0, ‘NO’, ‘YES’) from x$krbza |
| GV$RMAN_OUTPUT | select userenv(‘Instance’),SID_KRBMROT, ROWNO_KRBMROT, MTS_KRBMROT, L0ID_KRBMROT,L0TS_KRBMROT,TXT_KRBMROT, ID_KRBMROT, STAMP_KRBMROT from x$krbmrot order by L0ID_KRBMROT, L0TS_KRBMROT, MTS_KRBMROT,ROWNO_KRBMROT |
| GV$RMAN_STATUS_CURRENT | select userenv(‘Instance’), SID_KRBMRST, ID_KRBMRST, STAMP_KRBMRST, decode(LEVEL_KRBMRST, 0, to_number(NULL), PID_KRBMRST), decode(LEVEL_KRBMRST, 0, to_number(NULL), PTS_KRBMRST), L0ID_KRBMRST, L0TS_KRBMRST, LEVEL_KRBMRST, decode(LEVEL_KRBMRST, 0, ‘SESSION’, 1, ‘COMMAND’, ‘RECURSIVE OPERATION’), CMDID_KRBMRST, UPPER(OPER_KRBMRST), decode(STATUS_KRBMRST, 1, ‘RUNNING’, 1+8, ‘RUNNING WITH WARNINGS’, 1+16, ‘RUNNING WITH ERRORS’, 1+8+16, ‘RUNNING WITH ERRORS’, 2, ‘COMPLETED’, 2+8, ‘COMPLETED WITH WARNINGS’, 2+16, ‘COMPLETED WITH ERRORS’, 2+8+16, ‘COMPLETED WITH ERRORS’, ‘FAILED’), 0, to_date(START_KRBMRST,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(END_KRBMRST,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$krbmrst |
| GV$ROLLSTAT | select inst_id,kturdusn,kturdlat,kturdext,kturdsiz,kturdwrt,kturdnax, kturdget,kturdwat,decode(kturdopt, -1,to_number(null),kturdopt), kturdhwm,kturdnsh,kturdnwp,kturdnex,kturdash,kturdaae, decode(bitand(kturdflg,127), 0,’ONLINE’, 2,’PENDING OFFLINE’, 3,’OFFLINE’, 4, ‘FULL’, ‘UNKNOWN’), kturdcex, kturdcbk from x$kturd where kturdsiz != 0 and bitand(kturdflg,127) != 3 |
| GV$ROWCACHE | select inst_id,kqrstcid,decode(kqrsttyp,1,’PARENT’,'SUBORDINATE’), decode(kqrsttyp,2,kqrstsno,null),kqrsttxt,kqrstcsz,kqrstusg,kqrstfcs, kqrstgrq,kqrstgmi,kqrstsrq,kqrstsmi,kqrstsco,kqrstmrq,kqrstmfl, kqrstilr,kqrstifr,kqrstisr from x$kqrst |
| GV$ROWCACHE_PARENT | select inst_id, indx, kqrfphsh, kqrfpadd, kqrfpcid, kqrfpcnm, decode(bitand(kqrfpflg, 1), 0, ‘Y’, ‘N’), kqrfpmod, kqrfpreq, kqrfptxn, kqrfpses, kqrfpirq, kqrfpirl, kqrfpity, kqrfpii1, kqrfpii2, kqrfpkey from x$kqrfp |
| GV$ROWCACHE_SUBORDINATE | select inst_id, indx, kqrfshsh, kqrfsadd, kqrfscid, kqrfssid, kqrfssnm, decode(bitand(kqrfsflg, 1), 0, ‘Y’, ‘N’), kqrfspar, kqrfskey from x$kqrfs |
| GV$RSRC_CONSUMER_GROUP | select inst_id, name_kgskcft, class_id_kgskcft, current_count_kgskcft, runnable_count_kgskcft, total_count_kgskcft, cpu_wait_kgskcft, cpu_waits_kgskcft, total_used_kgskcft, yields_kgskcft, num_queued_kgskcft, undo_consump_kgskcft, active_limit_hit_kgskcft, swch_in_kgskcft, swch_out_kgskcft, undo_limit_hit_kgskcft, call_aborted_kgskcft, actv_sess_killed_kgskcft, idle_sess_killed_kgskcft, idlblkr_sess_kld_kgskcft, queued_time_kgskcft, queue_timeouts_kgskcft from x$kgskcft |
| GV$RSRC_CONSUMER_GROUP_CPU_MTH | select inst_id, policy_name_kgskcp from x$kgskcp |
| GV$RSRC_CONS_GROUP_HISTORY | select inst_id, seq_kgskscs, consumer_group_id_kgskscs, name_kgskscs, requests_kgskscs, cpu_wait_time_kgskscs, cpu_waits_kgskscs, consumed_cpu_time_kgskscs, yields_kgskscs, active_sess_limit_hit_kgskscs, undo_limit_hit_kgskscs, session_switches_in_kgskscs, session_switches_out_kgskscs, sql_canceled_kgskscs, active_sess_killed_kgskscs, idle_sess_killed_kgskscs, idle_blkr_sess_killed_kgskscs, queued_time_kgskscs, queue_time_outs_kgskscs from x$kgskscs |
| GV$RSRC_PLAN | select inst_id, plan_id_kgskpft, name_kgskpft, is_top_plan_kgskpft from x$kgskpft |
| GV$RSRC_PLAN_CPU_MTH | select inst_id, policy_name_kgskpp from x$kgskpp |
| GV$RSRC_PLAN_HISTORY | select inst_id, plw.seq_kskplw, decode(plw.id_kskplw, 0, to_number(null), plw.id_kskplw), plw.name_kskplw, plw.start_tm_kskplw, plw.end_tm_kskplw, decode(plw.window_id_kskplw, 0, ‘FALSE’, ‘TRUE’), o.name, decode(plw.auto_switch_kskplw, 0, ‘FALSE’, ‘TRUE’) from x$kskplw plw, obj$ o where plw.window_id_kskplw = o.obj#(+) |
| GV$RSRC_SESSION_INFO | select inst_id, sid_kgskvft, decode(class_id_kgskvft, 0,NULL,class_id_kgskvft), decode(orig_class_id_kgskvft, 0,NULL,orig_class_id_kgskvft), orig_class_map_kgskvft, mapped_cg_name_kgskvft, state_kgskvft, decode(active_kgskvft, 1,’TRUE’, 0,’FALSE’, ”), idle_time_kgskvft, cur_cpu_wait_time_kgskvft, tot_cpu_wait_time_kgskvft, cur_cpu_waits_kgskvft, tot_cpu_waits_kgskvft, cur_cpu_time_kgskvft, tot_cpu_time_kgskvft, cur_active_time_kgskvft, tot_active_time_kgskvft, cur_queued_time_kgskvft, tot_queued_time_kgskvft, cur_yields_kgskvft, tot_yields_kgskvft, cur_undo_kgskvft, max_undo_kgskvft, call_aborted_kgskvft, queue_timeouts_kgskvft, est_exec_lmt_hit_kgskvft from x$kgskvft |
| GV$RULE | select INST_ID, RULE_SET_OBJECT_ID, EVALUATION_CONTEXT_OBJECT_ID, RULE_OWNER, RULE_NAME, RULE_CONDITION, TRUE_HITS, MAYBE_HITS, SQL_EVALUATIONS from x$rule |
| GV$RULE_SET | select INST_ID, OWNER, NAME, CPU_TIME, ELAPSED_TIME, FIRST_LOAD_TIME, LAST_LOAD_TIME, LAST_LOADING_TIME, SHARABLE_MEM, RELOADS, INVALIDATIONS, EVALUATIONS, FIRST_HIT_EVALUATIONS, SIMPLE_RULES_ONLY_EVALUATIONS, SQL_FREE_EVALUATIONS, SQL_EXECUTIONS, CONDITIONS_PROCESSED, TRUE_RULES, MAYBE_RULES, VARIABLE_VALUE_FUNCTION_CALLS, VARIABLE_METHOD_FUNCTION_CALLS, EVALUATION_FUNCTION_CALLS from x$rule_set |
| GV$RULE_SET_AGGREGATE_STATS | select inst_id, name, value from x$kwrsnv |
| GV$SCHEDULER_RUNNING_JOBS | select inst_id, session_id, session_serial_num, job_id, paddr, os_process_id, CAST (numtodsinterval(session_stat_cpu/100, ‘second’) AS INTERVAL DAY(3) TO SECOND(2)) session_stat_cpu from x$jskslv |
| GV$SEGMENT_STATISTICS | select s.inst_id, u.name, o.name, o.subname, ts.name, s.fts_tsn, o.obj#, o.dataobj#, decode(o.type#, 0, ‘NEXT OBJECT’, 1, ‘INDEX’, 2, ‘TABLE’, 3, ‘CLUSTER’, 4, ‘VIEW’, 5, ‘SYNONYM’, 6, ‘SEQUENCE’, 7, ‘PROCEDURE’, 8, ‘FUNCTION’, 9, ‘PACKAGE’, 11, ‘PACKAGE BODY’, 12, ‘TRIGGER’, 13, ‘TYPE’, 14, ‘TYPE BODY’, 19, ‘TABLE PARTITION’, 20, ‘INDEX PARTITION’, 21, ‘LOB’, 22, ‘LIBRARY’, 23, ‘DIRECTORY’, 24, ‘QUEUE’, 28, ‘JAVA SOURCE’, 29, ‘JAVA CLASS’, 30, ‘JAVA RESOURCE’, 32, ‘INDEXTYPE’, 33, ‘OPERATOR’, 34, ‘TABLE SUBPARTITION’, 35, ‘INDEX SUBPARTITION’, 40, ‘LOB PARTITION’, 41, ‘LOB SUBPARTITION’, 42, ‘MATERIALIZED VIEW’, 43, ‘DIMENSION’, 44, ‘CONTEXT’, 47, ‘RESOURCE PLAN’, 48, ‘CONSUMER GROUP’, 51, ‘SUBSCRIPTION’, 52, ‘LOCATION’, 55, ‘XML SCHEMA’, 56, ‘JAVA DATA’, 57, ‘SECURITY PROFILE’, ‘UNDEFINED’), s.fts_statnam, s.fts_statid, s.fts_staval from obj$ o, user$ u, x$ksolsfts s, ts$ ts where o.owner# = u.user# and s.fts_inte = 0 and s.fts_objn = o.obj# and s.fts_tsn = ts.ts# and s.fts_objd = o.dataobj# and o.linkname is null and (o.type# not in (1 /* INDEX – handled below */, 10 /* NON-EXISTENT */) or (o.type# = 1 and 1 = (select 1 from ind$ i where i.obj# = o.obj# and i.type# in (1, 2, 3, 4, 6, 7, 9)))) and o.name != ‘_NEXT_OBJECT’ and o.name != ‘_default_auditing_options_’ union all select s.inst_id, u.name, o.name, o.subname, ts.name, s.fts_tsn, t.ktssoobjn, t.ktssoobjd, decode(o.type#, 0, ‘NEXT OBJECT’, 1, ‘INDEX’, 2, ‘TABLE’, 3, ‘CLUSTER’, 4, ‘VIEW’, 5, ‘SYNONYM’, 6, ‘SEQUENCE’, 7, ‘PROCEDURE’, 8, ‘FUNCTION’, 9, ‘PACKAGE’, 11, ‘PACKAGE BODY’, 12, ‘TRIGGER’, 13, ‘TYPE’, 14, ‘TYPE BODY’, 19, ‘TABLE PARTITION’, 20, ‘INDEX PARTITION’, 21, ‘LOB’, 22, ‘LIBRARY’, 23, ‘DIRECTORY’, 24, ‘QUEUE’, 28, ‘JAVA SOURCE’, 29, ‘JAVA CLASS’, 30, ‘JAVA RESOURCE’, 32, ‘INDEXTYPE’, 33, ‘OPERATOR’, 34, ‘TABLE SUBPARTITION’, 35, ‘INDEX SUBPARTITION’, 40, ‘LOB PARTITION’, 41, ‘LOB SUBPARTITION’, 42, ‘MATERIALIZED VIEW’, 43, ‘DIMENSION’, 44, ‘CONTEXT’, 47, ‘RESOURCE PLAN’, 48, ‘CONSUMER GROUP’, 51, ‘SUBSCRIPTION’, 52, ‘LOCATION’, 55, ‘XML SCHEMA’, 56, ‘JAVA DATA’, 57, ‘SECURITY PROFILE’, ‘UNDEFINED’), s.fts_statnam, s.fts_statid, s.fts_staval from obj$ o, user$ u, x$ksolsfts s, x$ktsso t, ts$ ts where o.owner# = u.user# and s.fts_inte = 0 and s.fts_objn = o.obj# and s.fts_tsn = t.ktssotsnum and s.fts_objn = t.ktssoobjn and s.fts_objd = t.ktssoobjd and s.fts_tsn = ts.ts# and t.ktssotsn = ts.name and o.linkname is null and (o.type# not in (1 /* INDEX – handled below */, 10 /* NON-EXISTENT */) or (o.type# = 1 and 1 = (select 1 from ind$ i where i.obj# = o.obj# and i.type# in (1, 2, 3, 4, 6, 7, 9)))) and o.name != ‘_NEXT_OBJECT’ and o.name != ‘_default_auditing_options_’ |
| GV$SEGSTAT | select inst_id, fts_tsn, fts_objn, fts_objd, fts_statnam, fts_statid, fts_staval from x$ksolsfts where fts_inte = 0 |
| GV$SEGSTAT_NAME | select inst_id, st_statid, st_name, decode(bitand(st_flag, 1), 0, ‘NO’, 1, ‘YES’) from x$ksolsstat where bitand(st_flag, 2) <> 2 |
| GV$SERVICEMETRIC | SELECT sm.inst_id, begtime, endtime, intsize_csec, groupid, sv.kswsastabnmh, sv.kswsastabnm, ctmhash, elapsedpercall, cpupercall, dbtimepercall, callspersec, dbtimepersec, goodness, delta, flags from x$kewmsvcmv sm, x$kswsastab sv where flag1 = 1 AND sm.svcid = sv.kswsastabsi |
| GV$SERVICEMETRIC_HISTORY | SELECT sm.inst_id, begtime, endtime, intsize_csec, groupid, sv.kswsastabnmh, sv.kswsastabnm, ctmhash, elapsedpercall, cpupercall, dbtimepercall, callspersec, dbtimepersec from x$kewmsvcmv sm, x$kswsastab sv where sm.svcid = sv.kswsastabsi |
| GV$SERVICES | select inst_id, kswsastabsi, kswsastabnm, kswsastabnmh, kswsastabnn, kswsastabcd, kswsastabcdh, decode(kswsastabgoal, -1, NULL, 0, ‘NONE’, 1, ‘SERVICE_TIME’, 2, ‘THROUGHPUT’, NULL) kswsastabgoal, decode(bitand(kswsastabpflg, 2), 2, ‘Y’, ‘N’) kswsastabpflg, decode(bitand(kswsastabpflg, 4), 4, ‘YES’, ‘NO’), decode(bitand(kswsastabpflg, 8), 8, ‘LONG’, ‘SHORT’) from x$kswsastab |
| GV$SERVICE_EVENT | select s.inst_id, s.kswsevtabnm, s.kswsevtabnmh, d.kslednam, d.ksledhash, s.kswsevtabwts, s.kswsevtabtmo, round(s.kswsevtabtim / 10000), round(s.kswsevtabtim / (10000 * s.kswsevtabwts)), round(s.kswsevtabmxt / 10000),s.kswsevtabtim from x$kswsevtab s, x$ksled d where s.kswsevtabwts != 0 and s.kswsevtabnum = d.indx |
| GV$SERVICE_STATS | select s.inst_id, s.svchsh, s.svcnam, m.extid, m.sname, s.kewsval from x$kewssvcv s, x$kewssmap m where s.kewsoff = m.offst and m.aggid = 3 |
| GV$SERVICE_WAIT_CLASS | select s.inst_id, s.kswsclstabnm, s.kswsclstabnmh, s.kswsclsid, s.kswsclsnum, s.kswsclsname, s.kswsclswts, round(s.kswsclstim / 10000) from x$kswsclstab s where s.kswsclswts != 0 |
| GV$SERV_MOD_ACT_STATS | select sma.inst_id, ‘SERVICE_MODULE_ACTION’, sma.srvnam, sma.modnam, sma.actnam, m.extid, m.sname, sma.statval from x$kewesmas sma, x$kewssmap m where sma.statpos = m.offst and m.aggid = 4 union all select sm.inst_id, ‘SERVICE_MODULE’, sm.srvnam, sm.modnam, NULL, m.extid, m.sname, sm.statval from x$kewesms sm, x$kewssmap m where sm.statpos = m.offst and m.aggid = 5 |
| GV$SESSION | select s.inst_id,s.addr,s.indx,s.ksuseser,s.ksuudses,s.ksusepro,s.ksuudlui,s.ksuudlna,s.ksuudoct,s.ksusesow, decode(s.ksusetrn,hextoraw(’00′),null,s.ksusetrn),decode(s.ksqpswat,hextoraw(’00′),null,s.ksqpswat),decode(bitand(s.ksuseidl,11),1,’ACTIVE’,0,decode(bitand(s.ksuseflg,4096),0,’INACTIVE’,'CACHED’),2,’SNIPED’,3,’SNIPED’, ‘KILLED’),decode(s.ksspatyp,1,’DEDICATED’,2,’SHARED’,3,’PSEUDO’,'NONE’), s.ksuudsid,s.ksuudsna,s.ksuseunm,s.ksusepid,s.ksusemnm,s.ksusetid,s.ksusepnm, decode(bitand(s.ksuseflg,19),17,’BACKGROUND’,1,’USER’,2,’RECURSIVE’,'?’), s.ksusesql, s.ksusesqh, s.ksusesqi, decode(s.ksusesch, 65535, to_number(null), s.ksusesch), s.ksusepsq, s.ksusepha, s.ksusepsi, decode(s.ksusepch, 65535, to_number(null), s.ksusepch), s.ksuseapp, s.ksuseaph, s.ksuseact, s.ksuseach, s.ksusecli, s.ksusefix, s.ksuseobj, s.ksusefil, s.ksuseblk, s.ksuseslt, s.ksuseltm, s.ksusectm,decode(bitand(s.ksusepxopt, 12),0,’NO’,'YES’),decode(s.ksuseft, 2,’SESSION’, 4,’SELECT’,8,’TRANSACTIONAL’,'NONE’),decode(s.ksusefm,1,’BASIC’,2,’PRECONNECT’,4,’PREPARSE’,'NONE’),decode(s.ksusefs, 1, ‘YES’, ‘NO’),s.ksusegrp,decode(bitand(s.ksusepxopt,4),4,’ENABLED’,decode(bitand(s.ksusepxopt,8),8,’FORCED’,'DISABLED’)),decode(bitand(s.ksusepxopt,2),2,’FORCED’,decode(bitand(s.ksusepxopt,1),1,’DISABLED’,'ENABLED’)),decode(bitand(s.ksusepxopt,32),32,’FORCED’,decode(bitand(s.ksusepxopt,16),16,’DISABLED’,'ENABLED’)), s.ksusecqd, s.ksuseclid, decode(s.ksuseblocker,4294967295,’UNKNOWN’, 4294967294, ‘UNKNOWN’,4294967293,’UNKNOWN’,4294967292,’NO HOLDER’, 4294967291,’NOT IN WAIT’,'VALID’),decode(s.ksuseblocker, 4294967295,to_number(null),4294967294,to_number(null), 4294967293,to_number(null), 4294967292,to_number(null),4294967291, to_number(null),bitand(s.ksuseblocker, 2147418112)/65536),decode(s.ksuseblocker, 4294967295,to_number(null),4294967294,to_number(null), 4294967293,to_number(null), 4294967292,to_number(null),4294967291, to_number(null),bitand(s.ksuseblocker, 65535)),s.ksuseseq, s.ksuseopc,e.kslednam, e.ksledp1, s.ksusep1,s.ksusep1r,e.ksledp2, s.ksusep2,s.ksusep2r,e.ksledp3,s.ksusep3,s.ksusep3r,e.ksledclassid, e.ksledclass#, e.ksledclass, decode(s.ksusetim,0,0,-1,-1,-2,-2, decode(round(s.ksusetim/10000),0,-1,round(s.ksusetim/10000))), s.ksusewtm,decode(s.ksusetim, 0, ‘WAITING’, -2, ‘WAITED UNKNOWN TIME’, -1, ‘WAITED SHORT TIME’, decode(round(s.ksusetim/10000),0,’WAITED SHORT TIME’,'WAITED KNOWN TIME’)),s.ksusesvc, decode(bitand(s.ksuseflg2,32),32,’ENABLED’,'DISABLED’),decode(bitand(s.ksuseflg2,64),64,’TRUE’,'FALSE’),decode(bitand(s.ksuseflg2,128),128,’TRUE’,'FALSE’)from x$ksuse s, x$ksled e where bitand(s.ksspaflg,1)!=0 and bitand(s.ksuseflg,1)!=0 and s.ksuseopc=e.indx |
| GV$SESSION_CONNECT_INFO | select inst_id, ksusenum, decode(ksuseaty, 0, ‘DATABASE’, 1, ‘OS’, 2, ‘NETWORK’, 3, ‘PROXY’, 4, ‘SERVER’, 5, ‘PASSWORD’, 6, ‘EXTERNAL ADAPTERS’, 7, ‘INTERNAL’, 8, ‘GLOBAL’, 9, ‘EXTERNAL’, 10, ‘PASSWORD BASED GLOBAL USER’, ‘?’), ksuseunm, ksuseban from x$ksusecon where bitand(ksuseflg,1)!=0 and bitand(ksuseflg,16)=0 |
| GV$SESSION_CURSOR_CACHE | select inst_id,kgiccmax,kgicccnt,kgiccopd,kgiccope,kgiccopn,kgicchit, decode(kgiccopn,0,1,kgicchit/kgiccopn) from x$kgicc |
| GV$SESSION_EVENT | select s.inst_id, s.kslessid, d.kslednam, s.ksleswts, s.kslestmo, round(s.kslestim / 10000), round(s.kslestim / (10000 * s.ksleswts), 2), round(s.kslesmxt / 10000), s.kslestim, d.ksledhash, d.ksledclassid, d.ksledclass#, d.ksledclass from x$ksles s, x$ksled d where s.ksleswts != 0 and s.kslesenm = d.indx |
| GV$SESSION_LONGOPS | select inst_id, ksulosno, ksulosrn, ksulopna, ksulotna, ksulotde, ksulosfr, ksulotot, ksulouni, to_date(ksulostm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(ksulolut,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(ksuloinft, ‘MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), decode(ksulopna, ‘Advisor’, ksuloif2, decode(sign(ksulotot-ksulosfr),-1,to_number(NULL), decode(ksulosfr, 0, to_number(NULL), round(ksuloetm*((ksulotot-ksulosfr)/ksulosfr))))), ksuloetm, ksuloctx, ksulomsg, ksulounm, ksulosql, ksulosqh, ksulosqi, ksuloqid from x$ksulop |
| GV$SESSION_OBJECT_CACHE | select inst_id,kocstpin,kocsthit,kocsttht,decode(kocstpin,0,1,kocsthit/kocstpin),decode(kocstpin,0,1,kocsttht/kocstpin),kocstorf,kocstrfs,kocstofs,kocstfls,kocstshr,kocstcnt,kocstpnd,kocstsiz,kocstopt,kocstmax from x$kocst |
| GV$SESSION_WAIT | select s.inst_id,s.indx,s.ksussseq,e.kslednam, e.ksledp1,s.ksussp1,s.ksussp1r,e.ksledp2, s.ksussp2,s.ksussp2r,e.ksledp3,s.ksussp3,s.ksussp3r, e.ksledclassid, e.ksledclass#, e.ksledclass, decode(s.ksusstim,0,0,-1,-1,-2,-2, decode(round(s.ksusstim/10000),0,-1,round(s.ksusstim/10000))), s.ksusewtm, decode(s.ksusstim, 0, ‘WAITING’, -2, ‘WAITED UNKNOWN TIME’, -1, ‘WAITED SHORT TIME’, decode(round(s.ksusstim/10000),0,’WAITED SHORT TIME’,'WAITED KNOWN TIME’)) from x$ksusecst s, x$ksled e where bitand(s.ksspaflg,1)!=0 and bitand(s.ksuseflg,1)!=0 and s.ksussseq!=0 and s.ksussopc=e.indx |
| GV$SESSION_WAIT_CLASS | select s.inst_id, s.kslcssid, s.kslcsser, s.kslcsclsid, s.kslcscls, s.kslcsclsname, s.kslcswts, round(s.kslcstim / 10000) from x$kslcs s where s.kslcswts != 0 |
| GV$SESSION_WAIT_HISTORY | select s.inst_id,s.ksusehsnum,s.ksusehwnum,s.ksusehopc, s.ksusehname, s.ksusehp1text,s.ksusehp1,s.ksusehp2text, s.ksusehp2,s.ksusehp3text,s.ksusehp3, round(s.ksusehwtm/10000), s.ksusehcnt from x$ksuseh s |
| GV$SESSMETRIC | SELECT inst_id, begtime, endtime, intsize_csec, sessid, sernum, cpu, phyrds, logrds, pga_memory, hard_parses, soft_parses, phyrds_pct, logrds_pct from x$kewmsemv where flag1 = 1 |
| GV$SESSTAT | select inst_id,ksusenum,ksusestn,ksusestv from x$ksusesta where bitand(ksspaflg,1)!=0 and bitand(ksuseflg,1)!=0 and ksusestn<(select ksusgstl from x$ksusgif) |
| GV$SESS_IO | select inst_id,indx, ksusesbg, ksusescg, ksusespr, ksusesbc, ksusescc from x$ksusio where bitand(ksspaflg,1)!=0 and bitand(ksuseflg,1)!=0 |
| GV$SESS_TIME_MODEL | select map.inst_id, sesv.ksusenum, map.extid, map.sname, sesv.kewsval from x$kewssmap map, x$kewssesv sesv where map.soffst = sesv.kewsnum and map.aggid = 1 and bitand(sesv.ksspaflg,1)!=0 and bitand(sesv.ksuseflg,1)!=0 and (map.stype = 2 or map.stype = 3) |
| GV$SES_OPTIMIZER_ENV | select INST_ID, SID_QKSCESEROW, PNUM_QKSCESEROW, PNAME_QKSCESEROW, decode(bitand(FLAGS_QKSCESEROW, 2), 0, ‘NO’, ‘YES’), PVALUE_QKSCESEROW from X$QKSCESES where bitand(FLAGS_QKSCESEROW, 8) = 0 and (bitand(FLAGS_QKSCESEROW, 4) = 0 or bitand(FLAGS_QKSCESEROW, 2) = 0) |
| GV$SGA | select inst_id,ksmsdnam,ksmsdval from x$ksmsd |
| GV$SGAINFO | select b, c, d, e from ( select ksmsgmemidx a, inst_id b, ksmsgmemnam c, ksmsgmemval d, decode(ksmsgmemrez, 0, ‘No’, 1, ‘Yes’, NULL) e from x$ksmsgmem union select 32 a, USERENV(‘Instance’) b, ‘Free SGA Memory Available’ c, current_size d, NULL e from v$sga_dynamic_free_memory) |
| GV$SGASTAT | select inst_id,”,ksmssnam,ksmsslen from x$ksmfs where ksmsslen>1 union all select inst_id,’shared pool’,ksmssnam, sum(ksmsslen) from x$ksmss where ksmsslen>1 group by inst_id, ‘shared pool’, ksmssnam union all select inst_id,’large pool’,ksmssnam, sum(ksmsslen) from x$ksmls where ksmsslen>1 group by inst_id, ‘large pool’, ksmssnam union all select inst_id,’java pool’,ksmssnam, sum(ksmsslen) from x$ksmjs where ksmsslen>1 group by inst_id, ‘java pool’, ksmssnam union all select inst_id,’streams pool’,ksmssnam, sum(ksmsslen) from x$ksmstrs where ksmsslen>1 group by inst_id, ‘streams pool’, ksmssnam |
| GV$SGA_CURRENT_RESIZE_OPS | select sc.inst_id, sc.component, decode(sc.opcode, 0, ‘STATIC’, 1, ‘INITIALIZING’, 2, ‘DISABLED’, 3, ‘GROW’, 4, ‘SHRINK’, 5, ‘SHRINK_CANCEL’, NULL), decode(sc.opmode, 1, ‘MANUAL’, 2, ‘DEFERRED’, 3, ‘IMMEDIATE’, NULL), pn.name, sc.initsize * sc.gransize, sc.targsize * sc.gransize, sc.cursize * sc.gransize, sc.starttime, sc.lasttime from x$kmgsct sc, v$parameter pn where (sc.parno = pn.num) and (sc.opcode <> 0) and (sc.starttime is not null) |
| GV$SGA_DYNAMIC_COMPONENTS | select st.inst_id, st.component, st.cursize * st.gransize, st.minsize * st.gransize, st.maxsize * st.gransize, st.usersize * st.gransize, st.opercnt, decode(st.lastoper, 0, ‘STATIC’, 1, ‘INITIALIZING’, 2, ‘DISABLED’, 3, ‘GROW’, 4, ‘SHRINK’, 5, ‘SHRINK_CANCEL’, NULL), decode(st.lastmode, 1, ‘MANUAL’, 2, ‘DEFERRED’, 3, ‘IMMEDIATE’, NULL), st.lasttime, st.gransize from x$kmgsct st |
| GV$SGA_DYNAMIC_FREE_MEMORY | select inst_id, gv.gransize * (select count(*) from x$ksmge where granstate = ‘FREE’ or granstate = ‘INVALID’) from x$kmgsct gv where rownum=1 |
| GV$SGA_RESIZE_OPS | select op.inst_id, gv.component, decode(op.opcode, 0, ‘STATIC’, 1, ‘INITIALIZING’, 2, ‘DISABLED’, 3, ‘GROW’, 4, ‘SHRINK’, 5, ‘SHRINK_CANCEL’, NULL), decode(op.opmode, 1, ‘MANUAL’, 2, ‘DEFERRED’, 3, ‘IMMEDIATE’, NULL), pn.name, op.initsize * gv.gransize, op.targsize * gv.gransize, op.realsize * gv.gransize, decode(op.status, 0, ‘INACTIVE’, 1, ‘PENDING’, 2, ‘COMPLETE’, 3, ‘CANCELLED’, 4, ‘ERROR’, 5, ‘ERROR’, 6, ‘CANCELLED’, 7, ‘CANCELLED’, NULL), op.starttime, op.endtime from x$kmgsop op, x$kmgsct gv, v$parameter pn where (op.grantype = gv.grantype) and (op.parno = pn.num) order by op.starttime |
| GV$SGA_TARGET_ADVICE | select A.inst_id, A.sgasz, round((A.sgasz / A.base_sgasz), 4), round(A.base_dbtime * round((A.dbtime / A.base_estd_dbtime), 4), 0), round((A.dbtime / A.base_estd_dbtime), 4), round(A.base_phy_reads * round((A.estd_physical_reads / A.base_estd_phy_reads), 4), 0) from x$kmgsbsadv A order by A.inst_id |
| GV$SHARED_POOL_ADVICE | select inst_id, sp_size, round(sp_size / basesp_size, 4), kglsim_size, kglsim_objs, kglsim_timesave, decode(kglsim_basetimesave, 0, to_number(null), round(kglsim_timesave / kglsim_basetimesave, 4)), kglsim_parsetime, decode(kglsim_baseparsetime, 0, to_number(null), round(kglsim_parsetime / kglsim_baseparsetime, 4)), kglsim_hits from x$kglsim |
| GV$SHARED_POOL_RESERVED | select p.inst_id, p.free_space, p.avg_free_size, p.free_count, p.max_free_size, p.used_size, p.avg_used_size, p.used_count, p.max_used_size, s.requests, s.request_misses, s.last_miss_size, s.max_miss_size, s.request_failures, s.last_failure_size, s.aborted_request_threshold, s.aborted_requests, s.last_aborted_size from (select avg(x$ksmspr.inst_id) inst_id, sum(decode(ksmchcls,’R-free’,ksmchsiz,0)) free_space, avg(decode(ksmchcls,’R-free’,ksmchsiz,0)) avg_free_size, sum(decode(ksmchcls,’R-free’,1,0)) free_count, max(decode(ksmchcls,’R-free’,ksmchsiz,0)) max_free_size, sum(decode(ksmchcls,’R-free’,0,ksmchsiz)) used_size, avg(decode(ksmchcls,’R-free’,0,ksmchsiz)) avg_used_size, sum(decode(ksmchcls,’R-free’,0,1)) used_count, max(decode(ksmchcls,’R-free’,0,ksmchsiz)) max_used_size from x$ksmspr where ksmchcom not like ‘%reserved sto%’) p, (select sum(kghlurcn) requests, sum(kghlurmi) request_misses, max(kghlurmz) last_miss_size, max(kghlurmx) max_miss_size, sum(kghlunfu) request_failures, max(kghlunfs) last_failure_size, max(kghlumxa) aborted_request_threshold, sum(kghlumer) aborted_requests, max(kghlumes) last_aborted_size from x$kghlu) s |
| GV$SHARED_SERVER | select inst_id,kmmsinam,kmmsiprp,kmmsista,kmmsinmg, kmmsinmb,kmmsibrk,kmmsivcp,kmmsiidl,kmmsibsy,kmmsitnc from x$kmmsi where bitand(kmmsiflg,1)!=0 |
| GV$SHARED_SERVER_MONITOR | select inst_id,kmmsgcmx,kmmsgmmx,kmmsgsta+kmmsgutr,kmmsgtrm,kmmsgsmx from x$kmmsg |
| GV$SORT_SEGMENT | select inst_id, tablespace_name, segment_file, segment_block, extent_size, current_users, total_extents, total_blocks, used_extents, used_blocks, free_extents, free_blocks, added_extents, extent_hits, freed_extents, free_requests, max_size, max_blocks, max_used_size, max_used_blocks, max_sort_size, max_sort_blocks, relative_fno from x$ktstssd |
| GV$SORT_USAGE | select x$ktsso.inst_id, username, username, ktssoses, ktssosno, prev_sql_addr, prev_hash_value, prev_sql_id, ktssotsn, decode(ktssocnt, 0, ‘PERMANENT’, 1, ‘TEMPORARY’), decode(ktssosegt, 1, ‘SORT’, 2, ‘HASH’, 3, ‘DATA’, 4, ‘INDEX’, 5, ‘LOB_DATA’, 6, ‘LOB_INDEX’ , ‘UNDEFINED’), ktssofno, ktssobno, ktssoexts, ktssoblks, ktssorfno from x$ktsso, v$session where ktssoses = v$session.saddr and ktssosno = v$session.serial# |
| GV$SPPARAMETER | select INST_ID, KSPSPFFTCTXSPSID, KSPSPFFTCTXSPNAME, KSPSPFFTCTXSPVALUE, KSPSPFFTCTXSPDVALUE, KSPSPFFTCTXISSPECIFIED, KSPSPFFTCTXORDINAL, KSPSPFFTCTXCOMMENT from x$kspspfile where ((translate(KSPSPFFTCTXSPNAME,’_',’#') not like ‘##%’) and ((translate(KSPSPFFTCTXSPNAME, ‘_’, ‘#’) not like ‘#%’) OR KSPSPFFTCTXISSPECIFIED = ‘TRUE’)) |
| GV$SQL | select inst_id,kglnaobj,kglfnobj,kglobt03, kglobhs0+kglobhs1+kglobhs2+kglobhs3+kglobhs4+kglobhs5+kglobhs6+kglobt16, kglobt08+kglobt11, kglobt10, kglobt01, decode(kglobhs6,0,0,1), decode(kglhdlmd,0,0,1), kglhdlkc, kglobt04, kglobt05, kglobt48, kglobt35, kglobpc6, kglhdldc, substr(to_char(kglnatim,’YYYY-MM-DD/HH24:MI:SS’),1,19), kglhdivc, kglobt12, kglobt13, kglobwdw, kglobt14, kglobwap, kglobwcc, kglobwcl, kglobwui, kglobt42, kglobt43, kglobt15, kglobt02, decode(kglobt32, 0, ‘NONE’, 1, ‘ALL_ROWS’, 2, ‘FIRST_ROWS’, 3, ‘RULE’, 4, ‘CHOOSE’, ‘UNKNOWN’), kglobtn0, kglobcce, kglobcceh, kglobt17, kglobt18, kglobts4, kglhdkmk, kglhdpar, kglobtp0, kglnahsh, kglobt46, kglobt30, kglobt09, kglobts5, kglobt48, kglobts0, kglobt19, kglobts1, kglobt20, kglobt21, kglobts2, kglobt06, kglobt07, decode(kglobt28, 0, to_number(NULL), kglobt28), kglhdadr, kglobt29, decode(bitand(kglobt00,64),64, ‘Y’, ‘N’), decode(kglobsta, 1, ‘VALID’, 2, ‘VALID_AUTH_ERROR’, 3, ‘VALID_COMPILE_ERROR’, 4, ‘VALID_UNAUTH’, 5, ‘INVALID_UNAUTH’, 6, ‘INVALID’), kglobt31, substr(to_char(kglobtt0,’YYYY-MM-DD/HH24:MI:SS’),1,19), decode(kglobt33, 1, ‘Y’, ‘N’), kglhdclt, kglobts3, kglobt44, kglobt45, kglobt47, kglobt49, kglobcla, kglobcbca from x$kglcursor_child |
| GV$SQLAREA | select inst_id, kglnaobj, kglfnobj, kglobt03, kglobhs0+kglobhs1+kglobhs2+kglobhs3+kglobhs4+kglobhs5+kglobhs6, kglobt08+kglobt11, kglobt10, kglobt01, kglobccc, kglobclc, kglhdlmd, kglhdlkc, kglobt04, kglobt05, kglobt48, kglobt35, kglobpc6, kglhdldc, substr(to_char(kglnatim,’YYYY-MM-DD/HH24:MI:SS’),1,19), kglhdivc, kglobt12, kglobt13, kglobwdw, kglobt14, kglobwap, kglobwcc, kglobwcl, kglobwui, kglobt42, kglobt43, kglobt15, kglobt02, decode(kglobt32, 0, ‘NONE’, 1, ‘ALL_ROWS’, 2, ‘FIRST_ROWS’, 3, ‘RULE’, 4, ‘CHOOSE’, ‘UNKNOWN’), kglobtn0, kglobcce, kglobcceh, kglobt17, kglobt18, kglobts4, kglhdkmk, kglhdpar, kglnahsh, kglobt46, kglobt30, kglobts0, kglobt19, kglobts1, kglobt20, kglobt21, kglobts2, kglobt06, kglobt07, decode(kglobt28, 0, NULL, kglobt28), kglhdadr, decode(bitand(kglobt00,64),64, ‘Y’, ‘N’), decode(kglobsta, 1, ‘VALID’, 2, ‘VALID_AUTH_ERROR’, 3, ‘VALID_COMPILE_ERROR’, 4, ‘VALID_UNAUTH’, 5, ‘INVALID_UNAUTH’, 6, ‘INVALID’), kglobt31, kglobtt0, decode(kglobt33, 1, ‘Y’, ‘N’), kglhdclt, kglobts3, kglobt44, kglobt45, kglobt47, kglobt49, kglobcla, kglobcbca from x$kglcursor_child_sqlid where kglobt02 != 0 |
| GV$SQLAREA_PLAN_HASH | select inst_id, kglnaobj, kglfnobj, kglhdpar, kglobt46, kglobt03, kglobt30, kglobccc, kglhdadr, kglobhs0+kglobhs1+kglobhs2+kglobhs3+kglobhs4+kglobhs5+kglobhs6, kglobt08+kglobt11, kglobt10, kglobt01, kglobclc, kglhdlmd, kglhdlkc, kglobpc6, kglobt04, kglobt05, kglobt50, kglobt35, kglhdldc, kglnatim, kglobtt0, kglobcla, kglhdivc, kglobt12, kglobt13, kglobwdw, kglobt14, kglobt06, kglobt07, kglobwap, kglobwcc, kglobwcl, kglobwui, kglobt42, kglobt43, kglobt15, kglobt02, decode(kglobt32, 0, ‘NONE’, 1, ‘ALL_ROWS’, 2, ‘FIRST_ROWS’, 3, ‘RULE’, 4, ‘CHOOSE’, ‘UNKNOWN’), kglobtn0, kglobcce, kglobcceh, kglobt17, kglobt18, kglobts4, kglhdkmk, kglobts0, kglobt19, kglobts1, kglobt20, kglobt21, kglobts2, decode(kglobt28, 0, NULL, kglobt28), decode(bitand(kglobt00,64),64, ‘Y’, ‘N’), decode(kglobsta, 1, ‘VALID’, 2, ‘VALID_AUTH_ERROR’, 3, ‘VALID_COMPILE_ERROR’, 4, ‘VALID_UNAUTH’, 5, ‘INVALID_UNAUTH’, 6, ‘INVALID’), kglobt31, kglobts3, kglobt44, kglobt45, kglobt47, kglobt49, kglobcbca from x$kglcursor_child_sqlidph |
| GV$SQLSTATS | select INST_ID, SQL_TEXT, SQL_FULLTEXT, SQL_ID, LAST_ACTIVE_TIME, LAST_ACTIVE_CHILD_ADDRESS, PLAN_HASH_VALUE, PARSE_CALLS, DISK_READS, DIRECT_WRITES, BUFFER_GETS, ROWS_PROCESSED, SERIALIZABLE_ABORTS, FETCHES, EXECUTIONS, END_OF_FETCH_COUNT, LOADS, VERSION_COUNT, INVALIDATIONS, PX_SERVERS_EXECUTIONS, CPU_TIME, ELAPSED_TIME, APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, SORTS, SHARABLE_MEM, TOTAL_SHARABLE_MEM from x$kkssqlstat |
| GV$SQLTEXT | select inst_id,kglhdadr, kglnahsh, kglnasqlid, kgloboct, piece, name from x$kglna where kgloboct != 0 |
| GV$SQLTEXT_WITH_NEWLINES | select inst_id,kglhdadr, kglnahsh, kglnasqlid, kgloboct, piece, name from x$kglna1 where kgloboct != 0 |
| GV$SQL_BIND_DATA | select inst_id,kxsbdcur, kxsbdbnd, kxsbddty, kxsbdmxl, kxsbdpmx, kxsbdmal, kxsbdpre, kxsbdscl, kxsbdofl, kxsbdof2, kxsbdbfp, kxsbdbln, kxsbdavl, kxsbdbfl, kxsbdind, kxsbdval from x$kxsbd |
| GV$SQL_BIND_METADATA | select inst_id,kglhdadr, position, kkscbndt, kkscbndl, kkscbnda, kksbvnnam from x$kksbv |
| GV$SQL_CURSOR | select inst_id,kxscccur, kxscccfl, decode(kxsccsta, 0, ‘CURNULL’, 1, ‘CURSYNTAX’, 2, ‘CURPARSE’, 3, ‘CURBOUND’, 4, ‘CURFETCH’, 5, ‘CURROW’, ‘ERROR’), kxsccphd, kxsccplk, kxsccclk, kxscccpn, kxscctbm, kxscctwm, kxscctbv, kxscctdv, kxsccbdf, kxsccflg, kxsccfl2, kxsccchd from x$kxscc |
| GV$SQL_JOIN_FILTER | SELECT INST_ID, QCSID, QCINSTID, SQLHASHV, LEN, NSET, FLT, TOT, ACTIVE from X$QESBLSTAT |
| GV$SQL_OPTIMIZER_ENV | select INST_ID, KQLFSQCE_PHAD, KQLFSQCE_HASH, KQLFSQCE_SQLID, KQLFSQCE_HADD, KQLFSQCE_CHNO, KQLFSQCE_PNUM, KQLFSQCE_PNAME, decode(bitand(KQLFSQCE_FLAGS, 2), 0, ‘NO’, ‘YES’), KQLFSQCE_PVALUE from X$KQLFSQCE where bitand(KQLFSQCE_FLAGS, 8) = 0 and (bitand(KQLFSQCE_FLAGS, 4) = 0 or bitand(KQLFSQCE_FLAGS, 2) = 0) |
| GV$SQL_PLAN | select inst_id, kqlfxpl_phad, kqlfxpl_hash, kqlfxpl_sqlid, kqlfxpl_plhash, kqlfxpl_hadd, kqlfxpl_chno, kqlfxpl_timestamp, substr(kqlfxpl_oper, 1, 30), substr(kqlfxpl_oopt, 1, 30), substr(kqlfxpl_tqid, 1, 40), to_number(decode(kqlfxpl_objn, 0, NULL, kqlfxpl_objn)), kqlfxpl_objowner, kqlfxpl_objname, kqlfxpl_alias, substr(kqlfxpl_objtype, 1, 20), substr(kqlfxpl_opti, 1, 20), kqlfxpl_opid, to_number(decode(kqlfxpl_opid, 0, NULL, kqlfxpl_paid)), kqlfxpl_depth, to_number(decode(kqlfxpl_pos, 0, decode(kqlfxpl_cost, 4294967295, NULL, kqlfxpl_cost), kqlfxpl_pos)), kqlfxpl_scols, to_number(decode(kqlfxpl_cost, 4294967295, NULL, kqlfxpl_cost)), to_number(decode(kqlfxpl_card, 0, NULL, kqlfxpl_card)), to_number(decode(kqlfxpl_size, 0, NULL, kqlfxpl_size)), substr(kqlfxpl_otag, 1, 35), substr(kqlfxpl_psta, 1, 5), substr(kqlfxpl_psto, 1, 5), to_number(decode(kqlfxpl_pnid, 0, NULL, kqlfxpl_pnid)), kqlfxpl_other, substr(kqlfxpl_dist, 1, 20), to_number(decode(kqlfxpl_cpuc, 4294967295, NULL, kqlfxpl_cpuc)), to_number(decode(kqlfxpl_ioct, 4294967295, NULL, kqlfxpl_ioct)), to_number(decode(kqlfxpl_temp, 0, NULL, kqlfxpl_temp)), kqlfxpl_keys, kqlfxpl_filter, kqlfxpl_proj, to_number(decode(kqlfxpl_time, 0, NULL, kqlfxpl_time)), kqlfxpl_qblock, kqlfxpl_remark, kqlfxpl_other_xml from x$kqlfxpl p |
| GV$SQL_PLAN_STATISTICS | select inst_id, PHADD_QESRS, HASHV_QESRS, SQLID_QESRS, PLHASH_QESRS, HADDR_QESRS, CHILDNO_QESRS, OPERID_QESRS, EXECS_QESRS, LSTARTS_QESRS, STARTS_QESRS, LOUTROWS_QESRS, OUTROWS_QESRS, LCRGETS_QESRS, CRGETS_QESRS, LCUGETS_QESRS, CUGETS_QESRS, LDREADS_QESRS, DREADS_QESRS, LDWRITES_QESRS, DWRITES_QESRS, LELAPTIME_QESRS, ELAPTIME_QESRS from X$QESRSTAT |
| GV$SQL_PLAN_STATISTICS_ALL | select inst_id, PHADD_QESRS, HASHV_QESRS, SQLID_QESRS, PLHASH_QESRS, HADDR_QESRS, CHILDNO_QESRS, TIMESTAMP_QESRS, substr(oper_qesrs, 1, 30), substr(oopt_qesrs, 1, 30), substr(tqid_qesrs, 1, 40), to_number(decode(objn_qesrs, 0, NULL, objn_qesrs)), objowner_qesrs, objname_qesrs, alias_qesrs, substr(objtype_qesrs, 1, 20), substr(opti_qesrs, 1, 20), opid_qesrs, to_number(decode(opid_qesrs, 0, NULL, paid_qesrs)), depth_qesrs, to_number(decode(pos_qesrs, 0, decode(cost_qesrs, 4294967295, NULL, cost_qesrs), pos_qesrs)), scols_qesrs, to_number(decode(cost_qesrs, 4294967295, NULL, cost_qesrs)), to_number(decode(card_qesrs, 0, NULL, card_qesrs)), to_number(decode(size_qesrs, 0, NULL, size_qesrs)), substr(otag_qesrs, 1, 35), substr(psta_qesrs, 1, 5), substr(psto_qesrs, 1, 5), to_number(decode(pnid_qesrs, 0, NULL, pnid_qesrs)), other_qesrs, substr(dist_qesrs, 1, 20), to_number(decode(cpuc_qesrs, 4294967295, NULL, cpuc_qesrs)), to_number(decode(ioct_qesrs, 4294967295, NULL, ioct_qesrs)), to_number(decode(temp_qesrs, 0, NULL, temp_qesrs)), KEYS_QESRS, FILTER_QESRS, PROJ_QESRS, to_number(decode(time_qesrs, 0, NULL, time_qesrs)), QBLOCK_QESRS, REMARK_QESRS, OTHER_XML_QESRS, EXECS_QESRS, to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LSTARTS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, STARTS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LOUTROWS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, OUTROWS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LCRGETS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, CRGETS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LCUGETS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, CUGETS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LDREADS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, DREADS_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LDWRITES_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, DWRITES_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, LELAPTIME_QESRS)), to_number(decode(LSTARTS_QESRS, 4294967295, NULL, ELAPTIME_QESRS)), substr(SIZEPOLICY_QESRS, 1, 10), to_number(decode(OPTIMAL_QESRS, 0, NULL, OPTIMAL_QESRS * 1024)), to_number(decode(OPTIMAL_QESRS, 0, NULL, ONEPASS_QESRS * 1024)), to_number(decode(OPTIMAL_QESRS, 0, NULL, LASTMEM_QESRS * 1024)), decode(OPTIMAL_QESRS, 0, NULL, substr(decode(LASTPASS_QESRS, 0, ‘OPTIMAL’, to_char(LASTPASS_QESRS) || ‘ PASS’ || decode(LASTPASS_QESRS, 1, ”, ‘ES’)), 1, 10)), to_number(decode(LASTDOP_QESRS, 0, NULL, LASTDOP_QESRS)), to_number(decode(OPTIMAL_QESRS, 0, NULL, (OPTACTS_QESRS + SPAACTS_QESRS + MPAACTS_QESRS))), to_number(decode(OPTIMAL_QESRS, 0, NULL, OPTACTS_QESRS)), to_number(decode(OPTIMAL_QESRS, 0, NULL, SPAACTS_QESRS)), to_number(decode(OPTIMAL_QESRS, 0, NULL, MPAACTS_QESRS)), to_number(decode(OPTIMAL_QESRS, 0, NULL, ATIME_QESRS)), to_number(decode(MAXTSEG_QESRS, 0, NULL, MAXTSEG_QESRS)), to_number(decode(LASTTSEG_QESRS, 0, NULL, LASTTSEG_QESRS)) from X$QESRSTATALL p where p.haddr_qesrs != p.phadd_qesrs |
| GV$SQL_REDIRECTION | select c.inst_id,c.kglhdadr,c.kglhdpar,c.kglnahsh,c.kglobt03, c.kglobt09, c.kglobt17,c.kglobt18, c.kglobt02, decode(r.reason,1,’INVALID OBJECT’, 2,’ROWID’,3,’QUERY REWRITE’,'READ ONLY’), r.error_code, r.position, r.sql_text_piece, r.error_msg from x$kglcursor_child c, x$kkssrd r where c.kglhdpar = r.parAddr and c.kglhdadr = r.kglhdadr |
| GV$SQL_SHARED_CURSOR | select inst_id, sql_id, kglhdpar, kglhdadr, childno, decode(bitand(bitvector, POWER(2,0)), POWER(2, 0), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,1)), POWER(2, 1), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,2)), POWER(2, 2), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,3)), POWER(2, 3), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,4)), POWER(2, 4), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,5)), POWER(2, 5), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,6)), POWER(2, 6), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,7)), POWER(2, 7), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,8)), POWER(2, 8), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,9)), POWER(2, 9), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,10)), POWER(2, 10), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,11)), POWER(2, 11), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,12)), POWER(2, 12), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,13)), POWER(2, 13), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,14)), POWER(2, 14), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,15)), POWER(2, 15), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,16)), POWER(2, 16), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,17)), POWER(2, 17), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,18)), POWER(2, 18), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,19)), POWER(2, 19), ‘Y’,'N’), decode(bitand(bitvector, POWER(2,20)), POWER(2, 20), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,21)), POWER(2, 21), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,22)), POWER(2, 22), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,23)), POWER(2, 23), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,24)), POWER(2, 24), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,25)), POWER(2, 25), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,26)), POWER(2, 26), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,27)), POWER(2, 27), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,28)), POWER(2, 28), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,29)), POWER(2, 29), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,30)), POWER(2, 30), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,31)), POWER(2, 31), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,32)), POWER(2, 32), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,33)), POWER(2, 33), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,34)), POWER(2, 34), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,35)), POWER(2, 35), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,36)), POWER(2, 36), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,37)), POWER(2, 37), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,38)), POWER(2, 38), ‘Y’,'N’), decode(bitand(bitvector, POWER(2,39)), POWER(2, 39), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,40)), POWER(2, 40), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,41)), POWER(2, 41), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,42)), POWER(2, 42), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,43)), POWER(2, 43), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,44)), POWER(2, 44), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,45)), POWER(2, 45), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,46)), POWER(2, 46), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,47)), POWER(2, 47), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,48)), POWER(2, 48), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,49)), POWER(2, 49), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,50)), POWER(2, 50), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,51)), POWER(2, 51), ‘Y’,'N’),decode(bitand(bitvector, POWER(2,52)), POWER(2, 52), ‘Y’,'N’) from x$kkscs |
| GV$SQL_SHARED_MEMORY | select /*+use_nl(h,c)*/ c.inst_id,kglnaobj,kglfnobj, kglnahsh, kglobt03, kglobhd6, rtrim(substr(ksmchcom, 1, instr(ksmchcom, ‘:’, 1, 1) – 1)), ltrim(substr(ksmchcom, -(length(ksmchcom) – (instr(ksmchcom, ‘:’, 1, 1))), (length(ksmchcom) – (instr(ksmchcom, ‘:’, 1, 1)) + 1))), ksmchcom, ksmchptr, ksmchsiz, ksmchcls, ksmchtyp, ksmchpar from x$kglcursor c, x$ksmhp h where ksmchds = kglobhd6 and kglhdadr != kglhdpar |
| GV$SQL_WORKAREA | SELECT INST_ID, PHADD_QKSMM, HASHV_QKSMM, SQLID_QKSMM, CHILDNO_QKSMM, WADDR_QKSMM, substr(OPERTYPE_QKSMM, 1, 20), to_number(decode(OPERTID_QKSMM, 65535, NULL, OPERTID_QKSMM)), substr(SIZEPOLICY_QKSMM, 1, 10), OPTIMAL_QKSMM * 1024, ONEPASS_QKSMM * 1024, LASTMEM_QKSMM * 1024, substr(decode(LASTPASS_QKSMM, 0, ‘OPTIMAL’, to_char(LASTPASS_QKSMM) || ‘ PASS’ || decode(LASTPASS_QKSMM, 1, ”, ‘ES’)), 1, 10), LASTDOP_QKSMM, (OPTACTS_QKSMM + SPAACTS_QKSMM + MPAACTS_QKSMM), OPTACTS_QKSMM, SPAACTS_QKSMM, MPAACTS_QKSMM, ATIME_QKSMM, to_number(decode(MAXTSEG_QKSMM, 0, NULL, MAXTSEG_QKSMM*1024)), to_number(decode(LASTTSEG_QKSMM, 0, NULL, LASTTSEG_QKSMM*1024)) from X$QKSMMWDS |
| GV$SQL_WORKAREA_ACTIVE | select INST_ID, SQLHASHV, SQLID, WADDR, substr(OPER_TYPE, 1, 20), to_number(decode(OPID, 65535, NULL, OPID)), substr(decode(bitand(MEM_FLAGS,1), 0, ‘MANUAL’, ‘AUTO’), 1, 6), SID, to_number(decode(QCINSTID, 65535, NULL, QCINSTID)), to_number(decode(QCSID, 65535, NULL, QCSID)), ATIME, WA_SIZE * 1024, to_number(decode(bitand(MEM_FLAGS,1), 0, NULL, EXP_SIZE*1024)), ACTUAL_MEM * 1024, MAX_MEM * 1024, PASSES, to_number(decode(KTSSOTSN, ”, NULL, KTSSOSIZE*1024)), decode(KTSSOTSN, ”, NULL, KTSSOTSN), to_number(decode(KTSSOTSN, ”, NULL, KTSSORFNO)), to_number(decode(KTSSOTSN, ”, NULL, KTSSOBNO)) from x$qesmmiwt |
| GV$SQL_WORKAREA_HISTOGRAM | select INST_ID, LOWBND * 1024, (HIBND * 1024)-1, OPTIMAL, ONEPASS, MPASS, MPASS+ONEPASS+OPTIMAL from X$QESMMIWH |
| GV$STANDBY_APPLY_SNAPSHOT | select INST_ID, SNAPSHOT_TIME, SESSION_ID, THREAD#, RESET_TIMESTAMP, SEQUENCE#, BLOCK#, APPLIED_SCN, APPLIED_TIME, NEWEST_RESET_TIMESTAMP, NEWEST_ARCHIVED_SEQ#, NEWEST_TIME, NEWEST_USED, NEWEST_SRL_SEQ#, BLOCKSIZE, APPLY_RATE from x$kcrrptdgstats |
| GV$STANDBY_LOG | select inst_id, slnum, decode(slpdb,0,’UNASSIGNED’,to_number(slpdb)), slthr, slseq, slsiz*slbsz, decode(slnab, 0, 0, (slnab-1)*slbsz), decode(bitand(slflg,1),0,’NO’,'YES’), decode(sign(slseq),0,’UNASSIGNED’,'ACTIVE’), to_number(sllos), to_date(sllot,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(slnxs), to_date(slnxt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccsl |
| GV$STATISTICS_LEVEL | select inst_id, name, description, decode(session_status, 0, ‘DISABLED’, 1, ‘ENABLED’, ‘UNKNOWN’), decode(system_status, 0, ‘DISABLED’, 1, ‘ENABLED’, ‘UNKNOWN’), decode(activation_level, 0, ‘BASIC’, 1, ‘TYPICAL’, ‘ALL’), view_name, decode(session_changeable, 0, ‘NO’, ‘YES’) from x$prmsltyx |
| GV$STATNAME | select inst_id,indx,ksusdnam,ksusdcls,ksusdhsh from x$ksusd |
| GV$STREAMS_APPLY_COORDINATOR | select inst_id,sid_knst,serial_knst, applynum_knstacr, applyname_knstacr,decode(state_knstacr,0,’INITIALIZING’, 1,’APPLYING’,2,’SHUTTING DOWN CLEANLY’,3,’ABORTING’,4,’IDLE’),total_applied_knstacr, total_waitdeps_knstacr,total_waitcommits_knstacr,total_admin_knstacr,total_assigned_knstacr,total_received_knstacr, total_ignored_knstacr,total_rollbacks_knstacr, total_errors_knstacr,lwm_time_knstacr, lwm_msg_num_knstacr, lwm_msg_time_knstacr,hwm_time_knstacr, hwm_msg_num_knstacr, hwm_msg_time_knstacr,startup_time_knstacr, elapsed_schedule_time_knstacr, elapsed_idle_time_knstacr from x$knstacr x where type_knst=1 and exists (select 1 from v$session s where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$STREAMS_APPLY_READER | select inst_id,sid_knst,serial_knst,applynum_knstasl, applyname_knstasl,decode(state_knstasl,0,’IDLE’,8,’DEQUEUE MESSAGES’,10,’SCHEDULE MESSAGES’,15,’INITIALIZING’,16,’SPILLING’,17,’PAUSED’),total_msg_knstasl, total_spill_msg_knstasl, last_rcv_time_knstasl,last_rcv_msg_num_knstasl, last_rcv_msg_time_knstasl, sga_used_knstasl, elapsed_dequeue_time_knstasl, elapsed_schedule_time_knstasl,elapsed_spill_time_knstasl,last_browse_num_knstasl, oldest_scn_num_knstasl, last_browse_seq_knstasl,last_deq_seq_knstasl,oldest_xid_usn_knstasl,oldest_xid_slt_knstasl,oldest_xid_sqn_knstasl from x$knstasl x where type_knst=7 and exists (select 1 from v$session s where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$STREAMS_APPLY_SERVER | select inst_id,sid_knst,serial_knst,applynum_knstasl, applyname_knstasl,slavid_knstasl,decode(state_knstasl,0,’IDLE’,1,’POLL SHUTDOWN’,2,’RECORD LOW-WATERMARK’,3,’ADD PARTITION’,4,’DROP PARTITION’,5,’EXECUTE TRANSACTION’,6,’WAIT COMMIT’,7,’WAIT DEPENDENCY’,8,’GET TRANSACTIONS’,9,’WAIT FOR NEXT CHUNK’,12,’ROLLBACK TRANSACTION’,13,’TRANSACTION CLEANUP’,14,’REQUEST UA SESSION’,15,’INITIALIZING’), xid_usn_knstasl,xid_slt_knstasl,xid_sqn_knstasl,cscn_knstasl,depxid_usn_knstasl,depxid_slt_knstasl,depxid_sqn_knstasl,depcscn_knstasl,msg_num_knstasl,total_assigned_knstasl,total_admin_knstasl,total_rollbacks_knstasl,total_msg_knstasl, last_apply_time_knstasl, last_apply_msg_num_knstasl,last_apply_msg_time_knstasl,elapsed_dequeue_time_knstasl, elapsed_apply_time_knstasl from x$knstasl x where type_knst=2 and exists (select 1 from v$session s where s.sid=x.sid_knst and s.serial#=x.serial_knst) |
| GV$STREAMS_CAPTURE | SELECT x.inst_id, x.sid_knst, x.serial_knst, x.capnum_knstcap, x.capname_knstcap, x.logminer_id_knstcap, x.startup_time_knstcap, case when (x.state_knstcap = 10 and d.loaded = ‘ACTIVE’) then d.current_state || ‘ ‘ || d.progress else DECODE(x.state_knstcap, 0, ‘INITIALIZING’, 1,’CAPTURING CHANGES’, 2, ‘EVALUATING RULE’, 3,’ENQUEUING MESSAGE’, 4, ‘SHUTTING DOWN’, 5,’ABORTING’, 6, ‘CREATING LCR’, 7,’WAITING FOR DICTIONARY REDO’, 8, ‘WAITING FOR REDO’,9,’PAUSED FOR FLOW CONTROL’, 10, ‘DICTIONARY INITIALIZATION’) end, m.msgs_filtered, m.msgs_kept, m.msgs_total, x.total_captured_knstcap, x.recent_time_knstcap, x.recent_msg_num_knstcap, x.recent_msg_time_knstcap, x.total_messages_created_knstcap, x.total_full_evaluations_knstcap, x.total_msg_enq_knstcap, x.enqueue_time_knstcap, x.enqueue_msg_num_knstcap, x.enqueue_msg_time_knstcap, DECODE(bitand(x.flags_knstcap, 1), 0, upstream.next_scn, 1, downstream.next_scn), DECODE(bitand(x.flags_knstcap, 1), 0, upstream.next_time, 1, downstream.next_time), x.elapsed_capture_time_knstcap, x.elapsed_rule_time_knstcap, x.elapsed_enqueue_time_knstcap, x.elapsed_lcr_time_knstcap, x.elapsed_wait_time_knstcap, x.elapsed_pause_time_knstcap, x.state_changed_time_knstcap from x$knstcap x, (SELECT session_id, sum(skipped_filter_calls) msgs_filtered, sum(kept_filter_calls) msgs_kept, sum(total_filter_calls) msgs_total from x$logmnr_process GROUP BY session_id) m, (SELECT last_write_scn next_scn, last_write_scn_time next_time from x$kcrfws) upstream, (SELECT session#, max(next_change#) next_scn, max(next_time) next_time from system.logmnr_log$ GROUP BY session#) downstream, x$logmnr_dictionary_load d where type_knst=8 AND x.logminer_id_knstcap = m.session_id(+) AND x.logminer_id_knstcap = d.session_id(+) AND x.logminer_id_knstcap = downstream.session#(+) AND EXISTS (SELECT 1 from v$session s where s.sid=x.sid_knst AND s.serial#=x.serial_knst) |
| GV$STREAMS_POOL_ADVICE | select inst_id, size_knlarow, round(size_knlarow / basesize_knlarow, 4), spillcnt_knlarow, spilltime_knlarow, unspillcnt_knlarow, unspilltime_knlarow from x$knlarow |
| GV$STREAMS_TRANSACTION | SELECT inst_id, strmname_knsttxn, type_knsttxn, xidusn_knsttxn, xidslt_knsttxn, xidsqn_knsttxn, msg_count_knsttxn, actual_msg_count_knsttxn, first_msg_time_knsttxn, first_msg_num_knsttxn, last_msg_time_knsttxn, last_msg_num_knsttxn from x$knsttxn |
| GV$SUBCACHE | select inst_id,kglnaown, kglnaobj, kglobtyp, kqlfshpn, kqlfscid, kqlfsscc, kqlfsesp, kqlfsasp, kqlfsusp from x$kqlset |
| GV$SYSAUX_OCCUPANTS | SELECT inst_id, occ_name_kewxocf, occ_desc_kewxocf, sch_name_kewxocf, move_proc_kewxocf, move_desc_kewxocf, space_usage_kewxocf from x$kewxocf |
| GV$SYSMETRIC | SELECT inst_id, begtime, endtime, intsize_csec, groupid, metricid, name, value, unit from x$kewmdrmv where flag1 = 1 AND groupid in (2,3) |
| GV$SYSMETRIC_HISTORY | SELECT inst_id, begtime, endtime, intsize_csec, groupid, metricid, name, value, unit from x$kewmdrmv where groupid in (2,3) |
| GV$SYSMETRIC_SUMMARY | SELECT inst_id, begtime, endtime, intsize_csec, groupid, metricid, name, numintv, max, min, avg, std, unit from x$kewmsmdv where groupid = 2 |
| GV$SYSSTAT | select inst_id,indx,ksusdnam,ksusdcls,ksusgstv,ksusdhsh from x$ksusgsta |
| GV$SYSTEM_CURSOR_CACHE | select inst_id,kgicsopn,kgicshit,decode(kgicsopn,0,1,kgicshit/kgicsopn) from x$kgics |
| GV$SYSTEM_EVENT | select d.inst_id, d.kslednam, s.ksleswts, s.kslestmo, round(s.kslestim / 10000), round(s.kslestim / (10000 * s.ksleswts), 2), s.kslestim, d.ksledhash, d.ksledclassid, d.ksledclass#, d.ksledclass from x$kslei s, x$ksled d where s.ksleswts != 0 and s.indx = d.indx |
| GV$SYSTEM_PARAMETER | select x.inst_id,x.indx+1,ksppinm,ksppity,ksppstvl, ksppstdvl, ksppstdf, decode(bitand(ksppiflg/256,1),1,’TRUE’,'FALSE’), decode(bitand(ksppiflg/65536,3),1,’IMMEDIATE’,2,’DEFERRED’, 3,’IMMEDIATE’,'FALSE’), decode(bitand(ksppiflg,4),4,’FALSE’, decode(bitand(ksppiflg/65536,3), 0, ‘FALSE’, ‘TRUE’)), decode(bitand(ksppstvf,7),1,’MODIFIED’,'FALSE’), decode(bitand(ksppstvf,2),2,’TRUE’,'FALSE’), decode(bitand(ksppilrmflg/64, 1), 1, ‘TRUE’, ‘FALSE’), ksppdesc, ksppstcmnt, ksppihash from x$ksppi x, x$ksppsv y where (x.indx = y.indx) and ((translate(ksppinm,’_',’#') not like ‘##%’) and ((translate(ksppinm,’_',’#') not like ‘#%’) or (ksppstdf = ‘FALSE’) or (bitand(ksppstvf,5) > 0))) |
| GV$SYSTEM_PARAMETER2 | select x.inst_id,kspftctxpn,ksppinm,ksppity,kspftctxvl, kspftctxdvl, kspftctxdf, decode(bitand(ksppiflg/256,1),1,’TRUE’,'FALSE’), decode(bitand(ksppiflg/65536,3),1,’IMMEDIATE’,2,’DEFERRED’, 3,’IMMEDIATE’,'FALSE’), decode(bitand(ksppiflg,4),4,’FALSE’, decode(bitand(ksppiflg/65536,3), 0, ‘FALSE’, ‘TRUE’)), decode(bitand(kspftctxvf,7),1,’MODIFIED’,'FALSE’), decode(bitand(kspftctxvf,2),2,’TRUE’,'FALSE’), decode(bitand(ksppilrmflg/64, 1), 1, ‘TRUE’, ‘FALSE’), ksppdesc, kspftctxvn, kspftctxct from x$ksppi x, x$ksppsv2 y where ((x.indx+1) = kspftctxpn) and ((translate(ksppinm,’_',’#') not like ‘##%’) and (translate(ksppinm,’_',’#') not like ‘#%’ or (kspftctxdf = ‘FALSE’) or (bitand(kspftctxvf,5) > 0))) |
| GV$SYSTEM_WAIT_CLASS | select s.inst_id, s.kslscsclsid, s.kslscscls, s.kslscsclsname, s.kslscswts, round(s.kslscstim / 10000) from x$kslscs s where s.kslscswts != 0 |
| GV$SYS_OPTIMIZER_ENV | select INST_ID, PNUM_QKSCESYROW, PNAME_QKSCESYROW, decode(bitand(FLAGS_QKSCESYROW, 2), 0, ‘NO’, ‘YES’), PVALUE_QKSCESYROW, DEFPVALUE_QKSCESYROW from X$QKSCESYS where bitand(FLAGS_QKSCESYROW, 8) = 0 and (bitand(FLAGS_QKSCESYROW, 4) = 0 or bitand(FLAGS_QKSCESYROW, 2) = 0) |
| GV$SYS_TIME_MODEL | select map.inst_id, map.extid, map.sname, sysv.kewsval from x$kewssmap map, x$kewssysv sysv where map.offst = sysv.indx and map.aggid = 1 and (map.stype = 2 or map.stype = 3) |
| GV$TABLESPACE | select inst_id,tstsn,tsnam, decode(bitand(tsflg, 1+2), 1, ‘NO’, 2,’NO’,'YES’), decode(bitand(tsflg, 4), 4,’YES’,'NO’), decode(bitand(tsflg, 8), 8,’NO’,'YES’), decode(bitand(tsflg, 16+32), 16, ‘ON’, 32, ‘OFF’, to_char(null)) from x$kccts where tstsn != -1 |
| GV$TEMPFILE | select tf.inst_id, tf.tfnum, to_number(tf.tfcrc_scn), to_date(tf.tfcrc_tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), tf.tftsn, tf.tfrfn, decode(bitand(tf.tfsta, 2),0,’OFFLINE’,2,’ONLINE’,'UNKNOWN’), decode(bitand(tf.tfsta, 12), 0,’DISABLED’,4, ‘READ ONLY’, 12, ‘READ WRITE’, ‘UNKNOWN’), fh.fhtmpfsz*tf.tfbsz, fh.fhtmpfsz, tf.tfcsz*tf.tfbsz,tf.tfbsz, fn.fnnam from x$kcctf tf, x$kccfn fn, x$kcvfhtmp fh where fn.fnfno=tf.tfnum and fn.fnfno=fh.htmpxfil and tf.tffnh=fn.fnnum and tf.tfdup!=0 and bitand(tf.tfsta, 32) <> 32 and fn.fntyp=7 and fn.fnnam is not null |
| GV$TEMPORARY_LOBS | select kdlt.inst_id, kdlt.kdltsno, sum(kdlt.kdltctmp), sum(kdlt.kdltnctmp), abs.count from X$KDLT kdlt, X$ABSTRACT_LOB abs group by kdlt.inst_id, kdlt.kdltsno, abs.count order by kdltsno |
| GV$TEMPSTAT | select k.inst_id,k.kcftiofno,k.kcftiopyr,k.kcftiopyw,k.kcftiopbr,k.kcftiopbw, k.kcftiosbr,k.kcftioprt,k.kcftiopwt,k.kcftiosbt,k.kcftioavg,k.kcftiolst, k.kcftiomin,k.kcftiormx,k.kcftiowmx from x$kcftio k,x$kcctf f where f.tfdup <> 0 and f.tfnum=k.kcftiofno |
| GV$TEMP_CACHE_TRANSFER | select x.inst_id, kcftiofno, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from x$kcftio x, x$kcctf tf where x.kcftiofno = tf.tfnum |
| GV$TEMP_EXTENT_MAP | select /*+ ordered use_nl(me) */ me.inst_id, ts.name, me.ktftmetfno, me.ktftmebno, me.ktftmeblks*ts.blocksize, me.ktftmeblks, me.ktftmeinst, me.ktftmefno from ts$ ts, x$ktftme me where ts.contents$ = 1 and ts.bitmapped <> 0 and ts.online$ = 1 and ts.ts# = me.ktftmetsn |
| GV$TEMP_EXTENT_POOL | select /*+ ordered use_nl(fc) */ fc.inst_id, ts.name, fc.ktstfctfno, fc.ktstfcec, fc.ktstfceu, fc.ktstfcbc, fc.ktstfcbu, fc.ktstfcbc*ts.blocksize, fc.ktstfcbu*ts.blocksize, fc.ktstfcfno from ts$ ts, x$ktstfc fc where ts.contents$ = 1 and ts.bitmapped <> 0 and ts.online$ = 1 and ts.ts# = fc.ktstfctsn |
| GV$TEMP_HISTOGRAM | select k.inst_id, k.kcftiofno,k.kcftiomaxdur,k.kcftioval from x$kcftiohist k,x$kcctf f where f.tfdup <> 0 and f.tfnum=k.kcftiofno |
| GV$TEMP_PING | select x.inst_id, kcftiofno, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 from x$kcftio x, x$kcctf tf where x.kcftiofno = tf.tfnum |
| GV$TEMP_SPACE_HEADER | select /*+ ordered use_nl(hc) */ hc.inst_id, ts.name, hc.ktfthctfno, (hc.ktfthcsz – hc.ktfthcfree)*ts.blocksize, (hc.ktfthcsz – hc.ktfthcfree), hc.ktfthcfree*ts.blocksize, hc.ktfthcfree, hc.ktfthcfno from ts$ ts, x$ktfthc hc where ts.contents$ = 1 and ts.bitmapped <> 0 and ts.online$ = 1 and ts.ts# = hc.ktfthctsn and hc.ktfthccval = 0 |
| GV$THREAD | select rt.inst_id,rtnum,decode(bitand(rtsta,1),1,’OPEN’,'CLOSED’), decode(bitand(rtsta,6),0,’DISABLED’,2,’PRIVATE’,6,’PUBLIC’,'UNKNOWN’), rtnlf,tirsid,to_date(rtots,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), rtcln,rtseq, to_number(rtckp_scn), to_date(rtckp_tim,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(rtenb), to_date(rtets,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_number(rtdis), to_date(rtdit,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), cpodr_seq, cpodr_bno, to_number(cpods), to_date(cpodt,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’) from x$kccrt rt, x$kcctir tr, x$kcccp where rtnlf != 0 and tr.inst_id = rt.inst_id and tirnum = rtnum and cptno = rtnum |
| GV$THRESHOLD_TYPES | SELECT t.inst_id, mid_kelrtd, gid_kelrtd, opmask_kelrtd, typnam_keltosd, alrtid_kelrtd, valtype_kelrtd from x$kelrtd t, x$keltosd o where typid_keltosd = objtype_kelrtd |
| GV$TIMER | select inst_id,ksutmtim from x$ksutm |
| GV$TIMEZONE_FILE | select FILENAME, VERSION from X$TIMEZONE_FILE |
| GV$TIMEZONE_NAMES | select TZNAME, TZABBREV from X$TIMEZONE_NAMES |
| GV$TRANSACTION | select inst_id,ktcxbxba,kxidusn,kxidslt,kxidsqn,ktcxbkfn,kubablk, kubaseq,kubarec, decode(ktcxbsta,0,’IDLE’,1,’COLLECTING’,2,’PREPARED’,3,’COMMITTED’, 4,’HEURISTIC ABORT’,5,’HEURISTIC COMMIT’, 6,’HEURISTIC DAMAGE’,7,’TIMEOUT’,9,’INACTIVE’, 10,’ACTIVE’,11,’PTX PREPARED’,12,’PTX COMMITTED’, ‘UNKNOWN’), ktcxbstm,ktcxbssb,ktcxbssw, ktcxbsen,ktcxbsfl,ktcxbsbk,ktcxbssq,ktcxbsrc, ktcxbses,ktcxbflg, decode(bitand(ktcxbflg,16),0,’NO’,'YES’), decode(bitand(ktcxbflg,32),0,’NO’,'YES’), decode(bitand(ktcxbflg,64),0,’NO’,'YES’), decode(bitand(ktcxbflg,8388608),0,’NO’,'YES’), ktcxbnam, ktcxbpus,ktcxbpsl,ktcxbpsq, ktcxbpxu,ktcxbpxs,ktcxbpxq, ktcxbdsb, ktcxbdsw, ktcxbubk,ktcxburc,ktcxblio,ktcxbpio,ktcxbcrg,ktcxbcrc, to_date(ktcxbstm,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), ktcxbdsb, ktcxbdsw, ktcxbssc, ktcxbdsc, ktcxbxid, ktcxbpid, ktcxbpxi from x$ktcxb where bitand(ksspaflg,1)!=0 and bitand(ktcxbflg,2)!=0 |
| GV$TRANSACTION_ENQUEUE | select s.inst_id,l.ktcxbxba,l.ktcxblkp,s.ksusenum,r.ksqrsidt,r.ksqrsid1, r.ksqrsid2, l.ksqlkmod, l.ksqlkreq,l.ksqlkctim,l.ksqlklblk from x$ktcxb l,x$ksuse s,x$ksqrs r where l.ksqlkses=s.addr and bitand(l.ksspaflg,1)!=0 and (l.ksqlkmod!=0 or l.ksqlkreq!=0) and l.ksqlkres=r.addr |
| GV$TRANSPORTABLE_PLATFORM | SELECT INST_ID, PLATFORM_ID, PLATFORM_NAME, decode(endian_format, 1,’Big’ ,0,’Little’,'UNKNOWN FORMAT’) from x$kcpxpl |
| GV$TSM_SESSIONS | select inst_id, indx, ksusmser, decode(ksusmsta, 0, ‘NONE’, 1, ‘SELECTED’, 2, ‘COMMITED SELECT’, 3, ‘READY FOR PREPARE’, 4, ‘PREPARED’, 5, ‘READY FOR SWITCH’, 6, ‘SWITCHED’, 7, ‘FAILED’, 8, ‘READY FOR STATE TRANSFER’, 9, ‘IN STATE TRANSFER’, 10, ‘END OF STATE TRANSFER’, ‘UNKNOWN’), decode(bitand(ksusmflg, 1), 1, ‘NO’, decode(ksusmbnd, 0, decode(bitand(ksusmflg, 8), 8, ‘NO’, ‘YES’), ‘YES’)), decode(bitand(ksusmflg, 1), 1, ‘NO’, ‘YES’), decode(bitand(ksusmflg, 8), 8, ‘NO’, ‘YES’), decode(bitand(ksusmflg, 16), 16, ‘YES’, ‘NO’), ksusmnmr, ksusmnmi, ksusmntr, ksusmnti, decode(ksusmbnd, 0, ‘NEVER’, 1, ‘CALL’, 2, ‘TRANSACTION’, 3, ‘APPLICATION’, ‘UNKNOWN’), decode(bitand(ksusmflg, 4), 4, ‘YES’, ‘NO’), ksusmcst, ksusmdst, ksusmnrt, ksusmbcm, ksusmstm, ksusmseq from x$ksusm where (bitand(ksspaflg, 1) != 0) and (bitand(ksusmsfl, 1) != 0) |
| GV$TYPE_SIZE | select inst_id,kqfszcom,kqfsztyp,kqfszdsc,kqfszsiz from x$kqfsz |
| GV$UNDOSTAT | select inst_id, to_date(KTUSMSTRBEGTIME,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(KTUSMSTRENDTIME,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), KTUSMSTTSN, KTUSMSTUSU, KTUSMSTTCT, KTUSMSTMQL, KTUSMSTRMQI, KTUSMSTMTC, KTUSMSTUAC, KTUSMSTUBS, KTUSMSTUBR, KTUSMSTXAC, KTUSMSTXBS, KTUSMSTXBR, KTUSMSTSOC, KTUSMSTOOS, KTUSMSTABK, KTUSMSTUBK, KTUSMSTEBK, KTUSMSTTUR from X$KTUSMST |
| GV$VERSION | select inst_id, banner from x$version |
| GV$VPD_POLICY | select c.inst_id,c.kglhdadr,c.kglhdpar,c.kglnahsh, c.kglobt03, c.kglobt09, p.kzrtpdow,p.kzrtpdon,p.kzrtpdgp,p.kzrtpdpy,p.kzrtpdpo, p.kzrtpdtx from x$kglcursor_child c, x$kzrtpd p where c.kglhdpar = p.kzrtpdpa and c.kglhdadr = p.kzrtpdad |
| GV$WAITCLASSMETRIC | SELECT inst_id, begtime, endtime, intsize_csec, wait#, wait_id, average_waiter_count, dbtime_in_wait, time_waited, wait_count from x$kewmevmv where flag1 = 1 AND GROUPID = 1 |
| GV$WAITCLASSMETRIC_HISTORY | SELECT inst_id, begtime, endtime, intsize_csec, wait#, wait_id, average_waiter_count, dbtime_in_wait, time_waited, wait_count from x$kewmevmv where GROUPID = 1 |
| GV$WAITSTAT | select inst_id,decode(indx,1,’data block’,2,’sort block’,3,’save undo block’, 4,’segment header’,5,’save undo header’,6,’free list’,7,’extent map’, 8,’1st level bmb’,9,’2nd level bmb’,10,’3rd level bmb’, 11,’bitmap block’,12,’bitmap index block’,13,’file header block’,14,’unused’, 15,’system undo header’,16,’system undo block’, 17,’undo header’,18,’undo block’), count,time from x$kcbwait where indx!=0 |
| GV$WALLET | SELECT INST_ID, CERTID, CERTDN, CERTSERIAL, CERTISSUER, KEYSIZE, CERTSTATUS from X$KZEKMFVW |
| GV$XML_AUDIT_TRAIL | select INST_ID, AUDIT_TYPE, SESSION_ID, PROXY_SESSIONID, STATEMENTID, ENTRYID, EXTENDED_TIMESTAMP, GLOBAL_UID, DB_USER, CLIENTIDENTIFIER, EXT_NAME, OS_USER, OS_HOST, OS_PROCESS, TERMINAL, INSTANCE_NUMBER, OBJECT_SCHEMA, OBJECT_NAME, POLICY_NAME, NEW_OWNER, NEW_NAME, ACTION, STATEMENT_TYPE, TRANSACTIONID, RETURNCODE, SCN, COMMENT_TEXT, AUTH_PRIVILEGES, GRANTEE, PRIV_USED, SES_ACTIONS, OS_PRIVILEGE, ECONTEXT_ID, SQL_BIND, SQL_TEXT from X$XML_AUDIT_TRAIL |
| GV$_LOCK | select USERENV(‘Instance’),laddr,kaddr,saddr,raddr,lmode,request,ctime, block from v$_lock1 union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktadm where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktatrfil where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktatrfsl where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktatl where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktstusc where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktstuss where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktstusg where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,ktcxbxba,ktcxblkp,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim,ksqlklblk from x$ktcxb where bitand(ksspaflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) |
| GV$_LOCK1 | select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim, ksqlklblk from x$kdnssf where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) union all select inst_id,addr,ksqlkadr,ksqlkses,ksqlkres,ksqlkmod,ksqlkreq, ksqlkctim, ksqlklblk from x$ksqeq where bitand(kssobflg,1)!=0 and (ksqlkmod!=0 or ksqlkreq!=0) |
| GV$_RESUMABLE2 | select inst_id, ktrsfaddr, ktrsfsid, decode (bitand(ktrsfflg, 1), 0, ‘NO’, ‘YES’), decode (ktrsfsta, 0, ‘NORMAL’, 1, ‘SUSPENDED’, 2, ‘TIMEOUT’, 3, ‘ERROR’, 4, ‘ABORTED’, ”), ktrsftmo, ktrsfspt, ktrsfrst, ktrsfnam, ktrsferr, ktrsfep1, ktrsfep2, ktrsfep3, ktrsfep4, ktrsfep5, ktrsfems, ktrsfobj, ktrsftyp from x$ktrso |
| GV$_SEQUENCES | select inst_id, KGLNAOWN,KGLNAOBJ,KGLOBT08,decode(bitand(KGLOBT00,1),0,’N',’Y'),decode(bitand(KGLOBT00,2),0,’N',’Y'),decode(bitand(KGLOBT00,16),0,’N',’Y'),KGLOBTN0,KGLOBTN2,KGLOBTN3,KGLOBTN1,decode(bitand(KGLOBT09,1),0,’N',’Y'),decode(bitand(KGLOBT09,2),0,’N',’Y'),KGLOBTN4,KGLOBTN5,decode(KGLOBT10,1,’Y',’N'),decode(KGLOBT10,1,KGLOBT02,null)from X$KGLOB where KGLOBTYP = 6 and KGLOBT11 = 1 |
| O$SQL_BIND_CAPTURE | select ADDRESS, HASH_VALUE, SQL_ID, CHILD_ADDRESS, CHILD_NUMBER, NAME, POSITION, DUP_POSITION, DATATYPE, DATATYPE_STRING, CHARACTER_SID, PRECISION, SCALE, MAX_LENGTH, WAS_CAPTURED, LAST_CAPTURED, VALUE_STRING, VALUE_ANYDATA from go$sql_bind_capture where inst_id = USERENV(‘Instance’) |
| V$ACCESS | select SID , OWNER , OBJECT , TYPE from GV$ACCESS where inst_id = USERENV(‘Instance’) |
| V$ACTIVE_INSTANCES | select INST_NUMBER , INST_NAME from GV$ACTIVE_INSTANCES where inst_id = USERENV(‘Instance’) |
| V$ACTIVE_SERVICES | select SERVICE_ID, NAME, NAME_HASH, NETWORK_NAME, CREATION_DATE, CREATION_DATE_HASH, GOAL, DTP, BLOCKED, AQ_HA_NOTIFICATION, CLB_GOAL from GV$ACTIVE_SERVICES where inst_id = USERENV(‘Instance’) |
| V$ACTIVE_SESSION_HISTORY | SELECT sample_id, sample_time, session_id, session_serial#, user_id, sql_id, sql_child_number, sql_plan_hash_value, force_matching_signature, sql_opcode, service_hash, session_type, session_state, qc_session_id, qc_instance_id, blocking_session, blocking_session_status, blocking_session_serial#, event, event_id, event#, seq#, p1text, p1, p2text, p2, p3text, p3, wait_class, wait_class_id, wait_time, time_waited, xid, current_obj#, current_file#, current_block#, program, module, action, client_id from GV$ACTIVE_SESSION_HISTORY where inst_id = USERENV(‘INSTANCE’) |
| V$ACTIVE_SESS_POOL_MTH | select name from gv$active_sess_pool_mth where inst_id = userenv(‘instance’) |
| V$ADVISOR_PROGRESS | select SID, SERIAL#, USERNAME, OPNAME, ADVISOR_NAME, TASK_ID, TARGET_DESC, SOFAR, TOTALWORK, UNITS, BENEFIT_SOFAR, BENEFIT_MAX, FINDINGS, RECOMMENDATIONS, TIME_REMAINING, START_TIME, LAST_UPDATE_TIME, ELAPSED_SECONDS, ADVISOR_METRIC1, METRIC1_DESC from GV$ADVISOR_PROGRESS where inst_id = USERENV(‘Instance’) |
| V$ALERT_TYPES | SELECT reason_id, object_type, type, group_name, scope, internal_metric_category, internal_metric_name from gv$alert_types where inst_id = USERENV(‘INSTANCE’) |
| V$AQ1 | select QID , WAITING, READY, EXPIRED, TOTAL_CONSUMERS, TOTAL_WAIT, AVERAGE_WAIT from GV$AQ1 |
| V$ARCHIVE | select GROUP# , THREAD# , SEQUENCE# , ISCURRENT , “CURRENT” , FIRST_CHANGE# from GV$ARCHIVE where inst_id = USERENV(‘Instance’) |
| V$ARCHIVED_LOG | select RECID , STAMP , NAME , DEST_ID , THREAD# , SEQUENCE# , RESETLOGS_CHANGE# , RESETLOGS_TIME , RESETLOGS_ID , FIRST_CHANGE# , FIRST_TIME , NEXT_CHANGE# , NEXT_TIME , BLOCKS , BLOCK_SIZE , CREATOR, REGISTRAR , STANDBY_DEST , ARCHIVED , APPLIED , DELETED , STATUS , COMPLETION_TIME , DICTIONARY_BEGIN , DICTIONARY_END , END_OF_REDO, BACKUP_COUNT , ARCHIVAL_THREAD#, ACTIVATION#, IS_RECOVERY_DEST_FILE, COMPRESSED, FAL, END_OF_REDO_TYPE from GV$ARCHIVED_LOG where inst_id = USERENV(‘Instance’) |
| V$ARCHIVE_DEST | select DEST_ID,DEST_NAME, STATUS, BINDING, NAME_SPACE, TARGET, ARCHIVER, SCHEDULE, DESTINATION, LOG_SEQUENCE, REOPEN_SECS, DELAY_MINS, MAX_CONNECTIONS, NET_TIMEOUT, PROCESS, REGISTER, FAIL_DATE, FAIL_SEQUENCE, FAIL_BLOCK, FAILURE_COUNT, MAX_FAILURE, ERROR, ALTERNATE, DEPENDENCY, REMOTE_TEMPLATE, QUOTA_SIZE, QUOTA_USED, MOUNTID, TRANSMIT_MODE, ASYNC_BLOCKS, AFFIRM, TYPE, VALID_NOW, VALID_TYPE, VALID_ROLE, DB_UNIQUE_NAME, VERIFY from GV$ARCHIVE_DEST where inst_id = USERENV(‘Instance’) |
| V$ARCHIVE_DEST_STATUS | select DEST_ID,DEST_NAME, STATUS, TYPE, DATABASE_MODE, RECOVERY_MODE, PROTECTION_MODE, DESTINATION, STANDBY_LOGFILE_COUNT, STANDBY_LOGFILE_ACTIVE, ARCHIVED_THREAD#, ARCHIVED_SEQ#, APPLIED_THREAD#, APPLIED_SEQ#, ERROR, SRL, DB_UNIQUE_NAME, SYNCHRONIZATION_STATUS, SYNCHRONIZED from GV$ARCHIVE_DEST_STATUS where inst_id = USERENV(‘Instance’) |
| V$ARCHIVE_GAP | select THREAD# , LOW_SEQUENCE# , HIGH_SEQUENCE# from GV$ARCHIVE_GAP where inst_id = USERENV(‘Instance’) |
| V$ARCHIVE_PROCESSES | select PROCESS, STATUS, LOG_SEQUENCE, STATE from GV$ARCHIVE_PROCESSES where inst_id = USERENV(‘Instance’) |
| V$ASM_ALIAS | select name, group_number, file_number, file_incarnation, alias_index, alias_incarnation, parent_index, reference_index, alias_directory, system_created from gv$asm_alias where inst_id = USERENV(‘Instance’) |
| V$ASM_CLIENT | select group_number, instance_name, db_name, status, software_version, compatible_version from gv$asm_client where inst_id = USERENV(‘Instance’) |
| V$ASM_DISK | select group_number, disk_number, compound_index, incarnation, mount_status, header_status, mode_status, state, redundancy, library, total_mb, free_mb, name, failgroup, label, path, udid, product, create_date, mount_date, repair_timer, reads, writes, read_errs, write_errs, read_time, write_time, bytes_read, bytes_written from gv$asm_disk where inst_id = USERENV(‘Instance’) |
| V$ASM_DISKGROUP | select group_number, name, sector_size, block_size, allocation_unit_size, state, type, total_mb, free_mb, required_mirror_free_mb, usable_file_mb, offline_disks, unbalanced, compatibility, database_compatibility from gv$asm_diskgroup where inst_id = USERENV(‘Instance’) |
| V$ASM_DISKGROUP_STAT | select group_number, name, sector_size, block_size, allocation_unit_size, state, type, total_mb, free_mb, required_mirror_free_mb, usable_file_mb, offline_disks, unbalanced, compatibility, database_compatibility from gv$asm_diskgroup_stat where inst_id = USERENV(‘Instance’) |
| V$ASM_DISK_STAT | select group_number, disk_number, compound_index, incarnation, mount_status, header_status, mode_status, state, redundancy, library, total_mb, free_mb, name, failgroup, label, path, udid, product, create_date, mount_date, repair_timer, reads, writes, read_errs, write_errs, read_time, write_time, bytes_read, bytes_written from gv$asm_disk_stat where inst_id = USERENV(‘Instance’) |
| V$ASM_FILE | select group_number, file_number, compound_index, incarnation, block_size, blocks, bytes, space, type, redundancy, striped, creation_date, modification_date, redundancy_lowered from gv$asm_file where inst_id = USERENV(‘Instance’) |
| V$ASM_OPERATION | select group_number, operation, state, power, actual, sofar, est_work, est_rate, est_minutes from gv$asm_operation where inst_id = USERENV(‘Instance’) |
| V$ASM_TEMPLATE | select group_number, entry_number, redundancy, stripe, system, name from gv$asm_template where inst_id = USERENV(‘Instance’) |
| V$AW_AGGREGATE_OP | select name_xsagopft as name, desc_xsagopft as longname, case when weight_xsagopft >= 0 then weight_xsagopft else null end as default_weight from x$xsagop where not bitand(flags_xsagopft, 32) = 0 |
| V$AW_ALLOCATE_OP | select name_xsagopft as name, desc_xsagopft as longname from x$xsagop where not bitand(flags_xsagopft, 64) = 0 |
| V$AW_CALC | select SESSION_ID, AGGREGATE_CACHE_HITS, AGGREGATE_CACHE_MISSES, SESSION_CACHE_HITS, SESSION_CACHE_MISSES, POOL_HITS, POOL_MISSES, POOL_NEW_PAGES, POOL_RECLAIMED_PAGES, CACHE_WRITES, POOL_SIZE, CURR_DML_COMMAND, PREV_DML_COMMAND, AGGR_FUNC_LOGICAL_NA, AGGR_FUNC_PRECOMPUTE, AGGR_FUNC_CALCS from gv$aw_calc where inst_id = USERENV(‘Instance’) |
| V$AW_LONGOPS | select SESSION_ID, CURSOR_NAME, COMMAND, STATUS, ROWS_PROCESSED, START_TIME from gv$aw_longops where inst_id = USERENV(‘Instance’) |
| V$AW_OLAP | select session_id, aw_number, attach_mode, generation, temp_space_pages, temp_space_reads, lob_reads, pool_changed_pages, pool_unchanged_pages from gv$aw_olap where inst_id = USERENV(‘Instance’) |
| V$AW_SESSION_INFO | select SESSION_ID, CLIENT_TYPE, SESSION_STATE, SESSION_HANDLE, USERID, TOTAL_TRANSACTION, TRANSACTION_TIME, TOTAL_TRANSACTION_TIME, AVERAGE_TRANSACTION_TIME, TRANSACTION_CPU_TIME, TOTAL_TRANSACTION_CPU_TIME, AVERAGE_TRANSACTION_CPU_TIME from gv$aw_session_info where inst_id = USERENV(‘Instance’) |
| V$BACKUP | select FILE# , STATUS , CHANGE# , TIME from GV$BACKUP where inst_id = USERENV(‘Instance’) |
| V$BACKUP_ARCHIVELOG_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(filesize) filesize_display from (select unique ‘BACKUPSET’ btype, b.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.set_stamp id1, b.set_count id2, thread#, sequence#, resetlogs_change#, resetlogs_time, first_change#, first_time, next_change#, next_time, (blocks+1)*a.block_size filesize, case when b.compression_ratio>1 then b.compression_ratio else 1 end compression_ratio from v$backup_redolog a, v$backup_set_details b where a.set_stamp = b.set_stamp and a.set_count = b.set_count union select unique ‘PROXYCOPY’, a.recid btype_key, session_recid session_key, session_recid, session_stamp, a.recid, a.stamp, thread#, sequence#, resetlogs_change#, resetlogs_time, first_change#, first_time, next_change#, next_time, (blocks+1)*block_size filesize, 1 from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))a |
| V$BACKUP_ARCHIVELOG_SUMMARY | select a.*, case when input_bytes/decode(output_bytes, 0, null, output_bytes) > 1 then input_bytes/decode(output_bytes, 0, null, output_bytes) else 1 end compression_ratio, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select sum(num_files_backed) num_files_backed, sum(distinct_files_backed) distinct_files_backed, min(min_first_change#) min_first_change#, max(max_next_change#) max_next_change#, min(min_first_time) min_first_time, max(max_next_time) max_next_time, sum(original_input_bytes) input_bytes, sum(output_bytes) output_bytes from ((select num_files_backed, distinct_files_backed, min_first_change#, max_next_change#, min_first_time, max_next_time, original_input_bytes, output_bytes from (select count(*) num_files_backed, min(first_change#)min_first_change#, max(next_change#) max_next_change#, min(first_time)min_first_time, max(next_time) max_next_time from v$backup_redolog where (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details)),(select count(*) distinct_files_backed from (select unique thread#, sequence#,resetlogs_change#, resetlogs_time from v$backup_redolog where (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details))), (select nvl(sum(original_input_bytes),0) original_input_bytes, nvl(sum(output_bytes), 0) output_bytes from (select unique set_count, set_stamp, original_input_bytes, output_bytes from v$backup_set_details where backup_type=’L'))) union (select num_files_backed, distinct_files_backed, min_first_change#, max_next_change#, min_first_time, max_next_time, original_input_bytes, output_bytes from (select count(*) num_files_backed, min(first_change#)min_first_change#, max(next_change#) max_next_change#, min(first_time)min_first_time, max(next_time) max_next_time, nvl(sum((blocks+1)*block_size),0) original_input_bytes, nvl(sum((blocks+1)*block_size),0) output_bytes from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)), (select count(*) distinct_files_backed from (select unique thread#, sequence#, resetlogs_change#,resetlogs_time from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))))))a |
| V$BACKUP_ASYNC_IO | select SID, SERIAL, USE_COUNT, RMAN_STATUS_RECID, RMAN_STATUS_STAMP,DEVICE_TYPE, TYPE, STATUS,FILENAME, SET_COUNT, SET_STAMP, BUFFER_SIZE, BUFFER_COUNT, TOTAL_BYTES, OPEN_TIME, CLOSE_TIME, ELAPSED_TIME, MAXOPENFILES, BYTES, EFFECTIVE_BYTES_PER_SECOND, IO_COUNT, READY, SHORT_WAITS, SHORT_WAIT_TIME_TOTAL, SHORT_WAIT_TIME_MAX, LONG_WAITS, LONG_WAIT_TIME_TOTAL, LONG_WAIT_TIME_MAX from gv$backup_async_io where inst_id = userenv(‘Instance’) |
| V$BACKUP_CONTROLFILE_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(filesize) filesize_display from (select unique ‘BACKUPSET’ btype, b.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.set_stamp id1, b.set_count id2, creation_time, resetlogs_change#,resetlogs_time,checkpoint_change#,checkpoint_time, (datafile_blocks+1)*a.block_size filesize, 1 compression_ratio from v$backup_datafile a, v$backup_set_details b where a.set_stamp = b.set_stamp and a.set_count = b.set_count and file# = 0 union select unique ‘IMAGECOPY’ btype, a.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.recid, a.stamp, creation_time, resetlogs_change#,resetlogs_time,checkpoint_change#,checkpoint_time, (blocks+1)*block_size filesize, 1 compression_ratio from v$datafile_copy a, v$rman_status b , (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file# = 0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)union select unique ‘PROXYCOPY’ btype, a.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.recid, a.stamp, creation_time, resetlogs_change#,resetlogs_time,checkpoint_change#,checkpoint_time, (blocks+1)*block_size filesize, 1 compression_ratio from v$proxy_datafile a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file# = 0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))a |
| V$BACKUP_CONTROLFILE_SUMMARY | select a.*, case when input_bytes/decode(output_bytes, 0, null, output_bytes) > 1 then input_bytes/decode(output_bytes, 0, null, output_bytes) else 1 end compression_ratio, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select sum(num_times_backed) num_files_backed, 1 num_distinct_files_backed, min(min_checkpoint_change#) min_checkpoint_change#, max(max_checkpoint_change#) max_checkpoint_change#, min(min_checkpoint_time) min_checkpoint_time, max(max_checkpoint_time) max_checkpoint_time, sum(input_bytes) input_bytes, sum(output_bytes) output_bytes from ((select unique count(*) over (partition by creation_time) num_times_backed, min(checkpoint_change#) over (partition by creation_time) min_checkpoint_change#, max(checkpoint_change#) over (partition by creation_time) max_checkpoint_change#, min(checkpoint_time) over (partition by creation_time) min_checkpoint_time, max(checkpoint_time) over (partition by creation_time) max_checkpoint_time, sum((datafile_blocks+1)*block_size) over (partition by creation_time) input_bytes, sum((blocks+1)*block_size) over (partition by creation_time) output_bytes, creation_time from v$backup_datafile where file# = 0 and (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details) ) union (select unique count(*) over (partition by creation_time) num_times_backed, min(checkpoint_change#) over (partition by creation_time) min_checkpoint_change#, max(checkpoint_change#) over (partition by creation_time) max_checkpoint_change#, min(checkpoint_time) over (partition by creation_time) min_checkpoint_time, max(checkpoint_time) over (partition by creation_time) max_checkpoint_time, sum((blocks+1)*block_size) over (partition by creation_time) input_bytes, sum((blocks+1)*block_size) over (partition by creation_time) output_bytes, creation_time from v$datafile_copy a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file# = 0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time) ) union (select unique count(*) over (partition by creation_time) num_times_backed, min(checkpoint_change#) over (partition by creation_time) min_checkpoint_change#, max(checkpoint_change#) over (partition by creation_time) max_checkpoint_change#, min(checkpoint_time) over (partition by creation_time) min_checkpoint_time, max(checkpoint_time) over (partition by creation_time) max_checkpoint_time, sum((blocks+1)*block_size) over (partition by creation_time) input_bytes, sum((blocks+1)*block_size) over (partition by creation_time) output_bytes, creation_time from v$proxy_datafile a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dua |
| V$BACKUP_COPY_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select b.session_recid session_key, b.session_recid, b.session_stamp, a.recid copy_key, a.file#, a.name, a.tag, a.creation_change#, a.creation_time, a.checkpoint_change#, a.checkpoint_time, a.marked_corrupt, (a.blocks+1)*a.block_size output_bytes, a.completion_time, a.controlfile_type, keep, keep_until, keep_options, is_recovery_dest_file from v$datafile_copy a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))a |
| V$BACKUP_COPY_SUMMARY | select a.*, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select nvl(sum(num_times_backed),0) num_copies, sum(distinct_copies) distinct_copies, min(min_checkpoint_change#) min_checkpoint_change#, max(max_checkpoint_change#) max_checkpoint_change#, min(min_checkpoint_time) min_checkpoint_time, max(max_checkpoint_time) max_checkpoint_time, sum(output_bytes) output_bytes from (select unique file#,count(*) over (partition by file#, creation_change#) num_times_backed, count(distinct file#) over (partition by file#, creation_change#,checkpoint_change#) distinct_copies, min(checkpoint_change#) over (partition by file#, creation_change#) min_checkpoint_change#, max(checkpoint_change#) over (partition by file#, creation_change#) max_checkpoint_change#, min(checkpoint_time) over (partition by file#, creation_change#) min_checkpoint_time, max(checkpoint_time) over (partition by file#, creation_change#) max_checkpoint_time, sum((blocks+1)*block_size) over (partition by file#, creation_change#) output_bytes from v$datafile_copy a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)))a |
| V$BACKUP_CORRUPTION | select RECID , STAMP , SET_STAMP , SET_COUNT , PIECE# , FILE# , BLOCK# , BLOCKS , CORRUPTION_CHANGE# , MARKED_CORRUPT, CORRUPTION_TYPE from GV$BACKUP_CORRUPTION where inst_id = USERENV(‘Instance’) |
| V$BACKUP_DATAFILE | select RECID , STAMP , SET_STAMP , SET_COUNT , FILE# , CREATION_CHANGE# , CREATION_TIME , RESETLOGS_CHANGE# , RESETLOGS_TIME , INCREMENTAL_LEVEL , INCREMENTAL_CHANGE# , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ABSOLUTE_FUZZY_CHANGE# , MARKED_CORRUPT , MEDIA_CORRUPT , LOGICALLY_CORRUPT , DATAFILE_BLOCKS , BLOCKS , BLOCK_SIZE, OLDEST_OFFLINE_RANGE, COMPLETION_TIME ,CONTROLFILE_TYPE, USED_CHANGE_TRACKING, BLOCKS_READ, USED_OPTIMIZATION from GV$BACKUP_DATAFILE where inst_id = USERENV(‘Instance’) |
| V$BACKUP_DATAFILE_DETAILS | select a.*, b.ts#, b.name tsname, sys.dbms_rcvman.num2displaysize(filesize) filesize_display from (select unique ‘BACKUPSET’ btype, b.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.set_stamp id1, b.set_count id2, file#, creation_change#, creation_time, resetlogs_change#, resetlogs_time, a.incremental_level, incremental_change#, checkpoint_change#, checkpoint_time, marked_corrupt, (datafile_blocks+1)*a.block_size filesize, (datafile_blocks+1)/(blocks+1) from v$backup_datafile a, v$backup_set_details b where a.set_stamp = b.set_stamp and a.set_count = b.set_count and file#<>0 union select unique ‘IMAGECOPY’ btype, a.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.recid, a.stamp, file#, creation_change#, creation_time, resetlogs_change#, resetlogs_time, incremental_level, 0 incremental_change#, checkpoint_change#, checkpoint_time, marked_corrupt, (blocks+1)*block_size filesize, 1 compression_ratio from v$datafile_copy a, v$rman_status b , (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file#<>0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)union select unique ‘PROXYCOPY’ btype, a.recid btype_key, b.session_recid session_key, b.session_recid, b.session_stamp, a.recid, a.stamp, file#, creation_change#, creation_time, resetlogs_change#, resetlogs_time, incremental_level, 0 incremental_change#, checkpoint_change#, checkpoint_time, null marked_corrupt, (blocks+1)*block_size filesize, 1 compression_ratio from v$proxy_datafile a, v$rman_status b , (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file#<>0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)) a, (select df.file#, df.ts#, ts.name from v$datafile df, v$tablespace ts where ts.ts# = df.ts#) b where a.file# = b.file#(+) |
| V$BACKUP_DATAFILE_SUMMARY | select a.*, case when input_bytes/decode(output_bytes, 0, null, output_bytes) > 1 then input_bytes/decode(output_bytes, 0, null, output_bytes) else 1 end compression_ratio, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select sum(num_times_backed) num_files_backed, count(*) num_distinct_files_backed, count(distinct ts#) num_distinct_ts_backed, min(min_checkpoint_change#) min_checkpoint_change#, max(max_checkpoint_change#) max_checkpoint_change#, min(min_checkpoint_time) min_checkpoint_time, max(max_checkpoint_time) max_checkpoint_time, sum(input_bytes) input_bytes, sum(output_bytes) output_bytes from (select a.*, b.ts# from (select unique a.file#, sum(a.num_times_backed) num_times_backed, min(min_checkpoint_change#) min_checkpoint_change#, max(max_checkpoint_change#) max_checkpoint_change#, min(min_checkpoint_time) min_checkpoint_time, max(max_checkpoint_time) max_checkpoint_time, sum(input_bytes) input_bytes, sum(output_bytes) output_bytes, creation_change# from ((select unique file#,count(*) over (partition by file#, creation_change#) num_times_backed, min(checkpoint_change#) over (partition by file#, creation_change#) min_checkpoint_change#, max(checkpoint_change#) over (partition by file#, creation_change#) max_checkpoint_change#, min(checkpoint_time) over (partition by file#, creation_change#) min_checkpoint_time, max(checkpoint_time) over (partition by file#, creation_change#) max_checkpoint_time, sum((datafile_blocks+1)*block_size) over (partition by file#, creation_change#) input_bytes, sum((blocks+1)*block_size) over (partition by file#, creation_change#) output_bytes, creation_change# from v$backup_datafile where file# <> 0 and (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details) ) union (select unique file#, count(*) over (partition by file#,creation_change#) num_times_backed, min(checkpoint_change#) over (partition by file#, creation_change#) min_checkpoint_change#, max(checkpoint_change#) over (partition by file#, creation_change#) max_checkpoint_change#, min(checkpoint_time) over (partition by file#, creation_change#) min_checkpoint_time, max(checkpoint_time) over (partition by file#, creation_change#) max_checkpoint_time, sum((blocks+1)*block_size) over (partition by file#, creation_change#) input_bytes, sum((blocks+1)*block_size) over (partition by file#, creation_change#) output_bytes, creation_change# from v$datafile_copy a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.file# <> 0 and a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time) ) union (select unique file#, count(*) over (partition by file#,creation_change#) num_times_backed, min(checkpoint_change#) over (partition by file#, creation_change#) min_checkpoint_change#, max(checkpoint_change#) over (partition by file#, creation_change#) max_checkpoint_change#, min(chec |
| V$BACKUP_DEVICE | select DEVICE_TYPE, DEVICE_NAME from GV$BACKUP_DEVICE where INST_ID = USERENV(‘Instance’) |
| V$BACKUP_PIECE | select RECID , STAMP ,SET_STAMP , SET_COUNT , PIECE# , COPY#, DEVICE_TYPE , HANDLE , COMMENTS , MEDIA , MEDIA_POOL , CONCUR , TAG , STATUS , START_TIME , COMPLETION_TIME , ELAPSED_SECONDS, DELETED, BYTES, IS_RECOVERY_DEST_FILE, RMAN_STATUS_RECID, RMAN_STATUS_STAMP, COMPRESSED from GV$BACKUP_PIECE where inst_id = USERENV(‘Instance’) |
| V$BACKUP_PIECE_DETAILS | select unique b.session_recid session_key, b.session_recid, b.session_stamp, a.*, sys.dbms_rcvman.num2displaysize(bytes) size_bytes_display from (select a.recid bs_key, c.recid bp_key, c.* from v$backup_set a, (select v$backup_piece.*, count(piece#) over (partition by set_count, set_stamp, copy#) pieces_per_set from v$backup_piece where status = ‘A’) c where a.set_stamp = c.set_stamp and a.set_count = c.set_count and a.pieces = c.pieces_per_set) a, (select session_recid, session_stamp, recid, stamp, start_time, end_time from v$rman_status) b , (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time) |
| V$BACKUP_REDOLOG | select RECID , STAMP , SET_STAMP , SET_COUNT , THREAD# , SEQUENCE# , RESETLOGS_CHANGE# , RESETLOGS_TIME , FIRST_CHANGE# , FIRST_TIME , NEXT_CHANGE# , NEXT_TIME , BLOCKS , BLOCK_SIZE from GV$BACKUP_REDOLOG where inst_id = USERENV(‘Instance’) |
| V$BACKUP_SET | select RECID , STAMP , SET_STAMP , SET_COUNT , BACKUP_TYPE , CONTROLFILE_INCLUDED , INCREMENTAL_LEVEL , PIECES , START_TIME , COMPLETION_TIME , ELAPSED_SECONDS , BLOCK_SIZE , INPUT_FILE_SCAN_ONLY, KEEP, KEEP_UNTIL, KEEP_OPTIONS from GV$BACKUP_SET where inst_id = USERENV(‘Instance’) |
| V$BACKUP_SET_DETAILS | select unique b.session_recid session_key, b.session_recid, b.session_stamp, a.recid bs_key, a.RECID, a.stamp, a.set_stamp, a.set_count, a.backup_type, a.controlfile_included, a.incremental_level, a.pieces, a.start_time, a.completion_time, a.elapsed_seconds, a.block_size, a.keep, a.keep_until, a.keep_options, a.device_type, a.compressed, a.num_copies, a.output_bytes, a.original_input_bytes, case when a.compression_ratio > 1 then a.compression_ratio else 1 end, ‘A’ status, a.original_inprate_bytes, a.output_rate_bytes, sys.dbms_rcvman.num2displaysize(original_input_bytes) original_input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display , sys.dbms_rcvman.num2displaysize(original_inprate_bytes) original_inprate_bytes_display, sys.dbms_rcvman.num2displaysize(output_rate_bytes) output_rate_bytes_display, sys.dbms_rcvman.sec2displaytime(elapsed_seconds) time_taken_display from ( select unique a.*, b.rman_status_recid, b.rman_status_stamp, decode(b.devcnt, 1, first_value(b.device_type) over (partition by b.set_stamp, b.set_count), ‘*’) device_type, b.compressed, count(distinct copy#) over (partition by b.set_stamp, b.set_count) num_copies, b.output_bytes output_bytes, c.original_input_bytes, c.original_input_bytes / (decode(b.output_bytes,0,c.original_input_bytes,b.output_bytes)) compression_ratio, c.original_input_bytes/ (decode(a.elapsed_seconds, 0, 1, a.elapsed_seconds)) original_inprate_bytes, b.output_bytes/ (decode(a.elapsed_seconds, 0, 1, a.elapsed_seconds)) output_rate_bytes from v$backup_set a, (select set_stamp, set_count, device_type, status, count(distinct device_type) over (partition by set_count,set_stamp)devcnt, compressed, sum(bytes) over (partition by set_count, set_stamp, copy#) output_bytes, copy#, RMAN_STATUS_RECID, RMAN_STATUS_STAMP, count(piece#) over (partition by set_count, set_stamp, copy#) npieces from v$backup_piece where status = ‘A’) b, ( select set_stamp, set_count, sum(original_input_bytes) original_input_bytes from ( select set_stamp, set_count, sum((datafile_blocks+1)*block_size) over (partition by set_count, set_stamp) original_input_bytes from v$backup_datafile union select set_stamp, set_count, sum(bytes) over (partition by set_count, set_stamp) original_input_bytes from v$backup_spfile ) group by set_stamp, set_count union select set_stamp, set_count, sum((blocks+1)*block_size) over (partition by set_count, set_stamp) original_input_bytes from v$backup_redolog ) c where a.set_stamp=b.set_stamp and a.set_stamp=b.set_stamp and a.set_stamp=c.set_stamp and a.set_stamp=c.set_stamp and a.pieces=b.npieces ) a, (select session_recid, session_stamp, recid, stamp, start_time, end_time from v$rman_status) b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time) |
| V$BACKUP_SET_SUMMARY | select a.*, case when original_input_bytes/decode(output_bytes, 0, null, output_bytes) > 1 then original_input_bytes/decode(output_bytes, 0, null, output_bytes) else 1 end compression_ratio, sys.dbms_rcvman.num2displaysize(original_input_bytes) original_input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display , sys.dbms_rcvman.num2displaysize(original_inprate_bytes) original_inprate_bytes_display, sys.dbms_rcvman.num2displaysize(output_rate_bytes) output_rate_bytes_display from (select count(*) num_backupsets, min(start_time) oldest_backup_time, max(start_time) newest_backup_time, sum(output_bytes) output_bytes, sum(original_input_bytes) original_input_bytes, avg(original_inprate_bytes) original_inprate_bytes, avg(output_rate_bytes) output_rate_bytes from (select unique set_stamp, set_count, start_time, output_bytes, original_input_bytes, original_inprate_bytes, output_rate_bytes, compression_ratio from v$backup_set_details))a |
| V$BACKUP_SPFILE | select RECID , STAMP , SET_STAMP , SET_COUNT , MODIFICATION_TIME, BYTES , COMPLETION_TIME from GV$BACKUP_SPFILE where inst_id = USERENV(‘Instance’) |
| V$BACKUP_SPFILE_DETAILS | select unique b.session_recid session_key, b.session_recid, b.session_stamp, b.recid bs_key, a.set_stamp, b.set_count, modification_time, a.bytes, sys.dbms_rcvman.num2displaysize(a.bytes) filesize_display from v$backup_spfile a, v$backup_set_details b where a.set_stamp = b.set_stamp and a.set_count = b.set_count |
| V$BACKUP_SPFILE_SUMMARY | select num_files_backed, num_distinct_files_backed, min_modification_time, max_modification_time, input_bytes, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display from (select count(*) num_files_backed, min(modification_time)min_modification_time, max(modification_time) max_modification_time, sum(bytes) input_bytes from v$backup_spfile where (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details)), (select count(*) num_distinct_files_backed from (select unique modification_time from v$backup_spfile where (set_stamp, set_count) in (select set_stamp, set_count from v$backup_set_details))) |
| V$BACKUP_SYNC_IO | select SID, SERIAL, USE_COUNT, RMAN_STATUS_RECID, RMAN_STATUS_STAMP,DEVICE_TYPE, TYPE, STATUS, FILENAME, SET_COUNT, SET_STAMP, BUFFER_SIZE, BUFFER_COUNT, TOTAL_BYTES, OPEN_TIME, CLOSE_TIME, ELAPSED_TIME, MAXOPENFILES, BYTES, EFFECTIVE_BYTES_PER_SECOND, IO_COUNT, IO_TIME_TOTAL, IO_TIME_MAX, DISCRETE_BYTES_PER_SECOND from gv$backup_sync_io where inst_id = userenv(‘Instance’) |
| V$BGPROCESS | select paddr,pserial#,name,description,error from gv$bgprocess where inst_id = USERENV(‘Instance’) |
| V$BH | select file#, block#, class#, status, xnc, forced_reads, forced_writes, lock_element_addr, lock_element_name, lock_element_class, dirty, temp, ping, stale, direct, new, objd, ts# from gv$bh where inst_id = USERENV(‘Instance’) |
| V$BLOCKING_QUIESCE | select sid from gv$blocking_quiesce where inst_id = userenv(‘instance’) |
| V$BLOCK_CHANGE_TRACKING | select decode(di2ctst, 0, ‘DISABLED’, 1, ‘TRANSITION’, 2, ‘ENABLED’,'ERROR’),fnnam, fh.bytes from x$kccdi2, x$kccfn, (select max(fhfsz*fhbsz) bytes from x$krcfh) fh where fnnum(+)=di2ctfn and fntyp(+)=200 |
| V$BSP | select cr_requests, current_requests, data_requests, undo_requests, tx_requests, current_results, private_results, zero_results, disk_read_results, fail_results, fairness_down_converts, fairness_clears, free_lock_elements, flushes, flushes_queued, flush_queue_full, flush_max_time, light_works, errors from gv$bsp where inst_id = USERENV(‘Instance’) |
| V$BUFFERED_PUBLISHERS | select queue_id, queue_schema, queue_name, sender_name, sender_address, sender_protocol, num_msgs, cnum_msgs, last_enqueued_msg, unbrowsed_msgs, overspilled_msgs, memory_usage, publisher_state from gv$buffered_publishers where inst_id = USERENV(‘Instance’) |
| V$BUFFERED_QUEUES | select queue_id, queue_schema, queue_name, startup_time, num_msgs, spill_msgs, cnum_msgs, cspill_msgs, expired_msgs from gv$buffered_queues where inst_id = USERENV(‘Instance’) |
| V$BUFFERED_SUBSCRIBERS | select queue_id, queue_schema, queue_name, subscriber_id, subscriber_name, subscriber_address, protocol, subscriber_type, startup_time, last_browsed_seq, last_browsed_num, last_dequeued_seq, last_dequeued_num, current_enq_seq, num_msgs, cnum_msgs, total_dequeued_msg, total_spilled_msg, expired_msgs from gv$buffered_subscribers where inst_id = USERENV(‘Instance’) |
| V$BUFFER_POOL | select id, name, block_size, resize_state, current_size, buffers, target_size, target_buffers, prev_size, prev_buffers, lo_bnum, hi_bnum, lo_setid, hi_setid, set_count from gv$buffer_pool where inst_id = USERENV(‘Instance’) |
| V$BUFFER_POOL_STATISTICS | select id, name, block_size, set_msize, cnum_repl, cnum_write, cnum_set, buf_got, sum_write, sum_scan, free_buffer_wait, write_complete_wait, buffer_busy_wait, free_buffer_inspected, dirty_buffers_inspected, db_block_change, db_block_gets, consistent_gets, physical_reads, physical_writes from gv$buffer_pool_statistics where inst_id = USERENV(‘Instance’) |
| V$CIRCUIT | select CIRCUIT , DISPATCHER , SERVER , WAITER , SADDR , STATUS , QUEUE , MESSAGE0 , MESSAGE1 , MESSAGE2, MESSAGE3, MESSAGES , BYTES , BREAKS , PRESENTATION, PCIRCUIT from GV$CIRCUIT where inst_id = USERENV(‘Instance’) |
| V$CLASS_CACHE_TRANSFER | select class, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, s_2_null, s_2_null_forced_stale, null_2_x, s_2_x, null_2_s, cr_transfer, current_transfer from gv$class_cache_transfer where inst_id = USERENV(‘Instance’) |
| V$CLASS_PING | select class, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, x_2_ssx, x_2_ssx_forced_write, s_2_null, s_2_null_forced_stale, ss_2_null, ss_2_rls, op_2_ss, null_2_x, s_2_x, ssx_2_x, null_2_s, null_2_ss from gv$class_ping where inst_id = USERENV(‘Instance’) |
| V$CLIENT_STATS | select CLIENT_IDENTIFIER , STAT_ID , STAT_NAME , VALUE from GV$CLIENT_STATS where inst_id = USERENV(‘Instance’) |
| V$CLUSTER_INTERCONNECTS | SELECT NAME, IP_ADDRESS, IS_PUBLIC, SOURCE from GV$CLUSTER_INTERCONNECTS where INST_ID=USERENV(‘Instance’) |
| V$CONFIGURED_INTERCONNECTS | SELECT NAME, IP_ADDRESS, IS_PUBLIC, SOURCE from GV$CONFIGURED_INTERCONNECTS where INST_ID=USERENV(‘Instance’) |
| V$CONTEXT | select namespace, attribute, value from x$context |
| V$CONTROLFILE | select STATUS , NAME, IS_RECOVERY_DEST_FILE, BLOCK_SIZE, FILE_SIZE_BLKS from GV$CONTROLFILE where inst_id = USERENV(‘Instance’) |
| V$CONTROLFILE_RECORD_SECTION | select TYPE , RECORD_SIZE , RECORDS_TOTAL , RECORDS_USED , FIRST_INDEX , LAST_INDEX , LAST_RECID from GV$CONTROLFILE_RECORD_SECTION where inst_id = USERENV(‘Instance’) |
| V$COPY_CORRUPTION | select RECID , STAMP , COPY_RECID , COPY_STAMP , FILE# , BLOCK# , BLOCKS , CORRUPTION_CHANGE# , MARKED_CORRUPT, CORRUPTION_TYPE from GV$COPY_CORRUPTION where inst_id = USERENV(‘Instance’) |
| V$CR_BLOCK_SERVER | select cr_requests, current_requests, data_requests, undo_requests, tx_requests, current_results, private_results, zero_results, disk_read_results, fail_results, fairness_down_converts, fairness_clears, free_gc_elements, flushes, flushes_queued, flush_queue_full, flush_max_time, light_works, errors from gv$cr_block_server where inst_id = USERENV(‘Instance’) |
| V$CURRENT_BLOCK_SERVER | select pin1, pin10, pin100, pin1000, pin10000, flush1, flush10, flush100, flush1000, flush10000, write1, write10, write100, write1000, write10000 from gv$current_block_server where inst_id = USERENV(‘Instance’) |
| V$DATABASE | select DBID, NAME, CREATED, RESETLOGS_CHANGE#, RESETLOGS_TIME, PRIOR_RESETLOGS_CHANGE#, PRIOR_RESETLOGS_TIME,LOG_MODE, CHECKPOINT_CHANGE#, ARCHIVE_CHANGE#, CONTROLFILE_TYPE, CONTROLFILE_CREATED, CONTROLFILE_SEQUENCE#, CONTROLFILE_CHANGE#, CONTROLFILE_TIME, OPEN_RESETLOGS, VERSION_TIME, OPEN_MODE, PROTECTION_MODE, PROTECTION_LEVEL, REMOTE_ARCHIVE, ACTIVATION#, SWITCHOVER#, DATABASE_ROLE, ARCHIVELOG_CHANGE#, ARCHIVELOG_COMPRESSION, SWITCHOVER_STATUS, DATAGUARD_BROKER, GUARD_STATUS, SUPPLEMENTAL_LOG_DATA_MIN, SUPPLEMENTAL_LOG_DATA_PK, SUPPLEMENTAL_LOG_DATA_UI, FORCE_LOGGING, PLATFORM_ID, PLATFORM_NAME, RECOVERY_TARGET_INCARNATION#, LAST_OPEN_INCARNATION#, CURRENT_SCN, FLASHBACK_ON,SUPPLEMENTAL_LOG_DATA_FK, SUPPLEMENTAL_LOG_DATA_ALL, DB_UNIQUE_NAME, STANDBY_BECAME_PRIMARY_SCN, FS_FAILOVER_STATUS, FS_FAILOVER_CURRENT_TARGET, FS_FAILOVER_THRESHOLD, FS_FAILOVER_OBSERVER_PRESENT, FS_FAILOVER_OBSERVER_HOST from GV$DATABASE where inst_id = USERENV(‘Instance’) |
| V$DATABASE_BLOCK_CORRUPTION | select FILE#, BLOCK#, BLOCKS, CORRUPTION_CHANGE#, CORRUPTION_TYPE from GV$DATABASE_BLOCK_CORRUPTION where inst_id = USERENV(‘Instance’) |
| V$DATABASE_INCARNATION | select incarnation#, resetlogs_change#, resetlogs_time, prior_resetlogs_change#, prior_resetlogs_time, status, resetlogs_id, prior_incarnation#, flashback_database_allowed from GV$DATABASE_INCARNATION where inst_id = USERENV(‘Instance’) |
| V$DATAFILE | select FILE# , CREATION_CHANGE# , CREATION_TIME , TS# , RFILE# , STATUS , ENABLED , CHECKPOINT_CHANGE# , CHECKPOINT_TIME, UNRECOVERABLE_CHANGE#, UNRECOVERABLE_TIME, LAST_CHANGE# , LAST_TIME , OFFLINE_CHANGE# , ONLINE_CHANGE# , ONLINE_TIME , BYTES , BLOCKS , CREATE_BYTES , BLOCK_SIZE , NAME , PLUGGED_IN , BLOCK1_OFFSET , AUX_NAME , FIRST_NONLOGGED_SCN, FIRST_NONLOGGED_TIME from GV$DATAFILE where inst_id = USERENV(‘Instance’) |
| V$DATAFILE_COPY | select RECID , STAMP , NAME , TAG , FILE# , RFILE# , CREATION_CHANGE# , CREATION_TIME , RESETLOGS_CHANGE# , RESETLOGS_TIME , INCREMENTAL_LEVEL, CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ABSOLUTE_FUZZY_CHANGE# , RECOVERY_FUZZY_CHANGE# , RECOVERY_FUZZY_TIME , ONLINE_FUZZY , BACKUP_FUZZY , MARKED_CORRUPT , MEDIA_CORRUPT , LOGICALLY_CORRUPT , BLOCKS , BLOCK_SIZE , OLDEST_OFFLINE_RANGE, DELETED, STATUS, COMPLETION_TIME , CONTROLFILE_TYPE, KEEP, KEEP_UNTIL, KEEP_OPTIONS, SCANNED, IS_RECOVERY_DEST_FILE, RMAN_STATUS_RECID, RMAN_STATUS_STAMP from GV$DATAFILE_COPY where inst_id = USERENV(‘Instance’) |
| V$DATAFILE_HEADER | select FILE# , STATUS , ERROR , FORMAT, RECOVER , FUZZY, CREATION_CHANGE#, CREATION_TIME , TABLESPACE_NAME , TS# , RFILE# , RESETLOGS_CHANGE# , RESETLOGS_TIME , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , CHECKPOINT_COUNT , BYTES , BLOCKS , NAME, SPACE_HEADER, LAST_DEALLOC_SCN from GV$DATAFILE_HEADER where inst_id = USERENV(‘Instance’) |
| V$DATAGUARD_CONFIG | select DGCDBUN from x$kcrrdgc |
| V$DATAGUARD_STATS | select NAME, VALUE, UNIT, TIME_COMPUTED from x$krvslvas union select NAME, VALUE, UNIT, TIME_COMPUTED from x$kcrrpvrs |
| V$DATAGUARD_STATUS | select FACILITY, SEVERITY, DEST_ID, MESSAGE_NUM, ERROR_CODE, CALLOUT, TIMESTAMP, MESSAGE from GV$DATAGUARD_STATUS where inst_id = USERENV(‘Instance’) |
| V$DATAPUMP_JOB | SELECT job_id, job_name, owner_name, msg_ctrl_queue, status_queue, operation, job_mode, master_id, state, workers, flags from gv$datapump_job where inst_id = USERENV(‘INSTANCE’) |
| V$DATAPUMP_SESSION | SELECT attach_id, job_id, saddr, type from gv$datapump_session where inst_id = USERENV(‘INSTANCE’) |
| V$DBFILE | select FILE# , NAME from GV$DBFILE where inst_id = USERENV(‘Instance’) |
| V$DBLINK | select DB_LINK , OWNER_ID , LOGGED_ON , HETEROGENEOUS , PROTOCOL , OPEN_CURSORS , IN_TRANSACTION , UPDATE_SENT , COMMIT_POINT_STRENGTH from GV$DBLINK where inst_id = USERENV(‘Instance’) |
| V$DB_CACHE_ADVICE | select id, name, block_size, advice_status, size_for_estimate, size_factor, buffers_for_estimate, estd_physical_read_factor, estd_physical_reads, estd_physical_read_time, estd_pct_of_db_time_for_reads, estd_cluster_reads, estd_cluster_read_time from gv$db_cache_advice where inst_id = userenv(‘instance’) |
| V$DB_OBJECT_CACHE | select OWNER , NAME , DB_LINK , NAMESPACE , TYPE , SHARABLE_MEM , LOADS , EXECUTIONS , LOCKS , PINS , KEPT , CHILD_LATCH , INVALIDATIONS from GV$DB_OBJECT_CACHE where inst_id = USERENV(‘Instance’) |
| V$DB_PIPES | select OWNERID , NAME , TYPE , PIPE_SIZE from GV$DB_PIPES where inst_id = USERENV(‘Instance’) |
| V$DB_TRANSPORTABLE_PLATFORM | select PLATFORM_ID, PLATFORM_NAME, decode(endian_format, 1,’Big’ ,0,’Little’,'UNKNOWN FORMAT’) from x$kcpxpl where endian_format = (select endian_format from x$kcpxpl pl, x$kccdi di where pl.platform_id = di.diplid) |
| V$DELETED_OBJECT | select RECID, STAMP, TYPE, OBJECT_RECID, OBJECT_STAMP, OBJECT_DATA from GV$DELETED_OBJECT where inst_id = USERENV(‘Instance’) |
| V$DISPATCHER | select NAME , NETWORK , PADDR , STATUS , ACCEPT , MESSAGES , BYTES , BREAKS , OWNED , CREATED , IDLE , BUSY , LISTENER, CONF_INDX from GV$DISPATCHER where inst_id = USERENV(‘Instance’) |
| V$DISPATCHER_CONFIG | select conf_indx, network, dispatchers, connections, sessions, pool, ticks, inbd_timout, outbd_timout, multiplex, listener, service from GV$DISPATCHER_CONFIG where inst_id = USERENV(‘Instance’) |
| V$DISPATCHER_RATE | select NAME, PADDR,CUR_LOOP_RATE,CUR_EVENT_RATE,CUR_EVENTS_PER_LOOP,CUR_MSG_RATE,CUR_SVR_BUF_RATE,CUR_SVR_BYTE_RATE,CUR_SVR_BYTE_PER_BUF,CUR_CLT_BUF_RATE,CUR_CLT_BYTE_RATE,CUR_CLT_BYTE_PER_BUF,CUR_BUF_RATE,CUR_BYTE_RATE,CUR_BYTE_PER_BUF,CUR_IN_CONNECT_RATE,CUR_OUT_CONNECT_RATE,CUR_RECONNECT_RATE,MAX_LOOP_RATE,MAX_EVENT_RATE,MAX_EVENTS_PER_LOOP,MAX_MSG_RATE,MAX_SVR_BUF_RATE,MAX_SVR_BYTE_RATE,MAX_SVR_BYTE_PER_BUF,MAX_CLT_BUF_RATE,MAX_CLT_BYTE_RATE,MAX_CLT_BYTE_PER_BUF,MAX_BUF_RATE,MAX_BYTE_RATE,MAX_BYTE_PER_BUF,MAX_IN_CONNECT_RATE,MAX_OUT_CONNECT_RATE,MAX_RECONNECT_RATE,AVG_LOOP_RATE,AVG_EVENT_RATE,AVG_EVENTS_PER_LOOP,AVG_MSG_RATE,AVG_SVR_BUF_RATE,AVG_SVR_BYTE_RATE,AVG_SVR_BYTE_PER_BUF,AVG_CLT_BUF_RATE,AVG_CLT_BYTE_RATE,AVG_CLT_BYTE_PER_BUF,AVG_BUF_RATE,AVG_BYTE_RATE,AVG_BYTE_PER_BUF,AVG_IN_CONNECT_RATE,AVG_OUT_CONNECT_RATE,AVG_RECONNECT_RATE,TTL_LOOPS,TTL_MSG,TTL_SVR_BUF,TTL_CLT_BUF,TTL_BUF,TTL_IN_CONNECT,TTL_OUT_CONNECT,TTL_RECONNECT,SCALE_LOOPS,SCALE_MSG,SCALE_SVR_BUF,SCALE_CLT_BUF,SCALE_BUF,SCALE_IN_CONNECT,SCALE_OUT_CONNECT,SCALE_RECONNECT from GV$DISPATCHER_RATE where inst_id = USERENV(‘Instance’) |
| V$DLM_ALL_LOCKS | select LOCKP, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, LOCKSTATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from GV$DLM_ALL_LOCKS where INST_ID = USERENV(‘Instance’) |
| V$DLM_CONVERT_LOCAL | select INST_ID, CONVERT_TYPE, AVERAGE_CONVERT_TIME, CONVERT_COUNT from GV$DLM_CONVERT_LOCAL where INST_ID = USERENV(‘Instance’) |
| V$DLM_CONVERT_REMOTE | select INST_ID, CONVERT_TYPE, AVERAGE_CONVERT_TIME, CONVERT_COUNT from GV$DLM_CONVERT_REMOTE where INST_ID = USERENV(‘Instance’) |
| V$DLM_LATCH | select addr, latch#, level#, name, gets, misses, sleeps,immediate_gets, immediate_misses, waiters_woken, waits_holding_latch, spin_gets, sleep1, sleep2, sleep3, sleep4, sleep5, sleep6, sleep7, sleep8, sleep9, sleep10, sleep11, wait_time from GV$DLM_LATCH where INST_ID = USERENV(‘Instance’) |
| V$DLM_LOCKS | select LOCKP, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, LOCKSTATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from GV$DLM_LOCKS where INST_ID = USERENV(‘Instance’) |
| V$DLM_MISC | select STATISTIC#, NAME, VALUE from GV$DLM_MISC where INST_ID = USERENV(‘Instance’) |
| V$DLM_RESS | select RESP, RESOURCE_NAME, ON_CONVERT_Q, ON_GRANT_Q, PERSISTENT_RES, MASTER_NODE, NEXT_CVT_LEVEL, VALUE_BLK_STATE, VALUE_BLK from GV$DLM_RESS where INST_ID = USERENV(‘Instance’) |
| V$DLM_TRAFFIC_CONTROLLER | select LOCAL_NID,REMOTE_NID,REMOTE_RID,REMOTE_INC, TCKT_AVAIL,TCKT_LIMIT,TCKT_RCVD,TCKT_WAIT, SND_SEQ_NO,RCV_SEQ_NO, SND_Q_LEN, SND_Q_MAX, SND_Q_TOT, SND_Q_TM_BASE, SND_Q_TM_WRAP, STATUS,SND_PROXY from GV$DLM_TRAFFIC_CONTROLLER where INST_ID = userenv(‘instance’) |
| V$ENABLEDPRIVS | select PRIV_NUMBER from GV$ENABLEDPRIVS where inst_id = USERENV(‘Instance’) |
| V$ENQUEUE_LOCK | select ADDR , KADDR , SID , TYPE , ID1 , ID2 , LMODE , REQUEST , CTIME , BLOCK from GV$ENQUEUE_LOCK where inst_id = USERENV(‘Instance’) |
| V$ENQUEUE_STAT | select INST_ID, EQ_TYPE, TOTAL_REQ#, TOTAL_WAIT#, SUCC_REQ#, FAILED_REQ#, CUM_WAIT_TIME from GV$ENQUEUE_STAT where INST_ID = USERENV(‘Instance’) |
| V$ENQUEUE_STATISTICS | select EQ_NAME, EQ_TYPE, REQ_REASON, TOTAL_REQ#, TOTAL_WAIT#, SUCC_REQ#, FAILED_REQ#, CUM_WAIT_TIME, REQ_DESCRIPTION, EVENT# from GV$ENQUEUE_STATISTICS where INST_ID = USERENV(‘Instance’) |
| V$EVENTMETRIC | SELECT begin_time, end_time, intsize_csec, event#, event_id, num_sess_waiting, time_waited, wait_count from gv$eventmetric where inst_id = USERENV(‘INSTANCE’) |
| V$EVENT_HISTOGRAM | select event#, event, wait_time_milli, wait_count from gv$event_histogram where inst_id = USERENV(‘Instance’) |
| V$EVENT_NAME | select event#, event_id, name,parameter1,parameter2,parameter3, wait_class_id, wait_class#, wait_class from gv$event_name where inst_id = USERENV(‘Instance’) |
| V$EXECUTION | select PID , DEPTH , FUNCTION , TYPE , NVALS , VAL1 , VAL2 , SEQH , SEQL from GV$EXECUTION where inst_id = USERENV(‘Instance’) |
| V$FAST_START_SERVERS | SELECT STATE, UNDOBLOCKSDONE, PID, XID from GV$FAST_START_SERVERS where inst_id = USERENV(‘Instance’) |
| V$FAST_START_TRANSACTIONS | SELECT USN, SLT, SEQ, STATE, UNDOBLOCKSDONE, UNDOBLOCKSTOTAL, PID, CPUTIME, PARENTUSN, PARENTSLT, PARENTSEQ, XID, PXID, RCVSERVERS from GV$FAST_START_TRANSACTIONS where INST_ID = USERENV(‘Instance’) |
| V$FILEMETRIC | SELECT begin_time, end_time, intsize_csec, file_id, creation_time, average_read_time, average_write_time, physical_reads, physical_writes, physical_block_reads, physical_block_writes from gv$filemetric where inst_id = USERENV(‘INSTANCE’) |
| V$FILEMETRIC_HISTORY | SELECT begin_time, end_time, intsize_csec, file_id, creation_time, average_read_time, average_write_time, physical_reads, physical_writes, physical_block_reads, physical_block_writes from gv$filemetric_history where inst_id = USERENV(‘INSTANCE’) |
| V$FILESPACE_USAGE | SELECT TABLESPACE_ID, RFNO, ALLOCATED_SPACE, FILE_SIZE, FILE_MAXSIZE, CHANGESCN_BASE, CHANGESCN_WRAP, FLAG from GV$FILESPACE_USAGE where INST_ID = USERENV(‘INSTANCE’) |
| V$FILESTAT | select FILE# , PHYRDS , PHYWRTS , PHYBLKRD , PHYBLKWRT , SINGLEBLKRDS, READTIM , WRITETIM, SINGLEBLKRDTIM, AVGIOTIM, LSTIOTIM, MINIOTIM, MAXIORTM, MAXIOWTM from GV$FILESTAT where inst_id = USERENV(‘Instance’) |
| V$FILE_CACHE_TRANSFER | select file_number, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, s_2_null, s_2_null_forced_stale, rbr, rbr_forced_write, rbr_forced_stale, null_2_x, s_2_x, null_2_s, cr_transfers, cur_transfers from gv$file_cache_transfer where inst_id = USERENV(‘Instance’) |
| V$FILE_HISTOGRAM | select FILE#, SINGLEBLKRDTIM_MILLI, SINGLEBLKRDS from GV$FILE_HISTOGRAM where inst_id = USERENV(‘Instance’) |
| V$FILE_PING | select file_number, frequency, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, x_2_ssx, x_2_ssx_forced_write, s_2_null, s_2_null_forced_stale, ss_2_null, ss_2_rls, wrb, wrb_forced_write, rbr, rbr_forced_write, rbr_forced_stale, cbr, cbr_forced_write, null_2_x, s_2_x, ssx_2_x, null_2_s, null_2_ss, op_2_ss from gv$file_ping where inst_id = USERENV(‘Instance’) |
| V$FIXED_TABLE | select NAME , OBJECT_ID , TYPE , TABLE_NUM from GV$FIXED_TABLE where inst_id = USERENV(‘Instance’) |
| V$FIXED_VIEW_DEFINITION | select VIEW_NAME , VIEW_DEFINITION from GV$FIXED_VIEW_DEFINITION where inst_id = USERENV(‘Instance’) |
| V$FLASHBACK_DATABASE_LOG | select OLDEST_FLASHBACK_SCN, OLDEST_FLASHBACK_TIME, RETENTION_TARGET, FLASHBACK_SIZE, ESTIMATED_FLASHBACK_SIZE from GV$FLASHBACK_DATABASE_LOG where inst_id = USERENV(‘Instance’) |
| V$FLASHBACK_DATABASE_LOGFILE | select NAME, LOG#, THREAD#, SEQUENCE#, BYTES, FIRST_CHANGE#, FIRST_TIME from GV$FLASHBACK_DATABASE_LOGFILE where inst_id = USERENV(‘Instance’) |
| V$FLASHBACK_DATABASE_STAT | select BEGIN_TIME, END_TIME, FLASHBACK_DATA, DB_DATA, REDO_DATA, ESTIMATED_FLASHBACK_SIZE from GV$FLASHBACK_DATABASE_STAT where inst_id = USERENV(‘Instance’) |
| V$FLASH_RECOVERY_AREA_USAGE | select fusg.file_type, decode(nvl2(ra.name, ra.space_limit, 0), 0, 0, round(nvl(fusg.space_used, 0)/ra.space_limit, 4) * 100), decode(nvl2(ra.name, ra.space_limit, 0), 0, 0, round(decode(fusg.file_type, ‘FLASHBACKLOG’, flb.flbrecl, nvl(fusg.space_reclaimable, 0))/ ra.space_limit, 4) * 100), nvl2(ra.name, fusg.number_of_files, 0) from v$recovery_file_dest ra, (select nvl((select fblogreclsiz from x$krfblog), 0) flbrecl from x$dual) flb, (select ‘CONTROLFILE’ file_type, sum(cfbsz * cffsz) space_used, 0 space_reclaimable, count(*) number_of_files from x$kcccf where bitand(cffl2,1) != 0 union all select ‘ONLINELOG’ file_type, sum(l.bytes) space_used, 0 space_reclaimable, count(*) number_of_files from v$log l, v$logfile lf where l.group# = lf.group# and lf.is_recovery_dest_file = ‘YES’ union all select ‘ARCHIVELOG’ file_type, sum(al.blocks * al.block_size) space_used, sum(case when dl.rectype = 11 then (al.blocks * al.block_size) else 0 end) space_reclaimable, count(*) number_of_files from v$archived_log al, x$kccagf dl where al.is_recovery_dest_file = ‘YES’ and al.recid = dl.recid(+) and dl.rectype(+) = 11 and al.name is not null union all select ‘BACKUPPIECE’ file_type, sum(bp.bytes) space_used, sum(case when dl.rectype = 13 then bp.bytes else 0 end) space_reclaimable, count(*) number_of_files from v$backup_piece bp, x$kccagf dl where bp.is_recovery_dest_file = ‘YES’ and bp.recid = dl.recid(+) and dl.rectype(+) = 13 and bp.handle is not null union all select ‘IMAGECOPY’ file_type, sum(dc.blocks * dc.block_size) space_used, |
| V$GCSHVMASTER_INFO | select HV_ID, CURRENT_MASTER, PREVIOUS_MASTER, REMASTER_CNT from GV$GCSHVMASTER_INFO where inst_id = USERENV(‘Instance’) |
| V$GCSPFMASTER_INFO | select FILE_ID, OBJECT_ID, CURRENT_MASTER, PREVIOUS_MASTER, REMASTER_CNT from GV$GCSPFMASTER_INFO where inst_id = USERENV(‘Instance’) |
| V$GC_ELEMENT | select gc_element_addr, indx, class, gc_element_name, mode_held, block_count, releasing, acquiring, writing, recovering, local, flags from gv$gc_element where inst_id = USERENV(‘Instance’) |
| V$GC_ELEMENTS_WITH_COLLISIONS | select gc_element_addr from gv$gc_elements_with_collisions where inst_id = USERENV(‘Instance’) |
| V$GES_BLOCKING_ENQUEUE | select HANDLE, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, STATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from GV$GES_BLOCKING_ENQUEUE where INST_ID = USERENV(‘Instance’) |
| V$GES_ENQUEUE | select HANDLE, GRANT_LEVEL, REQUEST_LEVEL, RESOURCE_NAME1, RESOURCE_NAME2, PID, TRANSACTION_ID0, TRANSACTION_ID1, GROUP_ID, OPEN_OPT_DEADLOCK, OPEN_OPT_PERSISTENT, OPEN_OPT_PROCESS_OWNED, OPEN_OPT_NO_XID, CONVERT_OPT_GETVALUE, CONVERT_OPT_PUTVALUE, CONVERT_OPT_NOVALUE, CONVERT_OPT_DUBVALUE, CONVERT_OPT_NOQUEUE, CONVERT_OPT_EXPRESS, CONVERT_OPT_NODEADLOCKWAIT, CONVERT_OPT_NODEADLOCKBLOCK, WHICH_QUEUE, STATE, AST_EVENT0, OWNER_NODE, BLOCKED, BLOCKER from GV$GES_ENQUEUE where INST_ID = USERENV(‘Instance’) |
| V$GLOBALCONTEXT | select namespace, attribute, value, username,clientidentifier from gv$globalcontext |
| V$GLOBAL_BLOCKED_LOCKS | select ADDR , KADDR , SID , TYPE , ID1 , ID2 , LMODE , REQUEST , CTIME from gv$global_blocked_locks where inst_id = userenv(‘instance’) |
| V$GLOBAL_TRANSACTION | select FORMATID, GLOBALID, BRANCHID, BRANCHES, REFCOUNT, PREPARECOUNT, STATE, FLAGS, COUPLING from GV$GLOBAL_TRANSACTION where INST_ID = USERENV(‘Instance’) |
| V$HS_AGENT | select unique AGENT_ID, MACHINE, PROCESS, PROGRAM, OSUSER, STARTTIME, AGENT_TYPE, FDS_CLASS_ID, FDS_INST_ID from GV$HS_AGENT where INST_ID = USERENV(‘Instance’) |
| V$HS_PARAMETER | select HS_SESSION_ID, PARAMETER, VALUE, SOURCE, ENV from GV$HS_PARAMETER where INST_ID = userenv(‘instance’) |
| V$HS_SESSION | select HS_SESSION_ID, AGENT_ID, SID, DB_LINK, DB_LINK_OWNER, STARTTIME from GV$HS_SESSION where INST_ID = USERENV(‘Instance’) |
| V$HVMASTER_INFO | select HV_ID, CURRENT_MASTER, PREVIOUS_MASTER, REMASTER_CNT from GV$HVMASTER_INFO where inst_id = USERENV(‘Instance’) |
| V$INDEXED_FIXED_COLUMN | select TABLE_NAME , INDEX_NUMBER , COLUMN_NAME , COLUMN_POSITION from GV$INDEXED_FIXED_COLUMN where inst_id = USERENV(‘Instance’) |
| V$INSTANCE | select INSTANCE_NUMBER , INSTANCE_NAME , HOST_NAME , VERSION , STARTUP_TIME , STATUS , PARALLEL , THREAD# , ARCHIVER , LOG_SWITCH_WAIT , LOGINS , SHUTDOWN_PENDING, DATABASE_STATUS, INSTANCE_ROLE, ACTIVE_STATE, BLOCKED from GV$INSTANCE where inst_id = USERENV(‘Instance’) |
| V$INSTANCE_CACHE_TRANSFER | select instance, class, cr_block, cr_busy, cr_congested, current_block, current_busy, current_congested from gv$instance_cache_transfer where inst_id = USERENV(‘Instance’) |
| V$INSTANCE_LOG_GROUP | select THREAD# , STATUS , ENABLED , GROUPS , INSTANCE , OPEN_TIME , CURRENT_GROUP# , SEQUENCE# , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ENABLE_CHANGE# , ENABLE_TIME , DISABLE_CHANGE# , DISABLE_TIME from GV$INSTANCE_LOG_GROUP where inst_id = USERENV(‘Instance’) |
| V$INSTANCE_RECOVERY | select RECOVERY_ESTIMATED_IOS, ACTUAL_REDO_BLKS, TARGET_REDO_BLKS, LOG_FILE_SIZE_REDO_BLKS, LOG_CHKPT_TIMEOUT_REDO_BLKS, LOG_CHKPT_INTERVAL_REDO_BLKS, FAST_START_IO_TARGET_REDO_BLKS, TARGET_MTTR, ESTIMATED_MTTR, CKPT_BLOCK_WRITES, OPTIMAL_LOGFILE_SIZE, ESTD_CLUSTER_AVAILABLE_TIME, WRITES_MTTR, WRITES_LOGFILE_SIZE, WRITES_LOG_CHECKPOINT_SETTINGS, WRITES_OTHER_SETTINGS, WRITES_AUTOTUNE, WRITES_FULL_THREAD_CKPT from GV$INSTANCE_RECOVERY where INST_ID = USERENV(‘Instance’) |
| V$JAVAPOOL | select CATEGORY, MEMUSED from gv$javapool where inst_id = USERENV(‘Instance’) |
| V$JAVA_LIBRARY_CACHE_MEMORY | select lc_namespace, lc_inuse_memory_objects, lc_inuse_memory_size, lc_freeable_memory_objects, lc_freeable_memory_size from gv$java_library_cache_memory where inst_id = USERENV(‘Instance’) |
| V$JAVA_POOL_ADVICE | select java_pool_size_for_estimate, java_pool_size_factor, estd_lc_size, estd_lc_memory_objects, estd_lc_time_saved, estd_lc_time_saved_factor, estd_lc_load_time, estd_lc_load_time_factor, estd_lc_memory_object_hits from gv$java_pool_advice where inst_id = USERENV(‘Instance’) |
| V$LATCH | select addr,latch#,level#,name,hash,gets,misses,sleeps,immediate_gets, immediate_misses,waiters_woken,waits_holding_latch,spin_gets, sleep1,sleep2,sleep3,sleep4,sleep5,sleep6,sleep7,sleep8,sleep9, sleep10,sleep11,wait_time from gv$latch where inst_id = USERENV(‘Instance’) |
| V$LATCHHOLDER | select PID , SID , LADDR , NAME , GETS from GV$LATCHHOLDER where inst_id = USERENV(‘Instance’) |
| V$LATCHNAME | select latch#,name, hash from gv$latchname where inst_id = userenv(‘Instance’) |
| V$LATCH_CHILDREN | select ADDR , LATCH# , CHILD# , LEVEL# , NAME , HASH , GETS , MISSES , SLEEPS , IMMEDIATE_GETS , IMMEDIATE_MISSES , WAITERS_WOKEN , WAITS_HOLDING_LATCH , SPIN_GETS , SLEEP1 , SLEEP2 , SLEEP3 , SLEEP4 , SLEEP5 , SLEEP6 , SLEEP7 , SLEEP8 , SLEEP9 , SLEEP10 , SLEEP11 , WAIT_TIME from GV$LATCH_CHILDREN where inst_id = USERENV(‘Instance’) |
| V$LATCH_MISSES | select PARENT_NAME, LOCATION, NWFAIL_COUNT, SLEEP_COUNT, WTR_SLP_COUNT, LONGHOLD_COUNT, LOCATION from GV$LATCH_MISSES where inst_id = USERENV(‘Instance’) |
| V$LATCH_PARENT | select ADDR , LATCH# , LEVEL# , NAME , HASH , GETS , MISSES , SLEEPS , IMMEDIATE_GETS , IMMEDIATE_MISSES , WAITERS_WOKEN , WAITS_HOLDING_LATCH , SPIN_GETS , SLEEP1 , SLEEP2 , SLEEP3 , SLEEP4 , SLEEP5 , SLEEP6 , SLEEP7 , SLEEP8 , SLEEP9 , SLEEP10 , SLEEP11 , WAIT_TIME from GV$LATCH_PARENT where inst_id = USERENV(‘Instance’) |
| V$LIBRARYCACHE | select NAMESPACE , GETS , GETHITS , GETHITRATIO , PINS , PINHITS , PINHITRATIO , RELOADS , INVALIDATIONS , DLM_LOCK_REQUESTS , DLM_PIN_REQUESTS , DLM_PIN_RELEASES , DLM_INVALIDATION_REQUESTS , DLM_INVALIDATIONS from GV$LIBRARYCACHE where inst_id = USERENV(‘Instance’) |
| V$LIBRARY_CACHE_MEMORY | select lc_namespace, lc_inuse_memory_objects, lc_inuse_memory_size, lc_freeable_memory_objects, lc_freeable_memory_size from gv$library_cache_memory where inst_id = USERENV(‘Instance’) |
| V$LICENSE | select sessions_max,sessions_warning,sessions_current,sessions_highwater, users_max, cpu_count_current, cpu_core_count_current, cpu_socket_count_current, cpu_count_highwater, cpu_core_count_highwater, cpu_socket_count_highwater from gv$license where inst_id = userenv(‘Instance’) |
| V$LOADISTAT | select OWNER, TABNAME, INDEXNAME, SUBNAME, MESSAGE_NUM, MESSAGE from GV$LOADISTAT where INST_ID = USERENV(‘Instance’) |
| V$LOADPSTAT | select OWNER , TABNAME , PARTNAME , LOADED from GV$LOADPSTAT where inst_id = USERENV(‘Instance’) |
| V$LOCK | select ADDR , KADDR , SID , TYPE , ID1 , ID2 , LMODE , REQUEST , CTIME , BLOCK from GV$LOCK where inst_id = USERENV(‘Instance’) |
| V$LOCKED_OBJECT | select xidusn,xidslot,xidsqn,object_id,session_id,oracle_username, os_user_name,process,locked_mode from gv$locked_object where inst_id = USERENV(‘Instance’) |
| V$LOCKS_WITH_COLLISIONS | select lock_element_addr from v$bh where (forced_writes + forced_reads) > 10 group by lock_element_addr having count(*) >= 2 |
| V$LOCK_ACTIVITY | SELECT FROM_VAL,TO_VAL,ACTION_VAL,COUNTER from GV$LOCK_ACTIVITY where INST_ID = USERENV(‘INSTANCE’) |
| V$LOCK_ELEMENT | select lock_element_addr, indx, class, lock_element_name, mode_held, block_count, releasing, acquiring, invalid, flags from gv$lock_element where inst_id = USERENV(‘Instance’) |
| V$LOCK_TYPE | select TYPE, NAME, ID1_TAG, ID2_TAG, IS_USER, DESCRIPTION from GV$LOCK_TYPE where INST_ID = USERENV(‘Instance’) |
| V$LOG | select GROUP# , THREAD# , SEQUENCE# , BYTES , MEMBERS , ARCHIVED , STATUS , FIRST_CHANGE# , FIRST_TIME from GV$LOG where inst_id = USERENV(‘Instance’) |
| V$LOGFILE | select GROUP# , STATUS , TYPE , MEMBER, IS_RECOVERY_DEST_FILE from GV$LOGFILE where inst_id = USERENV(‘Instance’) |
| V$LOGHIST | select THREAD# , SEQUENCE# , FIRST_CHANGE# , FIRST_TIME , SWITCH_CHANGE# from GV$LOGHIST where inst_id = USERENV(‘Instance’) |
| V$LOGMNR_CALLBACK | select session_id, function_id, description, type from gv$logmnr_callback where inst_id = userenv(‘instance’) |
| V$LOGMNR_CONTENTS | select SCN, CSCN, TIMESTAMP, COMMIT_TIMESTAMP, THREAD#, LOG_ID, XIDUSN, XIDSLT, XIDSQN, PXIDUSN, PXIDSLT, PXIDSQN, RBASQN, RBABLK, RBABYTE, UBAFIL, UBABLK, UBAREC, UBASQN, ABS_FILE#,REL_FILE#, DATA_BLK#, DATA_OBJ#, DATA_OBJD#, SEG_OWNER, SEG_NAME, TABLE_NAME, SEG_TYPE, SEG_TYPE_NAME, TABLE_SPACE, ROW_ID, SESSION#, SERIAL#, USERNAME, SESSION_INFO, TX_NAME, ROLLBACK, OPERATION, OPERATION_CODE, SQL_REDO, SQL_UNDO, RS_ID, SEQUENCE#, SSN, CSF, INFO, STATUS, REDO_VALUE, UNDO_VALUE, SQL_COLUMN_TYPE, SQL_COLUMN_NAME, REDO_LENGTH, REDO_OFFSET, UNDO_LENGTH, UNDO_OFFSET, DATA_OBJV#, SAFE_RESUME_SCN, XID, PXID, AUDIT_SESSIONID from GV$LOGMNR_CONTENTS where inst_id = userenv(‘instance’) |
| V$LOGMNR_DICTIONARY | select DB_NAME, DB_ID, DB_CREATED, TIMESTAMP, RESET_SCN, RESET_SCN_TIME, DB_VERSION_TIME, DB_CHARACTER_SET, DB_VERSION, DB_STATUS, DICTIONARY_SCN, ENABLED_THREAD_MAP, DB_TXN_SCN, FILENAME, INFO, STATUS from GV$LOGMNR_DICTIONARY where inst_id = userenv(‘instance’) |
| V$LOGMNR_DICTIONARY_LOAD | select session_id, logmnr_uid, action#, opcode, command, current_state, completed_actions, total_actions, loaded, percent_done from gv$logmnr_dictionary_load where inst_id = userenv(‘instance’) |
| V$LOGMNR_LATCH | select session_id, name, child_addr, state from gv$logmnr_latch where inst_id = userenv(‘instance’) |
| V$LOGMNR_LOGFILE | select log_id, filename, low_time, next_time, db_id, db_name, reset_scnwrp, reset_scnbas, reset_scn_time, thread_id, thread_sqn, low_scnwrp, low_scnbas, next_scnwrp, next_scnbas, file_state from gv$logmnr_logfile where inst_id = userenv(‘instance’) |
| V$LOGMNR_LOGS | select LOG_ID, FILENAME, LOW_TIME, HIGH_TIME, DB_ID, DB_NAME, RESET_SCN, RESET_SCN_TIME, THREAD_ID, THREAD_SQN, LOW_SCN, NEXT_SCN, DICTIONARY_BEGIN, DICTIONARY_END, TYPE, BLOCKSIZE, FILESIZE, INFO, STATUS from GV$LOGMNR_LOGS where inst_id = userenv(‘instance’) |
| V$LOGMNR_PARAMETERS | select START_DATE, REQUIRED_START_DATE, END_DATE, START_SCN, REQUIRED_START_SCN, END_SCN, OPTIONS, INFO, STATUS from GV$LOGMNR_PARAMETERS where inst_id = userenv(‘instance’) |
| V$LOGMNR_PROCESS | select session_id, pid, spid, role, username, sid, serial#, latchwait, latchspin, work_microsec, overhead_microsec from gv$logmnr_process where inst_id = userenv(‘instance’) |
| V$LOGMNR_REGION | select memstate, state, owning_process from gv$logmnr_region where inst_id = userenv(‘instance’) |
| V$LOGMNR_SESSION | select session_id, session_name, session_state, db_name, db_id, reset_scn, reset_timestamp, num_process, chunk_size, start_scn, end_scn, spill_scn, processed_scn, prepared_scn, read_scn, low_mark_scn, consumed_scn, max_memory_size, used_memory_size, prepared_work_size, available_work_size, available_txn, available_committed_txn, delivered_txn, delivered_committed_txn, pinned_txn, pinned_committed_txn, checkpoint_interval from GV$LOGMNR_SESSION where inst_id = userenv(‘instance’) |
| V$LOGMNR_STATS | select session_id, name,value from gv$logmnr_stats where inst_id = USERENV(‘Instance’) |
| V$LOGMNR_TRANSACTION | select session_id, xid, xidusn, xidslt, xidsqn, parent_xid, parent_xidusn, parent_xidslt, parent_xidsqn, start_time, start_scn, chunk#, total_chunks, redo_thread, low_time, low_scn, high_time, high_scn, lcr_count, spilled_lcr_count, dflag, mflag, mflag2, state, type, mining_status, queue from gv$logmnr_transaction where inst_id = userenv(‘instance’) |
| V$LOGSTDBY | select serial#,logstdby_id,pid,type,status_code,status,high_scn from gv$logstdby where inst_id = USERENV(‘Instance’) |
| V$LOGSTDBY_PROCESS | select sid, serial#,logstdby_id,spid,type,status_code,status,high_scn from gv$logstdby_process where inst_id = USERENV(‘Instance’) |
| V$LOGSTDBY_PROGRESS | select applied_scn,applied_time,restart_scn,restart_time,latest_scn, latest_time,mining_scn, mining_time from gv$logstdby_progress where inst_id = USERENV(‘Instance’) |
| V$LOGSTDBY_STATE | select primary_dbid,session_id,realtime_apply,state from gv$logstdby_state where inst_id = USERENV(‘Instance’) |
| V$LOGSTDBY_STATS | select name,value from gv$logstdby_stats where inst_id = USERENV(‘Instance’) |
| V$LOGSTDBY_TRANSACTION | select primary_xid, primary_start_scn, primary_start_time, primary_parent_xid, mining_status, apply_status, sid, serial# from gv$logstdby_transaction where inst_id = USERENV(‘Instance’) |
| V$LOG_HISTORY | select RECID , STAMP , THREAD# , SEQUENCE# , FIRST_CHANGE# , FIRST_TIME , NEXT_CHANGE#, RESETLOGS_CHANGE#, RESETLOGS_TIME from GV$LOG_HISTORY |
| V$MANAGED_STANDBY | select PROCESS, PID, STATUS, CLIENT_PROCESS, CLIENT_PID, CLIENT_DBID, GROUP#, RESETLOG_ID, THREAD#, SEQUENCE#, BLOCK#, BLOCKS, DELAY_MINS, KNOWN_AGENTS, ACTIVE_AGENTS from GV$MANAGED_STANDBY where inst_id = USERENV(‘Instance’) |
| V$MAP_COMP_LIST | select ELEM_IDX,NUM_COMP,COMP1_NAME,COMP1_VAL, COMP2_NAME,COMP2_VAL,COMP3_NAME,COMP3_VAL, COMP4_NAME,COMP4_VAL,COMP5_NAME,COMP5_VAL from gv$map_comp_list where inst_id = USERENV(‘Instance’) |
| V$MAP_ELEMENT | select ELEM_NAME,ELEM_IDX,ELEM_CFGID,ELEM_TYPE, ELEM_SIZE,ELEM_NSUBELEM,ELEM_DESCR,STRIPE_SIZE,LIB_IDX from gv$map_element where inst_id = USERENV(‘Instance’) |
| V$MAP_EXT_ELEMENT | select ELEM_IDX,NUM_ATTRB,ATTRB1_NAME,ATTRB1_VAL, ATTRB2_NAME,ATTRB2_VAL,ATTRB3_NAME,ATTRB3_VAL, ATTRB4_NAME,ATTRB4_VAL,ATTRB5_NAME,ATTRB5_VAL from gv$map_ext_element where inst_id = USERENV(‘Instance’) |
| V$MAP_FILE | select FILE_MAP_IDX,FILE_CFGID,FILE_STATUS,FILE_NAME, FILE_TYPE,FILE_STRUCTURE,FILE_SIZE,FILE_NEXTS,LIB_IDX from gv$map_file where inst_id = USERENV(‘Instance’) |
| V$MAP_FILE_EXTENT | select FILE_MAP_IDX,EXT_NUM,EXT_ELEM_OFF,EXT_SIZE, EXT_FILE_OFF,EXT_TYPE,ELEM_IDX from gv$map_file_extent where inst_id = USERENV(‘Instance’) |
| V$MAP_FILE_IO_STACK | select FILE_MAP_IDX,DEPTH,ELEM_IDX,CU_SIZE, STRIDE,NUM_CU,ELEM_OFFSET,FILE_OFFSET,DATA_TYPE, PARITY_POS,PARITY_PERIOD,ID,PARENT_ID from gv$map_file_io_stack where inst_id = USERENV(‘Instance’) |
| V$MAP_LIBRARY | select LIB_IDX,LIB_NAME,VENDOR_NAME,PROTOCOL_NUM, VERSION_NUM,PATH_NAME,MAP_FILE,FILE_CFGID,MAP_ELEM, ELEM_CFGID,MAP_SYNC from gv$map_library where inst_id = USERENV(‘Instance’) |
| V$MAP_SUBELEMENT | select CHILD_IDX,PARENT_IDX,SUB_NUM,SUB_SIZE, ELEM_OFFSET,SUB_FLAGS from gv$map_subelement where inst_id = USERENV(‘Instance’) |
| V$MAX_ACTIVE_SESS_TARGET_MTH | select name from gv$max_active_sess_target_mth where inst_id = userenv(‘instance’) |
| V$METRIC | SELECT begin_time, end_time, intsize_csec, group_id, entity_id, entity_sequence, metric_id, metric_name, value, metric_unit from gv$metric where inst_id = USERENV(‘INSTANCE’) |
| V$METRICGROUP | SELECT group_id, name, interval_size, max_interval from gv$metricgroup where inst_id = USERENV(‘INSTANCE’) |
| V$METRICNAME | SELECT group_id, group_name, metric_id, metric_name, metric_unit from gv$metricname where inst_id = USERENV(‘INSTANCE’) |
| V$METRIC_HISTORY | SELECT begin_time, end_time, intsize_csec, group_id, entity_id, entity_sequence, metric_id, metric_name, value, metric_unit from gv$metric_history where inst_id = USERENV(‘INSTANCE’) |
| V$MTTR_TARGET_ADVICE | select mttr_target_for_estimate, advice_status, dirty_limit, estd_cache_writes, estd_cache_write_factor, estd_total_writes, estd_total_write_factor, estd_total_ios, estd_total_io_factor from gv$mttr_target_advice where inst_id = userenv(‘instance’) |
| V$MUTEX_SLEEP | select MUTEX_TYPE, LOCATION, SLEEPS, WAIT_TIME from GV$MUTEX_SLEEP where INST_ID = USERENV(‘INSTANCE’) |
| V$MUTEX_SLEEP_HISTORY | select SLEEP_TIMESTAMP, MUTEX_TYPE, GETS, SLEEPS, REQUESTING_SESSION, BLOCKING_SESSION, LOCATION, MUTEX_VALUE, P1, P1RAW, P2, P3, P4, P5 from GV$MUTEX_SLEEP_HISTORY where INST_ID = USERENV(‘INSTANCE’) |
| V$MVREFRESH | SELECT SID, SERIAL#, CURRMVOWNER, CURRMVNAME from GV$MVREFRESH |
| V$MYSTAT | select SID , STATISTIC# , VALUE from GV$MYSTAT where inst_id = USERENV(‘Instance’) |
| V$NLS_PARAMETERS | select PARAMETER , VALUE from GV$NLS_PARAMETERS where inst_id = USERENV(‘Instance’) |
| V$NLS_VALID_VALUES | select PARAMETER , VALUE, ISDEPRECATED from GV$NLS_VALID_VALUES where inst_id = USERENV(‘Instance’) |
| V$OBJECT_DEPENDENCY | select FROM_ADDRESS , FROM_HASH , TO_OWNER , TO_NAME , TO_ADDRESS , TO_HASH , TO_TYPE from GV$OBJECT_DEPENDENCY where inst_id = USERENV(‘Instance’) |
| V$OBSOLETE_PARAMETER | select NAME , ISSPECIFIED from GV$OBSOLETE_PARAMETER where inst_id = USERENV(‘Instance’) |
| V$OFFLINE_RANGE | select RECID , STAMP , FILE# , OFFLINE_CHANGE# , ONLINE_CHANGE# , ONLINE_TIME, RESETLOGS_CHANGE#, RESETLOGS_TIME from GV$OFFLINE_RANGE where inst_id = USERENV(‘Instance’) |
| V$OPEN_CURSOR | select SADDR , SID , USER_NAME , ADDRESS , HASH_VALUE, SQL_ID, SQL_TEXT from GV$OPEN_CURSOR where inst_id = USERENV(‘Instance’) |
| V$OPTION | select PARAMETER , VALUE from GV$OPTION where inst_id = USERENV(‘Instance’) |
| V$OSSTAT | select STAT_NAME, VALUE, OSSTAT_ID from GV$OSSTAT where INST_ID = USERENV(‘Instance’) |
| V$PARALLEL_DEGREE_LIMIT_MTH | select name from gv$parallel_degree_limit_mth where inst_id = userenv(‘instance’) |
| V$PARAMETER | select NUM , NAME , TYPE , VALUE , DISPLAY_VALUE, ISDEFAULT , ISSES_MODIFIABLE , ISSYS_MODIFIABLE , ISINSTANCE_MODIFIABLE, ISMODIFIED , ISADJUSTED , ISDEPRECATED, DESCRIPTION, UPDATE_COMMENT, HASH from GV$PARAMETER where inst_id = USERENV(‘Instance’) |
| V$PARAMETER2 | select NUM , NAME , TYPE , VALUE , DISPLAY_VALUE, ISDEFAULT , ISSES_MODIFIABLE , ISSYS_MODIFIABLE , ISINSTANCE_MODIFIABLE, ISMODIFIED , ISADJUSTED , ISDEPRECATED, DESCRIPTION, ORDINAL, UPDATE_COMMENT from GV$PARAMETER2 where inst_id = USERENV(‘Instance’) |
| V$PARAMETER_VALID_VALUES | select num, name, ordinal, value, isdefault from GV$PARAMETER_VALID_VALUES where INST_ID = USERENV(‘Instance’) |
| V$PGASTAT | select NAME, VALUE, UNIT from GV$PGASTAT where INST_ID = USERENV(‘Instance’) |
| V$PGA_TARGET_ADVICE | select PGA_TARGET_FOR_ESTIMATE, PGA_TARGET_FACTOR, ADVICE_STATUS, BYTES_PROCESSED, ESTD_EXTRA_BYTES_RW, ESTD_PGA_CACHE_HIT_PERCENTAGE, ESTD_OVERALLOC_COUNT from GV$PGA_TARGET_ADVICE where INST_ID = USERENV(‘Instance’) |
| V$PGA_TARGET_ADVICE_HISTOGRAM | select PGA_TARGET_FOR_ESTIMATE, PGA_TARGET_FACTOR, ADVICE_STATUS, LOW_OPTIMAL_SIZE, HIGH_OPTIMAL_SIZE, ESTD_OPTIMAL_EXECUTIONS, ESTD_ONEPASS_EXECUTIONS, ESTD_MULTIPASSES_EXECUTIONS, ESTD_TOTAL_EXECUTIONS, IGNORED_WORKAREAS_COUNT from GV$PGA_TARGET_ADVICE_HISTOGRAM where INST_ID = USERENV(‘Instance’) |
| V$PQ_SESSTAT | select STATISTIC , LAST_QUERY , SESSION_TOTAL from GV$PQ_SESSTAT where inst_id = USERENV(‘Instance’) |
| V$PQ_SLAVE | select SLAVE_NAME , STATUS , SESSIONS , IDLE_TIME_CUR , BUSY_TIME_CUR , CPU_SECS_CUR , MSGS_SENT_CUR , MSGS_RCVD_CUR , IDLE_TIME_TOTAL , BUSY_TIME_TOTAL , CPU_SECS_TOTAL , MSGS_SENT_TOTAL , MSGS_RCVD_TOTAL from GV$PQ_SLAVE where inst_id = USERENV(‘Instance’) |
| V$PQ_SYSSTAT | select STATISTIC , VALUE from GV$PQ_SYSSTAT where inst_id = USERENV(‘Instance’) |
| V$PQ_TQSTAT | select DFO_NUMBER , TQ_ID , SERVER_TYPE , NUM_ROWS , BYTES , OPEN_TIME , AVG_LATENCY , WAITS , TIMEOUTS , PROCESS , INSTANCE from GV$PQ_TQSTAT where inst_id = USERENV(‘Instance’) |
| V$PROCESS | select addr, pid,spid,username,serial#,terminal,program,traceid,background, latchwait,latchspin,pga_used_mem,pga_alloc_mem,pga_freeable_mem,pga_max_mem from gv$process where inst_id = USERENV(‘Instance’) |
| V$PROCESS_MEMORY | select pid, serial#, category, allocated, used, max_allocated from gv$process_memory where inst_id = USERENV(‘Instance’) |
| V$PROCESS_MEMORY_DETAIL | select pid, serial#, category, name, heap_name, bytes, allocation_count, heap_descriptor, parent_heap_descriptor from gv$process_memory_detail where inst_id = USERENV(‘Instance’) |
| V$PROCESS_MEMORY_DETAIL_PROG | select pid, serial#, status from gv$process_memory_detail_prog where inst_id = USERENV(‘Instance’) |
| V$PROPAGATION_RECEIVER | select src_queue_schema, src_queue_name, src_dbname, dst_queue_schema, dst_queue_name, startup_time, high_water_mark, acknowledgement, total_msgs, elapsed_unpickle_time, elapsed_rule_time, elapsed_enqueue_time from gv$propagation_receiver where inst_id = USERENV(‘Instance’) |
| V$PROPAGATION_SENDER | select queue_id, queue_schema, queue_name, dst_queue_schema, dst_queue_name, startup_time, dblink, high_water_mark, acknowledgement, schedule_status, total_msgs, total_bytes, elapsed_dequeue_time, elapsed_pickle_time, elapsed_propagation_time, max_num_per_win, max_size from gv$propagation_sender where inst_id = USERENV(‘Instance’) |
| V$PROXY_ARCHIVEDLOG | select RECID , STAMP , DEVICE_TYPE , HANDLE , COMMENTS , MEDIA , MEDIA_POOL , TAG, STATUS , DELETED, THREAD# , SEQUENCE# , RESETLOGS_CHANGE# , RESETLOGS_TIME , FIRST_CHANGE# , FIRST_TIME , NEXT_CHANGE# , NEXT_TIME , BLOCKS , BLOCK_SIZE , START_TIME , COMPLETION_TIME , ELAPSED_SECONDS, RMAN_STATUS_RECID, RMAN_STATUS_STAMP from GV$PROXY_ARCHIVEDLOG where inst_id = USERENV(‘Instance’) |
| V$PROXY_ARCHIVELOG_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select b.session_recid session_key, b.session_recid, b.session_stamp, a.recid copy_key, a.thread#, a.sequence#, a.resetlogs_change#, a.resetlogs_time, a.handle, a.media, a.media_pool, a.tag, a.first_change#, a.next_change#, a.first_time, a.next_time, (a.blocks+1)*a.block_size output_bytes, a.completion_time from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual) c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))a |
| V$PROXY_ARCHIVELOG_SUMMARY | select nvl(num_files_backed, 0), distinct_files_backed, min_first_change#, max_next_change#, min_first_time, max_next_time, output_bytes, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select count(*) num_files_backed, min(first_change#)min_first_change#, max(next_change#) max_next_change#, min(first_time)min_first_time, max(next_time) max_next_time, sum((blocks+1)*block_size) output_bytes from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)), (select count(*) distinct_files_backed from (select unique thread#, sequence#, resetlogs_change#, resetlogs_time from v$proxy_archivedlog a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))) |
| V$PROXY_COPY_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select b.session_recid session_key, b.session_recid, b.session_stamp, a.recid copy_key, a.file#, a.handle, a.media, a.media_pool, a.tag, a.creation_change#, a.creation_time, a.checkpoint_change#, a.checkpoint_time, (a.blocks+1)*a.block_size output_bytes, a.completion_time, a.controlfile_type, keep, keep_until, keep_options from v$proxy_datafile a, v$rman_status b , (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time))a |
| V$PROXY_COPY_SUMMARY | select a.*, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from (select nvl(sum(num_times_backed),0) num_copies, sum(distinct_copies) distinct_copies, min(min_checkpoint_change#) min_checkpoint_change#, max(max_checkpoint_change#) max_checkpoint_change#, min(min_checkpoint_time) min_checkpoint_time, max(max_checkpoint_time) max_checkpoint_time, sum(output_bytes) output_bytes from (select unique file#, count(*) over (partition by file#,creation_change#) num_times_backed, count(distinct file#) over (partition by file#,creation_change#,checkpoint_change#) distinct_copies, min(checkpoint_change#) over (partition by file#, creation_change#) min_checkpoint_change#, max(checkpoint_change#) over (partition by file#, creation_change#) max_checkpoint_change#, min(checkpoint_time) over (partition by file#, creation_change#) min_checkpoint_time, max(checkpoint_time) over (partition by file#, creation_change#) max_checkpoint_time, sum((blocks+1)*block_size) over (partition by file#, creation_change#) output_bytes from v$proxy_datafile a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual)c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.status = ‘A’ and a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time)))a |
| V$PROXY_DATAFILE | select RECID , STAMP , DEVICE_TYPE , HANDLE , COMMENTS , MEDIA , MEDIA_POOL , TAG , STATUS , DELETED, FILE# , CREATION_CHANGE# , CREATION_TIME , RESETLOGS_CHANGE# , RESETLOGS_TIME , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ABSOLUTE_FUZZY_CHANGE# , RECOVERY_FUZZY_CHANGE# , RECOVERY_FUZZY_TIME , INCREMENTAL_LEVEL , ONLINE_FUZZY , BACKUP_FUZZY , BLOCKS , BLOCK_SIZE, OLDEST_OFFLINE_RANGE, START_TIME , COMPLETION_TIME , ELAPSED_SECONDS , CONTROLFILE_TYPE, KEEP, KEEP_UNTIL, KEEP_OPTIONS, RMAN_STATUS_RECID, RMAN_STATUS_STAMP from GV$PROXY_DATAFILE where inst_id = USERENV(‘Instance’) |
| V$PWFILE_USERS | select USERNAME , SYSDBA , SYSOPER from GV$PWFILE_USERS where inst_id = USERENV(‘Instance’) |
| V$PX_BUFFER_ADVICE | select STATISTIC , VALUE from GV$PX_BUFFER_ADVICE where inst_id = USERENV(‘Instance’) |
| V$PX_PROCESS | select SERVER_NAME, STATUS, PID, SPID, SID, SERIAL# from GV$PX_PROCESS where inst_id = USERENV(‘Instance’) |
| V$PX_PROCESS_SYSSTAT | select STATISTIC , VALUE from GV$PX_PROCESS_SYSSTAT where inst_id = USERENV(‘Instance’) |
| V$PX_SESSION | select saddr, sid, serial#, qcsid, qcserial#, qcinst_id, server_group, server_set, server#, degree, req_degree from GV$PX_SESSION where inst_id = USERENV(‘Instance’) |
| V$PX_SESSTAT | select saddr, sid, serial#, qcsid, qcserial#, qcinst_id, server_group, server_set, server#, degree, req_degree, statistic#, value from GV$PX_SESSTAT where inst_id = USERENV(‘Instance’) |
| V$QUEUE | select PADDR , TYPE , QUEUED , WAIT , TOTALQ from GV$QUEUE where inst_id = USERENV(‘Instance’) |
| V$QUEUEING_MTH | select name from gv$queueing_mth where inst_id = userenv(‘instance’) |
| V$RECOVERY_FILE_DEST | select location, slimit, (sused + scfile), srecl, fcnt from x$kccrdi |
| V$RECOVERY_FILE_STATUS | select FILENUM , FILENAME , STATUS from GV$RECOVERY_FILE_STATUS where inst_id = USERENV(‘Instance’) |
| V$RECOVERY_LOG | select THREAD# , SEQUENCE# , TIME , ARCHIVE_NAME from GV$RECOVERY_LOG where inst_id = USERENV(‘Instance’) |
| V$RECOVERY_PROGRESS | select START_TIME, TYPE, ITEM, UNITS, SOFAR, TOTAL, TIMESTAMP from GV$RECOVERY_PROGRESS where inst_id = USERENV(‘Instance’) |
| V$RECOVERY_STATUS | select RECOVERY_CHECKPOINT , THREAD , SEQUENCE_NEEDED , SCN_NEEDED , TIME_NEEDED , PREVIOUS_LOG_NAME , PREVIOUS_LOG_STATUS , REASON from GV$RECOVERY_STATUS where inst_id = USERENV(‘Instance’) |
| V$RECOVER_FILE | select FILE# , “ONLINE” , ONLINE_STATUS, ERROR , CHANGE# , TIME from GV$RECOVER_FILE where inst_id = USERENV(‘Instance’) |
| V$REPLPROP | SELECT SID, SERIAL#, NAME, DBLINK, STATE, XID, SEQUENCE from GV$REPLPROP where INST_ID = USERENV(‘Instance’) |
| V$REPLQUEUE | SELECT TXNS_ENQUEUED, CALLS_ENQUEUED, TXNS_PURGED, LAST_ENQUEUE_TIME, LAST_PURGE_TIME from GV$REPLQUEUE where INST_ID = USERENV(‘Instance’) |
| V$REQDIST | select BUCKET , COUNT from GV$REQDIST where inst_id = USERENV(‘Instance’) |
| V$RESERVED_WORDS | select KEYWORD, LENGTH, RESERVED, RES_TYPE, RES_ATTR, RES_SEMI, DUPLICATE from GV$RESERVED_WORDS where inst_id = USERENV(‘Instance’) |
| V$RESOURCE | select ADDR , TYPE , ID1 , ID2 from GV$RESOURCE where inst_id = USERENV(‘Instance’) |
| V$RESOURCE_LIMIT | select RESOURCE_NAME, CURRENT_UTILIZATION, MAX_UTILIZATION, INITIAL_ALLOCATION, LIMIT_VALUE from GV$RESOURCE_LIMIT where inst_id = USERENV(‘Instance’) |
| V$RESTORE_POINT | select SCN, DATABASE_INCARNATION#, GUARANTEE_FLASHBACK_DATABASE, STORAGE_SIZE, TIME, NAME from GV$RESTORE_POINT where inst_id = USERENV(‘Instance’) |
| V$RESUMABLE | select ADDR, SID, ENABLED, STATUS, TIMEOUT, SUSPEND_TIME, RESUME_TIME, NAME, ERROR_NUMBER, ERROR_PARAMETER1, ERROR_PARAMETER2, ERROR_PARAMETER3, ERROR_PARAMETER4, ERROR_PARAMETER5, ERROR_MSG from GV$RESUMABLE where inst_id = USERENV(‘Instance’) |
| V$RFS_THREAD | select THREAD#, RESETLOGS_CHANGE#, RESET_TIMESTAMP, LAST_REDO_SEQ#, LAST_REDO_BLK#, LAST_REDO_TIME, LOW_GAP_SCN, LOW_GAP_TIME, LAST_PING_TIME from gv$RFS_THREAD where INST_ID = USERENV(‘INSTANCE’) |
| V$RMAN_BACKUP_JOB_DETAILS | select a.*, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display, sys.dbms_rcvman.num2displaysize(input_bytes_per_sec) input_bytes_per_sec_display, sys.dbms_rcvman.num2displaysize(output_bytes_per_sec) output_bytes_per_sec_display, sys.dbms_rcvman.sec2displaytime(elapsed_seconds) time_taken_display from (select unique a.session_recid session_key, a.*, decode(autobackup_count, 0, ‘NO’, ‘YES’) autobackup_done, decode(status_weight, 2000, ‘FAILED’, 1900, ‘RUNNING WITH ERRORS’, 1500, ‘RUNNING WITH WARNINGS’, 1001, ‘RUNNING’, 900, ‘COMPLETED WITH ERRORS’, 500, ‘COMPLETED WITH WARNINGS’, 001, ‘COMPLETED’, ‘FAILED’) status, decode(object_type_weight,9, ‘DB FULL’, 8, ‘RECVR AREA’, 7, ‘DB INCR’, 6, ‘DATAFILE FULL’, 5, ‘DATAFILE INCR’, 4, ‘ARCHIVELOG’, 3, ‘CONTROLFILE’, 2, ‘SPFILE’, 1, ‘BACKUPSET’, null) input_type, decode(optimized_weight, 1, ‘YES’, ‘NO’) optimized, abs(a.end_time-a.start_time)*86400 elapsed_seconds, case when a.input_bytes/decode(a.output_bytes,0,null, a.output_bytes) > 1 then a.input_bytes/decode(a.output_bytes,0,null, a.output_bytes) else 1 end compression_ratio, a.input_bytes/(decode(a.end_time-a.start_time, 0, 1, abs(a.end_time-a.start_time)*86400)) input_bytes_per_sec, a.output_bytes/(decode(a.end_time-a.start_time, 0, 1, abs(a.end_time-a.start_time)*86400)) output_bytes_per_sec from (select session_recid, session_stamp, command_id, min(start_time) over (partition by session_recid, session_stamp) start_time, max(end_time) over (partition by session_recid, session_stamp) end_time, sum(input_bytes) over (partition by session_recid, session_stamp) input_bytes, sum(output_bytes) over (partition by session_recid, session_stamp) output_bytes, max(status_weight) over (partition by session_recid, session_stamp)status_weight, max(optimized_weight) over (partition by session_recid, session_stamp) optimized_weight, max(object_type_weight) over (partition by session_recid, session_stamp) object_type_weight, decode(count(distinct output_device_type) over (partition by session_recid, session_stamp),1, first_value(output_device_type) over (partition by session_recid, session_stamp),0, null, ‘*’) output_device_type, sum(autobackup_count) over (partition by session_recid, session_stamp) autobackup_count from V$RMAN_BACKUP_SUBJOB_DETAILS) a)a |
| V$RMAN_BACKUP_SUBJOB_DETAILS | select a.session_recid session_key, a.*, decode(nvl(b.autocnt,0), 0, ‘NO’, ‘YES’) autobackup_done, decode(status_weight, 2000, ‘FAILED’, 1900, ‘RUNNING WITH ERRORS’, 1500, ‘RUNNING WITH WARNINGS’, 1001, ‘RUNNING’, 900, ‘COMPLETED WITH ERRORS’, 500, ‘COMPLETED WITH WARNINGS’, 001, ‘COMPLETED’, ‘FAILED’) status, decode(object_type_weight,9, ‘DB FULL’, 8, ‘RECVR AREA’, 7, ‘DB INCR’, 6, ‘DATAFILE FULL’, 5, ‘DATAFILE INCR’, 4, ‘ARCHIVELOG’, 3, ‘CONTROLFILE’, 2, ‘SPFILE’, 1, ‘BACKUPSET’, null) object_type, decode(optimized_weight, 1, ‘YES’, ‘NO’) optimized, nvl(b.autocnt,0) autobackup_count, case when input_bytes/decode(output_bytes,0,null, output_bytes) > 1 then input_bytes/decode(output_bytes,0,null, output_bytes) else 1 end compression_ratio, sys.dbms_rcvman.num2displaysize(input_bytes) input_bytes_display, sys.dbms_rcvman.num2displaysize(output_bytes) output_bytes_display from ( select unique session_recid, session_stamp, operation, command_id, min(start_time) over (partition by session_recid, session_stamp, operation) start_time, max(end_time) over (partition by session_recid, session_stamp, operation) end_time, sum(input_bytes) over (partition by session_recid, session_stamp, operation) input_bytes, sum(output_bytes) over (partition by session_recid, session_stamp, operation) output_bytes, max(status_weight) over (partition by session_recid, session_stamp, operation)status_weight, max(object_type_weight) over (partition by session_recid, session_stamp, operation) object_type_weight, max(optimized_weight) over (partition by session_recid, session_stamp, operation) optimized_weight, decode(count(distinct output_device_type) over (partition by session_recid, session_stamp, operation),1, first_value(output_device_type) over (partition by session_recid, session_stamp, operation),0, null, ‘*’) output_device_type from (select d.*, decode(status, ‘RUNNING’, 1001, ‘RUNNING WITH WARNINGS’, 1500, ‘RUNNING WITH ERRORS’, 1900, ‘COMPLETED’, 0001, ‘COMPLETED WITH WARNINGS’, 500, ‘COMPLETED WITH ERRORS’, 900, ‘FAILED’, 2000, 2000) status_weight, decode(object_type, ‘DB FULL’, 9, ‘RECVR AREA’, 8, ‘DB INCR’, 7, ‘DATAFILE FULL’, 6, ‘DATAFILE INCR’, 5, ‘ARCHIVELOG’, 4, ‘CONTROLFILE’, 3, ‘SPFILE’, 2, ‘BACKUPSET’, 1, 0) object_type_weight, decode(optimized,’YES’, 1, 0) optimized_weight from v$rman_status d where operation like ‘BACKUP%’ and row_level=1)) a, ( select session_recid, session_stamp, count(*) autocnt from v$rman_status where operation like ‘%AUTOBACKUP%’ and row_level > 1 group by session_recid, session_stamp ) b where a.session_recid=b.session_recid (+) and a.session_stamp=b.session_stamp (+) |
| V$RMAN_BACKUP_TYPE | select 9, ‘DB FULL’ from dual union select 8, ‘RECVR AREA’ from dual union select 7, ‘DB INCR’ from dual union select 6, ‘DATAFILE FULL’ from dual union select 5, ‘DATAFILE INCR’ from dual union select 4, ‘ARCHIVELOG’ from dual union select 3, ‘CONTROLFILE’ from dual union select 2, ‘SPFILE’ from dual union select 1, ‘BACKUPSET’ from dual |
| V$RMAN_CONFIGURATION | select CONF#, NAME, VALUE from GV$RMAN_CONFIGURATION where inst_id = USERENV(‘Instance’) |
| V$RMAN_ENCRYPTION_ALGORITHMS | select algorithm_id, algorithm_name, algorithm_description, is_default, restore_only from gv$rman_encryption_algorithms where inst_id = USERENV(‘Instance’) |
| V$RMAN_OUTPUT | select SID,RECID,STAMP,SESSION_RECID,SESSION_STAMP,OUTPUT,RMAN_STATUS_RECID, RMAN_STATUS_STAMP, SESSION_RECID from GV$RMAN_OUTPUT where inst_id = USERENV(‘Instance’) |
| V$RMAN_STATUS | SELECT nvl(R1.SID,0),nvl(R1.RECID,R2.RSRRID),nvl(R1.STAMP,R2.RSRTST),decode(nvl(R1.ROW_LEVEL, R2.RSRLV), 0, to_number(NULL),nvl(R1.PARENT_RECID, RSRPI)),decode(nvl(R1.ROW_LEVEL, R2.RSRLV), 0, to_number(NULL),nvl(R1.PARENT_STAMP, R2.RSRPS)),decode (nvl(R1.ROW_LEVEL, R2.RSRLV), 0, nvl(R1.RECID,R2.RSRRID), R2.RSR0I), decode (nvl(R1.ROW_LEVEL, R2.RSRLV), 0, nvl(R1.STAMP,R2.RSRTST), R2.RSR0S), nvl(R1.ROW_LEVEL, R2.RSRLV),nvl(R1.ROW_TYPE, decode(R2.RSRLV, 0, ‘SESSION’,1, ‘COMMAND’,'RECURSIVE OPERATION’)),nvl(R1.COMMAND_ID,R2.RSRCI), nvl(R1.OPERATION, UPPER(R2.RSROP)),nvl(R1.STATUS, decode(bitand(R2.RSRIS,2+1), 2,decode(R2.RSRES, 1, ‘RUNNING’,1+8, ‘RUNNING WITH WARNINGS’, 1+16, ‘RUNNING WITH ERRORS’, 1+8+16, ‘RUNNING WITH ERRORS’, 2, ‘COMPLETED’, 2+8, ‘COMPLETED WITH WARNINGS’, 2+16, ‘COMPLETED WITH ERRORS’, 2+8+16, ‘COMPLETED WITH ERRORS’, ‘FAILED’), ‘FAILED’)), decode(R2.RSRMP, 0, nvl(HH.MBYTES, 0 ),R2.RSRMP), nvl(R1.START_TIME, to_date(R2.RSRST,’MM/DD/RR HH24:MI:SS’, ‘NLS_CALENDAR=Gregorian’)), nvl(R1.END_TIME, to_date(R2.RSRET,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’)), decode(R2.RSRIM, 0, nvl(HH.INPBYTES, 0), decode(bitand(R2.RSRIM, 2147483648), 0,R2.RSRIM, 2147483648, bitand(R2.RSRIM,2147483647)*1024*1024)), decode(R2.RSROM, 0, nvl(HH.OUTBYTES, 0), decode(bitand(R2.RSROM, 2147483648), 0,R2.RSROM, 2147483648, bitand(R2.RSROM,2147483647)*1024*1024)), decode(bitand(R2.RSRFL, 32), 1, ‘YES’, ‘NO’), nvl(nvl(nvl(nvl(nvl(nvl(nvl( decode(bitand(R2.RSRFL, 1+128),1, ‘DB FULL’,null), decode(bitand(R2.RSRFL, 64), 64, ‘RECVR AREA’, null)), decode(bitand(R2.RSRFL, 1+128), 129, ‘DB INCR’, null)), decode(bitand(R2.RSRFL, 2+128),2, ‘DATAFILE FULL’, 130, ‘DATAFILE INCR’, null)), decode(bitand(R2.RSRFL, 4), 4, ‘ARCHIVELOG’, null)), decode(bitand(R2.RSRFL, 8), 8, ‘CONTROLFILE’, null)), decode(bitand(R2.RSRFL, 16), 16, ‘SPFILE’, null)), decode(bitand(R2.RSRFL, 256), 256, ‘BACKUPSET’, null)), decode(bitand(R2.RSRIS, 32+16+8+4), 0, odev.device_type, 4, ‘DISK’, 8, ‘SBT_TAPE’, 16, ‘*’, null) device_type from X$KCCRSR R2, GV$RMAN_STATUS_CURRENT R1, (SELECT R.RSRRID RECID, R.RSRTST STAMP, sum(aggrcol)/(1024*1024) MBYTES, sum(inpcol) INPBYTES, sum(outcol) OUTBYTES from x$kccrsr R, (select rman_status_recid, rman_status_stamp, sum(case when type=3 then blocks*block_size else 0 end) aggrcol, sum(case when type=1 then blocks*block_size else 0 end) inpcol, sum(case when type=2 then blocks*block_size else 0 end) outcol from x$ksfqp group by rman_status_recid, rman_status_stamp) RS where R.RSRRID = RS.RMAN_STATUS_RECID(+) and R.RSRTST = RS.RMAN_STATUS_STAMP(+) group by R.RSRRID, R.RSRTST) HH, (SELECT unique R.RSRRID RECID, R.RSRTST STAMP, device_type from x$kccrsr R, (SELECT RMAN_STATUS_RECID, RMAN_STATUS_STAMP, decode(count(distinct devtype) over (partition by RMAN_STATUS_RECID, RMAN_STATUS_STAMP),1, first_value(devtype) over (partition by RMAN_STATUS_RECID, RMAN_STATUS_STAMP), 0, null,’*') device_type from x$ksfqp where 2 = TYPE) RS where R.RSRRID = RS.RMAN_STATUS_RECID(+) and R.RSRTST = RS.RMAN_STATUS_STAMP(+)) ODEV where nvl(R1.RECID,R2.RSRRID) = HH.RECID AND nvl(R1.STAMP,R2.RSRTST) = HH.STAMP AND nvl(R1.RECID,R2.RSRRID) = ODEV.RECID AND nvl(R1.STAMP,R2.RSRTST) = ODEV.STAMP AND R2.RSRRID = R1.RECID(+) AND R2.RSRTST = R1.STAMP(+) |
| V$ROLLSTAT | select USN , LATCH, EXTENTS , RSSIZE , WRITES , XACTS , GETS , WAITS , OPTSIZE , HWMSIZE , SHRINKS , WRAPS , EXTENDS , AVESHRINK , AVEACTIVE , STATUS , CUREXT , CURBLK from GV$ROLLSTAT where inst_id = USERENV(‘Instance’) |
| V$ROWCACHE | select cache#,type,subordinate#,parameter,count,usage,fixed, gets,getmisses,scans,scanmisses,scancompletes,modifications,flushes,dlm_requests,dlm_conflicts,dlm_releases from gv$rowcache where inst_id = USERENV(‘Instance’) |
| V$ROWCACHE_PARENT | select indx, hash, address, cache#, cache_name, existent, lock_mode, lock_request, txn, saddr, inst_lock_request, inst_lock_release, inst_lock_type, inst_lock_id1, inst_lock_id2, key from gv$rowcache_parent where inst_id = USERENV(‘Instance’) |
| V$ROWCACHE_SUBORDINATE | select indx, hash, address, cache#, subcache#, subcache_name, existent, parent, key from gv$rowcache_subordinate where inst_id = USERENV(‘Instance’) |
| V$RSRC_CONSUMER_GROUP | select id, name, active_sessions, execution_waiters, requests, cpu_wait_time, cpu_waits, consumed_cpu_time, yields, queue_length, current_undo_consumption, active_session_limit_hit, session_switches_in, session_switches_out, undo_limit_hit, sql_canceled, active_sessions_killed, idle_sessions_killed, idle_blkr_sessions_killed, queued_time, queue_time_outs from gv$rsrc_consumer_group where inst_id = userenv(‘instance’) |
| V$RSRC_CONSUMER_GROUP_CPU_MTH | select name from gv$rsrc_consumer_group_cpu_mth where inst_id = userenv(‘instance’) |
| V$RSRC_CONS_GROUP_HISTORY | select sequence#, id, name, requests, cpu_wait_time, cpu_waits, consumed_cpu_time, yields, active_sess_limit_hit, undo_limit_hit, session_switches_in, session_switches_out, sql_canceled, active_sess_killed, idle_sess_killed, idle_blkr_sess_killed, queued_time, queue_time_outs from gv$rsrc_cons_group_history where inst_id = userenv(‘instance’) |
| V$RSRC_PLAN | select id, name, is_top_plan from gv$rsrc_plan where inst_id = userenv(‘instance’) |
| V$RSRC_PLAN_CPU_MTH | select name from gv$rsrc_plan_cpu_mth where inst_id = userenv(‘instance’) |
| V$RSRC_PLAN_HISTORY | select sequence#, id, name, start_time, end_time, enabled_by_scheduler, window_name, allowed_automated_switches from gv$rsrc_plan_history where inst_id = userenv(‘instance’) |
| V$RSRC_SESSION_INFO | select sid, current_consumer_group_id, orig_consumer_group_id, mapping_attribute, mapped_consumer_group, state, active, current_idle_time, current_cpu_wait_time, cpu_wait_time, current_cpu_waits, cpu_waits, current_consumed_cpu_time, consumed_cpu_time, current_active_time, active_time, current_queued_time, queued_time, current_yields, yields, current_undo_consumption, max_undo_consumption, sql_canceled, queue_time_outs, estimated_execution_limit_hit from gv$rsrc_session_info where inst_id = userenv(‘instance’) |
| V$RULE | select RULE_SET_OBJECT_ID, EVALUATION_CONTEXT_OBJECT_ID, RULE_OWNER, RULE_NAME, RULE_CONDITION, TRUE_HITS, MAYBE_HITS, SQL_EVALUATIONS from GV$RULE where inst_id = USERENV(‘Instance’) |
| V$RULE_SET | select OWNER, NAME, CPU_TIME, ELAPSED_TIME, FIRST_LOAD_TIME, LAST_LOAD_TIME, LAST_LOADING_TIME, SHARABLE_MEM, RELOADS, INVALIDATIONS, EVALUATIONS, FIRST_HIT_EVALUATIONS, SIMPLE_RULES_ONLY_EVALUATIONS, SQL_FREE_EVALUATIONS, SQL_EXECUTIONS, CONDITIONS_PROCESSED, TRUE_RULES, MAYBE_RULES, VARIABLE_VALUE_FUNCTION_CALLS, VARIABLE_METHOD_FUNCTION_CALLS, EVALUATION_FUNCTION_CALLS from GV$RULE_SET where inst_id = USERENV(‘Instance’) |
| V$RULE_SET_AGGREGATE_STATS | select NAME, VALUE from GV$RULE_SET_AGGREGATE_STATS where inst_id = USERENV(‘Instance’) |
| V$SCHEDULER_RUNNING_JOBS | select session_id, session_serial_num, job_id, paddr, os_process_id, session_stat_cpu from gv$scheduler_running_jobs where inst_id = USERENV(‘Instance’) |
| V$SEGMENT_STATISTICS | select owner, object_name, subobject_name, tablespace_name, ts#, obj#, dataobj#, object_type, statistic_name, statistic#, value from gv$segment_statistics where inst_id = userenv(‘instance’) |
| V$SEGSTAT | select ts#, obj#, dataobj#, statistic_name, statistic#, value from gv$segstat where inst_id = userenv(‘instance’) |
| V$SEGSTAT_NAME | select statistic#, name, sampled from gv$segstat_name where inst_id = userenv(‘instance’) |
| V$SERVICEMETRIC | SELECT begin_time, end_time, intsize_csec, group_id, service_name_hash, service_name, ctmhash, elapsedpercall, cpupercall, dbtimepercall, callspersec, dbtimepersec, goodness, delta, flags from gv$servicemetric where inst_id = USERENV(‘INSTANCE’) |
| V$SERVICEMETRIC_HISTORY | SELECT begin_time, end_time, intsize_csec, group_id, service_name_hash, service_name, ctmhash, elapsedpercall, cpupercall, dbtimepercall, callspersec, dbtimepersec from gv$servicemetric_history where inst_id = USERENV(‘INSTANCE’) |
| V$SERVICES | select SERVICE_ID, NAME, NAME_HASH, NETWORK_NAME, CREATION_DATE, CREATION_DATE_HASH, GOAL, DTP, AQ_HA_NOTIFICATION, CLB_GOAL from GV$SERVICES where inst_id = USERENV(‘Instance’) |
| V$SERVICE_EVENT | select service_name, service_name_hash,event,event_id, total_waits, total_timeouts, time_waited,average_wait, max_wait,time_waited_micro from gv$service_event where inst_id = USERENV(‘Instance’) |
| V$SERVICE_STATS | select SERVICE_NAME_HASH , SERVICE_NAME , STAT_ID , STAT_NAME , VALUE from GV$SERVICE_STATS where inst_id = USERENV(‘Instance’) |
| V$SERVICE_WAIT_CLASS | select service_name, service_name_hash,wait_class_id, wait_class#, wait_class,total_waits, time_waited from gv$service_wait_class where inst_id = USERENV(‘Instance’) |
| V$SERV_MOD_ACT_STATS | select AGGREGATION_TYPE, SERVICE_NAME, MODULE, ACTION, STAT_ID, STAT_NAME, VALUE from GV$SERV_MOD_ACT_STATS where inst_id = USERENV(‘Instance’) |
| V$SESSION | select SADDR , SID , SERIAL# , AUDSID , PADDR , USER# , USERNAME , COMMAND , OWNERID, TADDR , LOCKWAIT , STATUS , SERVER , SCHEMA# , SCHEMANAME ,OSUSER , PROCESS , MACHINE , TERMINAL , PROGRAM , TYPE , SQL_ADDRESS , SQL_HASH_VALUE, SQL_ID, SQL_CHILD_NUMBER , PREV_SQL_ADDR , PREV_HASH_VALUE , PREV_SQL_ID, PREV_CHILD_NUMBER , MODULE , MODULE_HASH , ACTION , ACTION_HASH , CLIENT_INFO , FIXED_TABLE_SEQUENCE , ROW_WAIT_OBJ# , ROW_WAIT_FILE# , ROW_WAIT_BLOCK# , ROW_WAIT_ROW# , LOGON_TIME , LAST_CALL_ET , PDML_ENABLED , FAILOVER_TYPE , FAILOVER_METHOD , FAILED_OVER, RESOURCE_CONSUMER_GROUP, PDML_STATUS, PDDL_STATUS, PQ_STATUS, CURRENT_QUEUE_DURATION, CLIENT_IDENTIFIER, BLOCKING_SESSION_STATUS, BLOCKING_INSTANCE,BLOCKING_SESSION,SEQ#, EVENT#,EVENT,P1TEXT,P1,P1RAW,P2TEXT,P2,P2RAW, P3TEXT,P3,P3RAW,WAIT_CLASS_ID, WAIT_CLASS#,WAIT_CLASS,WAIT_TIME, SECONDS_IN_WAIT,STATE,SERVICE_NAME, SQL_TRACE, SQL_TRACE_WAITS, SQL_TRACE_BINDS from GV$SESSION where inst_id = USERENV(‘Instance’) |
| V$SESSION_CONNECT_INFO | select sid,authentication_type,osuser,network_service_banner from gv$session_connect_info where inst_id = USERENV(‘Instance’) |
| V$SESSION_CURSOR_CACHE | select MAXIMUM , COUNT , OPENED_ONCE , OPEN , OPENS , HITS , HIT_RATIO from GV$SESSION_CURSOR_CACHE where inst_id = USERENV(‘Instance’) |
| V$SESSION_EVENT | select sid,event,total_waits,total_timeouts,time_waited,average_wait, max_wait,time_waited_micro, event_id, wait_class_id,wait_class#, wait_class from gv$session_event where inst_id = USERENV(‘Instance’) |
| V$SESSION_LONGOPS | select SID, SERIAL#, OPNAME, TARGET, TARGET_DESC, SOFAR, TOTALWORK, UNITS, START_TIME, LAST_UPDATE_TIME, TIMESTAMP, TIME_REMAINING, ELAPSED_SECONDS, CONTEXT, MESSAGE, USERNAME, SQL_ADDRESS, SQL_HASH_VALUE, SQL_ID, QCSID from GV$SESSION_LONGOPS where inst_id = USERENV(‘Instance’) |
| V$SESSION_OBJECT_CACHE | select pins,hits,true_hits,hit_ratio,true_hit_ratio,object_refreshes,cache_refreshes,object_flushes,cache_flushes,cache_shrinks,cached_objects,pinned_objects,cache_size,optimal_size,maximum_size from gv$session_object_cache where inst_id=userenv(‘Instance’) |
| V$SESSION_WAIT | select sid,seq#,event,p1text,p1,p1raw,p2text,p2,p2raw,p3text, p3,p3raw,wait_class_id, wait_class#,wait_class,wait_time,seconds_in_wait,state from gv$session_wait where inst_id = USERENV(‘Instance’) |
| V$SESSION_WAIT_CLASS | select sid,serial#,wait_class_id, wait_class#,wait_class,total_waits, time_waited from gv$session_wait_class where inst_id = USERENV(‘Instance’) |
| V$SESSION_WAIT_HISTORY | select sid,seq#,event#,event,p1text,p1,p2text,p2,p3text,p3,wait_time, wait_count from gv$session_wait_history where inst_id = USERENV(‘Instance’) |
| V$SESSMETRIC | SELECT begin_time, end_time, intsize_csec, session_id, serial_num, cpu, physical_reads, logical_reads, pga_memory, hard_parses, soft_parses, physical_read_pct, logical_read_pct from gv$sessmetric where inst_id = USERENV(‘INSTANCE’) |
| V$SESSTAT | select SID , STATISTIC# , VALUE from GV$SESSTAT where inst_id = USERENV(‘Instance’) |
| V$SESS_IO | select SID , BLOCK_GETS , CONSISTENT_GETS , PHYSICAL_READS , BLOCK_CHANGES , CONSISTENT_CHANGES from GV$SESS_IO where inst_id = USERENV(‘Instance’) |
| V$SESS_TIME_MODEL | select SID, STAT_ID, STAT_NAME, VALUE from GV$SESS_TIME_MODEL where inst_id = USERENV(‘Instance’) |
| V$SES_OPTIMIZER_ENV | select SID, ID, NAME, ISDEFAULT, VALUE from GV$SES_OPTIMIZER_ENV where INST_ID = USERENV(‘Instance’) |
| V$SGA | select NAME , VALUE from GV$SGA where inst_id = USERENV(‘Instance’) |
| V$SGAINFO | select name, bytes, resizeable from gv$sgainfo where inst_id = USERENV(‘Instance’) |
| V$SGASTAT | select POOL, NAME , BYTES from GV$SGASTAT where inst_id = USERENV(‘Instance’) |
| V$SGA_CURRENT_RESIZE_OPS | select component, oper_type, oper_mode, parameter, initial_size, target_size, current_size, start_time, last_update_time from gv$sga_current_resize_ops where inst_id = USERENV(‘Instance’) |
| V$SGA_DYNAMIC_COMPONENTS | select component, current_size, min_size, max_size, user_specified_size, oper_count, last_oper_type, last_oper_mode, last_oper_time, granule_size from gv$sga_dynamic_components where inst_id = USERENV(‘Instance’) |
| V$SGA_DYNAMIC_FREE_MEMORY | select current_size from gv$sga_dynamic_free_memory where inst_id = USERENV(‘Instance’) |
| V$SGA_RESIZE_OPS | select component, oper_type, oper_mode, parameter, initial_size, target_size, final_size, status, start_time, end_time from gv$sga_resize_ops where inst_id = USERENV(‘Instance’) |
| V$SGA_TARGET_ADVICE | select sga_size, sga_size_factor, estd_db_time, estd_db_time_factor, estd_physical_reads from gv$sga_target_advice where inst_id = userenv(‘instance’) |
| V$SHARED_POOL_ADVICE | select shared_pool_size_for_estimate, shared_pool_size_factor, estd_lc_size, estd_lc_memory_objects, estd_lc_time_saved, estd_lc_time_saved_factor, estd_lc_load_time, estd_lc_load_time_factor, estd_lc_memory_object_hits from gv$shared_pool_advice where inst_id = USERENV(‘Instance’) |
| V$SHARED_POOL_RESERVED | select FREE_SPACE , AVG_FREE_SIZE , FREE_COUNT , MAX_FREE_SIZE , USED_SPACE , AVG_USED_SIZE , USED_COUNT , MAX_USED_SIZE , REQUESTS , REQUEST_MISSES , LAST_MISS_SIZE , MAX_MISS_SIZE , REQUEST_FAILURES , LAST_FAILURE_SIZE , ABORTED_REQUEST_THRESHOLD , ABORTED_REQUESTS , LAST_ABORTED_SIZE from GV$SHARED_POOL_RESERVED where inst_id = USERENV(‘Instance’) |
| V$SHARED_SERVER | select NAME , PADDR , STATUS , MESSAGES , BYTES , BREAKS , CIRCUIT , IDLE , BUSY , REQUESTS from GV$SHARED_SERVER where inst_id = USERENV(‘Instance’) |
| V$SHARED_SERVER_MONITOR | select MAXIMUM_CONNECTIONS , MAXIMUM_SESSIONS , SERVERS_STARTED , SERVERS_TERMINATED , SERVERS_HIGHWATER from GV$SHARED_SERVER_MONITOR where inst_id = USERENV(‘Instance’) |
| V$SORT_SEGMENT | select TABLESPACE_NAME , SEGMENT_FILE , SEGMENT_BLOCK , EXTENT_SIZE , CURRENT_USERS , TOTAL_EXTENTS , TOTAL_BLOCKS , USED_EXTENTS , USED_BLOCKS , FREE_EXTENTS , FREE_BLOCKS , ADDED_EXTENTS , EXTENT_HITS , FREED_EXTENTS , FREE_REQUESTS , MAX_SIZE , MAX_BLOCKS , MAX_USED_SIZE , MAX_USED_BLOCKS , MAX_SORT_SIZE , MAX_SORT_BLOCKS , RELATIVE_FNO from GV$SORT_SEGMENT where inst_id = USERENV(‘Instance’) |
| V$SORT_USAGE | select USERNAME , “USER” , SESSION_ADDR , SESSION_NUM , SQLADDR , SQLHASH, SQL_ID, TABLESPACE , CONTENTS , SEGTYPE , SEGFILE# , SEGBLK# ,EXTENTS , BLOCKS , SEGRFNO# from GV$SORT_USAGE where inst_id = USERENV(‘Instance’) |
| V$SPPARAMETER | select SID, NAME, VALUE, DISPLAY_VALUE, ISSPECIFIED, ORDINAL, UPDATE_COMMENT from GV$SPPARAMETER where INST_id = USERENV(‘Instance’) |
| V$SQL | select SQL_TEXT , SQL_FULLTEXT , SQL_ID, SHARABLE_MEM , PERSISTENT_MEM , RUNTIME_MEM , SORTS , LOADED_VERSIONS , OPEN_VERSIONS , USERS_OPENING , FETCHES , EXECUTIONS , PX_SERVERS_EXECUTIONS , END_OF_FETCH_COUNT, USERS_EXECUTING , LOADS , FIRST_LOAD_TIME, INVALIDATIONS, PARSE_CALLS , DISK_READS , DIRECT_WRITES , BUFFER_GETS , APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, ROWS_PROCESSED , COMMAND_TYPE , OPTIMIZER_MODE , OPTIMIZER_COST, OPTIMIZER_ENV, OPTIMIZER_ENV_HASH_VALUE, PARSING_USER_ID , PARSING_SCHEMA_ID , PARSING_SCHEMA_NAME, KEPT_VERSIONS , ADDRESS , TYPE_CHK_HEAP , HASH_VALUE, OLD_HASH_VALUE, PLAN_HASH_VALUE, CHILD_NUMBER, SERVICE, SERVICE_HASH, MODULE, MODULE_HASH , ACTION , ACTION_HASH , SERIALIZABLE_ABORTS , OUTLINE_CATEGORY, CPU_TIME, ELAPSED_TIME, OUTLINE_SID, CHILD_ADDRESS, SQLTYPE, REMOTE, OBJECT_STATUS, LITERAL_HASH_VALUE, LAST_LOAD_TIME, IS_OBSOLETE, CHILD_LATCH, SQL_PROFILE, PROGRAM_ID, PROGRAM_LINE#, EXACT_MATCHING_SIGNATURE, FORCE_MATCHING_SIGNATURE, LAST_ACTIVE_TIME, BIND_DATA from GV$SQL where inst_id = USERENV(‘Instance’) |
| V$SQLAREA | select SQL_TEXT, SQL_FULLTEXT, SQL_ID, SHARABLE_MEM, PERSISTENT_MEM, RUNTIME_MEM, SORTS, VERSION_COUNT, LOADED_VERSIONS, OPEN_VERSIONS, USERS_OPENING, FETCHES, EXECUTIONS, PX_SERVERS_EXECUTIONS, END_OF_FETCH_COUNT, USERS_EXECUTING, LOADS, FIRST_LOAD_TIME, INVALIDATIONS, PARSE_CALLS, DISK_READS, DIRECT_WRITES, BUFFER_GETS, APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, ROWS_PROCESSED, COMMAND_TYPE, OPTIMIZER_MODE, OPTIMIZER_COST, OPTIMIZER_ENV, OPTIMIZER_ENV_HASH_VALUE, PARSING_USER_ID, PARSING_SCHEMA_ID, PARSING_SCHEMA_NAME, KEPT_VERSIONS, ADDRESS, HASH_VALUE, OLD_HASH_VALUE, PLAN_HASH_VALUE, MODULE, MODULE_HASH, ACTION, ACTION_HASH, SERIALIZABLE_ABORTS, OUTLINE_CATEGORY, CPU_TIME, ELAPSED_TIME, OUTLINE_SID, LAST_ACTIVE_CHILD_ADDRESS, REMOTE, OBJECT_STATUS, LITERAL_HASH_VALUE, LAST_LOAD_TIME, IS_OBSOLETE, CHILD_LATCH, SQL_PROFILE, PROGRAM_ID, PROGRAM_LINE#, EXACT_MATCHING_SIGNATURE, FORCE_MATCHING_SIGNATURE, LAST_ACTIVE_TIME, BIND_DATA from GV$SQLAREA where inst_id = USERENV(‘Instance’) |
| V$SQLAREA_PLAN_HASH | select SQL_TEXT, SQL_FULLTEXT, ADDRESS, HASH_VALUE, SQL_ID, PLAN_HASH_VALUE, VERSION_COUNT, LAST_ACTIVE_CHILD_ADDRESS, SHARABLE_MEM, PERSISTENT_MEM, RUNTIME_MEM, SORTS, LOADED_VERSIONS, OPEN_VERSIONS, USERS_OPENING, USERS_EXECUTING, FETCHES, EXECUTIONS, PX_SERVERS_EXECUTIONS, END_OF_FETCH_COUNT, LOADS, FIRST_LOAD_TIME, LAST_LOAD_TIME, LAST_ACTIVE_TIME, INVALIDATIONS, PARSE_CALLS, DISK_READS, DIRECT_WRITES, BUFFER_GETS, CPU_TIME, ELAPSED_TIME, APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, ROWS_PROCESSED, COMMAND_TYPE, OPTIMIZER_MODE, OPTIMIZER_COST, OPTIMIZER_ENV, OPTIMIZER_ENV_HASH_VALUE, PARSING_USER_ID, PARSING_SCHEMA_ID, PARSING_SCHEMA_NAME, KEPT_VERSIONS, MODULE, MODULE_HASH, ACTION, ACTION_HASH, SERIALIZABLE_ABORTS, OUTLINE_CATEGORY, OUTLINE_SID, REMOTE, OBJECT_STATUS, LITERAL_HASH_VALUE, SQL_PROFILE, PROGRAM_ID, PROGRAM_LINE#, EXACT_MATCHING_SIGNATURE, FORCE_MATCHING_SIGNATURE, BIND_DATA from GV$SQLAREA_PLAN_HASH where inst_id = USERENV(‘Instance’) |
| V$SQLSTATS | select SQL_TEXT, SQL_FULLTEXT, SQL_ID, LAST_ACTIVE_TIME, LAST_ACTIVE_CHILD_ADDRESS, PLAN_HASH_VALUE, PARSE_CALLS, DISK_READS, DIRECT_WRITES, BUFFER_GETS, ROWS_PROCESSED, SERIALIZABLE_ABORTS, FETCHES, EXECUTIONS, END_OF_FETCH_COUNT, LOADS, VERSION_COUNT, INVALIDATIONS, PX_SERVERS_EXECUTIONS, CPU_TIME, ELAPSED_TIME, APPLICATION_WAIT_TIME, CONCURRENCY_WAIT_TIME, CLUSTER_WAIT_TIME, USER_IO_WAIT_TIME, PLSQL_EXEC_TIME, JAVA_EXEC_TIME, SORTS, SHARABLE_MEM, TOTAL_SHARABLE_MEM from gv$sqlstats where inst_id=USERENV(‘Instance’) |
| V$SQLTEXT | select ADDRESS, HASH_VALUE, SQL_ID, COMMAND_TYPE , PIECE, SQL_TEXT from GV$SQLTEXT where inst_id = USERENV(‘Instance’) |
| V$SQLTEXT_WITH_NEWLINES | select ADDRESS, HASH_VALUE, SQL_ID, COMMAND_TYPE, PIECE, SQL_TEXT from GV$SQLTEXT_WITH_NEWLINES where inst_id = USERENV(‘Instance’) |
| V$SQL_BIND_DATA | select CURSOR_NUM , POSITION , DATATYPE , SHARED_MAX_LEN , PRIVATE_MAX_LEN , ARRAY_SIZE , PRECISION , SCALE , SHARED_FLAG , SHARED_FLAG2 , BUF_ADDRESS , BUF_LENGTH , VAL_LENGTH , BUF_FLAG , INDICATOR , VALUE from GV$SQL_BIND_DATA where inst_id = USERENV(‘Instance’) |
| V$SQL_BIND_METADATA | select ADDRESS , POSITION , DATATYPE , MAX_LENGTH , ARRAY_LEN , BIND_NAME from GV$SQL_BIND_METADATA where inst_id = USERENV(‘Instance’) |
| V$SQL_CURSOR | select CURNO , FLAG , STATUS , PARENT_HANDLE , PARENT_LOCK , CHILD_LOCK , CHILD_PIN , PERS_HEAP_MEM , WORK_HEAP_MEM , BIND_VARS , DEFINE_VARS , BIND_MEM_LOC , INST_FLAG , INST_FLAG2, CHILD_HANDLE from GV$SQL_CURSOR where inst_id = USERENV(‘Instance’) |
| V$SQL_JOIN_FILTER | SELECT qc_session_id, qc_instance_id, sql_plan_hash_value, length, bits_set, filtered, probed, active from GV$SQL_JOIN_FILTER where inst_id = USERENV(‘INSTANCE’) |
| V$SQL_OPTIMIZER_ENV | select ADDRESS, HASH_VALUE, SQL_ID, CHILD_ADDRESS, CHILD_NUMBER, ID, NAME, ISDEFAULT, VALUE from GV$SQL_OPTIMIZER_ENV where INST_ID = USERENV(‘Instance’) |
| V$SQL_PLAN | select ADDRESS, HASH_VALUE, SQL_ID, PLAN_HASH_VALUE, CHILD_ADDRESS, CHILD_NUMBER, TIMESTAMP, OPERATION, OPTIONS, OBJECT_NODE, OBJECT#, OBJECT_OWNER, OBJECT_NAME, OBJECT_ALIAS, OBJECT_TYPE, OPTIMIZER, ID, PARENT_ID, DEPTH, POSITION, SEARCH_COLUMNS, COST, CARDINALITY, BYTES, OTHER_TAG, PARTITION_START, PARTITION_STOP, PARTITION_ID, OTHER, DISTRIBUTION, CPU_COST, IO_COST, TEMP_SPACE, ACCESS_PREDICATES, FILTER_PREDICATES, PROJECTION, TIME, QBLOCK_NAME, REMARKS, OTHER_XML from GV$SQL_PLAN where inst_id = USERENV(‘Instance’) |
| V$SQL_PLAN_STATISTICS | select ADDRESS, HASH_VALUE, SQL_ID, PLAN_HASH_VALUE, CHILD_ADDRESS, CHILD_NUMBER, OPERATION_ID, EXECUTIONS, LAST_STARTS, STARTS, LAST_OUTPUT_ROWS, OUTPUT_ROWS, LAST_CR_BUFFER_GETS, CR_BUFFER_GETS, LAST_CU_BUFFER_GETS, CU_BUFFER_GETS, LAST_DISK_READS, DISK_READS, LAST_DISK_WRITES, DISK_WRITES, LAST_ELAPSED_TIME, ELAPSED_TIME from GV$SQL_PLAN_STATISTICS where inst_id = USERENV(‘Instance’) |
| V$SQL_PLAN_STATISTICS_ALL | select ADDRESS, HASH_VALUE, SQL_ID, PLAN_HASH_VALUE, CHILD_ADDRESS, CHILD_NUMBER, TIMESTAMP, OPERATION, OPTIONS, OBJECT_NODE, OBJECT#, OBJECT_OWNER, OBJECT_NAME, OBJECT_ALIAS, OBJECT_TYPE, OPTIMIZER, ID, PARENT_ID, DEPTH, POSITION, SEARCH_COLUMNS, COST, CARDINALITY, BYTES, OTHER_TAG, PARTITION_START, PARTITION_STOP, PARTITION_ID, OTHER, DISTRIBUTION, CPU_COST, IO_COST, TEMP_SPACE, ACCESS_PREDICATES, FILTER_PREDICATES, PROJECTION, TIME, QBLOCK_NAME, REMARKS, OTHER_XML, EXECUTIONS, LAST_STARTS, STARTS, LAST_OUTPUT_ROWS, OUTPUT_ROWS, LAST_CR_BUFFER_GETS, CR_BUFFER_GETS, LAST_CU_BUFFER_GETS, CU_BUFFER_GETS, LAST_DISK_READS, DISK_READS, LAST_DISK_WRITES, DISK_WRITES, LAST_ELAPSED_TIME, ELAPSED_TIME, POLICY, ESTIMATED_OPTIMAL_SIZE, ESTIMATED_ONEPASS_SIZE, LAST_MEMORY_USED, LAST_EXECUTION, LAST_DEGREE, TOTAL_EXECUTIONS, OPTIMAL_EXECUTIONS, ONEPASS_EXECUTIONS, MULTIPASSES_EXECUTIONS, ACTIVE_TIME, MAX_TEMPSEG_SIZE, LAST_TEMPSEG_SIZE from GV$SQL_PLAN_STATISTICS_ALL where inst_id = USERENV(‘Instance’) |
| V$SQL_REDIRECTION | select ADDRESS,PARENT_HANDLE,HASH_VALUE,SQL_ID,CHILD_NUMBER, PARSING_USER_ID, PARSING_SCHEMA_ID,COMMAND_TYPE, REASON, ERROR_CODE, POSITION, SQL_TEXT_PIECE, ERROR_MESSAGE from GV$SQL_REDIRECTION where inst_id = USERENV(‘Instance’) |
| V$SQL_SHARED_CURSOR | select SQL_ID, ADDRESS, CHILD_ADDRESS, CHILD_NUMBER, UNBOUND_CURSOR, SQL_TYPE_MISMATCH, OPTIMIZER_MISMATCH, OUTLINE_MISMATCH, STATS_ROW_MISMATCH, LITERAL_MISMATCH, SEC_DEPTH_MISMATCH, EXPLAIN_PLAN_CURSOR, BUFFERED_DML_MISMATCH, PDML_ENV_MISMATCH, INST_DRTLD_MISMATCH, SLAVE_QC_MISMATCH, TYPECHECK_MISMATCH, AUTH_CHECK_MISMATCH, BIND_MISMATCH, DESCRIBE_MISMATCH, LANGUAGE_MISMATCH, TRANSLATION_MISMATCH, ROW_LEVEL_SEC_MISMATCH, INSUFF_PRIVS, INSUFF_PRIVS_REM, REMOTE_TRANS_MISMATCH, LOGMINER_SESSION_MISMATCH, INCOMP_LTRL_MISMATCH, OVERLAP_TIME_MISMATCH, SQL_REDIRECT_MISMATCH, MV_QUERY_GEN_MISMATCH, USER_BIND_PEEK_MISMATCH, TYPCHK_DEP_MISMATCH, NO_TRIGGER_MISMATCH, FLASHBACK_CURSOR, ANYDATA_TRANSFORMATION, INCOMPLETE_CURSOR, TOP_LEVEL_RPI_CURSOR, DIFFERENT_LONG_LENGTH, LOGICAL_STANDBY_APPLY, DIFF_CALL_DURN, BIND_UACS_DIFF, PLSQL_CMP_SWITCHS_DIFF, CURSOR_PARTS_MISMATCH, STB_OBJECT_MISMATCH, ROW_SHIP_MISMATCH, PQ_SLAVE_MISMATCH, TOP_LEVEL_DDL_MISMATCH, MULTI_PX_MISMATCH, BIND_PEEKED_PQ_MISMATCH, MV_REWRITE_MISMATCH, ROLL_INVALID_MISMATCH, OPTIMIZER_MODE_MISMATCH, PX_MISMATCH, MV_STALEOBJ_MISMATCH, FLASHBACK_TABLE_MISMATCH, LITREP_COMP_MISMATCH from GV$SQL_SHARED_CURSOR where inst_id = USERENV(‘Instance’) |
| V$SQL_SHARED_MEMORY | select SQL_TEXT, SQL_FULLTEXT, HASH_VALUE, SQL_ID, HEAP_DESC, STRUCTURE, FUNCTION, CHUNK_COM , CHUNK_PTR , CHUNK_SIZE , ALLOC_CLASS , CHUNK_TYPE , SUBHEAP_DESC from GV$SQL_SHARED_MEMORY where inst_id = USERENV(‘Instance’) |
| V$SQL_WORKAREA | select ADDRESS, HASH_VALUE, SQL_ID, CHILD_NUMBER, WORKAREA_ADDRESS, OPERATION_TYPE, OPERATION_ID, POLICY, ESTIMATED_OPTIMAL_SIZE, ESTIMATED_ONEPASS_SIZE, LAST_MEMORY_USED, LAST_EXECUTION, LAST_DEGREE, TOTAL_EXECUTIONS, OPTIMAL_EXECUTIONS, ONEPASS_EXECUTIONS, MULTIPASSES_EXECUTIONS, ACTIVE_TIME, MAX_TEMPSEG_SIZE, LAST_TEMPSEG_SIZE from GV$SQL_WORKAREA where inst_id = USERENV(‘Instance’) |
| V$SQL_WORKAREA_ACTIVE | select SQL_HASH_VALUE, SQL_ID, WORKAREA_ADDRESS, OPERATION_TYPE, OPERATION_ID, POLICY, SID, QCINST_ID, QCSID, ACTIVE_TIME, WORK_AREA_SIZE, EXPECTED_SIZE, ACTUAL_MEM_USED, MAX_MEM_USED, NUMBER_PASSES, TEMPSEG_SIZE, TABLESPACE, SEGRFNO#, SEGBLK# from GV$SQL_WORKAREA_ACTIVE where INST_ID = USERENV(‘Instance’) |
| V$SQL_WORKAREA_HISTOGRAM | select LOW_OPTIMAL_SIZE, HIGH_OPTIMAL_SIZE, OPTIMAL_EXECUTIONS, ONEPASS_EXECUTIONS, MULTIPASSES_EXECUTIONS, TOTAL_EXECUTIONS from GV$SQL_WORKAREA_HISTOGRAM where INST_ID = USERENV(‘Instance’) |
| V$STANDBY_APPLY_SNAPSHOT | select SNAPSHOT_TIME, SESSION_ID, THREAD#, RESET_TIMESTAMP, SEQUENCE#, BLOCK#, APPLIED_SCN, APPLIED_TIME, NEWEST_RESET_TIMESTAMP, NEWEST_ARCHIVED_SEQ#, NEWEST_TIME, NEWEST_USED, NEWEST_SRL_SEQ#, BLOCKSIZE, APPLY_RATE from GV$STANDBY_APPLY_SNAPSHOT where INST_ID = USERENV(‘INSTANCE’) |
| V$STANDBY_LOG | select GROUP# , DBID , THREAD# , SEQUENCE# , BYTES , USED , ARCHIVED , STATUS , FIRST_CHANGE# , FIRST_TIME , LAST_CHANGE# , LAST_TIME from GV$STANDBY_LOG where inst_id = USERENV(‘Instance’) |
| V$STATISTICS_LEVEL | select statistics_name, description, session_status, system_status, activation_level, statistics_view_name, session_settable from gv$statistics_level where inst_id = USERENV(‘Instance’) |
| V$STATNAME | select STATISTIC# , NAME , CLASS, STAT_ID from GV$STATNAME where inst_id = USERENV(‘Instance’) |
| V$STREAMS_APPLY_COORDINATOR | SELECT SID, SERIAL#, STATE, APPLY#, APPLY_NAME, TOTAL_APPLIED,TOTAL_WAIT_DEPS,TOTAL_WAIT_COMMITS, TOTAL_ADMIN, TOTAL_ASSIGNED, TOTAL_RECEIVED,TOTAL_IGNORED, TOTAL_ROLLBACKS, TOTAL_ERRORS,LWM_TIME, LWM_MESSAGE_NUMBER, LWM_MESSAGE_CREATE_TIME,HWM_TIME, HWM_MESSAGE_NUMBER, HWM_MESSAGE_CREATE_TIME,STARTUP_TIME, ELAPSED_SCHEDULE_TIME, ELAPSED_IDLE_TIME from GV$STREAMS_APPLY_COORDINATOR where INST_ID = USERENV(‘Instance’) |
| V$STREAMS_APPLY_READER | select SID, SERIAL#, APPLY#, APPLY_NAME, STATE, TOTAL_MESSAGES_DEQUEUED, TOTAL_MESSAGES_SPILLED, DEQUEUE_TIME, DEQUEUED_MESSAGE_NUMBER, DEQUEUED_MESSAGE_CREATE_TIME, SGA_USED, ELAPSED_DEQUEUE_TIME, ELAPSED_SCHEDULE_TIME, ELAPSED_SPILL_TIME, LAST_BROWSE_NUM, OLDEST_SCN_NUM, LAST_BROWSE_SEQ, LAST_DEQ_SEQ, OLDEST_XIDUSN, OLDEST_XIDSLT, OLDEST_XIDSQN from GV$STREAMS_APPLY_READER where INST_ID = USERENV(‘Instance’) |
| V$STREAMS_APPLY_SERVER | select SID, SERIAL#, APPLY#, APPLY_NAME,SERVER_ID, STATE, XIDUSN, XIDSLT, XIDSQN, COMMITSCN,DEP_XIDUSN, DEP_XIDSLT, DEP_XIDSQN, DEP_COMMITSCN, MESSAGE_SEQUENCE,TOTAL_ASSIGNED, TOTAL_ADMIN, TOTAL_ROLLBACKS,TOTAL_MESSAGES_APPLIED, APPLY_TIME, APPLIED_MESSAGE_NUMBER, APPLIED_MESSAGE_CREATE_TIME,ELAPSED_DEQUEUE_TIME, ELAPSED_APPLY_TIME from GV$STREAMS_APPLY_SERVER where INST_ID = USERENV(‘Instance’) |
| V$STREAMS_CAPTURE | select SID, SERIAL#, CAPTURE#, CAPTURE_NAME, LOGMINER_ID, STARTUP_TIME, STATE, TOTAL_PREFILTER_DISCARDED, TOTAL_PREFILTER_KEPT, TOTAL_PREFILTER_EVALUATIONS,TOTAL_MESSAGES_CAPTURED, CAPTURE_TIME, CAPTURE_MESSAGE_NUMBER, CAPTURE_MESSAGE_CREATE_TIME, TOTAL_MESSAGES_CREATED, TOTAL_FULL_EVALUATIONS, TOTAL_MESSAGES_ENQUEUED, ENQUEUE_TIME, ENQUEUE_MESSAGE_NUMBER, ENQUEUE_MESSAGE_CREATE_TIME, AVAILABLE_MESSAGE_NUMBER, AVAILABLE_MESSAGE_CREATE_TIME, ELAPSED_CAPTURE_TIME, ELAPSED_RULE_TIME,ELAPSED_ENQUEUE_TIME, ELAPSED_LCR_TIME, ELAPSED_REDO_WAIT_TIME, ELAPSED_PAUSE_TIME, STATE_CHANGED_TIME from GV$STREAMS_CAPTURE where INST_ID = USERENV(‘Instance’) |
| V$STREAMS_POOL_ADVICE | select streams_pool_size_for_estimate, streams_pool_size_factor, estd_spill_count, estd_spill_time, estd_unspill_count, estd_unspill_time from gv$streams_pool_advice where inst_id = USERENV(‘Instance’) |
| V$STREAMS_TRANSACTION | select STREAMS_NAME, STREAMS_TYPE, XIDUSN, XIDSLT, XIDSQN, CUMULATIVE_MESSAGE_COUNT, TOTAL_MESSAGE_COUNT, FIRST_MESSAGE_TIME, FIRST_MESSAGE_TIME, LAST_MESSAGE_TIME, LAST_MESSAGE_TIME from GV$STREAMS_TRANSACTION where INST_ID = USERENV(‘Instance’) |
| V$SUBCACHE | select OWNER_NAME , NAME , TYPE , HEAP_NUM , CACHE_ID , CACHE_CNT , HEAP_SZ , HEAP_ALOC , HEAP_USED from GV$SUBCACHE where inst_id = USERENV(‘Instance’) |
| V$SYSAUX_OCCUPANTS | SELECT occupant_name, occupant_desc, schema_name, move_procedure, move_procedure_desc, space_usage_kbytes from gv$sysaux_occupants where inst_id = USERENV(‘INSTANCE’) |
| V$SYSMETRIC | SELECT begin_time, end_time, intsize_csec, group_id, metric_id, metric_name, value, metric_unit from gv$sysmetric where inst_id = USERENV(‘INSTANCE’) |
| V$SYSMETRIC_HISTORY | SELECT begin_time, end_time, intsize_csec, group_id, metric_id, metric_name, value, metric_unit from gv$sysmetric_history where inst_id = USERENV(‘INSTANCE’) |
| V$SYSMETRIC_SUMMARY | SELECT begin_time, end_time, intsize_csec, group_id, metric_id, metric_name, num_interval, maxval, minval, average, standard_deviation, metric_unit from gv$sysmetric_summary where inst_id = USERENV(‘INSTANCE’) |
| V$SYSSTAT | select STATISTIC# , NAME , CLASS , VALUE, STAT_ID from GV$SYSSTAT where inst_id = USERENV(‘Instance’) |
| V$SYSTEM_CURSOR_CACHE | select OPENS , HITS , HIT_RATIO from GV$SYSTEM_CURSOR_CACHE where inst_id = USERENV(‘Instance’) |
| V$SYSTEM_EVENT | select event,total_waits,total_timeouts,time_waited,average_wait, time_waited_micro, event_id, wait_class_id, wait_class#, wait_class from gv$system_event where inst_id = USERENV(‘Instance’) |
| V$SYSTEM_PARAMETER | select NUM , NAME , TYPE , VALUE , DISPLAY_VALUE, ISDEFAULT , ISSES_MODIFIABLE , ISSYS_MODIFIABLE , ISINSTANCE_MODIFIABLE, ISMODIFIED , ISADJUSTED , ISDEPRECATED, DESCRIPTION, UPDATE_COMMENT, HASH from GV$SYSTEM_PARAMETER where inst_id = USERENV(‘Instance’) |
| V$SYSTEM_PARAMETER2 | select NUM, NAME, TYPE, VALUE, DISPLAY_VALUE, ISDEFAULT, ISSES_MODIFIABLE, ISSYS_MODIFIABLE , ISINSTANCE_MODIFIABLE, ISMODIFIED , ISADJUSTED , ISDEPRECATED, DESCRIPTION, ORDINAL, UPDATE_COMMENT from GV$SYSTEM_PARAMETER2 where inst_id = USERENV(‘Instance’) |
| V$SYSTEM_WAIT_CLASS | select wait_class_id, wait_class#,wait_class,total_waits,time_waited from gv$system_wait_class where inst_id = USERENV(‘Instance’) |
| V$SYS_OPTIMIZER_ENV | select ID, NAME, ISDEFAULT, VALUE, DEFAULT_VALUE from GV$SYS_OPTIMIZER_ENV where INST_ID = USERENV(‘Instance’) |
| V$SYS_TIME_MODEL | select STAT_ID, STAT_NAME, VALUE from GV$SYS_TIME_MODEL where inst_id = USERENV(‘Instance’) |
| V$TABLESPACE | select TS# , NAME, INCLUDED_IN_DATABASE_BACKUP, BIGFILE, FLASHBACK_ON, ENCRYPT_IN_BACKUP from GV$TABLESPACE where inst_id = USERENV(‘Instance’) |
| V$TEMPFILE | select FILE# , CREATION_CHANGE# , CREATION_TIME , TS# , RFILE# , STATUS , ENABLED , BYTES, BLOCKS, CREATE_BYTES , BLOCK_SIZE , NAME from GV$TEMPFILE where inst_id = USERENV(‘Instance’) |
| V$TEMPORARY_LOBS | select SID, CACHE_LOBS, NOCACHE_LOBS, ABSTRACT_LOBS from GV$TEMPORARY_LOBS where inst_id = USERENV(‘Instance’) |
| V$TEMPSTAT | select FILE# , PHYRDS , PHYWRTS , PHYBLKRD , PHYBLKWRT , SINGLEBLKRDS, READTIM , WRITETIM, SINGLEBLKRDTIM, AVGIOTIM, LSTIOTIM, MINIOTIM, MAXIORTM, MAXIOWTM from GV$TEMPSTAT where inst_id = USERENV(‘Instance’) |
| V$TEMP_CACHE_TRANSFER | select file_number, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, s_2_null, s_2_null_forced_stale, rbr, rbr_forced_write, null_2_x, s_2_x, null_2_s from gv$temp_cache_transfer where inst_id = USERENV(‘Instance’) |
| V$TEMP_EXTENT_MAP | select TABLESPACE_NAME , FILE_ID , BLOCK_ID , BYTES , BLOCKS , OWNER , RELATIVE_FNO from GV$TEMP_EXTENT_MAP where inst_id = USERENV(‘Instance’) |
| V$TEMP_EXTENT_POOL | select TABLESPACE_NAME , FILE_ID , EXTENTS_CACHED , EXTENTS_USED , BLOCKS_CACHED , BLOCKS_USED , BYTES_CACHED , BYTES_USED , RELATIVE_FNO from GV$TEMP_EXTENT_POOL where inst_id = USERENV(‘Instance’) |
| V$TEMP_HISTOGRAM | select FILE# , SINGLEBLKRDTIM_MILLI, SINGLEBLKRDS from GV$TEMP_HISTOGRAM where inst_id = USERENV(‘Instance’) |
| V$TEMP_PING | select file_number, frequency, x_2_null, x_2_null_forced_write, x_2_null_forced_stale, x_2_s, x_2_s_forced_write, x_2_ssx, x_2_ssx_forced_write, s_2_null, s_2_null_forced_stale, ss_2_null, ss_2_rls, wrb, wrb_forced_write, rbr, rbr_forced_write, rbr_forced_stale, cbr, cbr_forced_write, null_2_x, s_2_x, ssx_2_x, null_2_s, null_2_ss, op_2_ss from gv$temp_ping where inst_id = USERENV(‘Instance’) |
| V$TEMP_SPACE_HEADER | select TABLESPACE_NAME , FILE_ID , BYTES_USED , BLOCKS_USED , BYTES_FREE , BLOCKS_FREE , RELATIVE_FNO from GV$TEMP_SPACE_HEADER where inst_id = USERENV(‘Instance’) |
| V$THREAD | select THREAD# , STATUS , ENABLED , GROUPS , INSTANCE , OPEN_TIME , CURRENT_GROUP# , SEQUENCE# , CHECKPOINT_CHANGE# , CHECKPOINT_TIME , ENABLE_CHANGE# , ENABLE_TIME , DISABLE_CHANGE# , DISABLE_TIME, LAST_REDO_SEQUENCE#, LAST_REDO_BLOCK, LAST_REDO_CHANGE#, LAST_REDO_TIME from GV$THREAD where inst_id = USERENV(‘Instance’) |
| V$THRESHOLD_TYPES | SELECT metrics_id, metrics_group_id, operator_mask, object_type, alert_reason_id, metric_value_type from gv$threshold_types where inst_id = USERENV(‘INSTANCE’) |
| V$TIMER | select HSECS from GV$TIMER where inst_id = USERENV(‘Instance’) |
| V$TIMEZONE_FILE | select FILENAME, VERSION from GV$TIMEZONE_FILE |
| V$TIMEZONE_NAMES | select TZNAME, TZABBREV from GV$TIMEZONE_NAMES |
| V$TRANSACTION | select ADDR , XIDUSN , XIDSLOT , XIDSQN , UBAFIL , UBABLK , UBASQN , UBAREC , STATUS , START_TIME , START_SCNB , START_SCNW , START_UEXT , START_UBAFIL , START_UBABLK , START_UBASQN , START_UBAREC , SES_ADDR , FLAG , SPACE , RECURSIVE , NOUNDO , PTX , NAME,PRV_XIDUSN , PRV_XIDSLT , PRV_XIDSQN , PTX_XIDUSN , PTX_XIDSLT , PTX_XIDSQN , “DSCN-B” , “DSCN-W” , USED_UBLK , USED_UREC , LOG_IO , PHY_IO , CR_GET , CR_CHANGE, START_DATE, DSCN_BASE, DSCN_WRAP, START_SCN, DEPENDENT_SCN, XID, PRV_XID, PTX_XID from gv$transaction where inst_id = USERENV(‘Instance’) |
| V$TRANSACTION_ENQUEUE | select ADDR , KADDR , SID , TYPE , ID1 , ID2 , LMODE , REQUEST , CTIME , BLOCK from GV$TRANSACTION_ENQUEUE where inst_id = USERENV(‘Instance’) |
| V$TRANSPORTABLE_PLATFORM | SELECT PLATFORM_ID, PLATFORM_NAME, decode(endian_format, 1,’Big’ ,0,’Little’,'UNKNOWN FORMAT’) from x$kcpxpl |
| V$TSM_SESSIONS | select sid, serial#, state, migratable, migration_allowed, transferable, migration_boundary, nonmigratability_reason, nonmigratability_info, nontransferability_reason, nontransferability_info, stateless, preserve_state, cost, destination, roundtrips, blocking_component, start_time, sequence_number from gv$tsm_sessions where inst_id = USERENV(‘Instance’) |
| V$TYPE_SIZE | select COMPONENT , TYPE , DESCRIPTION , TYPE_SIZE from GV$TYPE_SIZE where inst_id = USERENV(‘Instance’) |
| V$UNDOSTAT | select to_date(KTUSMSTRBEGTIME,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), to_date(KTUSMSTRENDTIME,’MM/DD/RR HH24:MI:SS’,'NLS_CALENDAR=Gregorian’), KTUSMSTTSN, KTUSMSTUSU, KTUSMSTTCT, KTUSMSTMQL, KTUSMSTRMQI, KTUSMSTMTC, KTUSMSTUAC, KTUSMSTUBS, KTUSMSTUBR, KTUSMSTXAC, KTUSMSTXBS, KTUSMSTXBR, KTUSMSTSOC, KTUSMSTOOS, KTUSMSTABK, KTUSMSTUBK, KTUSMSTEBK, KTUSMSTTUR from X$KTUSMST where INST_ID = userenv(‘instance’) |
| V$UNUSABLE_BACKUPFILE_DETAILS | select b.session_recid session_key, b.session_recid, b.session_stamp, a.* from (select a.rman_status_recid, a.rman_status_stamp, ‘BACKUPSET’ btype, b.recid btype_key, a.set_stamp id1, a.set_count id2, ‘BACKUPPIECE’ filetype,b.recid filetype_key,a.status,a.bytes filesize, a.device_type, a.handle filename, a.media, a.media_pool from v$backup_piece a, v$backup_set b where a.set_stamp = b.set_stamp and a.set_count = b.set_count and status <> ‘A’ union select rman_status_recid, rman_status_stamp, ‘IMAGECOPY’, recid, recid, stamp, ‘DATAFILECOPY’, recid, status, (blocks+1)*block_size, ‘DISK’, name, null, null from v$datafile_copy where status <> ‘A’ and file#<>0 union select rman_status_recid, rman_status_stamp, ‘IMAGECOPY’, recid, recid, stamp, ‘CONTROLFILECOPY’, recid, status, (blocks+1)*block_size, ‘DISK’, name, null, null from v$datafile_copy where status <> ‘A’ and file#=0 union select rman_status_recid, rman_status_stamp, ‘PROXYCOPY’, recid, recid, stamp, ‘DATAFILECOPY’, recid, status, (blocks+1)*block_size, device_type, handle, media, media_pool from v$proxy_datafile where status <> ‘A’ and file#<>0 union select rman_status_recid, rman_status_stamp, ‘PROXYCOPY’, recid, recid, stamp, ‘CONTROLFILECOPY’, recid, status, (blocks+1)*block_size, device_type, handle, media, media_pool from v$proxy_datafile where status <> ‘A’ and file#=0 union select rman_status_recid, rman_status_stamp, ‘PROXYCOPY’, recid, recid, stamp, ‘ARCHIVELOGCOPY’, recid, status, (blocks+1)*block_size, device_type, handle, media, media_pool from v$proxy_archivedlog where status <> ‘A’) a, v$rman_status b, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionkey skey from dual) c, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionfromTimeRange fTime from dual) d, (select /*+ no_merge */ sys.dbms_rcvman.sv_getsessionuntilTimeRange uTime from dual) e where a.rman_status_recid = b.recid (+) and a.rman_status_stamp = b.stamp (+) and (c.skey is null or c.skey = b.session_recid) and (d.fTime is null or d.fTime <= b.start_time) and (e.uTime is null or e.uTime >= b.end_time) |
| V$VERSION | select BANNER from GV$VERSION where inst_id = USERENV(‘Instance’) |
| V$VPD_POLICY | select ADDRESS,PARADDR,SQL_HASH,SQL_ID,CHILD_NUMBER, OBJECT_OWNER, OBJECT_NAME,POLICY_GROUP,POLICY,POLICY_FUNCTION_OWNER,PREDICATE from GV$VPD_POLICY where inst_id = USERENV(‘Instance’) |
| V$WAITCLASSMETRIC | SELECT begin_time, end_time, intsize_csec, wait_class#, wait_class_id, average_waiter_count, dbtime_in_wait, time_waited, wait_count from gv$waitclassmetric where inst_id = USERENV(‘INSTANCE’) |
| V$WAITCLASSMETRIC_HISTORY | SELECT begin_time, end_time, intsize_csec, wait_class#, wait_class_id, average_waiter_count, dbtime_in_wait, time_waited, wait_count from gv$waitclassmetric_history where inst_id = USERENV(‘INSTANCE’) |
| V$WAITSTAT | select class,count,time from gv$waitstat where inst_id = USERENV(‘Instance’) |
| V$WALLET | SELECT CERT_ID, DN, SERIAL_NUM, ISSUER, KEYSIZE, STATUS from GV$WALLET where inst_id = USERENV(‘INSTANCE’) |
| V$XML_AUDIT_TRAIL | select AUDIT_TYPE, SESSION_ID, PROXY_SESSIONID, STATEMENTID, ENTRYID, EXTENDED_TIMESTAMP, GLOBAL_UID, DB_USER, CLIENTIDENTIFIER, EXT_NAME, OS_USER, OS_HOST, OS_PROCESS, TERMINAL, INSTANCE_NUMBER, OBJECT_SCHEMA, OBJECT_NAME, POLICY_NAME, NEW_OWNER, NEW_NAME, ACTION, STATEMENT_TYPE, TRANSACTIONID, RETURNCODE, SCN, COMMENT_TEXT, AUTH_PRIVILEGES, GRANTEE, PRIV_USED, SES_ACTIONS, OS_PRIVILEGE, ECONTEXT_ID, SQL_BIND, SQL_TEXT from GV$XML_AUDIT_TRAIL where inst_id=USERENV(‘Instance’) |
| V$_LOCK | select LADDR , KADDR , SADDR , RADDR , LMODE , REQUEST , CTIME , BLOCK from GV$_LOCK where inst_id = USERENV(‘Instance’) |
| V$_LOCK1 | select LADDR , KADDR , SADDR , RADDR , LMODE , REQUEST , CTIME , BLOCK from GV$_LOCK1 where inst_id = USERENV(‘Instance’) |
| V$_SEQUENCES | select SEQUENCE_OWNER , SEQUENCE_NAME , OBJECT# , ACTIVE_FLAG , REPLENISH_FLAG , WRAP_FLAG , NEXTVALUE , MIN_VALUE , MAX_VALUE , INCREMENT_BY , CYCLE_FLAG , ORDER_FLAG , CACHE_SIZE , HIGHWATER , BACKGROUND_INSTANCE_LOCK , INSTANCE_LOCK_FLAGS from GV$_SEQUENCES where inst_id = USERENV(‘Instance’) |
