Package org.hibernate.boot.spi

Class AbstractDelegatingMetadataBuilderImplementor<T extends MetadataBuilderImplementor>

java.lang.Object

org.hibernate.boot.spi.AbstractDelegatingMetadataBuilderImplementor<T>

Type Parameters:

T - The specific subclass; Allows subclasses to narrow the return type of the contract methods to a specialization of MetadataBuilderImplementor.

All Implemented Interfaces:

MetadataBuilder, MetadataBuilderImplementor

public abstract class AbstractDelegatingMetadataBuilderImplementor<T extends MetadataBuilderImplementor>
extends Object
implements MetadataBuilderImplementor

Convenience base class for custom implementors of MetadataBuilderImplementor using delegation.

Constructor Summary

Constructors

Constructor	Description
AbstractDelegatingMetadataBuilderImplementor(MetadataBuilderImplementor delegate)

Method Summary

Modifier and Type	Method	Description
MetadataBuilder	applyAccessType(AccessType accessType)	Specify the second-level access-type to be used by default for entities and collections that define second-level caching, but do not specify a granular access-type.
MetadataBuilder	applyArchiveDescriptorFactory(ArchiveDescriptorFactory factory)	Specify a particular ArchiveDescriptorFactory instance to use in scanning.
MetadataBuilder	applyAttributeConverter(AttributeConverter attributeConverter)	Adds an AttributeConverter instance.
MetadataBuilder	applyAttributeConverter(AttributeConverter attributeConverter, boolean autoApply)	Adds an AttributeConverter instance, explicitly indicating whether to auto-apply it.
<O,R> MetadataBuilder	applyAttributeConverter(Class<? extends AttributeConverter<O,R>> attributeConverterClass)	Adds an AttributeConverter by its Class.
<O,R> MetadataBuilder	applyAttributeConverter(Class<? extends AttributeConverter<O,R>> attributeConverterClass, boolean autoApply)	Adds an AttributeConverter by Class, explicitly indicating whether to auto-apply it.
MetadataBuilder	applyAttributeConverter(ConverterDescriptor descriptor)	Adds an AttributeConverter by a ConverterDescriptor
MetadataBuilder	applyAuxiliaryDatabaseObject(AuxiliaryDatabaseObject auxiliaryDatabaseObject)	Contribute an AuxiliaryDatabaseObject.
MetadataBuilder	applyBasicType(BasicType<?> type)	Specify an additional or overridden basic type mapping.
MetadataBuilder	applyBasicType(BasicType<?> type, String... keys)	Specify an additional or overridden basic type mapping supplying specific registration keys.
MetadataBuilder	applyBasicType(UserType<?> type, String... keys)	Register an additional or overridden custom type mapping.
MetadataBuilder	applyCacheRegionDefinition(CacheRegionDefinition cacheRegionDefinition)	Apply a CacheRegionDefinition to be applied to an entity, collection, or query while building the Metadata object.
MetadataBuilder	applyColumnOrderingStrategy(ColumnOrderingStrategy columnOrderingStrategy)	Specify the ColumnOrderingStrategy.
MetadataBuilder	applyFunctions(FunctionContributor functionContributor)	Apply an explicit FunctionContributor (implicit application via ServiceLoader will still happen too)
MetadataBuilder	applyImplicitCatalogName(String implicitCatalogName)	Specify the implicit catalog name to apply to any unqualified database names.
MetadataBuilder	applyImplicitNamingStrategy(ImplicitNamingStrategy namingStrategy)	Specify the ImplicitNamingStrategy.
MetadataBuilder	applyImplicitSchemaName(String implicitSchemaName)	Specify the implicit schema name to apply to any unqualified database names.
MetadataBuilder	applyIndexView(org.jboss.jandex.IndexView jandexView)	Allows specifying a specific Jandex index to use for reading annotation information.
MetadataBuilder	applyPhysicalNamingStrategy(PhysicalNamingStrategy namingStrategy)	Specify the PhysicalNamingStrategy.
MetadataBuilder	applyScanEnvironment(ScanEnvironment scanEnvironment)	Consider this temporary as discussed on ScanEnvironment
MetadataBuilder	applyScanner(Scanner scanner)	Specify a particular Scanner instance to use.
MetadataBuilder	applyScanOptions(ScanOptions scanOptions)	Specify the options to be used in performing scanning.
MetadataBuilder	applySharedCacheMode(SharedCacheMode cacheMode)	Specify the second-level cache mode.
MetadataBuilder	applySourceProcessOrdering(MetadataSourceType... sourceTypes)	Apply a specific ordering to the processing of sources.
MetadataBuilder	applySqlFunction(String functionName, SqmFunctionDescriptor function)	Contribute a SqmFunctionDescriptor to HQL.
MetadataBuilder	applyTempClassLoader(ClassLoader tempClassLoader)	Apply a ClassLoader for use while building the Metadata.
MetadataBuilder	applyTypes(TypeContributor typeContributor)	Apply an explicit TypeContributor (implicit application via ServiceLoader will still happen too)
Metadata	build()	Actually build the metamodel
protected MetadataBuilderImplementor	delegate()
MetadataBuilder	enableExplicitDiscriminatorsForJoinedSubclassSupport(boolean enabled)	Should we process or ignore explicitly defined discriminators in the case of joined subclasses? The legacy behavior of Hibernate was to ignore the discriminator annotations because Hibernate (unlike some providers) does not need discriminators to determine the concrete type when it comes to joined inheritance.
MetadataBuilder	enableGlobalNationalizedCharacterDataSupport(boolean enabled)	Should nationalized variants of character data be used in the database types? For example, should NVARCHAR be used instead of VARCHAR? NCLOB instead of CLOB?
MetadataBuilder	enableImplicitDiscriminatorsForJoinedSubclassSupport(boolean enabled)	Similarly to MetadataBuilder.enableExplicitDiscriminatorsForJoinedSubclassSupport(boolean), but here how should we treat joined inheritance when there is no explicitly defined discriminator annotations? If enabled, we will handle joined inheritance with no explicit discriminator annotations by implicitly creating one (following the JPA implicit naming rules).
MetadataBuilder	enableImplicitForcingOfDiscriminatorsInSelect(boolean supported)	For entities which do not explicitly say, should we force discriminators into SQL selects? The (historical) default is false
MetadataBuildingOptions	getMetadataBuildingOptions()	Get the options being collected on this MetadataBuilder that will ultimately be used in building the Metadata.
protected abstract T	getThis()	Returns a specific implementation.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hibernate.boot.MetadataBuilder

