@Override
public IdentifierGenerator createIdentifierGenerator(
		IdentifierGeneratorFactory identifierGeneratorFactory,
		Dialect dialect,
		String defaultCatalog,
		String defaultSchema,
		RootClass rootClass) throws MappingException {
	if ( builtIdentifierGenerator == null ) {
		builtIdentifierGenerator = buildIdentifierGenerator(
				identifierGeneratorFactory,
				dialect,
				defaultCatalog,
				defaultSchema,
				rootClass
		);
	}
	return builtIdentifierGenerator;
}
 

@Override
@Deprecated
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
    return metadata.getIdentifierGeneratorFactory();
}
 

public IdentifierGenerator createIdentifierGenerator(
IdentifierGeneratorFactory identifierGeneratorFactory,
Dialect dialect,
String defaultCatalog,
String defaultSchema,
RootClass rootClass) throws MappingException;
 

private IdentifierGenerator buildIdentifierGenerator(
		IdentifierGeneratorFactory identifierGeneratorFactory,
		Dialect dialect,
		String defaultCatalog,
		String defaultSchema,
		RootClass rootClass) throws MappingException {
	final boolean hasCustomGenerator = ! DEFAULT_ID_GEN_STRATEGY.equals( getIdentifierGeneratorStrategy() );
	if ( hasCustomGenerator ) {
		return super.createIdentifierGenerator(
				identifierGeneratorFactory, dialect, defaultCatalog, defaultSchema, rootClass
		);
	}

	final Class entityClass = rootClass.getMappedClass();
	final Class attributeDeclarer; // what class is the declarer of the composite pk attributes
	CompositeNestedGeneratedValueGenerator.GenerationContextLocator locator;

	// IMPL NOTE : See the javadoc discussion on CompositeNestedGeneratedValueGenerator wrt the
	//		various scenarios for which we need to account here
	if ( rootClass.getIdentifierMapper() != null ) {
		// we have the @IdClass / <composite-id mapped="true"/> case
		attributeDeclarer = resolveComponentClass();
	}
	else if ( rootClass.getIdentifierProperty() != null ) {
		// we have the "@EmbeddedId" / <composite-id name="idName"/> case
		attributeDeclarer = resolveComponentClass();
	}
	else {
		// we have the "straight up" embedded (again the hibernate term) component identifier
		attributeDeclarer = entityClass;
	}

	locator = new StandardGenerationContextLocator( rootClass.getEntityName() );
	final CompositeNestedGeneratedValueGenerator generator = new CompositeNestedGeneratedValueGenerator( locator );

	Iterator itr = getPropertyIterator();
	while ( itr.hasNext() ) {
		final Property property = (Property) itr.next();
		if ( property.getValue().isSimpleValue() ) {
			final SimpleValue value = (SimpleValue) property.getValue();

			if ( DEFAULT_ID_GEN_STRATEGY.equals( value.getIdentifierGeneratorStrategy() ) ) {
				// skip any 'assigned' generators, they would have been handled by
				// the StandardGenerationContextLocator
				continue;
			}

			final IdentifierGenerator valueGenerator = value.createIdentifierGenerator(
					identifierGeneratorFactory,
					dialect,
					defaultCatalog,
					defaultSchema,
					rootClass
			);
			generator.addGeneratedValuePlan(
					new ValueGenerationPlan(
							valueGenerator,
							injector( property, attributeDeclarer )
					)
			);
		}
	}
	return generator;
}
 

