Quadcap Bug Database

com/quadcap/app/bugdb/Loader.java

Go to the documentation of this file.

package com.quadcap.app.bugdb;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * A simple SQL loader utility.
 *
 * @author Stan Bailes
 */
public class Loader {
    Connection                  conn;
    StringBuffer                buffer = new StringBuffer();
    PrintWriter                 writer = null;
    
    /**
     * Construct a new loader.  It needs a connection in order to do
     * anything useful.
     */
    public Loader() {
    }

    /**
     * Construct a new loader bound to the specified connection.
     *
     * @param conn the connection to use.
     */
    public Loader(Connection conn) {
        this.conn = conn;
    }

    /**
     * Set the loader's connection
     *
     * @param conn the connection to use.
     */
    public void setConnection(Connection conn) {
        this.conn = conn;
    }
    
    /**
     * Get the loaders's connection
     *
     * @return the loader's current connection
     */
    public Connection getConnection() {
        return this.conn;
    }

    /**
     * Get the PrintWriter used to display the results of select statements.
     *
     * @return the current writer
     */
    public PrintWriter getWriter() {
        return writer;
    }

    /**
     * Set the PrintWriter used to display the results of select statements.
     *
     * @param writer the new writer
     */
    public void setWriter(PrintWriter writer) {
        this.writer = writer;
    }

    /**
     * Print (if a writer is set) the specified string
     *
     * @param s the string
     */
    final void print(String s) {
        if (writer != null) writer.print(s);
    }

    /**
     * Print (if a writer is set) the specified string, 
     * with a trailing newline.
     *
     * @param s the string
     */
    final void println(String s) {
        if (writer != null) writer.println(s);
    }

    /**
     * Print (if a writer is set) the stack trace for the specified throwable.
     *
     * @param t the throwable
     */
    final void print(Throwable t) {
        if (writer != null) t.printStackTrace(writer);
        if (t instanceof SQLException) {
            SQLException e = ((SQLException)t).getNextException();
            if (e != null) {
                print(e);
            }
        }
    }

    /**
     * Return a string left-justified in a field 'wid' characters wide.
     *
     * @param wid the field width
     * @param s the input string
     * @return the padded string
     */
    final static String pad(int wid, String s) {
        StringBuffer sb = new StringBuffer(s);
        while (sb.length() < wid) sb.append(' ');
        return sb.toString();
    }

    /**
     * Display a result set (to the current writer)
     *
     * @param rs the result set
     * @exception SQLException may be thrown
     */
    final void showResultSet(ResultSet rs) throws SQLException {
        ResultSetMetaData rmeta = rs.getMetaData();
        String delim = "";
        for (int i = 1; i <= rmeta.getColumnCount(); i++) {
            int wid = rmeta.getColumnDisplaySize(i);
            if (wid > 32) wid = 32;
            print(delim);
            delim = " ";
            print(pad(wid, rmeta.getColumnName(i)));
        }
        println("");
        while (rs.next()) {
            delim = "";
            for (int i = 1; i <= rmeta.getColumnCount(); i++) {
                int wid = rmeta.getColumnDisplaySize(i);
                if (wid > 32) wid = 32;
                print(delim);
                delim = " ";
                Object obj = rs.getObject(i);
                if (obj == null) obj = "<null>";
                if (obj instanceof byte[]) {
                    obj = hexBytes((byte[])obj);
                }
                print(pad(wid, obj.toString()));
            }
            println("");
        }
    }

