func dyn statement_set.c

func_dyn_statement_set.c#include <stdio.h>#include <stdlib.h>#include <string.h>

#include "constant_definition.h"#include "case_constant_definition.h"#include "case_constant_sql_stmt_def.h"

#include "constant_oracle_versions.h"

extern vaciar_cadena();extern pasar_amayus ();

char *func_dyn_statement_set (int version, int sentencia, char *opcion_uno, char *opcion_dos, char

*opcion_tres , char *opcion_cuatro){static char dyn_sts[MAX_STMT_SIZE];

vaciar_cadena (dyn_sts,MAX_STMT_SIZE);

switch (sentencia){case CASE_ORACLE_VERSION:

strcpy (dyn_sts,"select ltrim(lpad(banner,70)) Version from v$version ");

strcat (dyn_sts,"where banner like '%Oracle%' ");break;

case CASE_ACTIVE_PARAMETERS:strcpy (dyn_sts,"select name,value,description from

v$parameter order by 1 ");break;

case CASE_USERS_CONNECTED:strcpy (dyn_sts,"select saddr ADDRESS,sid SES,username

NOMBRE,command CMD, \n");strcat (dyn_sts,"status ESTADO,process PID,terminal

TERMINAL,LOCKWAIT, \n");strcat (dyn_sts,"to_char(logon_time,'DD/MM/YYYY -

HH24:MI:SS') INICIADO from v$session \n ");strcat (dyn_sts,"order by INICIADO \n");break;

case CASE_WAIT_STATISTICS:strcpy (dyn_sts,"select count CANTIDAD,time TIEMPO,class

CLASE from v$waitstat order by 1 ");break;

case CASE_DATAFILE_I_0:switch (version)

{case VERSION_ORACLE_920:

strcpy (dyn_sts,"select f.phyrds, f.phyblkrd, f.phywrts, ");

strcat (dyn_sts,"f.phyblkwrt, f.lstiotim*10 , d.name\n");

strcat (dyn_sts,"from v$filestat f, v$datafile d ");

strcat (dyn_sts,"where f.file# = d.file#and ");

strcat (dyn_sts,"f.lstiotim > 0 order by2 \n");

break;case VERSION_ORACLE_817:case VERSION_ORACLE_816:case VERSION_ORACLE_734:

strcpy (dyn_sts,"select f.phyrds, f.phyblkrd, f.phywrts, ");

strcat (dyn_sts,"f.phyblkwrt, d.name ");strcat (dyn_sts,"from v$filestat

f,v$datafile d ");

Página 1

func_dyn_statement_set.cstrcat (dyn_sts,"where f.file# = d.file#

");strcat (dyn_sts,"order by 2 \n");break;

default:break;

}break;

case CASE_DATAFILE_BLOCKS_R_W:strcpy (dyn_sts,"select d.name DATAFILE, f.phyblkrd

BLK_READ, f.phyblkwrt BLK_WRITE, \n");strcat (dyn_sts,"f.phyblkrd+f.phyblkwrt BLK_TOTAL from

v$filestat f, v$datafile d \n");strcat (dyn_sts,"where f.file# = d.file# order by 3 desc

");break;

case CASE_WAIT_EVENTS:strcpy (dyn_sts,"select se.sid, se.username

USUARIO,count(*) CANTIDAD,sw.event EVENTO \n");strcat (dyn_sts,"from v$session se, v$session_wait sw

where sw.sid=se.sid and \n");strcat (dyn_sts,"se.username > 'A' and sw.event not like

'SQL*Net%' and \n");strcat (dyn_sts,"sw.event not like 'PX Deq: Table Q

Normal%' and \n");strcat (dyn_sts,"sw.event not like 'PX Deq: Execution

Msg%' and \n");strcat (dyn_sts,"sw.event not like 'pipe get%' \n");strcat (dyn_sts,"group by se.sid, se.username, sw.event

");break;

case CASE_INSTANCE_STATUS:switch (version)

{case VERSION_ORACLE_816:case VERSION_ORACLE_817:case VERSION_ORACLE_920:

strcpy (dyn_sts,"select a.instance_number, a.instance_name, a.host_name, a.version, \n");

strcat (dyn_sts,"to_char(a.startup_time,'DD/MM/YYYY - HH24:MI:SS'),a.status, a.parallel, \n");

strcat (dyn_sts,"a.database_status, a.instance_role ,b.log \n");

strcat (dyn_sts,"from v$instance a, \n");

strcat (dyn_sts," (select log_mode log from v$database ) b \n");

break;case VERSION_ORACLE_734:

strcpy (dyn_sts,"select a.name, a.created, a.log_mode, a.checkpoint_change#, \n");

strcat (dyn_sts,"a.archive_change#, b.val1 ,c.val2, d.val3, e.value, a.log_mode \n");

strcat (dyn_sts,"from v$database a, \n");

strcat (dyn_sts,"(select decode (value,0,'OPEN') val1 \n");

strcat (dyn_sts,"from v$instance where key='RESTRICTED MODE') b, \n");

strcat (dyn_sts,"(select decode(value,0,'NO') val2 \n");

strcat (dyn_sts,"from v$instance where key='SHUTDOWN PENDING') c, \n");

strcat (dyn_sts,"(select to_char(to_date(value, 'J'),'DD/MM/YYYY') val3 \n");

strcat (dyn_sts,"from v$instance where key='STARTUP TIME - JULIAN' ) d, \n");

Página 2

func_dyn_statement_set.cstrcat (dyn_sts,"(select value \n");strcat (dyn_sts,"from v$instance where

key='STARTUP TIME - SECONDS' ) e \n");break;

default:break;

}break;

case CASE_TEMPORAL_SPACE_BY_USER:switch (version)


strcpy (dyn_sts,"select se.sid, se.serial#, se.username, so.extents, so.contents, \n");

strcat (dyn_sts,"sum((so.blocks)*(selectvalue from v$parameter \n");

strcat (dyn_sts,"where name in ('db_block_size'))/1000) size_kb \n");

strcat (dyn_sts,"from v$session se, v$sort_usage so where se.saddr=so.session_addr \n");

strcat (dyn_sts,"group by se.sid,se.serial#,se.username,so.extents,so.contents \n");


strcpy (dyn_sts,"select tablespace_name,extent_size, current_users, total_extents, \n");

strcat (dyn_sts,"total_blocks, used_extents, used_blocks, free_extents, free_blocks, \n");

strcat (dyn_sts,"max_used_size, max_used_blocks, max_sort_size, max_sort_blocks \n");

strcat (dyn_sts,"from v$sort_segment \n");

default:break;

}break;

case CASE_TOT_FREELIST_WAIT_PERCENT:strcpy (dyn_sts,"select (a.count/sum(b.value))*100

PCT_FREELIST from v$waitstat a, \n");strcat (dyn_sts,"v$sysstat b where a.class='free list'

and \n");strcat (dyn_sts,"b.name in ('db block gets','consistent

gets') group by a.count ");break;

case CASE_LAST_CHECKPOINT_TIME:switch (version)


strcpy (dyn_sts,"select min(sysdate - CHECKPOINT_TIME)*24*60 MINUTO, \n");

strcat (dyn_sts,"to_char(sysdate,'DD/MM/YYYY - HH24:MI:SS') FECHA \n");

strcat (dyn_sts,"from v$datafile_header");


strcpy (dyn_sts,"select count(sid) Cantidad from v$session \n");

break;default:

break;}

break;case CASE_LIST_TABLESPACES:

Página 3

func_dyn_statement_set.cswitch (version)


strcpy (dyn_sts,"select a.tablespace_name TBL_NAME,d.contents CONTENT,a.sum_bytes/1048576 AVAILA_KB, \n");

strcat (dyn_sts,"a.max_id MAX_ID,nvl(a.sum_bytes - c.sum_bytes,0)/1048576 USED_KB, \n");

strcat (dyn_sts,"nvl(c.sum_bytes,0)/1048576 FREE_KB, \n");

strcat (dyn_sts,"round(nvl((a.sum_bytes - c.sum_bytes),0.00)/a.sum_bytes*100.0,2) PCT_USED, d.status, \n");

strcat (dyn_sts,"d.extent_management,d.allocation_type from (select tablespace_name,sum(bytes) sum_bytes, \n");

strcat (dyn_sts,"count(1) max_id from dba_data_files group by tablespace_name ) a, \n");

strcat (dyn_sts,"(select tablespace_name,sum(bytes) sum_bytes from dba_free_space \n");

strcat (dyn_sts,"group by tablespace_name) c, dba_tablespaces d \n");

strcat (dyn_sts,"where a.tablespace_name= c.tablespace_name(+) and \n");

strcat (dyn_sts,"a.tablespace_name = d.tablespace_name (+) order by 5,1 ");

break;case VERSION_ORACLE_734:strcpy (dyn_sts,"select

a.tablespace_name TBL_NAME,d.contents CONTENT,a.sum_bytes/1048576 AVAILA_KB, \n");

strcat (dyn_sts,"a.max_id MAX_ID,nvl(a.sum_bytes - c.sum_bytes,0)/1048576 USED_KB, \n");

strcat (dyn_sts,"nvl(c.sum_bytes,0)/1048576 FREE_KB, \n");

strcat (dyn_sts,"round(nvl((a.sum_bytes - c.sum_bytes),0.00)/a.sum_bytes*100.0,2) PCT_USED, d.status \n");

strcat (dyn_sts,"from (select tablespace_name,sum(bytes) sum_bytes, \n");

strcat (dyn_sts,"count(1) max_id from dba_data_files group by tablespace_name ) a, \n");

strcat (dyn_sts,"(select tablespace_name,sum(bytes) sum_bytes from dba_free_space \n");

strcat (dyn_sts,"group by tablespace_name) c, dba_tablespaces d \n");

strcat (dyn_sts,"where a.tablespace_name= c.tablespace_name(+) and \n");

strcat (dyn_sts,"a.tablespace_name = d.tablespace_name (+) order by 5,1 ");

break;}

break;case CASE_ACTIVE_TRANSACTIONS:

switch (version){case VERSION_ORACLE_816:case VERSION_ORACLE_817:case VERSION_ORACLE_920:

strcpy (dyn_sts,"select tr.addr, \n");/* strcat

(dyn_sts,"to_char(tr.start_time,'DD/MM/YYYY - 24HH:MM:SS') TIME_START, \n");*/

strcat (dyn_sts,"tr.start_time, \n");strcat (dyn_sts,"tr.status

ESTADO,tr.used_ublk BLK_USED,tr.used_ublk*(select value \n");strcat (dyn_sts,"from v$parameter where

name in 'db_block_size')/1000 KB_USED,tr.used_urec, \n");

Página 4

func_dyn_statement_set.cstrcat (dyn_sts,"se.sid SES, se.serial#

SERIAL,rn.name,se.username from v$transaction tr, \n");strcat (dyn_sts,"v$session se,

v$rollname rn where tr.xidusn=rn.usn and \n");strcat (dyn_sts,"tr.ses_addr=se.saddr

order by 2,6");break;case VERSION_ORACLE_734:

strcpy (dyn_sts,"select tr.addr, ");strcat (dyn_sts,"tr.start_time, ");

/* strcat (dyn_sts,"to_char(tr.start_time,'DD/MM/YYYY - 24HH:MM:SS') TIME_START, \n"); */

strcat (dyn_sts,"tr.status ESTADO,tr.used_ublk BLK_USED,tr.used_ublk,\n");

strcat (dyn_sts,"tr.used_urec, \n");strcat (dyn_sts,"se.sid SES, se.serial#

SERIAL,rn.name,se.username from v$transaction tr, \n");strcat (dyn_sts,"v$session se,

v$rollname rn where tr.xidusn=rn.usn and \n");strcat (dyn_sts,"tr.ses_addr=se.saddr

order by 2,6");break;}

break;case CASE_LATCH_DETAILS:

strcpy (dyn_sts,"select gets GETS,misses MISS,round((gets-misses)*100/gets,2) HITRATIO, \n");

strcat (dyn_sts,"immediate_gets IMM_GETS,immediate_misses IMM_MISS,sleeps SLEEP, \n");

strcat (dyn_sts,"spin_gets GETSPIN,addr ADDR,latch#,nameNOMBRE from v$latch \n");

strcat (dyn_sts,"where misses > 0 and gets > 0 \n");strcat (dyn_sts,"order by 2 desc

,round(((gets-misses)/gets),2) desc");break;

case CASE_RESOURCE_LIMITS:switch (version)


strcpy (dyn_sts,"select resource_name NOMBRE,initial_allocation INIT_ALLOC, \n");

strcat (dyn_sts,"current_utilization CURR_UTILIZA,max_utilization MAX_UTILIZA, \n");

strcat (dyn_sts,"limit_value LIMITE fromv$resource_limit order by 4");


strcpy (dyn_sts,"select resource_name, limit \n");

strcat (dyn_sts,"from user_resource_limits order by 2");

break;}

break;case CASE_LIST_DATAFILES:


strcpy (dyn_sts,"select name DATAFILE,bytes/1048576 MBYTES, status ESTADO from v$datafile \n");

strcat (dyn_sts,"union all \n");strcat (dyn_sts,"select name

DATAFILE,bytes/1048576 MBYTES, status ESTADO from v$tempfile \n");strcat (dyn_sts," order by MBYTES desc

Página 5

func_dyn_statement_set.c\n");


strcpy (dyn_sts,"select name DATAFILE,bytes/1048576 MBYTES, status ESTADO from v$datafile \n");/* FALTARIA VER COMO HACEMOS PARA BUSCAR LA PARTE TEMPORAL EN VERSIONES 7.3.4

strcat (dyn_sts,"union all \n");strcat (dyn_sts,"select name

DATAFILE,bytes/1048576 MBYTES, status ESTADO from v$tempfile \n");*/

strcat (dyn_sts," order by MBYTES desc \n");

break;}

break;case CASE_LIST_DATAFILES_NEW_9I:


strcpy (dyn_sts,"select v.status ESTADO,d.file_name DATAFILE, d.tablespace_name TBLNAME, \n");

strcat (dyn_sts,"to_char(nvl((d.bytes/1024),0),'99999990.000') SIZE_KB, \n");

strcat (dyn_sts,"to_char(nvl(((d.bytes-nvl(s.bytes,0))/1024),0),'99999999.999') || '/' || to_char(nvl((d.bytes/1024),0),'99999999.999') || '/' || nvl (d.autoextensible,'NO') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl(((d.bytes -nvl(s.bytes,0))/d.bytes)*100,0),'990.00') USED_PCT \n");

strcat (dyn_sts,"from sys.dba_data_filesd, v$datafile v, (select file_id,sum(bytes) bytes \n");

strcat (dyn_sts,"from sys.dba_free_spacegroup by file_id) s \n");

strcat (dyn_sts,"where s.file_id(+)=d.file_id and d.file_name=v.name \n");

strcat (dyn_sts,"union all \n");strcat (dyn_sts,"select v.status ESTADO,

d.file_name DATAFILE, d.tablespace_name TBLNAME, \n");strcat

(dyn_sts,"to_char(nvl((d.bytes/1024),0),'99999990.000') SIZE_KB, \n");strcat

(dyn_sts,"to_char(nvl((t.bytes_cached / 1024),0),'9999999.999') || '/' || to_char(nvl((d.bytes/1024),0),'99999999.999') || '/' || nvl (d.autoextensible,'NO') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl((t.bytes_cached/d.bytes)*100,0),'990.00') USED_PCT \n");

strcat (dyn_sts,"from sys.dba_temp_filesd, v$temp_extent_pool t, v$tempfile v \n");

strcat (dyn_sts,"where t.file_id(+)=d.file_id and d.file_id=v.file# \n");

strcat (dyn_sts,"order by SIZE_KB desc \n");


strcpy (dyn_sts,"select v.status ESTADO,d.file_name DATAFILE, d.tablespace_name TBLNAME, \n");


strcat (dyn_sts,"to_char(nvl(((d.bytes-nvl(s.bytes,0))/1024),0),'99999999.999') || '/' || to_char(nvl((d.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl(((d.bytes -nvl(s.bytes,0))/d.bytes)*100,0),'990.00') USED_PCT \n");

Página 6

func_dyn_statement_set.cstrcat (dyn_sts,"from sys.dba_data_files

d, v$datafile v, (select file_id,sum(bytes) bytes \n");strcat (dyn_sts,"from sys.dba_free_space

group by file_id) s \n");strcat (dyn_sts,"where

s.file_id(+)=d.file_id and d.file_name=v.name \n");/* strcat (dyn_sts,"union all \n");

strcat (dyn_sts,"select v.status ESTADO,d.file_name DATAFILE, d.tablespace_name TBLNAME, \n");


strcat (dyn_sts,"to_char(nvl((t.bytes_cached / 1024),0),'9999999.999') || '/' || to_char(nvl((d.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl((t.bytes_cached/d.bytes)*100,0),'990.00') USED_PCT \n");

strcat (dyn_sts,"from sys.dba_temp_filesd, v$temp_extent_pool t, v$tempfile v \n");

strcat (dyn_sts,"where t.file_id(+)=d.file_id and d.file_id=v.file# \n"); */


break;}

break;case CASE_LIST_TABLESPACES_NEW_9I:


strcpy (dyn_sts,"select d.status ESTADO,d.tablespace_name TBLNAME,d.contents TIPO, \n");

strcat (dyn_sts,"d.extent_management EXTENT_MGM,to_char(nvl((a.bytes/1024),0),'99999999.999') SIZE_KB, \n");

strcat (dyn_sts,"to_char((nvl(a.bytes-nvl(f.bytes,0),0)/1024),'99999999.999') || '/' ||to_char(nvl((a.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl(((a.bytes -nvl(f.bytes,0))/a.bytes)*100,0),'990.00') USED_PCT \n");

strcat (dyn_sts,"from sys.dba_tablespaces d, (select tablespace_name, sum(bytes) bytes \n");

strcat (dyn_sts,"from dba_data_files group by tablespace_name) a, (select tablespace_name,sum(bytes) bytes \n");

strcat (dyn_sts,"from dba_free_space group by tablespace_name ) f \n");

strcat (dyn_sts,"where d.tablespace_name=a.tablespace_name(+) and \n");

strcat (dyn_sts,"d.tablespace_name = f.tablespace_name(+) and \n");

strcat (dyn_sts,"not (d.extent_management like 'LOCAL' and d.contents LIKE 'TEMPORARY') \n");

strcat (dyn_sts,"union all \n"); strcat (dyn_sts,"select d.status ESTADO,

d.tablespace_name TBLNAME,d.contents TIPO, \n");strcat (dyn_sts,"d.extent_management

EXTENT_MGM,to_char(nvl((a.bytes/1024),0),'99999999.999') SIZE_KB, \n");strcat

(dyn_sts,"to_char((nvl(t.bytes,0)/1024),'99999999.999') || '/' || to_char(nvl((a.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl((t.bytes/a.bytes)*100,0),'990.00') USED_PCT from sys.dba_tablespaces d, \n");

strcat (dyn_sts,"(select tablespace_name, sum(bytes) bytes from dba_temp_files group by tablespace_name) a, \n");

Página 7

func_dyn_statement_set.cstrcat (dyn_sts,"(select

tablespace_name, sum(bytes_cached) bytes from v$temp_extent_pool \n");strcat (dyn_sts,"group by

tablespace_name) t where d.tablespace_name=a.tablespace_name (+) and \n");strcat

(dyn_sts,"d.tablespace_name=t.tablespace_name (+) and d.extent_management like 'LOCAL' and \n");

strcat (dyn_sts,"d.contents like 'TEMPORARY' \n");



strcpy (dyn_sts,"select d.status ESTADO,d.tablespace_name TBLNAME,d.contents TIPO, \n");

strcat (dyn_sts,"to_char(nvl((a.bytes/1024),0),'99999999.999') SIZE_KB, \n");

strcat (dyn_sts,"to_char((nvl(a.bytes-nvl(f.bytes,0),0)/1024),'99999999.999') || '/' ||to_char(nvl((a.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl(((a.bytes -nvl(f.bytes,0))/a.bytes)*100,0),'990.00') USED_PCT \n");

strcat (dyn_sts,"from sys.dba_tablespaces d, (select tablespace_name, sum(bytes) bytes \n");

strcat (dyn_sts,"from dba_data_files group by tablespace_name) a, (select tablespace_name,sum(bytes) bytes \n");

strcat (dyn_sts,"from dba_free_space group by tablespace_name ) f \n");

strcat (dyn_sts,"where d.tablespace_name=a.tablespace_name(+) and \n");

strcat (dyn_sts,"d.tablespace_name = f.tablespace_name(+) and \n");

strcat (dyn_sts,"not d.contents LIKE 'TEMPORARY' \n");

/*strcat (dyn_sts,"union all \n"); strcat (dyn_sts,"select d.status ESTADO,

d.tablespace_name TBLNAME,d.contents TIPO, \n");strcat

(dyn_sts,"to_char(nvl((a.bytes/1024),0),'99999999.999') SIZE_KB, \n");strcat

(dyn_sts,"to_char((nvl(t.bytes,0)/1024),'99999999.999') || '/' || to_char(nvl((a.bytes/1024),0),'99999999.999') USED_KB, \n");

strcat (dyn_sts,"to_char(nvl((t.bytes/a.bytes)*100,0),'990.00') USED_PCT from sys.dba_tablespaces d, \n");

strcat (dyn_sts,"(select tablespace_name, sum(bytes) bytes from dba_temp_files group by tablespace_name) a, \n");

strcat (dyn_sts,"(select tablespace_name, sum(bytes_cached) bytes from v$temp_extent_pool \n");

strcat (dyn_sts,"group by tablespace_name) t where d.tablespace_name=a.tablespace_name (+) and \n");

strcat (dyn_sts,"d.tablespace_name=t.tablespace_name (+) and \n");

strcat (dyn_sts,"d.contents like 'TEMPORARY' ");

*/strcat (dyn_sts,"order by SIZE_KB desc

\n");break;

}break;

case CASE_ACTIVE_SESSIONS:switch (version)

{case VERSION_ORACLE_816:case VERSION_ORACLE_817:

Página 8

func_dyn_statement_set.ccase VERSION_ORACLE_920:

strcpy (dyn_sts,"select s.sid SES, s.serial# SERI, s.type TIPO, s.osuser OS_USER, \n");

strcat (dyn_sts,"to_char(logon_time,'DD/MM/YYYY - HH24:MI:SS') LOGON,s.status ESTADO, \n");

strcat (dyn_sts,"s.process PROCESO, s.machine MAQUINA, s.username NOMBRE, \n");

strcat (dyn_sts,"p.spid PID, s.program PROGRAMA \n");

strcat (dyn_sts,"from v$session s, v$process p \n");

strcat (dyn_sts,"where osuser is not null and p.addr=s.paddr \n");

strcat (dyn_sts,"order by LOGON, ESTADO \n");


strcpy (dyn_sts,"select s.sid SES, s.serial# SERI, s.type TIPO, s.osuser OS_USER, \n");

strcat (dyn_sts,"to_char(logon_time,'DD/MM/YYYY - HH24:MI:SS') LOGON,s.status ESTADO, \n");

strcat (dyn_sts,"s.process PROCESO, s.machine MAQUINA, s.username NOMBRE, \n");

strcat (dyn_sts,"p.spid PID, s.program PROGRAMA \n");

strcat (dyn_sts,"from v$session s, v$process p \n");

strcat (dyn_sts,"where osuser is not null and p.addr=s.paddr \n");

strcat (dyn_sts,"order by LOGON, ESTADO \n");

break;}

break;case CASE_SESSIONS_WAITS:

strcpy (dyn_sts,"select sw.sid SES, sw.seq# SEQ, nvl(sw.wait_time,0) W_T, \n");

strcat (dyn_sts,"nvl(sw.seconds_in_wait,0) S_W_T,nvl(se.username,'.') USUA, \n");

strcat (dyn_sts,"nvl(se.status,'.') ESTA,sw.event EVENT,sw.state, sw.p1text, sw.p1, \n");

strcat (dyn_sts,"sw.p1raw, sw.p2text, sw.p2, sw.p2raw, sw.p3text, sw.p3, sw.p3raw \n");

strcat (dyn_sts,"from v$session_wait sw, v$session se \n");

strcat (dyn_sts,"where sw.sid = se.sid order by 6,8 \n");

break;case CASE_DEFAULT_STORAGE_SETS_TABLESPACE:

strcpy (dyn_sts,"select tablespace_name TBLNAME, initial_extent INI_EXT, next_extent NEX_EXT, \n");

strcat (dyn_sts,"min_extents MIN_EXT, max_extents MAX_EXT, pct_increase PCT_INC \n");

strcat (dyn_sts,"from dba_tablespaces \n");strcat (dyn_sts,"order by tablespace_name \n");break;

case CASE_ALL_TABLES_STORAGE_SETTINGS:strcpy (dyn_sts,"select owner OWNER_TABLE, segment_name

SEG_NAME, tablespace_name TBL_NAME, \n");strcat (dyn_sts,"blocks BLKS, blocks SIZE_KB, \n");

strcat (dyn_sts,"extents EXTS, max_extents MAX_EXT \n");strcat (dyn_sts,"from dba_segments \n");strcat (dyn_sts,"where segment_type='TABLE' order by 1,2

\n");break;

Página 9

func_dyn_statement_set.ccase CASE_ALL_NON_SYS_TABLES_SETTINGS:


strcpy (dyn_sts,"select owner OWNER, table_name TNAME, tablespace_name TBLNAME, \n");

strcat (dyn_sts,"nvl(blocks,-1) BLOCK, nvl(num_rows,-1) NROWS, buffer_pool BUFF_POOL, \n");

strcat (dyn_sts,"nvl(to_char(last_analyzed,'DD/MM/YYYY - HH24:MI'),-1) LAST_ANALIZE, \n");

strcat (dyn_sts,"sum(blocks) \n");strcat (dyn_sts,"from dba_tables \n");strcat (dyn_sts,"group by

owner,table_name,tablespace_name,nvl(blocks,-1),nvl(num_rows,-1), \n");strcat

(dyn_sts,"buffer_pool,nvl(to_char(last_analyzed,'DD/MM/YYYY - HH24:MI'),-1) \n");

strcat (dyn_sts,"order by 1,2 \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select owner OWNER,

table_name TNAME, tablespace_name TBLNAME, \n");strcat (dyn_sts,"nvl(blocks,-1) BLOCK,

nvl(num_rows,-1) NROWS, \n");strcat (dyn_sts,"sum(blocks) \n");strcat (dyn_sts,"from dba_tables \n");strcat (dyn_sts,"group by

owner,table_name,tablespace_name,nvl(blocks,-1),nvl(num_rows,-1) \n");


}break;

case CASE_ALL_NON_SYS_INDEXES_SETTINGS:switch (version)


strcpy (dyn_sts,"select owner,index_name,tablespace_name, nvl(leaf_blocks,-1), nvl(num_rows,-1), \n");

strcat (dyn_sts,"buffer_pool, nvl(to_char(last_analyzed,'DD/MM/YYYY - HH24:MI'),-1), \n");

strcat (dyn_sts,"sum(leaf_blocks) \n");strcat (dyn_sts,"from dba_indexes \n");strcat (dyn_sts,"group by owner,

index_name, tablespace_name, nvl(leaf_blocks,-1), \n");strcat (dyn_sts,"nvl(num_rows,-1),

buffer_pool, nvl(to_char(last_analyzed,'DD/MM/YYYY - HH24:MI'),-1) \n");strcat (dyn_sts,"order by 1,2 \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select

owner,index_name,tablespace_name, nvl(leaf_blocks,-1), \n");

strcat (dyn_sts,"sum(leaf_blocks) \n");strcat (dyn_sts,"from dba_indexes \n");strcat (dyn_sts,"group by owner,

index_name, tablespace_name, nvl(leaf_blocks,-1) \n");


}break;

case CASE_USER_DEFINED:

Página 10

func_dyn_statement_set.cswitch (version)


strcpy (dyn_sts,"select * from (select distinct username, account_status, expiry_date, \n");

strcat (dyn_sts,"default_tablespace, temporary_tablespace, profile, \n");

strcat (dyn_sts,"to_char(created,'DD/MM/YYYY - HH24:MI') from dba_users \n");

strcat (dyn_sts,"union \n");strcat (dyn_sts,"select 'PUBLIC','OPEN',

to_date(null), '', '', \n");strcat (dyn_sts,"'',

to_char(to_date(null), \n");strcat (dyn_sts,"'DD/MM/YYYY - HH24:MI')

from dual) \n");strcat (dyn_sts,"order by

initcap(username) \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select distinct

username, \n");strcat (dyn_sts,"'----------',

to_date(null), \n");strcat (dyn_sts,"default_tablespace,

\n");strcat (dyn_sts,"temporary_tablespace,

profile, \n");strcat

(dyn_sts,"to_char(created,'DD/MM/YYYY - HH24:MI') from dba_users \n");strcat (dyn_sts,"union \n");strcat (dyn_sts,"select 'PUBLIC','OPEN',

to_date(null), '----------', \n");strcat (dyn_sts,"'----------',

'----------', to_char(to_date(null), \n");strcat (dyn_sts,"'DD/MM/YYYY - HH24:MI')

from dual \n");strcat (dyn_sts,"order by username \n");break;

}break;

case CASE_LIST_DATAFILE_REDO_CONTROL_FILES:strcpy (dyn_sts,"select file_name, tablespace_name,

status from dba_data_files \n");strcat (dyn_sts,"union all \n");strcat (dyn_sts,"select member, 'LOG FILE', status from

v$logfile \n");strcat (dyn_sts,"union all \n");strcat (dyn_sts,"select name, 'CONTROL FILE', status

from v$controlfile \n");strcat (dyn_sts,"order by 1,2 \n");break;

case CASE_LIST_DATAFILES_USED_BLOCKS:strcpy (dyn_sts,"select a.tablespace_name, a.file_name,

a.bytes, \n");strcat (dyn_sts,"(b.maximum + c.blocks -1) *

d.db_block_size highwater \n");strcat (dyn_sts,"from dba_data_files a, \n");strcat (dyn_sts,"(select file_id, max(block_id) maximum

\n");strcat (dyn_sts,"from dba_extents \n");strcat (dyn_sts,"group by file_id ) b, \n");strcat (dyn_sts,"dba_extents c, \n");strcat (dyn_sts,"(select value db_block_size from

v$parameter where name='db_block_size') d \n");strcat (dyn_sts,"where a.file_id = b.file_id \n");

Página 11

func_dyn_statement_set.cstrcat (dyn_sts,"and c.file_id = b.file_id \n");strcat (dyn_sts,"and c.block_id = b.maximum \n");strcat (dyn_sts,"order by a.bytes, a.tablespace_name,

a.file_name \n");break;

case CASE_LIST_SORT_BY_USER:strcpy (dyn_sts,"select vss.value VALOR,

substr(vsn.name,1,20) TYPE_SORT, \n");strcat (dyn_sts,"vs.sid SID, \n");strcat (dyn_sts,"substr(vs.osuser,1,20) OS_USER,

substr(vs.username,1,20) DB_USER \n");strcat (dyn_sts,"from v$session vs, v$sesstat vss,

v$statname vsn \n");strcat (dyn_sts,"where (vss.statistic# = vsn.statistic#)

and \n");strcat (dyn_sts,"(vs.sid = vss.sid ) and \n");strcat (dyn_sts,"(vsn.name like '%sort%') and \n");strcat (dyn_sts,"vss.value <> 0 \n");strcat (dyn_sts,"order by 1,2,3 \n");break;

case CASE_LIST_LOCK_STATUS:switch (version)


strcpy (dyn_sts,"select lo.addr, lo.kaddr, lo.sid SES, lo.type TIP, \n");

strcat (dyn_sts,"lo.id1 OBJID, lo.id2, \n");

strcat (dyn_sts,"lo.lmode, \n");strcat (dyn_sts,"lo.request REQT, \n");strcat (dyn_sts,"(select

ltrim(object_type) \n");strcat (dyn_sts,"from all_objects where

object_id=lo.id1) OBJ_TYP, \n");strcat (dyn_sts,"(select

ltrim(owner)||'.'||ltrim(object_name) \n");strcat (dyn_sts,"from all_objects where

object_id=lo.id1) OWN_OBJ, \n");strcat (dyn_sts,"(select sid SES \n");strcat (dyn_sts,"from v$session where

lockwait=lo.kaddr) LOC_SID, \n");strcat (dyn_sts,"ctime \n");strcat (dyn_sts,"from v$lock lo \n");strcat (dyn_sts,"order by lo.sid \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select lo.addr,

lo.kaddr, lo.sid, \n");strcat (dyn_sts,"lo.type, lo.id1,

lo.id2, \n");strcat (dyn_sts,"lo.lmode, \n");strcat (dyn_sts,"lo.request, \n");strcat (dyn_sts,"lo.id1, \n");strcat (dyn_sts,"lo.id1, \n");strcat (dyn_sts,"lo.kaddr, \n");strcat (dyn_sts,"lo.ctime \n");strcat (dyn_sts,"from v$lock lo \n");strcat (dyn_sts,"order by lo.sid \n");break;

}break;

case CASE_LIST_USER_BY_CPU_USAGE:strcpy (dyn_sts,"select vs.sid, vs.serial#, vs.type,

vs.osuser, \n");strcat (dyn_sts,"to_char(logon_time,'DD/MM/YYYY -

HH24:MI:SS'), \n");

Página 12

func_dyn_statement_set.c/* strcat (dyn_sts,"sysdate - logon_time, \n"); */

strcat (dyn_sts,"vs.process, vs.machine, vs.username, vss.value, \n");

strcat (dyn_sts,"vs.program \n");strcat (dyn_sts,"from v$session vs, v$sesstat vss,

v$statname vsn \n");strcat (dyn_sts,"where vss.statistic# = vsn.statistic#

and \n");strcat (dyn_sts,"vs.sid = vss.sid and \n");strcat (dyn_sts,"vsn.name = 'CPU used by this session'

\n");strcat (dyn_sts,"and vss.value <> 0 \n");strcat (dyn_sts,"order by 10 \n");break;

case CASE_SQL_STATEMENT_BY_THIS_USER:strcpy (dyn_sts,"select vsql.sql_text \n");strcat (dyn_sts,"from v$sqltext vsql \n");strcat (dyn_sts,"where vsql.address in ( select

vses.sql_address \n");strcat (dyn_sts,"from v$session vses \n");strcat (dyn_sts,"where vses.sid=");strcat (dyn_sts,opcion_uno);strcat (dyn_sts," )\n");strcat (dyn_sts,"order by vsql.piece \n");break;

case CASE_REDO_LOGS_STATUS:switch (version)


strcpy (dyn_sts,"select group#, thread#,sequence#, bytes, members, \n");

strcat (dyn_sts,"archived, status, first_change#, \n");

strcat (dyn_sts,"to_char(first_time,'DD/MM/YYYY - HH24:MI') \n");

strcat (dyn_sts,"from v$log \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select group#, thread#,

sequence#, bytes, members, \n");strcat (dyn_sts,"archived, status,

first_change#, \n");strcat (dyn_sts,"first_time \n");strcat (dyn_sts,"from v$log \n");break;

}break;

case CASE_ARCHIVED_LOGS_HISTORY:switch (version)


strcpy (dyn_sts,"select thread#, sequence#, name, first_change#, \n");

strcat (dyn_sts,"to_char (first_time,'DD/MM/YYYY - HH24:MI:SS'), \n");

strcat (dyn_sts,"blocks, block_size, \n");

strcat (dyn_sts,"to_char (completion_time,'DD/MM/YYYY - HH24:MI:SS') \n");

strcat (dyn_sts,"from v$archived_log order by 6 \n");


strcpy (dyn_sts,"select thread#,

Página 13

func_dyn_statement_set.csequence#,time, \n");

strcat (dyn_sts,"low_change#, high_change#, archive_name \n");

strcat (dyn_sts,"from v$log_history \n");

break;}

break;case CASE_REDO_LOG_RECOVERY_REPORT:

strcpy (dyn_sts,"select a.group#, a.first_change#, b.member, a.sequence# \n");

strcat (dyn_sts,"from v$log a, v$logfile b \n");strcat (dyn_sts,"where a.group# = b.group# \n");strcat (dyn_sts,"and a.status = 'CURRENT' \n");break;

case CASE_ARCHIVE_LOG_HISTROY:switch (version)


strcpy (dyn_sts,"select thread#, sequence#, first_change#, \n");

strcat (dyn_sts,"switch_change#, \n");strcat

(dyn_sts,"to_char(first_time,'DD/MM/YYYY - HH24:MI:SS') \n");strcat (dyn_sts,"from v$loghist \n");strcat (dyn_sts,"order by 5 \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select thread#,

sequence#, first_change#, \n");strcat (dyn_sts,"switch_change#, \n");strcat (dyn_sts,"first_time \n");strcat (dyn_sts,"from v$loghist \n");strcat (dyn_sts,"order by 5 \n");break;

}break;

case CASE_SESSION_LATCH_WAITS_SQL:strcpy (dyn_sts,"select sw.sid , nvl(se.username,'.') ,

\n");strcat (dyn_sts,"nvl(se.status,'.') , sq.sql_text \n");strcat (dyn_sts,"from v$session_wait sw, v$session se,

v$sqltext sq \n");strcat (dyn_sts,"where sw.sid = se.sid and \n");strcat (dyn_sts,"se.sql_address = sq.address and \n");strcat (dyn_sts,"se.sql_hash_value = sq.hash_value and

\n");strcat (dyn_sts,"sw.event = 'latch_free' \n");strcat (dyn_sts,"order by 1 \n");break;

case CASE_SESSION_PROGRAM_RUNNING_SQL:strcpy (dyn_sts,"select substr(v2.sid,1,5), \n");strcat (dyn_sts,"substr(v2.username,1,30), \n");strcat (dyn_sts,"program, sql_text \n");strcat (dyn_sts,"from sys.v_$sqlarea v1, \n");strcat (dyn_sts,"sys.v_$session v2 \n");strcat (dyn_sts,"where v1.address = v2.sql_address and

\n");strcat (dyn_sts,"v1.hash_value = v2.sql_hash_value \n");break;

case CASE_PRIVILEGES_BY_USER:strcpy (dyn_sts,"select decode (sa1.grantee#, 1,

'PUBLIC', u1.name), \n");strcat (dyn_sts,"substr (u2.name,1,25),

substr(spm.name,1,40) \n");strcat (dyn_sts,"from sys.sysauth$ sa1, sys.sysauth$

Página 14

func_dyn_statement_set.csa2, sys.user$ u1, \n");

strcat (dyn_sts,"sys.user$ u2, sys.system_privilege_map spm \n");

strcat (dyn_sts,"where sa1.grantee# = u1.user# and \n");strcat (dyn_sts,"sa1.privilege# = u2.user# and \n");strcat (dyn_sts,"u2.user# = sa2.grantee# and \n");strcat (dyn_sts,"sa2.privilege# = spm.privilege \n");strcat (dyn_sts,"union \n");strcat (dyn_sts,"select u.name, NULL,

substr(spm.name,1,40) \n");strcat (dyn_sts,"from sys.system_privilege_map spm,

sys.sysauth$ sa, \n");strcat (dyn_sts,"sys.user$ u \n");strcat (dyn_sts,"where sa.grantee#=u.user# and \n");strcat (dyn_sts,"sa.privilege# = spm.privilege \n");break;

case CASE_DETAILED_LOCKING_CAUSES:strcpy (dyn_sts,"select nvl(S.USERNAME,'Internal'),

L.SID, nvl(S.TERMINAL,'None'),\n");strcat (dyn_sts,"decode(command,

0,'None',decode(l.id2,0,U1.NAME||'.'||substr(T1.NAME,1,20),'None')),\n");strcat (dyn_sts,"command,\n");strcat (dyn_sts,"L.LMODE,L.REQUEST,\n");strcat (dyn_sts,"l.id1||'-'||l.id2, \n");strcat (dyn_sts,"l.type ||' - '|| l.type \n");strcat (dyn_sts,"from v$lock l, v$session s, sys.user$

u1, sys.obj$ t1 \n");strcat (dyn_sts,"where l.sid = s.sid and t1.obj# =

decode (l.id2,0,l.id1,1) and \n");strcat (dyn_sts,"u1.user# = t1.owner# and s.type !=

'BACKGROUND' \n");/* strcat (dyn_sts,"order by 1,5"); */

break;case CASE_CURRENT_STATISTICS_VALUES:

strcpy (dyn_sts,"select statistic#, name, value \n");strcat (dyn_sts,"from v$sysstat \n");strcat (dyn_sts,"order by name \n");break;

case CASE_TABLE_DESCRIPTION_USER_TABLENAME:switch (version)


strcpy (dyn_sts,"select tablespace_name,owner, table_name, \n");

strcat (dyn_sts,"nvl(to_char (num_rows),\'(Null)\'), \n");

strcat (dyn_sts,"nvl(to_char (last_analyzed,'YYYY/MM/DD-HH24:MI:SS'),\'(Null)\'), \n");

strcat (dyn_sts,"initial_extent,next_extent,\n");

strcat (dyn_sts,"min_extents,max_extents,pct_increase,buffer_pool,\n");

strcat (dyn_sts,"nvl(to_char (blocks),\'(Null)\'),\n");

strcat (dyn_sts,"freelists,pct_free,ini_trans,max_trans,\n");

strcat (dyn_sts,"freelist_groups \n");strcat (dyn_sts,"from dba_tables \n");if ( (strlen (opcion_uno) > 0) &&

(strlen (opcion_dos) == 0) ){strcat (dyn_sts,"where

owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");}

Página 15

func_dyn_statement_set.celse if ( (strlen(opcion_uno) == 0) && (

strlen (opcion_dos) > 0 )){strcat (dyn_sts,"where

table_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

else if ( (strlen (opcion_uno) > 0) && (strlen (opcion_dos) > 0 ))

{strcat (dyn_sts,"where

owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");strcat (dyn_sts,"and table_name

= '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

else strcat (dyn_sts,"\n");break;


tablespace_name,owner, table_name, \n");strcat (dyn_sts,"nvl(to_char

(num_rows),'(Null)'), \n");strcat (dyn_sts,"'(Null)', \n");strcat

(dyn_sts,"initial_extent,next_extent,\n");strcat

(dyn_sts,"min_extents,max_extents,pct_increase,'(Null)',\n");strcat (dyn_sts,"nvl(to_char

(blocks),'(Null)'),\n");strcat

(dyn_sts,"freelists,pct_free,ini_trans,max_trans,\n");strcat (dyn_sts,"freelist_groups \n");strcat (dyn_sts,"from dba_tables \n");if ( (strlen (opcion_uno) > 0) &&



else if ( (strlen(opcion_uno) == 0) && (strlen (opcion_dos) > 0 ))


table_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}



owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");strcat (dyn_sts,"and table_name



Página 16

func_dyn_statement_set.c}

break;case CASE_INDEX_DESCRIPTION_USER_INDEXNAME:


strcpy (dyn_sts,"select owner,index_name,table_owner, \n");

strcat (dyn_sts,"table_name,table_type,uniqueness,tablespace_name, \n");

strcat (dyn_sts,"ini_trans,max_trans,initial_extent,next_extent, \n");

strcat (dyn_sts,"min_extents,max_extents,pct_increase,freelists, \n");

strcat (dyn_sts,"freelist_groups,pct_free,blevel,leaf_blocks \n");

strcat (dyn_sts,"from dba_indexes \n");if ( (strlen (opcion_uno) > 0) &&





index_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}



owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");strcat (dyn_sts,"and index_name




owner,index_name,table_owner, \n");strcat

(dyn_sts,"table_name,table_type,uniqueness,tablespace_name, \n");strcat

(dyn_sts,"ini_trans,max_trans,initial_extent,next_extent, \n");strcat

(dyn_sts,"min_extents,max_extents,pct_increase,freelists, \n");strcat

(dyn_sts,"freelist_groups,pct_free,blevel,leaf_blocks \n");

strcat (dyn_sts,"from dba_indexes \n");if ( (strlen (opcion_uno) > 0) &&


owner='");

Página 17

func_dyn_statement_set.cstrcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");}



index_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}



owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");strcat (dyn_sts,"and index_name


else strcat (dyn_sts,"\n");}

break;case CASE_CURRENT_ACTIVITY_REPORT:

strcpy (dyn_sts,"SELECT address, buffer_gets, executions, ");

strcat (dyn_sts,"round(buffer_gets/executions), SUBSTR(sql_text,1,150) ");

strcat (dyn_sts,"FROM v$sqlarea WHERE executions > 0 AND");

strcat (dyn_sts,"buffer_gets > 10000 ORDER BY 3 desc, 3 desc \n");

break;case CASE_DICTIONARY_TABLE_COMMENTS:

strcpy (dyn_sts,"SELECT TABLE_NAME, COMMENTS \n");strcat (dyn_sts,"FROM DICT ORDER BY 1 \n");break;

case CASE_DICTIONARY_TABLE_COLUMNS_DESCRIP:strcpy (dyn_sts,"SELECT /*+ RULE */ DC.TABLE_NAME,

DC.COLUMN_NAME, DC.COMMENTS, ");strcat (dyn_sts,"TC.DATA_TYPE || DECODE( TC.DATA_TYPE,

'NUMBER', ");strcat (dyn_sts,"DECODE(TC.DATA_PRECISION,NULL,NULL,' ('

|| TC.DATA_PRECISION || ");strcat (dyn_sts,"DECODE( TC.DATA_SCALE, NULL, NULL, ','

|| TC.DATA_SCALE) || ')'), ");strcat (dyn_sts,"'VARCHAR2', ' (' || TC.DATA_LENGTH ||

')', 'CHAR', ' (' || ");strcat (dyn_sts,"TC.DATA_LENGTH || ')', NULL)

SQL_TYPE, ");strcat (dyn_sts,"DECODE ( TC.DATA_TYPE, 'VARCHAR2', 0,

'CHAR', 0, 'NUMBER', 1, 'DATE', ");strcat (dyn_sts,"2 ,'LONG', 3, 'RAW', 4, 'LONG ROW', 5,

'MLSLABEL', 6, -1) IMAGE_INDEX, ");strcat (dyn_sts,"TC.COLUMN_ID, TC.DATA_TYPE \n");strcat (dyn_sts,"FROM ALL_COL_COMMENTS DC, \n");strcat (dyn_sts,"( SELECT S.SYNONYM_NAME, S.TABLE_NAME,

C.COLUMN_NAME, C.DATA_TYPE, ");strcat (dyn_sts,"C.DATA_PRECISION, C.DATA_SCALE,

C.DATA_LENGTH, C.COLUMN_ID ");strcat (dyn_sts,"FROM SYS.ALL_TAB_COLUMNS C,

SYS.ALL_SYNONYMS S ");strcat (dyn_sts,"WHERE C.OWNER = S.TABLE_OWNER AND

C.OWNER = 'SYS' AND ");strcat (dyn_sts,"S.TABLE_OWNER = 'SYS' AND C.TABLE_NAME

Página 18

func_dyn_statement_set.c= S.TABLE_NAME AND ");

/* -------------------------- hacer referencia a variable host --------------------- */

strcat (dyn_sts,"S.OWNER = 'PUBLIC' ");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"AND S.SYNONYM_NAME ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");}

/* --------------------------------------------------------------------------------- */

strcat (dyn_sts,"UNION ");strcat (dyn_sts,"SELECT C.TABLE_NAME SYNONYM_NAME,

C.TABLE_NAME, C.COLUMN_NAME, ");strcat (dyn_sts,"C.DATA_TYPE, C.DATA_PRECISION,

C.DATA_SCALE, C.DATA_LENGTH, ");strcat (dyn_sts,"C.COLUMN_ID ");strcat (dyn_sts,"FROM SYS.ALL_TAB_COLUMNS C ");


/* strcat (dyn_sts,"WHERE C.OWNER = 'SYS' AND C.TABLE_NAME = :TABLE_NAME ) TC \n"); */

strcat (dyn_sts,"WHERE C.OWNER = 'SYS' ");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"AND C.TABLE_NAME = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ) TC \n");}

else{strcat (dyn_sts," ) TC \n");}

/* --------------------------------------------------------------------------------- */


strcat (dyn_sts,"WHERE DC.OWNER = 'SYS' \n");/**** --AND DC.TABLE_NAME = 'ALL_OBJECTS' \n"); ****/strcat (dyn_sts,"AND ");

/* --------------------------------------------------------------------------------- */


strcat (dyn_sts,"TC.TABLE_NAME = DC.TABLE_NAME AND ");

if ( (strlen (opcion_uno) > 0) ){strcat (dyn_sts,"TC.SYNONYM_NAME = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND \n");}

/* --------------------------------------------------------------------------------- */

strcat (dyn_sts,"TC.COLUMN_NAME = DC.COLUMN_NAME \n");strcat (dyn_sts,"ORDER BY DC.TABLE_NAME, COLUMN_ID \n");

break;case CASE_SGA_STATISTIC_GENERAL:

strcpy (dyn_sts,"SELECT NUM, NAME, VALUE, ISDEFAULT, ISMODIFIED, ISADJUSTED, \n");

strcat (dyn_sts,"DECODE( TYPE, 1, 'Boolean', 2, 'string', 3, 'integer', ");

Página 19

func_dyn_statement_set.cstrcat (dyn_sts,"4, 'file', 6, 'big integer',

TO_CHAR(TYPE)) TYPE, ");strcat (dyn_sts,"DECODE(ISSES_MODIFIABLE, 'TRUE', 'yes',

NULL) ISSES_MODIFIABLE, ");strcat (dyn_sts,"DECODE(ISSYS_MODIFIABLE, 'IMMEDIATE',

'immediate', 'DEFERRED', ");strcat (dyn_sts,"'deferred', NULL) ISSYS_MODIFIABLE,

DESCRIPTION \n");strcat (dyn_sts,"FROM sys.V_$PARAMETER \n");strcat (dyn_sts,"where (name = 'shared_pool_size' or

name = 'large_pool_size' or ");strcat (dyn_sts,"name = 'create_bitmap_area_size' or

name = 'java_pool_size' or ");strcat (dyn_sts,"name = 'sort_area_retained_size' or

name = 'sort_area_size' or ");strcat (dyn_sts,"name = 'db_block_buffers' or name =

'db_block_lru_latches' or ");strcat (dyn_sts,"name = 'db_block_size' or name =

'buffer_pool_keep' or ");strcat (dyn_sts,"name = 'buffer_pool_recycle') ");strcat (dyn_sts,"ORDER BY NUM \n");break;

case CASE_SGA_STATISTIC_MEMORY_USAGE:strcpy (dyn_sts,"SELECT 'shared pool', SS.NAME, SS.

BYTES/1024, ");strcat (dyn_sts,"100 * SS.BYTES / S.VALUE ,S.VALUE ");strcat (dyn_sts,"FROM sys.V_$SGASTAT SS, sys.V_$SGA S

");strcat (dyn_sts,"WHERE S.NAME = 'Variable Size' ");strcat (dyn_sts,"ORDER BY 1 desc, 3 DESC \n");break;

case CASE_SGA_STATISTIC_INFORMATION:strcpy (dyn_sts,"SELECT NAME, VALUE/1024 VALUE ");strcat (dyn_sts,"FROM sys.V_$SGA \n");break;

case CASE_ROW_CACHE_INFORMATION:strcpy (dyn_sts,"SELECT CACHE#, SUBORDINATE#, PARAMETER,

GETS, ");strcat (dyn_sts,"GETMISSES, ");strcat (dyn_sts,"to_number(decode( GETS, 0, null, 100 *

nvl(GETMISSES,0) / GETS)) ");strcat (dyn_sts,"SCANS, SCANMISSES, SCANCOMPLETES, \n");strcat (dyn_sts,"to_number(decode( SCANS, 0, NULL, 100 *

nvl(SCANMISSES,0) / SCANS)) "); strcat (dyn_sts,"COUNT, USAGE, FIXED, FLUSHES, MODIFICATIONS ");

strcat (dyn_sts,"FROM sys.V_$ROWCACHE ");strcat (dyn_sts,"ORDER BY GETMISSES,GETS \n");break;

case CASE_PERFORMANCE_DISK_I_O:strcpy (dyn_sts,"SELECT SUBSTR(NAME,1,255) NAME, \n");strcat (dyn_sts,"DECODE(READTIM,0,PHYBLKRD, READTIM)

READS, ");strcat (dyn_sts,"DECODE(WRITETIM,0,PHYBLKWRT, WRITETIM)

WRITES, ");strcat

(dyn_sts,"DECODE(READTIM+WRITETIM,0,PHYBLKRD+PHYBLKWRT, ");strcat (dyn_sts,"READTIM+WRITETIM) \n");strcat (dyn_sts,"FROM SYS.V_$DATAFILE DF,

SYS.V_$FILESTAT FS ");strcat (dyn_sts,"WHERE DF.FILE# = FS.FILE# \n");strcat (dyn_sts,"ORDER BY 4 \n");break;

case CASE_RECURSIVE_CALLS:strcpy (dyn_sts,"SELECT NAME, VALUE \n");strcat (dyn_sts,"FROM SYS.V_$SYSSTAT \n");strcat (dyn_sts,"WHERE NAME IN ('execute count',

'recursive calls') \n");strcat (dyn_sts,"ORDER BY 1 \n");

Página 20

func_dyn_statement_set.cbreak;

case CASE_SYSTEM_EVENTS:strcpy (dyn_sts,"SELECT EVENT, TOTAL_WAITS,

TOTAL_TIMEOUTS, \n");strcat (dyn_sts,"TIME_WAITED, AVERAGE_WAIT \n");strcat (dyn_sts,"FROM SYS.V_$SYSTEM_EVENT \n");strcat (dyn_sts,"ORDER BY TOTAL_WAITS, TIME_WAITED \n");break;

/* -------------------------------------------------------------- *//*

#define CASE_SQL_AREA_ALL_ENTRIES 52*/

case CASE_SQL_AREA_ALL_ENTRIES:strcpy (dyn_sts,"SELECT TO_NUMBER(DECODE( A.EXECUTIONS,

NULL,");strcat (dyn_sts,"NULL, 0, NULL,

A.BUFFER_GETS/A.EXECUTIONS)) AVG_GETS,");strcat (dyn_sts,"A.SQL_TEXT, A.SHARABLE_MEM,

A.PERSISTENT_MEM,");strcat (dyn_sts,"A.RUNTIME_MEM, A.SORTS,

A.VERSION_COUNT, A.LOADED_VERSIONS,");strcat (dyn_sts,"A.OPEN_VERSIONS, A.USERS_OPENING,

A.EXECUTIONS, ");strcat (dyn_sts,"A.USERS_EXECUTING, A.LOADS,

A.FIRST_LOAD_TIME, ");strcat (dyn_sts,"A.INVALIDATIONS, A.PARSE_CALLS,

A.DISK_READS, ");strcat (dyn_sts,"A.BUFFER_GETS, rawtohex(A.ADDRESS)

SQL_ADDRESS, ");strcat (dyn_sts,"A.HASH_VALUE SQL_HASH_VALUE,

A.ROWS_PROCESSED, ");strcat (dyn_sts,"A.COMMAND_TYPE, A.OPTIMIZER_MODE,

PU.USERNAME PARSING_USER,");strcat (dyn_sts,"PS.USERNAME PARSING_SCHEMA,

A.KEPT_VERSIONS, A.MODULE,");strcat (dyn_sts,"A.ACTION, A.SERIALIZABLE_ABORTS \n");strcat (dyn_sts,"FROM sys.V_$SQLAREA A, SYS.ALL_USERS

PU, SYS.ALL_USERS PS \n");strcat (dyn_sts,"WHERE PU.USER_ID = A.PARSING_USER_ID

AND ");strcat (dyn_sts,"PS.USER_ID = A.PARSING_SCHEMA_ID \n");strcat (dyn_sts,"ORDER BY

sharable_mem+persistent_mem+runtime_mem desc \n");break;/*

#define CASE_SQL_AREA_CPU_USAGE 53*/

case CASE_SQL_AREA_CPU_USAGE:strcpy (dyn_sts,"SELECT TO_NUMBER(DECODE( A.EXECUTIONS,

NULL, NULL,");strcat (dyn_sts,"0, NULL, A.BUFFER_GETS/A.EXECUTIONS))

AVG_GETS, ");strcat (dyn_sts,"A.SQL_TEXT, A.SHARABLE_MEM,

A.PERSISTENT_MEM, ");strcat (dyn_sts,"A.RUNTIME_MEM, A.SORTS,

A.VERSION_COUNT, ");strcat (dyn_sts,"A.LOADED_VERSIONS, A.OPEN_VERSIONS,

A.USERS_OPENING,");strcat (dyn_sts,"A.EXECUTIONS, A.USERS_EXECUTING,

A.LOADS, ");strcat (dyn_sts,"A.FIRST_LOAD_TIME, A.INVALIDATIONS,

A.PARSE_CALLS,");strcat (dyn_sts,"A.DISK_READS, A.BUFFER_GETS,

rawtohex(A.ADDRESS) SQL_ADDRESS,");strcat (dyn_sts,"A.HASH_VALUE SQL_HASH_VALUE,


Página 21

func_dyn_statement_set.cPU.USERNAME PARSING_USER,");

strcat (dyn_sts,"PS.USERNAME PARSING_SCHEMA, A.KEPT_VERSIONS, ");

strcat (dyn_sts,"A.MODULE, A.ACTION, A.SERIALIZABLE_ABORTS \n");

strcat (dyn_sts,"FROM sys.V_$SQLAREA A, SYS.ALL_USERS PU, ");

strcat (dyn_sts,"SYS.ALL_USERS PS, v$session s \n");strcat (dyn_sts,"WHERE PU.USER_ID = A.PARSING_USER_ID

AND ");strcat (dyn_sts,"PS.USER_ID = A.PARSING_SCHEMA_ID and

");strcat (dyn_sts,"(s. sid in (SELECT sid FROM V$SESSTAT

");strcat (dyn_sts,"WHERE STATISTIC# = 12 and value > 0)

and ");strcat (dyn_sts,"a.executions > 0 and s.sql_address =

a.address) \n");strcat (dyn_sts,"ORDER BY

sharable_mem+persistent_mem+runtime_mem desc \n");break;/*

#define CASE_SQL_AREA_MEMORY_USAGE 54*/

case CASE_SQL_AREA_MEMORY_USAGE:strcpy (dyn_sts,"SELECT MAX(TO_NUMBER(DECODE(

A.EXECUTIONS, NULL,");strcat (dyn_sts,"NULL, 0, NULL,

A.BUFFER_GETS/A.EXECUTIONS))) AVG_GETS,");strcat (dyn_sts,"MAX(A.SHARABLE_MEM) SHARABLE_MEM, ");strcat (dyn_sts,"MAX(A.PERSISTENT_MEM) PERSISTENT_MEM,

");strcat (dyn_sts,"MAX(A.RUNTIME_MEM) RUNTIME_MEM,

MAX(A.SORTS) SORTS, ");strcat (dyn_sts,"MAX(A.VERSION_COUNT) VERSION_COUNT, ");strcat (dyn_sts,"MAX(A.LOADED_VERSIONS) LOADED_VERSIONS,

");strcat (dyn_sts,"MAX(A.OPEN_VERSIONS) OPEN_VERSIONS, ");strcat (dyn_sts,"MAX(A.USERS_OPENING) USERS_OPENING, ");strcat (dyn_sts,"MAX(A.EXECUTIONS) EXECUTIONS, ");strcat (dyn_sts,"MAX(A.USERS_EXECUTING) USERS_EXECUTING,

MAX(A.LOADS) LOADS,");strcat (dyn_sts,"MAX(A.INVALIDATIONS)

INVALIDATIONS,MAX(A.PARSE_CALLS) PARSE_CALLS, ");strcat (dyn_sts,"MAX(A.DISK_READS)

DISK_READS,MAX(A.BUFFER_GETS) BUFFER_GETS, ");strcat (dyn_sts,"MAX(A.ROWS_PROCESSED) ROWS_PROCESSED,

MAX(A.KEPT_VERSIONS) KEPT_VERSIONS, ");strcat (dyn_sts,"MAX(A.SERIALIZABLE_ABORTS)

SERIALIZABLE_ABORTS \n");strcat (dyn_sts,"FROM sys.V_$SQLAREA A \n");break;/*

#define CASE_SQL_AREA_BUFFER_GET_SUM 55*/

case CASE_SQL_AREA_BUFFER_GET_SUM:strcpy (dyn_sts,"SELECT TO_NUMBER(DECODE( A.EXECUTIONS,

NULL, NULL, 0, ");strcat (dyn_sts,"NULL, A.BUFFER_GETS/A.EXECUTIONS))

AVG_GETS, A.SQL_TEXT, ");strcat (dyn_sts,"A.SHARABLE_MEM, A.PERSISTENT_MEM,

A.RUNTIME_MEM, A.SORTS, ");strcat (dyn_sts,"A.VERSION_COUNT, A.LOADED_VERSIONS,

A.OPEN_VERSIONS, ");strcat (dyn_sts,"A.USERS_OPENING, A.EXECUTIONS,

A.USERS_EXECUTING, ");strcat (dyn_sts,"A.LOADS, A.FIRST_LOAD_TIME,

A.INVALIDATIONS, A.PARSE_CALLS,");

Página 22

func_dyn_statement_set.cstrcat (dyn_sts,"A.DISK_READS, A.BUFFER_GETS,

rawtohex(A.ADDRESS) SQL_ADDRESS, ");strcat (dyn_sts,"A.HASH_VALUE SQL_HASH_VALUE,


PU.USERNAME PARSING_USER,");strcat (dyn_sts,"PS.USERNAME PARSING_SCHEMA,

A.KEPT_VERSIONS, A.MODULE, ");strcat (dyn_sts,"A.ACTION, A.SERIALIZABLE_ABORTS \n");strcat (dyn_sts,"FROM sys.V_$SQLAREA A, SYS.ALL_USERS

PU, SYS.ALL_USERS PS ");strcat (dyn_sts,"WHERE PU.USER_ID = A.PARSING_USER_ID

AND ");strcat (dyn_sts,"PS.USER_ID = A.PARSING_SCHEMA_ID and

");strcat (dyn_sts,"buffer_gets > 1282729/10 \n");strcat (dyn_sts,"ORDER BY buffer_gets desc \n");break;/*

#define CASE_INIT_PARAMETERS_VALUES_STATUS 56*/

case CASE_INIT_PARAMETERS_VALUES_STATUS:strcpy (dyn_sts,"SELECT NUM, NAME, VALUE, ISDEFAULT,

ISMODIFIED, ");strcat (dyn_sts,"ISADJUSTED, DECODE( TYPE, 1, 'Boolean',

2, 'string',");strcat (dyn_sts,"3, 'integer', 4, 'file', 6, 'big

integer', ");strcat (dyn_sts,"TO_CHAR(TYPE)) TYPE,

DECODE(ISSES_MODIFIABLE, ");strcat (dyn_sts,"'TRUE', 'yes', NULL) ISSES_MODIFIABLE,

");strcat (dyn_sts,"DECODE(ISSYS_MODIFIABLE, 'IMMEDIATE',

'immediate', ");strcat (dyn_sts,"'DEFERRED', 'deferred', NULL)

ISSYS_MODIFIABLE, ");strcat (dyn_sts,"DESCRIPTION \n");strcat (dyn_sts,"FROM sys.V_$PARAMETER \n");strcat (dyn_sts,"ORDER BY NUM \n");break;

/* -------------------------------------------------------------- */

case CASE_TABLESPACE_FRAGMENTATION:strcpy (dyn_sts,"SELECT TABLESPACE_NAME, BYTES/1024

KBYTES, ");strcat (dyn_sts,"COUNT( *) NUM_EXTENTS, SUM(BYTES) /

1024 SUM_KBYTES, ");strcat (dyn_sts,"'Used Extents' USAGE, ");

/* strcat (dyn_sts,"DECODE( BYTES, :INITIAL_EXTENT,'INITIAL_SIZE','CHANGED_SIZE'), "); */

strcat (dyn_sts,"TO_CHAR(BYTES,'99999999999'), ");strcat (dyn_sts,"BYTES ");

/* strcat (dyn_sts,"FILE_ID, EXTENT_ID "); */strcat (dyn_sts,"FROM SYS.DBA_EXTENTS \n");if ( strlen (opcion_uno) > 0 )

{strcat (dyn_sts,"WHERE TABLESPACE_NAME = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' \n");}

strcat (dyn_sts,"GROUP BY TABLESPACE_NAME, BYTES/1024, ");/* strcat (dyn_sts,"DECODE( BYTES, :INITIAL_EXTENT,'INITIAL_SIZE','CHANGED_SIZE'), "); */

strcat (dyn_sts,"BYTES,");strcat (dyn_sts,"BYTES ");

/* strcat (dyn_sts,"FILE_ID, EXTENT_ID "); */

Página 23

func_dyn_statement_set.cstrcat (dyn_sts,"\n");strcat (dyn_sts,"UNION ");strcat (dyn_sts,"SELECT TABLESPACE_NAME, BYTES/1024

KBYTES, ");strcat (dyn_sts,"COUNT (*) NUM_EXTENTS, SUM(BYTES)/1024

SUM_KBYTES, ");strcat (dyn_sts,"'Free Chunks' USAGE, ");strcat (dyn_sts,"'0'CERO, ");strcat (dyn_sts,"to_number(null) bytes ");

/* strcat (dyn_sts,"to_number(null),to_number(null) \n");*/

strcat (dyn_sts,"FROM SYS.DBA_FREE_SPACE ");if ( strlen (opcion_uno) > 0 )


strcat (dyn_sts,"GROUP BY TABLESPACE_NAME, BYTES/1024 ");

strcat (dyn_sts,"ORDER BY 1,2,3 \n");break;

case CASE_SHOW_NLS_PARAMETERS:strcpy (dyn_sts,"select p.name, d.VALUE value_database,

");strcat (dyn_sts,"i.VALUE value_instance,s.VALUE

value_session, ");strcat (dyn_sts,"p.comment$ comments \n");strcat (dyn_sts,"from sys.props$ p,

nls_session_parameters s, ");strcat (dyn_sts,"nls_database_parameters d,

nls_instance_parameters i ");strcat (dyn_sts,"where p.name = s.PARAMETER (+) and ");strcat (dyn_sts,"p.name = d.PARAMETER (+) and p.name =

i.PARAMETER (+) \n");break;

case CASE_CONTROL_FILES_STATUS:strcpy (dyn_sts,"SELECT NAME, NVL( STATUS, 'OK') STATUS

\n");strcat (dyn_sts,"FROM sys.V_$CONTROLFILE \n");break;

case CASE_SORT_SEGMENTS_USERS:strcpy (dyn_sts,"SELECT TABLESPACE_NAME, SEGMENT_FILE,

SEGMENT_BLOCK, ");strcat (dyn_sts,"EXTENT_SIZE, CURRENT_USERS,

TOTAL_EXTENTS, ");strcat (dyn_sts,"TOTAL_BLOCKS, USED_EXTENTS,

USED_BLOCKS, FREE_EXTENTS,");strcat (dyn_sts,"FREE_BLOCKS, ADDED_EXTENTS,

EXTENT_HITS, FREED_EXTENTS,");strcat (dyn_sts,"FREE_REQUESTS, MAX_SIZE, MAX_BLOCKS,

MAX_USED_SIZE, ");strcat (dyn_sts,"MAX_USED_BLOCKS, MAX_SORT_SIZE,

MAX_SORT_BLOCKS, ");strcat (dyn_sts,"'TO_NUMBER(NULL) RELATIVE_FNO' \n");strcat (dyn_sts,"FROM SYS.V_$SORT_SEGMENT \n");if ( strlen (opcion_uno) > 0 )


strcat (dyn_sts,"ORDER BY TABLESPACE_NAME,SEGMENT_FILE \n");

break;case CASE_ORACLE_QUOTAS:

strcpy (dyn_sts,"SELECT Q.TABLESPACE_NAME, Q.USERNAME, Q.BYTES/1024 KBYTES, ");

Página 24

func_dyn_statement_set.cstrcat (dyn_sts,"DECODE( Q.MAX_BYTES, -1, -1,

Q.MAX_BYTES/1024) MAX_KBYTES, ");strcat (dyn_sts,"Q.BLOCKS, DECODE( Q.MAX_BLOCKS, -1, -1,

Q.MAX_BLOCKS) MAX_BLOCKS, ");strcat (dyn_sts,"TO_NUMBER(DECODE( Q.MAX_BYTES, -1,

NULL, 100*Q.BYTES/Q.MAX_BYTES)) USAGE_PERCENT ");strcat (dyn_sts,"FROM SYS.DBA_TS_QUOTAS Q \n");if ( strlen (opcion_uno) > 0 )


strcat (dyn_sts,"ORDER BY TABLESPACE_NAME \n");break;

case CASE_TABLE_GENERAL_DESCRIPTION:strcpy (dyn_sts,"SELECT SEL.*, COMMENTS ");strcat (dyn_sts,"FROM ( ");strcat (dyn_sts,"SELECT O.OWNER, O.OBJECT_NAME

TABLE_NAME, O.OBJECT_TYPE, ");strcat (dyn_sts,"O.OBJECT_TYPE R_OBJECT_TYPE, DECODE(

O.OBJECT_TYPE, 'TABLE', 0, 'VIEW', 1, 5) IMAGE_INDEX, ");strcat (dyn_sts,"O.OBJECT_NAME NAME, O.OWNER

SYNONYM_OWNER, O.CREATED, O.LAST_DDL_TIME, O.STATUS, ");strcat (dyn_sts,"T.TABLESPACE_NAME, T.PCT_FREE,

T.PCT_USED, T.PCT_INCREASE, T.NEXT_EXTENT / 1024 NEXT_EXTENT, ");strcat (dyn_sts,"T.INI_TRANS, T.MAX_TRANS,

T.INITIAL_EXTENT / 1024 INITIAL_EXTENT, T.MIN_EXTENTS, ");strcat (dyn_sts,"T.MAX_EXTENTS, T.FREELISTS,

T.FREELIST_GROUPS, T.BACKED_UP, T.NUM_ROWS, T.BLOCKS, ");strcat (dyn_sts,"T.EMPTY_BLOCKS, T.AVG_SPACE,

T.CHAIN_CNT, T.AVG_ROW_LEN, T.DEGREE, T.INSTANCES, ");strcat (dyn_sts,"LTRIM(T.CACHE) CACHE, TO_DATE(NULL)

LAST_ANALYZED, 'YES' LOGGING, 'NO' PARTITIONED, ");strcat (dyn_sts,"'DEFAULT' BUFFER_POOL, ' ' IOT_NAME, '

' IOT_TYPE, ' ' TABLE_LOCK, ");strcat (dyn_sts,"' ' NESTED, TO_NUMBER(0)

AVG_SPACE_FREELIST_BLOCKS, TO_NUMBER(NULL) NUM_FREELIST_BLOCKS, ");strcat (dyn_sts,"TO_NUMBER(NULL) SAMPLE_SIZE, null

table_type_owner, null table_type, ' ' SECONDARY, ");strcat (dyn_sts,"' ' ROW_MOVEMENT, ' ' GLOBAL_STATS, ' '

USER_STATS, ' ' DURATION, ' ' SKIP_CORRUPT, ");strcat (dyn_sts,"' ' MONITORING, 'N' TEMPORARY \n");strcat (dyn_sts,"FROM SYS.ALL_OBJECTS O, ALL_TABLES T

\n");strcat (dyn_sts,"WHERE \n");if ( strlen (opcion_uno) > 0 )

{strcat (dyn_sts,"O.OWNER = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND T.OWNER = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND \n");

}strcat (dyn_sts,"T.TABLE_NAME = O.OBJECT_NAME AND

O.OBJECT_TYPE = 'TABLE' \n");strcat (dyn_sts,") SEL, SYS.ALL_TAB_COMMENTS C \n");strcat (dyn_sts,"WHERE C.OWNER = SEL.OWNER AND

C.TABLE_NAME = SEL.TABLE_NAME AND \n");strcat (dyn_sts,"SEL.OBJECT_TYPE = 'TABLE' \n");strcat (dyn_sts,"ORDER BY

NLSSORT(SEL.NAME,'NLS_SORT=BINARY') \n");break;

case CASE_TABLE_COLUMN_DESCRIPTION:strcpy (dyn_sts,"select c.owner,c.table_name,column_name

\n");strcat (dyn_sts,"from sys.all_cons_columns cc,

Página 25

func_dyn_statement_set.csys.all_constraints c ");

strcat (dyn_sts,"where cc.owner = c.owner \n");if ( strlen (opcion_uno) > 0 )

{strcat (dyn_sts,"and c.owner = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' and cc.owner = '");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' \n");

}strcat (dyn_sts,"and cc.constraint_name =

c.constraint_name and ");if ( strlen (opcion_dos) > 0 ){strcat (dyn_sts,"c.table_name = '");strcat (dyn_sts,opcion_dos);

strcat (dyn_sts,"' AND \n");

}strcat (dyn_sts,"c.constraint_type = 'P' \n");strcat (dyn_sts,"order by

c.owner,c.table_name,cc.position \n");break;

case CASE_TABLE_CONSTRAINTS:strcpy (dyn_sts,"SELECT DISTINCT C1.POSITION,

SUBSTR(C1.COLUMN_NAME,1,30) COLUMN_NAME, ");strcat (dyn_sts,"C2.TABLE_NAME,

SUBSTR(C2.COLUMN_NAME,1,30) R_COLUMN_NAME, ");strcat (dyn_sts,"DATA_TYPE ||

DECODE(DATA_TYPE,'NUMBER',DECODE( DATA_PRECISION, NULL, ");strcat (dyn_sts,"NULL, ' (' ||DATA_PRECISION || DECODE(

DATA_SCALE, NULL, NULL, ',' || DATA_SCALE) || ')'), ");strcat (dyn_sts,"'VARCHAR2', ' (' || DATA_LENGTH ||

')', 'CHAR', ' (' || DATA_LENGTH || ')', NULL) SQL_TYPE, ");strcat (dyn_sts,"DECODE( C.NULLABLE, 'N', 'NOT NULL',

NULL) NULLABLE, ");strcat (dyn_sts,"DECODE( DATA_TYPE, 'VARCHAR2', 0,

'CHAR', 0, 'NUMBER', 1, 'DATE', 2, ");strcat (dyn_sts,"'LONG', 3, 'RAW', 4, 'LONG RAW', 5,

'MLSLABEL', 6, -1) IMAGE_INDEX \n");strcat (dyn_sts,"FROM SYS.ALL_TAB_COLUMNS C,

SYS.ALL_CONS_COLUMNS C1, SYS.ALL_CONS_COLUMNS C2 \n");strcat (dyn_sts,"WHERE C1.OWNER = :OWNER AND

C1.CONSTRAINT_NAME = :CONSTRAINT_NAME AND \n");strcat (dyn_sts,"C1.TABLE_NAME = :TABLE_NAME AND C.OWNER

= :OWNER AND ");strcat (dyn_sts,"C.TABLE_NAME = :TABLE_NAME AND

C.OWNER = C1.OWNER AND C.TABLE_NAME = C1.TABLE_NAME ");strcat (dyn_sts,"AND C.COLUMN_NAME = C1.COLUMN_NAME AND

C2.OWNER = :R_OWNER AND C2.CONSTRAINT_NAME = :R_CONSTRAINT_NAME ");strcat (dyn_sts,"AND C2.TABLE_NAME = :R_TABLE_NAME AND

C1.POSITION= C2.POSITION \n");strcat (dyn_sts,"UNION \n");strcat (dyn_sts,"SELECT DISTINCT C1.POSITION,

SUBSTR(C1.COLUMN_NAME,1,30) COLUMN_NAME, NULL TABLE_NAME, ");strcat (dyn_sts,"NULL R_COLUMN_NAME, DATA_TYPE ||

DECODE( DATA_TYPE, 'NUMBER', ");strcat (dyn_sts,"DECODE( DATA_PRECISION, NULL, NULL, '

(' || DATA_PRECISION || ");strcat (dyn_sts,"DECODE( DATA_SCALE, NULL, NULL, ',' ||

DATA_SCALE) || ')'), 'VARCHAR2', ' (' || DATA_LENGTH || ')', ");strcat (dyn_sts,"'CHAR', ' (' || DATA_LENGTH || ')',

NULL) SQL_TYPE, DECODE( C.NULLABLE, 'N', 'NOT NULL', NULL) NULLABLE, ");strcat (dyn_sts,"DECODE( DATA_TYPE, 'VARCHAR2', 0,

'CHAR', 0, 'NUMBER', 1, 'DATE', 2, 'LONG', ");strcat (dyn_sts,"3, 'RAW', 4, 'LONG RAW', 5, 'MLSLABEL',

Página 26

func_dyn_statement_set.c6, -1) IMAGE_INDEX \n");

strcat (dyn_sts,"FROM (select * from SYS.ALL_TAB_COLUMNS\n");

strcat (dyn_sts,"where owner = :owner and table_name = :table_name) C, \n");

strcat (dyn_sts,"SYS.ALL_CONS_COLUMNS C1 \n");strcat (dyn_sts,"WHERE C1.OWNER = :OWNER AND

C1.CONSTRAINT_NAME = :CONSTRAINT_NAME AND \n");strcat (dyn_sts,"C1.TABLE_NAME = :TABLE_NAME AND C.OWNER

(+) = C1.OWNER AND \n");strcat (dyn_sts,"C.TABLE_NAME (+) = C1.TABLE_NAME AND

C.COLUMN_NAME (+) = C1.COLUMN_NAME AND \n");strcat (dyn_sts,":R_CONSTRAINT_NAME IS NULL \n");strcat (dyn_sts,"AND :R_TABLE_NAME IS NULL \n");break;

case CASE_INDEX_GENERAL_DESCRIPTION:strcpy (dyn_sts,"SELECT I.INDEX_OWNER OWNER,

I.INDEX_NAME, I.COLUMN_POSITION, ");strcat (dyn_sts,"SUBSTR(I.COLUMN_NAME,1,255)

COLUMN_NAME,DATA_TYPE || ");strcat (dyn_sts,"DECODE( DATA_TYPE,'NUMBER', DECODE(

DATA_PRECISION, NULL, NULL,");strcat (dyn_sts,"' (' || DATA_PRECISION || DECODE(

DATA_SCALE , NULL, NULL, ',' || ");strcat (dyn_sts,"DATA_SCALE) || ')'),'VARCHAR2', ' ('

|| DATA_LENGTH || ')', 'CHAR',");strcat (dyn_sts,"' (' || DATA_LENGTH || ')', NULL)

SQL_TYPE, DECODE( C.NULLABLE, 'N',");strcat (dyn_sts,"'NOT NULL', 'NULL ') NULLABLE,

'ASC' DESCEND,DECODE( C.DATA_TYPE, 'VARCHAR2',");strcat (dyn_sts,"0 , 'CHAR', 0, 'NUMBER', 1, 'DATE', 2,

'LONG', 3, 'RAW', 4, 'LONG RAW', 5,");strcat (dyn_sts,"'MLSLABEL', 6, -1) IMAGE_INDEX \n");strcat (dyn_sts,"FROM (select * from SYS.ALL_TAB_COLUMNS

\n");if ( (strlen (opcion_uno) > 0) && (strlen (opcion_dos)

== 0) ){strcat (dyn_sts,"where owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");}

else if ( (strlen(opcion_uno) == 0) && ( strlen (opcion_dos) > 0 ))

{strcat (dyn_sts,"where table_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

else if ( (strlen (opcion_uno) > 0) && ( strlen (opcion_dos) > 0 ))

{strcat (dyn_sts,"where owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");strcat (dyn_sts,"and table_name = '");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

strcat (dyn_sts," ) C, \n");strcat (dyn_sts,"SYS.ALL_IND_COLUMNS I \n");strcat (dyn_sts,"WHERE \n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"I.INDEX_OWNER ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND ");}

Página 27

func_dyn_statement_set.cif ( (strlen (opcion_tres) > 0) )

{strcat (dyn_sts,"I.INDEX_NAME ='");strcat (dyn_sts,opcion_tres);strcat (dyn_sts,"' AND ");}

strcat (dyn_sts,"C.OWNER (+) = I.INDEX_OWNER AND C.TABLE_NAME (+) = I.TABLE_NAME ");

strcat (dyn_sts,"AND C.COLUMN_NAME (+) = I.COLUMN_NAME \n");

strcat (dyn_sts,"ORDER BY I.INDEX_OWNER,I.INDEX_NAME,I.COLUMN_POSITION \n");

break;case CASE_AUDIT_DEFINITION:

strcpy (dyn_sts,"SELECT OBJECT_NAME, OBJECT_TYPE, AUDIT_OPTION, ");

strcat (dyn_sts,"decode ( substr(SUCCESS,1,1), '-', null, 'S',");

strcat (dyn_sts,"'BY SESSION', 'A', 'BY ACCESS', substr(SUCCESS,1,1)) ");

strcat (dyn_sts,"WHENEVER_SUCCESSFUL, decode( substr (SUCCESS,3,1),");

strcat (dyn_sts,"'-', null, 'S', 'BY SESSION', 'A', 'BY ACCESS', ");

strcat (dyn_sts,"substr(SUCCESS,3,1)) WHENEVER_UNSUCCESSFUL \n");

strcat (dyn_sts,"FROM \n");strcat (dyn_sts,"(SELECT OBJECT_NAME, OBJECT_TYPE, ");strcat (dyn_sts,"'ALTER' AUDIT_OPTION,ALT SUCCESS ");strcat (dyn_sts,"FROM sys.DBA_OBJ_AUDIT_OPTS \n");

/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts,"where owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");

}if ( (strlen (opcion_dos) > 0) ){

strcat (dyn_sts," and object_name ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' ");

}if ( (strlen (opcion_tres) > 0) ){

strcat (dyn_sts," and object_type='");strcat (dyn_sts,opcion_tres);strcat (dyn_sts,"' \n");

}/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- *//* strcat (dyn_sts,"WHERE OWNER = :OWNER AND \n");

strcat (dyn_sts,"OBJECT_NAME = :TABLE_NAME AND \n");strcat (dyn_sts,"OBJECT_TYPE = :OBJECT_TYPE \n");

*/strcat (dyn_sts,"UNION \n");strcat (dyn_sts,"SELECT OBJECT_NAME, OBJECT_TYPE,

'AUDIT', AUD ");strcat (dyn_sts,"FROM sys.DBA_OBJ_AUDIT_OPTS \n");




strcat (dyn_sts," and object_name ='");

Página 28

func_dyn_statement_set.cstrcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' ");






'COMMENT', COM ");strcat (dyn_sts,"FROM sys.DBA_OBJ_AUDIT_OPTS \n");










'DELETE', DEL ");strcat (dyn_sts,"FROM sys.DBA_OBJ_AUDIT_OPTS \n");








strcat (dyn_sts,"OBJECT_NAME = :TABLE_NAME AND \n");

Página 29

func_dyn_statement_set.cstrcat (dyn_sts,"OBJECT_TYPE = :OBJECT_TYPE \n");

*/strcat (dyn_sts," UNION \n");strcat (dyn_sts,"SELECT OBJECT_NAME, OBJECT_TYPE,

'GRANT', GRA ");strcat (dyn_sts,"FROM sys.DBA_OBJ_AUDIT_OPTS \n");








strcat (dyn_sts," OBJECT_NAME = :TABLE_NAME AND \n");strcat (dyn_sts,"OBJECT_TYPE = :OBJECT_TYPE \n");


'INDEX', IND FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */

if ( (strlen (opcion_uno) > 0) ){






}/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- *//* strcat (dyn_sts," WHERE OWNER = :OWNER AND \n");



'INSERT', INS FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */



}if ( (strlen (opcion_dos) > 0) )

Página 30

func_dyn_statement_set.c{







'LOCK', LOC FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */










'RENAME', REN FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */







}/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- *//* strcat (dyn_sts," WHERE OWNER =:OWNER AND \n");

strcat (dyn_sts,"OBJECT_NAME = :TABLE_NAME AND \n");

Página 31

func_dyn_statement_set.cstrcat (dyn_sts,"OBJECT_TYPE = :OBJECT_TYPE \n");


'SELECT', SEL FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */










'UPDATE', UPD FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */










'REFERENCES', REF FROM sys.DBA_OBJ_AUDIT_OPTS ");/* -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- */




Página 32

func_dyn_statement_set.cstrcat (dyn_sts," and object_name ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' ");





*/strcat (dyn_sts,") \n");break;

case CASE_SHOW_SEGMENTS_EXTENTS:strcpy (dyn_sts,"SELECT S.OWNER, S.SEGMENT_NAME,

S.SEGMENT_TYPE, S.TABLESPACE_NAME, ");strcat (dyn_sts,"S.BYTES/1024 KBYTES, S.BLOCKS,

S.EXTENTS, S.NEXT_EXTENT/1024 NEXT_EXTENT , ");strcat (dyn_sts,"S.PCT_INCREASE, S.MAX_EXTENTS,

S.MAX_EXTENTS - S.EXTENTS FREE_EXTENTS, ");strcat (dyn_sts,"DECODE( SEGMENT_TYPE, 'CACHE', 14,

'CLUSTER', 15, 'INDEX', 17, ");strcat (dyn_sts,"'ROLLBACK', 13, 'TABLE' , 0, 'TABLE

PARTITION', 38, 'INDEX PARTITION', 39, -1) IMAGE_INDEX \n");strcat (dyn_sts,"FROM SYS.DBA_SEGMENTS S \n");if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts,"where TABLESPACE_NAME ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND ");


strcat (dyn_sts," OWNER ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' AND ");


strcat (dyn_sts," SEGMENT_TYPE='");strcat (dyn_sts,opcion_tres);strcat (dyn_sts,"' \n");

}strcat (dyn_sts,"ORDER BY S.OWNER, FREE_EXTENTS \n");break;

case CASE_SHOW_EXTENTS_INSIDE_DATAFILES:strcpy (dyn_sts,"SELECT TO_CHAR(X.EXTENT_ID) EXTENT_ID,

X.OWNER, ");strcat (dyn_sts,"X.SEGMENT_NAME, X.SEGMENT_TYPE,

X.TABLESPACE_NAME, ");strcat (dyn_sts,"X.FILE_ID, X.BLOCK_ID, X.BYTES/1024

KBYTES, X.BLOCKS, ");strcat (dyn_sts,"F.FILE_NAME \n");strcat (dyn_sts,"FROM SYS.DBA_EXTENTS X,

SYS.DBA_DATA_FILES F \n");strcat (dyn_sts,"WHERE \n");strcat (dyn_sts,"F.TABLESPACE_NAME = X.TABLESPACE_NAME

AND \n");strcat (dyn_sts,"F.FILE_ID = X.FILE_ID \n");if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts,"AND TABLESPACE_NAME ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");

Página 33

func_dyn_statement_set.c}if ( (strlen (opcion_dos) > 0) ){

strcat (dyn_sts," AND OWNER ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' ");


strcat (dyn_sts," AND SEGMENT_NAME='");strcat (dyn_sts,opcion_tres);strcat (dyn_sts,"' \n");

}strcat (dyn_sts,"ORDER BY 1 \n");break;

case CASE_SHOW_USER_LISTS:strcpy (dyn_sts,"SELECT u.USERNAME, u.USER_ID,

u.DEFAULT_TABLESPACE, \n");strcat (dyn_sts,"u.password, u.TEMPORARY_TABLESPACE,

u.CREATED, u.PROFILE, ");strcat (dyn_sts,"'N/A' ACCOUNT_STATUS, to_date(null)

LOCK_DATE, ");strcat (dyn_sts,"to_date(null) EXPIRY_DATE, null

INITIAL_RSRC_CONSUMER_GROUP, ");strcat (dyn_sts,"p.SYSDBA, p.SYSOPER \n");strcat (dyn_sts,"FROM SYS.DBA_USERS u,

SYS.V_$PWFILE_USERS p \n");strcat (dyn_sts,"WHERE u.USERNAME = p.USERNAME (+) \n");strcat (dyn_sts,"UNION \n");strcat (dyn_sts,"SELECT 'PUBLIC' USERNAME,

TO_NUMBER(NULL) USER_ID, ");strcat (dyn_sts,"NULL DEFAULT_TABLESPACE, null password,

NULL TEMPORARY_TABLESPACE, ");strcat (dyn_sts,"TO_DATE(NULL) CREATED, NULL PROFILE,

'LOCKED' ACCOUNT_STATUS, ");strcat (dyn_sts,"TO_DATE(NULL) LOCK_DATE, TO_DATE(NULL)

EXPIRY_DATE, ");strcat (dyn_sts,"null INITIAL_RSRC_CONSUMER_GROUP,

'FALSE' SYSDBA, 'FALSE' SYSOPER ");strcat (dyn_sts,"FROM DUAL \n");strcat (dyn_sts,"ORDER BY 1 \n");break;

case CASE_SHOW_ROLES_PRIVILEGES:strcpy (dyn_sts,"SELECT distinct PRIVILEGE, OWNER,

TABLE_NAME, GRANTOR, \n");strcat (dyn_sts,"GRANTEE,GRANTABLE, 'NO' COL_PRIVS ");strcat (dyn_sts,"FROM SYS.DBA_TAB_PRIVS \n");strcat (dyn_sts,"WHERE \n");strcat (dyn_sts," OWNER = :OWNER \n");strcat (dyn_sts," AND TABLE_NAME = :TABLE_NAME \n");strcat (dyn_sts," AND GRANTEE = :GRANTEE \n");strcat (dyn_sts,"UNION ");strcat (dyn_sts, "SELECT DISTINCT PRIVILEGE, OWNER,

TABLE_NAME, GRANTOR, \n");strcat (dyn_sts,"GRANTEE,NULL GRANTABLE, 'YES'

COL_PRIVS \n");strcat (dyn_sts,"FROM SYS.DBA_COL_PRIVS \n");strcat (dyn_sts,"WHERE \n");strcat (dyn_sts," OWNER = :OWNER \n");strcat (dyn_sts," AND TABLE_NAME = :TABLE_NAME \n");strcat (dyn_sts," AND GRANTEE = :GRANTEE \n");strcat (dyn_sts," ORDER BY 1 \n");break;

case CASE_SHOW_PRIVILEGES_COLUMNS:strcpy (dyn_sts,"SELECT P.COLUMN_NAME, P.GRANTOR,

P.GRANTEE, P.PRIVILEGE, ");strcat (dyn_sts,"P.GRANTABLE, DATA_TYPE || DECODE(

DATA_TYPE,'NUMBER', ");

Página 34

func_dyn_statement_set.cstrcat (dyn_sts,"DECODE( DATA_PRECISION, NULL, NULL, '

(' || DATA_PRECISION || ");strcat (dyn_sts,"DECODE( DATA_SCALE, NULL, NULL, ',' ||

DATA_SCALE) || ')'), ");strcat (dyn_sts,"'VARCHAR2', ' (' || DATA_LENGTH ||

')', 'CHAR', ");strcat (dyn_sts," ' (' || DATA_LENGTH || ')', NULL)

SQL_TYPE, ");strcat (dyn_sts,"DECODE( C.NULLABLE, 'N', 'NOT NULL',

NULL) NULLABLE, ");strcat (dyn_sts,"DECODE( C.DATA_TYPE, ' VARCHAR2', 0,

'CHAR', 0, 'NUMBER',");strcat (dyn_sts," 1, 'DATE', 2, 'LONG', 3, 'RAW', 4,

'LONG RAW',");strcat (dyn_sts," 5, 'MLSLABEL', 6, -1) IMAGE_INDEX

\n");strcat (dyn_sts,"FROM SYS.ALL_COL_PRIVS P,

SYS.ALL_TAB_COLUMNS C \n");strcat (dyn_sts,"WHERE C.COLUMN_NAME = P.COLUMN_NAME

\n");/* ***************************************************************

*/if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts,"AND P.TABLE_SCHEMA ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' AND ");strcat (dyn_sts,"AND C.OWNER ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' \n");

}/*strcat (dyn_sts," AND P.TABLE_SCHEMA = :OWNER

\n");strcat (dyn_sts," AND C.OWNER = :OWNER \n");*/

/* ****************************************************************/

if ( (strlen (opcion_dos) > 0) ){

strcat (dyn_sts,"AND P.TABLE_NAME ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' AND ");strcat (dyn_sts,"AND C.TABLE_NAME ='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");

}/*strcat (dyn_sts," AND P.TABLE_NAME = :TABLE_NAME

\n");strcat (dyn_sts," AND C.TABLE_NAME = :TABLE_NAME

\n");*/

/* ****************************************************************/

if ( (strlen (opcion_tres) > 0) ){

strcat (dyn_sts,"AND P.PRIVILEGE ='");strcat (dyn_sts,opcion_tres);strcat (dyn_sts,"' ");

}/*strcat (dyn_sts," AND P.PRIVILEGE = :PRIVILEGE

\n");*/

/* ****************************************************************/

if ( (strlen (opcion_cuatro) > 0) )

Página 35

func_dyn_statement_set.c{

strcat (dyn_sts,"AND P.GRANTEE ='");strcat (dyn_sts,opcion_cuatro);strcat (dyn_sts,"' ");

}/*strcat (dyn_sts," AND P.GRANTEE = :GRANTEE \n");

*//* ***************************************************************

*/strcat (dyn_sts," ORDER BY C.COLUMN_ID \n");break;

case CASE_SHOW_LOCKS_VIEWS:strcpy (dyn_sts,"select l.id1,decode(l.type, 'MR',

'Media Recovery', 'RT', 'Redo Thread', 'UN', 'User Name', ");strcat (dyn_sts,"'TX', 'Transaction', 'TM', 'DML',

'UL', 'PL/SQL User Lock', 'DX', 'Distributed Xaction', ");strcat (dyn_sts,"'CF', 'Control File', 'IS', 'Instance

State', 'FS', 'File Set', 'IR', 'Instance Recovery', ");strcat (dyn_sts,"'ST', 'Disk Space Transaction', 'TS',

'Temp Segment', 'IV', 'Library Cache Invalidation', ");strcat (dyn_sts,"'LS', 'Log Start or Switch', 'RW',

'Row Wait', 'SQ', 'Sequence Number', ");strcat (dyn_sts,"'TE', 'Extend Table', 'TT', 'Temp

Table', l.type) type, ");strcat (dyn_sts,"decode( l.lmode, 2,'share update', 3,

'row exclusive', 4, 'share', 5, 'share row exclusive', ");strcat (dyn_sts,"6, 'exclusive', 0, '-', l.lmode)

lmode, ");strcat (dyn_sts,"decode( l.request, 0, '-', 2, 'share

update', 3, 'row exclusive', 4, 'share', ");strcat (dyn_sts,"5, 'share row exclusive', 6,

'exclusive', l.request) request , ");/* strcat (dyn_sts,"null object_name, \n"); */

strcat (dyn_sts,"o.object_name object_name, \n");

/* strcat (dyn_sts,"null owner, \n"); */strcat (dyn_sts,"o.owner owner, \n");

/* strcat (dyn_sts,"null object_type, \n"); */strcat (dyn_sts,"o.object_type object_type, \n");

strcat (dyn_sts," -1 image_index , \n");strcat (dyn_sts," nvl(o.object_name,

'(ID='||to_char(l.id1)||')')object_name, o.owner, o.object_type, ");strcat (dyn_sts," DECODE( O.OBJECT_TYPE, 'TABLE', 0,

'VIEW', 1, 'SYNONYM', 2, 'TRIGGER', ");strcat (dyn_sts,"4, 'PACKAGE', 5, 'PACKAGE BODY', 6,

'PROCEDURE', 7, 'FUNCTION', 8, 'INDEX', 17, ");strcat (dyn_sts," 'SEQUENCE', 18, -1) IMAGE_INDEX

\n");strcat (dyn_sts,"from sys.v_$lock l , SYS.all_objects o

\n");strcat (dyn_sts,"where l.id1 = o.object_id (+) \n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"AND l.sid ='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"' ");}

/* strcat (dyn_sts,"and l.sid = :SID \n"); */strcat (dyn_sts,"order by lmode desc, request \n");break;

case CASE_GRAPH_LOCK_WAITS:strcpy (dyn_sts,"select l.sid, S.PROGRAM, S.USERNAME,

S.TERMINAL \n");strcat (dyn_sts,"from \n");

Página 36

func_dyn_statement_set.cstrcat (dyn_sts," (SELECT SID FROM SYS.V_$LOCK WHERE

LMODE>1 \n");strcat (dyn_sts," MINUS select SID FROM sys.v_$LOCK

WHERE REQUEST>0 ) L, \n");strcat (dyn_sts," SYS.V_$SESSION S \n");strcat (dyn_sts,"WHERE L.SID = S.SID AND S.USERNAME IS

NOT NULL \n");break;

case CASE_OBJECT_ACCESS_SESSION:strcpy (dyn_sts,"SELECT SID, DECODE( OWNER, USER, NULL,

OWNER || '.' ) || ");strcat (dyn_sts,"OBJECT OBJECT, TYPE OBJ_TYPE \n");strcat (dyn_sts,"FROM SYS.V_$ACCESS \n");if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts,"WHERE SID=");strcat (dyn_sts,opcion_uno);strcat (dyn_sts," ");

}strcat (dyn_sts,"ORDER BY 1 \n");break;

case CASE_SHOW_LATCHES:strcpy (dyn_sts,"SELECT L.*, N.NAME \n");strcat (dyn_sts,"FROM SYS.V_$LATCH L, \n");strcat (dyn_sts,"SYS.V_$LATCHHOLDER H, \n");strcat (dyn_sts,"SYS.V_$LATCHNAME N \n");strcat (dyn_sts,"WHERE L.ADDR = H.LADDR \n");strcat (dyn_sts," AND N.LATCH# = L.LATCH# \n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"AND H.PID=");strcat (dyn_sts,opcion_uno);strcat (dyn_sts," \n");}

break;case CASE_SHOW_STATISTICS:


strcpy (dyn_sts,"select id, name, set_msize, cnum_repl, \n");

strcat (dyn_sts,"cnum_write, cnum_set, buf_got, sum_write, \n");

strcat (dyn_sts,"sum_scan, free_buffer_wait, \n");

strcat (dyn_sts,"write_complete_wait, buffer_busy_wait, \n");

strcat (dyn_sts,"free_buffer_inspected, dirty_buffers_inspected, \n");

strcat (dyn_sts,"db_block_change, db_block_gets, \n");

strcat (dyn_sts,"consistent_gets, physical_reads, \n");

strcat (dyn_sts,"physical_writes \n");strcat (dyn_sts,"from

v$buffer_pool_statistics \n");break;

case VERSION_ORACLE_734:strcpy (dyn_sts,"select banner\n");strcat (dyn_sts," from v$version ");break;

}break;

case CASE_SHOW_TRANSACTIONS:strcpy (dyn_sts,"SELECT s.sid,t.ADDR, t.XIDUSN,

t.XIDSLOT, t.XIDSQN, t.UBAFIL, t.UBABLK, ");

Página 37

func_dyn_statement_set.cstrcat (dyn_sts,"t.UBASQN,t.UBAREC,t.STATUS,to_date(

t.start_time, 'MM/DD/RR HH24:MI:SS') start_time, ");strcat (dyn_sts,"t.START_SCNB, t.START_SCNW,

t.START_UEXT, t.START_UBAFIL,t.START_UBABLK, ");strcat (dyn_sts,"t.START_UBASQN, t.START_UBAREC,

t.SES_ADDR, t.FLAG, t.SPACE, t.RECURSIVE, ");strcat (dyn_sts,"t.NOUNDO, t.PRV_XIDUSN, t.PRV_XIDSLT,

t.PRV_XIDSQN, null PTX, null PTX_XIDUSN, ");strcat (dyn_sts,"null PTX_XIDSLT, null PTX_XIDSQN, null

DSCN_B, null DSCN_W, t.USED_UBLK, ");strcat (dyn_sts,"t.USED_UREC, t.LOG_IO, t.PHY_IO,

t.CR_GET, t.CR_CHANGE \n");strcat (dyn_sts,"FROM SYS.V_$TRANSACTION T,

SYS.V_$SESSION S \n");strcat (dyn_sts,"WHERE S.SADDR = T.SES_ADDR \n");if ( (strlen (opcion_uno) > 0) ){

strcat (dyn_sts," AND SID=");strcat (dyn_sts,opcion_uno);strcat (dyn_sts," ");

}strcat (dyn_sts,"ORDER BY t.start_scnb \n");break;

case CASE_SHOW_DATAFILES_STATUS:strcpy (dyn_sts,"SELECT F.FILE_ID, F.TABLESPACE_NAME,

");strcat (dyn_sts,"'N/A' AUTOEXTENSIBLE, TO_NUMBER(null)

MAXBYTES, ");strcat (dyn_sts,"TO_NUMBER(null) NEXT_SIZE, F.BYTES/1024

KBYTES, F.BLOCKS, ");strcat (dyn_sts,"F.STATUS, NVL(MAX(S.BYTES)/1024,0)

MAX_CHUNK_SPACE, ");strcat (dyn_sts,"NVL(MIN (S.BYTES)/1024,0)

MIN_CHUNK_SPACE, NVL(SUM(S.BYTES)/1024, 0) FREE_SPACE, ");strcat (dyn_sts,"NVL(COUNT(S.BYTES),0) FRAGMENTS,

100*(F.BYTES-NVL(SUM(S.BYTES),0))/F.BYTES USAGE_PCT, ");strcat (dyn_sts,"B.STATUS BACKUP_STATUS, B.CHANGE#

BACKUP_CHANGE#, B.TIME BACKUP_TIME, \n");strcat (dyn_sts,"F.FILE_NAME \n");strcat (dyn_sts,"FROM SYS.DBA_DATA_FILES F,

SYS.DBA_FREE_SPACE S, \n");strcat (dyn_sts,"SYS.V_$BACKUP B \n");strcat (dyn_sts,"WHERE F.TABLESPACE_NAME =

S.TABLESPACE_NAME (+) AND \n");strcat (dyn_sts,"F.FILE_ID = S.FILE_ID (+) AND F.FILE_ID

= B.FILE# \n");strcat (dyn_sts,"GROUP BY F.FILE_NAME, F.FILE_ID ,

F.TABLESPACE_NAME, \n");strcat (dyn_sts,"F.BYTES, F.BLOCKS, F.STATUS, 'N/A',

TO_NUMBER(null), \n");strcat (dyn_sts,"TO_NUMBER(null), B.STATUS,

B.CHANGE#, B.TIME \n");strcat (dyn_sts,"ORDER BY F.FILE_NAME \n");break;

case CASE_SHOW_DB_OBJECT_CACHE:strcpy (dyn_sts,"select owner, namespace, loads,

executions, locks, pins, kept, ");strcat (dyn_sts,"sum(sharable_mem), name \n");strcat (dyn_sts," from v$db_object_cache \n");strcat (dyn_sts," group by owner, name, namespace,

loads, ");strcat (dyn_sts," executions, locks, pins, kept \n");strcat (dyn_sts," order by sum(sharable_mem) desc \n");break;

case CASE_TABLE_ALERT_EXTENT_USED:strcpy (dyn_sts,"select

t1.owner,t1.segment_name,t1.segment_type, \n");strcat (dyn_sts,"t2.min_extents, t2.max_extents,

Página 38

func_dyn_statement_set.ccount(*), \n");

strcat (dyn_sts,"to_char(100*count(*)/t2.max_extents,'99.99') \n");

strcat (dyn_sts,"from dba_extents t1, dba_segments t2 \n");

strcat (dyn_sts,"where t1.segment_type='TABLE' \n");strcat (dyn_sts,"and t1.owner = t2.owner \n");strcat (dyn_sts,"and t1.segment_type = t2.segment_type

\n");strcat (dyn_sts,"and t1.segment_name = t2.segment_name

\n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"and t1.owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

if ( (strlen (opcion_dos) > 0) ){strcat (dyn_sts,"and t1.segment_name='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

strcat (dyn_sts,"group by t1.owner,t1.segment_name,t1.segment_type, ");

strcat (dyn_sts,"t2.min_extents, t2.max_extents \n");strcat (dyn_sts,"order by 7 desc \n");break;

case CASE_INDEX_ALERT_EXTENT_USED:strcpy (dyn_sts,"select

t1.owner,t1.segment_name,t1.segment_type, \n");strcat (dyn_sts,"t2.min_extents, t2.max_extents,

count(*), \n");strcat

(dyn_sts,"to_char(100*count(*)/t2.max_extents,'99.99') \n");strcat (dyn_sts,"from dba_extents t1, dba_segments t2

\n");strcat (dyn_sts,"where t1.segment_type='INDEX' \n");strcat (dyn_sts,"and t1.owner = t2.owner \n");strcat (dyn_sts,"and t1.segment_type = t2.segment_type

\n");strcat (dyn_sts,"and t1.segment_name = t2.segment_name

\n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"and t1.owner='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

if ( (strlen (opcion_dos) > 0) ){strcat (dyn_sts,"and t1.segment_name='");strcat (dyn_sts,opcion_dos);strcat (dyn_sts,"' \n");}

strcat (dyn_sts,"group by t1.owner,t1.segment_name,t1.segment_type, ");

strcat (dyn_sts,"t2.min_extents, t2.max_extents \n");strcat (dyn_sts,"order by 7 desc \n");break;

case CASE_USER_TIME_WORKING:strcpy (dyn_sts,"select vse.osuser, vse.username usernm,

vse.status status, \n");strcat (dyn_sts,"'@$SCR/killer

'||rpad(vse.sid||','||vse.serial#,9) kill, \n");strcat (dyn_sts,"spid UNIX,

nvl(substr(vse.module,1,60),substr(vse.program,1,60)) vtext, \n");strcat (dyn_sts,"to_char(to_number(sysdate -

Página 39

func_dyn_statement_set.cvse.logon_time)*24*60, '99999.99') minutos, \n");

strcat (dyn_sts,"to_char(vse.logon_time,'dd-mon hh24:mm') logon \n");

strcat (dyn_sts,"from v$session vse, v$process vps \n");strcat (dyn_sts,"where vse.PADDR = vps.ADDR \n");strcat (dyn_sts,"order by vtext, minutos desc \n");break;

case CASE_IS_USER_WORKING:strcpy (dyn_sts,"select vse.osuser, vse.username usernm,

vse.status status, \n");strcat (dyn_sts,"'@$SCR/killer

'||rpad(vse.sid||','||vse.serial#,9) kill, \n");strcat (dyn_sts,"spid UNIX,

nvl(substr(vse.module,1,60),substr(vse.program,1,60)) vtext, \n");strcat (dyn_sts,"sum(vsa.disk_reads) reads,

sum(vsa.buffer_gets) gets , \n");strcat (dyn_sts,"to_char(to_number(sysdate -

vse.logon_time)*24*60, '99999.99') minutos, \n");strcat (dyn_sts,"to_char(vse.logon_time,'dd-mon

hh24:mm') logon \n");strcat (dyn_sts,"from v$session vse, v$sqlarea vsa,

v$process vps \n");strcat (dyn_sts,"where vse.sql_address=vsa.address and

\n");strcat (dyn_sts,"vse.sql_hash_value=vsa.hash_value and

\n");strcat (dyn_sts,"vse.username is not null and vse.PADDR

= vps.ADDR \n");strcat (dyn_sts,"group by vse.osuser, vse.username,

vse.status, \n");strcat (dyn_sts,"vse.sid, vse.serial#, vps.spid, \n");strcat

(dyn_sts,"nvl(substr(vse.module,1,60),substr(vse.program,1,60)) , \n");strcat (dyn_sts,"vsa.disk_reads, vsa.buffer_gets,

vse.logon_time \n");strcat (dyn_sts,"order by minutos desc \n");break;

case CASE_VER_SQL_PROGRAM:strcpy (dyn_sts,"select vps.pid,

vps.spid,vse.sid,vse.status, vse.osuser,vse.username usernm, \n");strcat (dyn_sts,"vse.terminal, vse.machine, \n");strcat (dyn_sts,"'@$SCR/killer

'||rpad(vse.sid||','||vse.serial#,9) kill, \n");strcat

(dyn_sts,"nvl(substr(vse.module,1,60),substr(vse.program,1,60)) vtext, \n");strcat (dyn_sts,"to_char(to_number(sysdate -

vse.logon_time)*24*60, '99999.99') minutos \n");strcat (dyn_sts,"from v$session vse, v$process vps \n");strcat (dyn_sts,"where vse.PADDR = vps.ADDR \n");strcat (dyn_sts,"and ( \n");strcat (dyn_sts," ( UPPER (

nvl(substr(vse.module,1,60),substr(vse.program,1,60))) like 'SQL*PLUS%' ) or \n");

strcat (dyn_sts," ( UPPER ( nvl(substr(vse.module,1,60),substr(vse.program,1,60))) like '%PLUS%' ) or \n");

strcat (dyn_sts," ( UPPER ( nvl(substr(vse.module,1,60),substr(vse.program,1,60))) like '%T.O.A.D%' ) or \n");

strcat (dyn_sts," ( UPPER ( nvl(substr(vse.module,1,60),substr(vse.program,1,60))) like '%SQLNAV%' ) or \n");

strcat (dyn_sts," ( UPPER ( nvl(substr(vse.module,1,60),substr(vse.program,1,60))) like '%SQL%' ) ) \n");

strcat (dyn_sts," order by minutos desc \n");break;

case CASE_SQL_SESS_IO:strcpy (dyn_sts,"select s.sid, s.username, s.terminal,

s.machine, \n");

Página 40

func_dyn_statement_set.cstrcat (dyn_sts,"i.block_gets, i.consistent_gets,

i.physical_reads, \n");strcat (dyn_sts,"i.block_changes, i.consistent_changes

\n");strcat (dyn_sts,"from v$session s, v$sess_io i \n");strcat (dyn_sts,"where s.sid = i.sid \n");

if ( (strlen (opcion_uno) > 0) ){strcat (dyn_sts,"and s.sid='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

strcat (dyn_sts,"order by i.block_gets, i.physical_reads\n");

break;case CASE_SQL_SESSION_EVENT:

strcpy (dyn_sts,"select s.sid, s.username, s.terminal, s.machine, \n");

strcat (dyn_sts,"e.event, e.total_waits, e.total_timeouts, \n");

strcat (dyn_sts,"e.time_waited, e.average_wait, e.max_wait \n");

strcat (dyn_sts,"from v$session s, v$session_event e \n");

strcat (dyn_sts,"where s.sid = e.sid \n");

if ( (strlen (opcion_uno) > 0) ){strcat (dyn_sts,"and s.sid='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

strcat (dyn_sts,"order by s.sid, e.total_waits, e.average_wait \n");

break;case CASE_SQL_SESSION_WAIT:

strcpy (dyn_sts,"select s.sid,s.username,s.terminal,s.machine, \n");

strcat (dyn_sts,"w.seq#,w.event,w.p1text,w.p1, w.p1raw, w.p2text, \n");

strcat (dyn_sts,"w.p2,w.p2raw, w.p3text, w.p3, w.p3raw, w.wait_time, \n");

strcat (dyn_sts,"w.seconds_in_wait, w.state \n");strcat (dyn_sts,"from v$session s, v$session_wait w

\n");strcat (dyn_sts,"where s.sid = w.sid \n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"and s.sid='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

break;case CASE_SQL_SESSION_LONG_OPER:

strcpy (dyn_sts,"select s.SID, s.USERNAME, s.TERMINAL, s.MACHINE, \n");

strcat (dyn_sts,"sl.SERIAL#, sl.OPNAME, sl.TARGET, \n");strcat (dyn_sts,"sl.TARGET_DESC, sl.SOFAR, sl.TOTALWORK,

sl.UNITS, \n");strcat (dyn_sts,"to_char(sl.start_time,'DD/MM/YYYY -

HH24:MI:SS'), \n");strcat (dyn_sts,"to_char(sl.last_update_time,'DD/MM/YYYY

- HH24:MI:SS'), \n");strcat (dyn_sts,"sl.time_remaining, \n");strcat (dyn_sts,"sl.ELAPSED_SECONDS, \n");strcat (dyn_sts,"sl.CONTEXT, sl.MESSAGE, sl.USERNAME,

sl.SQL_ADDRESS, \n");

Página 41

func_dyn_statement_set.cstrcat (dyn_sts,"sl.SQL_HASH_VALUE, sl.QCSID \n");strcat (dyn_sts,"from v$session_longops sl, v$session

s\n");strcat (dyn_sts,"where sl.sid = s.sid \n");if ( (strlen (opcion_uno) > 0) )

{strcat (dyn_sts,"and s.sid='");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"'\n ");}

break;case CASE_SQL_LOCKED_OBJECTS:

strcpy (dyn_sts,"select XIDUSN,XIDSLOT,XIDSQN,OBJECT_ID,\n");

strcat (dyn_sts,"SESSION_ID,ORACLE_USERNAME,OS_USER_NAME, \n");

strcat (dyn_sts,"PROCESS,LOCKED_MODE \n");strcat (dyn_sts,"from v$locked_object \n");break;

case CASE_SQL_TRANSACTION_DETAIL:strcpy (dyn_sts,"select

addr,xidusn,xidslot,xidsqn,ubafil, \n");strcat

(dyn_sts,"ubablk,ubasqn,ubarec,start_ubafil,start_ubablk, \n");strcat (dyn_sts,"start_ubasqn,start_ubarec,log_io,

phy_io \n");strcat (dyn_sts,"from v$transaction \n");break;

case CASE_SQL_LOCK_MEDIUM_INFO:strcpy (dyn_sts,"select s.saddr,l.sid, s.serial#,

s.username, s.terminal, \n");strcat (dyn_sts,"decode(l.type,'RW','RW - Row Wait

Enqueue','TM','TM - DML Enqueue', \n");strcat (dyn_sts,"'TX','TX - Trans Enqueue','UL','UL -

User',l.type||'System') res, \n");strcat (dyn_sts,"t.name tab, u.name owner, l.id1,

l.id2, decode(l.lmode, \n");strcat (dyn_sts,"1,'No Lock',2,'Row Share',3,'Row

Exclusive',4,'Share',5,'Shr Row Excl', \n");strcat (dyn_sts,"6,'Exclusive','NONE')

lmode,decode(l.request,1,'No Lock',2,'Row Share', \n");strcat (dyn_sts,"3,'Row Excl',4,'Share',5,'Shr Row

Excl',6,'Exclusive','NONE') request \n");strcat (dyn_sts,"from v$lock l, v$session s, sys.user$

u, sys.obj$ t \n");strcat (dyn_sts,"where l.sid = s.sid and s.type !=

'BACKGROUND' and \n");strcat (dyn_sts,"t.obj# = l.id1 and u.user# = t.owner#

\n");break;

case CASE_SQL_LOCK_FULL_INFO:strcpy (dyn_sts,"select nvl(S.USERNAME,'Internal')

username,L.SID, nvl(S.TERMINAL,'None') terminal,\n");strcat

(dyn_sts,"decode(command,0,'None',decode(l.id2,0,U1.NAME||'.'||substr(T1.NAME,1,35),'None')) tab,\n");

strcat (dyn_sts,"decode(command,0,'BACKGROUND',1,'CreateTable',2,'INSERT',3,'SELECT', \n");

strcat (dyn_sts,"4,'CREATE CLUSTER',5,'ALTER CLUSTER',6,'UPDATE',7,'DELETE',8,'DROP', \n");

strcat (dyn_sts,"9,'CREATE INDEX',10,'DROP INDEX',11,'ALTER INDEX',12,'DROP TABLE', \n");

strcat (dyn_sts,"13,'CREATE SEQUENCE',14,'ALTER SEQUENCE',15,'ALTER TABLE', \n");

strcat (dyn_sts,"16,'DROP SEQUENCE',17,'GRANT',18,'REVOKE',19,'CREATE SYNONYM', \n");

strcat (dyn_sts,"20,'DROP SYNONYM',21,'CREATE VIEW',22,'DROP VIEW',23,'VALIDATE INDEX', \n");

Página 42

func_dyn_statement_set.cstrcat (dyn_sts,"24,'CREATE PROCEDURE',25,'ALTER

PROCEDURE',26,'LOCK TABLE', \n");strcat (dyn_sts,"27,'NO

OPERATION',28,'RENAME',29,'COMMENT',30,'AUDIT',31,'NOAUDIT', \n");strcat (dyn_sts,"32,'CREATE EXTERNAL DATABASE',33,'DROP

EXTERNAL DATABASE', \n");strcat (dyn_sts,"34,'CREATE DATABASE',35,'ALTER

DATABASE',36,'CREATE ROLLBACK SEGMENT',\n");strcat (dyn_sts,"37,'ALTER ROLLBACK SEGMENT',38,'DROP

ROLLBACK SEGMENT',39,'CREATE TABLESPACE', \n");strcat (dyn_sts,"40,'ALTER TABLESPACE',41,'DROP

TABLESPACE',42,'ALTER SESSION',43,'ALTER USER', \n");strcat

(dyn_sts,"44,'COMMIT',45,'ROLLBACK',46,'SAVEPOINT',47,'PL/SQL EXECUTE',48,'SET TRANSACTION', \n");

strcat (dyn_sts,"49,'ALTER SYSTEM SWITCH LOG',50,'EXPLAIN',51,'CREATE USER',52,'CREATE ROLE', \n");

strcat (dyn_sts,"53,'DROP USER',54,'DROP ROLE',55,'SET ROLE',56,'CREATE SCHEMA',57,'CREATE CONTROL FILE', \n");

strcat (dyn_sts,"58,'ALTER TRACING',59,'CREATE TRIGGER',60,'ALTER TRIGGER',61,'DROP TRIGGER',\n");

strcat (dyn_sts,"62,'ANALYZE TABLE',63,'ANALYZE INDEX',64,'ANALYZE CLUSTER',65,'CREATE PROFILE', \n");

strcat (dyn_sts,"66,'DROP PROFILE',67,'ALTER PROFILE',68,'DROP PROCEDURE',69,'DROP PROCEDURE', \n");

strcat (dyn_sts,"70,'ALTER RESOURCE COST',71,'CREATE SNAPSHOT LOG',72,'ALTER SNAPSHOT LOG', \n");

strcat (dyn_sts,"73,'DROP SNAPSHOT LOG',74,'CREATE SNAPSHOT',75,'ALTER SNAPSHOT',76,'DROP SNAPSHOT', \n");

strcat (dyn_sts,"79,'ALTER ROLE',85,'TRUNCATE TABLE',86,'TRUNCATE CLUSTER',87,'-',88,'ALTER VIEW',\n");

strcat (dyn_sts,"89,'-',90,'-',91,'CREATE FUNCTION',92,'ALTER FUNCTION',93,'DROP FUNCTION',94,'CREATE PACKAGE', \n");

strcat (dyn_sts,"95,'ALTER PACKAGE',96,'DROP PACKAGE',97,'CREATE PACKAGE BODY',98,'ALTER PACKAGE BODY', \n");

strcat (dyn_sts,"99,'DROP PACKAGE BODY',command||' - \?\?\?') COMMAND, decode(L.LMODE,1,'No Lock', \n");

strcat (dyn_sts," 2,'Row Share',3,'Row Exclusive',4,'Share',5,'Share Row Exclusive',6,'Exclusive','NONE') lmode, \n");

strcat (dyn_sts," decode(L.REQUEST,1,'No Lock',2,'Row Share',3,'Row Exclusive',4,'Share',5,'Share Row Exclusive', \n");

strcat (dyn_sts,"6,'Exclusive','NONE') request,l.id1||'-'||l.id2 Laddr,l.type||' - '||decode(l.type,'BL','Buffer hash table instance lock', \n");

strcat (dyn_sts,"'CF',' Control file schema global enqueue lock','CI','Cross-instance function invocation instance lock', \n");

strcat (dyn_sts,"'CS','Control file schema global enqueue lock','CU','Cursor bind lock','DF','Data file instance lock', \n");

strcat (dyn_sts,"'DL','Direct loader parallel index create','DM','Mount/startup db primary/secondary instance lock', \n");

strcat (dyn_sts,"'DR','Distributed recovery process lock','DX','Distributed transaction entry lock','FI','SGA open-file information lock', \n");

strcat (dyn_sts,"'FS','File set lock','HW','Space management operations on a specific segment lock','IN','Instance number lock', \n");

strcat (dyn_sts,"'IR','Instance recovery serialization global enqueue lock','IS','Instance state lock','IV','Library cache invalidationinstance lock', \n");

strcat (dyn_sts,"'JQ','Job queue lock','KK','Thread kicklock','MB','Master buffer hash table instance lock','MM','Mount definition gloabal enqueue lock', \n");

strcat (dyn_sts,"'MR','Media recovery lock','PF','Password file lock','PI','Parallel operation lock','PR','Process startup lock', \n");

strcat (dyn_sts,"'PS','Parallel operation lock','RE','USE_ROW_ENQUEUE enforcement lock','RT','Redo thread global enqueue lock', \n");

Página 43

func_dyn_statement_set.cstrcat (dyn_sts,"'RW','Row wait enqueue

lock','SC','System commit number instance lock','SH','System commit number high water mark enqueue lock', \n");

strcat (dyn_sts,"'SM','SMON lock','SN','Sequence number instance lock','SQ','Sequence number enqueue lock','SS','Sort segment lock', \n");

strcat (dyn_sts,"'ST','Space transaction enqueue lock','SV','Sequence number value lock','TA','Generic enqueue lock','TD','DDL enqueue lock', \n");

strcat (dyn_sts,"'TE','Extend-segment enqueue lock','TM','DML enqueue lock','TT','Temporary table enqueue lock','TX','Transaction enqueue lock', \n");

strcat (dyn_sts,"'UL','User supplied lock','UN','User name lock','US','Undo segment DDL lock','WL','Being-written redo log instance lock', \n");

strcat (dyn_sts,"'WS','Write-atomic-log-switch global enqueue lock','TS',decode(l.id2,0,'Temporary segment enqueue lock (ID2=0)',");

strcat (dyn_sts,"'New block allocation enqueue lock (ID2=1)'),'LA','Library cache lock instance lock (A=namespace)', \n");

strcat (dyn_sts,"'LB','Library cache lock instance lock (B=namespace)','LC','Library cache lock instance lock (C=namespace)', \n");

strcat (dyn_sts,"'LD','Library cache lock instance lock (D=namespace)','LE','Library cache lock instance lock (E=namespace)', \n");

strcat (dyn_sts,"'LF','Library cache lock instance lock (F=namespace)','LG','Library cache lock instance lock (G=namespace)', \n");

strcat (dyn_sts,"'LH','Library cache lock instance lock (H=namespace)','LI','Library cache lock instance lock (I=namespace)', \n");

strcat (dyn_sts,"'LJ','Library cache lock instance lock (J=namespace)','LK','Library cache lock instance lock (K=namespace)', \n");

strcat (dyn_sts,"'LL','Library cache lock instance lock (L=namespace)','LM','Library cache lock instance lock (M=namespace)', \n");

strcat (dyn_sts,"'LN','Library cache lock instance lock (N=namespace)','LO','Library cache lock instance lock (O=namespace)', \n");

strcat (dyn_sts,"'LP','Library cache lock instance lock (P=namespace)','LS','Log start/log switch enqueue lock','PA','Library cache pin instance lock (A=namespace)', \n");

strcat (dyn_sts,"'PB','Library cache pin instance lock (B=namespace)','PC','Library cache pin instance lock (C=namespace)', \n");

strcat (dyn_sts,"'PD','Library cache pin instance lock (D=namespace)','PE','Library cache pin instance lock (E=namespace)', \n");

strcat (dyn_sts,"'PF','Library cache pin instance lock (F=namespace)','PG','Library cache pin instance lock (G=namespace)', \n");

strcat (dyn_sts,"'PH','Library cache pin instance lock (H=namespace)','PI','Library cache pin instance lock (I=namespace)', \n");

strcat (dyn_sts,"'PJ','Library cache pin instance lock (J=namespace)','PL','Library cache pin instance lock (K=namespace)', \n");

strcat (dyn_sts,"'PK','Library cache pin instance lock (L=namespace)','PM','Library cache pin instance lock (M=namespace)', \n");

strcat (dyn_sts,"'PN','Library cache pin instance lock (N=namespace)','PO','Library cache pin instance lock (O=namespace)', \n");

strcat (dyn_sts,"'PP','Library cache pin instance lock (P=namespace)','PQ','Library cache pin instance lock (Q=namespace)', \n");

strcat (dyn_sts,"'PR','Library cache pin instance lock (R=namespace)','PS','Library cache pin instance lock (S=namespace)', \n");

strcat (dyn_sts,"'PT','Library cache pin instance lock (T=namespace)','PU','Library cache pin instance lock (U=namespace)', \n");

strcat (dyn_sts,"'PV','Library cache pin instance lock (V=namespace)','PW','Library cache pin instance lock (W=namespace)', \n");

strcat (dyn_sts,"'PX','Library cache pin instance lock (X=namespace)','PY','Library cache pin instance lock (Y=namespace)', \n");

strcat (dyn_sts,"'PZ','Library cache pin instance lock (Z=namespace)','QA','Row cache instance lock (A=cache)', \n");

strcat (dyn_sts,"'QB','Row cache instance lock (B=cache)','QC','Row cache instance lock (C=cache)','QD','Row cache instance lock (D=cache)', \n");

strcat (dyn_sts,"'QE','Row cache instance lock (E=cache)','QF','Row cache instance lock (F=cache)','QG','Row cache instance lock (G=cache)',\n");

Página 44

func_dyn_statement_set.cstrcat (dyn_sts,"'QH','Row cache instance lock

(H=cache)','QI','Row cache instance lock (I=cache)','QJ','Row cache instance lock (J=cache)', \n");

strcat (dyn_sts,"'QL','Row cache instance lock (K=cache)','QK','Row cache instance lock (L=cache)','QM','Row cache instance lock (M=cache)', \n");

strcat (dyn_sts,"'QN','Row cache instance lock (N=cache)','QO','Row cache instance lock (O=cache)','QP','Row cache instance lock (P=cache)',\n");

strcat (dyn_sts,"'QQ','Row cache instance lock (Q=cache)','QR','Row cache instance lock (R=cache)','QS','Row cache instance lock (S=cache)', \n");

strcat (dyn_sts,"'QT','Row cache instance lock (T=cache)','QU','Row cache instance lock (U=cache)','QV','Row cache instance lock (V=cache)', \n");

strcat (dyn_sts,"'QW','Row cache instance lock (W=cache)','QX','Row cache instance lock (X=cache)','QY','Row cache instance lock (Y=cache)', \n");

strcat (dyn_sts,"'QZ','Row cache instance lock (Z=cache)','\?\?\?\?') Lockt \n");

strcat (dyn_sts,"FROM V$LOCK L,V$SESSION S, SYS.USER$ U1, SYS.OBJ$ T1 \n");

strcat (dyn_sts,"where L.SID = S.SID \n");strcat (dyn_sts,"and T1.OBJ# = decode(L.ID2,0,L.ID1,1)

\n");strcat (dyn_sts,"and U1.USER# = T1.OWNER# and S.TYPE !=

'BACKGROUND' \n");strcat (dyn_sts,"order by 1,2,5 \n");break;

case CASE_SQL_LOCK_BY_SESSION_ID:strcat (dyn_sts,"SELECT

p.username,p.pid,p.spid,s.username ora,DECODE(l2.type, \n");strcat (dyn_sts,"'TX','TRANSACTION

ROW-LEVEL','TS','TEMPORARY SEGMENT ', \n");strcat (dyn_sts,"'TD','TABLE LOCK','TM','ROW

LOCK',l2.type ) vlock, \n");strcat (dyn_sts,"DECODE(l2.type,'TX','DML

LOCK','TS','TEMPORARY SEGMENT', \n");strcat (dyn_sts,"'TD',DECODE(l2.lmode+l2.request,4,\n");strcat (dyn_sts,"'PARSE '||u.name||'.'||o.name,6,'DDL',

l2.lmode+l2.request), \n");strcat (dyn_sts,"'TM','DML

'||u.name||'.'||o.name,l2.type ) type, \n");strcat

(dyn_sts,"DECODE(l2.lmode+l2.request,2,'RS',3,'RX',4,'S',5,'SRX',6,'X',l2.lmode+l2.request) lmode, \n");

strcat (dyn_sts,"DECODE(l2.request,0,NULL,'WAIT') wait \n");

strcat (dyn_sts,"FROM v$process p, v$_lock l1, v$lock l2, v$resource r, \n");

strcat (dyn_sts,"sys.obj$ o, sys.user$ u, v$session s \n");

strcat (dyn_sts,"WHERE s.paddr=p.addr AND s.saddr = l1.saddr \n");

strcat (dyn_sts,"AND l1.raddr = r.addr AND l2.addr = l1.laddr \n");

strcat (dyn_sts,"AND l2.type <> 'MR' AND l2.type <> 'RT' \n");

strcat (dyn_sts,"AND r.id1 = o.obj# (+) AND o.owner# = u.user# (+) \n");

if ( (strlen (opcion_uno) > 0) ){strcat (dyn_sts,"and p.username LIKE NVL ('");strcat (dyn_sts,opcion_uno);strcat (dyn_sts,"','%') \n ");}

strcat (dyn_sts,"AND p.username LIKE NVL('&&us_','%') \n");

Página 45

func_dyn_statement_set.cstrcat (dyn_sts,"ORDER BY 1, 2, 3, 4, 5 \n");break;

case CASE_SQL_WHO_IS_WAITING_FOR:strcpy (dyn_sts,"SELECT substr(s1.username,1,12) , \n");strcat (dyn_sts,"substr(s1.osuser,1,8)

,substr(to_char(w.session_id),1,5) , \n");strcat (dyn_sts,"P1.spid ,

substr(s2.username,1,12), \n");strcat (dyn_sts,"substr(s2.osuser,1,8)

,substr(to_char(h.session_id),1,5) , \n");strcat (dyn_sts,"P2.spid \n");strcat (dyn_sts,"FROM v$process P1, \n");strcat (dyn_sts,"v$process P2, \n");strcat (dyn_sts,"v$session S1, \n");strcat (dyn_sts,"v$session S2, \n");strcat (dyn_sts,"dba_locks w, \n");strcat (dyn_sts,"dba_locks h \n");strcat (dyn_sts,"WHERE (((h.mode_held != 'None') and

(h.mode_held != 'Null') \n");strcat (dyn_sts,"and ((h.mode_requested = 'None') or

(h.mode_requested = 'Null'))) \n");strcat (dyn_sts,"and (((w.mode_held = 'None') or

(w.mode_held = 'Null')) \n");strcat (dyn_sts,"and ((w.mode_requested != 'None') and

(w.mode_requested != 'Null')))) \n");strcat (dyn_sts,"and w.lock_type = h.lock_type and

w.lock_id1 = h.lock_id1 \n");strcat (dyn_sts,"and w.lock_id2 = h.lock_id2 and

w.session_id != h.session_id \n");strcat (dyn_sts,"and w.session_id = S1.sid and

h.session_id = S2.sid AND \n");strcat (dyn_sts,"S1.paddr = P1.addr AND S2.paddr =

P2.addr \n");break;

case CASE_SQL_WHICH_SQL_RUNNING:strcpy (dyn_sts,"SELECT s.sid, s.username, s.osuser,

\n");strcat (dyn_sts,"nvl(s.machine, '?') machine,

nvl(s.program, '?') program, \n");strcat (dyn_sts,"s.process F_Ground, p.spid B_Ground,

X.sql_text \n");strcat (dyn_sts,"FROM \n");strcat (dyn_sts,"sys.v_$session S, \n");strcat (dyn_sts,"sys.v_$process P, \n");strcat (dyn_sts,"sys.v_$sqlarea X \n");strcat (dyn_sts,"WHERE s.osuser like

lower(nvl('&OS_User','%')) AND \n");strcat (dyn_sts,"s.username like

upper(nvl('&Oracle_User','%')) AND \n");strcat (dyn_sts,"s.sid like nvl('&SID','%') AND s.paddr

= p.addr AND \n");strcat (dyn_sts,"s.type != 'BACKGROUND'AND s.sql_address

= x.address AND \n");strcat (dyn_sts,"s.sql_hash_value = x.hash_value \n");strcat (dyn_sts,"ORDER BY S.sid \n");break;

case CASE_WHICH_OBJECTS_LOCKED_BY_USER:strcpy (dyn_sts,"select ADDR, INDX, INST_ID, KGLLKADR,

KGLLKUSE, \n");strcat (dyn_sts,"KGLLKSES, KGLLKSNM, KGLLKHDL, KGLLKPNC,

KGLLKPNS, \n");strcat (dyn_sts,"KGLLKCNT, KGLLKMOD, KGLLKREQ, KGLLKFLG,

KGLLKSPN, \n");strcat (dyn_sts,"KGLLKHTB, KGLNAHSH, KGLHDPAR, KGLHDNSP,

USER_NAME, \n");strcat (dyn_sts,"KGLNAOBJ \n");strcat (dyn_sts,"from X$KGLLK \n");if ( (strlen (opcion_uno) > 0) )

Página 46

func_dyn_statement_set.c{strcat (dyn_sts,"where kgllkses in (select saddr

\n");strcat (dyn_sts,"from v$session where sid =");strcat (dyn_sts,opcion_uno);strcat (dyn_sts," ) \n ");}

strcat (dyn_sts,"order by KGLLKSES \n");break;

/* ------------------------------------------------- *//************* Agregado 25-Agosto-2005 ***************/

case CASE_BUFFER_CACHE_DEFINED:switch (version)


strcpy (dyn_sts,"select id, name, block_size, current_size, \n");

strcat (dyn_sts,"buffers \n");strcat (dyn_sts,"from v$buffer_pool

\n");break;}

break;

case CASE_BUFFER_CACHE_TOTAL_SIZE:switch (version)


strcpy (dyn_sts,"select sum(current_size),sum(buffers) \n");

strcat (dyn_sts,"from v$buffer_pool \n");

break;}

break;/* ------------------------------------------------- */

case CASE_OPTIMIZER_INDEX_COST_ADJ_ESTIMATE:switch (version)


strcpy (dyn_sts,"select 100 * (sum(decode(event,");

strcat (dyn_sts,"'db file sequential read',average_wait,0))/");

strcat (dyn_sts,"sum(decode(event,'db file scattered read',");

strcat (dyn_sts,"average_wait,0))) \n");strcat (dyn_sts,"from v$system_event

\n");strcat (dyn_sts,"where event like 'db

file s%' \n");break;}

break;/* ------------------------------------------------- */

case CASE_OPTIMIZER_INDEX_CACHING_ESTIMAGE:switch (version)


strcpy (dyn_sts," SELECT TO ESTIMAGE BUFFER HIT RATIO ");

break;}

/* ------------------------------------------------- */default:

strcpy (dyn_sts,"select banner\n");strcat (dyn_sts," from v$version ");

Página 47

func_dyn_statement_set.cbreak;

}return (dyn_sts);}

Página 48

func dyn statement_set.c

Technology

strcpy dyn

version strcat dyn

cadena dyn

cstrcat dyn

mode nstrcat dyn

val2 nstrcat dyn

c strcat dyn

namen strcat dyn