French

Introduction

Cet article va vous expliquer comment développer un programme Java exécutable à partir de DB-MAIN. Ce module va accéder au référentiel de DB-MAIN et générer un dictionnaire (au format CSV) contenant les informations sur toutes les propriétés des objets d’un schéma (voir exemple ci-dessous).

Pour ce faire, vous avez besoin d’installer Eclipse avec Java 1.8 et DB-MAIN sur votre ordinateur.

 

schema DB-Main

 

Création du projet Eclipse

Lancez Eclipse et allez dans le menu [New/Java project…]. Entrez un nom de projet (« Dictionary » dans notre exemple) et cliquez sur le bouton [Next].

new java project

Cliquez sur l’onglet [Libraries] et ajoutez la librairie jidbm.jar (se trouvant dans le répertoire bin du répertoire d’installation de DB-MAIN) en cliquant sur le bouton [Add external JAR…].

Java settings

Terminez la création de votre projet en cliquant sur le bouton [Finish].

Création du module Dictionary

Dans votre projet « Dictionary », allez sur le menu [New/Class] et introduisez le nom « DictionaryGeneration » comme nom de la classe.

Java class

Terminez la création de la classe en cliquant sur le bouton [Finish]. Le code source complet de la classe Dictionary se trouve à l’adresse : http://www.rever.eu/db-main/files/Dictionary.java.

Editez la classe DictionaryGeneration et créez la méthode « runDBM() » (ci-dessous). Il s’agit de la méthode appelée par DB-MAIN lorsqu’on exécute un module Java. Si cette méthode n’est pas dans le programme, l’exécution s’arrêtera. Le code correspondant est :

public class Dictionary {
  private static PrintWriter fw = null;
  /**
   * Method called by DB-MAIN to generate a CSV file containing an attribute
   * dictionary of current schema.
   * 
   * @throws IOException
   */
  public static void runDBM() throws IOException {
    // Open the DB-MAIN console
    new DBMConsole();
    // Create the DBMLibrary instance
    DBMLibrary lib = new DBMLibrary();
    // Get the current schema
    DBMSchema sch = lib.getCurrentDBMSchema();
    if (sch == null) {
      System.out.println("Error: Select a schema before.");
      return;
    } else {
      // Create a new CSV file
      JFileChooser fc = new JFileChooser("");
      int rVal = fc.showSaveDialog(null);
      if (rVal == JFileChooser.APPROVE_OPTION) {
        try {
          fw = new PrintWriter(fc.getSelectedFile());
        } catch (Exception wri) {
          System.out.println("Error: Impossible to write in the file "
              + fc.getSelectedFile().getName() + ".");
          return;
        }
      } else {
        return;
      }
      // Write labels of columns in the CSV file
      fw.println(
          "Owner,Attribute,Cardinalities,Type,Lenght,Decimal number");
      // For each entity type of the current schema, displays its
      // attributes
      DBMEntityType ent = sch.getFirstDataObjectEntityType();
      while (ent != null) {
        displayEntity(ent);
        ent = sch.getNextDataObjectEntityType(ent);
      }
      // Close the CSV file
      fw.close();
    }
  }
}

L’instruction « new DBMConsole(); » permet d’ouvrir une console dans laquelle seront affichés les différents messages (System.out.println(...)). L’instruction « DBMSchema sch = lib.getCurrentDBMSchema() » retourne le schéma courant (celui qui est visible dans DB-MAIN).

Pour mieux comprendre comment parcourir le référentiel DB-MAIN, voici la partie qui nous intéresse pour écrire le module :

schema

Un schéma est composé d’objets données (« DBMDataObject ») dont :

  • des types d’entité (« DBMEntityType »)
  • des types d’association (« DBMRelationshipType »)
  • des attributs simples (« DBMSimpleAttribute »)
  • et des attributs décomposables (attributs décomposés en sous-attributs, « DBMCompoundAttribute »).

Pour parcourir les types d’entité d’un schéma, il faut utiliser les méthodes « getFirstDataObjectEntityType » (qui donne le premier type d’entité du schéma) et « getNextDataObjectEntityType » (qui donne le type d’entité suivant d’un type d’entité donné).

Pour compiler le code de la méthode « runDBM », il faut créer la méthode « displayEntity » prenant comme argument le type d’entité courant. Voici le code correspondant :

  /**
   * Method that for a given entity type browse all these attributes.
   * 
   * @param ent
   *            entity type to be processed
   */
  private static void displayEntity(DBMEntityType ent) {
    // Print the entity type name in console
    System.out.println("Entity type: " + ent.getName());
    // For each attribute, displays its properies
    DBMAttribute att = ent.getFirstAttribute();
    while (att != null) {
      displayAttribute(att, "", ent);
      att = ent.getNextAttribute(att);
    }
  }

