Quadcap Embeddable Database

com/quadcap/sql/tools/XmlDump.java

Go to the documentation of this file.

package com.quadcap.sql.tools;

/* 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.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;


import java.util.Iterator;
import java.util.List;
import java.util.HashMap;
import java.util.Map;


import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Vector;

import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;

import java.sql.SQLException;
import java.sql.Types;

import java.util.zip.GZIPOutputStream;

import com.quadcap.sql.Backup;

import com.quadcap.sql.types.Type;

import com.quadcap.util.Config;
import com.quadcap.util.Debug;

import com.quadcap.util.collections.DiGraph;

/**
  * Dump an SQL database in an XML representation.  The XML document
  * has an outer tag of <code>&lt;database&gt;</code>.  Each child element
  * then contains one table row, where the tag name specifies the table name;
  * each child element of this tag contains one column value where the
  * tag name specifies the column name.  Most object are represented in
  * their standard Java <code>toString</code> style representation, except
  * binary objects, which are dumped in hexadecimal.  (Base-64 would probably
  * be better...) 
  *
  * @author Stan Bailes
  */

public class XmlDump implements Backup {
    Connection                  conn;
    int                         indentLevel             = 0;
    String                      lineSep;
    boolean                     wasBegin                = false;
    boolean                     wasEnd                  = false;

    /**
     * No-argument constructor.  The object so constructed needs a 
     * <code>Connection</code> in order to do anything useful.
     */
    public XmlDump() {
        lineSep = System.getProperty("line.separator");
    }

    /**
     * Construct an XmlDump object bound to the specified connection.
     *
     * @param conn the database connection
     */
    public XmlDump(Connection conn) {
        this.conn = conn;
        lineSep = System.getProperty("line.separator");
    }

    /**
     * Construct an XmlDump object bound to the specified connection,
     * and with a specified initial indent level.
     * 
     * @param conn the database connection
     * @param indentLevel the initial indent level (in units -- currently
     *          indent units are simple spaces
     */
    public XmlDump(Connection conn, int indentLevel) {
        this.indentLevel = indentLevel;
        this.conn = conn;
        lineSep = System.getProperty("line.separator");
    }

    /**
     * Set the dumper's database connection
     *
     * @param conn the new database connection
     */
    public void setConnection(Connection conn) {
        this.conn = conn;
    }

    /**
     * Get the dumper's database connection
     *
     * @return the current database connection
     */
    public Connection getConnection() {
        return conn;
    }

    final void beginTag(Writer w, String tag) throws IOException {
        if (wasBegin) w.write(lineSep);
        for (int i = 0; i < indentLevel; i++) w.write(' ');
        indentLevel++;
        w.write('<');
        w.write(tag);
        w.write('>');
        wasBegin = true;
        wasEnd = false;
    }

    final void endTag(Writer w, String tag) throws IOException {
        indentLevel--;
        if (wasEnd) {
            for (int i = 0; i < indentLevel; i++) w.write(' ');
        }
        w.write('<');
        w.write('/');
        w.write(tag);
        w.write('>');
        w.write(lineSep);
        wasBegin = false;
        wasEnd = true;
    }

    static final String charsLt         = "&lt;";
    static final String charsGt         = "&gt;";
    static final String charsAmp        = "&amp;";

