Table Name Acronym Expanded

x$bh buffer header

x$k2gte, kernel 2-phase

commit, global
transaction entry

x$k2gte2
x$kcbbf kernel cache, buffer
buffer_handles
x$kcbfwait kernel cache, buffer
file wait
x$kcbkpfs kernel cache, buffer
ckpt prefetch statistics

x$kcbobh kernel cache, buffer,

objectqueue buffer
header
x$kcboqh kernel cache, buffer,
object queue header
x$kcbsw kernel cache, buffer
statistics why

x$kcbwait kernel cache, buffer

wait
x$kcbwbpd kernel cache, buffer
workingset buffer pool
descriptor

x$kcbwds kernel cache, buffer

workingset descriptors

x$kcbwh kernel cache, buffer

where/why
x$kcccf kernel cache,
controlfilemanagement
control file
x$kcccp kernel cache,
controlfile checkpoint
progress
x$kccdi kernel cache,
controlfilemanagement
database information

x$kccle kernel cache,

controlfile logfile entry
x$kccnrs, x$kccrsp kernel cache,
controlfile non-
guaranteed
restorepoint; kernel
cache, controlfile
restore point

x$kcfio kernel cache, file I/O

x$kclcrst kernel cache, (RAC)
lock, consistent read
statistics
x$kclfh kernel cache, (RAC)
lock file hashtable
x$kclfi kernel cache, (RAC)
lock file index
x$kclfx kernel cache, (RAC)
lock freelist statistics
x$kcluh kernel cache, (RAC)
lock undo header
x$kclui kernel cache, (RAC)
lock undo index
x$kcrfstrand kernel cache, redo file
strand

x$kcrfx kernel cache, redo file

context
x$kdxst kernel data, index
status
x$kdxhs kernel data, index
histogram
x$kewrtb kernel event?,
workload repository
tables
x$kfdat kernel file, disk
allocation table?

x$kghlu kernel generic, heap

LRUs
x$kglcursor kernel generic,
librarycache cursor
x$kgllk kernel generic,
librarycache lock

x$kglob kernel generic,

librarycache object

x$kglpn kernel generic,

librarycache pin
x$kglrd kernel generic,
librarycache readonly
dependency

x$kglst kernel generic,

librarycache status
x$kgskvft kernel generic,
service, ?? fixed table

x$kqdpg kernel query,

dictionary PGA
x$kqfco kernel query, fixed
table columns
x$kqfdt kernel query, fixed
derived table

x$kqfp kernel query, fixed

procedure
x$kqfsz kernel query, fixed
size (size of fixed
objects in current
version of Oracle)
x$kqfta kernel query, fixed
table
x$kqfvi kernel query, fixed
view
x$kqfvt kernel query, fixed
view table (how fixed
view is built on fixed
tables)
x$kqrpd kernel query,
rowcache parent
definition
x$kqrsd kernel query,
rowcache subordinate
definition
x$krcfh, x$krcfde, kernel recovery,
x$krcfbh, x$krcbit changetracking file,
header, descriptor,
bitmap header, bitmap
block
x$ksled, x$kslei, kernel service, latch
x$ksles event descriptor, latch
events for instance,
latch events for
session
x$kslemap kernel service, latch
event map
x$ksllclass kernel service, latch,
latch class
x$kslpo kernel service, latch
posting
x$ksmfs kernel service,
memory fixed SGA
x$ksmfsv kernel service,
memory fixed SGA
variables

x$ksmhp kernel service,

memory heap

x$ksmjs kernel service,

memory java_pool
statistics
x$ksmlru kernel service,
memory LRU
x$ksmls kernel service,
memory large_pool
statistics
x$ksmmem kernel service,
memory

x$ksmpp kernel service,

memory pga heap
x$ksmsd kernel service,
memory sga definition

x$ksmsp kernel service,

memory sga heap

x$ksmspr kernel service,

memory shared pool
reserved
x$ksmss kernel service,
memory sga statistics

