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ésutat

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

La 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

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

Lister les tables X$ d’une version Oracle

Ce petit script PERL permet de lister les tables « X$ » du moteur … Ce qui ne dit pas ce qu’elles font

#!/usr/bin/perl -w

use strict;

#open O, ($ORACLE_HOME."/bin/oracle");
open O, ("/logiciels/oracle/ora_10.2.0/bin/oracle");
open F, (">x");

my $l;
my $p = ' ' x 40;
my %x;

while (read (O,$l,10000)) {
$l = $p.$l;

foreach ($l =~ /(x$w{3,})/g) {
$x{$_}++;
}

$p = substr ($l,-40);
}

foreach (sort keys %x) {
print F "$_n";
}

Ce script provient du site http://www.adp-gmbh.ch

On peut trouver certaines explications sur le contenu des tables « X$ » sur freeshell, sur le site BC Oracle Training ou en bien d’autres endroits 😉

La version 10 d’oracle en liste quelques 350 par exemple la table x$kwddef liste l’ensemble des mots clés du SQL, la requête suivante permet donc de les lister :

select KEYWORD from x$kwddef
order by KEYWORD
/

Citation

« The programmers didn’t like the idea at all because it deprived them of the intellectual excitement of not quite understanding what they were doing. They like the challenge of chasing the bugs. »

E. Dijkstra (Prix Turing)

Générer des rapports statspack

Petite procédure pour générer un nombre important de rapports statspack.

SET SERVEROUTPUT OFF
set feedback off

var delta number;
var date_fin varchar2(20);
begin
:delta:=&1;
-- :date_fin:=&2;
end;
/

create or replace procedure dba_all_reports( delta in number
, fin in varchar default to_char(sysdate, 'YYYYMMDDHH24MI') ) as
begin
for i in (select snap_id
, snap_next
, to_char(snap_time, 'MMDD_HH24MI') rpt_name
, instance_name
from (select s.SNAP_ID
, lead(s.SNAP_ID,1) over (order by s.SNAP_ID) SNAP_NEXT
, s.STARTUP_TIME
, lead(s.STARTUP_TIME, 1) over (order by s.SNAP_ID) STARTUP_NEXT
, s.SNAP_TIME
, i.INSTANCE_NAME
from stats$snapshot s, v$instance i)
where SNAP_NEXT=SNAP_ID+1
and STARTUP_TIME=STARTUP_NEXT
and snap_time between to_date(fin,'YYYYMMDDHH24MI')-delta and to_date(fin,'YYYYMMDDHH24MI') )
loop
DBMS_OUTPUT.ENABLE (32000);
dbms_output.put_line ('define begin_snap='||i.snap_id);
dbms_output.put_line ('define end_snap='||i.snap_next);
dbms_output.put_line ('define report_name='||i.instance_name||'_'||i.rpt_name);
dbms_output.put_line ('@?/rdbms/admin/spreport.sql');
end loop;
end;
/

SET SERVEROUTPUT ON
spool reports.sql
-- execute dba_all_reports(:delta, :date_fin)
execute dba_all_reports(:delta)
spool off

@reports.sql

drop procedure dba_all_reports;

Les rapports ainsi générés sont nommés <ORACLE_SID>_<MOIS><JOUR>_<HEURE><MINUTES>.lst

On peut décommenter les lignes

--  :date_fin:=&2;
et
-- execute dba_all_reports(:delta, :date_fin)

et supprimer la ligne

execute dba_all_reports(:delta)

de manière à générer des rapports anciens.