Identifier sa session

En PL/SQL

exec sys.dbms_session.set_identifier          ('identifiant de session')
exec sys.dbms_application_info.set_client_info('info client')
exec sys.dbms_application_info.set_module     ('module', 'action')

Eventuellement, si l’on veut ne changer que l’action

exec sys.dbms_application_info.set_action('action')

En PHP

<?php 
 oci_set_client_identifier($db , 'identifiant de session'); 
 oci_set_client_info      ($db , 'info client'); 
 oci_set_module_name      ($db , 'module'); 
 oci_set_action           ($db , 'action'); 
?>

Retrouver ces informations

select sys_context('USERENV', 'CLIENT_IDENTIFIER') as "client identifier"
     , sys_context('USERENV', 'CLIENT_INFO') as "client info"
     , sys_context('USERENV', 'MODULE') as module
     , sys_context('USERENV', 'ACTION') as action
from sys.dual ;

Avec un peu de mise en forme

SQL> col "client identifier" for a25
SQL> col "client info" for a17
SQL> col module for a17
SQL> col action for a17

SQL> /

client identifier         client info       MODULE            ACTION
------------------------- ----------------- ----------------- -----------------
identifiant de session    info client       module            action

C’était pourtant pas si compliqué

PS: On peut aussi le faire en java ou en .Net si tant est qu’on utilise encore des trucs aussi dépassés ou encore en C via la bibliothèque OCI1 si l’on est résolument moderne. Tout cela est détaillé dans l’excellent Troubleshooting Oracle Performance de Christian Antognini paru chez APress au chapitre 2 pages 45 à 48. Et de manière plus cryptique et éparpillée dans la documentation de l’éditeur.


1. OCI pour Oracle Call Interface, livré par Oracle avec tous les “clients”

Lister les structures mémoire

La structure mémoire (X$…) qui garde la trace des structures mémoires est x$kqfta pour les lister c’est la requête suivante :

select KQFTANAM from x$kqfta

ou, plus simple encore :

select name from v$fixed_table

C’est tout de même plus simple que de passer par un code perl qui ne va pas forcément s’avérer complet

Toujours intéressant à lire sur le sujet : http://www.orafaq.com/wiki/X$_Table ou encore http://yong321.freeshell.org/computer/x$table.html

Trouver le DDL d’une vue dynamique (V$… ou GV$…)

On utilise v$fixed_view_definition

SELECT * 
FROM v$fixed_view_definition 
where view_name = upper('v$fixed_view_definition')

On obtient :

V$FIXED_VIEW_DEFINITION
SELECT * FROM gv$fixed_view_definition where inst_id = USERENV('Instance')

Et donc, comme on a autre chose que du fromage blanc entre les oreille on passe la requête suivante :

SELECT * 
FROM v$fixed_view_definition 
where view_name = upper('gv$fixed_view_definition')

Pour finalement obtenir :

GV$FIXED_VIEW_DEFINITION
select i.inst_id,kqfvinam,kqftpsel from x$kqfvi i, x$kqfvt t where i.indx = t.indx

C’était pourtant pas si compliqué

Requêtage du vide 1/2

Je veux générer la consommation de temps de chaque SQL_ID sur une période donnée, j’utilise ASH (ou plus exactement v$active_session_history).

Je définis un certain nombre de variables pour rendre le code lisible et ré-utilisable.

  • deb: date de début de l’échantillonnage
  • fin: date de fin de l’échantillonnage
  • nbsec: nombre de seconde d’aggrégation
  • nbVals: nombre de valeurs à générer dans l’intervalle d’échantillonnage
  • DBID: commenté, pourrait serveir à travailler avec DBA_HIST_ACTIVE_SESS_HISTORY
var deb varchar2(25)
var fin varchar2(25)
var frmt varchar2(25)
var nbsec number
var nbVals number
-- var dbid number

Je positionne les valeurs des variables, je veux échantillonner sur les 10 dernières minutes

-- exec select dbid into :dbid from v$database
exec :frmt :=  'YYYYMMDDHH24MISS' 
exec select to_char(trunc( sysdate - interval '10' minute , 'MI'), :frmt ), to_char( trunc (sysdate, 'MI'), :frmt) into :deb, :fin from dual 
exec :nbsec := 60
exec :nbVals := 10

La requête est la suivante (et elle n’est forcément pas simple)