x$ksmup kernel service,

memory uga heap

x$ksolsfts kernel service, object

level statistics, fts?

x$ksppcv kernel service,

parameter, current
(session) value
x$ksppi kernel service,
parameter, parameter
info
x$ksppsv kernel service,
parameter, system
value
x$ksqeq kernel service,
enqueue en-queue
x$ksqrs kernel service,
enqueue resource
x$ksqst kernel service,
enqueue_managemen
t statistics types
x$ksulv kernel service, user
locale value
x$ksulop kernel service, user
long operation
x$ksupgp kernel service, user
process group
x$ksupr kernel service, user
process
x$ksuse kernel service, user
session
x$ksuvmstat kernel service, user
virtual memory
statistics
x$kswsastab kernel service,
workgroup services,

x$ktcxb kernel transaction,

control object

x$ktfbfe kernel transaction, file

bitmap free extent
x$ktfbhc kernel transaction, file
bitmap header control

x$ktfbue kernel transaction, file

bitmap used extent

x$ktifb, x$ktiff, kernel transaction, ?

x$ktifp, x$ktifv flush ?
x$ktprxrt kernel transaction,
parallel transaction
rollback
x$ktuxe kernel transaction,
undo transaction entry

x$kxfpsds kernel execution, fast

process slave
dequeue statistics
x$kxsbd kernel execution, SQL
bind data

x$kzsprv kernel security,

session privilege
x$kzsro kernel security,
session role
x$le lock element

x$le_stat lock element status

x$messages (background process)
messages
x$qksceses, query compilation
x$qkscesys service, compilation
environment, session
or system

x$targetrba target RBA

x$trace

x$uganco user global area,

network connection

Note 1 x$kglcursor
columns
 Comments
The most common use of this table is to find the object and the file# and block# of its header when there's high cache buffers chains latch contention:
select obj, dbarfil, dbablk from x$bh a, v$latch_children b where a.hladdr = b.addr for the said latch (whose sleeps you think are too high). You can
also use this table to see if a specific buffer has too many clones: select dbarfil, dbablk, count(*) from x$bh group by dbarfil, dbablk having count(*) >
2. Note that obj column matches dba_objects.data_object_id, not object_id. For performance reason, don't merge dba_extents with the query of x$bh
that has a group by, unless you use in-line view and no_merge hint (see J. Lewis Practical Oracle8i, p.215) The tch column, touch count, records
how many times a particular buffer has been accessed. Its flag column is explained by J. Lewis; explanation of state, mode and indx can be found in
Anjo Kolk's paper. Tim is time the buffer touch happened (276392.996). Lru_flag is about the buffer's hot/cold feature (Ref and 221860.999); 8 is often
used to find hot blocks.
Mark Bobak's query (originally in Metalink forum thread 524821.994, where he further attributed authorship) uses
this table to find sessions coming from or going to a remote database; in short, x$k2gte.k2gtdses matches
v$session.saddr, .k2gtdxcb matches v$transaction.addr. select /*+ ordered */ substr(s.ksusemnm,1,10)||'-'||
substr(s.ksusepid,1,10) origin, substr(g.k2gtitid_ora,1,35) gtxid, substr(s.indx,1,4)||'.'|| substr(s.ksuseser,1,5)
lsession, s.ksuudlna username, substr(decode(bitand(ksuseidl,11), 1,'ACTIVE', 0, decode( bitand(ksuseflg,4096)
, 0,'INACTIVE','CACHED'), 2,'SNIPED', 3,'SNIPED', 'KILLED'),1,1) status, e.kslednam waiting from x$k2gte g,
x$ktcxb t, x$ksuse s, x$ksled e where g.k2gtdxcb=t.ktcxbxba and g.k2gtdses=t.ktcxbses and s.addr=g.k2gtdses
and e.indx=s.ksuseopc; It's more robust than this query, and better than checking for DX locks for outgoing
sessions (since a DX lock only shows up in v$lock for the current distributed transaction session). X$k2gte2 is
the same as x$k2gte except on k2gtetyp which may show 2 for 'TIGHTLY COUPLED' instead of 0 for 'FREE'.
One use of x$k2gte[2] is the clearly translated global transaction ID in k2gtitid_ora as opposed to the hex
numbers in v$global_transaction.globalid.

