How to use

Table

in

org.hibernate.mapping

  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();
            foreignKey.getTable().getName(),
            foreignKey.getReferencedTable().getName()
    foreignKey.getTable().getQualifiedTableName(),
    dialect
);
final String targetTableName = jdbcEnvironment.getQualifiedObjectNameFormatter().format(
    foreignKey.getReferencedTable().getQualifiedTableName(),
    dialect
);
final StringBuilder buffer = new StringBuilder( dialect.getAlterTableString( sourceTableName ) )
            dialect.getAddForeignKeyConstraintString(

@Override
public String[] getSqlCreateStrings(Table table, Metadata metadata) {
  final QualifiedName tableName = new QualifiedNameParser.NameParts(
      Identifier.toIdentifier( table.getCatalog(), table.isCatalogQuoted() ),
      Identifier.toIdentifier( table.getSchema(), table.isSchemaQuoted() ),
      table.getNameIdentifier()
  );
      new StringBuilder( tableCreateString( table.hasPrimaryKey() ) )
          .append( ' ' )
          .append(
  boolean isPrimaryKeyIdentity = table.hasPrimaryKey()
      && table.getIdentifierValue() != null
      && table.getIdentifierValue().isIdentityColumn( metadata.getIdentifierGeneratorFactory(), dialect );
  if ( table.hasPrimaryKey() ) {
    Column pkColumn = (Column) table.getPrimaryKey().getColumns().iterator().next();
    pkColName = pkColumn.getQuotedName( dialect );
  final Iterator columnItr = table.getColumnIterator();
  boolean isFirst = true;
  while ( columnItr.hasNext() ) {
      UniqueKey uk = table.getOrCreateUniqueKey( keyName );
      uk.addColumn( col );
      buf.append(
  if ( table.hasPrimaryKey() ) {
    buf.append( ", " )

public boolean isPhysicalConstraint() {
  return referencedTable.isPhysicalTable()
      && getTable().isPhysicalTable()
      && !referencedTable.hasDenormalizedTables();
}

public String toString() {
  StringBuilder buf = new StringBuilder().append( getClass().getName() )
      .append( '(' );
  if ( getCatalog() != null ) {
    buf.append( getCatalog() ).append( "." );
  }
  if ( getSchema() != null ) {
    buf.append( getSchema() ).append( "." );
  }
  buf.append( getName() ).append( ')' );
  return buf.toString();
}

protected void applyComments(Table table, QualifiedName tableName, List<String> sqlStrings) {
  if ( dialect.supportsCommentOn() ) {
    if ( table.getComment() != null ) {
      sqlStrings.add( "comment on table " + tableName + " is '" + table.getComment() + "'" );
    }
    final Iterator iter = table.getColumnIterator();
    while ( iter.hasNext() ) {
      Column column = (Column) iter.next();
      String columnComment = column.getComment();
      if ( columnComment != null ) {
        sqlStrings.add( "comment on column " + tableName + '.' + column.getQuotedName( dialect ) + " is '" + columnComment + "'" );
      }
    }
  }
}

  referencedEntityColumns = associatedClass.getIdentifier().getColumnIterator();
  Property referencedProperty = associatedClass.getRecursiveProperty( referencedPropertyName );
  referencedEntityColumns = referencedProperty.getColumnIterator();
    associatedClass.getTable().getName(),
    element.getColumnIterator(),
    referencedEntityColumns
  fromAndWhere = getFromAndWhereFormula(
      targetPropertyPersistentClass.getTable()
          .getQualifiedTableName()
          .toString(),
      element.getColumnIterator(),
      associatedClass.getIdentifier().getColumnIterator()
  );
while ( properties.hasNext() ) {
  Property current = (Property) properties.next();
  Property newProperty = new Property();
  newProperty.setCascade( current.getCascade() );
  newProperty.setValueGenerationStrategy( current.getValueGenerationStrategy() );
  newProperty.setInsertable( false );
  String formulaString;
  if ( current instanceof Column ) {
    formulaString = ( (Column) current ).getQuotedName();

  referencedEntityColumns = associatedClass.getIdentifier().getColumnIterator();
  Property referencedProperty = associatedClass.getRecursiveProperty( referencedPropertyName );
  referencedEntityColumns = referencedProperty.getColumnIterator();
    .append( associatedClass.getTable().getName() )
  Column colColumn = (Column) collectionTableColumns.next();
  Column refColumn = (Column) referencedEntityColumns.next();
  fromAndWhereSb.append( alias ).append( '.' ).append( refColumn.getQuotedName() )
      .append( '=' ).append( colColumn.getQuotedName() ).append( " and " );
while ( properties.hasNext() ) {
  Property current = (Property) properties.next();
  Property newProperty = new Property();
  newProperty.setCascade( current.getCascade() );
  newProperty.setGeneration( current.getGeneration() );
  newProperty.setInsertable( false );
  String formulaString;
  if ( current instanceof Column ) {
    formulaString = ( (Column) current ).getQuotedName();

  subclassTableNames.add( tableName );
  String[] key = new String[idColumnSpan];
  Iterator cItr = tab.getPrimaryKey().getColumnIterator();
  subclassTableNames.add( joinTableName );
  String[] key = new String[idColumnSpan];
  Iterator citer = joinTable.getPrimaryKey().getColumnIterator();
while ( iter.hasNext() ) {
  Property prop = (Property) iter.next();
  String tabname = prop.getValue().getTable().getQualifiedName(
      factory.getDialect(),
      factory.getSettings().getDefaultCatalogName(),
while ( iter.hasNext() ) {
  Property prop = (Property) iter.next();
  Table tab = prop.getValue().getTable();
  String tabname = tab.getQualifiedName(
      factory.getDialect(),
      factory.getSettings().getDefaultCatalogName(),
  notNullColumnTableNumbers = new int[subclassSpan];
  final int id = getTableId(
      persistentClass.getTable().getQualifiedName(
          factory.getDialect(),
          factory.getSettings().getDefaultCatalogName(),
      discriminatorValues[k] = discriminatorValue.toString();
      int id = getTableId(

public String sqlCreateString(Dialect dialect, Mapping p, String defaultCatalog, String defaultSchema) {
  StringBuilder buf = new StringBuilder( hasPrimaryKey() ? dialect.getCreateTableString() : dialect.getCreateMultisetTableString() )
      .append( ' ' )
      .append( getQualifiedName( dialect, defaultCatalog, defaultSchema ) )
      .append( " (" );
  boolean identityColumn = idValue != null && idValue.isIdentityColumn( p.getIdentifierGeneratorFactory(), dialect );
  if ( hasPrimaryKey() && identityColumn ) {
    pkname = ( (Column) getPrimaryKey().getColumnIterator().next() ).getQuotedName( dialect );
  Iterator iter = getColumnIterator();
  while ( iter.hasNext() ) {
    Column col = (Column) iter.next();
    buf.append( col.getQuotedName( dialect ) )
        .append( ' ' );
    if ( identityColumn && col.getQuotedName( dialect ).equals( pkname ) ) {
    if ( col.isUnique() ) {
      String keyName = Constraint.generateName( "UK_", this, col );
      UniqueKey uk = getOrCreateUniqueKey( keyName );
      uk.addColumn( col );
      buf.append( dialect.getUniqueDelegate()
  if ( hasPrimaryKey() ) {
    buf.append( ", " )
        .append( getPrimaryKey().sqlConstraintString( dialect ) );

);
StringBuilder root = new StringBuilder( dialect.getAlterTableString( tableName ) )
    .append( ' ' )
    .append( dialect.getAddColumnString() );
Iterator iter = getColumnIterator();
List results = new ArrayList();
  final ColumnInformation columnInfo = tableInfo.getColumn( Identifier.toIdentifier( column.getName(), column.isQuoted() ) );
        .append( column.getQuotedName( dialect ) )
        .append( ' ' )
        .append( column.getSqlType( dialect, metadata ) );
    if ( column.isNullable() ) {
      alter.append( dialect.getNullColumnString() );
    if ( column.isUnique() ) {
      String keyName = Constraint.generateName( "UK_", this, column );
      UniqueKey uk = getOrCreateUniqueKey( keyName );
      uk.addColumn( column );
      alter.append( dialect.getUniqueDelegate()
  log.debugf( "No alter strings for table : %s", getQuotedName() );

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 testEntityToDatabaseBindingMetadata() {
    Metadata metadata = MetadataExtractorIntegrator.INSTANCE.getMetadata();

    for ( PersistentClass persistentClass : metadata.getEntityBindings()) {
      Table table = persistentClass.getTable();
      LOGGER.info( "Entity: {} is mapped to table: {}",
             persistentClass.getClassName(),
             table.getName()
      );

      for(Iterator propertyIterator =
          persistentClass.getPropertyIterator(); propertyIterator.hasNext(); ) {
        Property property = (Property) propertyIterator.next();
        for(Iterator columnIterator =
            property.getColumnIterator(); columnIterator.hasNext(); ) {
          Column column = (Column) columnIterator.next();
          LOGGER.info( "Property: {} is mapped on table column: {} of type: {}",
                 property.getName(),
                 column.getName(),
                 column.getSqlType()
          );
        }
      }
    }
  }
}

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 void createPrimaryKey() {
  //Primary key constraint
  final Table table = getTable();
  PrimaryKey pk = new PrimaryKey( table );
  pk.setName( PK_ALIAS.toAliasString( table.getName() ) );
  table.setPrimaryKey( pk );
  pk.addColumns( getKey().getColumnIterator() );
}

Iterator idColumnsIt = referencedEntity.getKey().getColumnIterator();
while ( idColumnsIt.hasNext() ) {
  idColumns.add( (Column) idColumnsIt.next() );
    throw new MappingException(
        "Unable to find column with logical name: "
            + columns[0].getReferencedColumn() + " in " + referencedEntity.getTable() + " and its related "
            + "supertables and secondary tables"
    );
    ( (PersistentClass) columnOwner ).getTable() :
    ( (Join) columnOwner ).getTable();
              + logicalReferencedColumnName + " in " + matchingTable.getName()
      );
    Column refCol = new Column( referencedColumnName );
    boolean contains = idColumns.contains( refCol );
    if ( !contains ) {

if ( !model.hasSubclasses() ) {
  return model.getTable().getQualifiedName(
      dialect,
      settings.getDefaultCatalogName(),
Iterator titer = model.getSubclassTableClosureIterator();
while ( titer.hasNext() ) {
  Table table = (Table) titer.next();
  if ( !table.isAbstractUnionTable() ) {
    Iterator citer = table.getColumnIterator();
    while ( citer.hasNext() ) {
      columns.add( citer.next() );
  if ( !table.isAbstractUnionTable() ) {
    while ( citer.hasNext() ) {
      Column col = (Column) citer.next();
      if ( !table.containsColumn( col ) ) {
        int sqlType = col.getSqlTypeCode( mapping );
        buf.append( dialect.getSelectClauseNullString( sqlType ) )
            .append( " as " );
    buf.append( " from " )
        .append(
            table.getQualifiedName(
                dialect,
                settings.getDefaultCatalogName(),

@Test
public void testTableName() {
  assert MIDDLE_VERSIONS_ENTITY_NAME.equals(
      metadata().getEntityBinding( MIDDLE_VERSIONS_ENTITY_NAME ).getTable().getName()
  );
}

@Test
public void testDefaultValue() throws Exception {
  Join join = (Join) metadata().getEntityBinding( Life.class.getName() ).getJoinClosureIterator().next();
  assertEquals( "ExtendedLife", join.getTable().getName() );
  org.hibernate.mapping.Column owner = new org.hibernate.mapping.Column();
  owner.setName( "LIFE_ID" );
  assertTrue( join.getTable().getPrimaryKey().containsColumn( owner ) );
  Session s = openSession();
  Transaction tx = s.beginTransaction();
  Life life = new Life();
  life.duration = 15;
  life.fullDescription = "Long long description";
  s.persist( life );
  tx.commit();
  s.close();
  s = openSession();
  tx = s.beginTransaction();
  Query q = s.createQuery( "from " + Life.class.getName() );
  life = (Life) q.uniqueResult();
  assertEquals( "Long long description", life.fullDescription );
  tx.commit();
  s.close();
}

  table.setPrimaryKey( new PrimaryKey( table ) );
      segmentColumnName,
      StringType.INSTANCE,
      database.getDialect().getTypeName( Types.VARCHAR, keySize, 0, 0 )
  );
  pkColumn.setNullable( false );
  table.addColumn( pkColumn );
  table.getPrimaryKey().addColumn( pkColumn );
      LongType.INSTANCE
  );
  table.addColumn( valueColumn );
    table.getQualifiedTableName(),
    jdbcEnvironment.getDialect()
);
    valueColumnName +
    " from " +
    jdbcEnvironment.getDialect().appendLockHint( LockMode.PESSIMISTIC_WRITE, tableName ) +
    " where " + segmentColumnName + " = '" + segmentName + "'" +
    jdbcEnvironment.getDialect().getForUpdateString();

protected void checkDefaultJoinTableAndAllColumnNames(
    Metadata metadata,
    Class<?> ownerEntityClass,
    String ownerCollectionPropertyName,
    String expectedCollectionTableName,
    String ownerForeignKeyNameExpected,
    String[] columnNames) {
  final org.hibernate.mapping.Collection collection = metadata.getCollectionBinding( ownerEntityClass.getName() + '.' + ownerCollectionPropertyName );
  final org.hibernate.mapping.Table table = collection.getCollectionTable();
  assertEquals( expectedCollectionTableName, table.getName() );
  // The default owner and inverse join columns can only be computed if they have PK with 1 column.
  assertEquals( 1, collection.getOwner().getKey().getColumnSpan() );
  assertEquals(
    ownerForeignKeyNameExpected,
    collection.getKey().getColumnIterator().next().getText()
  );
  int columnNumber = table.getColumnSpan();
  for ( int i = 0; i < columnNumber; i++ ) {
    assertEquals( columnNames[i], table.getColumn( i + 1 ).getName());
  }
}