SQL DOCUMENTATION GENERATOR - PARTE V

Siamo arrivati alla parte "succulenta" del progetto e finalmente possiamo andare ad analizzare ogni riga del nostro codice Java riguardo il progetto SqlDocGenerator.

package org.dgl.sqldocgen;

import java.sql.ResultSet;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import org.dgl.manager.DBManager;
import org.dgl.manager.LogManager;
import org.dgl.sqldocgen.db.StoredProcedure;
import org.dgl.sqldocgen.db.Table;
import org.dgl.sqldocgen.db.TableColumn;
import org.dgl.sqldocgen.db.TableTrigger;
import org.dgl.sqldocgen.db.View;
import org.dgl.sqldocgen.gui.ProgressionFrame;

public class SqlDocGenerator {

    private DBManager databaseManager;
    private ArrayList tables;
    private ArrayList storedProcedures;
    private ArrayList views;
    private ProgressionFrame progressionFrame;

    public SqlDocGenerator(SqlConfiguration sqlConfiguration) throws Exception {
        this(Util.createDBManagerFromSQLConfiguration(sqlConfiguration));
    }

    public SqlDocGenerator(DBManager databaseManager) throws Exception {
        this.databaseManager = databaseManager;
        tables = new ArrayList<>();
        storedProcedures = new ArrayList<>();
        views = new ArrayList<>();
    }

    public void read(){
        try {
            progressionFrame = new ProgressionFrame();
            progressionFrame.setText("PROGRESSIONFRAME_LOADINGTABLES");
            progressionFrame.setValue(25);
            readTables();
            progressionFrame.setText("PROGRESSIONFRAME_LOADINGVIEWS");
            progressionFrame.setValue(50);
            readViews();
            progressionFrame.setText("PROGRESSIONFRAME_LOADINGSTOREDPROCEDURES");
            progressionFrame.setValue(75);
            readStoredProcedures();
            progressionFrame.setText("PROGRESSIONFRAME_LOADINGDONE");
            progressionFrame.setValue(100);
            progressionFrame.dispose();
        } catch (Exception ex) {
            ex.printStackTrace();
            LogManager.error(LogManager.describeException(ex));
            JOptionPane.showMessageDialog(null, ex.toString(), "", JOptionPane.ERROR_MESSAGE);
        }
    }

    public void dispose() throws Exception {
        getDatabaseManager().close();
        for (Table t : getTables()) {
            t.getColumns().clear();
            t.getTriggers().clear();
        }
        getTables().clear();
        getStoredProcedures().clear();
        getViews().clear();
    }

    private void readTables() throws Exception {
        String sql;
        ResultSet tableResult, columnResult, triggerResult;
        sql = SQL.QUERY_TABLES;
        tableResult = getDatabaseManager().query(sql);
        while (tableResult.next()) {
            Table table;
            table = Table.parse(tableResult);
            sql = SQL.QUERY_COLUMNS;
            sql = sql.replaceFirst("\\?", "" + table.getId());
            columnResult = getDatabaseManager().query(sql);
            while (columnResult.next()) {
                TableColumn tc = TableColumn.parse(columnResult);
                table.getColumns().add(tc);
            }
            columnResult.close();
            sql = SQL.QUERY_TRIGGERS;
            sql = sql.replaceFirst("\\?", "" + table.getId());
            triggerResult = getDatabaseManager().query(sql);
            while (triggerResult.next()) {
                TableTrigger trigger;
                trigger = TableTrigger.parse(triggerResult);
                if (table.getTriggers().contains(trigger)) {
                    TableTrigger original = table.getTriggers().get(table.getTriggers().indexOf(trigger));
                    original.setCode(original.getCode() + trigger.getCode());
                } else {
                    table.getTriggers().add(trigger);
                }
            }
            triggerResult.close();
            getTables().add(table);
        }
        tableResult.close();
    }

    private void readStoredProcedures() throws Exception {
        String sql;
        ResultSet storedProceduresResult;
        sql = SQL.QUERY_STOREDPROCEDURES;
        storedProceduresResult = getDatabaseManager().query(sql);
        while (storedProceduresResult.next()) {
            StoredProcedure storedProcedure;
            storedProcedure = StoredProcedure.parse(storedProceduresResult);
            getStoredProcedures().add(storedProcedure);
        }
        storedProceduresResult.close();
    }

    private void readViews() throws Exception {
        String sql;
        ResultSet viewsResult;
        sql = SQL.QUERY_VIEWS;
        viewsResult = getDatabaseManager().query(sql);
        while (viewsResult.next()) {
            View view;
            view = View.parse(viewsResult);
            getViews().add(view);
        }
        viewsResult.close();
    }

    public ArrayList
getTables() {
        return tables;
    }

    public ArrayList getStoredProcedures() {
        return storedProcedures;
    }

    public ArrayList getViews() {
        return views;
    }

    public DBManager getDatabaseManager() {
        return databaseManager;
    }

}

Adesso vediamo di analizzare metodo per metodo il codice sopra citato:

• Metodo Costruttore
• Inizializza il ProgressionFrame (la finestra di dialogo per mostrare il caricamento del database in corso, maggiori dettagli) e gli array delle Tabelle, Viste e StoredProcedure.
• read
• Viene effettuata la ciclica lettura degli elementi del database. Nota che all'interno dei metodi readXXX come readTable si fa riferimento alla classe SQL, questa classe contiene tutte le query in formato testo, utile per non avere 100 query sparse in tutto il progetto Java. (per i dettagli di quali query utilizzare per estrapolare i dati vedere il post dedicato)
• readTables
• Per ogni tabella del database vengono lette le colonne collegate e i trigger. Notare che viene applicato un controllo se il trigger che si sta per inserire è già presente (a volte SQL Server divide il codice di un Trigger in due record della tabella sys.triggers).
• readViews e readStoredProcedures
• Vengono lette tutte le Viste e StoredProcedures.
• dispose
• Viene liberata la memoria eseguendo il clear degli array degli oggetti e il close della connessione con il database sql.

Conclusione

Nel prossimo appuntamento vedremo insieme i metodi di salvataggio/caricamento di un oggetto SqlDocGenerator su file.