Jonathan Lewis ("_db_handles")

A commonly used query breaks down the contents of v$waitstat into per-datafile statistics: select name, count,
time from v$datafile df, x$kcbfwait fw where fw.indx+1 = df.file#
Tanel Poder

10g and up. Tanel Poder

See above

Note:34405.1 (select kcbwhdes, why0+why1+why2 "Gets", "OTHER_WAIT" from x$kcbsw s, x$kcbwh w where
s.indx=w.indx and s."OTHER_WAIT">0 order by 3), Ref1 ("statistics about the way these [x$kcbwh] functions
have been used")

See 183770.999 for relationship to x$bh and x$kcbwds. Some people use this query to find how many blocks of a segmen

See above. Also see Ref1, Ref2, Ref3. Total row count in this table is _db_block_lru_latches, although only
db_writer_processes rows have real numbers.

See x$kcbsw for SQL. Ref1 ("different functions that may be used to perform different types of logical I/O"), Ref2

In 10gR1, to find controlfile size as viewed at OS level but from inside Oracle, select cfnam, (cffsz+1)*cfbsz from x$kcccf. c
S. Adams and K Gopalakrishnan use this view to find how much the current redo log is filled. Eygle studied
instance heartbeat, column cphbt.

lebsz may be used to show redo logfile block size, usually 512; should report the same as the command dbfsize
redologfile ($ORACLE_HOME/bin/dbfsize is available on UNIX only)
Base tables of v$restore_point, for non-guaranteed and guaranteed restore points. Retain records of them after
they were dropped

base table of v$cr_block_server or v$bsp, used to troubleshoot global cache cr requests

See Ref1, Ref2. If lwm is too low, you may see 'gc freelist' wait.

10g and up. Info about redo strands. Non-zero pvt_strand_state_kcrfa_cln means a transaction is using this private strand

"columns bfs (buffer size) and bsz (block size). Dividing bfs by bsz gives mxr (the maximum number of blocks to read size)

used in catalog.sql to create index_stats

used in catalog.sql to create index_histogram

See Note:555124.1

Only populated in ASM instance. See Note:351117.1 and Julian Dyke et al Pro Oracle Database 10g RAC on
Linux, pp.232-3. Column v_kfdat is 'V' for allocated and 'F' for free. For most ASM-related x$ tables, read Luca
Canali.

Base table for v$sql, v$sqlarea. Fixed view based on x$kglob according to x$kqfdt. See Note 1 or x$kglob for more details
Used in catblock.sql to build dba_kgllock. kgllkuse or kgllkses maps to v$session.saddr, kgllkpnc call pin,
kgllkpns session pin, kgllkmod lock held (0: no lock; 1: null; 2: shared; 3: exclusive), kgllkflg (allegedly 8 for pre-
10g or 2048 for 10g meaning SQL being run, Ref; 256 for broken kgl lock in 10g or 1 in 9i, Ref), kgllkspn
savepoint. If you get library cache lock or pin wait, kgllkhdl matches v$session_wait.p1raw (handle address), and
kglnaobj is the first 80 characters of the object name. Note:122793.1 has this SQL for our convenience: select *
from x$kgllk lock_a where kgllkreq = 0 and exists (select lock_b. kgllkhdl from x$kgllk lock_b where kgllkses =
'&saddr_from_v$session' /* blocked session */ and lock_a.kgllkhdl = lock_b.kgllkhdl and kgllkreq > 0). Kgllkadr
column is shown in event 10270 trace files to find SQLs in session cursor cache (Ref)

To find library cache object for wait events library cache pin or lock and pipe get or put, match kglhdadr with
v$session_wait.p1raw. kglhdflg is partially explained in Note:311689.1 (for permanent keeping). kglhddmk may
be data object load mask; can be used to identify the number of the loaded heap, counted from 0 (see comment
of 06/12/01 in Bug:1164709). Steve Adams' objects_on_hot_latches.sql finds the way Oracle links a library
cache object (based on kglnahsh) to a specific library cache child latch. x$kglob, and in case of cursors
x$kglcursor too, can be used to find library cache objects that are partially built therefore not visible in
v$sql(XXX), v$open_cursor, v$object_dependency. (Try typing select *; and enter, then check these views!)

used in catblock.sql to build dba_kgllock. Some columns are simiarly explained for x$kgllk.

kglnacnm (container name?) is PL/SQL program unit or anonymous block while kglnadnm (dependent name?) is the indivi

Base table of v$blocking_quiesce. If the blocking session is not in SYS_GROUP consumer group according to
v$rsrc_session_info, v$blocking_quiesce ignores it. Workaround is to directly query x$kgskvft. (Ref; Bug
7832504)
Row cache cursor statistics, columns explained in "How can you tune it?" section of Tuning the _row_cache_cursors Param

x$kqfco.kqfcotab=x$kqfta.indx

acronym explained by Julian Dyke: it contains x$kglcursor, x$kgltable etc. which are based on x$kglob; effectively these a

used in catprc.sql to build disk_and_fixed_objects view

Base table of v$fixed_table, whose object_id (indx of x$kqfta) matches obj# of tab_stats$, the table
dbms_stats.gather_fixed_objects_stats inserts stats into.

Column kqrpdosz is size of this parent rowcache object, not exposed in v$rowcache_parent although shown in
rowcache dump.
Column kqrsdosz is size of this subordinate rowcache object, not exposed in v$rowcache_subordinate although
shown in rowcache dump.

Alex Gorbachev

Base tables for v$event_name, v$system_event, and v$session_event, respectively. Benefit of querying x$ksles:
(1) When ksleswts (wait count) is 0, v$session_event won't have the row but x$ksles still has them with non-zero
kslestim (time waited micro) or kslesmxt (max wait time in micro); (2) Since kslesmxt is in microsec, it could be
non-zero even if v$session_event.max_wait is 0. x$kslei has benefit (2) over v$system_event.

"Indx = event number...Basically map events to a small number of useful classes like I/O waits" (Ref)

"describes the 8 classes", "Specify which latch belongs to which class" with _latch_class_ (Ref)

Note:653299 says it "tracks which function is posting smon". Ksllwnam column (the part before semicolon if it exists) can m

also contains db_block_buffers and log_buffer sizes for some reason

detailing fixed SGA: select a.ksmfsnam, a.ksmfstyp, a.ksmfssiz, b.ksmmmval from x$ksmfsv a, x$ksmmem b where a.ksm

S. Adams, "What it returns depends on which heap descriptor you join to it. It is effectively a function returning
the contents of an arbitrary heap that takes the heap descriptor as its argument." You need to join this table to
another one on heap descriptor ksmchds, such as in v$sql_shared_memory (joining to x$kglcursor), or to
x$ksmsp (ksmchds=x$ksmsp.ksmchpar), and use use_nl hint. Example.

Refer to Metalink Notes 61623.1 and 43600.1 for details. Note that query on this table can only be done once; subsequent query
returns no rows unless large chunk shared pool allocations happened in the interim.

Entire SGA memory map. You can find your database version by select ksmmmval from x$ksmmem where indx
= 2 (if it's 64-bit Oracle, try 1), regardless machine architecture endian-ness. Note that the 4 bytes containing the
version are delimited as XX.X.XX.X.XX so 09200300 is 9.2.0.3.0. Due to memory guard pages, you can only
select from x$ksmmem specifying rownum < some number or indx = some value; otherwise the session may
hang or throws ORA-3113 (Windows doesn't seem to have this problem). Indx is SGA index, i.e. SGA address
minus sgabeg (which is x$ksmmem.addr where indx = 0), divided by architecture word size (4 for 32-bit, 8 for 64-
bit machines); e.g., the value stored at address 0x9CD3F5D0 on a 64-bit machine (which is really address
0x000000009CD3F5B0) whose sgabeg is 0x60000000 can be calculated as:

select (to_number('9CD3F5D0','xxxxxxxx') - to_number('60000000','xxxxxxxx')) /8 from dual;

select ksmmmval from x$ksmmem where indx = 127565498;
PGA heap (variable area). PGA subheaps: select /*+use_nl(h,p)*/ h.ksmchds,p.ksmchcom, h.ksmchcom
ksmchnam,h.ksmchsiz, h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmpp p where h.ksmchds = p.ksmchpar and
p.ksmchcls like '%recr' and p.ksmchpar != hextoraw('00');
The 3rd argument of ORA-4031 tells you which section of shared (or java or large) pool is short of memory. It
matches x$ksmsp.ksmchcom (or v$sgastat.name). SGA heaps: select /*+use_nl(h,s)*/ sess.sid, sess.username,
h.ksmchds, h.ksmchcom ksmchnam, h.ksmchsiz, h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmsp s,v$session
sess where h.ksmchds = s.ksmchpar and s.ksmchcls like '%recr' and s.ksmchpar != hextoraw('00') and
h.ksmchown = sess.saddr; SGA subheaps: select /*+use_nl(h,s)*/ h.ksmchds,s.ksmchcom,h.ksmchcom
ksmchnam, h.ksmchsiz,h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmsp s where h.ksmchds = s.ksmchpar and
s.ksmchcls like '%recr'and s.ksmchpar != hextoraw('00');

The 3rd argument of ORA-4031 tells you which section of shared (or java or large) pool is short of memory. It
matches x$ksmss.ksmssnam (or v$sgastat.name).

UGA heap (variable area). UGA subheaps: select /*+use_nl(h,s)*/ h.ksmchds,u.ksmchcom,h.ksmchcom

ksmchnam,h.ksmchsiz,h.ksmchcls,h.ksmchpar from x$ksmhp h,x$ksmup u where h.ksmchds = u.ksmchpar and
u.ksmchcls like '%recr' and u.ksmchpar != hextoraw('00');
Base table of v$segstat and v$segment_statistics. Fts_stmp records the last time fts_staval was updated,
fts_preval the previously recorded value. Fts_inte greater than 0 reveals some less known types of statistics.
Note that value in v$segstat or v$segment_statistics is cumulative; e.g., if "row lock waits" is non-zero, the waits
may not be happening right now.
Base table of v$parameter and v$parameter2. See comments on x$ksppi.

Base table of v$parameter, v$system_parameter and v$system_parameter2. Often used to see undocumented parameters:
select a.ksppinm Parameter, a.ksppdesc Description, b.ksppstvl "Session Value", c.ksppstvl "Instance Value" from x$ksppi a, x$ksppcv b, x$ksppsv c
where a.indx = b.indx and a.indx = c.indx and a.ksppinm like '\_%' escape '\' order by 1

Base table of v$system_parameter and v$system_parameter2. See comments on x$ksppi.

"shows all outstanding enqueues with an additional flag. It basically shows the same information as the v$lock table." from

Acronym explained by K Gopalakrishnan. You can find how many times each type of enqueue lock has been taken since i

Ksupgpnm!='DEFAULT' may suggest session leaking (Ref)

T. Poder finds hidden recursive session based on ksuseflg.

In 10g and up, base table providing physical_memory_bytes to v$osstat (and VM paging stats on Windows). But
on Linux up to Oracle 10.2.0.3, this number is system free memory in kilobytes (grep MemFree /proc/meminfo); on
other OSes or 10.2.0.4 or up on Linux, it is "Total number of bytes of physical memory".
Base table of v$services and a few other service-related views. v$services may need
x$kswsastab.kswsastabpflg=0 restriction; otherwise stopped services linger in the view till instance bounce.

Base table of v$transaction. Four bits of ktcxbflg column, exposed as v$transaction.flag, are explained in
v$fixed_view_definition. Metalink Mark Bobak and Melissa Holman explain the bit for isolation level. Since
v$transaction is empty without a transaction, you can directly query x$ktcxb to find sessions with serializable
isolation level: select * from v$session where taddr in (select ktcxbxba from x$ktcxb where
bitand(ktcxbflg,268435456) <> 0). Other bits of ktcxbflg not shown in v$fixed_view_definition are: bit 1 read write
and read committed, 4(?) read only, 13 using private strand (Ref).

Free extent bitmap in file header for LMT (equivalent to fet$ in DMT); check dba_free_space view definition

Summarizes free space with one row per datafile (Ref); check dba_data_files or dba_temp_files view definition

Used extent bitmap in file header for LMT (equivalent to uet$ in DMT)

Probably related to in-memory undo. See 7th bullet of IMU.txt.

Fairlie Rego

"get the SCN of the most recently committed (local) transaction" with select max(ktuxescnw * power(2, 32) +
ktuxescnb) from x$ktuxe (Ref); select * from x$ktuxe where ktuxecfl = 'DEAD' and ktuxesta = 'ACTIVE' "shows
transaction dead waiting for cleanup" (Ref)
Current list of reasons for parallel execution dequeuing, as explained for wait event "parallel query dequeue wait" in Anjo K

Base table of v$sql_bind_data. Column kxsbdof2 (or shared_flag2 of v$sql_bind_data) is oacfl2 (not oacflg2 as
in Note:39817.1) in SQL trace. "System-generated binds have a value of 256 in the SHARED_FLAG2 column".
According to Bug 4359367, when it's 0x300, the bind variable is marked as unsafe (affecting
cursor_sharing=similar). Note:296377.1 has more on its value.
Session-specific. Base table for v$enabledprivilege, which is base table of session_privs

used in many SQL scripts in ?/rdbms/admin

See the definition of GV$BH for its relationship with x$bh. Note that v$gc_element differs slightly from
v$lock_element and documentation for v$gc_element is really for v$lock_element.

May be the place where processes store and fetch messages. Related to _messages parameter, messages
latch, and "rdbms ipc (message|reply)" wait events.
Base tables for v$ses_optimizer_env and v$sys_optimizer_env, respectively. There're so many optimizer
parameters the two documented views are missing that sometimes you need to query these base tables directly.
Select pname_qksceserow from x$qksceses minus select name from v$ses_optimizer_env to have a feel of the
missing ones. Or subtract v$sys_optimizer_env.name from x$qkscesys.pname_qkscesyrow.

Ref
Beginning with 9i, x$trace records event tracing info. 10g RAC bdump/cdmp_time directory has trw files that
contain the same info (the trace file seems to have columns TimeInMicroSec:?, OraclePid, SID, event, OpCode,
TraceData). select event, count(*) from x$trace group by event shows what events are enabled internally (not
shown in v$parameter). oerr ora eventID on UNIX shows the event name. RAC databases should have GES and
GCS related events set. select pid, count(*) from x$trace group by pid shows how many events have been
trapped by each oracle process (including those that exited). select sid, pid, count(*) from x$trace where (sid,
pid) in (select sid, pid from v$session s, v$process p where s.paddr = p.addr) group by sid, pid order by 1, 2
shows the numbers for each currently existing session (I think without the where clause, exited sessions would
be included). select event, op, time, seq#, data from x$trace where sid = &sid and pid = &pid order by time
shows traced events for a session in question.

Base table of v$dblink. Since it's about UGA, each session has different content. After you end your distributed
transactions (which includes distributed queries) and close database links, v$dblink no longer shows the entries.
But x$uganco still has them, with ncoflg set to 8320 and hstflg set to 0. Unfortunately this is not very useful
because you can't see the UGA content from a different session.