private void alignColumns(Table referencedTable) { final int referencedPkColumnSpan = referencedTable.getPrimaryKey().getColumnSpan(); if ( referencedPkColumnSpan != getColumnSpan() ) { StringBuilder sb = new StringBuilder(); sb.append( "Foreign key (" ).append( getName() ).append( ":" ) .append( getTable().getName() ) .append( " [" ); appendColumns( sb, getColumnIterator() ); sb.append( "])" ) .append( ") must have same number of columns as the referenced primary key (" ) .append( referencedTable.getName() ) .append( " [" ); appendColumns( sb, referencedTable.getPrimaryKey().getColumnIterator() ); sb.append( "])" ); throw new MappingException( sb.toString() ); } Iterator fkCols = getColumnIterator(); Iterator pkCols = referencedTable.getPrimaryKey().getColumnIterator(); while ( pkCols.hasNext() ) { ( (Column) fkCols.next() ).setLength( ( (Column) pkCols.next() ).getLength() ); } }
public String toString() { if ( !isReferenceToPrimaryKey() ) { return getClass().getName() + '(' + getTable().getName() + getColumns() + " ref-columns:" + '(' + getReferencedColumns() + ") as " + getName() + ")"; } else { return super.toString(); } }
if ( !foreignKey.isCreationEnabled() ) { return NO_COMMANDS; if ( !foreignKey.isPhysicalConstraint() ) { return NO_COMMANDS; final int numberOfColumns = foreignKey.getColumnSpan(); final String[] columnNames = new String[numberOfColumns]; final String[] targetColumnNames = new String[numberOfColumns]; if ( foreignKey.isReferenceToPrimaryKey() ) { if ( numberOfColumns != foreignKey.getReferencedTable().getPrimaryKey().getColumnSpan() ) { throw new AssertionFailure( String.format( COLUMN_MISMATCH_MSG, numberOfColumns, foreignKey.getReferencedTable().getPrimaryKey().getColumnSpan(), foreignKey.getName(), foreignKey.getTable().getName(), foreignKey.getReferencedTable().getName() targetItr = foreignKey.getReferencedTable().getPrimaryKey().getColumnIterator(); if ( numberOfColumns != foreignKey.getReferencedColumns().size() ) { throw new AssertionFailure( String.format( COLUMN_MISMATCH_MSG,
@Override public String getExportIdentifier() { // NOt sure name is always set. Might need some implicit naming return StringHelper.qualify( getTable().getExportIdentifier(), "FK-" + getName() ); }
@Override public void createForeignKeys() { includedTable.createForeignKeys(); Iterator iter = includedTable.getForeignKeyIterator(); while ( iter.hasNext() ) { ForeignKey fk = (ForeignKey) iter.next(); createForeignKey( Constraint.generateName( fk.generatedConstraintNamePrefix(), this, fk.getColumns() ), fk.getColumns(), fk.getReferencedEntityName(), fk.getKeyDefinition(), fk.getReferencedColumns() ); } }
@Test public void testMultiColumnForeignKeys() { Metadata metadata = metadataDescriptor.createMetadata(); Table table = HibernateUtil.getTable( metadata, JdbcUtil.toIdentifier(this, "LINE_ITEM")); Assert.assertNotNull(table); ForeignKey foreignKey = HibernateUtil.getForeignKey(table, JdbcUtil.toIdentifier(this, "TO_CUSTOMER_ORDER")); Assert.assertNotNull(foreignKey); Assert.assertEquals( reverseEngineeringStrategy.tableToClassName( new TableIdentifier(null, null, JdbcUtil.toIdentifier(this, "CUSTOMER_ORDER"))), foreignKey.getReferencedEntityName()); Assert.assertEquals(JdbcUtil.toIdentifier(this, "LINE_ITEM"), foreignKey.getTable().getName()); Assert.assertEquals(2, foreignKey.getColumnSpan()); Assert.assertEquals(foreignKey.getColumn(0).getName(), "CUSTOMER_ID_REF"); Assert.assertEquals(foreignKey.getColumn(1).getName(), "ORDER_NUMBER"); Table tab = HibernateUtil.getTable( metadata, JdbcUtil.toIdentifier(this, "CUSTOMER_ORDER")); Assert.assertEquals(tab.getPrimaryKey().getColumn(0).getName(), "CUSTOMER_ID"); Assert.assertEquals(tab.getPrimaryKey().getColumn(1).getName(), "ORDER_NUMBER"); PersistentClass lineMapping = metadata.getEntityBinding( reverseEngineeringStrategy .tableToClassName(new TableIdentifier(null, null, JdbcUtil.toIdentifier(this, "LINE_ITEM")))); Assert.assertEquals(4, lineMapping.getIdentifier().getColumnSpan()); Iterator<?> columnIterator = lineMapping.getIdentifier().getColumnIterator(); Assert.assertEquals(((Column) (columnIterator.next())).getName(), "CUSTOMER_ID_REF"); Assert.assertEquals(((Column) (columnIterator.next())).getName(), "ORDER_NUMBER"); }
public boolean matches(ForeignKey fk) { if ( refTable.equalsIgnoreCase( fk.getReferencedTable().getName() ) ) { if ( fk.getColumnSpan() == references.size() ) { List fkRefs; if ( fk.isReferenceToPrimaryKey() ) { fkRefs = fk.getReferencedTable().getPrimaryKey().getColumns(); } else { fkRefs = fk.getReferencedColumns(); } for ( int i = 0; i < fk.getColumnSpan(); i++ ) { Column column = fk.getColumn( i ); Column ref = ( Column ) fkRefs.get( i ); if ( !hasReference( column, ref ) ) { return false; } } return true; } } return false; }
protected void secondPassCompileForeignKeys(Table table, Set done) throws MappingException { table.createForeignKeys(); Iterator iter = table.getForeignKeyIterator(); while ( iter.hasNext() ) { ForeignKey fk = ( ForeignKey ) iter.next(); if ( !done.contains( fk ) ) { done.add( fk ); final String referencedEntityName = fk.getReferencedEntityName(); if (referencedEntityName==null) { throw new MappingException("An association from the table "+ fk.getTable().getName() + " does not specify the referenced entity" ); } if ( log.isDebugEnabled() ) { log.debug( "resolving reference to class: " + referencedEntityName ); } PersistentClass referencedClass = ( PersistentClass ) classes.get( referencedEntityName ); if ( referencedClass == null ) { throw new MappingException( "An association from the table " + fk.getTable().getName() + " refers to an unmapped class: " + referencedEntityName ); } if ( referencedClass.isJoinedSubclass() ) { secondPassCompileForeignKeys( referencedClass.getSuperclass().getTable(), done ); } fk.setReferencedTable( referencedClass.getTable() ); } } }
String defaultCatalog, String defaultSchema) { String[] columnNames = new String[getColumnSpan()]; String[] referencedColumnNames = new String[getColumnSpan()]; if ( isReferenceToPrimaryKey() ) { referencedColumnItr = referencedTable.getPrimaryKey().getColumnIterator(); Iterator columnItr = getColumnIterator(); int i = 0; while ( columnItr.hasNext() ) { columnNames[i] = ( (Column) columnItr.next() ).getQuotedName( dialect ); referencedColumnNames[i] = referencedColumnItr.next().getQuotedName( dialect ); i++; constraintName, columnNames, referencedTable.getQualifiedName( dialect, defaultCatalog, ), referencedColumnNames, isReferenceToPrimaryKey() );
protected void checkDefaultJoinColumnName( Class<?> ownerEntityClass, String ownerCollectionPropertyName, String ownerForeignKeyNameExpected) { final org.hibernate.mapping.Collection ownerCollection = metadata().getCollectionBinding( ownerEntityClass.getName() + '.' + ownerCollectionPropertyName ); // The default owner join column can only be computed if it has a PK with 1 column. assertEquals ( 1, ownerCollection.getOwner().getKey().getColumnSpan() ); assertEquals( ownerForeignKeyNameExpected, ownerCollection.getKey().getColumnIterator().next().getText() ); boolean hasOwnerFK = false; for ( Iterator it=ownerCollection.getCollectionTable().getForeignKeyIterator(); it.hasNext(); ) { final ForeignKey fk = (ForeignKey) it.next(); assertSame( ownerCollection.getCollectionTable(), fk.getTable() ); if ( fk.getColumnSpan() > 1 ) { continue; } if ( fk.getColumn( 0 ).getText().equals( ownerForeignKeyNameExpected ) ) { assertSame( ownerCollection.getOwner().getTable(), fk.getReferencedTable() ); hasOwnerFK = true; } } assertTrue( hasOwnerFK ); }
@Test public void testForeignKeyNameSetForMapsIdJoinColumn() { for ( Namespace namespace : metadata().getDatabase().getNamespaces() ) { for ( Table table : namespace.getTables() ) { if ( table.getName().equals( "Post" ) ) { Iterator<org.hibernate.mapping.ForeignKey> foreignKeyIterator = table.getForeignKeyIterator(); while ( foreignKeyIterator.hasNext() ) { org.hibernate.mapping.ForeignKey foreignKey = foreignKeyIterator.next(); if ( foreignKey.getColumn( 0 ).getName().equals( "PD_ID" ) ) { assertEquals( "FK_PD", foreignKey.getName() ); return; } } } } } fail( "Expected to find a Foreign Key mapped to column PD_ID but failed to locate it" ); } }
Iterator itr = table.getForeignKeyIterator(); while ( itr.hasNext() ) { final ForeignKey fk = (ForeignKey) itr.next(); if ( !done.contains( fk ) ) { done.add( fk ); final String referencedEntityName = fk.getReferencedEntityName(); if ( referencedEntityName == null ) { throw new MappingException( "An association from the table " + fk.getTable().getName() + " does not specify the referenced entity" ); throw new MappingException( "An association from the table " + fk.getTable().getName() + " refers to an unmapped class: " + referencedEntityName fk.setReferencedTable( referencedClass.getTable() ); final List<Identifier> columnNames = extractColumnNames( fk.getColumns() ); List<Identifier> referencedColumnNames = null; fk.setName( nameIdentifier.render( getDatabase().getJdbcEnvironment().getDialect() ) ); fk.alignColumns();
if ( foreignKey.getName() == null || tableInformation == null ) { return false; final String referencingColumn = foreignKey.getColumn( 0 ).getName(); final String referencedTable = foreignKey.getReferencedTable().getName(); return tableInformation.getForeignKey( Identifier.toIdentifier( foreignKey.getName() ) ) != null;
for(Iterator<?> iterator = table.getForeignKeyIterator(); iterator.hasNext();) { ForeignKey foreignKey = (ForeignKey) iterator.next(); if ( contains( foreignKey.getColumnIterator(), processedColumns ) ) { if ( !preferBasicCompositeIds ) continue; //it's in the pk, so skip this one mutable = false; if(revengStrategy.excludeForeignKeyAsManytoOne(foreignKey.getName(), TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns())) { log.debug("Rev.eng excluded *-to-one for foreignkey " + foreignKey.getName()); } else if (revengStrategy.isOneToOne(foreignKey)){ Property property = bindOneToOne(rc, foreignKey.getReferencedTable(), foreignKey, processedColumns, true, false); rc.addProperty(property); } else { boolean isUnique = isUniqueReference(foreignKey); String propertyName = revengStrategy.foreignKeyToEntityName( foreignKey.getName(), TableIdentifier.create(foreignKey.getTable() ), foreignKey.getColumns(), TableIdentifier.create(foreignKey.getReferencedTable() ), foreignKey.getReferencedColumns(), isUnique );
public void createForeignKeys() { includedTable.createForeignKeys(); Iterator iter = includedTable.getForeignKeyIterator(); while ( iter.hasNext() ) { ForeignKey fk = (ForeignKey) iter.next(); createForeignKey( fk.getName() + Integer.toHexString( getName().hashCode() ), fk.getColumns(), fk.getReferencedEntityName() ); } }
list = findForeignKeys(table.getForeignKeyIterator(), keyColumns); checkColumn(column); String propertyName = revengStrategy.columnToPropertyName( TableIdentifier.create(table), column.getName() ); property = bindBasicProperty( BinderUtils.makeUnique(pkc, propertyName), table, column, processedColumns, mapping); ForeignKey foreignKey = fkfc.key; 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);
method.setAccessible( true ); ForeignKey foreignKey = new ForeignKey(); foreignKey.setName( "objectId2id_1" ); // Make sure the match is not successful based on key name foreignKey.addColumn( new Column( "id" ) ); foreignKey.setReferencedTable( new Table( "table2" ) );
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; }
@Test public void testCompositeUserDefinedForeignKeys() { Table table = HibernateUtil.getTable(metadata, JdbcUtil.toIdentifier(this, "CHILDREN") ); Iterator<?> foreignKeyIterator = table.getForeignKeyIterator(); ForeignKey fk = (ForeignKey) foreignKeyIterator.next(); Assert.assertEquals(fk.getReferencedTable().getName(), JdbcUtil.toIdentifier(this, "PARENT") ); Assert.assertEquals(2, fk.getReferencedColumns().size()); Assert.assertEquals("child_to_parent", fk.getName()); PersistentClass classMapping = metadata.getEntityBinding("Children"); Property property = classMapping.getProperty("propertyParent"); Assert.assertEquals(2,property.getColumnSpan()); classMapping = metadata.getEntityBinding("Parent"); property = classMapping.getProperty("propertyChildren"); }
for ( Namespace namespace : metadata().getDatabase().getNamespaces() ) { for ( org.hibernate.mapping.Table table : namespace.getTables() ) { Iterator fkItr = table.getForeignKeyIterator(); while (fkItr.hasNext()) { ForeignKey fk = (ForeignKey) fkItr.next(); assertTrue( fk.getName().length() <= MAX_NAME_LENGTH ); Column column = fk.getColumn( 0 ); if ( column.getName().equals( "explicit_native" ) ) { foundCount++; assertEquals( fk.getName(), EXPLICIT_FK_NAME_NATIVE ); else if ( column.getName().equals( "explicit_jpa" ) ) { foundCount++; assertEquals( fk.getName(), EXPLICIT_FK_NAME_JPA ); Iterator ukItr = table.getUniqueKeyIterator(); while (ukItr.hasNext()) { UniqueKey uk = (UniqueKey) ukItr.next(); if ( column.getName().equals( "explicit" ) ) { foundCount++; assertEquals( uk.getName(), EXPLICIT_UK_NAME );