Donnerstag, 8. Januar 2015

ORADEBUG DOC 12.1.0.2

this is just an online docu of ORADEBUG DOC in 12.1.0.2.
The general comments from Tanel Poder apply to this version as well.




SQL> oradebug doc

Internal Documentation
**********************

  EVENT                           Help on events (syntax, event list, ...)
  COMPONENT       [<comp_name>]   List all components or describe <comp_name>

ORADEBUG DOC EVENT

SQL> oradebug doc event

Event Help:
***********

  Formal Event Syntax
  --------------------
    <event_spec>   ::= '<event_id> [<event_scope>]
                                   [<event_filter_list>]
                                   [<event_parameters>]
                                   [<action_list>]
                                   [off]'

    <event_id>     ::= <event_name | number>[<target_parameters>]

    <event_scope>  ::= [<scope_name>: scope_parameters]

    <event_filter> ::= {<filter_name>: filter_parameters}

    <action>       ::= <action_name>(action_parameters)

    <action_parameters> ::= <parameter_name> = [<value>|<action>][, ]

    <*_parameters> ::= <parameter_name> = <value>[, ]


  Some Examples
  -------------
    * Set event 10235 level 1:
      alter session set events '10235';

    * Set events SQL_TRACE (a.k.a. 10046) level 1:
      alter session set events 'sql_trace';

    * Turn off event SQL_TRACE:
      alter session set events 'sql_trace off';

    * Set events SQL_TRACE with parameter <plan_stat> set to 'never'
      and parameter <wait> set to 'true':
      alter session set events 'sql_trace wait=true, plan_stat=never';

    * Trace in-memory the SQL_MONITOR component (the target) and all its
      sub-components at level high. Get high resolution time for each
      trace:
      alter session set events 'trace[sql_mon.*] memory=high,
                                                 get_time=highres';

    * On-disk trace PX servers p000 and p005 for components 'sql_mon'
      and 'sql_optimizer' (including sub-components) at level highest:
      alter system set events 'trace[sql_mon | sql_optimizer.*]
                            {process: pname = p000 | process: pname=p005}';

    * Same as above but only when SQL id '7ujay4u33g337' is executed:
      alter system set events 'trace[sql_mon | sql_optimizer.*]
                                    [sql: 7ujay4u33g337]
                            {process: pname = p000 | process: pname=p005}';

    * Execute an action immediatly by using 'immediate' for the event
      name:
      alter session set events 'immediate eventdump(system)'

    * Create an incident labeled 'table_missing' when external error
      942 is signaled by process id 14534:
      alter session set events '942 {process: 14534}
                                    incident(table_missing)';


  Notes
  -----
    * Implicit parameter level is 1 by default
      e.g. '10053' is same as '10053 level 1'

    * Event target (see [<target_parameters>] construct) is only
      supported by specific events like the TRACE[] event

    * <event_scope> and/or <event_filter> are constructs
      that can be used for any event

    * Same event can be set simultaneously for a different scope or
      target but not for different filters.

    * '|' character can be used to select multiple targets, scope or
      filters.

      E.g. 'sql_trace [sql: sql_id=g3yc1js3g2689 | sql_id=7ujay4u33g337]'

    * '=' sign is optional in <*_parameters>

      E.g. 'sql_trace level 12';

    * Like PL/SQL, no need to specify the parameter name for target,
      scope, filters and action. Resolution is done by position in
      that case:

      E.g. 'sql_trace [sql: g3yc1js3g2689 | 7ujay4u33g337]'


  Help sub-topics
  ---------------

    NAME    [<event_name>]      List all events or describe <event_name>
    SCOPE   [<scope_name>]      List all scopes or describe <scope_name>
    FILTER  [<filter_name>]     List all filters or describe <filter_name>
    ACTION  [<action_name>]     List all actions or describe <action_name>


SQL> spool off


ORADEBUG DOC EVENT NAME

SQL> oradebug doc event name

Events in library DIAG:
------------------------------
trace[]              Main event to control UTS tracing
disable_dde_action[] Event used by DDE to disable actions
ams_trace[]          Event to dump ams performance trace records
ams_rowsrc_trace[]   Event to dump ams row source tracing
sweep_verification   Event to enable sweep file verification
enable_xml_inc_staging Event to enable xml incident staging format
dbg[]                Event to hook dbgtDbg logging statements

Events in library RDBMS:
------------------------------
wait_event[]         event to control wait event post-wakeup actions
alert_text           event for textual alerts
trace_recursive      event to force tracing recursive SQL statements
clientid_overwrite   event to overwrite client_identifier when client_info is set
sql_monitor          event to force monitoring SQL statements
sql_monitor_test     event to test SQL monitoring
eventsync_tac        Event posted from events syncing tac
sql_trace            event for sql trace
pmon_startup         startup of pmon process
background_startup   startup of background processes
db_open_begin        start of db open operation
test_gvtf            test GV$() Table Tunction
fault                Event used to inject fault in RDBMS kernel
gcr_systest          gcr_systest
em_express           EM Express debug event
emx_control          event to control em express
emx_test_control     event to control em express testing
awrdiag[]            AWR Diagnostic Event
msgq_trace           event to control msgq tracing
ipclw_trace          event to control ipclw tracing
kbc_fault            event to control container fault injection
asm_corruption_trace event to control ASM corruption tracing
kxdrs_sim            debug event to simulate certain conditions in kxdrs layer

kcfio_debug          debug event to debug kcfio based on event level

krbabrstat_fault     event to control krbabrstat fault injection
periodic_dump[]      event for periodically dumping

