SDB est un outil permettant de manipuler, à travers un intepréteur Perl inclus, les informations d'une base Rdb.
Il permet, en particulier, de manipuler sa description physique, les différentes analyses, etc...
Il est utilisé, à titre d'exemple, pour générer de façon automatique des rapports d'analyses, des scripts de réorganisation prenant en compte le taux de remplissage des différentes aires, etc...

Attention : Vous devez installer PERL pour pouvoir utiliser SDB.

                        sdb.zip        sdb_perl_script.zip

Exemple :

$ r sdb
Nov 17 1999 13:35:33, jfp@altavista.net
SDB> att mabase
SDB> load
SDB> do root.pl
--------------Info base-------------------------
Version de Rdb : Oracle Rdb V7.0-31
Base DISK$RDB:[DIR]MABASE.RDB;1 : 4 aires.
  Pas de journalisation
  10 slots d'aires et 10 slots d'aij libres
  250 buffers globaux de 12 blocks, 20 par utilisateur avec un max de 5
  50 connexions simultanées sur 2 noeuds au maximum
  Ecriture asynchrone activé
    5 buffers non modifiés au minimum,
    4 buffers écrits simultanément au maximum
  Optimisation backup incrémental activée
  4 aires uniformes.
  3 aires ont été étendues, toutes uniformes.
  Tailles total : 704 Mo
    Aires : 703 Mo
    Snap  : 1 Mo
  4603781 lignes dans 155 tables représentant 1043 Mo de données.
  214 index btree.
----------------Aires étendues--------------------------
UAREA01T uniforme, 29997 Pages d'extension (16 %)
RDB$SYSTEM uniforme, 918 Pages d'extension (20 %)
AREA_DEFAULT uniforme, 555 Pages d'extension (44 %)
----------------Snap étendues--------------------------
SDB>  Exit
$
$ ty root.pl
use strict;

#  Database : $Sdb::Database

sub round ($) {
  my $n = shift;

# "%.0f" effectue l'arrondi
  return sprintf "%.0f", $n;
}

