databaseconnection.java

自动生成JAVA-Struts网站的程序

        if (mtdt == null) {
            mtdt = conn.getMetaData();
        }
        String[][] s = getAllResultSetColumns(mtdt.getPrimaryKeys(catalog,
                null, table));
        mtdt = null;
        return s;
    }

    public String[][] getTableImportedKeys(String catalog, String table) throws Exception {

        if (mtdt == null) {
            mtdt = conn.getMetaData();
        }
        String[][] s = getAllResultSetColumns(mtdt.getImportedKeys(catalog,
                null, table));
        mtdt = null;
        return s;
    }

    public String[][] getTableExportedKeys(String catalog, String table) throws Exception {

        if (mtdt == null) {
            mtdt = conn.getMetaData();
        }
        String[][] s = getAllResultSetColumns(mtdt.getExportedKeys(catalog,
                null, table));
        mtdt = null;
        return s;
    }

    public String[] getProcedures(String catalog) throws Exception {

        if (mtdt == null) {
            mtdt = conn.getMetaData();
        }
        String[] s = getResultSetColumn(mtdt.getProcedures(catalog, null, "%"), "PROCEDURE_NAME");
        mtdt = null;
        return s;
    }

    public String[][] getProcedureColumns(String catalog, String
            procedure) throws Exception {

        if (mtdt == null) {
            mtdt = conn.getMetaData();
        }
        String[][] s = getAllResultSetColumns(mtdt.getProcedureColumns(catalog, null, procedure, "%"));
        mtdt = null;
        return s;
    }

    public void test() throws Exception {

        String text = toString2(getSession()) +
                toString2(getEngineInfo()) +
                toString2(getEngineSpecs()) +
                toString2(getEngineFeatures()) +
                toString2(getEngineLimitations());

        System.out.println("-> METADATAS\n" + text);

        String[] catalogs = getCatalogs();
        System.out.println("-> CATALOGS\n" + toString1(catalogs));
        for (int i = 0; i < catalogs.length; i++) {
            System.out.println("-> USER TABLES IN " + catalogs[i]);
            System.out.println(toString1(getTables(catalogs[i], "TABLE")));
        }
        for (int i = 0; i < catalogs.length; i++) {
            System.out.println("-> SYSTEM TABLES IN " + catalogs[i]);
            System.out.println(toString1(getTables(catalogs[i], "SYSTEM TABLE")));
        }

        System.out.println(toString2(getAllResultSetColumns(getResultSet("SELECT* FROM TEST"))));
        System.out.println("OK");
    }

    //************************************************************************
    //************************************************************************
    //************************************************************************

    public String[] getResultSetColumn(ResultSet rs, String column) throws Exception {

        Vector v = new Vector();
        while (rs.next()) {
            v.addElement(rs.getString(column));
        }
        String s[] = new String[v.size()];
        s = v2a(v);
        return s;
    }

    public String[] getResultSetColumn(ResultSet rs, int i) throws Exception {

        Vector v = new Vector();
        while (rs.next()) {
            v.addElement(rs.getString(i));
        }
        String s[] = new String[v.size()];
        s = v2a(v);
        return s;
    }

    public ResultSet getResultSet(String sql) throws Exception {

        Statement st = conn.createStatement();
        st.setMaxRows(400);
        System.out.println(sql);
        return st.executeQuery(sql);
    }

    public void executeUpdate(String sql) throws Exception {

        Statement st = conn.createStatement();
        System.out.println(sql);
        st.executeUpdate(sql);
        //return st.executeQuery(sql);
    }


    public ResultSet getSrollResultSet(String sql) throws Exception {

        Statement st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
        st.setMaxRows(400);
        System.out.println(sql);
        return st.executeQuery(sql);
    }

    public String[][] executeComplexQuery(String sql) throws Exception {

        boolean resultSetIsAvailable;
        boolean moreResultsAvailable;
        int i = 0;
        int res = 0;
        String[][] bigresult = null;
        String[][] result = null;

        Statement curStmt = conn.createStatement();
        resultSetIsAvailable = curStmt.execute(sql);
        ResultSet rs = null;
        for (moreResultsAvailable = true; moreResultsAvailable;) {
            if (resultSetIsAvailable) {
                if ((rs = curStmt.getResultSet()) != null) {
                    // we have a resultset
                    result = getAllResultSetColumns(rs);
                }
            } else {
                if ((res = curStmt.getUpdateCount()) != -1) {
                    // we have an updatecount
                    result = new String[2][2];
                    result[0] = setString2("UPDATE", "");
                    result[1] = setString2("Update count", res);
                } else {
                    // else no more results
                    moreResultsAvailable = false;
                }
            }
            if (moreResultsAvailable) {
                resultSetIsAvailable = curStmt.getMoreResults();
            }
            bigresult = concat(bigresult, result);
        }
        if (rs != null) rs.close();
        curStmt.close();
        return bigresult;
    }

    public String[][] getAllResultSetColumns(ResultSet rs) throws Exception {

        String[] headers = getResultSetColumnHeaders(rs);
        String[][] rows = getResultSetRows(rs);
        String[][] t = new String[rows.length + 1][headers.length];
        t[0] = headers;
        for (int i = 0; i < rows.length; i++) {
            t[i + 1] = rows[i];
        }
        return t;
    }

    public String[] getResultSetColumnHeaders(ResultSet rs) throws Exception {

        ResultSetMetaData rsmd = rs.getMetaData();
        String[] headers = new String[rsmd.getColumnCount()];
        for (int i = 0; i < headers.length; i++) {
            headers[i] = rsmd.getColumnLabel(i + 1);
        }
        return headers;
    }

    public String[][] getResultSetRows(ResultSet rs) throws Exception {

        ResultSetMetaData rsmd = rs.getMetaData();
        Vector v = new Vector();
        while (rs.next()) {
            String[] columns = new String[rsmd.getColumnCount()];
            for (int i = 0; i < columns.length; i++) {
                columns[i] = rs.getString(i + 1);
            }
            v.addElement(columns);
        }
        String[][] t = new String[v.size()][rsmd.getColumnCount()];
        for (int i = 0; i < v.size(); i++) {
            t[i] = (String[]) v.elementAt(i);
        }
        rs.close();
        return t;
    }

    public String[] setString2(String s, String t) {

        String[] r = new String[2];
        r[0] = new String(s);
        r[1] = new String(t);
        return r;
    }

    public String[] setString2(String s, boolean b) {

        String[] r = new String[2];
        r[0] = new String(s);
        r[1] = new String(b ? "yes" : "no");
        return r;
    }

    public String[] setString2(String s, int i) {

        String[] r = new String[2];
        r[0] = new String(s);
        r[1] = "" + i;
        return r;
    }

    public String toString1(String[] s1) {
        String s = "\n";
        for (int i = 0; i < s1.length; i++) {
            s += s1[i] + "\n";
        }
        return s;
    }

    public String toString2(String[][] s2) {

        String s = "\n";
        for (int i = 0; i < s2.length; i++) {
            for (int j = 0; j < s2[0].length; j++) {
                s += s2[i][j] + "\t";
            }
            s += "\n";
        }
        return s;
    }

    public String[] v2a(Vector v) {

        String[] s = new String[v.size()];
        for (int i = 0; i < v.size(); i++) {
            s[i] = (String) v.elementAt(i);
        }
        return s;
    }

    public String[][] concat(String[][] a, String[][] b) {

        if (a == null) return b;
        if (b == null) return a;

        String[][] out = new String[a.length + b.length][Math.max(a[0].length, b[0].length)];
        for (int i = 0; i < a.length; i++) {
            out[i] = a[i];
        }
        for (int j = 0; j < b.length; j++) {
            out[a.length + j] = b[j];
        }
        return out;
    }
}