Events in library GENERIC:
------------------------------
kg_event[]           Support old error number events (use err# for short)

Events in library CLIENT:
------------------------------
oci_trace            event for oci trace

Events in library LIBCELL:
------------------------------
libcell_stat         libcell statistics level specification
cellclnt_skgxp_trc_ops Controls to trace SKGXP operations
cellclnt_ossnet_trc  Controls to trace IP affinity in ossnet
cellclnt_high_lat_ops Control to trace High-latency I/O operations
diskmon_sim_ops[]    Diskmon simulation events
cellclnt_read_outlier_limit Control to trace read I/O outliers
cellclnt_write_outlier_limit Control to trace write I/O outliers
cellclnt_lgwrite_outlier_limit Control to trace log write I/O outliers
cellclnt_sparse_mode Mode of how to handle sparse buffers

Events in library ADVCMP:
------------------------------
arch_comp_level[]    arch_comp_level[<ulevel, 1-7>]
ccmp_debug           columnar compression debug event
inmemory_nobasic     disable KDZCF_IMC_BASIC implementation
inmemory_nohybrid    disable KDZCF_IMC_HYBRID implementation
ccmp_align           columnar compression enable alignment
ccmp_countstar       columnar compression enable count(*) optimization
ccmp_dumpunaligned   columnar compression dump dbas of unaligned CUs
ccmp_rbtree          columnar compression switch back to rb tree
inmemory_force_ccl   inmemory force column compression levels
inmemory_imcu[]      inmemory_imcu[<ulevel=  nocomp|dml|query_low|query_high|capacity_low|capacity_high>]

Events in library PLSQL:
------------------------------
plsql_event[]        Support PL/SQL error number events


SQL> spool off


ORADEBUG DOC EVENT NAME <event_name>
SQL> ORADEBUG DOC EVENT NAME trace

trace: Main event to control UTS tracing

Usage
-------
trace [ component       <string>[0] ]
   disk            < default | lowest | low | medium | high | highest | disable >,
   memory          < default | lowest | low | medium | high | highest | disable >,
   get_time        < disable | default | seq | highres | seq_highres >,
   get_stack       < disable | default | force >,
   operation       <string>[32],
   function        <string>[32],
   file            <string>[32],
   line            <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME disable_dde_action

disable_dde_action: Event used by DDE to disable actions

Usage
-------
disable_dde_action [ action_name     <string>[100] ]
   facility        <string>[20],
   error           <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME ams_trace

ams_trace: Event to dump ams performance trace records

Usage
-------
ams_trace [ relation        <string>[30] ]

SQL> spool off


SQL> ORADEBUG DOC EVENT NAME ams_rowsrc_trace

ams_rowsrc_trace: Event to dump ams row source tracing

Usage
-------
ams_rowsrc_trace [ relation        <string>[30] ]
   level           <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME dbg

dbg: Event to hook dbgtDbg logging statements

Usage
-------
dbg [ component       <string>[0] ]
   operation       <string>[32],
   function        <string>[32],
   file            <string>[32],
   line            <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME wait_event

wait_event: event to control wait event post-wakeup actions

Usage
-------
wait_event [ name            <string>[64] ]


SQL> ORADEBUG DOC EVENT NAME awrdiag

awrdiag: AWR Diagnostic Event

Usage
-------
awrdiag [ name            <string>[64] ]
   level           <ub4>,
   str1            <string>[256],
   str2            <string>[256],
   num1            <ub8>,
   num2            <ub8>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME periodic_dump

periodic_dump: event for periodically dumping

Usage
-------
periodic_dump [ name            <string>[64] ]
   level           <ub4>,
   seconds         <ub4>,
   lifetime        <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME kg_event

kg_event: Support old error number events (use err# for short)

Usage
-------
kg_event [ errno           <ub4> ]
   level           <ub4>,
   lifetime        <ub4>,
   armcount        <ub4>,
   traceinc        <ub4>,
   forever         <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME diskmon_sim_ops
Error: "diskmon_sim_ops" not a known event/library name
Use <event_name>, <library_name> or <library_name>.<event_name>

SQL> spool off


SQL> ORADEBUG DOC EVENT NAME arch_comp_level

arch_comp_level: arch_comp_level[<ulevel, 1-7>]

Usage
-------
arch_comp_level [ ulevel          <ub4> ]
   ilevel          <ub8>,
   sortcols        <ub4>,
   cusize          <ub4>,
   analyze_amt     <ub4>,
   analyze_rows    <ub4>,
   analyze_minrows <ub4>,
   mincusize       <ub4>,
   maxcusize       <ub4>,
   mincurows       <ub4>,
   align           <ub4>,
   rowlocks        <ub4>,
   maxcuhpctfree   <ub4>,
   guarantee_rll   <ub4>,
   cla_stride      <ub4>,
   dict_cla_stride <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME inmemory_imcu

inmemory_imcu: inmemory_imcu[<ulevel=  nocomp|dml|query_low|query_high|capacity_low|capacity_high>]

Usage
-------
inmemory_imcu [ ulevel       < invalid | nocomp | dml | query_low | query_high | capacity_low | capacity_high > ]
   target_rows     <ub4>,
   source_maxbytes <ub4>


SQL> spool off


SQL> ORADEBUG DOC EVENT NAME plsql_event

plsql_event: Support PL/SQL error number events

Usage
-------
plsql_event [ errno           <ub4> ]

SQL> spool off



ORADEBUG DOC EVENT SCOPE

SQL> oradebug doc event scope

Event scopes in library RDBMS:
------------------------------
SQL[]                sql scope for RDBMS


SQL> spool off


ORADEBUG DOC EVENT SCOPE SQL
SQL> oradebug doc event scope sql

SQL: sql scope for RDBMS

Usage
-------
[SQL:  sql_id          <string>[20] ]


SQL> spool off



ORADEBUG DOC EVENT FILTER

SQL> ORADEBUG DOC EVENT FILTER

Event filters in library DIAG:
------------------------------
occurence            filter to implement counting for event checks
callstack            filter to only fire an event when a function is on the stack
eq                   filter to only fire an event when a == b
ne                   filter to only fire an event when a != b
gt                   filter to only fire an event when a > b
lt                   filter to only fire an event when a < b
ge                   filter to only fire an event when a >= b
le                   filter to only fire an event when a <= b
anybit               filter to only fire an event when (a & b) != 0
allbit               filter to only fire an event when (a & b) == b
nobit                filter to only fire an event when (a & b) == 0
bet                  filter to only fire an event when b <= a <= c
nbet                 filter to only fire an event when a < b or a > c
in                   filter to only fire an event when a is equal to any b .. p
nin                  filter to only fire an event when a is not equal to any b .. p
streq                filter to only fire an event when string s1 = s2 (up to <len> characters)
strne                filter to only fire an event when string s1 != s2 (up to <len> characters)
tag                  filter to only fire an event when a tag is set

Event filters in library RDBMS:
------------------------------
wait                 filter for specific wait parameters and wait duration
process              filter to set events only for a specific process
px                   filter to check identity of the process for fault injection

Event filters in library GENERIC:
------------------------------
errarg               filter to set error events only for a specific error argument


SQL> spool off



ORADEBUG DOC EVENT FILTER <filter_name>
SQL> ORADEBUG DOC EVENT FILTER occurence

occurence: filter to implement counting for event checks

Usage
-------
{occurence:  start_after     <ub4>,
             end_after       <ub4> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER callstack

callstack: filter to only fire an event when a function is on the stack

Usage
-------
{callstack:  fname           <string>[64],
             fprefix         <string>[64],
             maxdepth        <ub4> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER eq

eq: filter to only fire an event when a == b

Usage
-------
{eq:  a               <ub8>,
      b               <ub8> }


SQL>

SQL> ORADEBUG DOC EVENT FILTER ne

ne: filter to only fire an event when a != b

Usage
-------
{ne:  a               <ub8>,
      b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER gt

gt: filter to only fire an event when a > b

Usage
-------
{gt:  a               <ub8>,
      b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER lt

lt: filter to only fire an event when a < b

Usage
-------
{lt:  a               <ub8>,
      b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER ge

ge: filter to only fire an event when a >= b

Usage
-------
{ge:  a               <ub8>,
      b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER le

le: filter to only fire an event when a <= b

Usage
-------
{le:  a               <ub8>,
      b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER anybit

anybit: filter to only fire an event when (a & b) != 0

Usage
-------
{anybit:  a               <ub8>,
          b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER allbit

allbit: filter to only fire an event when (a & b) == b

Usage
-------
{allbit:  a               <ub8>,
          b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER nobit

nobit: filter to only fire an event when (a & b) == 0

Usage
-------
{nobit:  a               <ub8>,
         b               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER bet

bet: filter to only fire an event when b <= a <= c

Usage
-------
{bet:  a               <ub8>,
       b               <ub8>,
       c               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER nbet

nbet: filter to only fire an event when a < b or a > c

Usage
-------
{nbet:  a               <ub8>,
        b               <ub8>,
        c               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER in

in: filter to only fire an event when a is equal to any b .. p

Usage
-------
{in:  a               <ub8>,
      b               <ub8>,
      c               <ub8>,
      d               <ub8>,
      e               <ub8>,
      f               <ub8>,
      g               <ub8>,
      h               <ub8>,
      i               <ub8>,
      j               <ub8>,
      k               <ub8>,
      l               <ub8>,
      m               <ub8>,
      n               <ub8>,
      o               <ub8>,
      p               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER nin

nin: filter to only fire an event when a is not equal to any b .. p

Usage
-------
{nin:  a               <ub8>,
       b               <ub8>,
       c               <ub8>,
       d               <ub8>,
       e               <ub8>,
       f               <ub8>,
       g               <ub8>,
       h               <ub8>,
       i               <ub8>,
       j               <ub8>,
       k               <ub8>,
       l               <ub8>,
       m               <ub8>,
       n               <ub8>,
       o               <ub8>,
       p               <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER streq

streq: filter to only fire an event when string s1 = s2 (up to <len> characters)

Usage
-------
{streq:  s1              <string>[256],
         s2              <string>[256],
         len             <ub4> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER strne

strne: filter to only fire an event when string s1 != s2 (up to <len> characters)

Usage
-------
{strne:  s1              <string>[256],
         s2              <string>[256],
         len             <ub4> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER tag

tag: filter to only fire an event when a tag is set

Usage
-------
{tag:  tname           <string>[64] }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER wait

wait: filter for specific wait parameters and wait duration

Usage
-------
{wait:  minwait         <ub8>,
        p1              <ub8>,
        p2              <ub8>,
        p3              <ub8>,
        _actual_wait_time <ub8> default 'evargn(pos=1)',
        _actual_wait_p1 <ub8> default 'evargn(pos=2)',
        _actual_wait_p2 <ub8> default 'evargn(pos=3)',
        _actual_wait_p3 <ub8> default 'evargn(pos=4)' }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER process

process: filter to set events only for a specific process

Usage
-------
{process:  ospid           <string>[20],
           orapid          <ub4>,
           pname           <string>[20],
           con_id          <ub8> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER px

px: filter to check identity of the process for fault injection

Usage
-------
{px:  slave_set       <ub4>,
      slave_num       <ub4>,
      local_slave_num <ub4>,
      instance_id     <ub4>,
      dfo_number      <ub4>,
      oct             <ub4>,
      pxid            <ub4> }


SQL> spool off


SQL> ORADEBUG DOC EVENT FILTER errarg

errarg: filter to set error events only for a specific error argument

Usage
-------
{errarg:  arg1            <string>[50],
          arg2            <string>[50],
          arg3            <string>[50],
          arg4            <string>[50],
          arg5            <string>[50],
          arg6            <string>[50],
          arg7            <string>[50],
          arg8            <string>[50] }


SQL> spool off




ORADEBUG DOC EVENT ACTION

SQL> ORADEBUG DOC EVENT ACTION

Actions in library DIAG:
---------------------------
evfunc                - Get posting function name
evfile                - Get posting file name
evline                - Get posting file line number as ub8
evfmt                 - Get trace / log format string
evargc                - Get count of event check arguments as a ub8
evargn                - Get event check argument value as ub8
evargp                - Get event check argument value as void *
evargs               
  - Get event check argument as string, with optional format
errargs               - Get error argument as string
errargn               - Get error argument as ub8
errargp               - Get error argument as pointer
errargc               - Get count of error arguments as a ub8
sum                  
  - Compute a1 + a2 + ... + a15 as ub8 (zero if all NULL)
trace                
  - trace to disk; apply format to string arguments
 % is an argument placeholder
 \n and \t are supported. Use double \ as escape
sub                   - Compute a1 - a2 as ub8
add                   - Compute a1 + a2 as ub8
mod                   - Compute a1 modulo a2 as ub8
div                   - Compute a1 / a2 as ub8
mul                   - Compute a1 * a2 as ub8
incr                  - Increment ptr by offset
decr                  - Decrement ptr by offset
refn                 
  - Dereference ptr-to-number: *(ub<numsize>*)(((ub1*)<ptr>)) + <offset>)
refp                 
  - Dereference ptr-to-ptr: *(ub1**)(((ub1*)<ptr>)) + <offset>)
refs                 
  - Dereference ptr-to-string: *(oratext **)(((ub1*)<ptr>) + <offset>)
 Length is optional; NULL-terminated string is assumed
refsl                
  - Dereference ptr-to-string: *(oratext **)(((ub1*)<ptr>) + <offset>)
 with ptr-to-length: *(ub<lensize>*)(((ub1*)<ptr>) + <lenoffset>)
dumpFrameContext      - Dump Frame Context contents
dumpBuckets          
kgsfdmp              
dumpDiagCtx          
dumpDbgecPopLoc      
dumpDbgecMarks       
dumpGeneralConfiguration 
dumpADRLockTable     
shortstack           
  - get short stack (up to 256 characters)
showoffsets controls display of code offsets
skipframes can be used to overcome 256 char limit
dbgvci_action_signal_crash 

Actions in library RDBMS:
---------------------------
incident              - Create an Incident
sqlmon_dump           - SQL Monitor Dump SGA Action
varaddr               - Return address of a fixed PGA/SGA/UGA variable
username              - Return user log-in name
sqlid                 - Return current SQL Id in character format
flashfreeze          
oradebug              - debug process using ORADEBUG
debugger              - debug process using System Debugger
debug                
  - alias for 'debugger' - debug process using System Debugger
crash                 - crash process
kill_instance         - killing RDBMS instance
controlc_signal       - received 1013 signal
eventdump             - list events that are set in the group
kdlut_bucketdump_action 
kzxt_dump_action     
dumpKernelDiagState  
HMCHECK              (async)
DATA_BLOCK_INTEGRITY_CHECK (async)
CF_BLOCK_INTEGRITY_CHECK (async)
DB_STRUCTURE_INTEGRITY_CHECK (async)
REDO_INTEGRITY_CHECK (async)
TRANSACTION_INTEGRITY_CHECK (async)
SQL_TESTCASE_REC     (async)
SQL_TESTCASE_REC_DATA (async)
ORA_12751_DUMP       
sqladv_dump_dumpctx  
ORA_4030_DUMP        
  - dump summary of PGA memory usage, largest allocations
ORA_4036_DUMP         - dump summary of PGA memory usage
HNGDET_MEM_USAGE_DUMP_NOARGS  - dump hang detection memory usage
kcfis_action          - kcfis actions
exadata_dump_modvers  - Exadata dump module versions
QUERY_BLOCK_DUMP      - Debug action for dumping a qbcdef tree
dumpADVMState         - Dump contents of ADVM state
dumpASMState          - Dump contents of ASM state
ASM_CHECK_DG         (async) - Run check diskgroup
ASM_DUMP_KSTSS        - Dump KST Trace and System State
ASM_MOUNT_FAIL_CHECK (async)
ASM_DGFDM_CHECK_NO_DG_NAME (async)
ASM_SYNC_IO_FAIL_CHECK (async)
ASM_DG_FORCE_DISMOUNT_CHECK (async)
ASM_ALLOC_FAIL_CHECK (async)
ASM_ADD_DISK_CHECK   (async)
ASM_FILE_BUSY_CHECK  (async)
ASM_TOOMANYOFF_FAIL_CHECK (async)
ASM_INSUFFICIENT_DISKS_CHECK (async)
ASM_INSUFFICIENT_MEM_CHECK (async)
KJZN_ASYNC_SYSTEM_STATE (async)
KSI_GET_TRACE         - Get lmd0 traces for ksi issues
TRACE_BUFFER_ON       - Allocate trace output buffer for ksdwrf()
TRACE_BUFFER_OFF     
  - Flush and deallocate trace output buffer for ksdwrf()
LATCHES               - Dump Latches
XS_SESSION_STATE      - Dump XS session state
PROCESSSTATE          - Dump process state
SYSTEMSTATE           - Dump system state
INSTANTIATIONSTATE    - Dump instantiation state
CONTEXTAREA           - Dump cursor context area
HEAPDUMP             
  - Dump memory heap (1-PGA, 2-SGA, 4-UGA, +1024-Content)
POKE_LENGTH           - Set length before poking value
POKE_VALUE            - Poke a value into memory
POKE_VALUE0           - Poke 0 value into memory
GLOBAL_AREA          
  - Dump fixed global area(s) (1=PGA/2=SGA/3=UGA, add +8 for pointer content)
REALFREEDUMP          - Dump PGA real free memory allocator state
FLUSH_JAVA_POOL       - Flush Java pool
PGA_DETAIL_GET       
  - Ask process to publish PGA detail info (level is pid)
PGA_DETAIL_DUMP      
  - Dump PGA detail information for process (level is pid) 
PGA_DETAIL_CANCEL     - Free PGA detail request (level is pid)
PGA_SUMMARY           - Summary of PGA memory usage, largest allocations
MODIFIED_PARAMETERS   - Dump parameters modifed by session (level unused)
ERRORSTACK           
  - Dump state (ksedmp). Use INCIDENT action to create incident 
CALLSTACK             - Dump call stack (level > 1 to dump args)
RECORD_CALLSTACK     
  - Record or dump call stack, level = #frames (level += 1000000 go to trc)
BG_MESSAGES           - Dump routine for background messages
ENQUEUES             
  - Dump enqueues (level >=2 adds resources, >= 3 adds locks)
KSTDUMPCURPROC       
  - Dump current process trace buffer (1 for all events)
KSTDUMPALLPROCS      
  - Dump all processes trace buffers (1 for all events)
KSTDUMPALLPROCS_CLUSTER 
  - Dump all processes (cluster wide) trace buffers (1 for all events)
KSKDUMPTRACE          - Dumping KSK KST tracing (no level)
DBSCHEDULER           - Dump ressource manager state
LDAP_USER_DUMP        - Dump LDAP user mode
LDAP_KERNEL_DUMP      - Dump LDAP kernel mode
DUMP_ALL_OBJSTATS     - Dump database objects statistics
DUMPGLOBALDATA        - Rolling migration DUMP GLOBAL DATA
HANGANALYZE           - Hang analyze
HANGANALYZE_PROC      - Hang analyze current process
HANGANALYZE_GLOBAL    - Hang analyze system
HNGDET_MEM_USAGE_DUMP  - dump hang detection memory usage
GES_STATE             - Dump DML state
RACDUMP               - Dump RAC state
OCR                   - OCR client side tracing
CSS                   - CSS client side tracing
CRS                   - CRS client side tracing
SYSTEMSTATE_GLOBAL    - Perform cluster wide system state dump (via DIAG)
DUMP_ALL_COMP_GRANULE_ADDRS 
  - MMAN dump all granule addresses of all components (no level)
DUMP_ALL_COMP_GRANULES 
  - MMAN dump all granules of all components (1 for partial list)
DUMP_ALL_REQS        
  - MMAN dump all pending memory requests to alert log
DUMP_TRANSFER_OPS     - MMAN dump transfer and resize operations history
DUMP_ADV_SNAPSHOTS   
  - MMAN dump all snapshots of advisories (level unused)
CONTROLF              - DuMP control file info
FLUSH_CACHE          
  - Flush buffer cache without shuting down the instance
SET_AFN               - Set afn # for buffer flush (level = afn# )
SET_ISTEMPFILE       
  - Set istempfile for buffer flush (level = istempfile )
FLUSH_BUFFER          - Reuse block range without flushing entire cache
BUFFERS               - Dump all buffers in the buffer cache at level l
SET_TSN_P1           
  - Set tablespace # for buffer dump (level = ts# + 1)
BUFFER               
  - Dump all buffers for full relative dba <level> at lvl 10
BC_SANITY_CHECK      
  - Run buffer cache sanity check (level = 0xFF for full)
SET_NBLOCKS           - Set number of blocks for range reuse checks
CHECK_ROREUSE_SANITY  - Check range/object reuse sanity (level = ts#)
DUMP_PINNED_BUFFER_HISTORY 
  - kcb Dump pinned buffers history (level = # buffers)
REDOLOGS              - Dump all online logs according to the level
LOGHIST              
  - Dump the log history (1: dump earliest/latest entries, >1: dump most recent 2**level entries)
REDOHDR               - Dump redo log headers
LOCKS                 - Dump every lock element to the trace file
GC_ELEMENTS           - Dump every lock element to the trace file
FILE_HDRS             - Dump database file headers
FBINC                
  - Dump flashback logs of the current incarnation and all its ancestors.
FBHDR                 - Dump all the flashback logfile headers
FLASHBACK_GEN         - Dump flashback generation state
KTPR_DEBUG           
  - Parallel txn recovery (1: cleanup check, 2: dump ptr reco ctx, 3: dump recent smon runs)
DUMP_TEMP             - Dump temp space management state (no level)
DROP_SEGMENTS         - Drop unused temporary segments
TREEDUMP             
  - Dump an index tree rooted at dba BLOCKDBA (<level>)
KDLIDMP               - Dump 11glob inodes states (level = what to dump)
ROW_CACHE             - Dump all cache objects
LIBRARY_CACHE        
  - Dump the library cache (level > 65535 => level = obj @)
CURSORDUMP            - Dump session cursors
CURSOR_STATS          - Dump all statistics information for cursors
SHARED_SERVER_STATE   - Dump shared server state
LISTENER_REGISTRATION - Dump listener registration state
JAVAINFO              - Dump Oracle Java VM
KXFPCLEARSTATS        - Clear all Parallel Query messaging statistics
KXFPDUMPTRACE         - Dump Parallel Query in-memory traces
KXFXSLAVESTATE        - Dump PX slave state (1: uga; 2: current cursor state; 3: all cursors)
KXFXCURSORSTATE       - Dump PX slave cursor state
WORKAREATAB_DUMP      - Dump SQL Memory Manager workarea table
OBJECT_CACHE          - Dump the object cache
SAVEPOINTS            - Dump savepoints
RULESETDUMP           - Dump rule set
FAILOVER              - Set condition failover immediate
OLAP_DUMP             - Dump OLAP state
AWR_FLUSH_TABLE_ON    - Enable flush of table id <level> (ids in X$KEWRTB)
AWR_FLUSH_TABLE_OFF  
  - Disable flush of table id <level> (ids in X$KEWRTB)
ASHDUMP               - Dump ASH data (level = # of minutes)
ASHDUMPSECONDS        - Dump ASH data (level = # of seconds)
HM_FW_TRACE           - DIAG health monitor set tracing level
IR_FW_TRACE           - DIAG intelligent repair set/clear trace
GWM_TRACE             - Global Services Management set/clear trace
GWM_TEST              - Global Services Management set/clear GDS test
GLOBAL_BUFFER_DUMP    - Request global buffer dump (level 1 = TRUE)
DEAD_CLEANUP_STATE    - Dump dead processes and killed sessions
IMDB_PINNED_BUFFER_HISTORY 
  - Dump IMDB pinned buffer history (level = (dump_level << 16 | num_buffers))
HEAPDUMP_ADDR         - Heap dump by address routine (level > 1 dump content)
POKE_ADDRESS          - Poke specified address (level = value)
CURSORTRACE           - Trace cursor by hash value (hash value is address)
RULESETDUMP_ADDR      - Dump rule set by address
kewmdump              - Dump Metrics Metadata and Memory
con_id                - Return Container Id as UB8
DBGT_SPLIT_CSTSTRING 
DUMP_SWAP             - dump system memory and swap information
ALERT_SWAP            - issue alert message about system swap percentage
DUMP_PATCH            - dump patch information
dumpBucketsRdbms     

Actions in library GENERIC:
---------------------------
xdb_dump_buckets     
dumpKGERing           - Dump contents of KGE ring buffer
dumpKGEState          - Dump KGE state information for debugging

Actions in library CLIENT:
---------------------------
kpuActionDefault      - dump OCI data
kpuActionSignalCrash 
  - crash and produce a core dump (if supported and possible)
kpudpaActionDpapi     - DataPump dump action


SQL> spool off
ORADEBUG DOC EVENT ACTION <action_name>
You can get more details about some actions by running the doc command for the library.action:

SQL> ORADEBUG DOC EVENT ACTION RDBMS.query_block_dump

ORADEBUG DOC COMPONENT


SQL> ORADEBUG DOC COMPONENT


Components in library DIAG:
--------------------------
  diag_uts                     Unified Tracing Service (dbgt, dbga)
    uts_vw                     UTS viewer toolkit (dbgtp, dbgtn)
  diag_adr                     Automatic Diagnostic Repository (dbgr)
    ams_comp                   ADR Meta-data Repository (dbgrm)
    ame_comp                   ADR Export/Import Services (dbgre)
    ami_comp                   ADR Incident Meta-data Services (dbgri)
    diag_ads                   Diagnostic Directory and File Services (dbgrf, sdbgrf, sdbgrfu, sdbgrfb)
  diag_hm                      Diagnostic Health Monitor ((null))
  diag_ips                     Diagnostic Incident Packaging System ((null))
  diag_dde                     Diagnostic Data Extractor (dbge)
  diag_fmwk                    Diagnostic Framework (dbgc)
    diag_ilcts                 Diagnostic Inter-Library Compile-time Service (dbgf)
    diag_attr                  Diagnostic Attributes Management ((null))
    diag_comp                  Diagnostic Components Management ((null))
  diag_testp                   Diagnostic component test parent (dbgt)
    diag_testc1                Diagnostic component test child 1 ((null))
    diag_testc2                Diagnostic component test child 2 ((null))
  KGSD                         Kernel Generic Service Debugging (kgsd)
  diag_events                  Diagnostic Events (dbgd)
  diag_adl                     Diagnostic ARB Alert Log (dbgrl, dbgrlr)
  diag_vwk                     Diagnostic viewer toolkit (dbgv)
    diag_vwk_parser            Diagnostic viewer parser (dbgvp, dbgvl)
    diag_vwk_uts               Diagnostic viewer for UTS traces and files (dbgvf)
    diag_vwk_ams               Diagnostic viewer for AMS metadata (dbgvm)
    diag_vwk_ci                Diagnostic viewer for command line (dbgvci)
  kghsc                        KGHSC Compact Stream (kghsc)
  dbgxtk                       DBGXTK xml toolkit (dbgxtk)

Components in library RDBMS:
--------------------------
  SQL_Compiler                 SQL Compiler ((null))
    SQL_Parser                 SQL Parser (qcs)
    SQL_Semantic               SQL Semantic Analysis (kkm)
    SQL_Optimizer              SQL Optimizer ((null))
      SQL_Transform            SQL Transformation (kkq, vop, nso)
        SQL_MVRW               SQL Materialized View Rewrite ((null))
        SQL_VMerge             SQL View Merging (kkqvm)
        SQL_Virtual            SQL Virtual Column (qksvc, kkfi)
      SQL_APA                  SQL Access Path Analysis (apa)
      SQL_Costing              SQL Cost-based Analysis (kko, kke)
        SQL_Parallel_Optimization SQL Parallel Optimization (kkopq)
      SQL_Plan_Management      SQL Plan Managment (kkopm)
      SQL_Plan_Directive       SQL Plan Directive (qosd)
    SQL_Code_Generator         SQL Code Generator (qka, qkn, qke, kkfd, qkx)
      SQL_Parallel_Compilation SQL Parallel Compilation (kkfd)
      SQL_Expression_Analysis  SQL Expression Analysis (qke)
    MPGE                       MPGE (qksctx)
    ADS                        ADS (kkoads)
  SQL_Execution                SQL Execution (qer, qes, kx, qee)
    Parallel_Execution         Parallel Execution (qerpx, qertq, kxfr, kxfx, kxfq, kxfp)
      PX_Messaging             Parallel Execution Messaging (kxfp)
      PX_Group                 Parallel Execution Slave Group (kxfp)
      PX_Affinity              Parallel Affinity (ksxa)
      PX_Buffer                Parallel Execution Buffers (kxfpb)
      PX_Granule               Parallel Execution Granules (kxfr)
      PX_Control               Parallel Execution Control (kxfx)
      PX_Table_Queue           Parallel Execution Table Queues (kxfq)
      PX_Scheduler             Parallel Execution Scheduler (qerpx)
      PX_Queuing               Parallel Execution Queuing (kxfxq)
      PX_Blackbox              Parallel Execution Blackbox (kxf)
      PX_PTL                   Parallel Execution PTL (kxft)
      PX_Expr_Eval             Parallel Execution Expression Evaluation ((null))
      PX_Selector              Parallel Execution PX Selector (qerpsel)
      PX_Overhead              Parallel Execution Overhead (qerpx, kxfr, kxfx, kxfp)
    Bloom_Filter               Bloom Filter (qerbl, qesbl)
    Vector_Processing          Vector Processing ((null))
      Vector_Translate         Vector Translate (qkaxl, qerxl, qesxl, qesxlp, qerrc)
      Vector_Aggregate         Vector Aggregate (qergv, qesgv)
      Vector_PX                Vector PX (qesxlp, qerxl)
    Time_Limit                 Query Execution Time Limit (opiexe, qerst)
  PGA_Manage                   PGA Memory Management ((null))
    PGA_Compile                PGA Memory Compilation ((null))
    PGA_IMM                    PGA Memory Instance Manage ((null))
    PGA_CMM                    PGA Memory Cursor Manage ((null))
    PGA_ADV                    PGA Memory Advisor ((null))
  rdbms_dde                    RDBMS Diagnostic Data Extractor (dbke)
  VOS                          VOS (ks)
    hang_analysis              Hang Analysis (ksdhng)
    background_proc            Background Processes (ksb, ksbt)
    system_param               System Parameters (ksp, kspt)
    ksu                        Kernel Service User (ksu)
      ksutac                   KSU Timeout Actions ((null))
    ksv_trace                  Kernel Services Slave Management (ksv)
    file                       File I/O (ksfd, ksfdaf)
  sql_mon                      SQL Monitor (keswx)
    sql_mon_deamon             SQL Monitor Deamon ((null))
    sql_mon_query              SQL Monitor Query ((null))
  CACHE_RCV                    Cache Recovery (kcv, kct, kcra, kcrp, kcb)
    DLF                        Delayed Log Force ((null))
  DIRPATH_LOAD                 Direct Path Load (kl, kdbl, kpodp)
    DIRPATH_LOAD_BIS           Direct Path Kpodpbis Routine (kpodp)
  RAC                          Real Application Clusters ((null))
    GES                        Global Enqueue Service ((null))
      KSI                      Kernel Service Instance locking (ksi)
      RAC_ENQ                  Enqueue Operations ((null))
      DD                       GES Deadlock Detection ((null))
      RAC_BCAST                Enqueue Broadcast Operations ((null))
      RAC_FRZ                  DLM-Client Freeze/Unfreeze (kjfz)
      KJOE                     DLM Omni Enqueue service (kjoe)
    GCS                        Global Cache Service (kjb)
      GCS_BSCN                 Broadcast SCN (kjb, kcrfw)
      GCS_READMOSTLY           GCS Read-mostly (kjb)
      GCS_READER_BYPASS        GCS Reader Bypass (kjb)
      GCS_DELTAPUSH            GCS Delta Push (kjb)
    GSIPC                      Global Enqueue/Cache Service IPC ((null))
    RAC_RCFG                   Reconfiguration ((null))
    RAC_DRM                    Dynamic Remastering ((null))
    RAC_MRDOM                  Multiple Recovery Domains ((null))
    CGS                        Cluster Group Services (kjxg)
    CGSIMR                     Instance Membership Recovery (kjxgr)
    RAC_WLM                    Work Load Management (wlm)
    RAC_MLMDS                  RAC Multiple LMS (kjm)
    RAC_KA                     Kernel Accelerator (kjk)
    RAC_LT                     RAC Latch Usage ((null))
  db_trace                     RDBMS server only tracing ((null))
  kst                          server trace layer tracing (kst)
  ddedmp                       RDBMS Diagnostic Data Extractor Dumper (dbked)
  cursor                       Shared Cursor (kxs, kks)
    Bind_Capture               Bind Capture Tracing ((null))
  KSM                          Kernel Service Memory (ksm)
  KSE                          Kernel Service Error Manager (kse)
  explain                      SQL Explain Plan (xpl)
  rdbms_event                  RDBMS Events (dbkd)
  LOB_INODE                    Lob Inode (kdli)
  rdbms_adr                    RDBMS ADR (dbkr)
  ASM                          Automatic Storage Management (kf)
    KFK                        KFK (kfk)
      KFKIO                    KFK IO (kfkio)
      KFKSB                    KFK subs (kfksubs)
    KFN                        ASM Networking subsystem (kfn)
      KFNU                     ASM Umbillicus (kfnm, kfns, kfnb)
      KFNS                     ASM Server networking (kfns)
      KFNC                     ASM Client networking (kfnc)
      KFNOR                    KFN orion (kfnor)
    KFIS                       ASM Intelligent Storage interfaces (kfis)
    KFM                        ASM Node Monitor Interface Implementation (kfm)
      KFMD                     ASM Node Monitor Layer for Diskgroup Registration (kfmd)
      KFMS                     ASM Node Monitor Layers Support Function Interface (kfms)
    KFFB                       ASM Metadata Block (kffb)
    KFFD                       ASM Metadata Directory (kffd)
    KFZ                        ASM Zecurity subsystem (kfz)
    KFC                        ASM Cache (kfc)
    KFR                        ASM Recovery (kfr)
    KFE                        ASM attributes (kfe)
    KFDP                       ASM PST (kfdp)
    KFG                        ASM diskgroups (kfg)
    KFDS                       ASM staleness registry and resync (kfds)
    KFIA                       ASM Remote (kfia)
      KFIAS                    ASM IOServer (kfias)
      KFIAC                    ASM IOServer client (kfiac)
    KFFSCRUB                   ASM Scrubbing (kffscrub)
    KFIO                       ASM translation I/O layer (kfio)
    KFIOER                     ASM translation I/O layer (kfioer)
    KFV                        ASM Volume subsystem (kfv)
      KFVSU                    ASM Volume Umbillicus (kfvsu)
      KFVSD                    ASM Volume Background (kfvsd)
    KFDX                       ASM Exadata interface (kfdx)
    KFZP                       ASM Password File Layer (kfzp)
    KFA                        ASM Alias Operations (kfa)
    KFF                        KFF (kff)
    KFD                        ASM Disk (kfd)
      KFDVA                    ASM Virtual ATB (kfdva)
    KFTHA                      ASM Transparent High Availability (kftha)
  DML                          DML Drivers (ins, del, upd)
  Health_Monitor               Health Monitor ((null))
  DRA                          Data Repair Advisor ((null))
  DIRACC                       Direct access to fixed tables (kqfd)
  PART                         Partitioning (kkpo, qespc, qesma, kkpa, qergi)
    PART_IntPart               Interval Partitioning ((null))
    PART_Dictionary            Partitioning Dictionary (kkpod)
  LOB_KDLW                     Lob kdlw (kdlw)
  LOB_KDLX                     Lob xfm (kdlx)
  LOB_KDLXDUP                  Lob dedup (kdlxdup)
  LOB_KDLRCI                   Lob rci (kdlrci)
  LOB_KDLA                     SecureFile Archive (kdla)
  SQL_Manage                   SQL Manageability (kes)
    SQL_Manage_Infra           Other SQL Manageability Infrastructure (kesai, kesqs, kesatm, kesutl, kessi, keswat, keswts, keswsq)
    SQL_Tune                   SQL Tuning Advisor (kest)
      SQL_Tune_Auto            SQL Tuning Advisor (auto-tune) (kestsa)
        Auto_Tune_Opt          Auto Tuning Optimizer (kkoat)
      SQL_Tune_Index           SQL Tuning Advisor (index-tune) (kestsi)
      SQL_Tune_Plan            SQL Tuning Advisor (plan node analysis) (kestsp)
      SQL_Tune_Px              SQL Tuning Advisor (parallel execution) (kestsa)
      SQL_Tune_Fr              SQL Tuning Advisor (fix regression) (kestsa)
    SQL_Test_Exec              SQL Test-Execute Service (kestse)
    SQL_Perf                   SQL Performance Analyzer (kesp, keswpi)
    SQL_Repair                 SQL Repair Advisor (kesds)
    SQL_trace_parser           SQL trace parser (kesstp)
  SQL_Analyze                  SQL Analyze (qksan)
  SQL_DS                       SQL Dynamic Sampling Services (qksds)
  SQL_DDL                      SQL DDL (atb, ctc, dtb)
  RAT_WCR                      Real Application Test: Workload Capture and Replay (kec)
  Spatial                      Spatial (md)
    Spatial_IND                Spatial Indexing (mdr)
    Spatial_GR                 Spatial GeoRaster (mdgr)
  Text                         Text (dr)
  rdbms_gc                     RDBMS Diagnostic Generic Configuration (dbkgc)
  XS                           XS Fusion Security (kzx)
    XSSESSION                  XS Session (kzxs)
    XSPRINCIPAL                XS Principal (kzxu)
    XSSECCLASS                 XS Security Class (kzxc, kzxsp)
    XSXDS                      XS Data Security (kzxd)
    XSVPD                      XS VPD ((null))
    XSXDB_DEFAULT              XS XDB ((null))
    XS_MIDTIER                 XS Midtier (kpuzxs)
    XSNSTEMPLATE               XS Namespace template (kzxnt)
    XSACL                      XS ACL (kzxa)
    XSADM                      XS Administrative operation (kzxm, kzxi)
  AQ                           Streams Advanced Queuing (kwq, kkcn, kpon, kpoaq, kpce, kpcm, kpun, kpuaq, kws)
    AQ_DEQ                     Streams Advanced Queuing Dequeue (kwqid, kwqdl)
    AQ_BACK                    Streams Advanced Queueing Background (kwsbg, kwsbsm)
      AQ_TM                    Streams Advanced Queuing Time Manager (kwqit, kwqmn)
      AQ_CP                    Streams Advanced Queuing Cross Process (kwscp, kwsipc)
      AQ_LB                    Streams Advanced Queuing Load Balancer (kwslb, kwslbbg)
      AQ_NTFN                  Streams Advanced Queuing Notification (kpond, kkcne)
        AQ_NTFNP12C            Streams Advanced Queuing pre-12c Notification (kwqic)
      AQ_TMSQ                  Streams Advanced Queuing Time Manager for Sharded Queue (kwsbtm, kwsbjc, kwsbit)
    AQ_MC                      Streams Advanced Queuing Message Cache (kwsmc, kwssh, kwsmb, kwsmsg, kwssb, kwschnk, kwscb, kwsdqwm, kwssbsh)
    AQ_PT                      Streams Advanced Queuing Partitioning (kwspt)
    AQ_SUB                     Streams Advanced Queuing Subscription (kwssi, kwssa, kwsnsm, kwsnsme)
  KSFM                         Kernel Service File Mapping (ksfm)
  KXD                          Exadata specific Kernel modules (kxd)
    KXDAM                      Exadata Disk Auto Manage (kxdam)
    KCFIS                      Exadata Predicate Push (kcfis)
    NSMTIO                     Trace Non Smart I/O (nsmtio)
    KXDBIO                     Exadata Block level Intelligent Operations (kxdbio)
    KXDRS                      Exadata Resilvering Layer (kxdrs)
    KXDOFL                     Exadata Offload (kxdofl)
    KXDMISC                    Exadata Misc (kxdmisc)
    KXDCM                      Exadata Metrics Fixed Table Callbacks (kxdcm)
    KXDBC                      Exadata Backup Compression for Backup Appliance (kxdbc)
  DV                           Database Vault (kzv)
  ASO                          Advanced Security Option ((null))
    RADM                       Real-time Application-controlled Data Masking (kzradm)
  SVRMAN                       Server Manageability (ke)
    AWR                        Automatic Workload Repository (kew)
      ASH                      Active Session History (kewa)
      METRICS                  AWR metrics (kewm)
      REPOSITORY               AWR Repository (kewr)
        FLUSH                  AWR Snapshot Flush (kewrf)
        PURGE                  AWR Snapshot Purge (kewrps)
      AWRUTL                   AWR Utilities (kewu)
    AUTOTASK                   Automated Maintenance Tasks (ket)
    MMON                       MMON/MMNL Infrastructure (keb)
    SVRALRT                    Server Generated Alert Infrastructure (kel)
  OLS                          Oracle Label Security (zll)
  AUDITNG                      Database Audit Next Generation (aud, kza, kzft, aus, aop, ttp)
    Configuration              ANG Configuration (aud, kza, kzft, aus, aop, ttp)
    QueueWrite                 ANG Queue Write (aud, kza, kzft, aus, aop, ttp)
    FileWrite                  ANG File Write (aud, kza, kzft, aus, aop, ttp)
    RecordCompose              ANG Record Compose (aud, kza, kzft, aus, aop, ttp)
    DBConsolidation            ANG Database Consolidation (aud, kza, kzft, aus, aop, ttp)
    SYS_Auditing               ANG SYS Auditing (aud, kza, kzft, aus, aop, ttp)
  KJCI                         KJCI Cross Instance Call (kjci)
  KJZ                          KJZ - DIAG (kjz)
    KJZC                       KJZC - DIAG Communication Layer (kjzc)
    KJZD                       KJZD - DIAG Main Layer (kjzd)
    KJZF                       KJZF - DIAG Flow Control Layer (kjzf)
    KJZG                       KJZG - DIAG Group Services Layer (kjzg)
    KJZH                       KJZH - DIAG API Layer (kjzh)
    KJZM                       KJZM - DIAG Membership Layer (kjzm)
  SEC                          Security (kz)
    CBAC                       Code-Based Access Control (kzc)
  dbop                         DBOP monitoring (keomn)
    dbop_gen                   DBOP generic service (keomg)
      dbop_deamon              DBOP monitoring Deamon (keomg)
    dbop_comp                  DBOP composite type (keomm)
  em_express                   EM Express (kex)
  orarep                       orarep (ker)
  Data                         Data Layer (kd, ka)
    KDS                        Kernel Data Scan (kds)
      KDSRID                   Fetch By Rowid (kdsgrp, kdsgnp)
      KDSFTS                   Full Table Scan (kdsttgr, kdstgr)
      KDSCLU                   Cluster Table Scan (kdsics, kdscgr)
    KDI                        Index Layer (kdi)
      KDIZOLTP                 OLTP HIGH Index (kdizoltp)
      KDXOKCMP                 Auto Prefix Compressed Index (kdxokcmp)
      KDIL                     Index Load (kdil)
  RAT                          Real Application Testing (kec)
    RAT_MASK                   Real Application Testing: Masking (kesm, kecprm)
  BA                           Backup Appliance (kbrs)
  KBC                          BA Containers (kbc)
  connection_broker            Connection Broker (kmp)
  KRA                          Kernel Recovery Area Function (kra)
  KRA_SQL                      KRA SQL Tracing ((null))
  KRB                          Kernel Backup Restore (krb)
    KRB_THREAD                 KRBBPC Thread Switches ((null))
    KRB_IO                     KRB I/O ((null))
    KRB_INCR                   KRB Incremental Restore ((null))
    KRB_PERF                   KRB Performance Tracing ((null))
    KRB_BPOUTPUT               Detailed Backup Piece Output ((null))
    KRB_BPVAL                  Detailed Block List During Restore Validate ((null))
    KRB_FLWRES                 Details on Restore Flow ((null))
    KRB_FLWCPY                 Details on krbydd Flow ((null))
    KRB_FLWBCK                 Details on Backup Flow ((null))
    KRB_FLWUSAGE               RMAN Feature Usage ((null))
    KRB_OPTIM                  Unused Space Compression ((null))
  KRBABR                       Auto Block Media Recovery (krbabr)
  KRC                          Recovery Block Change Tracking (krc)
  KRC_CHANGES                  Recovery Block Change Tracking CHANGES ((null))
  IM                           in-memory ((null))
    IM_transaction             IM transaction layer ((null))
      IM_Txn_PJ                IM Txn Private Journal (ktmpj)
      IM_Txn_SJ                IM Txn Shared Journal (ktmsj)
      IM_Txn_JS                IM Txn Journal Scan (ktmjs)
      IM_Txn_Conc              IM Txn Concurrency (ktmc)
      IM_Txn_Blk               IM Txn Block (ktmb)
      IM_Txn_Read              IM Txn Read (ktmr)
    IM_space                   IM space layer ((null))
    IM_data                    IM data layer (kdm)
      IM_populate              IM populating (kdml)
      IM_background            IM background (kdmr)
      IM_scan                  IM scans ((null))
      IM_journal               IM journal ((null))
      IM_dump                  IM dump ((null))
      IM_FS                    IM faststart ((null))
      IM_optimizer             IM optimizer (kdmo)
  xdb_wallet                   XDB Wallet (kzs)
  PROGINT                      Programmatic Interfaces (kp)
    OCI                        OCI (oci, kpk, kpn)
    OPI                        OPI (opi)
    RPI                        RPI (rpi, kpr)
    NPI                        NPI (npi, nco, kpfs)
    Two_Task                   Two Task (osn, ksn)
    PROGINT_PLSQL              Programmatic Interfaces to/from PL/SQL (kkx, psd, pckl, plswa)
    Two_Phase                  Two-phase commit (k2)
    Conn_Pool                  Connection Pool (kppl)
    TSM                        Transparent Session Migration (kpm, kps)
    PROGINT_MISC               Progint Miscellaneous (kpo, kpbf, kpin)

Components in library GENERIC:
--------------------------
  Generic_VOS                  Generic VOS ((null))
    VOS_Heap_Manager           VOS Heap Manager ((null))
    VOS_Latches                VOS Latches ((null))
    VOS_GST                    VOS Generic Stack Trace (kgds)
  XML                          XML (qmxt, qmxq)
  Generic_XDB                  Generic XDB ((null))
    XDB_Repository             XDB Repository (qme)
    XDB_Protocols              XDB Protocols (qmh, qmf, qmn)
    XDB_Query                  XDB Query (qmxtra, qerxp)
    XDB_XMLIndex               XDB XMLIndex (qmxtri, qmixq)
    XDB_Schema                 XDB Schema (qmxtri, qmixq)
    XDB_XOB                    XDB XOB (qmx)
    XDB_CSX                    XDB CSX (qmcx)
      XDB_CSX_ENCODING         XDB CSX ENCODING (qmcxe, qmcxm)
      XDB_CSX_DECODING         XDB CSX DECODING (qmcxd)
      XDB_CSX_SELFCON          XDB CSX SELFCON (qmcxe)
    XDB_Default                XDB Default ((null))
  LOB                          LOB (koll, kola)
    LOB_Refcount               LOB Refcount (kolr)
    LOB_Default                LOB Default (kole,  kokl, koxs, kokla, koklm, koklv)
  KGH                          KGH Memory Allocator (kgh)
  KGF                          ASM Automatic Storage Management (kgf)
  LIBCACHE                     LIBCACHE (kgl, kql)
  OBJECTS                      OBJECTS ((null))
    OBJECTS_DDL                OBJECTS DDL (kokt)
    OBJECTS_Types              OBJECTS Types (kot, ko, ort)
    OBJECTS_Images             OBJECTS Images (koke, kot, kad)
    OBJECTS_Anydata            OBJECTS Anydata (kokla, kolo, kot, kad)
    OBJECTS_Streams            OBJECTS Streams (koxs)
    OBJECTS_Dict               OBJECTS Dictionary (kkdo, qcdo)
    OBJECTS_Semanal            OBJECTS Semantic Analysis (koks, qcso, qcto)
    OBJECTS_Default            OBJECTS Default ((null))
  KGFPM                        PATCH repository (kgfpm)
  KGFDVF                       Voting File Interface (kgfdvf)
  Shared_Objects               Shared Object Manager (pes)
    SO_Loader                  Native Code Loader (pesld)

Components in library CLIENT:
--------------------------
  Client_KPU                   Client KPU ((null))
    KPU_Memory                 KPU Memory ((null))
    KPU_TTC                    KPU TTC ((null))
    KPU_Relational             KPU Relational ((null))
    KPU_Objects                KPU Objects ((null))
    KPU_LOBS                   KPU LOBS ((null))
  progint_appcont              Prog Interfaces Application Continuity ((null))
    progint_appcont_rdbms      Prog Interfaces Application Continuity RDBMS-side ((null))
  SQLLDR_Load                  SQLLDR Load (ul)
  DPAPI_Load                   DPAPI Load (kpudp)

Components in library LIBCELL:
--------------------------
  Client_Library               Client Library ((null))
    Disk_Layer                 Disk Layer ((null))
    Network_Layer              Network Layer ((null))
    IPC_Layer                  IPC Layer ((null))

Components in library ORANET:
--------------------------
  TNSLSNR                      OraNet Listener ((null))
    NET_NSGR                   Network Service Generic Registration ((null))
    NET_NSGI                   TNI Network Service Generic Listener User-defined class ((null))
  CMAN                         OraNet Connection Manager ((null))
  NET                          OraNet Services ((null))
    NET_NI                     Network Interface Layer ((null))
    NET_NS                     Network Session Layer ((null))
    NET_NT                     Network Transport Layer ((null))
    NET_NTM                    Network Transport Mailbox Layer ((null))
    NET_NTP                    Network Transport IPC Layer ((null))
    NET_NTT                    Network Transport TCP/IP Layer ((null))
    NET_NTUS                   Network Transport Unix Domain Sockets Layer ((null))
    NET_NL                     Network Library ((null))
    NET_NA                     Network Authentication ((null))
    NET_NZ                     Network Zecurity ((null))
    NET_NTZ                    Network SSL ((null))
    NET_NU                     Network Trace Route Utility ((null))
    NET_NN                     Network Names ((null))

Components in library ADVCMP:
--------------------------
  ADVCMP_MAIN                  Archive Compression (kdz)
    ADVCMP_COMP                Archive Compression: Compression (kdzc, kdzh, kdza)
    ADVCMP_DECOMP              Archive Compression: Decompression (kdzd, kdzs)
      ADVCMP_DECOMP_HPK        Archive Compression: HPK (kdzk)
      ADVCMP_DECOMP_PCODE      Archive Compression: Pcode (kdp)

Components in library PLSQL:
--------------------------
  PLSQL_Apps                   PL/SQL Apps (di, pi, plitblm, scm, std, textio, wpiutil)
  PLSQL_Codegen                PL/SQL Codegen ((null))
    PLSQL_COG_IDL_Gen          PL/SQL Codegen IDL Gen (pdw)
    PLSQL_COG_Infrastructure   PL/SQL Codegen Infrastructure (pdz)
    PLSQL_COG_Native           PL/SQL Codegen Native (pdn)
    PLSQL_COG_Optimizer        PL/SQL Codegen Optimizer (pdx)
    PLSQL_COG_MCode_Gen        PL/SQL Codegen MCode Gen (pdy)
  PLSQL_Code_Execution         PL/SQL Code Execution (pb, pd, pe, pf, plst, pri)
  PLSQL_External_Proc          PL/SQL External Proc (pef, ociextp)
  PLSQL_IDL                    PL/SQL IDL (pdt, pt)
  PLSQL_ILMS                   PL/SQL ILMS (pgm)
  PLSQL_KNLDE                  PL/SQL KNLDE (pbbicd, pbp3g, pbs, pbt3g, peibp)
  PLSQL_KG_Interface           PL/SQL KG Interface (bam, hep, hsh, lis, par, phdr, pk)
  PLSQL_Infrastructure         PL/SQL Infrastructure (pci, pcm, ph, pl, pncutil, pp, ps, pu, tre)
  PLSQL_PSD                    PL/SQL PSD ((null))
    PLSQL_PSD_Generic          PL/SQL PSD Generic (psd, pso, psu)
    PLSQL_PSD_Standalones      PL/SQL PSD Standalones (p2c, pls, psx)
  PLSQL_Semantics              PL/SQL Semantics (ph2, pha, phn)
  PLSQL_Syntax                 PL/SQL Syntax (ph1)

SQL> spool off

Mittwoch, 7. Januar 2015

checking suspicious bind variables in v$sql_monitor

In my current company we try to stabilize the performance of our Peoplesoft application. So on a more or less regular base I get a call to investigate as "it" is "slow" now.
During my research I found one error-pattern I'd like to show here: SQLs which where parsed for very selective BINDs (like customer-id) are executed with a single space (" ") as bind.
Unfortunately in Peoplesoft this character is used similar to NULL - so when it doesn't know what value to store, a space is used.
In general such BINDs lead to improper NESTED LOOPs.
Every time I found such executions, they where accepted as defect by development.

I'm in the lucky position to have tuning pack licensed, so I can use real time sql monitoring. That's very handy as I can save the a SQL in question together with a lot of infos (client, machine, module, start-time, BINDs, ...) in a html file and save it for later analysis/forward.

As v$sql_monitor shows specific executions, and it has all the BINDs stored as well, I can use it now to find other suspicious statements. So this little statement gives me some infos where to look closer:

SELECT sql_id, 
       name, 
       '--' || value || '--' 
FROM   (SELECT KEY, 
               sql_id, 
               xmltype.Createxml(binds_xml) confval 
        FROM   v$sql_monitor) v, 
       XMLTABLE('/binds/bind' passing v.confval 
                COLUMNS name  VARCHAR2(25)   path '@name', 
                        value VARCHAR2(4000) path '.'      ) 
WHERE  value = ' ' 
        OR value IS NULL; 
with an output like this:
SQL_ID        NAME                      VALUE
------------- ------------------------- -----
63pw6bqt84793 :2                        -- -- 

Please do NOT start with this statement when your application is "slow" - not even when it's Peoplesoft.

Dienstag, 7. Oktober 2014

enhanced SQL trace

As a huge friend of Oracles SQL trace I also see it's limitations as well. One of these limitations is visible in it's underlying infrastructure: the wait interface. It's only about waits.
There is another source of information as well, you could call it the DO interface, but the common term is session and system statistics. there Oracle counts what it is doing.
Unfortunately I do not know a simple way to show both realities in a common way.

At least for consistent gets I now can show (most of) them together with wait events.

The magic is done by event 10200 - Dump Consistent Reads.

I create a trace file with both, 10046 and 10200 event:


SET AUTOTRACE ON STATISTICS

ALTER SESSION SET EVENTS '10200 TRACE NAME CONTEXT FOREVER, LEVEL 1';
ALTER SESSION SET EVENTS '10046 TRACE NAME CONTEXT FOREVER, LEVEL 8';

select * from berx.t1;

Statistics
----------------------------------------------------------
         80  recursive calls
          0  db block gets
        118  consistent gets
          0  physical reads
          0  redo size
        654  bytes sent via SQL*Net to client
        524  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
         15  sorts (memory)
          0  sorts (disk)
          3  rows processed

Of course the additional event gives additional lines which will not be processed by those tools to parse SQL traces. I will not go into any detail of those additional lines - especially as I don't know about them to much. If you are interested I'd recommend Charles Hoopers blog.

I just grab lines which contain the string completed for block and rework their values so it looks similar to something the SQL trace parsers know. This is a very inexperienced piece of code!

#!/usr/bin/perl -w
#10200_preproc.pl
use strict;

my $cursor       = 0 ;
my $timestamp    = 0 ;
my $is_processed = 0 ;
my $tablespace;
my $block;
my $object_id;

while (<>) {
  my $line = $_;
  if ($line =~ m/.*#(\d+)[: ].*/) {
    ($cursor = $line) =~ s/.*#(\d+)[: ].*/$1/ ;
  }
  $cursor =~ tr/\n//d;

  if ($line =~ m/.*tim=(\d+).*/) {
    ($timestamp = $line) =~ s/.*#(\d+)[: ].*/$1/ ;
  }
  $timestamp =~ tr/\n//d;

  if ($line =~ m/completed for block/) {
    ($tablespace = $line) =~ s/.*\<([abcdefx\d]+) : .*/$1/ ;
    ($block      = $line) =~ s/.* : ([abcdefx\d]+).*/$1/;
    ($object_id  = $line) =~ s/.*objd: ([abcdefx\d]+).*/$1/;
    $tablespace =~ tr/\n//d;
    $block      =~ tr/\n//d;
    $object_id  =~ tr/\n//d;
    $tablespace = hex($tablespace) +1;
    $block      = hex($block);
    $object_id  = hex($object_id);
# WAIT #391723720: nam='db file scattered read' ela= 2876 file#=5 block#=129 blocks=127 obj#=71123 tim=90982740602
    print "WAIT #"; # as the hash is somethign special ...
    print "$cursor: nam='LIO - completed for block' ela=0 tablespace=$tablespace block#=$block obj=$object_id obj#=$object_id tim=$timestamp\n";
    $is_processed = 1;

  }
  if ($is_processed == 0) {
    print $line;
  }
  else {
    $is_processed = 0
  }

}

This code should really be seen as an example, not a solution!
Out of a line like
ktrgcm(): completed for block  <0x0000 : 0x0041560c> objd: 0x0000003e
it creates
WAIT #47572859450312: nam='LIO - completed for block' ela=0 tablespace=1 block#=4281868 obj=62 obj#=62 tim=47572859450312

Probably the only magic is the Cursor and timing info which I just copy from the last SQL trace line above. I'd as well like not to use the keyword WAIT as for sure the process is not waiting in this case, but I have to still trick the tools.

With my modified tracefile from the statement above I create this report:

CALL-NAME                    DURATION       %  CALLS      MEAN       MIN       MAX
---------------------------  --------  ------  -----  --------  --------  --------
SQL*Net message from client  0.671976   95.8%      3  0.223992  0.000165  0.671529
PARSE                        0.025995    3.7%      1  0.025995  0.025995  0.025995
row cache lock               0.001640    0.2%     12  0.000137  0.000079  0.000497
FETCH                        0.001000    0.1%      2  0.000500  0.000000  0.001000
library cache pin            0.000471    0.1%      2  0.000236  0.000214  0.000257
library cache lock           0.000443    0.1%      2  0.000222  0.000211  0.000232
Disk file operations I/O     0.000047    0.0%      1  0.000047  0.000047  0.000047
SQL*Net message to client    0.000002    0.0%      3  0.000001  0.000000  0.000001
LIO - completed for block    0.000000    0.0%    117  0.000000  0.000000  0.000000
CLOSE                        0.000000    0.0%      3  0.000000  0.000000  0.000000
EXEC                         0.000000    0.0%      1  0.000000  0.000000  0.000000
XCTEND                       0.000000    0.0%      1  0.000000  0.000000  0.000000
---------------------------  --------  ------  -----  --------  --------  --------
TOTAL (12)                   0.701574  100.0%    148  0.004740  0.000000  0.671529

You see 117 LIO - completed for block events here, which is quite close to 118 consistent gets.

There are probably a lot more things to do, still it helps me to show what a statement is doing (in terms of LIO) beside the time it spends waiting.

Montag, 16. Dezember 2013

Instrumentation still needed

Recently I received an email with an simple content:
"It" is slow again :-)
The email explained a package to be slow.

Ok, I started with my "not enough information" reply and an email conversation began.

We are still not ready to identify the problem, but as there is no code instrumentation in place I tried to identify what's possible with v$active_session_history (ASH).
To do so, I created 2 Packages: P1 and P2. P1 has a procedure DO_IT and a function SLEEP, which burns CPU for approximately x seconds. P2 only has a function SLEEP, which also burns CPU for approximately x seconds and then calls P1.SLEEP again. P1.DO_IT has a simple sql which calls P1.SLEEP and P2.SLEEP. My code is properly instrumented using DBMS_APPLICATION_INFO.set_module in the code and dbms_session.set_identifier to identify one specific execution - to compare it's value to the information already available in v$active_session_history.
Here the packages:
CREATE OR REPLACE
PACKAGE P1
IS
  PROCEDURE DO_IT(SEC IN NUMBER);
  FUNCTION SLEEP(SEC IN NUMBER)
    RETURN NUMBER;
END; 
/

CREATE OR REPLACE
PACKAGE P2
IS
  FUNCTION SLEEP(SEC IN NUMBER)
    RETURN NUMBER;
END; 
/
 
CREATE OR REPLACE PACKAGE BODY P1
IS
  PROCEDURE DO_IT(SEC IN NUMBER)
  IS
    r NUMBER;
  BEGIN
    DBMS_APPLICATION_INFO.set_module(module_name => 'P1', 
                                     action_name => 'DO_IT');
    dbms_output.put_line('++P1.DO_IT++');
    SELECT P2.SLEEP(SEC) into r 
    FROM DUAL
    WHERE P1.SLEEP(SEC) > 1;
    dbms_output.put_line('--P1.DO_IT--');
    DBMS_APPLICATION_INFO.set_module(module_name => 'blaaa',
                                     action_name => 'blaaa');
  END DO_IT;
  
  FUNCTION SLEEP(SEC IN NUMBER)
    RETURN NUMBER
  IS
    C NUMBER := 0;
    now DATE := SYSDATE;
  BEGIN
    DBMS_APPLICATION_INFO.set_module(module_name => 'P1',
                                     action_name => 'SLEEP');
    dbms_output.put_line('++P1.SLEEP++');
    LOOP
      C := C + 1;
      EXIT WHEN now + (SEC * (1/86400)) <= SYSDATE;
    END LOOP;
    
    dbms_output.put_line('--P1.SLEEP--');
    DBMS_APPLICATION_INFO.set_module(module_name => 'blaaa',
                                    action_name => 'blaaa');
    RETURN C;
    END SLEEP;
END;
/

CREATE OR REPLACE
PACKAGE BODY P2
IS
  FUNCTION SLEEP(SEC IN NUMBER)
    RETURN NUMBER
  IS 
    C NUMBER := 0; 
    D NUMBER := 0; 
    now DATE := SYSDATE;
  BEGIN
    DBMS_APPLICATION_INFO.set_module(module_name => 'P2',
                                    action_name => 'SLEEP');
        dbms_output.put_line('++P2.SLEEP++');                                
    LOOP
      C := C + 1;
      EXIT WHEN now + (SEC * (1/86400)) <= SYSDATE;
    END LOOP;  
    SELECT P1.SLEEP(SEC) into D
    FROM DUAL;
    C := C + D; 
    dbms_output.put_line('--P2.SLEEP--');    
    DBMS_APPLICATION_INFO.set_module(module_name => 'blaaa',
                                     action_name => 'blaaa');
    RETURN C;
  END SLEEP;
END;
/

I started the testcase with a simple
set serveroutput on
exec dbms_session.set_identifier(client_id => 'berx testcase ' || to_char(sysdate, 'YYYY-MM-DD HH24:MI:SS') );
exec p1.do_it(5);
exec dbms_session.set_identifier(client_id => 'berx testcase ' || to_char(sysdate, 'YYYY-MM-DD HH24:MI:SS') );
exec p1.do_it(5);
exec dbms_session.set_identifier(client_id => 'blaaa');

And immediately afterwards I checked for sql_id, top_level_sql_id, action, module, client_id, plsql_entry_object_id, plsql_entry_subprogram_id, plsql_object and plsql_subprogram_id

select SESSION_ID,
       sql_id,
       ( SELECT max( substr( sql_text , 1, 40 )) FROM v$sql sq WHERE sq.sql_id = ash.sql_id ) AS sql_text,
       TOP_LEVEL_SQL_ID,
       ( SELECT max( substr( sql_text , 1, 40 )) FROM v$sql sq WHERE sq.sql_id = ash.top_level_sql_id ) AS top_level_sql_text,
       action,
       module,
       client_id
,      ( SELECT object_name    FROM dba_procedures WHERE object_id = plsql_entry_object_id AND subprogram_id = 0) AS plsql_entry_object
,      ( SELECT procedure_name FROM dba_procedures WHERE object_id = plsql_entry_object_id AND subprogram_id = plsql_entry_subprogram_id) AS plsql_entry_subprogram
,      ( SELECT object_name    FROM dba_procedures WHERE object_id = plsql_object_id       AND subprogram_id = 0) AS plsql_object
,      ( SELECT procedure_name FROM dba_procedures WHERE object_id = plsql_object_id       AND subprogram_id = PLSQL_SUBPROGRAM_ID) AS plsql_subprogram 
from v$active_session_history ash 
where SAMPLE_TIME > sysdate - 1/(24*60)
      and session_id = SYS_CONTEXT('USERENV','SID')
order by SAMPLE_TIME asc;

Here is the result (please excuse the wide list).

ST                  SESSION_ID  SQL_ID        SQL_TEXT                                 TOP_LEVEL_SQL_ID TOP_LEVEL_SQL_TEXT                       ACTION     MODULE     CLIENT_ID                           PLSQL_ENTRY_OBJECT             PLSQL_ENTRY_SUBPROGRAM         PLSQL_OBJECT    PLSQL_SUBPROGRAM
------------------- ----------  ------------- ---------------------------------------- ---------------- ---------------------------------------- ---------- ---------- ----------------------------------- ------------------------------ ------------------------------ --------------- ----------------
2013-12-14 22:24:00        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:01        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:02        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:03        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:04        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:05        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:06        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:07        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:08        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:09        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:10        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:11        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:12        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:13        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:14        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:00   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:15        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:16        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:17        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:18        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:19        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:20        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:21        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:22        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          STANDARD        SYSDATE          
2013-12-14 22:24:23        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:24        160  cqd77zbnpa79n SELECT P2.SLEEP(:B1 ) FROM DUAL WHERE P1 1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P2         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P2              SLEEP            
2013-12-14 22:24:25        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:26        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:27        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:28        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            
2013-12-14 22:24:29        160  cc9hp65m5aq6s SELECT P1.SLEEP(:B1 ) FROM DUAL          1ahw2g5n38js5    BEGIN p1.do_it(5); END;                  SLEEP      P1         berx testcase 2013-12-14 22:24:15   P1                             DO_IT                          P1              SLEEP            

 30 rows selected 

So my findings here:

  • TOP_LEVEL_SQL_ID is the same all the time. That's good, as I have a valid anchor on the top most layer. 
  • there is nothing similar to SQL_EXEC_ID for the TOP_LEVEL_SQL_ID. So I can not distinguish the 2 runs of P1.DO_IT.
  • PLSQL_OBJECT.PLSQL_SUBPROGRAM does not always reflect the current application module, as also internal code (as SYSDATE) is shown there. ACTION and MODULE are more reliable. 
  • Only with ASH I don't see any general way to identify the runtime of sub-TOP_LEVEL SQLs or PLSQL_SUBPROGRAMs.
  • The most complete picture from ASH is only given with proper instrumentation
  • If you need the full insight about the stack of SQL and PL/SQL calls, you need to trace the session. This again works like a charm with ACTION and MODULE set and DBMS_MONITOR.SERV_MOD_ACT_STAT_ENABLE 

Sonntag, 24. November 2013

No Adaptive Cursor Sharing for collections

Recently I was hunting a performance problem at work.

A developer read about adaptive cursor sharing and therefore guessed, the optimizer would know about the number of rows when he passes a collection for a table(:bind) function. I can totally understand it, as there where no limitations in the statement (except the 14 binds):
The adaptive cursor sharing feature enables a single statement that contains bind variables to use multiple execution plans. Cursor sharing is "adaptive" because the cursor adapts its behavior so that the database does not always use the same plan for each execution or bind variable value.
For appropriate queries, the database monitors data accessed over time for different bind values, ensuring the optimal choice of cursor for a specific bind value. For example, the optimizer might choose one plan for bind value 9 and a different plan for bind value 10. Cursor sharing is "adaptive" because the cursor adapts its behavior so that the same plan is not always used for each execution or bind variable value.
Adaptive cursor sharing is enabled for the database by default and cannot be disabled. Note that adaptive cursor sharing does not apply to SQL statements containing more than 14 bind variables.
There is no limitation about where the bind peeking is done (and where not). Based on my findings I'd limit it to "only in filtration". But I accept any better wording.

Now let's go down to the testcase (all tested in 11.2.0.3):
To prepare a nice environment I did:

DROP TYPE T_COLLECTION_TEST;
/

DROP TYPE O_COLLECTION_TEST;
/

DROP PACKAGE COLLECTION_TEST;
/
*/

CREATE TYPE O_COLLECTION_TEST
AS
  OBJECT
  (
    RN             NUMBER,
    OWNER          VARCHAR2(30),
    OBJECT_NAME    VARCHAR2(30),
    SUBOBJECT_NAME VARCHAR2(30),
    OBJECT_ID      NUMBER,
    DATA_OBJECT_ID NUMBER,
    OBJECT_TYPE    VARCHAR2(19),
    CREATED        DATE,
    LAST_DDL_TIME  DATE,
    TIMESTAMP      VARCHAR2(19),
    STATUS         VARCHAR2(7),
    TEMPORARY      VARCHAR2(1),
    GENERATED      VARCHAR2(1),
    SECONDARY      VARCHAR2(1),
    NAMESPACE      NUMBER,
    EDITION_NAME   VARCHAR2(30));
  /
CREATE TYPE T_COLLECTION_TEST
IS
  TABLE OF O_COLLECTION_TEST;
  /

DROP TABLE AOT ;
CREATE TABLE AOT AS 
      select rownum rn, v.*
      from (SELECT * FROM ALL_OBJECTS
      UNION ALL
      SELECT * FROM ALL_OBJECTS
      UNION ALL
      SELECT * FROM ALL_OBJECTS
   UNION ALL
      SELECT * FROM ALL_OBJECTS
   UNION ALL
      SELECT * FROM ALL_OBJECTS) v
;

create unique index iAOT on aot(rn);

exec dbms_stats.gather_table_stats(null,'AOT');



CREATE OR REPLACE
PACKAGE COLLECTION_TEST
IS
  G_COLLECTION_SIZE NUMBER := 0;
  R_CT T_COLLECTION_TEST := T_COLLECTION_TEST();
  FUNCTION RUN(
      P_COLLECTION_SIZE IN NUMBER)
    RETURN T_COLLECTION_TEST;
END; 
/

CREATE OR REPLACE
PACKAGE BODY COLLECTION_TEST
IS
FUNCTION RUN(
    P_COLLECTION_SIZE IN NUMBER)
  RETURN T_COLLECTION_TEST
IS
BEGIN
  IF G_COLLECTION_SIZE <> P_COLLECTION_SIZE THEN
    G_COLLECTION_SIZE  := P_COLLECTION_SIZE;
    SELECT O_COLLECTION_TEST(RN, OWNER , OBJECT_NAME , SUBOBJECT_NAME , OBJECT_ID , DATA_OBJECT_ID , OBJECT_TYPE , CREATED , LAST_DDL_TIME , TIMESTAMP , STATUS , TEMPORARY , GENERATED , SECONDARY , NAMESPACE , EDITION_NAME ) BULK COLLECT
    INTO R_CT
    FROM AOT WHERE rn <= G_COLLECTION_SIZE;
  END IF;
  RETURN R_CT;
END;
END;
/


That's enough for a small testcase. In fact I merged 2 tests into one run:
first: does the optimizer cares for a table(:bind) function
second: does the cardinality hint helps?

So the actual test run is:

DECLARE
  n NUMBER := 1;
  i NUMBER := 0;
  c T_COLLECTION_TEST;
TYPE tab_ao_tab
IS
  TABLE OF VARCHAR2(100);
  ao_tab tab_ao_tab;
  idx NUMBER;
  x   NUMBER := 0;
BEGIN
  EXECUTE immediate 'ALTER SYSTEM FLUSH SHARED_POOL';
  DBMS_MONITOR.session_trace_enable(waits=>TRUE, binds=>TRUE);
  FOR i IN 1..6
  LOOP
    dbms_output.put_line(i);
    n := power(10,i);
    c := collection_test.run(n);
    dbms_output.put_line(n);
    DBMS_APPLICATION_INFO.set_client_info(client_info => 'Number: '|| n);
    dbms_output.put_line('test1 ');
    EXECUTE immediate 'select /*+ gather_plan_statistics dynamic_sampling(t 10) */                      
t.owner || ''.'' || ao.object_name                     
from table(:c) t,   AOT ao                      
where t.rn = ao.rn' bulk collect INTO ao_tab USING c;
    FOR indx IN ao_tab.FIRST..ao_tab.LAST
    LOOP
      x := n + 1;
    END LOOP;
    dbms_output.put_line('x: ' || x);
    dbms_output.put_line('test2 ');
    dbms_output.put_line('cardinality1 ');
    EXECUTE immediate 'select /*+ gather_plan_statistics cardinality(t ' || n || ') */                      
t.owner || ''.'' || ao.object_name                     
from table(:c) t,   AOT ao                      
where t.rn = ao.rn' bulk collect INTO ao_tab USING c;
    FOR indx IN ao_tab.FIRST..ao_tab.LAST
    LOOP
      x := x + 1;
    END LOOP;
    dbms_output.put_line('x: ' || x);
  END LOOP;
  DBMS_MONITOR.session_trace_disable;
END;
/

If you want to try this at home, there is no need to create a sql-trace file. I'm just so used to it.
Now my big question is, how many cursors this testcase creates and what's their execution plan is.

select sql_id, child_number, executions, plan_hash_value, substr(sql_text,1,56) text
from v$sql 
where lower(sql_text) like 'select /*+ gather_plan_statistics%'
order by executions desc, plan_hash_value asc, text asc;

With a result (on my system):

SQL_ID         CN  EX PLAN_HASH_VALUE TEXT                                                   
------------- --- --- --------------- --------------------------------------------------------
9741g8bfng454   0   6      1690681298 select /*+ gather_plan_statistics dynamic_sampling(t 10) 
dr4yxf89n0g2k   0   1      1690681298 select /*+ gather_plan_statistics cardinality(t 10) */   
14yffxq80k21d   0   1      1690681298 select /*+ gather_plan_statistics cardinality(t 100) */  
52vt0cr9ghnh4   0   1      1690681298 select /*+ gather_plan_statistics cardinality(t 1000) */ 
2d6328126t9gz   0   1      3714863083 select /*+ gather_plan_statistics cardinality(t 10000) * 
du8ds9qupzzcn   0   1      3714863083 select /*+ gather_plan_statistics cardinality(t 100000)  
9t4zm8nkpr8dj   0   1      3714863083 select /*+ gather_plan_statistics cardinality(t 1000000)

The statements with cardinality hint show a proper flip in the execution plan from 1000 to 10000 rows.
Unfortunately the statement with dynamic_sampling does not follow this pattern. The first execution plan sticks:
------------------------------------------------------------------------------------------------------                                                                                                                                                                                                       
| Id  | Operation                           | Name | Starts | E-Rows | A-Rows |   A-Time   | Buffers |                                                                                                                                                                                                       
------------------------------------------------------------------------------------------------------                                                                                                                                                                                                       
|   0 | SELECT STATEMENT                    |      |      1 |        |     10 |00:00:00.01 |      19 |                                                                                                                                                                                                       
|   1 |  NESTED LOOPS                       |      |      1 |        |     10 |00:00:00.01 |      19 |                                                                                                                                                                                                       
|   2 |   NESTED LOOPS                      |      |      1 |     10 |     10 |00:00:00.01 |       9 |                                                                                                                                                                                                       
|   3 |    COLLECTION ITERATOR PICKLER FETCH|      |      1 |     10 |     10 |00:00:00.01 |       0 |                                                                                                                                                                                                       
|*  4 |    INDEX UNIQUE SCAN                | IAOT |     10 |      1 |     10 |00:00:00.01 |       9 |                                                                                                                                                                                                       
|   5 |   TABLE ACCESS BY INDEX ROWID       | AOT  |     10 |      1 |     10 |00:00:00.01 |      10 |                                                                                                                                                                                                       
------------------------------------------------------------------------------------------------------   
And all the following executions obey this execution plan. Without thinking or checking.
But the plan can change:  Doing the same testcase with 6..1 the plan is now stable at


------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                 
| Id  | Operation                          | Name | Starts | E-Rows | A-Rows |   A-Time   | Buffers | Reads  | Writes |  OMem |  1Mem | Used-Mem | Used-Tmp|                                                                                                                                                 
------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                 
|   0 | SELECT STATEMENT                   |      |      1 |        |    340K|00:00:01.88 |    5101 |   6810 |   6810 |       |       |          |         |                                                                                                                                                 
|*  1 |  HASH JOIN                         |      |      1 |    340K|    340K|00:00:01.88 |    5101 |   6810 |   6810 |    47M|  4032K| 3769K (1)|   58368 |                                                                                                                                                 
|   2 |   COLLECTION ITERATOR PICKLER FETCH|      |      1 |    340K|    340K|00:00:00.13 |       0 |      0 |      0 |       |       |          |         |                                                                                                                                                 
|   3 |   TABLE ACCESS FULL                | AOT  |      1 |    340K|    340K|00:00:00.09 |    5101 |      0 |      0 |       |       |          |         |                                                                                                                                                 
------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                                                                                                 

I hope you can see, even in 11.2.0.3 it's like rain on monday morning in Washington DCDynamic Sampling jumps in, but it's not adaptive.
What's the conclusion here? 
If you use a collection in a table function, and the expected numbers in that collection varies by dimensions, take care! My solution is a cardinality hint, but that might be complicated if you are using a framework.
I don't know any 'cheap' solution. 
Maybe anyone wants to try this in 12c. I did not focus there yet. It's still 2013 :-)