kern/src/de/superx/bin/Doquery.java

package de.superx.bin;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.StringTokenizer;
import java.util.logging.LogManager;
import java.util.logging.Logger;

import de.superx.bin.Doschema.Format;

/**
 * @author Daniel Quathamer Projektgruppe SuperX
 * doquery.java
 * @
 * Dieses Javaprogramm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.<br>
 * Gebrauch:<br> java doquery <Pfad zu logger-properties> <pfad zu db.properties> <sql-Ausdruck> <Ausgabeformat (txt | html | xml)>(optional) <delimiter> <mit Spaltenüberschriften (true | false)>(optional) <Ausgabedatei>(optional)
 *

 */
//Änderungen
/*
 * 16.4.04 Wenn kein  outfile angegeben, werden alle select results auf die Console geloggt
 * 19.1.2006 dq: Unload großer Tabellen unter Postgres ermöglicht. 
 */
public class Doquery {
    private static Connection myDb;

    private static Statement st; // Our statement to run queries with

    private static DatabaseMetaData dbmd;

    // This defines the structure of the database
    private static boolean done = false; // Added by CWJ to permit \q command

    private static String delim = "^";

    private static String header = "false";

    private static Format outFormat = Format.txt;

    private static String logfile = "../conf/logging.properties";

    private static String tabelle = "";

    private static String dbpropfile = "../conf/db.properties";

    private static SxConnection myConnection = null;

    private static String db_driver;

    private static String outfile = "";

    private static Logger logger = (Logger) Logger.getLogger(Doquery.class.toString());

    private static String usage = "-------------------------------------\nGebrauch: java de.superx.SimpleTransform -logger=<<Pfad zu logging.properties>> -IN=<<xml-Datei>> -XSL=<<xsl-Datei>> -method=<<xml |html|text>>(optional) -param=<<Parameter>>(optional) -OUT=<<Ausgabedatei>>(optional) \n---------------------------------------------------";