Cette méthode parcourt les attributs d’un type d’entité pour afficher leurs propriétés. Elle utilise la méthode « displayAttribute » prenant comme argument l’attribut courant, un préfixe pour l’affichage de son nom et son propriétaire. Le code de cette nouvelle méthode est :

  /**
   * Method that for a given attribute displays these properties and browse
   * its sub-attributes if it is a compound attribute.
   * 
   * @param att
   *            attribute to be processed
   * @param prefix
   *            prefix of attribute name
   * @param ent
   *            owner of attribute att
   */
  private static void displayAttribute(DBMAttribute att, String prefix,
      DBMEntityType ent) {
    // Write attribute owner name, its name with prefix and its
    // cardinalities in CSV file
    fw.print(ent.getName() + "," + prefix + att.getName() + ","
        + att.getMinimumCardinality() + "-"
        + att.getMaximumCardinality());
    if (att.isSimpleAttribute()) {// Simple attribute
      // Write simple attribute name in console
      System.out.println("Simple attribute: " + att.getName());
      // Write simple attribute type, lenght and number of decimals in CSV
      // file
      DBMSimpleAttribute siatt = (DBMSimpleAttribute) att;
      fw.println("," + siatt.getTypeName() + "," + siatt.getLength() + ","
          + siatt.getDecimalNumber());
    } else {
      // Write coumpound attribute type
      fw.println(",COMP_ATT");
      // Display sub-attributes of compound attribute
      displayCompoundAttribute((DBMCompoundAttribute) att, prefix, ent);
    }
  }

Il existe deux types d’attributs : les attributs simples (« DBMSimpleAttribute ») et les attributs décomposables (« DBMCompoundAttribute ») qui possèdent à leur tour des attributs simples ou décomposables. La méthode « displayAttribute » écrit les propriétés communes aux attributs dans le fichier CSV et teste ensuite le type de l’attribut. Si c’est un attribut simple, on écrit les propriétés spécifiques à ce type d’attribut dans le fichier CSV, sinon, dans le cas d’un attribut décomposable, on parcourt ces sous-attributs pour les afficher dans le fichier CSV. Le code de la méthode « displayCompoundAttribute » est :

  /**
   * Method that, for a given compound attribute, browses its sub-attributes.
   * 
   * @param coatt
   *            compound attribute to be processed
   * @param prefix
   *            prefix used for sub-attributes
   * @param ent
   *            owner of coatt
   */
  private static void displayCompoundAttribute(DBMCompoundAttribute coatt,
      String prefix, DBMEntityType ent) {
    // Write compound attribute name in console
    System.out.println("Compound attribute: " + coatt.getName());
    // For each sub-attributes of coatt, display their properties
    DBMAttribute att = coatt.getFirstAttribute();
    while (att != null) {
      displayAttribute(att, prefix + coatt.getName() + ".", ent);
      att = coatt.getNextAttribute(att);
    }
  }

Pour chaque attribut de l’attribut décomposable, on refait appel à la méthode qui affiche les propriétés des attributs dans le fichier CSV.

L’encodage du programme Java est maintenant terminé.

Exécution du module

Pour tester le programme Java, il faut lancer DB-MAIN. Dans la boîte « About », cliquez sur le bouton [Library (Demo project)].

DB-Main launch box

Double-cliquez sur le schéma « Library/Conceptual] pour l’ouvrir (et ainsi le rendre courant). Pour exécuter le programme Java, allez dans le menu [File/Execute plugin…] et ouvrez le fichier « Dictionary.class » qui se trouve dans le répertoire « bin » de votre projet « Dictionary ».

DB-Main library

La console DB-MAIN va s’ouvrir avec la boîte pour créer le fichier CSV. Donnez un nom de fichier et cliquez sur le bouton « OK ». Le programme Java va écrire les informations de déboguage dans la console et créer votre fichier CSV avec la liste de tous les attributs du schéma courant ainsi que leurs propriétés.

DB-Main java console

Conclusion

Vous venez de créer votre premier module Java pour DB-MAIN. Immédiatement, les possibilités d’extension de votre outil de modélisation préféré vous viennent à l’esprit.

Pour vous aider dans le développement d’autres modules, vous pouvez consulter le manuel de référence de la JIDBM (« JIDBM-reference-manual.pdf ») et sa Javadoc (« JIDBM-javadoc ») distribués avec DB-MAIN (soit dans le menu [Démarrer/DB-MAIN…] sous Windows, soit dans le répertoire « doc » du répertoire d’installation de DB-MAIN sous Linux).

Dans le répertoire plugins de la distribution de DB-MAIN, il y a également deux modules Java avec leur code source. Il s’agit de :

« SQLGenerator.java » (répertoire « sql ») : générateur simplifié de scripts SQL de création de bases de données.

« StatisticGenerator.java » (répertoire « statistic ») : générateur simplifié de statistiques de schémas.

Vous pouvez essayer et modifier ces deux modules pour les adapter à vos besoins.

Si vous avez des questions sur cet article ou, plus généralement, sur DB-MAIN, contactez-nous via le formulaire de contact ou le forum.

Mots clés: 

Auteur: 

Jean Henrard, Jean-Marc Hick