with dts as ( select  to_char( to_date(:deb, :frmt)  
                             + ( rownum/ ( 60 *60 *24 ) ) * :nbsec  
                             , :frmt ) dt 
              from dual
              connect by rownum &lt;= :nbVals ) ,
-- ----------------------------------------------------------------------------------
    vals as ( select to_char(trunc(SAMPLE_TIME, 'MI'), :frmt) sample_time_min        
--                   , INSTANCE_NUMBER
--                   , DBID    
                   , SQL_ID 
                   , count(*) sec_per_min
--                   , count(*) * 10 sec_per_min
              from v$active_session_history 
--              from dba_hist_active_sess_history 
              where SAMPLE_TIME between to_date(:deb, :frmt) and to_date(:fin, :frmt)
--                and DBID = :dbid
              group by trunc(SAMPLE_TIME, 'MI')           
--                     , INSTANCE_NUMBER
--                     , DBID
                     , SQL_ID ),
-- ----------------------------------------------------------------------------------
  TOPSQL as ( select SQL_ID 
                   , sum(sec_per_min) pos
              from vals
              group by sql_id
              order by 2 desc, sql_id asc )
-- ----------------------------------------------------------------------------------
select dt
     , pos
     , sql_id
     , max(sec_per_min) sec_per_min
from ( Select distinct dt
            , sql_id
            , pos
            , case when dt=sample_time_min then sec_per_min 
                   else                         0           end  sec_per_min
       from dts, vals natural join TOPSQL )
group by dt, sql_id, pos
order by dt, sql_id, pos desc
/

Décorticons

  • La sous requête factorisée DTS :
    select  to_char( to_date(:deb, :frmt)  
                   + ( rownum/ ( 60 *60 *24 ) ) * :nbsec  
                   , :frmt ) dt 
    from dual
    connect by rownum &lt;= :nbVals

    permet de générer les dates d’échantillons à retenir sous forme d’horodatage régulier.

  • La sous requête factorisée VALS (sans les commentaires qui permettent de travailler en mode historique)
    select to_char(trunc(SAMPLE_TIME, 'MI'), :frmt) sample_time_min           
         , SQL_ID 
         , count(*) sec_per_min
    from v$active_session_history 
    where SAMPLE_TIME between to_date(:deb, :frmt) and to_date(:fin, :frmt)
    group by trunc(SAMPLE_TIME, 'MI')           
           , SQL_ID 

    permet de relier les SQL_ID à leur charge

  • La sous requête factorisée TOPSQL
    select SQL_ID 
         , sum(sec_per_min) pos
    from vals
    group by sql_id
    order by 2 desc, sql_id asc )

    permet de calculer la charge globale de chaque SQL_ID et de les classer.

  • LA requête en tant que telle effectue le produit cartésien et ne retient que ce qui l’intéresse … C’est cher payé, mais ça donne le résultat escompté
    select dt
         , pos
         , sql_id
         , max(sec_per_min) sec_per_min
    from ( Select distinct dt
                , sql_id
                , pos
                , case when dt=sample_time_min then sec_per_min 
                       else                         0           end  sec_per_min
           from dts, vals natural join TOPSQL )
    group by dt, sql_id, pos
    order by dt, sql_id, pos desc

Le résultat avec un peu de présentation ( break on dt skip 1 ) :

DT                               POS SQL_ID        SEC_PER_MIN
------------------------- ---------- ------------- -----------
20150427211800                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427211900                    10 a1xgxtssv5rrp          10
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212000                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212100                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212200                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212300                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j          10
                                  10 gv1qak5fn39tk          10
                                  10 935y1fyshgm9v           0

20150427212400                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a          10
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212500                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0

20150427212600                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v          10

20150427212700                    10 a1xgxtssv5rrp           0
                                  10 cyz7q9n00p23a           0
                                  10 d0v9kqgaysm5j           0
                                  10 gv1qak5fn39tk           0
                                  10 935y1fyshgm9v           0


50 lignes sélectionnées.

Certes il fallait y réfléchir un peu plus d’une demi seconde mais …

C’était pourtant pas si compliqué.

Ca reste pourtant très perfectible. On va la remettre sur le métier, histoire que ça ne soit pas du vite-fait mal-fait. Suite dans un prochain épisode.

Générer un horodatage régulier

