public void addTableIdentifierStrategy(Table table, String identifierClass, Properties params) { if(identifierClass!=null) { final TableIdentifier tid = TableIdentifier.create(table); identifierStrategyForTable.put(tid, identifierClass); identifierPropertiesForTable.put(tid, params); } }
public void addMetaAttributeInfo(Table table, MultiMap map) { if(map!=null && !map.isEmpty()) { tableMetaAttributes.put(TableIdentifier.create(table), map); } }
public void addPrimaryKeyNamesForTable(Table table, List<String> boundColumnNames, String propertyName, String compositeIdName) { TableIdentifier tableIdentifier = TableIdentifier.create(table); if(boundColumnNames!=null && !boundColumnNames.isEmpty()) { primaryKeyColumnsForTable.put(tableIdentifier, boundColumnNames); } if(StringHelper.isNotEmpty(propertyName)) { propertyNameForPrimaryKey.put(tableIdentifier, propertyName); } if(StringHelper.isNotEmpty(compositeIdName)) { compositeIdNameForTable.put(tableIdentifier, compositeIdName); } }
public void addTable(Table table, String wantedClassName) { Iterator<?> fkIter = table.getForeignKeyIterator(); while ( fkIter.hasNext() ) { ForeignKey fk = (ForeignKey) fkIter.next(); TableIdentifier identifier = TableIdentifier.create(fk.getReferencedTable()); List<ForeignKey> existing = foreignKeys.get(identifier); if(existing==null) { existing = new ArrayList<ForeignKey>(); foreignKeys.put(identifier, existing); } existing.add( fk ); } tables.add(table); if(StringHelper.isNotEmpty(wantedClassName)) { tableToClassName.put(TableIdentifier.create(table), wantedClassName); } }
Map<String, List<ForeignKey>> process(ReverseEngineeringStrategy revengStrategy) { Map<String, List<ForeignKey>> oneToManyCandidates = new HashMap<String, List<ForeignKey>>(); Iterator<Entry<String, Table>> iterator = dependentTables.entrySet().iterator(); while (iterator.hasNext() ) { Entry<String, Table> entry = iterator.next(); String fkName = entry.getKey(); Table fkTable = entry.getValue(); List<Column> columns = dependentColumns.get(fkName); List<Column> refColumns = referencedColumns.get(fkName); String className = revengStrategy.tableToClassName(TableIdentifier.create(referencedTable) ); ForeignKey key = fkTable.createForeignKey(fkName, columns, className, null, refColumns); key.setReferencedTable(referencedTable); addToMultiMap(oneToManyCandidates, className, key); } return oneToManyCandidates; }
private void bindColumnsToVersioning(Table table, RootClass rc, Set<Column> processed, Mapping mapping) { TableIdentifier identifier = TableIdentifier.create(table); String optimisticLockColumnName = revengStrategy.getOptimisticLockColumnName(identifier); if(optimisticLockColumnName!=null) { Column column = table.getColumn(new Column(optimisticLockColumnName)); if(column==null) { log.warn("Column " + column + " wanted for <version>/<timestamp> not found in " + identifier); } else { bindVersionProperty(table, identifier, column, rc, processed, mapping); } } else { log.debug("Scanning " + identifier + " for <version>/<timestamp> columns."); Iterator<?> columnIterator = table.getColumnIterator(); while(columnIterator.hasNext()) { Column column = (Column) columnIterator.next(); boolean useIt = revengStrategy.useColumnForOptimisticLock(identifier, column.getName()); if(useIt && !processed.contains(column)) { bindVersionProperty( table, identifier, column, rc, processed, mapping ); return; } } log.debug("No columns reported while scanning for <version>/<timestamp> columns in " + identifier); } }
@SuppressWarnings("unchecked") private void bindIncomingForeignKeys(PersistentClass rc, Set<Column> processed, List<ForeignKey> foreignKeys, Mapping mapping) { if(foreignKeys!=null) { for (Iterator<ForeignKey> iter = foreignKeys.iterator(); iter.hasNext();) { ForeignKey foreignKey = iter.next(); if(revengStrategy.excludeForeignKeyAsCollection( foreignKey.getName(), TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns())) { log.debug("Rev.eng excluded one-to-many or one-to-one for foreignkey " + foreignKey.getName()); } else if (revengStrategy.isOneToOne(foreignKey)){ Property property = bindOneToOne(rc, foreignKey.getTable(), foreignKey, processed, false, true); rc.addProperty(property); } else { Property property = bindOneToMany(rc, foreignKey, processed, mapping); rc.addProperty(property); } } } }
.tableToClassName(TableIdentifier.create(targetTable))); propertyName = revengStrategy.foreignKeyToInverseEntityName( fk.getName(), TableIdentifier.create(fk.getReferencedTable()), fk.getReferencedColumns(), TableIdentifier.create(targetTable), fk.getColumns(), isUnique); propertyName = revengStrategy.foreignKeyToEntityName( fk.getName(), TableIdentifier.create(fk.getReferencedTable()), fk.getReferencedColumns(), TableIdentifier.create(targetTable), fk.getColumns(), isUnique);
public String foreignKeyToManyToManyName(ForeignKey fromKey, TableIdentifier middleTable, ForeignKey toKey, boolean uniqueReference) { String propertyName = Introspector.decapitalize( StringHelper.unqualify( getRoot().tableToClassName(TableIdentifier.create( toKey.getReferencedTable()) )) ); propertyName = pluralize( propertyName ); if(!uniqueReference) { //TODO: maybe use the middleTable name here ? if(toKey.getColumns()!=null && toKey.getColumns().size()==1) { String columnName = ( (Column) toKey.getColumns().get(0) ).getName(); propertyName = propertyName + "For" + toUpperCamelCase(columnName); } else { // composite key or no columns at all safeguard propertyName = propertyName + "For" + toUpperCamelCase(toKey.getName()); } } return propertyName; }
TableIdentifier tableIdentifier = TableIdentifier.create(table); if(table.getColumn(column)!=null) { throw new MappingException("Column " + column.getName() + " already exists in table " + tableIdentifier );
pkc.setEmbedded(false); String compositeIdName = revengStrategy.tableToCompositeIdName(TableIdentifier.create(rc.getTable())); if(compositeIdName==null) { compositeIdName = revengStrategy.classNameToCompositeIdName(rc.getClassName()); checkColumn(column); String propertyName = revengStrategy.columnToPropertyName( TableIdentifier.create(table), column.getName() ); property = bindBasicProperty( BinderUtils.makeUnique(pkc, propertyName), table, column, processedColumns, mapping); String propertyName = revengStrategy.foreignKeyToEntityName( foreignKey.getName(), TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns(), true ); property = bindManyToOne( BinderUtils.makeUnique(pkc, propertyName), true, table, foreignKey, processedColumns);
TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns())) { String propertyName = revengStrategy.foreignKeyToEntityName( foreignKey.getName(), TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns(), isUnique
public static List<String> getPrimaryKeyInfoInRevengStrategy( ReverseEngineeringStrategy revengStrat, Table table, String defaultCatalog, String defaultSchema) { List<String> result = null; TableIdentifier tableIdentifier = TableIdentifier.create(table); result = revengStrat.getPrimaryKeyColumnNames(tableIdentifier); if (result == null) { String catalog = getCatalogForModel(table.getCatalog(), defaultCatalog); String schema = getSchemaForModel(table.getSchema(), defaultSchema); tableIdentifier = new TableIdentifier(catalog, schema, table.getName()); result = revengStrat.getPrimaryKeyColumnNames(tableIdentifier); } return result; }
public static String getTableIdentifierStrategyNameInRevengStrategy( ReverseEngineeringStrategy revengStrat, Table table, String defaultCatalog, String defaultSchema) { String result = null; TableIdentifier tableIdentifier = TableIdentifier.create(table); result = revengStrat.getTableIdentifierStrategyName(tableIdentifier); if (result == null) { String catalog = getCatalogForModel(table.getCatalog(), defaultCatalog); String schema = getSchemaForModel(table.getSchema(), defaultSchema); tableIdentifier = new TableIdentifier(catalog, schema, table.getName()); result = revengStrat.getTableIdentifierStrategyName(tableIdentifier); } return result; }
public static Map<String,MetaAttribute> getTableToMetaAttributesInRevengStrategy( ReverseEngineeringStrategy revengStrat, Table table, String defaultCatalog, String defaultSchema) { Map<String,MetaAttribute> result = null; TableIdentifier tableIdentifier = TableIdentifier.create(table); result = revengStrat.tableToMetaAttributes(tableIdentifier); if (result == null) { String catalog = getCatalogForModel(table.getCatalog(), defaultCatalog); String schema = getSchemaForModel(table.getSchema(), defaultSchema); tableIdentifier = new TableIdentifier(catalog, schema, table.getName()); result = revengStrat.tableToMetaAttributes(tableIdentifier); } return result; }
public static Map<String,MetaAttribute> getColumnToMetaAttributesInRevengStrategy( ReverseEngineeringStrategy revengStrat, Table table, String defaultCatalog, String defaultSchema, String column) { Map<String,MetaAttribute> result = null; TableIdentifier tableIdentifier = TableIdentifier.create(table); result = revengStrat.columnToMetaAttributes(tableIdentifier, column); if (result == null) { String catalog = getCatalogForModel(table.getCatalog(), defaultCatalog); String schema = getSchemaForModel(table.getSchema(), defaultSchema); tableIdentifier = new TableIdentifier(catalog, schema, table.getName()); result = revengStrat.columnToMetaAttributes(tableIdentifier, column); } return result; }
public static String getColumnToPropertyNameInRevengStrategy( ReverseEngineeringStrategy revengStrat, Table table, String defaultCatalog, String defaultSchema, String columnName) { String result = null; TableIdentifier tableIdentifier = TableIdentifier.create(table); result = revengStrat.columnToPropertyName(tableIdentifier, columnName); if (result == null) { String catalog = getCatalogForModel(table.getCatalog(), defaultCatalog); String schema = getSchemaForModel(table.getSchema(), defaultSchema); tableIdentifier = new TableIdentifier(catalog, schema, table.getName()); result = revengStrat.columnToPropertyName(tableIdentifier, columnName); } return result; }
TableIdentifier.create(table), column.getName(), sqlTypeCode.intValue(),
TableIdentifier tableIdentifier = TableIdentifier.create(table); String className = revengStrategy.tableToClassName( tableIdentifier ); log.debug("Building entity " + className + " based on " + tableIdentifier);