@Override
public IdentifierGenerator createIdentifierGenerator(
		IdentifierGeneratorFactory identifierGeneratorFactory,
		Dialect dialect, 
		String defaultCatalog, 
		String defaultSchema, 
		RootClass rootClass) throws MappingException {

	if ( identifierGenerator != null ) {
		return identifierGenerator;
	}

	Properties params = new Properties();
	
	//if the hibernate-mapping did not specify a schema/catalog, use the defaults
	//specified by properties - but note that if the schema/catalog were specified
	//in hibernate-mapping, or as params, they will already be initialized and
	//will override the values set here (they are in identifierGeneratorProperties)
	if ( defaultSchema!=null ) {
		params.setProperty(PersistentIdentifierGenerator.SCHEMA, defaultSchema);
	}
	if ( defaultCatalog!=null ) {
		params.setProperty(PersistentIdentifierGenerator.CATALOG, defaultCatalog);
	}
	
	//pass the entity-name, if not a collection-id
	if (rootClass!=null) {
		params.setProperty( IdentifierGenerator.ENTITY_NAME, rootClass.getEntityName() );
		params.setProperty( IdentifierGenerator.JPA_ENTITY_NAME, rootClass.getJpaEntityName() );
	}
	
	//init the table here instead of earlier, so that we can get a quoted table name
	//TODO: would it be better to simply pass the qualified table name, instead of
	//      splitting it up into schema/catalog/table names
	String tableName = getTable().getQuotedName(dialect);
	params.setProperty( PersistentIdentifierGenerator.TABLE, tableName );
	
	//pass the column name (a generated id almost always has a single column)
	String columnName = ( (Column) getColumnIterator().next() ).getQuotedName(dialect);
	params.setProperty( PersistentIdentifierGenerator.PK, columnName );
	
	if (rootClass!=null) {
		StringBuilder tables = new StringBuilder();
		Iterator iter = rootClass.getIdentityTables().iterator();
		while ( iter.hasNext() ) {
			Table table= (Table) iter.next();
			tables.append( table.getQuotedName(dialect) );
			if ( iter.hasNext() ) {
				tables.append(", ");
			}
		}
		params.setProperty( PersistentIdentifierGenerator.TABLES, tables.toString() );
	}
	else {
		params.setProperty( PersistentIdentifierGenerator.TABLES, tableName );
	}

	if (identifierGeneratorProperties!=null) {
		params.putAll(identifierGeneratorProperties);
	}

	// TODO : we should pass along all settings once "config lifecycle" is hashed out...
	final ConfigurationService cs = metadata.getMetadataBuildingOptions().getServiceRegistry()
			.getService( ConfigurationService.class );

	params.put(
			AvailableSettings.PREFER_POOLED_VALUES_LO,
			cs.getSetting( AvailableSettings.PREFER_POOLED_VALUES_LO, StandardConverters.BOOLEAN, false )
	);
	if ( cs.getSettings().get( AvailableSettings.PREFERRED_POOLED_OPTIMIZER ) != null ) {
		params.put(
				AvailableSettings.PREFERRED_POOLED_OPTIMIZER,
				cs.getSettings().get( AvailableSettings.PREFERRED_POOLED_OPTIMIZER )
		);
	}

	identifierGeneratorFactory.setDialect( dialect );
	identifierGenerator = identifierGeneratorFactory.createIdentifierGenerator( identifierGeneratorStrategy, getType(), params );

	return identifierGenerator;
}
 

public boolean isIdentityColumn(IdentifierGeneratorFactory identifierGeneratorFactory, Dialect dialect) {
	identifierGeneratorFactory.setDialect( dialect );
	return IdentityGenerator.class.isAssignableFrom(identifierGeneratorFactory.getIdentifierGeneratorClass( identifierGeneratorStrategy ));
}
 

@Override
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
	return delegate.getIdentifierGeneratorFactory();
}
 

public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
	return null;
}
 

@Override
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
	return delegate.getIdentifierGeneratorFactory();
}
 

@Override
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
	return identifierGeneratorFactory;
}
 

@Override
public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
	return identifierGeneratorFactory;
}
 

public IdentifierGeneratorFactory getIdentifierGeneratorFactory() {
    return sessionFactoryImplementor.getIdentifierGeneratorFactory();
}
 

/**
 * Allow access to the id generator factory, though this is only needed/allowed from configuration.
 *
 * @return Access to the identifier generator factory
 *
 * @deprecated temporary solution 
 */
@Deprecated
public IdentifierGeneratorFactory getIdentifierGeneratorFactory();
 

public boolean isIdentityColumn(IdentifierGeneratorFactory identifierGeneratorFactory, Dialect dialect);