    public static void go(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException, IllegalArgumentException {
        if (args.length > 0) {
            logfile = args[0].trim();
        } else {
            throw new IllegalArgumentException("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");

        }
        File f = new File(logfile);
        if (!f.exists()) {
            throw new IOException("Datei nicht gefunden: " + logfile);
        }

        FileInputStream ins = new FileInputStream(logfile);
        LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
        MyLogManager.readConfiguration(ins);
        logfile = MyLogManager.getProperty(".level");
        logger.info("Using Loggging-Level " + logfile);
        String _sql = "";
        if (args.length > 1) {
            dbpropfile = args[1].trim();
        } else {
            logger.severe("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");
            System.exit(1);
        }
        if (args.length > 2) {
            _sql = args[2].trim();
            //DOS produces unnecessary ".." around the stmt
            if (_sql.length() > 0) {

                if (_sql.startsWith("\"")) _sql = _sql.substring(1, _sql.length());
                if (_sql.endsWith("\"")) _sql = _sql.substring(0, _sql.length() - 1);
            }

        } else {
            logger.severe("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, sql-String) erfoderlich");
            System.exit(1);
        }
        if (args.length > 3) {
            //outFormat = args[3].trim();
            outFormat = Format.valueOf(args[3].trim().toLowerCase());
        }

        if (args.length > 4) {
            delim = args[4].trim();
        }
        if (args.length > 5) {
            header = args[5].trim();

        }
        if (args.length > 6) {
            outfile = args[6].trim();

        }
        if (delim.equals("")) delim = "^"; //default Delimiter
        if (!outfile.equals("")) {
            try {
                FileWriter f1 = new FileWriter(outfile);
                f1.write("");
                f1.close();
            } catch (IOException e) {
                logger.severe("Fehler beim Erstellen der Datei " + outfile);
            }
        }
        getConnection(logger, dbpropfile);
        SxTransformer myTransformer = null;
        if (myConnection.m_DriverClass == SxConnection.DriverClass.dc_postgre && !outfile.equals("") && outFormat == Format.txt && !header.equals("true")) {
            //Postgres-Boost-Mode
            logger.info("Unload with Postgres Boost mode");
            PreparedStatement l_stmt = null;
            PreparedStatement l_stmtFetch = null;
            PreparedStatement l_stmtClose = null;
            ResultSet l_rset = null;
            ResultSetMetaData l_mdat = null;
            int l_rows;
            try { //exception

                st = myDb.createStatement();

                if (_sql.indexOf(";") > 0) {
                    String einzelsql = "";
                    //mehrere Statements hintereinander
                    StringTokenizer tk = new StringTokenizer(_sql, ";");
                    for (; tk.hasMoreTokens();) {
                        einzelsql = tk.nextToken();
                        if (tk.hasMoreTokens())
                            //das letzte SQL wird unten ausgeführt:
                            st.execute(einzelsql);
                    }
                    _sql = einzelsql;
                }
                logger.info("Print Result of: " + _sql);

                st.execute("Begin;");
                try { //finally
                    //open the cursor

                    l_stmt = myConnection.prepareStatement("DECLARE FOO CURSOR FOR " + _sql);
                    l_stmt.execute();

                    l_stmtFetch = myConnection.prepareStatement("FETCH FORWARD 10000 FROM FOO");
                    l_rset = l_stmtFetch.executeQuery();
                    l_mdat = l_rset.getMetaData();
                    while (true) {
                        //perform a fetch from the cursor (possibly multiple fetches	will be done)

                        if (l_rset.next() == false) break;
                        //l_rset.beforeFirst() ;

                        if (outfile.equals("")) {
                            myTransformer = new SxTransformer(logger, System.out);
                            //myClient.setLogAllResultSetsToConsole(true);
                        } else
                            myTransformer = new SxTransformer(logger, new FileWriter(outfile, true));

                        myTransformer.setDelim(delim);
                        myTransformer.setHeader(header);

                        myTransformer.setOutrs(l_rset);
                        myTransformer.setOutrsmd(l_mdat);
                        myTransformer.printResult(outFormat.name());
                        l_rset = l_stmtFetch.executeQuery();

                    }


                    //don't forget to close the cursor
                    l_stmtClose = myConnection.prepareStatement("CLOSE FOO");
                    l_stmtClose.execute();
                } finally {
                    if (l_rset != null) {
                        l_rset.close();
                    }
                    if (l_stmt != null) {
                        l_stmt.close();
                    }
                    if (l_stmtFetch != null) {
                        l_stmtFetch.close();
                    }
                    if (l_stmtClose != null) {
                        l_stmtClose.close();
                    }
                }
            } catch (SQLException l_se) {
                //do something useful here
                logger.severe("Fehler beim SQL " + _sql);
                l_se.printStackTrace();
            }
            st = myDb.createStatement();
            //if (myConnection.m_DriverClass.equals("org.postgresql.Driver"))
            st.execute("commit;");
            myConnection.close();
        } else {
            //normaler Modus für IDS, Access und andere Exportformate ausser txt

            SxJdbcClient myClient = new SxJdbcClient(logger, dbpropfile, _sql);


            //logger.info("Executing sql: " + _sql);
            myClient.Rs_executeALL();
            logger.info("Getting resultset");
            ResultSet myrs = myClient.getRs();
            //logger.info("Starting output for: " + _sql);
            if (myrs != null && myrs.next()) {
                if (outfile.equals("")) {
                    myTransformer = new SxTransformer(logger, System.out);
                    myClient.setLogAllResultSetsToConsole(true);
                } else
                    myTransformer = new SxTransformer(logger, new FileWriter(outfile));

                myTransformer.setDelim(delim);
                myTransformer.setHeader(header);

                myTransformer.setOutrs(myrs);
                myTransformer.setOutrsmd(myClient.getRsmd());
                logger.info("Print Result of: " + _sql);

                myTransformer.printResult(outFormat.name());

            }
            //else
            //	logger.info("Keine Rückgabewerte aus SQL-Script");
            myClient.close();
        }
        logger.info("doquery erfolgreich beendet");

    }

    /*
     * Display some instructions on how to run the example
     */
    public static void instructions() {
        System.out.println("SuperX @version@\n");
        System.out.println("\nDieses Java-Programm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.\n");
        System.out.println("Gebrauch:\n java doquery <Pfad zu logger-properties> <pfad zu db.properties> <sql-Ausdruck> <Ausgabeformat (txt | html | xml)>(optional) <delimiter> <mit Spaltenüberschriften (true | false)>(optional) <Ausgabedatei>(optional)\n");
        System.exit(1);
    }

    public static void main(String args[]) {
        try {
            go(args);
        } catch (Exception ex) {
            System.err.println("Doquery Aufruf fehlgeschlagen.\n" + ex);
            ex.printStackTrace();
            System.exit(1);
        }
    }

    public static void getConnection(Logger logger, String propFile) throws SQLException {
        myConnection = new SxConnection();
        myConnection.setPropfile(propFile);
        logger.config("Starting Connection...");
        try {
            myDb = myConnection.getConnection();
            st = myDb.createStatement();
            //st = myDb.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
            //          java.sql.ResultSet.CONCUR_READ_ONLY);
            //st.setFetchSize(100); 
            dbmd = myDb.getMetaData();
            //st = myDb.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
            //ResultSet.CONCUR_UPDATABLE);
        } catch (Exception e) {
            e.printStackTrace();
            logger.severe("Keine DB-Verbindung: " + e.toString());
            throw new SQLException("Keine DB-Verbindung: " + e.toString());
        }
        db_driver = myConnection.m_DriverClass.stringValue();

    }


}