Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or .
*/
package org.hibernate.boot.internal;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import javax.persistence.AttributeConverter;
import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.persistence.MapsId;
import org.hibernate.AnnotationException;
import org.hibernate.AssertionFailure;
import org.hibernate.DuplicateMappingException;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.SessionFactory;
import org.hibernate.annotations.AnyMetaDef;
import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.annotations.common.util.StringHelper;
import org.hibernate.boot.CacheRegionDefinition;
import org.hibernate.boot.SessionFactoryBuilder;
import org.hibernate.boot.model.IdentifierGeneratorDefinition;
import org.hibernate.boot.model.TypeDefinition;
import org.hibernate.boot.model.naming.Identifier;
import org.hibernate.boot.model.naming.ImplicitForeignKeyNameSource;
import org.hibernate.boot.model.naming.ImplicitIndexNameSource;
import org.hibernate.boot.model.naming.ImplicitUniqueKeyNameSource;
import org.hibernate.boot.model.relational.AuxiliaryDatabaseObject;
import org.hibernate.boot.model.relational.Database;
import org.hibernate.boot.model.relational.ExportableProducer;
import org.hibernate.boot.model.relational.Namespace;
import org.hibernate.boot.model.source.internal.ImplicitColumnNamingSecondPass;
import org.hibernate.boot.model.source.spi.LocalMetadataBuildingContext;
import org.hibernate.boot.spi.AttributeConverterAutoApplyHandler;
import org.hibernate.boot.spi.InFlightMetadataCollector;
import org.hibernate.boot.spi.MetadataBuildingContext;
import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.boot.spi.NaturalIdUniqueKeyBinder;
import org.hibernate.cfg.AnnotatedClassType;
import org.hibernate.cfg.AttributeConverterDefinition;
import org.hibernate.cfg.CopyIdentifierComponentSecondPass;
import org.hibernate.cfg.CreateKeySecondPass;
import org.hibernate.cfg.FkSecondPass;
import org.hibernate.cfg.JPAIndexHolder;
import org.hibernate.cfg.PkDrivenByDefaultMapsIdSecondPass;
import org.hibernate.cfg.PropertyData;
import org.hibernate.cfg.QuerySecondPass;
import org.hibernate.cfg.RecoverableException;
import org.hibernate.cfg.SecondPass;
import org.hibernate.cfg.SecondaryTableSecondPass;
import org.hibernate.cfg.SetSimpleValueTypeSecondPass;
import org.hibernate.cfg.UniqueConstraintHolder;
import org.hibernate.cfg.annotations.NamedEntityGraphDefinition;
import org.hibernate.cfg.annotations.NamedProcedureCallDefinition;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.function.SQLFunction;
import org.hibernate.engine.ResultSetMappingDefinition;
import org.hibernate.engine.spi.FilterDefinition;
import org.hibernate.engine.spi.NamedQueryDefinition;
import org.hibernate.engine.spi.NamedSQLQueryDefinition;
import org.hibernate.id.IdentifierGenerator;
import org.hibernate.id.factory.IdentifierGeneratorFactory;
import org.hibernate.id.factory.spi.MutableIdentifierGeneratorFactory;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.internal.SessionFactoryImpl;
import org.hibernate.internal.util.collections.CollectionHelper;
import org.hibernate.mapping.Collection;
import org.hibernate.mapping.Column;
import org.hibernate.mapping.DenormalizedTable;
import org.hibernate.mapping.FetchProfile;
import org.hibernate.mapping.ForeignKey;
import org.hibernate.mapping.IdentifierCollection;
import org.hibernate.mapping.Index;
import org.hibernate.mapping.Join;
import org.hibernate.mapping.KeyValue;
import org.hibernate.mapping.MappedSuperclass;
import org.hibernate.mapping.PersistentClass;
import org.hibernate.mapping.Property;
import org.hibernate.mapping.RootClass;
import org.hibernate.mapping.SimpleValue;
import org.hibernate.mapping.Table;
import org.hibernate.mapping.UniqueKey;
import org.hibernate.query.spi.NamedQueryRepository;
import org.hibernate.type.TypeResolver;
/**
* The implementation of the in-flight Metadata collector contract.
*
* The usage expectation is that this class is used until all Metadata info is
* collected and then {@link #buildMetadataInstance} is called to generate
* the complete (and immutable) Metadata object.
*
* @author Steve Ebersole
*/
public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector {
private static final CoreMessageLogger log = CoreLogging.messageLogger( InFlightMetadataCollectorImpl.class );
private final MetadataBuildingOptions options;
private final TypeResolver typeResolver;
private final AttributeConverterManager attributeConverterManager = new AttributeConverterManager();
private final ClassmateContext classmateContext = new ClassmateContext();
private final UUID uuid;
private final MutableIdentifierGeneratorFactory identifierGeneratorFactory;
private final Map entityBindingMap = new HashMap();
private final Map collectionBindingMap = new HashMap();
private final Map typeDefinitionMap = new HashMap();
private final Map filterDefinitionMap = new HashMap();
private final Map imports = new HashMap();
private Database database;
private final Map namedQueryMap = new HashMap();
private final Map namedNativeQueryMap = new HashMap();
private final Map namedProcedureCallMap = new HashMap();
private final Map sqlResultSetMappingMap = new HashMap();
private final Map namedEntityGraphMap = new HashMap();
private final Map fetchProfileMap = new HashMap();
private final Map idGeneratorDefinitionMap = new HashMap();
private Map sqlFunctionMap;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// All the annotation-processing-specific state :(
private final Set defaultIdentifierGeneratorNames = new HashSet();
private final Set defaultNamedQueryNames = new HashSet();
private final Set defaultNamedNativeQueryNames = new HashSet();
private final Set defaultSqlResultSetMappingNames = new HashSet();
private final Set defaultNamedProcedureNames = new HashSet();
private Map anyMetaDefs;
private Map mappedSuperClasses;
private Map> propertiesAnnotatedWithMapsId;
private Map> propertiesAnnotatedWithIdAndToOne;
private Map mappedByResolver;
private Map propertyRefResolver;
private Set delayedPropertyReferenceHandlers;
private Map
> uniqueConstraintHoldersByTable;
private Map
> jpaIndexHoldersByTable;
public InFlightMetadataCollectorImpl(
MetadataBuildingOptions options,
TypeResolver typeResolver) {
this.uuid = UUID.randomUUID();
this.options = options;
this.typeResolver = typeResolver;
this.identifierGeneratorFactory = options.getServiceRegistry().getService( MutableIdentifierGeneratorFactory.class );
for ( Map.Entry sqlFunctionEntry : options.getSqlFunctions().entrySet() ) {
if ( sqlFunctionMap == null ) {
// we need this to be a ConcurrentHashMap for the one we ultimately pass along to the SF
// but is this the reference that gets passed along?
sqlFunctionMap = new ConcurrentHashMap( 16, .75f, 1 );
}
sqlFunctionMap.put( sqlFunctionEntry.getKey(), sqlFunctionEntry.getValue() );
}
for ( AuxiliaryDatabaseObject auxiliaryDatabaseObject : options.getAuxiliaryDatabaseObjectList() ) {
getDatabase().addAuxiliaryDatabaseObject( auxiliaryDatabaseObject );
}
}
@Override
public UUID getUUID() {
return null;
}
@Override
public MetadataBuildingOptions getMetadataBuildingOptions() {
return options;
}
@Override
public TypeResolver getTypeResolver() {
return typeResolver;
}
@Override
public Database getDatabase() {
// important to delay this instantiation until as late as possible.
if ( database == null ) {
this.database = new Database( options );
}
return database;
}
@Override
public NamedQueryRepository buildNamedQueryRepository(SessionFactoryImpl sessionFactory) {
throw new UnsupportedOperationException( "#buildNamedQueryRepository should not be called on InFlightMetadataCollector" );
}
@Override
public Map getSqlFunctionMap() {
return sqlFunctionMap;
}
@Override
public void validate() throws MappingException {
// nothing to do
}
@Override
public Set getMappedSuperclassMappingsCopy() {
return new HashSet( mappedSuperClasses.values() );
}
@Override
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
return identifierGeneratorFactory;
}
@Override
public SessionFactoryBuilder getSessionFactoryBuilder() {
throw new UnsupportedOperationException(
"You should not be building a SessionFactory from an in-flight metadata collector; and of course " +
"we should better segment this in the API :)"
);
}
@Override
public SessionFactory buildSessionFactory() {
throw new UnsupportedOperationException(
"You should not be building a SessionFactory from an in-flight metadata collector; and of course " +
"we should better segment this in the API :)"
);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Entity handling
@Override
public java.util.Collection getEntityBindings() {
return entityBindingMap.values();
}
@Override
public Map getEntityBindingMap() {
return entityBindingMap;
}
@Override
public PersistentClass getEntityBinding(String entityName) {
return entityBindingMap.get( entityName );
}
@Override
public void addEntityBinding(PersistentClass persistentClass) throws DuplicateMappingException {
final String entityName = persistentClass.getEntityName();
if ( entityBindingMap.containsKey( entityName ) ) {
throw new DuplicateMappingException( DuplicateMappingException.Type.ENTITY, entityName );
}
entityBindingMap.put( entityName, persistentClass );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Collection handling
@Override
public java.util.Collection getCollectionBindings() {
return collectionBindingMap.values();
}
@Override
public Collection getCollectionBinding(String role) {
return collectionBindingMap.get( role );
}
@Override
public void addCollectionBinding(Collection collection) throws DuplicateMappingException {
final String collectionRole = collection.getRole();
if ( collectionBindingMap.containsKey( collectionRole ) ) {
throw new DuplicateMappingException( DuplicateMappingException.Type.COLLECTION, collectionRole );
}
collectionBindingMap.put( collectionRole, collection );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Hibernate Type handling
@Override
public TypeDefinition getTypeDefinition(String registrationKey) {
return typeDefinitionMap.get( registrationKey );
}
@Override
public void addTypeDefinition(TypeDefinition typeDefinition) {
if ( typeDefinition == null ) {
throw new IllegalArgumentException( "Type definition is null" );
}
// Need to register both by name and registration keys.
if ( !StringHelper.isEmpty( typeDefinition.getName() ) ) {
addTypeDefinition( typeDefinition.getName(), typeDefinition );
}
if ( typeDefinition.getRegistrationKeys() != null ) {
for ( String registrationKey : typeDefinition.getRegistrationKeys() ) {
addTypeDefinition( registrationKey, typeDefinition );
}
}
}
private void addTypeDefinition(String registrationKey, TypeDefinition typeDefinition) {
final TypeDefinition previous = typeDefinitionMap.put(
registrationKey, typeDefinition );
if ( previous != null ) {
log.debugf(
"Duplicate typedef name [%s] now -> %s",
registrationKey,
typeDefinition.getTypeImplementorClass().getName()
);
}
}
@Override
public ClassmateContext getClassmateContext() {
return classmateContext;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// attribute converters
@Override
public void addAttributeConverter(AttributeConverterDefinition definition) {
attributeConverterManager.addConverter(
AttributeConverterDescriptorImpl.create(
definition,
classmateContext
)
);
}
@Override
public void addAttributeConverter(Class converterClass) {
addAttributeConverter( AttributeConverterDefinition.from( converterClass ) );
}
@Override
public AttributeConverterAutoApplyHandler getAttributeConverterAutoApplyHandler() {
return attributeConverterManager;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// filter definitions
@Override
public Map getFilterDefinitions() {
return filterDefinitionMap;
}
@Override
public FilterDefinition getFilterDefinition(String name) {
return filterDefinitionMap.get( name );
}
@Override
public void addFilterDefinition(FilterDefinition filterDefinition) {
if ( filterDefinition == null || filterDefinition.getFilterName() == null ) {
throw new IllegalArgumentException( "Filter definition object or name is null: " + filterDefinition );
}
filterDefinitionMap.put( filterDefinition.getFilterName(), filterDefinition );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// fetch profiles
@Override
public java.util.Collection getFetchProfiles() {
return fetchProfileMap.values();
}
@Override
public FetchProfile getFetchProfile(String name) {
return fetchProfileMap.get( name );
}
@Override
public void addFetchProfile(FetchProfile profile) {
if ( profile == null || profile.getName() == null ) {
throw new IllegalArgumentException( "Fetch profile object or name is null: " + profile );
}
FetchProfile old = fetchProfileMap.put( profile.getName(), profile );
if ( old != null ) {
log.warn( "Duplicated fetch profile with same name [" + profile.getName() + "] found." );
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// identifier generators
@Override
public IdentifierGeneratorDefinition getIdentifierGenerator(String name) {
if ( name == null ) {
throw new IllegalArgumentException( "null is not a valid generator name" );
}
return idGeneratorDefinitionMap.get( name );
}
@Override
public java.util.Collection
collectTableMappings() {
ArrayList
tables = new ArrayList
();
for ( Namespace namespace : getDatabase().getNamespaces() ) {
tables.addAll( namespace.getTables() );
}
return tables;
}
@Override
public void addIdentifierGenerator(IdentifierGeneratorDefinition generator) {
if ( generator == null || generator.getName() == null ) {
throw new IllegalArgumentException( "ID generator object or name is null." );
}
if ( defaultIdentifierGeneratorNames.contains( generator.getName() ) ) {
return;
}
final IdentifierGeneratorDefinition old = idGeneratorDefinitionMap.put( generator.getName(), generator );
if ( old != null ) {
log.duplicateGeneratorName( old.getName() );
}
}
@Override
public void addDefaultIdentifierGenerator(IdentifierGeneratorDefinition generator) {
this.addIdentifierGenerator( generator );
defaultIdentifierGeneratorNames.add( generator.getName() );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Named EntityGraph handling
@Override
public NamedEntityGraphDefinition getNamedEntityGraph(String name) {
return namedEntityGraphMap.get( name );
}
@Override
public Map getNamedEntityGraphs() {
return namedEntityGraphMap;
}
@Override
public void addNamedEntityGraph(NamedEntityGraphDefinition definition) {
final String name = definition.getRegisteredName();
final NamedEntityGraphDefinition previous = namedEntityGraphMap.put( name, definition );
if ( previous != null ) {
throw new DuplicateMappingException(
DuplicateMappingException.Type.NAMED_ENTITY_GRAPH, name );
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Named query handling
public NamedQueryDefinition getNamedQueryDefinition(String name) {
if ( name == null ) {
throw new IllegalArgumentException( "null is not a valid query name" );
}
return namedQueryMap.get( name );
}
@Override
public java.util.Collection getNamedQueryDefinitions() {
return namedQueryMap.values();
}
@Override
public void addNamedQuery(NamedQueryDefinition def) {
if ( def == null ) {
throw new IllegalArgumentException( "Named query definition is null" );
}
else if ( def.getName() == null ) {
throw new IllegalArgumentException( "Named query definition name is null: " + def.getQueryString() );
}
if ( defaultNamedQueryNames.contains( def.getName() ) ) {
return;
}
applyNamedQuery( def.getName(), def );
}
private void applyNamedQuery(String name, NamedQueryDefinition query) {
checkQueryName( name );
namedQueryMap.put( name.intern(), query );
}
private void checkQueryName(String name) throws DuplicateMappingException {
if ( namedQueryMap.containsKey( name ) || namedNativeQueryMap.containsKey( name ) ) {
throw new DuplicateMappingException( DuplicateMappingException.Type.QUERY, name );
}
}
@Override
public void addDefaultQuery(NamedQueryDefinition queryDefinition) {
applyNamedQuery( queryDefinition.getName(), queryDefinition );
defaultNamedQueryNames.add( queryDefinition.getName() );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Named native-query handling
@Override
public NamedSQLQueryDefinition getNamedNativeQueryDefinition(String name) {
return namedNativeQueryMap.get( name );
}
@Override
public java.util.Collection getNamedNativeQueryDefinitions() {
return namedNativeQueryMap.values();
}
@Override
public void addNamedNativeQuery(NamedSQLQueryDefinition def) {
if ( def == null ) {
throw new IllegalArgumentException( "Named native query definition object is null" );
}
if ( def.getName() == null ) {
throw new IllegalArgumentException( "Named native query definition name is null: " + def.getQueryString() );
}
if ( defaultNamedNativeQueryNames.contains( def.getName() ) ) {
return;
}
applyNamedNativeQuery( def.getName(), def );
}
private void applyNamedNativeQuery(String name, NamedSQLQueryDefinition query) {
checkQueryName( name );
namedNativeQueryMap.put( name.intern(), query );
}
@Override
public void addDefaultNamedNativeQuery(NamedSQLQueryDefinition query) {
applyNamedNativeQuery( query.getName(), query );
defaultNamedNativeQueryNames.add( query.getName() );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Named stored-procedure handling
@Override
public java.util.Collection getNamedProcedureCallDefinitions() {
return namedProcedureCallMap.values();
}
@Override
public void addNamedProcedureCallDefinition(NamedProcedureCallDefinition definition) {
if ( definition == null ) {
throw new IllegalArgumentException( "Named query definition is null" );
}
final String name = definition.getRegisteredName();
if ( defaultNamedProcedureNames.contains( name ) ) {
return;
}
final NamedProcedureCallDefinition previous = namedProcedureCallMap.put( name, definition );
if ( previous != null ) {
throw new DuplicateMappingException( DuplicateMappingException.Type.PROCEDURE, name );
}
}
@Override
public void addDefaultNamedProcedureCallDefinition(NamedProcedureCallDefinition definition) {
addNamedProcedureCallDefinition( definition );
defaultNamedProcedureNames.add( definition.getRegisteredName() );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// result-set mapping handling
@Override
public Map getResultSetMappingDefinitions() {
return sqlResultSetMappingMap;
}
@Override
public ResultSetMappingDefinition getResultSetMapping(String name) {
return sqlResultSetMappingMap.get( name );
}
@Override
public void addResultSetMapping(ResultSetMappingDefinition resultSetMappingDefinition) {
if ( resultSetMappingDefinition == null ) {
throw new IllegalArgumentException( "Result-set mapping was null" );
}
final String name = resultSetMappingDefinition.getName();
if ( name == null ) {
throw new IllegalArgumentException( "Result-set mapping name is null: " + resultSetMappingDefinition );
}
if ( defaultSqlResultSetMappingNames.contains( name ) ) {
return;
}
applyResultSetMapping( resultSetMappingDefinition );
}
public void applyResultSetMapping(ResultSetMappingDefinition resultSetMappingDefinition) {
final ResultSetMappingDefinition old = sqlResultSetMappingMap.put(
resultSetMappingDefinition.getName(),
resultSetMappingDefinition
);
if ( old != null ) {
throw new DuplicateMappingException(
DuplicateMappingException.Type.RESULT_SET_MAPPING,
resultSetMappingDefinition.getName()
);
}
}
@Override
public void addDefaultResultSetMapping(ResultSetMappingDefinition definition) {
final String name = definition.getName();
if ( !defaultSqlResultSetMappingNames.contains( name ) && sqlResultSetMappingMap.containsKey( name ) ) {
sqlResultSetMappingMap.remove( name );
}
applyResultSetMapping( definition );
defaultSqlResultSetMappingNames.add( name );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// imports
@Override
public Map getImports() {
return imports;
}
@Override
public void addImport(String importName, String entityName) {
if ( importName == null || entityName == null ) {
throw new IllegalArgumentException( "Import name or entity name is null" );
}
log.tracev( "Import: {0} -> {1}", importName, entityName );
String old = imports.put( importName, entityName );
if ( old != null ) {
log.debug( "import name [" + importName + "] overrode previous [{" + old + "}]" );
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Table handling
@Override
public Table addTable(
String schemaName,
String catalogName,
String name,
String subselectFragment,
boolean isAbstract) {
final Namespace namespace = getDatabase().locateNamespace(
getDatabase().toIdentifier( catalogName ),
getDatabase().toIdentifier( schemaName )
);
// annotation binding depends on the "table name" for @Subselect bindings
// being set into the generated table (mainly to avoid later NPE), but for now we need to keep that :(
final Identifier logicalName;
if ( name != null ) {
logicalName = getDatabase().toIdentifier( name );
}
else {
logicalName = null;
}
if ( subselectFragment != null ) {
return new Table( namespace, logicalName, subselectFragment, isAbstract );
}
else {
Table table = namespace.locateTable( logicalName );
if ( table != null ) {
if ( !isAbstract ) {
table.setAbstract( false );
}
return table;
}
return namespace.createTable( logicalName, isAbstract );
}
}
@Override
public Table addDenormalizedTable(
String schemaName,
String catalogName,
String name,
boolean isAbstract,
String subselectFragment,
Table includedTable) throws DuplicateMappingException {
final Namespace namespace = getDatabase().locateNamespace(
getDatabase().toIdentifier( catalogName ),
getDatabase().toIdentifier( schemaName )
);
// annotation binding depends on the "table name" for @Subselect bindings
// being set into the generated table (mainly to avoid later NPE), but for now we need to keep that :(
final Identifier logicalName;
if ( name != null ) {
logicalName = getDatabase().toIdentifier( name );
}
else {
logicalName = null;
}
if ( subselectFragment != null ) {
return new DenormalizedTable( namespace, logicalName, subselectFragment, isAbstract, includedTable );
}
else {
Table table = namespace.locateTable( logicalName );
if ( table != null ) {
throw new DuplicateMappingException( DuplicateMappingException.Type.TABLE, logicalName.toString() );
}
else {
table = namespace.createDenormalizedTable( logicalName, isAbstract, includedTable );
}
return table;
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Mapping impl
@Override
public org.hibernate.type.Type getIdentifierType(String entityName) throws MappingException {
final PersistentClass pc = entityBindingMap.get( entityName );
if ( pc == null ) {
throw new MappingException( "persistent class not known: " + entityName );
}
return pc.getIdentifier().getType();
}
@Override
public String getIdentifierPropertyName(String entityName) throws MappingException {
final PersistentClass pc = entityBindingMap.get( entityName );
if ( pc == null ) {
throw new MappingException( "persistent class not known: " + entityName );
}
if ( !pc.hasIdentifierProperty() ) {
return null;
}
return pc.getIdentifierProperty().getName();
}
@Override
public org.hibernate.type.Type getReferencedPropertyType(String entityName, String propertyName) throws MappingException {
final PersistentClass pc = entityBindingMap.get( entityName );
if ( pc == null ) {
throw new MappingException( "persistent class not known: " + entityName );
}
Property prop = pc.getReferencedProperty( propertyName );
if ( prop == null ) {
throw new MappingException(
"property not known: " +
entityName + '.' + propertyName
);
}
return prop.getType();
}
private Map logicalToPhysicalTableNameMap = new HashMap();
private Map physicalToLogicalTableNameMap = new HashMap();
@Override
public void addTableNameBinding(Identifier logicalName, Table table) {
logicalToPhysicalTableNameMap.put( logicalName, table.getNameIdentifier() );
physicalToLogicalTableNameMap.put( table.getNameIdentifier(), logicalName );
}
@Override
public void addTableNameBinding(String schema, String catalog, String logicalName, String realTableName, Table denormalizedSuperTable) {
final Identifier logicalNameIdentifier = getDatabase().toIdentifier( logicalName );
final Identifier physicalNameIdentifier = getDatabase().toIdentifier( realTableName );
logicalToPhysicalTableNameMap.put( logicalNameIdentifier, physicalNameIdentifier );
physicalToLogicalTableNameMap.put( physicalNameIdentifier, logicalNameIdentifier );
}
@Override
public String getLogicalTableName(Table ownerTable) {
final Identifier logicalName = physicalToLogicalTableNameMap.get( ownerTable.getNameIdentifier() );
if ( logicalName == null ) {
throw new MappingException( "Unable to find physical table: " + ownerTable.getName() );
}
return logicalName.render();
}
@Override
public String getPhysicalTableName(Identifier logicalName) {
final Identifier physicalName = logicalToPhysicalTableNameMap.get( logicalName );
return physicalName == null ? null : physicalName.render();
}
@Override
public String getPhysicalTableName(String logicalName) {
return getPhysicalTableName( getDatabase().toIdentifier( logicalName ) );
}
/**
* Internal struct used to maintain xref between physical and logical column
* names for a table. Mainly this is used to ensure that the defined NamingStrategy
* is not creating duplicate column names.
*/
private class TableColumnNameBinding implements Serializable {
private final String tableName;
private Map logicalToPhysical = new HashMap();
private Map physicalToLogical = new HashMap();
private TableColumnNameBinding(String tableName) {
this.tableName = tableName;
}
public void addBinding(Identifier logicalName, Column physicalColumn) {
final String physicalNameString = physicalColumn.getQuotedName( getDatabase().getJdbcEnvironment().getDialect() );
bindLogicalToPhysical( logicalName, physicalNameString );
bindPhysicalToLogical( logicalName, physicalNameString );
}
private void bindLogicalToPhysical(Identifier logicalName, String physicalName) throws DuplicateMappingException {
final String existingPhysicalNameMapping = logicalToPhysical.put( logicalName, physicalName );
if ( existingPhysicalNameMapping != null ) {
final boolean areSame = logicalName.isQuoted()
? physicalName.equals( existingPhysicalNameMapping )
: physicalName.equalsIgnoreCase( existingPhysicalNameMapping );
if ( !areSame ) {
throw new DuplicateMappingException(
String.format(
Locale.ENGLISH,
"Table [%s] contains logical column name [%s] referring to multiple physical " +
"column names: [%s], [%s]",
tableName,
logicalName,
existingPhysicalNameMapping,
physicalName
),
DuplicateMappingException.Type.COLUMN_BINDING,
tableName + "." + logicalName
);
}
}
}
private void bindPhysicalToLogical(Identifier logicalName, String physicalName) throws DuplicateMappingException {
final Identifier existingLogicalName = physicalToLogical.put( physicalName, logicalName );
if ( existingLogicalName != null && ! existingLogicalName.equals( logicalName ) ) {
throw new DuplicateMappingException(
String.format(
Locale.ENGLISH,
"Table [%s] contains physical column name [%s] referred to by multiple physical " +
"column names: [%s], [%s]",
tableName,
physicalName,
logicalName,
existingLogicalName
),
DuplicateMappingException.Type.COLUMN_BINDING,
tableName + "." + physicalName
);
}
}
}
private Map