applyImplicitListSemantics

Methods inherited from interface org.hibernate.boot.spi.MetadataBuilderImplementor

getBootstrapContext

Constructor Detail

AbstractDelegatingMetadataBuilderImplementor

public AbstractDelegatingMetadataBuilderImplementor(MetadataBuilderImplementor delegate)

Method Detail

delegate

protected MetadataBuilderImplementor delegate()

getThis

protected abstract T getThis()

Returns a specific implementation. See the What is the "getThis trick?".

applyImplicitSchemaName

public MetadataBuilder applyImplicitSchemaName(String implicitSchemaName)

Description copied from interface: MetadataBuilder

Specify the implicit schema name to apply to any unqualified database names.

Its default is defined by the "hibernate.default_schema" setting if using property-based configuration.

Specified by:

applyImplicitSchemaName in interface MetadataBuilder

Parameters:

implicitSchemaName - The implicit schema name

Returns:

this, for method chaining

See Also:

MappingSettings.DEFAULT_SCHEMA

applyImplicitCatalogName

public MetadataBuilder applyImplicitCatalogName(String implicitCatalogName)

Description copied from interface: MetadataBuilder

Specify the implicit catalog name to apply to any unqualified database names.

Its default is defined by the "hibernate.default_catalog" setting if using property-based configuration.

Specified by:

applyImplicitCatalogName in interface MetadataBuilder

Parameters:

implicitCatalogName - The implicit catalog name

Returns:

this, for method chaining

See Also:

MappingSettings.DEFAULT_CATALOG

applyImplicitNamingStrategy

public MetadataBuilder applyImplicitNamingStrategy(ImplicitNamingStrategy namingStrategy)

Description copied from interface: MetadataBuilder

Specify the ImplicitNamingStrategy.

Its default is defined by the "hibernate.implicit_naming_strategy" setting if using property-based configuration.

Specified by:

applyImplicitNamingStrategy in interface MetadataBuilder

Parameters:

namingStrategy - The ImplicitNamingStrategy

Returns:

this, for method chaining

See Also:

MappingSettings.IMPLICIT_NAMING_STRATEGY

applyPhysicalNamingStrategy

public MetadataBuilder applyPhysicalNamingStrategy(PhysicalNamingStrategy namingStrategy)

Description copied from interface: MetadataBuilder

Specify the PhysicalNamingStrategy.

Its default is defined by the "hibernate.physical_naming_strategy" setting if using property-based configuration.

Specified by:

applyPhysicalNamingStrategy in interface MetadataBuilder

Parameters:

namingStrategy - The PhysicalNamingStrategy

Returns:

this, for method chaining

See Also:

MappingSettings.PHYSICAL_NAMING_STRATEGY

applyColumnOrderingStrategy

public MetadataBuilder applyColumnOrderingStrategy(ColumnOrderingStrategy columnOrderingStrategy)

Description copied from interface: MetadataBuilder

Specify the ColumnOrderingStrategy.

Its default is defined by the "hibernate.column_ordering_strategy" setting if using property-based configuration.

Specified by:

applyColumnOrderingStrategy in interface MetadataBuilder

Parameters:

columnOrderingStrategy - The ColumnOrderingStrategy

Returns:

this, for method chaining

See Also:

MappingSettings.IMPLICIT_NAMING_STRATEGY

applySharedCacheMode

public MetadataBuilder applySharedCacheMode(SharedCacheMode cacheMode)

Description copied from interface: MetadataBuilder

Specify the second-level cache mode.

Its default is defined by the javax.persistence.sharedCache.mode setting if using property-based configuration.

Specified by:

applySharedCacheMode in interface MetadataBuilder

Parameters:

cacheMode - The cache mode.

Returns:

this, for method chaining

See Also:

MetadataBuilder.applyAccessType(org.hibernate.cache.spi.access.AccessType)

applyAccessType

public MetadataBuilder applyAccessType(AccessType accessType)

Description copied from interface: MetadataBuilder

Specify the second-level access-type to be used by default for entities and collections that define second-level caching, but do not specify a granular access-type.

Its default is defined by the "hibernate.cache.default_cache_concurrency_strategy" setting if using property-based configuration.

Specified by:

applyAccessType in interface MetadataBuilder

Parameters:

accessType - The access-type to use as default.

Returns:

this, for method chaining

See Also:

CacheSettings.DEFAULT_CACHE_CONCURRENCY_STRATEGY, MetadataBuilder.applySharedCacheMode(jakarta.persistence.SharedCacheMode)

applyIndexView

public MetadataBuilder applyIndexView(org.jboss.jandex.IndexView jandexView)

Description copied from interface: MetadataBuilder

Allows specifying a specific Jandex index to use for reading annotation information.

It's important to understand that if a Jandex index is passed in, it is expected that this Jandex index already contains all entries for all classes. No additional indexing will be done in this case.

Specified by:

applyIndexView in interface MetadataBuilder

Parameters:

jandexView - The Jandex index to use.

Returns:

this, for method chaining

applyScanOptions

public MetadataBuilder applyScanOptions(ScanOptions scanOptions)

Description copied from interface: MetadataBuilder

Specify the options to be used in performing scanning.

Specified by:

applyScanOptions in interface MetadataBuilder

Parameters:

scanOptions - The scan options.

Returns:

this, for method chaining

See Also:

PersistenceSettings.SCANNER_DISCOVERY