sub showDatabase() {
  my $db = $Sdb::Database;

  my $areas = $db->allAreas();

  print "--------------Info base-------------------------\n";
  print "Version de Rdb : ${ \$db->version() } \n";
  print "Base ${ \$db->dbName() } : ";
  if ($db->mfdb()) {
      print "${ \$db->stoAreaCount() } aires.";
  } else {
      print "mono-fichier";
  }
  print "\n";

  if ($db->aijEnabled()) {
      print "  AIJ actif";
      if ($db->aijCount() == 1) {
      print " journal extensible";
      } else {
          print " ${ \$db->aijCount() } journaux";
      }
  } else {
    print "  Pas de journalisation";
  }
  print "\n";

  print "  ${ \$db->stoAreaFree() } slot";
  print "s" if ($db->stoAreaFree() > 1);
  print " d'aires et ${ \$db->aijFree() } slot";
  print "s" if ($db->aijFree() > 1);
  print " d'aij libres";
  print "\n";

  print "  Buffers de la base mappe sur l'espace systeme\n"
        if ($db->memoryMapping());

  if ($db->gbEnabled()) {
      print "  ${ \$db->gbNumBuff() } buffers globaux de ${ \$db->bufferSize() }
";
      print " blocks, ${ \$db->numberBuffers() } par utilisateur avec un max de ";
      print "${ \$db->gbNumPerUser() }";
      print ", \n    transfert optimisé des pages" if ($db->gbTransfer());
  } else {
      print "  ${ \$db->numberBuffers() } buffers de ";
      print "${ \$db->bufferSize() } blocs\n";
  }
  print "\n";

  print "  ${ \$db->numberUsers() } connexions simultanées sur ";
  print "${ \$db->numberNodes() } noeud";
  print "s" if ($db->numberNodes() > 1);
  print " au maximum\n";

  if (! $db->snpEnabled()) {
      print "  Snapshot désactivé\n";
  } elsif ($db->snpDeferred()) {
     print "  Snapshot differé\n";
  }

  print "  Index system décompressés\n" if (! $db->idxCompression());

  print "  Collection des statistiques désactivée\n"
        if (! $db->statistics());

  if ($db->fcChkptEnabled()) {
      print "  Fast commit activé (${ \$db->fcChkptInterval() } blocs, ";
      print $db->fcChkptTime() . " s";
      if ($db->fcCommitToJrnl()) {
          print ", CTJ activé ${ \$db->fcTsnInterval() } transactions";
      }
      print ")\n";
  }

  if (! $db->dAsynchPrefetch()) {
      print "  Prefetch asynchrone dynamique désactivé\n";
  } elsif (($db->dapfDepth() != 4) || ($db->dapfThreshold() != 4)) {
      print "Prefetch dynamique asynchrone activé avec une profondeur de ";
      print "${ \$db->dapfDepth() } buffers et un seuil de ";
      print "${ \$db->dapfThreshold() } pages\n";
  }

  if (! $db->asynchBatchwrite()) {
     print "  Ecriture asynchrone désactivé\n";
  } elsif ($db->abwMaxBuffers() || ($db->abwCleanBuffers() != 5)) {
     print "  Ecriture asynchrone activé\n    ${ \$db->abwCleanBuffers() }";
     print " buffers non modifiés au minimum,\n    ${ \$db->abwMaxBuffers() }";
     print " buffers écrits simultanément au maximum\n";
  }

  print "  Carry-over lock désactivé\n" unless ($db->lckoptEnabled());

  print "  Optimisation backup incrémental ";
  if ($db->incrBackup()) {print "activée";} else {print "désactivée";};
  print "\n";

  if (! $db->algCount()) {
      print "  ALG désactivé\n";
  } elsif ($db->algCount() != 3) {
      print "  ${ \$db->algCount() }  niveaux de locking\n";
  }

  print "  ${ \$db->lockTimeout() } s d'attente maximum sur lock\n"
        if ($db->lockTimeout());

  print "  ${ \$db->uniformAreaCount() } aires uniformes";
  if ($db->mixedAreaCount()) {
      print ", ${ \$db->mixedAreaCount() } aires mixtes.";
  } else {
      print ".";
  }
  print "\n";

  if ($db->areaExtendedCount()) {
      print "  ${ \$db->areaExtendedCount() }";
      if ($db->areaExtendedCount() > 1) {
          print " aires ont été étendues";
      } else {
          print " aire a été étendue";
      }
      if (($db->areaExtendedCount() == 1) &&
          ($db->mixedAreaExtendedCount() == 1)) {
          print ", aire mixte";
      } elsif ($db->mixedAreaExtendedCount()) {
          print ", dont ${ \$db->mixedAreaExtendedCount() } mixte";
          print "s" if ($db->mixedAreaExtendedCount() > 1);
      } elsif ($db->areaExtendedCount() == 1) {
          print ", aire uniforme";
      } else {
          print ", toutes uniformes";
      }
      print ".";
  }
  print "\n";

  print "  Tailles total : ${ \($db->areaMo() + $db->snapMo() + $db->aijMo()) } Mo\n";
  print "    Aires : ${ \$db->areaMo() } Mo\n";
  print "    Snap  : ${ \$db->snapMo() } Mo\n";
  print "    Aij   : ${ \$db->aijMo() } Mo\n" if ($db->aijCount());

  print "  ${ \$db->rowCount() } lignes dans ${ \$db->tableCount() }";
  print " tables représentant ${ \$db->dataVolumeMo() } Mo de données.";
  print "\n";

  print "  ${ \$db->indexCount() } index ";
  if (! $db->hashCount()) {
      print "btree.";
  } elsif (! $db->btreeCount()) {
      print "hash.";
  } else {
      print "(${ \$db->hashCount() } hash, ${ \$db->btreeCount() } btree).";
  }
  print "\n";

  my @sort1 = sort { ($b->allocationMax() - $b->allocation()) <=>
                     ($a->allocationMax() - $a->allocation()) }
                   @$areas;

  print "----------------Aires étendues--------------------------\n";
  foreach (@sort1) {
      if ($_->areaExtended()) {
          print $_->areaName();
          if ($_->areaType()) {
              print " mixte";
          } else {
              print " uniforme";
          }
          print ", ${ \( $_->allocationMax() -  $_->allocation()) }";
          print " Pages d'extension (";
          print "${ \( round(100 * (($_->allocationMax() / $_->allocation() - 1)))) }";
          print " %)\n";
      }
  }

  my @sort1 = sort { ($b->snpAllocMax() - $b->snpAllocation()) <=>
                     ($a->snpAllocMax() - $a->snpAllocation()) }
                   @$areas;

  print "----------------Snap étendues--------------------------\n";
  foreach (@sort1) {
      if ($_->snapExtended()) {
          print $_->areaName();
          if ($_->areaType()) {
              print " mixte";
          } else {
              print " uniforme";
          }
          print ", ${ \( $_->snpAllocMax() -  $_->snpAllocation()) }";
          print " Pages d'extension (";
          print "${ \( round(100 * ($_->snpAllocMax() / $_->snpAllocation() - 1))) }";
          print " %)\n";
      }
  }

}

open (SdbOutput, '>' . $Sdb::OutputFileName) or
        die "Impossible d'ouvrir le fichier $Sdb::OutputFileName\n";
my $prevOutput = select SdbOutput;

showDatabase();

select $prevOutput;
close SdbOutput;
$