    final void writeString(Writer w, String str) throws IOException {
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            switch (c) {
            case '<':
                w.write(charsLt);
                break;
            case '>':
                w.write(charsGt);
                break;
            case '&':
                w.write(charsAmp);
                break;
            default:
                w.write(c);
            }
        }
        wasBegin = false;
        wasEnd = false;
    }

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

    final void writeBinaryStream(Writer w, InputStream is) throws IOException {
        int c;
        while ((c = is.read()) >= 0) {
            w.write(hexBytes[(c >> 4) & 0xf]);
            w.write(hexBytes[c & 0xf]);
        }
    }

    final void writeCharacterStream(Writer w, Reader r) throws IOException {
        int ci;
        while ((ci = r.read()) >= 0) {
            char c = (char)ci;
            switch (c) {
            case '<':
                w.write(charsLt);
                break;
            case '>':
                w.write(charsGt);
                break;
            case '&':
                w.write(charsAmp);
                break;
            default:
                w.write(c);
            }
        }
    }    

    final void writeBinary(Writer w, Object obj)
        throws IOException
    {
        if (obj instanceof Boolean) {
            w.write((((Boolean)obj).booleanValue()) ? '1' : '0');
        } else {
            byte[] buf = (byte[])obj;
            for (int i = 0; i < buf.length; i++) {
                byte c = buf[i];
                w.write(hexBytes[(c >> 4) & 0xf]);
                w.write(hexBytes[c & 0xf]);
            }
        }
    }

    final void writeValue(Writer w, Object obj, int jdbcType) 
        throws SQLException, IOException
    {
        switch (jdbcType) {
        case Types.BIT:
        case Types.TINYINT:
        case Types.SMALLINT:
        case Types.INTEGER:
        case Types.BIGINT:
        case Types.FLOAT:
        case Types.REAL:
        case Types.DOUBLE:
        case Types.NUMERIC:
        case Types.DECIMAL:
        case Types.CHAR:
        case Types.VARCHAR:
        case Types.LONGVARCHAR:
        case Types.DATE:
        case Types.TIME:
        case Types.TIMESTAMP:
        case Types.OTHER:
            writeString(w, obj.toString());
            break;
//-         //#ifdef JDK11
//-         case Type.CLOB:
            //#else
        case Types.CLOB:
            writeCharacterStream(w, ((Clob)obj).getCharacterStream());
            //#endif
            break;
//-         //#ifdef JDK11
//-         case Type.BLOB:
            //#else
        case Types.BLOB:
            //#endif
            writeBinaryStream(w, ((Blob)obj).getBinaryStream());
            break;
        case Types.BINARY:
        case Types.VARBINARY:
        case Types.LONGVARBINARY:
            writeBinary(w, obj);
            break;
        case Types.NULL:
            //#ifndef JDK11
        case Types.JAVA_OBJECT:
        case Types.DISTINCT:
        case Types.STRUCT:
        case Types.ARRAY:
        case Types.REF:
            //#endif
            throw new IOException("Not supported, jdbc type: " + jdbcType +
                ", object = " + obj.getClass().getName() + ": " + obj);
        }
    }

    List parseViewDef(String s) {
        List ret = new ArrayList();
        StringBuffer sb = new StringBuffer();
        int idx = s.indexOf(" AS ");
        if (idx >= 0) {
            s = s.substring(idx+4);
        }
        boolean l = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            boolean d = Character.isLetterOrDigit(c) || c == '.';
            if (d ^ l) {
                if (sb.length() > 0) {
                    ret.add(sb.toString());
                    sb.setLength(0);
                }
            }
            if (d) {
                sb.append(c);
            }
            l = d;
        }
        if (sb.length() > 0) ret.add(sb.toString());
        return ret;
    }

    void dumpViewDefinitions(Writer w) throws SQLException, IOException {
        DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
        ResultSet rs = (ResultSet)dbMeta.getTables(null, "%", "%", null);
        Map map = new HashMap();
        DiGraph graph = new DiGraph();
        try {
            while (rs.next()) {
                String type = rs.getString(4);
                if (type.toLowerCase().indexOf("view") >= 0) {
                    String schema = rs.getString(2);
                    String table = rs.getString(3);
                    if (schema != null && schema.length() > 0) {
                        table = schema + "." + table;
                    }
                    String view = rs.getString(5);
                    if (view != null) {
                        Iterator it = parseViewDef(view).iterator();
                        while (it.hasNext()) {
                            String base = it.next().toString();
                            graph.addArc(base, table);
                            //graph.addArc(table, base);
                        }
                        map.put(table, view);
                    }
                }
            }
            Iterator iter = graph.levelize(true);
            while (iter.hasNext()) {
                String s = iter.next().toString();
                Object x = map.get(s);
                if (x != null) {
                    beginTag(w, "ddl");
                    writeString(w, "CREATE " + x.toString());
                    endTag(w, "ddl");
                }
            }
        } finally {
            rs.close();
        }
    }

    void dumpIndexDefinitions(Writer w, String tableName)
        throws SQLException, IOException
    {
        String schemaP = null;
        String tableP = tableName;
        int idx = tableName.indexOf('.');
        if (idx > 0) {
            schemaP = tableName.substring(0, idx);
            tableP = tableName.substring(idx+1);
        }
        DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
        ResultSet rs = (ResultSet)dbMeta.getIndexInfo(null, schemaP, tableP, false, true);
        try {
            StringBuffer columns = new StringBuffer();
            boolean unique = false;
            String table = null;
            String index = null;
            while (rs.next()) {
                if (rs.getObject(5) != null) {
                    String sch = rs.getString(2);
                    String tab = rs.getString(3);
                    if (sch != null && sch.length() > 0) {
                        tab = sch + "." + tab;
                    }
                    if (index != null && !index.equals(rs.getString(6))) {
                        beginTag(w, "ddl");
                        writeString(w, "CREATE " + (unique ? "UNIQUE " : "") +
                                    " INDEX " + index + " ON " +
                                    table + "(" + columns + ")");
                        endTag(w, "ddl");
                        columns.setLength(0);
                    }
                    String column = rs.getString(9);
                    unique = !rs.getBoolean(4);
                    index = rs.getString(6);
                    table = tab;
                    if (columns.length() > 0) columns.append(", ");
                    columns.append(column);
                }
            }
            if (index != null) {
                beginTag(w, "ddl");
                writeString(w, "CREATE " + (unique ? "UNIQUE " : "") +
                            " INDEX " + index + " ON " +
                            table + "(" + columns + ")");
                endTag(w, "ddl");
            }
        } finally {
            rs.close();
        }
    }
    
    
    final Iterator orderTables() throws SQLException {
        ArrayList t = new ArrayList();
        DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
        ResultSet rs = (ResultSet)dbMeta.getTables(null, "%", "%", null);
        try {
            while (rs.next()) {
                String type = rs.getString(4);
                if (type.toLowerCase().indexOf("table") >= 0) {
                    String schema = rs.getString(2);
                    String table = rs.getString(3);
                    if (schema != null && schema.length() > 0) {
                        table = schema + "." + table;
                    }
                    t.add(table);
                }
            }
        } finally {
            rs.close();
        }
        return t.iterator();
    }
    
    class DbType {
        int             type;
        String          prefix;
        String          suffix;
        String          createParams;
        DbType(int type, String prefix, String suffix, String createParams) {
            this.type = type;
            this.prefix = prefix == null ? "" : prefix;
            this.suffix = suffix == null ? "" : suffix;
            this.createParams = createParams == null ? "" : createParams;
        }

        String getTypePrefix() { return prefix; }
        String getTypeSuffix() { return suffix; }

        String getCreateParams(ResultSet rs) throws SQLException {
            StringBuffer sb = new StringBuffer("");
            String cp = createParams;
            while (cp.length() > 0) {
                String param = cp;
                int idx = cp.indexOf(',');
                if (idx > 0) {
                    param = cp.substring(0, idx).trim();
                    cp = cp.substring(idx+1).trim();
                } else {
                    cp = "";
                }
                if (param.equalsIgnoreCase("length") ||
                    param.equalsIgnoreCase("precision")) {
                    if (sb.length() == 0) {
                        sb.append('(');
                    } else {
                        sb.append(',');
                    }
                    sb.append(rs.getString(7));
                } else if (param.equalsIgnoreCase("scale")) {
                    if (sb.length() == 0) {
                        sb.append('(');
                    } else {
                        sb.append(',');
                    }
                    sb.append(rs.getString(9));
                }
            }
            if (sb.length() > 0) {
                sb.append(')');
            }
            return sb.toString();
        }
    };

    Hashtable types = null;

    Hashtable getTypes() throws SQLException {
        if (types == null) {
            types = new Hashtable();
            DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
            ResultSet rs = (ResultSet)dbMeta.getTypeInfo();
            while (rs.next()) {
                int type = rs.getInt(2);
                String prefix = rs.getString(4);
                String suffix = rs.getString(5);
                String createParams = rs.getString(6);
                DbType t = new DbType(type, prefix, suffix, createParams);
                types.put(new Integer(type), t);
            }
        }
        return types;
    }

    DbType getType(int type) throws SQLException {
        DbType t = null;
        getTypes();
        t = (DbType)types.get(new Integer(type));
        if (t == null) {
            throw new RuntimeException("no type: " + type);
        }
        return t;
    }

    /**
     * Dump the SQL foreign key constraints for the specified table
     */
    public void dumpTableForeignKeys(Writer w, String tableName) 
        throws SQLException, IOException 
    {
        String schema = null;
        String table = tableName;
        int idx = tableName.indexOf('.');
        if (idx > 0) {
            schema = tableName.substring(0, idx);
            table = tableName.substring(idx+1);
        }
        DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
        ResultSet rs = (ResultSet)dbMeta.getImportedKeys(null, schema, table);
        String cname = "";
        Vector pkeys = null;
        String pkTable = null;
        StringBuffer sb = new StringBuffer("");
        while (rs.next()) {
            String constraintName = rs.getString(12);
            if (!constraintName.equals(cname)) {
                if (cname.length() > 0) {
                    sb.append(") references ");
                    sb.append(pkTable);
                    sb.append("(");
                    for (int i = 0; i < pkeys.size(); i++) {
                        if (i > 0) sb.append(", ");
                        sb.append(pkeys.elementAt(i).toString());
                    }
                    sb.append(")\n");
                    beginTag(w, "ddl");
                    writeString(w, sb.toString());
                    endTag(w, "ddl");
                }
                String pkSchema = rs.getString(2);
                if (pkSchema != null && pkSchema.length() > 0) {
                    pkTable = pkSchema + "." + rs.getString(3);
                } else {
                    pkTable = rs.getString(3);
                }
                cname = constraintName;
                sb.setLength(0);
                sb.append("\nalter table ");
                sb.append(tableName);
                sb.append(" add constraint ");
                sb.append(cname);
                sb.append(" foreign key(");
                pkeys = new Vector();
            } else {
                sb.append(", ");
            }
            sb.append(rs.getString(8));
            pkeys.addElement(rs.getString(4));
        }
        if (cname.length() > 0) {
            sb.append(") references ");
            sb.append(pkTable);
            sb.append("(");
            for (int i = 0; i < pkeys.size(); i++) {
                if (i > 0) sb.append(", ");
                sb.append(pkeys.elementAt(i).toString());
            }
            sb.append(")");
            beginTag(w, "ddl");
            writeString(w, sb.toString());
            endTag(w, "ddl");
        }
    }

    /**
     * Dump the SQL table definition for the specified table
     */
    public void dumpTableDefinition(Writer w, String tableName) 
        throws SQLException, IOException 
    {
        Hashtable constraints = new Hashtable();
        String schema = null;
        String table = tableName;
        int idx = tableName.indexOf('.');
        if (idx > 0) {
            schema = tableName.substring(0, idx);
            table = tableName.substring(idx+1);
        }
        DatabaseMetaData dbMeta = (DatabaseMetaData)conn.getMetaData();
        ResultSet rs = (ResultSet)dbMeta.getColumns(null, schema, table, "%");

        ResultSet rs2 =
            conn.createStatement().executeQuery("select * from " + tableName);
        ResultSetMetaData rsMeta = rs2.getMetaData();
        
        StringBuffer sb = new StringBuffer("\ncreate table ");
        sb.append(tableName);
        sb.append('(');
        boolean first = true;
        while (rs.next()) {
            sb.append("\n\t");
            if (!first) sb.append(", ");
            first = false;
            int type = rs.getInt(5);
            DbType t = getType(type);
            sb.append(rs.getString(4));         // column name
            sb.append(' ');
            sb.append(rs.getString(6));         // type name
            sb.append(t.getCreateParams(rs));
            if (rs.getInt(11) == ResultSetMetaData.columnNoNulls) {
                sb.append(" NOT NULL");
            }
            String dflt = rs.getString(13);
            if (dflt != null) {
                sb.append(" DEFAULT ");
                sb.append(t.getTypePrefix());
                sb.append(dflt);
                sb.append(t.getTypeSuffix());
            }
            if (rsMeta.isAutoIncrement(rs.getInt(17))) {
                sb.append(" WITH IDENTITY");
            }
        }
        rs.close();
        rs2.close();

        rs = (ResultSet)dbMeta.getPrimaryKeys(null, schema, table);
        first = true;
        while (rs.next()) {
            if (first) {
                constraints.put(rs.getString(6), "");
                sb.append("\n\t, constraint ");
                sb.append(rs.getString(6));             // constraint name
                sb.append(" primary key (");
                first = false;
            } else {
                sb.append(", ");
            }
            sb.append(rs.getString(4));                 // column name
        }
        if (!first) sb.append(')');
        rs.close();

        String iname = "";
        rs = (ResultSet)dbMeta.getIndexInfo(null, schema, table, true, false);
        first = true;
        while (rs.next()) {
            String indexName = rs.getString(6);
            if (constraints.get(indexName) != null) continue;
            if (rs.getObject(5) != null) continue;
            if (indexName.equals(iname)) {
                sb.append(", ");
            } else {
                if (iname.length() > 0) {
                    sb.append(")");
                }
                sb.append("\n\t, constraint ");
                sb.append(indexName);
                sb.append(" unique(");
                iname = indexName;
            }
            sb.append(rs.getString(9));         // column name
        }
        if (iname.length() > 0) {
            sb.append(')');
        }
        rs.close();

        sb.append(")\n");
        beginTag(w, "ddl");
        writeString(w, sb.toString());
        endTag(w, "ddl");
    }

    /**
     * Dump the rows of the specified table to the output stream in XML
     * format.  Each row is dumped as an XML element with the tag name
     * equal to the table name.  Each non-null column is dumped as a
     * sub-element with the tag name equal to the column name.
     *
     * @param w the output stream
     * @param tableName the name of the database table to dump.
     *
     * @exception IOException may be thrown
     * @exception SQLException may be thrown
     */
    public void dumpTable(Writer w, String tableName)
        throws IOException, SQLException
    {
        tableName = tableName.toUpperCase();
        Statement s = (Statement)conn.createStatement();
        try {
            ResultSet rs = (ResultSet)s.executeQuery("select * from " + tableName);
            try {
                ResultSetMetaData rm = (ResultSetMetaData)rs.getMetaData();
                int cols = rm.getColumnCount();
                while (rs.next()) {
                    beginTag(w, tableName);
                    for (int i = 1; i <= cols; i++) {
                        Object obj = rs.getObject(i);
                        if (!rs.wasNull()) {
                            beginTag(w, rm.getColumnName(i));
                            try {
                                writeValue(w, obj, rm.getColumnType(i));
                            } catch (IOException e) {
                                Debug.println("Table: " + tableName +
                                              ", column = " + i + ": " +
                                              rm.getColumnName(i));
                                throw e;
                            }
                            endTag(w, rm.getColumnName(i));
                        }
                    }
                    endTag(w, tableName);
                }
            } finally {
                rs.close();
            }
        } finally {
            s.close();
        }
    }

    /**
     * Dump all of the tables in the database which is referenced by the
     * current connection object to the specified output stream.  This
     * routine writes a well-formed XML document, with a document element
     * named <code>&lt;database&gt;</code>.  Sub-elements correspond to
     * indidivual table rows.<p>
     *
     * This routine first constructs a graph of the foreign table reference
     * constraints, and attempts to output base tables before dependant
     * tables, so that the resulting file can be imported without causing
     * foreign key integrity violations.<p>
     *
     * @param w the output stream
     *
     * @exception IOException may be thrown
     * @exception SQLException may be thrown
     */
    public void dumpTables(Writer w)
        throws IOException, SQLException
    {
        w.write("<?xml version=\"1.0\"?>\n");
        beginTag(w, "database");
        Iterator iter = orderTables();
        while (iter.hasNext()) {
            String table = iter.next().toString();
            dumpTableDefinition(w, table);
        }
        dumpViewDefinitions(w);

        iter = orderTables();
        beginTag(w, "dml");
        while (iter.hasNext()) {
            String table = iter.next().toString();
            dumpTable(w, table);
        }
        endTag(w, "dml");

        iter = orderTables();
        while (iter.hasNext()) {
            String table = iter.next().toString();
            dumpIndexDefinitions(w, table);
        }

        iter = orderTables();
        while (iter.hasNext()) {
            String table = iter.next().toString();
            dumpTableForeignKeys(w, table);
        }
        endTag(w, "database");      
    }

    /**
     * A convenience function that sets the current connection and dumps
     * the database in one go.
     *
     * @param conn the database connection
     * @param w the output stream
     *
     * @exception IOException may be thrown
     * @exception SQLException may be thrown
     */
    public void backup(java.sql.Connection conn, Writer w) 
        throws IOException, SQLException
    {
        this.conn = (Connection)conn;
        dumpTables(w);
    }

    /**
     * Establish a database connection based on the settings of system
     * properties.
     *
     * <p>The following system properties are used to establish the 
     * database connection:
     * <table border=1>
     * <tr><th align=left>jdbc.driver</th>
     *     <td>The name of the JDBC driver class (default
     *         <code>com.quadcap.jdbc.JdbcDriver</code>)</td></tr>
     * <tr><th align=left>jdbc.url</th>
     *     <td>The JDBC URL used to establish the database connection.
     *         </td></tr>
     * <tr><th align=left>jdbc.props</th>
     *     <td>The name of a properties file used to establish the connection.
     *         If this property is specified, <code>jdbc.user</code> and
     *         <code>jdbc.password</code> aren't used.
     *         If this property has the value <code>"system"</code>, then
     *         the system properties are passed to the 
     *         <code>DriverManager.getConnection()</code> method.
     *         </td></tr>
     * <tr><th align=left>jdbc.user</th>
     *     <td>The user name used to establish the 
     *         database connection.  If neither <code>jdbc.props</code>
     *         nor <code>jdbc.user</code> is specified, the
     *         <code>DriverManager.getConnection(String url)</code>
     *         method is used to establish the connection.</td></tr>
     * <tr><th align=left>jdbc.password</th>
     *     <td>The password used to establish the 
     *         database connection.</td></tr>
     * </table>
     * </p>
     *
     * @exception Exception may be thrown if there's a problem connecting
     *          to the database.
     */
    public static Connection makeConnection() throws Exception {
        Config.reset();
        String driver = Config.getProperty("jdbc.driver",
                                           "com.quadcap.jdbc.JdbcDriver");
        String url = Config.getProperty("jdbc.url");
        String user = Config.getProperty("jdbc.user");
        String pass = Config.getProperty("jdbc.password");
        String propsfile = Config.getProperty("jdbc.props");
        Connection xconn = null;
        Class.forName(driver);
        if (propsfile != null) {
            Properties props;
            if (propsfile.equals("system")) {
                props = System.getProperties();
            } else {
                props = new Properties();
                FileInputStream pfile = new FileInputStream(propsfile);
                props.load(pfile);
            }
            xconn =
                (Connection)java.sql.DriverManager.getConnection(url, props);
        } else if (user != null) {
            xconn =
                (Connection)java.sql.DriverManager.getConnection(url, user,
                                                                 pass);
        } else {
            xconn = (Connection)java.sql.DriverManager.getConnection(url);
        }
        return xconn;
    }

    /**
     * A main program which allows this function to be run as a command-line
     * application for doing an off-line dump.  The name of the output file is
     * specified as the argument.  If the name of the output file
     * ends with <code>".gz"</code>, the output is compressed using the
     * <code>gzip</code> compression mechanism.
     *
     * @see makeConnection for a description of the System properties used
     *          to establish the database connection.
     * @param args <code>com.quadcap.sql.tools.XmlDump</code>
     *  <i>output file</i>
     */
    public static void main(String[] args) {
        try {
            Connection xconn = makeConnection();
            try {
                XmlDump dump = new XmlDump(xconn);
                String outfile = args[0];
                if (outfile.endsWith(".xml")) {
                    FileOutputStream fos = new FileOutputStream(outfile);
                    OutputStreamWriter ow = new OutputStreamWriter(fos);
                    BufferedWriter bw = new BufferedWriter(ow);
                    dump.dumpTables(bw);
                    bw.close();
                } else if (outfile.endsWith(".xml.gz")) {
                    FileOutputStream fos = new FileOutputStream(outfile);
                    GZIPOutputStream gos = new GZIPOutputStream(fos);
                    OutputStreamWriter ow = new OutputStreamWriter(gos);
                    BufferedWriter bw = new BufferedWriter(ow);
                    dump.dumpTables(bw);
                    bw.flush();
                    bw.close();
                } else {
                    throw new Exception("Unrecognized output type for file: " +
                                        outfile);
                }
            } finally {
                xconn.close();
            }
        } catch (Exception e) {
            com.quadcap.util.Debug.print(e);
        }
    }
}