Problématique : on veut générer une suite de dates (surtout les heures, minutes et secondes) depuis en SQL pur

-- nombre de secondes
var nbsec number

-- nombre de valeurs souhaitées 
var nbVals number

-- On veut les 15 premiers multiples de 19 secondes
exec :nbsec := 19
exec :nbVals := 15 

-- La requête
select  to_char( trunc(sysdate-1) 
               + ( rownum/ ( 60 *60 *24 ) ) * :nbsec  
               , 'HH24:MI:SS' ) dt 
from dual
connect by rownum <= :nbVals ; 

Résultat

DT
--------
00:00:19
00:00:38
00:00:57
00:01:16
00:01:35
00:01:54
00:02:13
00:02:32
00:02:51
00:03:10
00:03:29
00:03:48
00:04:07
00:04:26
00:04:45

15 lignes sélectionnées.

C’était pourtant pas si compliqué.

Trouver les informations basiques d’une base Oracle à laquelle on est connecté

La requête

SELECT SYS.UTL_INADDR.get_host_address      IP_ADDR
     , SYS.UTL_INADDR.get_host_name         HOSTNAME
     , SYS.DBMS_UTILITY.CURRENT_INSTANCE    INST#
     , SYS.DBMS_UTILITY.port_string         OS
     , platform_id
     , platform_name
     , name
     , DB_UNIQUE_NAME
     , DBID
     , current_scn
     , decode ( parallel, 'YES', 'RAC', 'NOT RAC') IS_RAC
from v$database natural join v$instance;

Le résultat (splitté pour une meilleure lecture)

IP_ADDR                      HOSTNAME     INST# OS                   
---------------------------- ------------ ----- -------------------- 
fe80::4b5:7ff9:2cca:6ca8%3   ALPHAORIOJO      1 IBMPC/WIN_NT64-9.1.0 

PLATFORM_ID PLATFORM_NAME                  NAME       DB_UNIQUE_NAME 
----------- ------------------------------ ---------- -------------- 
         12 Microsoft Windows x86 64-bit   OJOTST     ojotst     

        DBID CURRENT_SCN IS_RAC
------------ ----------- --------
  2831882428     8207733 NOT RAC

C’était pourtant pas si compliqué !

SQLPlus l(e seul)’outil qu’il vous faut pour administrer vos bases de données Oracle

Cet article est repris d’un ancien blog et fusionné avec un autre

SQLPlus est l’outil incontournable du DBA Oracle. Même si beaucoup n’utilisent que des interfaces graphiques, il arrive un moment ou un autre où il doit se connecter à une machine qui ne propose pas cette commodité et dès lors, l’outil basique, livré avec le moteur, devient un passage obligé voire incontournable ou presque.

Je liste ici quelques trucs, astuces, commandes qui permettent d’utiliser SQLPlus de manière sympathique et sans trop de prise de tête.

(suite…)

sql2csv ou comment générer un fichier csv depuis SQL*PLUS

La question revient souvent sur les forums : comment produire un fichier csv depuis SQL*Plus

Une solution a été donnée sur le forum Developpez.net, elle est copiée ici dans une version un peu remaniée et très légèrement plus générique

L’appel est simple depuis sqlplus: @sql2csv <nom du fichier contenant la(les) requête(s) à exporter en csv>