    /**
     * Return the next SQL command from the input stream.
     *
     * @param is the input stream
     * @return the SQL statement
     * @exception IOException may be thrown
     */
    static String getLine(InputStream is) throws IOException {
        StringBuffer sb = new StringBuffer();
        int ch;
        int state = 0;
        while ((ch = is.read()) > 0) {
            char c = (char)ch;
            switch (state) {
            case 0:
                if (c == '-') {
                    state = 1;
                } else if (c == ';') {
                    if (sb.length() > 0) {
                        return sb.toString();
                    }
                } else if (Character.isWhitespace(c) && sb.length() == 0) {
                } else {
                    sb.append(c);
                }
                break;
            case 1:
                if (c == '-') {
                    state = 2;
                } else {
                    sb.append('-');
                    sb.append(c);
                    state = 0;
                }
                break;
            case 2:
                if (c == '\r') state = 3;
                if (c == '\n') state = 0;
                break;
            case 3:
                if (c == '\n') state = 0;
                break;
            }
        }
        return null;
    }

    /**
     * Execute the specified SQL command
     *
     * @param sql the SQL statement to execute
     */
    final void execute(String sql) {
        try {
            Statement stmt = conn.createStatement();
            try {
                if (sql.equals("BEGINTRANSACTION")) {
                    conn.setAutoCommit(false);
                } else if (sql.equals("ENDTRANSACTION") ||
                           sql.equals("COMMIT")) {
                    conn.commit();
                    conn.setAutoCommit(true);
                } else if (sql.equals("ROLLBACK")) {
                    conn.rollback();
                    conn.setAutoCommit(true);
                } else {
                    if (stmt.execute(sql)) {
                        ResultSet rs = stmt.getResultSet();
                        try {
                            showResultSet(rs);
                        } finally {
                            rs.close();
                        }
                    }
                }
            } catch (Throwable t) {
                print(t);
            } finally {
                stmt.close();
            }
        } catch (Throwable t) {
            print(t);
        }
    }

    /**
     * The main point of this class, which is to execute all the SQL commands
     * found in the specified file.
     *
     * @param filename the name of the file
     */
    public void loadFile(String filename) throws IOException {
        FileInputStream fis = new FileInputStream(filename);
        loadStream(fis);
    }

    /**
     * Execute the SQL script contained in the specified input stream
     *
     * @param is the input stream
     */
    public void loadStream(InputStream is) {
        try {
            Statement stmt = conn.createStatement();
            BufferedInputStream bis = new BufferedInputStream(is, 1024);
            String sql = null;
            while ((sql = getLine(bis)) != null) {
                try {
                    if (sql.equals("BEGINTRANSACTION")) {
                        conn.setAutoCommit(false);
                    } else if (sql.equals("ENDTRANSACTION") ||
                               sql.equals("COMMIT")) {
                        conn.commit();
                        conn.setAutoCommit(true);
                    } else if (sql.equals("ROLLBACK")) {
                        conn.rollback();
                        conn.setAutoCommit(true);
                    } else {
                        if (stmt.execute(sql)) {
                            ResultSet rs = stmt.getResultSet();
                            showResultSet(rs);
                        }
                    }
                } catch (Throwable t) {
                    print(t);
                }
            }
        } catch (Throwable t) {
            print(t);
        } finally {
            try {
                is.close();
            } catch (Exception e) {}
        }
    }

    static char[] hexMap = {'0', '1', '2', '3', '4', '5', '6', '7',
                            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    /**
     * Return a string containing the hexadecimal representation of the
     * specified byte array
     *
     * @param buf the byte array
     * @return the ASCII hex representation of the byte array.
     */
    public static String hexBytes(byte[] buf) {
        if (buf == null) return "<null>";
        return hexBytes(buf, 0, buf.length);
    }

    /**
     * Return a string containing the hexadecimal representation of 
     * a portion of the specified byte array
     *
     * @param buf the byte array
     * @param off the position of the first byte to convert
     * @param len the number of bytes to convert
     * @return the ASCII hex representation of the bytes
     */
    public static String hexBytes(byte[] buf, int off, int len) {
        if (buf == null) return "<null>";
        StringBuffer sb = new StringBuffer();
        for (int i = off; i < off + len; i++) {
            byte b = buf[i];
            sb.append(hexMap[(b >> 4) & 0xf]);
            sb.append(hexMap[b & 0xf]);
        }
        return sb.toString();
    }
}