import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private EntityBinding createEntityBinding(EntitySource entitySource, EntityBinding superEntityBinding) {
	if ( processedEntityNames.contains( entitySource.getEntityName() ) ) {
		return metadata.getEntityBinding( entitySource.getEntityName() );
	}

	currentBindingContext = entitySource.getLocalBindingContext();
	try {
		final EntityBinding entityBinding = doCreateEntityBinding( entitySource, superEntityBinding );

		metadata.addEntity( entityBinding );
		processedEntityNames.add( entityBinding.getEntity().getName() );

		processFetchProfiles( entitySource, entityBinding );

		return entityBinding;
	}
	finally {
		currentBindingContext = null;
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private EntityBinding createBasicEntityBinding(EntitySource entitySource, EntityBinding superEntityBinding) {
	if ( superEntityBinding == null ) {
		return makeRootEntityBinding( (RootEntitySource) entitySource );
	}
	else {
		switch ( currentInheritanceType ) {
			case SINGLE_TABLE:
				return makeDiscriminatedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			case JOINED:
				return makeJoinedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			case TABLE_PER_CLASS:
				return makeUnionedSubclassBinding( (SubclassEntitySource) entitySource, superEntityBinding );
			default:
				// extreme internal error!
				throw new AssertionFailure( "Internal condition failure" );
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private EntityBinding makeRootEntityBinding(RootEntitySource entitySource) {
	currentHierarchyEntityMode = entitySource.getEntityMode();

	final EntityBinding entityBinding = buildBasicEntityBinding( entitySource, null );

	bindPrimaryTable( entitySource, entityBinding );

	bindIdentifier( entitySource, entityBinding );
	bindVersion( entityBinding, entitySource );
	bindDiscriminator( entitySource, entityBinding );

	entityBinding.getHierarchyDetails().setCaching( entitySource.getCaching() );
	entityBinding.getHierarchyDetails().setExplicitPolymorphism( entitySource.isExplicitPolymorphism() );
	entityBinding.getHierarchyDetails().setOptimisticLockStyle( entitySource.getOptimisticLockStyle() );

	entityBinding.setMutable( entitySource.isMutable() );
	entityBinding.setWhereFilter( entitySource.getWhere() );
	entityBinding.setRowId( entitySource.getRowId() );

	return entityBinding;
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindIdentifier(RootEntitySource entitySource, EntityBinding entityBinding) {
	if ( entitySource.getIdentifierSource() == null ) {
		throw new AssertionFailure( "Expecting identifier information on root entity descriptor" );
	}
	switch ( entitySource.getIdentifierSource().getNature() ) {
		case SIMPLE: {
			bindSimpleIdentifier( (SimpleIdentifierSource) entitySource.getIdentifierSource(), entityBinding );
			break;
		}
		case AGGREGATED_COMPOSITE: {
			// composite id with an actual component class
		    break;
		}
		case COMPOSITE: {
			// what we used to term an "embedded composite identifier", which is not tobe confused with the JPA
			// term embedded. Specifically a composite id where there is no component class, though there may
			// be a @IdClass :/
		    break;
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindDiscriminator(RootEntitySource entitySource, EntityBinding entityBinding) {
	final DiscriminatorSource discriminatorSource = entitySource.getDiscriminatorSource();
	if ( discriminatorSource == null ) {
		return;
	}

	EntityDiscriminator discriminator = new EntityDiscriminator();
	SimpleValue relationalValue = makeSimpleValue(
			entityBinding,
			discriminatorSource.getDiscriminatorRelationalValueSource()
	);
	discriminator.setBoundValue( relationalValue );

	discriminator.getExplicitHibernateTypeDescriptor().setExplicitTypeName(
			discriminatorSource.getExplicitHibernateTypeName() != null
					? discriminatorSource.getExplicitHibernateTypeName()
					: "string"
	);

	discriminator.setInserted( discriminatorSource.isInserted() );
	discriminator.setForced( discriminatorSource.isForced() );

	entityBinding.getHierarchyDetails().setEntityDiscriminator( discriminator );
	entityBinding.setDiscriminatorMatchValue( entitySource.getDiscriminatorMatchValue() );
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private Table createTable(EntityBinding entityBinding, TableSource tableSource) {
	String tableName = tableSource.getExplicitTableName();
	if ( StringHelper.isEmpty( tableName ) ) {
		tableName = currentBindingContext.getNamingStrategy()
				.classToTableName( entityBinding.getEntity().getClassName() );
	}
	else {
		tableName = currentBindingContext.getNamingStrategy().tableName( tableName );
	}
	tableName = quoteIdentifier( tableName );

	final Schema.Name databaseSchemaName = Helper.determineDatabaseSchemaName(
			tableSource.getExplicitSchemaName(),
			tableSource.getExplicitCatalogName(),
			currentBindingContext
	);
	return currentBindingContext.getMetadataImplementor()
			.getDatabase()
			.locateSchema( databaseSchemaName )
			.locateOrCreateTable( Identifier.toIdentifier( tableName ) );
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindTableUniqueConstraints(EntitySource entitySource, EntityBinding entityBinding) {
	for ( ConstraintSource constraintSource : entitySource.getConstraints() ) {
		if ( constraintSource instanceof UniqueConstraintSource ) {
			TableSpecification table = entityBinding.locateTable( constraintSource.getTableName() );
			if ( table == null ) {
				// throw exception !?
			}
			String constraintName = constraintSource.name();
			if ( constraintName == null ) {
				// create a default name
			}

			UniqueKey uniqueKey = table.getOrCreateUniqueKey( constraintName );
			for ( String columnName : constraintSource.columnNames() ) {
				uniqueKey.addColumn( table.locateOrCreateColumn( quoteIdentifier( columnName ) ) );
			}
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
void resolve() {
	for ( EntityBinding entityBinding : metadata.getEntityBindings() ) {
		if ( entityBinding.getHierarchyDetails().getEntityDiscriminator() != null ) {
			resolveDiscriminatorTypeInformation( entityBinding.getHierarchyDetails().getEntityDiscriminator() );
		}
		for ( AttributeBinding attributeBinding : entityBinding.attributeBindings() ) {
			if ( SingularAttributeBinding.class.isInstance( attributeBinding ) ) {
				resolveSingularAttributeTypeInformation(
						SingularAttributeBinding.class.cast( attributeBinding  )
				);
			}
			else if ( AbstractPluralAttributeBinding.class.isInstance( attributeBinding ) ) {
				resolvePluralAttributeTypeInformation(
						AbstractPluralAttributeBinding.class.cast( attributeBinding )
				);
			}
			else {
				throw new AssertionFailure( "Unknown type of AttributeBinding: " + attributeBinding.getClass().getName() );
			}
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
@Override
public EntityBinding getRootEntityBinding(String entityName) {
	EntityBinding binding = entityBindingMap.get( entityName );
	if ( binding == null ) {
		throw new IllegalStateException( "Unknown entity binding: " + entityName );
	}

	do {
		if ( binding.isRoot() ) {
			return binding;
		}
		binding = binding.getSuperEntityBinding();
	} while ( binding != null );

	throw new AssertionFailure( "Entity binding has no root: " + entityName );
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
public UnionSubclassEntityPersister(
		final EntityBinding entityBinding,
		final EntityRegionAccessStrategy cacheAccessStrategy,
		final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
		final SessionFactoryImplementor factory,
		final Mapping mapping) throws HibernateException {
	super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
	// TODO: implement!!! initializing final fields to null to make compiler happy.
	subquery = null;
	tableName = null;
	subclassClosure = null;
	spaces = null;
	subclassSpaces = null;
	discriminatorValue = null;
	discriminatorSQLValue = null;
	constraintOrderedTableNames = null;
	constraintOrderedKeyColumnNames = null;
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
@Override
protected ProxyFactory buildProxyFactory(EntityBinding mappingInfo, Getter idGetter, Setter idSetter) {

	ProxyFactory pf = new MapProxyFactory();
	try {
		//TODO: design new lifecycle for ProxyFactory
		pf.postInstantiate(
				getEntityName(),
				null,
				null,
				null,
				null,
				null
		);
	}
	catch ( HibernateException he ) {
		LOG.unableToCreateProxyFactory(getEntityName(), he);
		pf = null;
	}
	return pf;
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
/**
 * Process an entity hierarchy.
 *
 * @param entityHierarchy THe hierarchy to process.
 */
public void processEntityHierarchy(EntityHierarchy entityHierarchy) {
	currentInheritanceType = entityHierarchy.getHierarchyInheritanceType();
	EntityBinding rootEntityBinding = createEntityBinding( entityHierarchy.getRootEntitySource(), null );
	if ( currentInheritanceType != InheritanceType.NO_INHERITANCE ) {
		processHierarchySubEntities( entityHierarchy.getRootEntitySource(), rootEntityBinding );
	}
	currentHierarchyEntityMode = null;
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private EntityBinding makeDiscriminatedSubclassBinding(SubclassEntitySource entitySource, EntityBinding superEntityBinding) {
	final EntityBinding entityBinding = buildBasicEntityBinding( entitySource, superEntityBinding );

	entityBinding.setPrimaryTable( superEntityBinding.getPrimaryTable() );
	entityBinding.setPrimaryTableName( superEntityBinding.getPrimaryTableName() );
	bindDiscriminatorValue( entitySource, entityBinding );

	return entityBinding;
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindSimpleIdentifier(SimpleIdentifierSource identifierSource, EntityBinding entityBinding) {
	final BasicAttributeBinding idAttributeBinding = doBasicSingularAttributeBindingCreation(
			identifierSource.getIdentifierAttributeSource(), entityBinding
	);

	entityBinding.getHierarchyDetails().getEntityIdentifier().setValueBinding( idAttributeBinding );
	IdGenerator generator = identifierSource.getIdentifierGeneratorDescriptor();
	if ( generator == null ) {
		Map<String, String> params = new HashMap<String, String>();
		params.put( IdentifierGenerator.ENTITY_NAME, entityBinding.getEntity().getName() );
		generator = new IdGenerator( "default_assign_identity_generator", "assigned", params );
	}
	entityBinding.getHierarchyDetails()
			.getEntityIdentifier()
			.setIdGenerator( generator );

	final org.hibernate.metamodel.relational.Value relationalValue = idAttributeBinding.getValue();

	if ( SimpleValue.class.isInstance( relationalValue ) ) {
		if ( !Column.class.isInstance( relationalValue ) ) {
			// this should never ever happen..
			throw new AssertionFailure( "Simple-id was not a column." );
		}
		entityBinding.getPrimaryTable().getPrimaryKey().addColumn( Column.class.cast( relationalValue ) );
	}
	else {
		for ( SimpleValue subValue : ( (Tuple) relationalValue ).values() ) {
			if ( Column.class.isInstance( subValue ) ) {
				entityBinding.getPrimaryTable().getPrimaryKey().addColumn( Column.class.cast( subValue ) );
			}
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindVersion(EntityBinding entityBinding, RootEntitySource entitySource) {
	final SingularAttributeSource versioningAttributeSource = entitySource.getVersioningAttributeSource();
	if ( versioningAttributeSource == null ) {
		return;
	}

	BasicAttributeBinding attributeBinding = doBasicSingularAttributeBindingCreation(
			versioningAttributeSource, entityBinding
	);
	entityBinding.getHierarchyDetails().setVersioningAttributeBinding( attributeBinding );
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private void bindDiscriminatorValue(SubclassEntitySource entitySource, EntityBinding entityBinding) {
	final String discriminatorValue = entitySource.getDiscriminatorMatchValue();
	if ( discriminatorValue == null ) {
		return;
	}
	entityBinding.setDiscriminatorMatchValue( discriminatorValue );
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
private SimpleValue makeSimpleValue(
		EntityBinding entityBinding,
		RelationalValueSource valueSource) {
	final TableSpecification table = entityBinding.locateTable( valueSource.getContainingTableName() );

	if ( ColumnSource.class.isInstance( valueSource ) ) {
		return makeColumn( (ColumnSource) valueSource, table );
	}
	else {
		return makeDerivedValue( (DerivedValueSource) valueSource, table );
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
@SuppressWarnings( {"unchecked"} )
void resolve() {
	for ( EntityBinding entityBinding : metadata.getEntityBindings() ) {
		if ( entityBinding.isRoot() ) {
			Properties properties = new Properties( );
			properties.putAll(
					metadata.getServiceRegistry()
							.getService( ConfigurationService.class )
							.getSettings()
			);
			//TODO: where should these be added???
			if ( ! properties.contains( AvailableSettings.PREFER_POOLED_VALUES_LO ) ) {
				properties.put( AvailableSettings.PREFER_POOLED_VALUES_LO, "false" );
			}
			if ( ! properties.contains( PersistentIdentifierGenerator.IDENTIFIER_NORMALIZER ) ) {
				properties.put(
						PersistentIdentifierGenerator.IDENTIFIER_NORMALIZER,
						new ObjectNameNormalizerImpl( metadata )
				);
			}
			entityBinding.getHierarchyDetails().getEntityIdentifier().createIdentifierGenerator(
					metadata.getIdentifierGeneratorFactory(),
					properties
			);
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
void resolve() {
	for ( EntityBinding entityBinding : metadata.getEntityBindings() ) {
		for ( SingularAssociationAttributeBinding attributeBinding : entityBinding.getEntityReferencingAttributeBindings() ) {
			resolve( attributeBinding );
		}
	}
}
 

import org.hibernate.metamodel.binding.EntityBinding; //导入依赖的package包/类
public void addEntity(EntityBinding entityBinding) {
	final String entityName = entityBinding.getEntity().getName();
	if ( entityBindingMap.containsKey( entityName ) ) {
		throw new DuplicateMappingException( DuplicateMappingException.Type.ENTITY, entityName );
	}
	entityBindingMap.put( entityName, entityBinding );
}