-- merci à skuatamad (http://www.developpez.net/forums/u253956/skuatamad/)
  --
  -- 1 paramètre : le nom du script sql à exécuter
  -- En sortie un fichier CSV
  --
  
  store set settings_sqlplus replace
  
  set echo off
  set feedback off
  set linesize 32767
  set pages 0 emb on newp none
  set sqlprompt ''
  set trimspool on
  set long 9999999
  set longc 9999999
  set colsep ';'
  set heading on
  set recsep off
  set headsep on
  set underline off
  
  spool &&1..csv
  @&&1
  spool off
  
  undef 1
  @settings_sqlplus

Par exemple avec cette requête sql stockée dans le fichier sessions.sql :

select sid
     , serial#
     , process
     , sql_id
     , last_call_et
     , status
  from v$session ;
 

On obtient génère le fichier csv de la manière suivante:

SQL> @sessions

       SID    SERIAL# PROCESS      SQL_ID        LAST_CALL_ET STATUS
---------- ---------- ------------ ------------- ------------ --------
       146         10 4312         4gd6b1r53yt88        60116 ACTIVE
       151          2 4308                              60116 ACTIVE
       157          7 3836                              60126 ACTIVE
       159         46 6640:5200    g8730nuf9c1xf            0 ACTIVE
       160          1 3796                              60133 ACTIVE
       161          1 3792         4gd6b1r53yt88        60133 ACTIVE
       162          1 3788                              60133 ACTIVE
       163          1 3784                              60133 ACTIVE
       164          1 3780                              60133 ACTIVE
       165          1 3776                              60133 ACTIVE
       166          1 3772                              60133 ACTIVE
       
       SID    SERIAL# PROCESS      SQL_ID        LAST_CALL_ET STATUS
---------- ---------- ------------ ------------- ------------ --------
       167          1 3768                              60133 ACTIVE
       168          1 3764                              60133 ACTIVE
       169          1 3760                              60133 ACTIVE
       170          1 3756                              60133 ACTIVE
       
15 rows selected.

SQL> @sql2csv sessions
Wrote file settings_sqlplus
       SID;   SERIAL#;PROCESS     ;SQL_ID       ;LAST_CALL_ET;STATUS
       146;        10;4312        ;4gd6b1r53yt88;       60140;ACTIVE
       151;         2;4308        ;             ;       60140;ACTIVE
       157;         7;3836        ;             ;       60150;ACTIVE
       159;        46;6640:5200   ;g8730nuf9c1xf;           0;ACTIVE
       160;         1;3796        ;             ;       60157;ACTIVE
       161;         1;3792        ;4gd6b1r53yt88;       60157;ACTIVE
       162;         1;3788        ;             ;       60157;ACTIVE
       163;         1;3784        ;             ;       60157;ACTIVE
       164;         1;3780        ;             ;       60157;ACTIVE
       165;         1;3776        ;             ;       60157;ACTIVE
       166;         1;3772        ;             ;       60157;ACTIVE
       167;         1;3768        ;             ;       60157;ACTIVE
       168;         1;3764        ;             ;       60157;ACTIVE
       169;         1;3760        ;             ;       60157;ACTIVE
       170;         1;3756        ;             ;       60157;ACTIVE
       
SQL> ho type sessions.csv
       SID;   SERIAL#;PROCESS     ;SQL_ID       ;LAST_CALL_ET;STATUS
       146;        10;4312        ;4gd6b1r53yt88;       60140;ACTIVE
       151;         2;4308        ;             ;       60140;ACTIVE
       157;         7;3836        ;             ;       60150;ACTIVE
       159;        46;6640:5200   ;g8730nuf9c1xf;           0;ACTIVE
       160;         1;3796        ;             ;       60157;ACTIVE
       161;         1;3792        ;4gd6b1r53yt88;       60157;ACTIVE
       162;         1;3788        ;             ;       60157;ACTIVE
       163;         1;3784        ;             ;       60157;ACTIVE
       164;         1;3780        ;             ;       60157;ACTIVE
       165;         1;3776        ;             ;       60157;ACTIVE
       166;         1;3772        ;             ;       60157;ACTIVE
       167;         1;3768        ;             ;       60157;ACTIVE
       168;         1;3764        ;             ;       60157;ACTIVE
       169;         1;3760        ;             ;       60157;ACTIVE
       170;         1;3756        ;             ;       60157;ACTIVE

Convenons-en c’est dune laideur absolue même si dans bien des cas ça suffit.

La version 12 apporte à sqlplus l’option CSV à “SET MARKUP” qui a pour effet de créer un fichier CSV normalisé

set markup csv on delim ";"
 
select OWNER,TABLE_NAME,TABLESPACE_NAME,STATUS,LAST_ANALYZED from all_tables where rownum &lt; 11 ;
 
"OWNER";"TABLE_NAME";"TABLESPACE_NAME";"STATUS";"LAST_ANALYZED"
"SYS";"DUAL";"SYSTEM";"VALID";"24-FEB-21"
"SYS";"SYSTEM_PRIVILEGE_MAP";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"TABLE_PRIVILEGE_MAP";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"USER_PRIVILEGE_MAP";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"STMT_AUDIT_OPTION_MAP";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"AV_DUAL";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"WRR$_REPLAY_CALL_FILTER";"SYSAUX";"VALID";"24-JAN-21"
"SYS";"SCHEDULER_FILEWATCHER_QT";"SYSTEM";"VALID";
"SYS";"HS_BULKLOAD_VIEW_OBJ";"SYSTEM";"VALID";"24-JAN-21"
"SYS";"HS$_PARALLEL_METADATA";"SYSTEM";"VALID";"24-JAN-21"
 
10 rows selected.

Mieux non ?

Scripter en perl sous Oracle

Pearl sous Oracle Server RDBMS

Depuis quelques temps Oracle livre avec ses clients et serveurs RDBMS sont livrés avec perl, pas dans une version récente certes mais qui permet de se connecter à la base et de travailler avec. Avec cette nouveauté, l’avantage est de pouvoir développer des scripts portables et léger pour l’administration des bases et pour un reporting minimal sans passer par de très (trop ?) lourdes et inutiles machines virtuelles (fin de troll … saurez-vous en repérer le début ?). Dans cet article, on donnera les quelques trucs minimaux pour se connecter à une base oracle et travailler avec.

Avertissement

Cet article n’a pas pour but de vous apprendre perl que vous connaissez déjà (non ?) mais bien se remémorer les quelques trucs utiles pour développer rapidement des scripts d’administration portables de windows vers unix en passant par linux et VMS !!!

Au fait, ça existe encore VMS ?

Environnement et bibliothèques perl

Perl est livré dans le répertoir perl de l’ORACLE_HOME, la localistion précise des binaires qui lui sont liés dépendent de l’OS et de la version d’Oracle RDBMS. Par exemple :

  • En version 10.2.0.3 sous windows 2008R2 64bits : %ORACLE_HOME%/perl/bin
  • En version 11.1.0.6 sous windows vista SP2 32bits : %ORACLE_HOME%/perl/5.8.3/bin/MSWin32-x86-multi-thread
  • En version 11.2.0.2 sous AIX 5.3 64bits : %ORACLE_HOME%/perl/bin

Sur les environnements de type UNIX il faut aussi positionner la variable d’environnement PERL5LIB (comme un PATH, par exemple pour AIX 64 bits et oracle 11.2.0.2 PERL5LIB=$ORACLE_HOME/perl/libsite_perl/5.10.0/aix-thread-multi-64all/:$ORACLE_HOME/perl/lib/5.10.0/ ).

Deux bibliothèques nécessaires à la connexion DBI et DBD::ORACLE. Exemples de connexions :

use DBI;

my $cnx;
my $c_usr  = "system";
my $c_pass = "amanger";

$cnx = DBI->connect( "dbi:Oracle:$ENV{ORACLE_SID}", "$c_usr", "$c_pass"
                   , { AutoCommit => 0, PrintError => 0} ) 
        or die PError ("Connexion impossiblen") ;

[TRAITEMENTS]
        
$cnx->disconnect() ;

ou pour une connexion as sysdba :

use DBI;
use DBD::Oracle qw(:ora_session_modes);

my $cnx;
my $c_usr  = "sys";
my $c_pass = "c_o_i";

$cnx = DBI->connect( "dbi:Oracle:$ENV{ORACLE_SID}", "$c_usr", "$c_pass"
                   , { AutoCommit => 0, PrintError => 0,  ora_session_mode => ORA_SYSDBA } ) 
        or die PError ("Connexion impossiblen") ;

[TRAITEMENTS]
        
$cnx->disconnect() ;

Exécuter une requête avec perl

On suppose qu’on dispose d’une connexion dans la variable $cnx.

Une ligne retournée

my $v_sql="select DBID
     , DB_UNIQUE_NAME
     , HOST_NAME
     , STATUS
     , INSTANCE_ROLE
from sys.v_$instance, sys.v_$database";

my $qry = $cnx->prepare($v_sql);
$qry->execute();
my ($dbid, $dbun, $db_hostname, $db_status, $db_role) = $qry->fetchrow_array();
$qry->finish();

Plusieur lignes retournées

my $v_sql="select * 
from sys.dba_objects";

my $qry = $cnx->prepare($v_sql);
$qry->execute();
my @t_objs = $qry->fetchrow_array();
$qry->finish();

Utilisation de bind variables

Notez l’utilisation de DBD ora_types …

use DBD::Oracle qw(:ora_types);

my $v_sql="select * 
from sys.dba_hist_snapshots where snap_id between :deb and :fin ";

my $qry = $cnx->prepare($v_sql);

$qry->bind_param( ":deb" , 1234  , { ora_type => ORA_NUMBER } )  ;
$qry->bind_param( ":fin" , 1256  , { ora_type => ORA_NUMBER } )  ;

$qry->execute();
my @t_snid = $qry->fetchrow_array();
$qry->finish();

Gérer les sorties oracle de type longs

$cnx->{LongReadLen} = 512*1024;
$cnx->{LongTruncOk} = 1;

my $v_sql="select sqlid, sql_fulltext from sys.v_$v_sql";

my $qry = $cnx->prepare($v_sql);
$qry->execute();
my @t_sqlt = $qry->fetchrow_array();
$qry->finish();

PL/SQL

Exécuter une procédure

my $v_sql="begin
 for c in (select lolo, lulu from toto)
 loop
  insert into tutu values (c.lulu, c.toto);
 end loop;
 commit;
end;";

my $qry = $cnx->prepare($v_sql);
$qry->execute();
$qry->finish();

Exécuter une procédure avec des bind variables

my $baz;
my $v_sql="begin foo.barr(:baz); end;";

my $qry = $cnx->prepare($v_sql);
$qry->bind_param_inout(":baz", $baz,400);

$qry->execute();
$qry->finish();

Récupérer la sortie de type dbms_output d’une procédure

$dbh->func( 1000000, 'dbms_output_enable' );

my $baz;
my $v_sql="begin foo.barr(); end;";

my $qry = $cnx->prepare($v_sql);
my $sortie_dbms = $cnx->func( 'dbms_output_get' );

$qry->execute();
$qry->finish();

Ce sont là les fonctionnalités perl liées à la base dont je me sers le plus. Plus d’inforamtion sur le site CPAN notamment concernant le module DBI et le module DBD::Oracle.

Nombre de colonnes variable et PL/SQL

Ce que je veux faire

Dans mon post précédent, j’ai créé une fonction qui me permet d’afficher sous forme de tableau à deux dimensions diverses informations tirées d’une table. Nommée pompeusement transposition, le requête permet entre autres d’afficher en ligne ou en colonne, le topn sql_id consommateurs sur un wait event et leur évolution sur un certain nombre de clichés.

Maintenant, je voudrais exploiter ces données dans du code PL/SQL, j’ai donc besoin de créer du code qui saura s’adapter au nombre de colonnes remontées. Un premier code permet d’afficher les valeurs

declare
  requete  clob;
  nb_cols  number;
  tab_cols t_varchar;
  auto_plsql clob;
  ttext    varchar2(32767);
begin
  p_trsp('sql_id'                               
       , 'snap_id'
       , 'dba_hist_sqlstat'
       , 'EXECUTIONS_DELTA'
       , 'sys'
       , '834'
       , '840'
       , 18
       , 'yes'
       , requete
       , nb_cols
       , tab_cols);
  auto_plsql :='begin 
for c in (';
  dbms_lob.append(auto_plsql,requete);
  ttext:=')
loop 
dbms_output.put(to_char(c.snap_id)||'' '');
';
  dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  for i in 1..nb_cols
  loop
    ttext:='dbms_output.put(to_char(c.c_'||trim(to_char(i))||',''9999'')||'' '');
'; 
    dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  end loop;
  ttext:='dbms_output.put_line('' '');
end loop;
end;'; 
  dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  execute immediate auto_plsql;
end;
/

Ce dui donne :

834     0  1803  1730  1430  1024     0   414     0     0   339   312   298   269     0   318   213   209   256  
835  2085  1493  1316   905   952   723   291   714     0   229   234   233   232   241   184   187   181   161   
836  2068  1490  1308   862   944   720   291   708   708   229   228   228   228   241   175   184   180   134   
837  1962  1466  1265   870   892   712   292     0     0   228   228   228   228   237   170   181   176   133   
838  1644  1490  1096   700   732   718   291     0     0   229   231   231   231   241   175   184   172   132   
839  1909  1494  1275  1064   864   721   328   648   648   229   235   233   231   241   193   184   178   154   
840  2028  1490  1288   858   924   723   291     0   693   230   231   231   231   241   175   184   180   133   

Et si on limite topn à 4 (donc 4 colonnes + snap id) on obtient :

834     0  1803  1730  1430
835  2085  1493  1316   905
836  2068  1490  1308   862
837  1962  1466  1265   870
838  1644  1490  1096   700
839  1909  1494  1275  1064
840  2028  1490  1288   858

Et si on va un poil plus loin pour traiter le résultat des colonnes dans du PL/SQL …

CREATE OR REPLACE
PACKAGE OJO_RPT
AS
PROCEDURE report(
    debut IN varchar2,
    fin   IN varchar2,
    topn  IN NUMBER);
END OJO_RPT;
/

CREATE OR REPLACE
PACKAGE body OJO_RPT
AS
-- private proc
type t_varchar is table of varchar2(1000);

procedure p_trsp   ( lig   in varchar2         -- Colonne qui sera utilisee en tete de ligne 
         , col    in varchar2         -- Colonne qui sera utilisee en tete de colonne
         , ltab   in varchar2         -- Table source 
         , pivot  in varchar2         -- Colonne qui sera utilisee pour remplir le tabeau
         , owner  in varchar2         -- Proprietaire de la table
         , mini   in varchar2         -- Valeur minimale pour col
         , maxi   in varchar2         -- Valeur maximale pour col
         , topn   in number           -- Nombre de lig affichees ordonnes par cumul de pivot descendant
         , trsp  in varchar2 := 'No'  -- Transposition de la table (lig en tete de colonne et col en tete de ligne)
                  , req   out clob
                  , ncol  out number
                  , t_ncl out t_varchar ) is
 v_col    varchar2(32767);  
 v_where  varchar2(32767);  -- clause where pour mini et maxi
 v_wtopn  varchar2(1000);   -- clause where pour topn
 v_owner  varchar2(255);    
 c1  sys_refcursor;    
 v_poreq  varchar2(32767);  
  i               number;
begin
        t_ncl:=t_varchar();
 -- Gestion de la variable topn, si null on prend tout
 if topn is null
 then
   v_wtopn:=' ';
 else
   v_wtopn:=' where rownum <= '||topn;
 end if;

 -- Gestion de la variable owner, si null on prend ls schema appelant 
 if owner is null
 then 
  select sys_context('USERENV','CURRENT_SCHEMA') into v_owner from sys.dual;
 else
  v_owner:=owner;
 end if;
 
 -- Gestion des variables mini et maxi, si null on prend tout
 if ( mini is not null or maxi is not null )
 then
  v_where:=' where ';
  if mini is not null 
  then
   v_where:=v_where||col||' >
= '||mini ;
   if maxi is not null
   then
       v_where:=v_where||' and '||col||' <= '||maxi ;
   end if;
  else
      v_where:=v_where||col||' <= '||maxi ;
  end if;
 end if;
 
    -- Si on ne transpose pas lig et col  
 if upper(trsp) = 'NO'
 then
   req:='select * from (Select '||lig||' c_0
, sum('||pivot||') total ';
          i:=1;
   open c1 for 'select distinct to_char('||col||') from '||v_owner||'.'||ltab||v_where||' order by 1' ;
   loop
    fetch c1 into v_col;
    exit when c1%notfound;
    v_poreq:='
   , sum(decode(to_char('||col||'),'''||v_col||''','||pivot||',0)) c_'||trim(to_char(i)) ;
    dbms_lob.writeappend(req,length(v_poreq),v_poreq);
                  t_ncl.extend();
                  t_ncl(i):=trim(to_char(v_col));
                  i:=i+1;
   end loop;
          ncol:=c1%rowcount;
          close c1;
   v_poreq:='
from '||v_owner||'.'||ltab||v_where||'
group by '||lig||'
order by 2 desc)'||v_wtopn ;
   dbms_lob.writeappend(req,length(v_poreq),v_poreq);

    -- Si on transpose lig et col  
 else
   req:='Select '||col||' c_0';
          i:=1;
   open c1 for 'select ent from (select distinct to_char('||lig||') ent, sum('||pivot||') tot from '||v_owner||'.'||ltab||v_where||' group by to_char('||lig||') order by 2 desc)'||v_wtopn ;
   loop
     fetch c1 into v_col;
     exit when c1%notfound;
     v_poreq:='
   , sum(decode(to_char('||lig||'),'''||v_col||''','||pivot||',0)) c_'||trim(to_char(i)) ;
     dbms_lob.writeappend(req,length(v_poreq),v_poreq);
                          t_ncl.extend();
                          t_ncl(i):=trim(to_char(v_col));
                          i:=i+1;
   end loop;
          ncol:=c1%rowcount;
   close c1;
   v_poreq:='
from '||v_owner||'.'||ltab||v_where||'
group by '||col||'
order by 1 asc';
   dbms_lob.writeappend(req,length(v_poreq),v_poreq);
 end if;        
end p_trsp;

procedure trt( t in t_varchar ) is
  vt varchar2(32767);
  c  sys_refcursor;
begin
  open c for 'select * from table(t)';
  loop
    fetch c into vt;
    exit when c%notfound;
    dbms_output.put_line(vt);
  end loop;
end trt;


-- public proc
PROCEDURE report(
    debut IN varchar2,
    fin   IN varchar2,
    topn  IN NUMBER) is
  requete  clob;
  nb_cols  number;
  tab_cols t_varchar;
  auto_plsql clob;
  ttext varchar2(32767);
begin
  for c0 in (select column_name from dba_tab_columns where table_name='DBA_HIST_SQLSTAT' and owner='SYS' and column_name like '%DELTA')
  loop
  p_trsp('sql_id'                               
       , 'snap_id'
       , 'dba_hist_sqlstat'
       , c0.column_name
       , 'sys'
       , debut
       , fin
       , topn
       , 'no'
       , requete
       , nb_cols
       , tab_cols);
  auto_plsql :='begin 
for c in (';
  dbms_lob.append(auto_plsql,requete);
  ttext:=')
loop 
dbms_output.put(to_char(c.c_0)||'' '');
';
  dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  for i in 1..nb_cols
  loop
    ttext:='dbms_output.put(to_char(c.c_'||trim(to_char(i))||',''99999999'')||'' '');
'; 
    dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  end loop;
  ttext:='dbms_output.put_line('' '');
end loop;
end;'; 
  dbms_lob.writeappend(auto_plsql,length(ttext), ttext);
  dbms_output.put_line(c0.column_name);
  execute immediate auto_plsql;
  end loop;
end report;

END OJO_RPT;
/

Le résultat de cette requête étant une succession de tableaux, dont je donne ici les trois premiers :

FETCHES_DELTA
cm5vu20fhtnq1      6549      5494      5490      5401      5490      5497      5490
8t43xdhf4d9x2         0      2085      2068      1962      1644      1909      2028
0k8522rmdzg4k      1976      1604      1600      1575      1600      1606      1600
089dbukv1aanh      1730      1316      1308      1265      1096      1275      1288
aykvshm7zsabd         0         0      2640      2618         0         0         0
5ms6rbzdnq16t         0       723       720       712       718       721       723
83taa7kaw59c1      3587         0         0         0         0         0         0
5kyb5bvnu3s04       414       291       291       292       291       328       291
7qqnad1j615m7         0       714       708         0         0       648         0
5hfunyv38vwfp         0         0       708         0         0       648       693
END_OF_FETCH_COUNT_DELTA
8t43xdhf4d9x2         0      2085      2068      1962      1644      1909      2028
cm5vu20fhtnq1      1803      1493      1490      1466      1490      1494      1490
089dbukv1aanh      1730      1316      1308      1265      1096      1275      1288
8vwv6hx92ymmm      1430       905       862       870       700      1064       858
6v7n0y2bq89n8      1024       952       944       892       732       864       924
5ms6rbzdnq16t         0       723       720       712       718       721       723
5kyb5bvnu3s04       414       291       291       292       291       328       291
7qqnad1j615m7         0       714       708         0         0       648         0
5hfunyv38vwfp         0         0       708         0         0       648       693
43c5ykm1mcp2a       312       234       228       228       231       235       231
SORTS_DELTA
5ms6rbzdnq16t         0       723       720       712       718       721       723
fsbqktj5vw6n9       213       187       184       181       184       184       184
4jrfrtx4u6zcx         0       122       122       128       122       150       122
aykvshm7zsabd         0         0       360       357         0         0         0
db78fxqxwxt7r       447         0         0         0         0         0         0
btwkwwx56w4z6         0        60        60        59        60        60        60
75u022kdra1fz         0        60        60        59        60        60        60
7ng34ruy5awxq       338         0         0         0         0         0         0
grb1cf30q5r7m       314         0         0         0         0         0         0
gvt8zu1k1tsff         0       122         0         0         0       150         0