Ignore:
Timestamp:
02/04/10 21:56:24 (2 years ago)
Author:
kasper
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • MetadataBeans/trunk/src/main/java/org/eobjects/metamodel/XmlDataContextStrategy.java

    r886 r887  
    3737import org.eobjects.metamodel.query.SelectItem; 
    3838import org.eobjects.metamodel.schema.Column; 
     39import org.eobjects.metamodel.schema.MutableColumn; 
    3940import org.eobjects.metamodel.schema.ColumnType; 
     41import org.eobjects.metamodel.schema.ImmutableRelationship; 
     42import org.eobjects.metamodel.schema.MutableSchema; 
     43import org.eobjects.metamodel.schema.MutableTable; 
    4044import org.eobjects.metamodel.schema.Relationship; 
    41 import org.eobjects.metamodel.schema.Schema; 
    4245import org.eobjects.metamodel.schema.Table; 
    4346import org.eobjects.metamodel.schema.TableType; 
    … …  
    5356import org.xml.sax.InputSource; 
    5457 
    55  
    5658/** 
    5759 * A DataContext strategy that reads XML content and maps it to a table-based 
    … …  
    6971        public static final String NATIVE_TYPE_TEXT = "XML Text"; 
    7072        private static final String TEXT_CONTENT_TEMP_SUFFIX = "_metamodel_text_content"; 
    71         private Schema _schema; 
     73        private MutableSchema _schema; 
    7274        private Map<String, List<Object[]>> _tableData = new HashMap<String, List<Object[]>>();; 
    7375        private boolean _autoFlattenTables; 
    … …  
    8688                _autoFlattenTables = autoFlattenTables; 
    8789                _schemaName = schemaName; 
    88                 _schema = new Schema(_schemaName); 
     90                _schema = new MutableSchema(_schemaName); 
    8991                loadSchema(document); 
    9092        } 
    … …  
    195197 
    196198        @Override 
    197         protected Schema getMainSchema() throws MetaModelException { 
     199        protected MutableSchema getMainSchema() throws MetaModelException { 
    198200                loadSchema(); 
    199201                return _schema; 
    … …  
    214216        public XmlDataContextStrategy loadSchema() { 
    215217                if (_schema == null) { 
    216                         _schema = new Schema(_schemaName); 
     218                        _schema = new MutableSchema(_schemaName); 
    217219                        try { 
    218220                                DocumentBuilderFactory dbf = DocumentBuilderFactory 
    … …  
    237239                // node or pure XML structure) 
    238240                Table[] tables = _schema.getTables(); 
    239                 for (Table table : tables) { 
     241                for (Table t : tables) { 
     242                        MutableTable table = (MutableTable) t; 
    240243                        String tableName = table.getName(); 
    241244                        List<Object[]> tableRows = _tableData.get(tableName); 
    … …  
    248251                                Column idColumn = getIdColumn(table); 
    249252                                Column column = table.getColumnByName("id"); 
    250                                 if (column == null) { 
    251                                         idColumn.setName("id"); 
     253                                if (column == null && column instanceof MutableColumn) { 
     254                                        ((MutableColumn) idColumn).setName("id"); 
    252255                                } 
    253256 
    … …  
    264267                                } 
    265268                                if (!found) { 
    266                                         table.removeColumn(textContentColumn); 
     269                                        ((MutableTable) table).removeColumn(textContentColumn); 
    267270                                } else { 
    268271                                        // Rename all text content columns to reasonable 
    … …  
    274277                                        column = table.getColumnByName(preferredName); 
    275278                                        if (column == null) { 
    276                                                 textContentColumn.setName(preferredName); 
     279                                                ((MutableColumn) textContentColumn) 
     280                                                                .setName(preferredName); 
    277281                                        } 
    278282                                } 
    … …  
    285289 
    286290        private void loadTables(Element element, String tablePrefix, 
    287                         Column parentKeyColumn, int parentKey) { 
     291                        MutableColumn parentKeyColumn, int parentKey) { 
    288292                Attr[] attributes = getAttributes(element); 
    289293                String textContent = getTextContent(element); 
    … …  
    292296                                || hasSiblings(element)) { 
    293297                        // We need to represent this type of node with a table 
    294                         Table table = _schema.getTableByName(tableName); 
     298                        MutableTable table = (MutableTable) _schema 
     299                                        .getTableByName(tableName); 
    295300                        Column idColumn; 
    296                         Column foreignKeyColumn; 
     301                        MutableColumn foreignKeyColumn; 
    297302                        List<Object[]> tableRows; 
    298303                        if (table == null) { 
    299304                                _log.info("Creating table: " + tableName); 
    300                                 table = new Table(tableName, TableType.TABLE, _schema); 
     305                                table = new MutableTable(tableName, TableType.TABLE, _schema); 
    301306                                _schema.addTable(table); 
    302307                                idColumn = getIdColumn(table); 
    … …  
    306311                                if (parentKeyColumn != null) { 
    307312                                        Table parentTable = parentKeyColumn.getTable(); 
    308                                         foreignKeyColumn = new Column( 
    309                                                         parentTable.getName() + "_id", parentKeyColumn 
    310                                                                         .getType(), table, table.getColumnCount(), 
    311                                                         false); 
     313                                        foreignKeyColumn = new MutableColumn(parentTable.getName() 
     314                                                        + "_id", parentKeyColumn.getType(), table, table 
     315                                                        .getColumnCount(), false); 
    312316                                        foreignKeyColumn.setNativeType(NATIVE_TYPE_FOREIGN_KEY); 
    313                                         table.addColumn(foreignKeyColumn); 
    314  
    315                                         Relationship.createRelationship( 
    316                                                         new Column[] { parentKeyColumn }, 
    317                                                         new Column[] { foreignKeyColumn }); 
     317                                        ((MutableTable) table).addColumn(foreignKeyColumn); 
     318 
     319                                        ImmutableRelationship.createRelationship( 
     320                                                        new MutableColumn[] { parentKeyColumn }, 
     321                                                        new MutableColumn[] { foreignKeyColumn }); 
    318322 
    319323                                } else { 
    … …  
    325329                                Column[] foreignKeys = table.getForeignKeys(); 
    326330                                if (foreignKeys.length == 1) { 
    327                                         foreignKeyColumn = foreignKeys[0]; 
     331                                        foreignKeyColumn = (MutableColumn) foreignKeys[0]; 
    328332                                } else { 
    329333                                        foreignKeyColumn = null; 
    … …  
    333337                        Column textContentColumn = getTextContentColumn(table, element 
    334338                                        .getNodeName()); 
    335                         Map<Column, String> columnValues = new HashMap<Column, String>(); 
     339                        Map<MutableColumn, String> columnValues = new HashMap<MutableColumn, String>(); 
    336340                        for (Attr attr : attributes) { 
    337341                                String name = attr.getName(); 
    338                                 Column column = table.getColumnByName(name); 
     342                                MutableColumn column = (MutableColumn) table 
     343                                                .getColumnByName(name); 
    339344                                if (column == null) { 
    340345                                        _log.info("Creating column: " + tableName + "." + name); 
    341                                         column = new Column(name, ColumnType.VARCHAR, table, table 
    342                                                         .getColumnCount(), true); 
     346                                        column = new MutableColumn(name, ColumnType.VARCHAR, table, 
     347                                                        table.getColumnCount(), true); 
    343348                                        column.setNativeType(NATIVE_TYPE_ATTRIBUTE); 
    344                                         table.addColumn(column); 
     349                                        ((MutableTable) table).addColumn(column); 
    345350                                } 
    346351                                columnValues.put(column, attr.getValue()); 
    … …  
    360365                        } 
    361366                        // Add values for attributes 
    362                         for (Entry<Column, String> entry : columnValues.entrySet()) { 
     367                        for (Entry<MutableColumn, String> entry : columnValues.entrySet()) { 
    363368                                rowData[entry.getKey().getColumnNumber()] = entry.getValue(); 
    364369                        } 
    … …  
    373378                                // child tables can create relationship to it 
    374379                                parentKey = id; 
    375                                 parentKeyColumn = idColumn; 
     380                                parentKeyColumn = (MutableColumn) idColumn; 
    376381                        } 
    377382                        tableRows.add(rowData); 
    … …  
    400405                        _log.info("Creating text content column for table: " 
    401406                                        + table.getName()); 
    402                         column = new Column(preferredColumnName + TEXT_CONTENT_TEMP_SUFFIX, 
    403                                         ColumnType.VARCHAR, table, table.getColumnCount(), true); 
    404                         column.setNativeType(NATIVE_TYPE_TEXT); 
    405                         table.addColumn(column); 
     407                        MutableColumn c = new MutableColumn(preferredColumnName 
     408                                        + TEXT_CONTENT_TEMP_SUFFIX, ColumnType.VARCHAR, table, 
     409                                        table.getColumnCount(), true); 
     410                        c.setNativeType(NATIVE_TYPE_TEXT); 
     411                        ((MutableTable) table).addColumn(c); 
     412                        column = c; 
     413 
    406414                } 
    407415                return column; 
    408416        } 
    409417 
    410         private Column getIdColumn(Table table) { 
     418        private Column getIdColumn(MutableTable table) { 
    411419                Column[] columns = table.getColumns(); 
    412420                Column column = null; 
    413421                for (Column col : columns) { 
    414422                        if (NATIVE_TYPE_PRIMARY_KEY.equals(col.getNativeType())) { 
    415                                 column = col; 
     423                                column = (MutableColumn) col; 
    416424                                break; 
    417425                        } 
    … …  
    420428                        String tableName = table.getName(); 
    421429                        _log.info("Creating id column for table: " + tableName); 
    422                         column = new Column(tableName + "_metamodel_surrogate_id", 
    423                                         ColumnType.INTEGER, table, table.getColumnCount(), false); 
    424                         column.setNativeType(NATIVE_TYPE_PRIMARY_KEY); 
    425                         column.setIndexed(true); 
    426                         table.addColumn(column); 
     430                        MutableColumn c = new MutableColumn(tableName 
     431                                        + "_mdbeans_surrogate_id", ColumnType.INTEGER, table, table 
     432                                        .getColumnCount(), false); 
     433                        c.setNativeType(NATIVE_TYPE_PRIMARY_KEY); 
     434                        c.setIndexed(true); 
     435                        table.addColumn(c); 
     436                        column = c; 
    427437                } 
    428438                return column; 
    … …  
    492502 
    493503        public XmlDataContextStrategy flattenTables(Relationship relationship) { 
    494                 Table primaryTable = relationship.getPrimaryTable(); 
    495                 Table foreignTable = relationship.getForeignTable(); 
     504                MutableTable primaryTable = (MutableTable) relationship 
     505                                .getPrimaryTable(); 
     506                MutableTable foreignTable = (MutableTable) relationship 
     507                                .getForeignTable(); 
    496508 
    497509                // Check that foreignTable is not primary table in other relationships 
    … …  
    530542 
    531543                Query q = new Query(); 
    532                 q.select(primaryColumns.toArray(new Column[primaryColumns.size()])); 
    533                 q.select(foreignColumns.toArray(new Column[foreignColumns.size()])); 
     544                q.select(primaryColumns 
     545                                .toArray(new MutableColumn[primaryColumns.size()])); 
     546                q.select(foreignColumns 
     547                                .toArray(new MutableColumn[foreignColumns.size()])); 
    534548                q.from(new FromItem(JoinType.LEFT, relationship)); 
    535549                if (_log.isDebugEnabled()) { 
    … …  
    540554 
    541555                for (Column foreignColumn : foreignColumns) { 
    542                         Column newPrimaryColumn = new Column(foreignColumn.getName(), 
    543                                         foreignColumn.getType(), primaryTable, primaryTable 
    544                                                         .getColumnCount(), foreignColumn.isNullable()); 
     556                        MutableColumn newPrimaryColumn = new MutableColumn(foreignColumn 
     557                                        .getName(), foreignColumn.getType(), primaryTable, 
     558                                        primaryTable.getColumnCount(), foreignColumn.isNullable()); 
    545559                        newPrimaryColumn.setIndexed(foreignColumn.isIndexed()); 
    546560                        newPrimaryColumn.setNativeType(foreignColumn.getNativeType()); 
    547                         primaryTable.addColumn(newPrimaryColumn); 
     561                        ((MutableTable) primaryTable).addColumn(newPrimaryColumn); 
    548562                } 
    549563                _tableData.put(primaryTableName, tableRows); 
    550                 foreignTable.getSchema().removeTable(foreignTable); 
     564                ((MutableSchema) foreignTable.getSchema()).removeTable(foreignTable); 
    551565                _tableData.remove(foreignTableName); 
    552                 relationship.remove(); 
     566                ImmutableRelationship.remove(relationship); 
    553567 
    554568                if (_log.isInfoEnabled()) { 
Note: See TracChangeset for help on using the changeset viewer.