Changeset 8013 for mauRepo


Ignore:
Timestamp:
09/12/11 15:54:50 (8 years ago)
Author:
mnagni
Message:

At first run MOLES3 Editor uses correctly all the python classes and SQLAlchemy tables generated by this code. That's good!

Location:
mauRepo/xmi2sqlalchemy/trunk/src
Files:
6 edited
1 moved

Legend:

Unmodified
Added
Removed
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTablesClosure.java

    r8009 r8013  
    2929package ndg.services.newmoon.velocity.python; 
    3030 
    31 import java.io.File; 
    32 import java.io.FileWriter; 
    3331import java.io.IOException; 
    34 import java.io.Writer; 
    3532import java.util.ArrayList; 
    36 import java.util.Collection; 
    37 import java.util.Collections; 
    3833import java.util.HashSet; 
    3934import java.util.Iterator; 
     
    4338import ndg.services.newmoon.NewmoonException; 
    4439import ndg.services.newmoon.UMLElementsArchive; 
    45 import ndg.services.newmoon.UMLElementsArchive.PropertyMap; 
    4640import ndg.services.newmoon.collect.AttributeModel; 
    4741import ndg.services.newmoon.collect.ClassModel; 
    48 import ndg.services.newmoon.collect.ClassModel.STEREOTYPE; 
    4942import ndg.services.newmoon.velocity.python.support.AssociationTable; 
    5043import ndg.services.newmoon.velocity.python.support.ForeignKey; 
    51 import ndg.services.newmoon.velocity.python.support.ImportCollector; 
    52 import ndg.services.newmoon.velocity.python.support.OverriddenAttribute; 
    5344import ndg.services.newmoon.velocity.python.support.Relationship; 
    5445import ndg.services.newmoon.velocity.python.support.Relationship.RELATION_TYPE; 
     
    5647import ndg.services.newmoon.xmiModel.UMLClass; 
    5748import ndg.services.newmoon.xmiModel.UMLClassDataType; 
    58 import ndg.services.newmoon.xmiModel.UMLDataType; 
    5949 
    6050import org.apache.commons.collections.Closure; 
    6151import org.apache.commons.collections.CollectionUtils; 
    62 import org.apache.commons.lang.StringUtils; 
    63 import org.apache.commons.lang.text.StrBuilder; 
    64 import org.apache.velocity.context.Context; 
    6552import org.slf4j.Logger; 
    6653import org.slf4j.LoggerFactory; 
     
    7057 *  
    7158 */ 
    72 public class InnerGenerateTablesClosure implements Closure { 
    73  
    74         private enum CONTEXT { 
    75                 tableModel, umlClass, simpleAttributes, imports, mapping, inheritedParents, associationTable, notSortable 
    76         }; 
    77  
    78         private final ImportCollector importCollector = new ImportCollector(); 
    79  
    80         private final static String tableTemplateFile = "velocity/python/sqlAlchemyTables.vm"; 
    81  
    82         private final StrBuilder sqlTablesStrBuffer = new StrBuilder(1000); 
    83  
    84         // Collects the necessary classes to import 
    85         private final static String importTemplateFile = "velocity/python/importing.vm"; 
    86         // Collects the information about the relations between the mappers 
    87         private final static String mapperTemplateFile = "velocity/python/mapping.vm"; 
    88         // Collects the information about the relations between the not sortable 
    89         // mappers (first step) 
    90         private final static String notSortableMapperTemplateFile_1 = "velocity/python/notSortableMapping_1.vm"; 
    91         // Collects the information about the relations between the not sortable 
    92         // mappers (second step) 
    93         private final static String notSortableMapperTemplateFile_2 = "velocity/python/notSortableMapping_2.vm"; 
    94         // Collects the information to build a manytomany adapter table 
    95         private final static String associationTemplateFile = "velocity/python/association.vm"; 
    96  
     59public class GenerateTablesClosure implements Closure { 
    9760        private final Set<TableModel> tableModels = new HashSet<TableModel>(); 
    9861        private final Set<AssociationTable> associationTable = new HashSet<AssociationTable>(); 
    9962        private final Set<TableModel> notSortable = new HashSet<TableModel>(); 
    100  
    101         private final Context vcontext = NmVelocity.getInstance().createContext(); 
    102         private GenerateModuleHelper helper; 
    10363        private List<NewmoonException> exceptions = new ArrayList<NewmoonException>(); 
    10464 
    10565        private final Logger logger = LoggerFactory 
    106                         .getLogger(InnerGenerateTablesClosure.class); 
     66                        .getLogger(GenerateTablesClosure.class); 
    10767 
    10868        /** 
     
    164124        private void collectData(TableModel tm) throws NewmoonException, 
    165125                        IOException { 
    166                 updateImportToSQLTables(tm.getAssociatedClass()); 
    167126                parseAttributes(tm); 
    168127                collectInheritedParents(tm); 
    169                 updateImportToSQLTables(tm.getAssociatedClass()); 
    170128                addInheritanceAsComposition(tm); 
    171129        } 
     
    196154                                        || am.isVoidable(); 
    197155 
    198                         Relationship rl = new Relationship(parent, child, am.getName(), 
    199                                         nullable); 
     156                        Relationship rl = new Relationship(parent, child, am.getName(), nullable, false); 
    200157 
    201158                        if (am.hasMultiplicity() && parent.equals(child)) { 
     
    225182 
    226183                        TableModel parent = processUMLclass(cm); 
    227                         Relationship rl = new Relationship(child, parent, parent.getAssociatedClass().getName(), 
    228                                         false); 
     184                        Relationship rl = new Relationship(child, parent, '_' + parent.getAssociatedClass().getName().toLowerCase(), 
     185                                        false, true); 
    229186                         
    230187                        ForeignKey fk = new ForeignKey(child, parent.getAssociatedClass().getName()); 
     
    270227                } 
    271228        } 
    272  
    273         private <E> void applyTemplate(Collection<E> models, CONTEXT contextName, 
    274                         StrBuilder sb, String templateName) { 
    275                 Iterator<E> iter = models.iterator(); 
    276                 Object item = null; 
    277                 while (iter.hasNext()) { 
    278                         item = iter.next(); 
    279                         if (item instanceof TableModel && ((TableModel) item).isSkipIt()) 
    280                                 continue; 
    281  
    282                         try { 
    283                                 getVcontext().put(contextName.name(), item); 
    284                                 sb.append(NmVelocity.getInstance().fillTemplate(getVcontext(), 
    285                                                 templateName)); 
    286                         } catch (Exception e) { 
    287                                 e.printStackTrace(); 
    288                         } 
    289                 } 
    290         } 
    291  
    292         protected void writeAll() throws IOException { 
    293  
    294                 checkReciprocalTables(); 
    295  
    296                 List<TableModel> tbs = sortTableModels(); 
    297                 // -- THINK BEFORE CHANGE THE ORDER!! --// 
    298                 applyTemplate(tbs, CONTEXT.tableModel, sqlTablesStrBuffer, 
    299                                 tableTemplateFile); 
    300                 applyTemplate(notSortable, CONTEXT.tableModel, sqlTablesStrBuffer, 
    301                                 tableTemplateFile); 
    302  
    303                 applyTemplate(associationTable, CONTEXT.associationTable, 
    304                                 sqlTablesStrBuffer, associationTemplateFile); 
    305  
    306                 applyTemplate(tbs, CONTEXT.tableModel, sqlTablesStrBuffer, 
    307                                 mapperTemplateFile); 
    308  
    309                 Set<TableModel> nsSimple = new HashSet<TableModel>(); 
    310                 Iterator<TableModel> iter = notSortable.iterator(); 
    311                 while (iter.hasNext()) { 
    312                         TableModel tm = iter.next(); 
    313                         if (tm.getInherited().size() == 0) { 
    314                                 nsSimple.add(tm); 
    315                                 iter.remove(); 
    316                         } 
    317                 } 
    318  
    319                 applyTemplate(nsSimple, CONTEXT.tableModel, sqlTablesStrBuffer, 
    320                                 notSortableMapperTemplateFile_1); 
    321                 applyTemplate(notSortable, CONTEXT.tableModel, sqlTablesStrBuffer, 
    322                                 notSortableMapperTemplateFile_1); 
    323                 applyTemplate(nsSimple, CONTEXT.tableModel, sqlTablesStrBuffer, 
    324                                 notSortableMapperTemplateFile_2); 
    325                 applyTemplate(notSortable, CONTEXT.tableModel, sqlTablesStrBuffer, 
    326                                 notSortableMapperTemplateFile_2); 
    327                 // -------------------------------------// 
    328  
    329                 Writer sqlTablesWriter = new FileWriter(new File(getHelper() 
    330                                 .getBaseDir(), "sqlTables.py"), true); 
    331                 sqlTablesWriter 
    332                                 .append("from sqlalchemy import Table, Column, Integer, String, ForeignKey, Sequence, event, MetaData\n"); 
    333                 sqlTablesWriter 
    334                                 .append("from sqlalchemy.orm import relationship, backref, mapper, clear_mappers\n"); 
    335                 sqlTablesWriter 
    336                                 .append("from sqlalchemy.ext.declarative import declarative_base\n"); 
    337                 sqlTablesWriter 
    338                                 .append("from sqlalchemy.dialects.postgresql import ARRAY, TEXT, NUMERIC, BOOLEAN, DATE\n"); 
    339                 sqlTablesWriter.append("from sqlalchemy.types import DateTime\n"); 
    340                 sqlTablesWriter 
    341                                 .append("from sqlalchemy.orm.util import class_mapper\n"); 
    342                 sqlTablesWriter 
    343                                 .append("from sqlalchemy.schema import ForeignKeyConstraint\n\n"); 
    344  
    345                 sqlTablesWriter.flush(); 
    346  
    347                 // import 
    348                 getVcontext().put(CONTEXT.imports.name(), 
    349                                 importCollector.getImportMap()); 
    350                 sqlTablesWriter.append(NmVelocity.getInstance().fillTemplate( 
    351                                 getVcontext(), importTemplateFile)); 
    352                 sqlTablesWriter.append("\n\n"); 
    353                 sqlTablesWriter.append("clear_mappers()\n"); 
    354                 sqlTablesWriter.append("metadata = MetaData()\n"); 
    355                 sqlTablesWriter.append("def next_id(connection, seq_name):\n"); 
    356                 sqlTablesWriter.append("    seq = Sequence(seq_name)\n"); 
    357                 sqlTablesWriter.append("    seq.create(bind=connection)\n"); 
    358                 sqlTablesWriter.append("    return connection.execute(seq)\n"); 
    359                 sqlTablesWriter.append("\n\n"); 
    360                 sqlTablesWriter.append(sqlTablesStrBuffer.toString()); 
    361                 sqlTablesWriter.append("metadata.create_all(engine)\n"); 
    362                 sqlTablesWriter.append("\n\n"); 
    363                 sqlTablesWriter.close(); 
    364         } 
    365  
    366         public void updateImportToSQLTables(UMLClass umlClass) { 
    367                 synchronized (importCollector) { 
    368                         importCollector.updateImports(umlClass); 
    369                 } 
    370         } 
    371  
    372         private void checkReciprocalTables() { 
    373                 Iterator<TableModel> iterator = getTableModels().iterator(); 
    374                 while (iterator.hasNext()) { 
    375                         TableModel tb = iterator.next(); 
    376  
    377                         /* 
    378                          * Checks if one attribute or one of attribuite's children refers 
    379                          * back to this TableModel 
    380                          */ 
    381                         checkTableLoop(tb); 
    382  
    383                         /* 
    384                          * Checks if one attribute of this TableModel 1) has the same name 
    385                          * as one of TableModel's parents 2) has one of the TableModel's 
    386                          * parent as parent too and eventually set up a many-to-many 
    387                          * relationship 
    388                          */ 
    389                         checkTableAttributeOverriding(tb); 
    390                 } 
    391         } 
    392  
    393         private void checkTableAttributeOverriding(TableModel tb) { 
    394                 Set<TableModel> ovm = new HashSet<TableModel>(); 
    395                 for (AttributeModel am : tb.getAttributeModel()) { 
    396                         ovm.clear(); 
    397                         for (TableModel inherited : tb.getInherited()) { 
    398                                 for (AttributeModel inhAttribute : inherited 
    399                                                 .getAttributeModel()) { 
    400                                         if (inhAttribute.getName().equals(am.getName())) { 
    401                                                 ovm.add(tb); 
    402                                                 ovm.add(inherited); 
    403                                         } 
    404                                 } 
    405                         } 
    406                         if (!ovm.isEmpty()) { 
    407                                 tb.getOa().add(new OverriddenAttribute(ovm, am.getName())); 
    408                         } 
    409                 } 
    410         } 
    411  
    412         private void checkTableLoop(TableModel tb) { 
    413                 Iterator<Relationship> iterator = tb.getRelationship().iterator(); 
    414                 while (iterator.hasNext()) { 
    415                         Relationship rl = iterator.next(); 
    416                         LoopFinder lf = new LoopFinder(rl, getTableModels().size()); 
    417                         lf.search(); 
    418                 } 
    419  
    420                 Iterator<TableModel> tm = tb.getInherited().iterator(); 
    421                 while (tm.hasNext()) { 
    422                         solveForeignLoop(tm.next(), tb); 
    423                 } 
    424         } 
    425  
    426         /** 
    427          * On the first pass the algorithm creates the inheritance relation in the 
    428          * form 
    429          *  
    430          * // * --parent Column('id', primaryKey) 
    431          *  
    432          * --child Column('parent_id', ForeignKey('parent.id'), primaryKey) 
    433          *  
    434          * now if the child has an attribute[0..*] of the parent type 
    435          *  
    436          * the structure is similar to 
    437          *  
    438          * --parent Column('id', primaryKey) --parent Column('child_id', 
    439          * ForeignKey('child.id')) 
    440          *  
    441          *  
    442          * --child Column('parent_id', ForeignKey('parent.id'), primaryKey) 
    443          * --mapper(child, relationship(ParentType, 'child_field')) 
    444          *  
    445          * which creates a circular reference 
    446          *  
    447          * is necessary to modify the relation type to a many-to-many type and for 
    448          * this is necessary 1) to delete the foreignkey from the parent 2) modify 
    449          * the relation on the child 3) create a third (association) table 
    450          **/ 
    451         private void solveForeignLoop(TableModel parent, TableModel child) { 
    452                 Iterator<ForeignKey> fk = parent.getFk().iterator(); 
    453                 while (fk.hasNext()) { 
    454                         ForeignKey tmp_fk = fk.next(); 
    455                         if (!tmp_fk.getTableModel().equals(child)) 
    456                                 continue; 
    457  
    458                         AssociationTable at = new AssociationTable(parent, child); 
    459                         if (!associationTable.contains(at)) { 
    460                                 // create the third (association) table 
    461                                 associationTable.add(at); 
    462                                 updateRelationToManyToMany(child, parent); 
    463                                 fk.remove(); 
    464                                 continue; 
    465                         } 
    466                 } 
    467  
    468         } 
    469  
    470         private class LoopFinder { 
    471                 private final int maxPathLength; 
    472                 private List<TableModel> oldPath = new ArrayList<TableModel>(); 
    473                 private final Relationship relationship; 
    474  
    475                 public LoopFinder(Relationship relationship, List<TableModel> oldPath, 
    476                                 int maxPathLength) { 
    477                         super(); 
    478                         this.relationship = relationship; 
    479                         this.maxPathLength = maxPathLength; 
    480                         this.oldPath.add(relationship.getFromTable()); 
    481                         this.oldPath.addAll(oldPath); 
    482                 } 
    483  
    484                 public LoopFinder(Relationship relationship, int maxPathLength) { 
    485                         this(relationship, new ArrayList<TableModel>(), maxPathLength); 
    486                 } 
    487  
    488                 public void search() { 
    489                         if (maxPathLength == oldPath.size()) 
    490                                 return; 
    491                         if (relationship.getBackrefName() != null) 
    492                                 return; 
    493                         if (oldPath.contains(relationship.getToTable())) { 
    494                                 checkReciprocalReference(relationship); 
    495                         } else { 
    496                                 Iterator<Relationship> iterator = relationship.getToTable() 
    497                                                 .getRelationship().iterator(); 
    498                                 while (iterator.hasNext()) { 
    499                                         Relationship item = iterator.next(); 
    500                                         LoopFinder lf = new LoopFinder(item, oldPath, maxPathLength); 
    501                                         lf.search(); 
    502                                 } 
    503                         } 
    504                 } 
    505  
    506                 /** 
    507                  * On the first pass the algorithm has created one-to-many relation in 
    508                  * the form 
    509                  *  
    510                  * --parent mapper(parent, relationship(ChildType, 'parent_field')) 
    511                  *  
    512                  * --child Column('parent_id', ForeignKey('parent.id')) 
    513                  *  
    514                  * now if 1) the parent has an attribute of the child type 2) the child 
    515                  * has an attribute of the parent type 
    516                  *  
    517                  * the structure is similar to 
    518                  *  
    519                  * --parent Column('child_id', ForeignKey('child.id')) mapper(parent, 
    520                  * relationship(ChildType, 'parent_field')) 
    521                  *  
    522                  * --child Column('parent_id', ForeignKey('parent.id')) mapper(child, 
    523                  * relationship(ParentType, 'child_field')) 
    524                  *  
    525                  * if there is a reciprocal one-to-many reference is necessary to modify 
    526                  * the relation type to a many-to-many type and for this is necessary 1) 
    527                  * to delete the foreignkey from both 2) delete the relation on the 
    528                  * child 3) create a third (association) table 4) modify appropriately 
    529                  * the parent relationship 
    530                  **/ 
    531                 private void checkReciprocalReference(Relationship rl) { 
    532                         // if the table has a self-reference is ok 
    533                         if (!rl.getFromTable().equals(rl.getToTable()) 
    534                                         && !rl.isManyToMany()) { 
    535                                 if (associationTable.contains(new AssociationTable(rl 
    536                                                 .getFromTable(), rl.getToTable())) 
    537                                                 || associationTable.contains(new AssociationTable(rl 
    538                                                                 .getToTable(), rl.getFromTable()))) 
    539                                         return; 
    540  
    541                                 // validate the relationship 
    542                                 updateRelationToManyToMany(rl.getToTable(), rl); 
    543                         } 
    544                 } 
    545         } 
    546  
    547         private void updateRelationToManyToMany(TableModel child, 
    548                         Relationship onParent) { 
    549                 Iterator<Relationship> onChildIterator = child.getRelationship() 
    550                                 .iterator(); 
    551                 while (onChildIterator.hasNext()) { 
    552                         Relationship onChild = onChildIterator.next(); 
    553                         // Are the tables referring one to another? 
    554                         if (onParent.getToTable().equals(onChild.getFromTable())) { 
    555                                 // Are both the relations one-to-many? 
    556                                 if (onParent.isManyToOne() && onChild.isManyToOne()) { 
    557                                         onParent.setRelationType(RELATION_TYPE.MANY_TO_MANY); 
    558                                         onParent.setBackrefName(onChild.getName()); 
    559                                         // Remove the reciprocal one-to-many foreign keys 
    560                                         removeFKFromTables(onParent, onChild); 
    561                                         onChildIterator.remove(); 
    562                                         associationTable.add(new AssociationTable(onChild)); 
    563                                 } else { 
    564                                         // is a "simple" loop reference. Has to solve with the 
    565                                         // "use_alter" SqlAlchemy's ForeignKey option 
    566                                         useAlterInFKFromTableModel(onParent, onChild); 
    567                                 } 
    568                         } 
    569                 } 
    570         } 
    571  
    572         private void removeFKFromTables(Relationship onParent, Relationship onChild) { 
    573                 removeFKFromTableModel(onParent.getFromTable(), onChild.getName(), 
    574                                 onParent.getToTable()); 
    575                 removeFKFromTableModel(onParent.getToTable(), onParent.getName(), 
    576                                 onParent.getFromTable()); 
    577         } 
    578  
    579         private void useAlterInFKFromTableModel(Relationship onParent, 
    580                         Relationship onChild) { 
    581                 useAlterInFKFromTableModel(onParent.getFromTable(), onChild.getName(), 
    582                                 onParent.getToTable()); 
    583                 useAlterInFKFromTableModel(onParent.getToTable(), onParent.getName(), 
    584                                 onParent.getFromTable()); 
    585         } 
    586  
    587         private void removeFKFromTableModel(TableModel model, String attrName, 
    588                         TableModel fromModel) { 
    589                 Iterator<ForeignKey> fkchilditerator = model.getFk().iterator(); 
    590                 while (fkchilditerator.hasNext()) { 
    591                         ForeignKey cfk = fkchilditerator.next(); 
    592                         if (cfk.getParentAttributeName().equals(attrName) 
    593                                         && cfk.getTableModel().equals(fromModel)) { 
    594                                 fkchilditerator.remove(); 
    595                                 return; 
    596                         } 
    597                 } 
    598         } 
    599  
    600         private void useAlterInFKFromTableModel(TableModel model, String attrName, 
    601                         TableModel fromModel) { 
    602                 Iterator<ForeignKey> fkchilditerator = model.getFk().iterator(); 
    603                 while (fkchilditerator.hasNext()) { 
    604                         ForeignKey cfk = fkchilditerator.next(); 
    605                         if (cfk.getParentAttributeName().equals(attrName) 
    606                                         && cfk.getTableModel().equals(fromModel)) { 
    607                                 cfk.setUseAlter(true); 
    608                                 return; 
    609                         } 
    610                 } 
    611         } 
    612  
    613         private void updateRelationToManyToMany(TableModel child, 
    614                         TableModel onParent) { 
    615                 for (Relationship rl : child.getRelationship()) { 
    616                         if (!rl.getToTable().equals(onParent)) 
    617                                 continue; 
    618                         rl.setRelationType(RELATION_TYPE.MANY_TO_MANY); 
    619                         return; 
    620                 } 
    621         } 
    622  
    623         private List<TableModel> sortTableModels() { 
    624                 List<TableModel> finalTable = new ArrayList<TableModel>(); 
    625                 Iterator<TableModel> iter = getTableModels().iterator(); 
    626                 TableModel tb = null; 
    627                 notSortable.addAll(getTableModels()); 
    628                 while (iter.hasNext()) { 
    629                         tb = iter.next(); 
    630                         if (tb.getRelationship().size() == 0 
    631                                         && tb.getInherited().size() == 0) { 
    632                                 finalTable.add(tb); 
    633                                 notSortable.remove(tb); 
    634                         } 
    635                 } 
    636  
    637                 int index = -1; 
    638                 while (finalTable.size() < getTableModels().size()) { 
    639                         index = finalTable.size(); 
    640                         if (logger.isDebugEnabled()) 
    641                                 logger.debug("finalTable.size() : tableModels.size() - " 
    642                                                 + String.valueOf(finalTable.size()) + ":" 
    643                                                 + String.valueOf(getTableModels().size())); 
    644                         updateFinalTable(finalTable); 
    645  
    646                         // is possible more optimization? 
    647                         if (index == finalTable.size()) 
    648                                 break; 
    649                 } 
    650                 return finalTable; 
    651         } 
    652  
    653         private void updateFinalTable(List<TableModel> finalTable) { 
    654                 List<TableModel> tm = new ArrayList<TableModel>(notSortable); 
    655                 Collections.shuffle(tm); 
    656                 Iterator<TableModel> iter = tm.iterator(); 
    657                 TableModel tb = null; 
    658                 while (iter.hasNext()) { 
    659                         tb = iter.next(); 
    660                         if (finalTable.contains(tb)) 
    661                                 continue; 
    662  
    663                         boolean add = true; 
    664  
    665                         Iterator<Relationship> innerIter = tb.getRelationship().iterator(); 
    666                         Relationship innerRelation = null; 
    667                         while (innerIter.hasNext()) { 
    668                                 innerRelation = innerIter.next(); 
    669                                 if (innerRelation.getFromTable().equals( 
    670                                                 innerRelation.getToTable())) 
    671                                         continue; 
    672                                 add = finalTable.contains(innerRelation.getToTable()) && add; 
    673                         } 
    674  
    675                         Iterator<TableModel> inheritedIter = tb.getInherited().iterator(); 
    676                         while (inheritedIter.hasNext()) { 
    677                                 add = finalTable.contains(inheritedIter.next()) && add; 
    678                         } 
    679  
    680                         if (add) { 
    681                                 finalTable.add(tb); 
    682                                 notSortable.remove(tb); 
    683                         } 
    684                 } 
    685         } 
    686  
    687         /** 
    688          * @return the vcontext 
    689          */ 
    690         private Context getVcontext() { 
    691                 return vcontext; 
    692         } 
    693  
    694         /** 
    695          * @return the helper 
    696          */ 
    697         private GenerateModuleHelper getHelper() { 
    698                 if (helper == null) 
    699                         try { 
    700                                 helper = new GenerateModuleHelper(); 
    701                         } catch (IOException e) { 
    702                                 // TODO Auto-generated catch block 
    703                                 e.printStackTrace(); 
    704                         } 
    705                 return helper; 
    706         } 
    707229} 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/GenerateTables_.java

    r8012 r8013  
    5151import ndg.services.newmoon.velocity.python.support.Relationship.RELATION_TYPE; 
    5252import ndg.services.newmoon.velocity.python.support.TableModel; 
    53 import ndg.services.newmoon.xmiModel.UMLClass; 
    5453import ndg.services.newmoon.xmiModel.UMLModel; 
    5554 
     
    6968                tableModel, umlClass, simpleAttributes, imports, mapping, inheritedParents, associationTable, notSortable 
    7069        }; 
    71  
    72         private final ImportCollector importCollector = new ImportCollector(); 
    7370 
    7471        private final static String tableTemplateFile = "velocity/python/sqlAlchemyTables.vm"; 
     
    8784        private final static String associationTemplateFile = "velocity/python/association.vm"; 
    8885         
    89         //private final Set<AssociationTable> associationTable = new HashSet<AssociationTable>(); 
    90         //private final Set<TableModel> notSortable = new HashSet<TableModel>(); 
    91          
    9286        private final Context vcontext = NmVelocity.getInstance().createContext(); 
    9387        private GenerateModuleHelper helper; 
     
    109103                CollectionUtils.forAllDo(UMLElementsArchive.getInstance().getUMLClassesByUMLModel(umlModel), ccm); 
    110104                 
    111                 InnerGenerateTablesClosure closure = new InnerGenerateTablesClosure(); 
     105                GenerateTablesClosure closure = new GenerateTablesClosure(); 
    112106                CollectionUtils.forAllDo(ccm.getResult(), closure); 
    113107                writeAll(closure); 
     
    132126        } 
    133127         
    134         private void writeAll(InnerGenerateTablesClosure closure) throws IOException { 
    135                 PythonImportClosure importClosure = new PythonImportClosure(); 
    136    
     128        private void writeAll(GenerateTablesClosure closure) throws IOException { 
     129                PythonImportClosure importClosure = new PythonImportClosure();   
    137130                checkReciprocalTables(closure, importClosure); 
    138131 
     
    192185        } 
    193186 
    194         public void updateImportToSQLTables(UMLClass umlClass) { 
    195                 synchronized (importCollector) { 
    196                         importCollector.updateImports(umlClass); 
    197                 } 
    198         } 
    199  
    200         private void checkReciprocalTables(InnerGenerateTablesClosure closure, PythonImportClosure importClosure) { 
     187        private void checkReciprocalTables(GenerateTablesClosure closure, PythonImportClosure importClosure) { 
    201188                //Imports the classes necessaries for the table declaration 
    202189                CollectionUtils.forAllDo(closure.getTableModels(), importClosure); 
     
    242229        } 
    243230         
    244         private void checkTableLoop(TableModel tb, InnerGenerateTablesClosure closure) { 
     231        private void checkTableLoop(TableModel tb, GenerateTablesClosure closure) { 
    245232                Iterator<Relationship> iterator = tb.getRelationship().iterator(); 
    246233                while (iterator.hasNext()) { 
     
    281268         * relation on the child 3) create a third (association) table  
    282269         **/ 
    283         private void solveForeignLoop(TableModel parent, TableModel child, InnerGenerateTablesClosure closure) { 
     270        private void solveForeignLoop(TableModel parent, TableModel child, GenerateTablesClosure closure) { 
    284271                Iterator<ForeignKey> fk = parent.getFk().iterator(); 
    285272                while (fk.hasNext()) { 
     
    304291                private List<TableModel> oldPath = new ArrayList<TableModel>(); 
    305292                private final Relationship relationship; 
    306                 private final InnerGenerateTablesClosure closure; 
    307                  
    308                 public LoopFinder(Relationship relationship, List<TableModel> oldPath, int maxPathLength, InnerGenerateTablesClosure closure) { 
     293                private final GenerateTablesClosure closure; 
     294                 
     295                public LoopFinder(Relationship relationship, List<TableModel> oldPath, int maxPathLength, GenerateTablesClosure closure) { 
    309296                        super(); 
    310297                        this.relationship = relationship; 
     
    316303                } 
    317304 
    318                 public LoopFinder(Relationship relationship, int maxPathLength, InnerGenerateTablesClosure closure) { 
     305                public LoopFinder(Relationship relationship, int maxPathLength, GenerateTablesClosure closure) { 
    319306                        this(relationship, new ArrayList<TableModel>(), maxPathLength, closure); 
    320307                } 
     
    376363        } 
    377364 
    378         private void updateRelationToManyToMany(TableModel child, Relationship onParent, InnerGenerateTablesClosure closure) { 
     365        private void updateRelationToManyToMany(TableModel child, Relationship onParent, GenerateTablesClosure closure) { 
    379366                Iterator<Relationship> onChildIterator = child.getRelationship().iterator(); 
    380367                while (onChildIterator.hasNext()) { 
     
    439426        }        
    440427         
    441         private List<TableModel> sortTableModels(InnerGenerateTablesClosure closure) { 
     428        private List<TableModel> sortTableModels(GenerateTablesClosure closure) { 
    442429                List<TableModel> finalTable = new ArrayList<TableModel>(); 
    443430                Iterator<TableModel> iter = closure.getTableModels().iterator(); 
     
    466453        } 
    467454         
    468         private void updateFinalTable(List<TableModel> finalTable, InnerGenerateTablesClosure closure) { 
     455        private void updateFinalTable(List<TableModel> finalTable, GenerateTablesClosure closure) { 
    469456                List<TableModel> tm = new ArrayList<TableModel>(closure.getNotSortable()); 
    470457                Collections.shuffle(tm); 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/java/ndg/services/newmoon/velocity/python/support/Relationship.java

    r7996 r8013  
    4545        private RELATION_TYPE relationType = null; 
    4646        private String backrefName = null; 
     47        //If true indicates that even if the relationType is MANY-to-MANY 
     48        //the relation is a ONE-to-ONE relation. 
     49        private final boolean doNotUseList; 
    4750         
    4851        /** 
     
    5255         * @param nullable 
    5356         */ 
    54         public Relationship(TableModel fromTable, TableModel toTable, String name, boolean nullable) { 
     57        public Relationship(TableModel fromTable, TableModel toTable, String name, boolean nullable, boolean doNotUseList) { 
    5558                super(); 
    5659                this.fromTable = fromTable;              
     
    5861                this.name = name; 
    5962                this.nullable = nullable; 
     63                this.doNotUseList = doNotUseList;                
    6064        } 
    6165         
     66        /** 
     67         * @return the doNotUseList 
     68         */ 
     69        public boolean isDoNotUseList() { 
     70                return doNotUseList; 
     71        } 
     72 
     73 
     74 
    6275        public boolean isManyToMany() { 
    6376                return checkRelationType(RELATION_TYPE.MANY_TO_MANY); 
     
    116129        } 
    117130         
    118         public void setRelationType(RELATION_TYPE relationType) { 
    119                 this.relationType = relationType; 
     131        public void setRelationType(RELATION_TYPE relationType) {  
     132                        this.relationType = relationType; 
    120133        } 
    121134 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/global_library.vm

    r8012 r8013  
    3535#if ($relation.isManyToMany()) 
    3636'${relation.name}': relationship(${tt},  
    37 secondary=${tt.toLowerCase()}_${ft.toLowerCase()}_table, 
    38 #if ($relation.backrefName) backref='_${relation.backrefName}' #end 
     37secondary=${tt.toLowerCase()}_${ft.toLowerCase()}_table 
     38#if ($relation.backrefName), backref='_${relation.backrefName}' #end 
    3939#elseif($relation.isOneToMany()) 
    4040'${relation.name}': relationship(${tt} 
    4141#elseif($relation.isOneToOne()) 
    42 '${relation.name}': relationship(${tt}, uselist=False#end 
     42'${relation.name}': relationship(${tt}#end 
     43#if($relation.isOneToOne() || $relation.doNotUseList) 
     44, uselist=False 
     45#end 
    4346#if($tt == $tmn) 
    4447, remote_side=[${tmn.toLowerCase()}_table.c.${tmn.toLowerCase()}_id] 
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/mapping.vm

    r8009 r8013  
    1414#end 
    1515 
    16 #macro( joinInheritedClasses $tableModel) 
    17 #if($tableModel.inherited.size() > 0) 
    18 #foreach( $parent in $parents).join(${parent.associatedClass.name.toLowerCase()}_table)#end 
    19 #end 
     16#if(!$tableModel.associatedClass.name.equals('EARootClass')) 
     17mapper($tableModel.associatedClass.name, #tableName($tableModel)  
     18, properties  = {#relationColumns($tableModel)}) 
    2019#end 
    2120 
    22 #macro( identicalAttributes $tableModel) 
    23 #if($tableModel.oa.size() > 0) 
    24         #foreach( $oa in $tableModel.oa) 
    25                 '${oa.attributeName}': [#tableName($tableModel.associatedClass.name).c.${oa.attributeName} 
    26                 #foreach( $ovAttTable in $oa.models) 
    27                         , #tableName($ovAttTable.associatedClass.name).c.${oa.attributeName} 
    28                 #end]  
    29                 #if($foreach.hasNext),#end                       
    30                 #end 
    31         #end 
    32 #end 
    33  
    34 #macro( generateProperties $tableModel) 
    35         ###if($tableModel.relationship.size() > 0 && $tableModel.oa.size() > 0) 
    36 ##, properties  = {#identicalAttributes($tableModel), #relationColumns($tableModel)} 
    37 ##      #elseif($tableModel.relationship.size() > 0) 
    38 , properties  = {#relationColumns($tableModel)} 
    39 ##      #elseif($tableModel.oa.size() > 0) 
    40 ##, properties  = {#identicalAttributes($tableModel)} 
    41 ##      #end 
    42 #end 
    43  
    44 mapper($tableModel.associatedClass.name, #tableName($tableModel)  
    45 #generateProperties($tableModel)) 
    46  
  • mauRepo/xmi2sqlalchemy/trunk/src/main/resources/velocity/python/pythonClass.vm

    r8012 r8013  
    4141#end 
    4242 
    43 #macro( attributes $classModel) 
    44 #foreach($key in $classModel.attributeModel) 
    45 #if($key.name) 
    46 ${tab}${tab}self._${key.name} 
    47 #end 
    48 #end 
    49 #if($classModel.parents && $classModel.parents.size() > 0) 
    50 #foreach( $parent in $classModel.parents) 
    51 ${tab}${tab}self._${parent.associatedClass.name}         
    52 #end 
    53 #end 
    54 #end 
    55  
    56 #macro (getter $attributeModel, $parentName) 
    57 #set ( $methodName = "$display.capitalize( $attributeModel.name )") 
    58 ${tab}def get${methodName}(self): 
    59 #if($parentName != '') 
    60 ${tab}${tab}return self._${parentName}.${key.name} 
    61 #else 
    62 ${tab}${tab}return self._${key.name} 
    63 #end 
    64 #end 
    65  
    66 #macro (setter $attributeModel, $parentName) 
    67 #set ( $methodName = "$display.capitalize( $attributeModel.name )") 
    68 ${tab}def set${methodName}(self, value): 
    69 #if($parentName != '') 
    70 ${tab}${tab} self._${parentName}.set${methodName}(value) 
    71 #else 
    72 ${tab}${tab} self._${key.name} = value 
    73 #end 
    74 #end 
    75  
    76 #macro ( dogettersetter $attributeModel, $parentName) 
    77 #foreach($key in $attributeModel) 
    78 #if($key.name) 
    79  
    80 #getter($key, $parentName) 
    81  
    82 #setter($key, $parentName) 
    83 #end 
    84 #end 
    85 #end 
    86  
    87  
    88 #macro( gettersetter $classModel) 
    89 #dogettersetter( $classModel.attributeModel, '') 
    90 #foreach($parent in $classModel.parents) 
    91 #dogettersetter($parent.attributeModel, $parent.associatedClass.name) 
    92 #end 
    93 #end 
    94  
    95 #macro( addAggregate $classModel) 
    96 #foreach($parent in $classModel.parents) 
    97 #if (!($parent.isEnumeration() || $parent.isCodeList() || $parent.isUnion())) 
    98 ${tab}${tab}self._${parent.associatedClass.name} 
    99 #end 
    100 #end 
    101 #end 
    102  
    10343 
    10444#macro( importing $toImport) 
    105   
    10645#foreach( $key in $toImport.keySet())    
    10746from $key import #foreach( $item in $toImport.get($key)) $item#if($foreach.hasNext),#end 
     
    11150#end 
    11251 
    113 #macro (getter_ $attribute) 
     52#macro (getter $attribute) 
    11453#set ( $methodName = "$display.capitalize( $attribute.name )") 
    11554#if($attribute.parentName) 
    11655${tab}@property 
    11756${tab}def ${attribute.name}(self): 
    118 ${tab}${tab}return self.${attribute.parentName}.${attribute.name} 
     57${tab}${tab}return self._${attribute.parentName.toLowerCase()}.${attribute.name} 
    11958#end 
    12059#end 
    12160 
    122 #macro (setter_ $attribute) 
     61#macro (setter $attribute) 
    12362#set ( $methodName = "$display.capitalize( $attribute.name )") 
    124 ##if($attribute.typeName && !$attribute.typeName.equalsIgnoreCase('CharacterString')) 
    125 ##${tab}${tab} if (isinstance(value, ${attribute.typeName})): 
    126 ##end 
    12763#if($attribute.parentName) 
    12864${tab}@${attribute.name}.setter 
    12965${tab}def ${attribute.name}(self, value): 
    130 ${tab}${tab}${tab} self._${attribute.parentName}.${attribute.name} = value 
     66${tab}${tab}${tab} self._${attribute.parentName.toLowerCase()}.${attribute.name} = value 
    13167#end 
    13268#end 
    13369 
    134 #macro ( dogettersetter_ $attributes) 
     70#macro ( dogettersetter $attributes) 
    13571#foreach($attribute in $attributes) 
    13672 
    137 #getter_($attribute) 
     73#getter($attribute) 
    13874 
    139 #setter_($attribute) 
     75#setter($attribute) 
    14076#end 
    14177#end 
    14278 
    143 #macro( attributes_ $attributes, $parents) 
     79#macro( attributes $attributes, $parents) 
    14480#foreach($attribute in $attributes) 
    14581#if($attribute.parent) 
     
    14985#if($parents) 
    15086#foreach( $parent in $parents) 
    151 ${tab}${tab}self._${parent.associatedClass.name} = ${parent.associatedClass.name}()      
     87${tab}${tab}self._${parent.associatedClass.name.toLowerCase()} = ${parent.associatedClass.name}()        
    15288#end 
    15389#end 
     
    183119#end 
    184120#if (!($classModel.isEnumeration() || $classModel.isCodeList() || $classModel.isUnion())) 
    185 #attributes_($attributes, $classModel.parents) 
     121#attributes($attributes, $classModel.parents) 
    186122${tab}${tab}super(${classModel.associatedClass.name}, self).__init__() 
    187 #dogettersetter_($attributes) 
     123#dogettersetter($attributes) 
    188124#end 
  • mauRepo/xmi2sqlalchemy/trunk/src/test/resources/removeAll

    r7996 r8013  
    33ci_onlineresource, ci_responsibleparty, ci_series, 
    44ci_telephone, clocktime, compositeobservableproperty, 
    5 "date", dateprecision, "datetime", distance, dq_dataquality, 
     5date, dateprecision, datetime, distance, dq_dataquality, 
    66dq_element, dq_result, dq_scope, ex_extent,  
    77ex_geographicdescription, ex_geographicextent, ex_temporalextent, 
     
    1010le_algorithm, le_nominalresolution, le_processing, le_source, 
    1111length, li_lineage, li_processstep, li_source, localname,  
    12 "location", md_aggregateinformation, md_applicationschemainformation,  
     12location, md_aggregateinformation, md_applicationschemainformation,  
    1313md_browsegraphic, md_constraints, md_contentinformation,  
    1414md_digitaltransferoptions, md_distribution, md_distributor, 
     
    2525mo_operation, mo_organization, mo_platform, mo_process, mo_processing, 
    2626mo_project, mo_responsiblepartyinfo, mo_result, mo_specimen,  
    27 mo_specimenprocess, namedvalue, "number", observablepropertyconstraint, 
     27mo_specimenprocess, namedvalue, number, observablepropertyconstraint, 
    2828om_observation, om_process, rs_identifier, rs_referencesystem, 
    29 "any", sc_crs, scale, scopedname, sf_process, sf_samplingfeature, 
    30 sf_specimen, simpleobservableproperty, "time", tm_duration, 
     29any, sc_crs, scale, scopedname, sf_process, sf_samplingfeature, 
     30sf_specimen, simpleobservableproperty, time, tm_duration, 
    3131tm_geometricprimitive, tm_instant, tm_object, tm_period, 
    3232tm_periodduration, tm_position, tm_primitive, tm_temporalposition, 
     
    4040mo_project_mo_project, mo_result_mo_result, om_observation_om_observation, mo_project_mo_observation, 
    4141mo_observation_mo_observationcollection, ci_citation_md_identifier, ceda_project_ceda_observation, 
    42 ceda_observation_ceda_observationcollection, ci_individual, ci_party, ci_responsiblepartyinfo 
     42ceda_observation_ceda_observationcollection, ci_individual, ci_party, ci_responsiblepartyinfo, 
     43ceda_process_ceda_acquisition, ceda_process_ceda_compositeprocess, ci_onlineresource_mo_onlineresource, 
     44clocktime_datetime, date_datetime, earootclass, ex_geographicextent_ex_geographicdescription, 
     45genericname_localname, genericname_scopedname, gf_attributetype, gf_featuretype, gf_propertytype_gf_attributetype, 
     46 
    4347CASCADE; 
    4448 
     
    5963CASCADE;  
    6064 
     65 
     66 SELECT    
     67 'DROP TABLE IF EXISTS '||c.relname ||' CASCADE;'   
     68 FROM pg_catalog.pg_class c   
     69 JOIN pg_catalog.pg_roles r ON r.oid = c.relowner   
     70 LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace   
     71 WHERE c.relkind IN ('r','')   
     72 AND n.nspname NOT IN ('pg_catalog', 'pg_toast')   
     73 AND pg_catalog.pg_table_is_visible(c.oid)   
     74 ORDER BY 1;   
     75 
     76SELECT    
     77 'DROP SEQUENCE IF EXISTS '||c.relname ||' CASCADE;'   
     78 FROM pg_catalog.pg_class c   
     79 JOIN pg_catalog.pg_roles r ON r.oid = c.relowner   
     80 LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace   
     81 WHERE c.relkind IN ('S','')   
     82 AND n.nspname NOT IN ('pg_catalog', 'pg_toast')   
     83 AND pg_catalog.pg_table_is_visible(c.oid)   
     84 ORDER BY 1;   
     85 
     86DROP TABLE IF EXISTS ceda_process_ceda_acquisition CASCADE; 
     87DROP TABLE IF EXISTS ceda_process_ceda_compositeprocess CASCADE; 
     88DROP TABLE IF EXISTS ceda_process_ceda_processing CASCADE; 
     89DROP TABLE IF EXISTS ci_onlineresource_mo_onlineresource CASCADE; 
     90DROP TABLE IF EXISTS clocktime_datetime CASCADE; 
     91DROP TABLE IF EXISTS date_datetime CASCADE; 
     92DROP TABLE IF EXISTS earootclass CASCADE; 
     93DROP TABLE IF EXISTS ex_geographicextent_ex_geographicdescription CASCADE; 
     94DROP TABLE IF EXISTS genericname_localname CASCADE; 
     95DROP TABLE IF EXISTS genericname_scopedname CASCADE; 
     96DROP TABLE IF EXISTS gf_attributetype CASCADE; 
     97DROP TABLE IF EXISTS gf_featuretype CASCADE; 
     98DROP TABLE IF EXISTS gf_propertytype_gf_attributetype CASCADE; 
     99DROP TABLE IF EXISTS io_identifiedobjectbase_sc_crs CASCADE; 
     100DROP TABLE IF EXISTS localname_typename CASCADE; 
     101DROP TABLE IF EXISTS md_identifier_rs_identifier CASCADE; 
     102DROP TABLE IF EXISTS measure_scale CASCADE; 
     103DROP TABLE IF EXISTS measure_time CASCADE; 
     104DROP TABLE IF EXISTS mo_acquisition_ceda_acquisition CASCADE; 
     105DROP TABLE IF EXISTS mo_compositeprocess_ceda_compositeprocess CASCADE; 
     106DROP TABLE IF EXISTS mo_computation_mo_processing CASCADE; 
     107DROP TABLE IF EXISTS mo_instrument_ceda_instrument CASCADE; 
     108DROP TABLE IF EXISTS mo_observation_ceda_observation CASCADE; 
     109DROP TABLE IF EXISTS mo_observationcollection_ceda_observationcollection CASCADE; 
     110DROP TABLE IF EXISTS mo_operation_ceda_operation CASCADE; 
     111DROP TABLE IF EXISTS mo_platform_ceda_platform CASCADE; 
     112DROP TABLE IF EXISTS mo_process_ceda_process CASCADE; 
     113DROP TABLE IF EXISTS mo_processing_ceda_processing CASCADE; 
     114DROP TABLE IF EXISTS mo_process_mo_acquisition CASCADE; 
     115DROP TABLE IF EXISTS mo_process_mo_compositeprocess CASCADE; 
     116DROP TABLE IF EXISTS mo_process_mo_computation CASCADE; 
     117DROP TABLE IF EXISTS mo_project_ceda_project CASCADE; 
     118DROP TABLE IF EXISTS mo_result_ceda_result CASCADE; 
     119DROP TABLE IF EXISTS multiplicity CASCADE; 
     120DROP TABLE IF EXISTS obs_coll_migration CASCADE; 
     121DROP TABLE IF EXISTS observation_migration CASCADE; 
     122DROP TABLE IF EXISTS om_observation_mo_observation CASCADE; 
     123DROP TABLE IF EXISTS om_process_mo_process CASCADE; 
     124DROP TABLE IF EXISTS rs_referencesystem_sc_crs CASCADE; 
     125DROP TABLE IF EXISTS tm_duration_tm_periodduration CASCADE; 
     126DROP TABLE IF EXISTS tm_geometricprimitive_tm_instant CASCADE; 
     127DROP TABLE IF EXISTS tm_geometricprimitive_tm_period CASCADE; 
     128DROP TABLE IF EXISTS tm_object_tm_primitive CASCADE; 
     129DROP TABLE IF EXISTS tm_primitive_tm_geometricprimitive CASCADE; 
     130DROP TABLE IF EXISTS typename CASCADE; 
     131DROP TABLE IF EXISTS unitofmeasure_uomlength CASCADE; 
     132DROP TABLE IF EXISTS unitofmeasure_uomscale CASCADE; 
Note: See TracChangeset for help on using the changeset viewer.