datasetutils.java

来自「java实现浏览器等本地桌面的功能」· Java 代码 · 共 645 行 · 第 1/2 页

                        if (val != null && !("".equals(val))) {
                            column.setExpression(val);
                        }
                        break;
                    default:
                        //error condition
                        System.out.println("Error in DataSetParser");
                }
            } else if (qName.equals("dataProvider")) {
                String classType = attrs.getValue("class");
                if (classType != null) {
                    try {
                        dataProvider = (DataProvider)Class.forName(classType).newInstance();
                        table.setDataProvider(dataProvider);
                        //TODO There needs to be a more general configuration solution
                        if (dataProvider instanceof SQLDataProvider) {
                            String tableName = attrs.getValue("tableName");
                            if (tableName != null && !tableName.equals("")) {
                                TableCommand cmd = new TableCommand(tableName);
                                cmd.setWhereClause(attrs.getValue("whereClause"));
                                cmd.setOrderByClause(attrs.getValue("orderByClause"));
                                cmd.setHavingClause(attrs.getValue("havingClause"));
                                dataProvider.setCommand(cmd);
                            } else {
                                SQLCommand command = new SQLCommand();
                                command.setCustom(true);
                                command.setSelectSQL(attrs.getValue("select"));
                                command.setInsertSQL(attrs.getValue("insert"));
                                command.setUpdateSQL(attrs.getValue("update"));
                                command.setDeleteSQL(attrs.getValue("delete"));
                                dataProvider.setCommand(command);
                            }
                        }
                    } catch (Exception e) {
                        //hmmm
                        e.printStackTrace();
                    }
                }
            } else if (qName.equals("dataRelationTable")) {
                DataRelationTable drt = ds.createRelationTable(attrs.getValue("name"));
                drt.setRelation((DataRelation)ds.getElement(attrs.getValue("relation")));
                drt.setParentSelector((DataSelector)ds.getElement(attrs.getValue("parentSelector")));
                drt.setParentTable((DataTable)ds.getElement(attrs.getValue("parentTable")));
            } else if (qName.equals("dataRelation")) {
                DataRelation relation = ds.createRelation(attrs.getValue("name"));
                relation.setParentColumn((DataColumn)ds.getElement(attrs.getValue("parentColumn")));
                relation.setChildColumn((DataColumn)ds.getElement(attrs.getValue("childColumn")));
            } else if (qName.equals("dataValue")) {
                DataValue value = ds.createValue(attrs.getValue("name"));
                value.setExpression(attrs.getValue("expression"));
            }
        }

        public void endElement(String uri, String localName, String qName) throws org.xml.sax.SAXException {
            if (qName.equals("xs:element")) {
                switch(elementDepth) {
                    case 1:
                        //this is a dataset tag
                        break;
                    case 2:
                        //this is a table tag
                        break;
                    case 3:
                        //this is a column tag
                        break;
                    default:
                        //error condition
                        System.out.println("Error in DataSetParser");
                }
                elementDepth--;
            }
        }

        public void endDocument() throws org.xml.sax.SAXException {
        }
    }

    public static DataSet createFromDatabaseSchema(JDBCDataConnection conn, String databaseName, String... names) {
        java.util.Set<String> set = new java.util.HashSet<String>();
        for (String name : names) {
            set.add(name);
        }
        DataSet ds = createFromDatabaseSchema(conn.getConnection(), databaseName, set);
        for (DataTable table : ds.getTables()) {
            if (!(table instanceof DataRelationTable) && table.getDataProvider() != null) {
                table.getDataProvider().setConnection(conn);
            }
        }
        return ds;
    }
    
    /**
     * Creates a DataSet based on some DatabaseMetaData information. This method
     * takes a Set of database entity &quot;names&quot; which are of the form:<br>
     * table or table.column
     */
    public static DataSet createFromDatabaseSchema(java.sql.Connection conn, String databaseName, java.util.Set<String> names) {
        DataSet ds = new DataSet();
        try {
            java.util.Set<String> tableNames = new java.util.HashSet<String>();
            for (String name : names) {
                if (name.contains(".")) {
                    tableNames.add(name.substring(0, name.indexOf(".")));
                } else {
                    tableNames.add(name);
                }
            }

            java.sql.DatabaseMetaData md = conn.getMetaData();
//            printResultSet(md.getCatalogs());
//            printResultSet(md.getSchemas());
//            printResultSet(md.getTables(databaseName, null, "package", null));
            for (String tableName : tableNames) {
                DataTable table = ds.createTable(tableName);
                //check to see whether the entire table is to be included, or only some of the table
                if (names.contains(tableName)) {
                    //import all of the table columns
                    System.out.println("Including all columns");
                    java.sql.ResultSet rs = md.getColumns(databaseName, null, tableName, null);
                    while (rs.next()) {
                        DataColumn col = table.createColumn(rs.getString(4));
                        col.setDefaultValue(rs.getObject(13));
//                        col.setKeyColumn(value);
                        col.setReadOnly(false);
                        col.setRequired(rs.getString(18).equals("NO"));
                        col.setType(getType(rs.getInt(5)));
                    }
                } else {
                    //import the key columns, and the specified columns
                    //first, create a set of columns for this table, including
                    //the key column names
                    java.util.Set<String> colNames = new java.util.HashSet<String>();
                    for (String name : names) {
                        if (name.startsWith(tableName) && name.contains(".")) {
                            String colName = name.substring(name.indexOf(".") +1);
                            colNames.add(colName);
                        }
                    }
                    java.sql.ResultSet rs = md.getPrimaryKeys(databaseName, null, tableName);
                    while (rs.next()) {
                        colNames.add(rs.getString(4));
                    }
                
                    //now, get the column information for these columns
                    System.out.println("Including columns: " + colNames);
                    for (String colName : colNames) {
                        rs = md.getColumns(databaseName, null, tableName, colName);
                        while (rs.next()) {
                            DataColumn col = table.createColumn(rs.getString(4));
                            col.setDefaultValue(rs.getObject(13));
//                            col.setKeyColumn(value);
                            col.setReadOnly(false);
                            col.setRequired(rs.getString(18).equals("NO"));
                            col.setType(getType(rs.getInt(5)));
                        }
                    }
                    
//                md.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);
//                printResultSet(md.getExportedKeys(databaseName, null, tableName));
//                printResultSet(md.getImportedKeys(databaseName, null, tableName));
//                md.getTables(catalog, schemaPattern, tableNamePattern, types);
                }
                
                //create the DataProvider
                org.jdesktop.dataset.provider.sql.SQLDataProvider dp = new org.jdesktop.dataset.provider.sql.SQLDataProvider(tableName);
                table.setDataProvider(dp);
            }
            
            //now that all of the tables are created, create the relations
            for (String tableName : tableNames) {
                java.sql.ResultSet rs = md.getImportedKeys(databaseName, null, tableName);
//                System.out.println(tableName + ":");
//                printResultSet(rs);
                while (rs.next()) {
                    //TODO for now, DataRelations only support a single column,
                    //so if the sequence is > 1, skip it
                    if (rs.getInt(9) > 1) {
                        continue;
                    }
                    String childTableName = rs.getString(7);
                    String childColName = rs.getString(8);
                    DataTable parentTable = ds.getTable(tableName);
                    DataColumn parentColumn = parentTable.getColumn(rs.getString(4));
                    DataTable childTable = ds.getTable(childTableName);
                    DataColumn childColumn = childTable.getColumn(childColName);
                    if (parentColumn != null && childColumn != null && parentColumn != childColumn) {
                        DataRelation rel = ds.createRelation(rs.getString(12));
                        rel.setParentColumn(parentColumn);
                        rel.setChildColumn(childColumn);
                    } else if (parentColumn == childColumn) {
                        System.out.println("column identity: " + childTableName + "." + childColName + " = " + parentTable.getName() + "." + parentColumn.getName());
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return ds;
    }
    
    private static Class getType(int type) {
        switch (type) {
            case java.sql.Types.ARRAY:
                return Object.class;
            case java.sql.Types.BIGINT:
                return java.math.BigInteger.class;
            case java.sql.Types.BINARY:
                return Boolean.class;
            case java.sql.Types.BIT:
                return Boolean.class;
            case java.sql.Types.BLOB:
                return byte[].class;
            case java.sql.Types.BOOLEAN:
                return Boolean.class;
            case java.sql.Types.CHAR:
                return Character.class;
            case java.sql.Types.CLOB:
                return char[].class;
            case java.sql.Types.DATALINK:
                return Object.class;
            case java.sql.Types.DATE:
                return java.util.Date.class;
            case java.sql.Types.DECIMAL:
                return java.math.BigDecimal.class;
            case java.sql.Types.DISTINCT:
                return Object.class;
            case java.sql.Types.DOUBLE:
                return BigDecimal.class;
            case java.sql.Types.FLOAT:
                return java.math.BigDecimal.class;
            case java.sql.Types.INTEGER:
                return java.math.BigInteger.class;
            case java.sql.Types.JAVA_OBJECT:
                return Object.class;
            case java.sql.Types.LONGVARBINARY:
                return byte[].class;
            case java.sql.Types.LONGVARCHAR:
                return String.class;
            case java.sql.Types.NULL:
                return Object.class;
            case java.sql.Types.NUMERIC:
                return java.math.BigDecimal.class;
            case java.sql.Types.OTHER:
                return Object.class;
            case java.sql.Types.REAL:
                return java.math.BigDecimal.class;
            case java.sql.Types.REF:
                return Object.class;
            case java.sql.Types.SMALLINT:
                return Integer.class;
            case java.sql.Types.STRUCT:
                return Object.class;
            case java.sql.Types.TIME:
                return java.util.Date.class;
            case java.sql.Types.TIMESTAMP:
                return java.util.Date.class;
            case java.sql.Types.TINYINT:
                return Integer.class;
            case java.sql.Types.VARBINARY:
                return byte[].class;
            case java.sql.Types.VARCHAR:
                return String.class;
            default:
                System.out.println("Unsupported type");
                return Object.class;
        }
    }
    
    //helper method used for debugging
    private static void printResultSet(java.sql.ResultSet rs) throws Exception {
        //print out the result set md
        java.sql.ResultSetMetaData md = rs.getMetaData();
        StringBuilder buffer = new StringBuilder();
        StringBuilder lineBuffer = new StringBuilder();
        for (int i=0; i<md.getColumnCount(); i++) {
            buffer.append(pad(md.getColumnName(i+1), ' '));
            for (int j=0; j<20; j++) {
                lineBuffer.append("-");
            }
            if (i < (md.getColumnCount() -1)) {
                buffer.append(" | ");
                lineBuffer.append("---");
            }
        }
        System.out.println(buffer.toString());
        System.out.println(lineBuffer.toString());
        
        buffer = new StringBuilder();
        while (rs.next()) {
            for (int i=0; i<md.getColumnCount(); i++) {
                Object obj = rs.getObject(i+1);
                String data = obj == null ? "<null>" : obj.toString();
                data = pad(data, ' ');
                buffer.append(data);
                if (i < (md.getColumnCount() -1)) {
                    buffer.append(" | ");
                }
            }
            buffer.append("\n");
        }
        System.out.println(buffer.toString());
    }
    
    //helper method used for debugging
    private static String pad(String s, char padChar) {
        if (s == null) {
            return "<null>              ";
        } else if (s.length() > 20) {
            return s.substring(0, 20);
        } else if (s.length() < 20) {
            StringBuilder buffer = new StringBuilder(s);
            for (int i=s.length(); i<20; i++) {
                buffer.append(padChar);
            }
            return buffer.toString();
        } else {
            return s;
        }
    }
}