applyScanEnvironment

public MetadataBuilder applyScanEnvironment(ScanEnvironment scanEnvironment)

Description copied from interface: MetadataBuilder

Consider this temporary as discussed on ScanEnvironment

Specified by:

applyScanEnvironment in interface MetadataBuilder

Parameters:

scanEnvironment - The environment for scanning

Returns:

this, for method chaining

applyScanner

public MetadataBuilder applyScanner(Scanner scanner)

Description copied from interface: MetadataBuilder

Specify a particular Scanner instance to use.

Its default is defined by the "hibernate.archive.scanner" setting if using property-based configuration.

Specified by:

applyScanner in interface MetadataBuilder

Parameters:

scanner - The scanner to use.

Returns:

this, for method chaining

See Also:

PersistenceSettings.SCANNER

applyArchiveDescriptorFactory

public MetadataBuilder applyArchiveDescriptorFactory(ArchiveDescriptorFactory factory)

Description copied from interface: MetadataBuilder

Specify a particular ArchiveDescriptorFactory instance to use in scanning.

Its default is defined by the "hibernate.archive.interpreter" setting if using property-based configuration.

Specified by:

applyArchiveDescriptorFactory in interface MetadataBuilder

Parameters:

factory - The ArchiveDescriptorFactory to use.

Returns:

this, for method chaining

See Also:

PersistenceSettings.SCANNER_ARCHIVE_INTERPRETER

enableExplicitDiscriminatorsForJoinedSubclassSupport

public MetadataBuilder enableExplicitDiscriminatorsForJoinedSubclassSupport(boolean enabled)

Description copied from interface: MetadataBuilder

Should we process or ignore explicitly defined discriminators in the case of joined subclasses? The legacy behavior of Hibernate was to ignore the discriminator annotations because Hibernate (unlike some providers) does not need discriminators to determine the concrete type when it comes to joined inheritance. However, for portability reasons we do now allow using explicit discriminators along with joined inheritance. It is configurable though to support legacy apps.

Its default is defined by the "hibernate.discriminator.ignore_explicit_for_joined" setting if using property-based configuration.

Specified by:

enableExplicitDiscriminatorsForJoinedSubclassSupport in interface MetadataBuilder

Parameters:

enabled - Should processing (not ignoring) explicit discriminators be enabled?

Returns:

this, for method chaining

See Also:

MappingSettings.IGNORE_EXPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS

enableImplicitDiscriminatorsForJoinedSubclassSupport

public MetadataBuilder enableImplicitDiscriminatorsForJoinedSubclassSupport(boolean enabled)

Description copied from interface: MetadataBuilder

Similarly to MetadataBuilder.enableExplicitDiscriminatorsForJoinedSubclassSupport(boolean), but here how should we treat joined inheritance when there is no explicitly defined discriminator annotations? If enabled, we will handle joined inheritance with no explicit discriminator annotations by implicitly creating one (following the JPA implicit naming rules).

Again the premise here is JPA portability, bearing in mind that some JPA provider need these discriminators.

Its default is defined by the "hibernate.discriminator.implicit_for_joined" setting if using property-based configuration.

Specified by:

enableImplicitDiscriminatorsForJoinedSubclassSupport in interface MetadataBuilder

Parameters:

enabled - Should we implicitly create discriminator for joined inheritance if one is not explicitly mentioned?

Returns:

this, for method chaining

See Also:

MappingSettings.IMPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS

enableImplicitForcingOfDiscriminatorsInSelect

public MetadataBuilder enableImplicitForcingOfDiscriminatorsInSelect(boolean supported)

Description copied from interface: MetadataBuilder

For entities which do not explicitly say, should we force discriminators into SQL selects? The (historical) default is false

Its default is defined by the "hibernate.discriminator.force_in_select" setting if using property-based configuration.

Specified by:

enableImplicitForcingOfDiscriminatorsInSelect in interface MetadataBuilder

Parameters:

supported - true indicates we will force the discriminator into the select; false indicates we will not.

Returns:

this, for method chaining

See Also:

MappingSettings.FORCE_DISCRIMINATOR_IN_SELECTS_BY_DEFAULT

enableGlobalNationalizedCharacterDataSupport

public MetadataBuilder enableGlobalNationalizedCharacterDataSupport(boolean enabled)

Description copied from interface: MetadataBuilder

Should nationalized variants of character data be used in the database types? For example, should NVARCHAR be used instead of VARCHAR? NCLOB instead of CLOB?

Its default is defined by the "hibernate.use_nationalized_character_data" setting if using property-based configuration.

Specified by:

enableGlobalNationalizedCharacterDataSupport in interface MetadataBuilder

Parameters:

enabled - true says to use nationalized variants; false says to use the non-nationalized variants.

Returns:

this, for method chaining

See Also:

MappingSettings.USE_NATIONALIZED_CHARACTER_DATA

applyBasicType

public MetadataBuilder applyBasicType(BasicType<?> type)

Description copied from interface: MetadataBuilder

Specify an additional or overridden basic type mapping.

Specified by:

applyBasicType in interface MetadataBuilder

Parameters:

type - The type addition or override.

Returns:

this, for method chaining

applyBasicType

public MetadataBuilder applyBasicType(BasicType<?> type,
                                      String... keys)

Description copied from interface: MetadataBuilder

Specify an additional or overridden basic type mapping supplying specific registration keys.

Specified by:

applyBasicType in interface MetadataBuilder

Parameters:

type - The type addition or override.

keys - The keys under which to register the basic type.

Returns:

this, for method chaining

applyBasicType

public MetadataBuilder applyBasicType(UserType<?> type,
                                      String... keys)

Description copied from interface: MetadataBuilder

Register an additional or overridden custom type mapping.

Specified by:

applyBasicType in interface MetadataBuilder

Parameters:

type - The custom type

keys - The keys under which to register the custom type.

Returns:

this, for method chaining

applyTypes

public MetadataBuilder applyTypes(TypeContributor typeContributor)

Description copied from interface: MetadataBuilder

Apply an explicit TypeContributor (implicit application via ServiceLoader will still happen too)

Specified by:

applyTypes in interface MetadataBuilder

Parameters:

typeContributor - The contributor to apply

Returns:

this, for method chaining

applyCacheRegionDefinition

public MetadataBuilder applyCacheRegionDefinition(CacheRegionDefinition cacheRegionDefinition)

Description copied from interface: MetadataBuilder

Apply a CacheRegionDefinition to be applied to an entity, collection, or query while building the Metadata object.

Specified by:

applyCacheRegionDefinition in interface MetadataBuilder

Parameters:

cacheRegionDefinition - The cache region definition to apply

Returns:

this, for method chaining

applyTempClassLoader

public MetadataBuilder applyTempClassLoader(ClassLoader tempClassLoader)

Description copied from interface: MetadataBuilder

Apply a ClassLoader for use while building the Metadata.

Ideally we should avoid accessing ClassLoaders when perform 1st phase of bootstrap. This is a ClassLoader that can be used in cases where we absolutely must.

In EE managed environments, this is the ClassLoader mandated by PersistenceUnitInfo.getNewTempClassLoader(). This ClassLoader is discarded by the container afterward, the idea being that the Class can still be enhanced in the application ClassLoader.

In other environments, pass a ClassLoader that performs the same function, if desired.

Specified by:

applyTempClassLoader in interface MetadataBuilder

Parameters:

tempClassLoader - ClassLoader for use while building the Metadata

Returns:

this, for method chaining

applySourceProcessOrdering

public MetadataBuilder applySourceProcessOrdering(MetadataSourceType... sourceTypes)

Description copied from interface: MetadataBuilder

Apply a specific ordering to the processing of sources.

Unlike most of the methods of this interface (which deal with multiple values internally), this one replaces any source processing order that was already set.

Its default is defined by the "hibernate.mapping.precedence" setting if using property-based configuration.

Specified by:

applySourceProcessOrdering in interface MetadataBuilder

