French

Dans cet article, nous allons vous montrer comment écrire un module Java permettant d’importer les descriptions des tables et des colonnes dans un schéma DB-MAIN. Les descriptions sont stockées dans un fichier CSV au format suivant :

"Nom table","nom colonne","description"

La description peut contenir des « , » ou des retours à la ligne. Si elle contient des « " », il faut les doubler.
Par exemple, si l'on veut ajouter le commentaire suivant à la table « BOOK » :

A book is any written "piece of work"
in the literary, scientific or technical domain.

Le fichier CSV sera le suivant :

BOOK,,"A book is any written ""piece of work""
in the literary, scientific or technical domain."

Le résultat dans DB-MAIN sera le suivant :

entity type DB-Main

Création du projet

L’article précédent de notre blog (Mon premier module Java pour DB-MAIN) décrivait comment créer un projet dans Eclipse. Pour ce nouveau projet, il faut créer une classe nommée « ImportDescription.java ». Le code source complet de la classe « ImportDescription » se trouve à l’adresse suivante.

Ce projet utilise deux fichiers .jar. Comme dans le premier projet, nous avons besoin de jidbm.jar (se trouvant dans le répertoire bin du répertoire d’installation de DB-MAIN) pour pouvoir accéder au référentiel de DB-MAIN. Nous avons également besoin de opencsv-3.9.jar (qui peut être téléchargé à l’url suivante).

Lecture du fichier CSV

« runDBM » est la méthode appelée par DB-MAIN. Elle ouvre la console (DBMConsole) pour afficher les messages, cherche le schéma courant (lib.getCurrentDBMSchema()) et demande le chemin d’accès du fichier CSV.

public class ImportDescription {
	private DBMSchema sch;

	/**
	 * Method called by DB-MAIN to import a CSV file to update the semantic description
	 * of the table and column of the current schema.
	 * 
	 * @throws IOException
	 */
	public static void runDBM () throws IOException{
		// Open the DB-MAIN console
		new DBMConsole();
		System.out.println("start");
		// Create the DBMLibrary instance
		DBMLibrary lib = new DBMLibrary();
		// Get the current schema
		DBMSchema sch = lib.getCurrentDBMSchema();
		if(sch == null){
			System.out.println("select a schema ");
			return;
		}
		// get the name of the CSV file
		JFileChooser fileChooser = new JFileChooser();
		fileChooser.setDialogTitle("DBD extractor - Select log file");
		FileNameExtensionFilter filter = new FileNameExtensionFilter(
				"csv (*.csv)", "csv");
		fileChooser.setFileFilter(filter);
		int res = fileChooser.showOpenDialog(null);

		if (res != JFileChooser.APPROVE_OPTION){
			return;
		}
		String filename = fileChooser.getSelectedFile().getPath();
		
		// read the csv file
		ImportDescription importDesc = new ImportDescription(sch);
		importDesc.readFile(filename);
		
		System.out.println("end");
	}

	public ImportDescription(DBMSchema sch) {
		this.sch = sch;
	}
}

La méthode « readFile() » effectue la lecture du fichier. Pour lire le fichier CSV, nous utilisons la librairie « opencsv » (http://opencsv.sourceforge.net/). Le constructeur « CSVReader(new FileReader(csvFile)) » prend comme argument le fichier CSV. Chaque ligne est lue dans un tableau de chaîne de caractères (String[]). Le premier élément (nextLine[0]) est le nom de la table, le second (nextLine[1]) le nom de la colonne et le troisième (nextLine[2]) la description.

/**
	 * Read a csv file ('csvFile') and update the description of the tables
 * and the columns of the schema
	 * The format of the csv file is "table name;column name;description"
	 * @param csvFile the path of the csv file
	 */
	private void readFile(String csvFile) {
		CSVReader reader;
		try {
			reader = new CSVReader(new FileReader(csvFile));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return;
		}
		// nextLine[] is an array of values from the line
		String [] nextLine;
		try {
			while ((nextLine = reader.readNext()) != null) {
				// the name of the table
				String tableName = nextLine[0];
				// the name of the column
				String columnName = nextLine[1];
				// the description
				String description = nextLine[2];
				updateDescription(tableName, columnName, description);
			}
			reader.close();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}   
	}
}

Chercher la table/colonne à modifier

La méthode « findDataObject() » recherche la table ou la colonne qu’il faut mettre à jour. Comme on peut le constater dans le schéma suivant, le concept de table (DBMEntityType) et celui de colonne (DBMAttribute) héritent de la même classe, à savoir DBMDataObject. La méthode « findDataObject() » va retourner un DBMDataObject qui sera soit un DBMEntityType si le nom de la colonne est vide, soit un DBMAttribute si le nom de la colonne existe.

La méthode « findEntityType() » retrouve un type d’entité (table) d’un schéma sur base de son nom. Si le nom de la colonne n’est pas vide, on utilise la méthode « findAttribute() » pour retrouver l’attribut appartenant au type d’entité.

schema

/**
	 * If 'columnName' is empty, return the table (DBMEntityType) named 'tableName'
	 * Otherwise, return the column (DBMSimpleAttributre) named 'tableName.columnName'
	 * @param tableName Name of a table
	 * @param columnName Name of a column of 'table'. Can be empty
	 * @return The table or the column named 'tableName.columnName'
	 */
	private DBMDataObject findDataObject(String tableName, String columnName) {
		// find the table named 'tableName'
		DBMEntityType table = sch.findEntityType(tableName);
		if(table == null){
			System.out.println("table (" + tableName + " not found");
			return null;
		}
		if(columnName.isEmpty()){
			return table;
		} else {
			// find the column of 'table' named 'columnName'
			DBMAttribute column = table.findAttribute(columnName);
			if(column == null){
				System.out.println("column (" + columnName + " not found");
				return null;
			}
			return column;
		}
	}

Modifier la description

Chaque objet du référentiel de DB-MAIN a des champs (par exemple name, type, length, semanticDescription). Chaque champ dispose d’un « getter » (par exemple, getName()) et d’un « setter » (par exemple, setName()). La plupart des objets disposent de deux descriptions, sémantique et technique. Dans notre exemple, nous allons mettre à jour la description sémantique.
« updateDescription » appelle « findDataObject » pour retrouver l’objet et mettre à jour sa description. Pour la description sémantique, la méthode « setSemanticDescription() » est utilisée.

/**
	 * if 'columnName' is empty, update the description of the table 'tableName'.
	 * Otherwise update the description of the column 'tableName.columnName' 
	 * @param tableName Name of a table
	 * @param columnName Name of a column of 'table'. Can be empty
	 * @param description A description
	 */
	private void updateDescription(String tableName, String columnName, String description) {
		DBMDataObject dataObject = findDataObject(tableName, columnName);
		if(dataObject != null){
			dataObject.setSemanticDescription(description);
		}
	}

Conclusion

Vous venez de créer un module Java pour DB-MAIN mettant à jour les descriptions des types d’entité et des attributs du schéma courant. 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).

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(s): 

Jean Henrard