Parameters:

sourceTypes - The types, in the order they should be processed

Returns:

this for method chaining

See Also:

MappingSettings.ARTIFACT_PROCESSING_ORDER

applyFunctions

public MetadataBuilder applyFunctions(FunctionContributor functionContributor)

Description copied from interface: MetadataBuilder

Apply an explicit FunctionContributor (implicit application via ServiceLoader will still happen too)

Specified by:

applyFunctions in interface MetadataBuilder

Parameters:

functionContributor - The contributor to apply

Returns:

this, for method chaining

applySqlFunction

public MetadataBuilder applySqlFunction(String functionName,
                                        SqmFunctionDescriptor function)

Description copied from interface: MetadataBuilder

Contribute a SqmFunctionDescriptor to HQL.

Specified by:

applySqlFunction in interface MetadataBuilder

See Also:

StandardSQLFunction

applyAuxiliaryDatabaseObject

public MetadataBuilder applyAuxiliaryDatabaseObject(AuxiliaryDatabaseObject auxiliaryDatabaseObject)

Description copied from interface: MetadataBuilder

Contribute an AuxiliaryDatabaseObject.

Specified by:

applyAuxiliaryDatabaseObject in interface MetadataBuilder

applyAttributeConverter

public MetadataBuilder applyAttributeConverter(ConverterDescriptor descriptor)

Description copied from interface: MetadataBuilder

Adds an AttributeConverter by a ConverterDescriptor

Specified by:

applyAttributeConverter in interface MetadataBuilder

Parameters:

descriptor - The descriptor

Returns:

this for method chaining

applyAttributeConverter

public <O,R> MetadataBuilder applyAttributeConverter(Class<? extends AttributeConverter<O,R>> attributeConverterClass)

Description copied from interface: MetadataBuilder

Adds an AttributeConverter by its Class.

Specified by:

applyAttributeConverter in interface MetadataBuilder

Parameters:

attributeConverterClass - The AttributeConverter class.

Returns:

this for method chaining

applyAttributeConverter

public <O,R> MetadataBuilder applyAttributeConverter(Class<? extends AttributeConverter<O,R>> attributeConverterClass,
                                                           boolean autoApply)

Description copied from interface: MetadataBuilder

Adds an AttributeConverter by Class, explicitly indicating whether to auto-apply it.

Specified by:

applyAttributeConverter in interface MetadataBuilder

Parameters:

attributeConverterClass - The AttributeConverter class.

autoApply - Should the AttributeConverter be auto applied to property types as specified by its "entity attribute" parameterized type?

Returns:

this for method chaining

applyAttributeConverter

public MetadataBuilder applyAttributeConverter(AttributeConverter attributeConverter)

Description copied from interface: MetadataBuilder

Adds an AttributeConverter instance.

Specified by:

applyAttributeConverter in interface MetadataBuilder

Parameters:

attributeConverter - The AttributeConverter instance.

Returns:

this for method chaining

applyAttributeConverter

public MetadataBuilder applyAttributeConverter(AttributeConverter attributeConverter,
                                               boolean autoApply)

Description copied from interface: MetadataBuilder

Adds an AttributeConverter instance, explicitly indicating whether to auto-apply it.

Specified by:

applyAttributeConverter in interface MetadataBuilder

Parameters:

attributeConverter - The AttributeConverter instance.

autoApply - Should the AttributeConverter be auto applied to property types as specified by its "entity attribute" parameterized type?

Returns:

this for method chaining

getMetadataBuildingOptions

public MetadataBuildingOptions getMetadataBuildingOptions()

Description copied from interface: MetadataBuilderImplementor

Get the options being collected on this MetadataBuilder that will ultimately be used in building the Metadata.

Specified by:

getMetadataBuildingOptions in interface MetadataBuilderImplementor

Returns:

The current building options

build

public Metadata build()

Description copied from interface: MetadataBuilder

Actually build the metamodel

Specified by:

build in interface MetadataBuilder

Returns:

The built metadata.