Interface MetadataBuilder

    • Method Detail

      • applySharedCacheMode

        MetadataBuilder applySharedCacheMode​(jakarta.persistence.SharedCacheMode cacheMode)
        Specify the second-level cache mode to be used. This is the cache mode in terms of whether or not to cache.

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

        Parameters:
        cacheMode - The cache mode.
        Returns:
        this, for method chaining
        See Also:
        applyAccessType(org.hibernate.cache.spi.access.AccessType)
      • applyIndexView

        MetadataBuilder applyIndexView​(org.jboss.jandex.IndexView jandexView)
        Allows specifying a specific Jandex index to use for reading annotation information.

        It is 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.

        NOTE : Here for future expansion. At the moment the passed Jandex index is not used.

        Parameters:
        jandexView - The Jandex index to use.
        Returns:
        this, for method chaining
      • applyScanEnvironment

        MetadataBuilder applyScanEnvironment​(ScanEnvironment scanEnvironment)
        Consider this temporary as discussed on ScanEnvironment
        Parameters:
        scanEnvironment - The environment for scanning
        Returns:
        this, for method chaining
      • enableNewIdentifierGeneratorSupport

        MetadataBuilder enableNewIdentifierGeneratorSupport​(boolean enable)
        Should we enable support for the "new" (since 3.2) identifier generator mappings for handling:
        • GenerationType.SEQUENCE
        • GenerationType.IDENTITY
        • GenerationType.TABLE
        • GenerationType.AUTO

        Its default is defined by the AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS setting if using property-based configuration.

        Parameters:
        enable - true to enable; false to disable; don't call for default.
        Returns:
        this, for method chaining
        See Also:
        AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS
      • enableExplicitDiscriminatorsForJoinedSubclassSupport

        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. 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 AvailableSettings.IGNORE_EXPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS setting if using property-based configuration.

        Parameters:
        enabled - Should processing (not ignoring) explicit discriminators be enabled?
        Returns:
        this, for method chaining
        See Also:
        AvailableSettings.IGNORE_EXPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS
      • enableGlobalNationalizedCharacterDataSupport

        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?

        Its default is defined by the AvailableSettings.USE_NATIONALIZED_CHARACTER_DATA setting if using property-based configuration.

        Parameters:
        enabled - true says to use nationalized variants; false says to use the non-nationalized variants.
        Returns:
        this, for method chaining
        See Also:
        AvailableSettings.USE_NATIONALIZED_CHARACTER_DATA
      • applyBasicType

        MetadataBuilder applyBasicType​(BasicType type)
        Specify an additional or overridden basic type mapping.
        Parameters:
        type - The type addition or override.
        Returns:
        this, for method chaining
      • applyBasicType

        MetadataBuilder applyBasicType​(BasicType type,
                                       String... keys)
        Specify an additional or overridden basic type mapping supplying specific registration keys.
        Parameters:
        type - The type addition or override.
        keys - The keys under which to register the basic type.
        Returns:
        this, for method chaining
      • applyBasicType

        MetadataBuilder applyBasicType​(UserType type,
                                       String... keys)
        Register an additional or overridden custom type mapping.
        Parameters:
        type - The custom type
        keys - The keys under which to register the custom type.
        Returns:
        this, for method chaining
      • applyTypes

        MetadataBuilder applyTypes​(TypeContributor typeContributor)
        Apply an explicit TypeContributor (implicit application via ServiceLoader will still happen too)
        Parameters:
        typeContributor - The contributor to apply
        Returns:
        this, for method chaining
      • applyCacheRegionDefinition

        MetadataBuilder applyCacheRegionDefinition​(CacheRegionDefinition cacheRegionDefinition)
        Apply a CacheRegionDefinition to be applied to an entity, collection or query while building the Metadata object.
        Parameters:
        cacheRegionDefinition - The cache region definition to apply
        Returns:
        this, for method chaining
      • applyTempClassLoader

        MetadataBuilder applyTempClassLoader​(ClassLoader tempClassLoader)
        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 when we have to. IN EE managed environments, this is the ClassLoader mandated by PersistenceUnitInfo.getNewTempClassLoader(). This ClassLoader is thrown away by the container afterwards. 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.

        Parameters:
        tempClassLoader - ClassLoader for use during building the Metadata
        Returns:
        this, for method chaining
      • applySourceProcessOrdering

        MetadataBuilder applySourceProcessOrdering​(MetadataSourceType... sourceTypes)
        Apply a specific ordering to the processing of sources. Note that unlike most of the methods on this contract that deal with multiple values internally, this one *replaces* any already set (its more a setter) instead of adding to.

        Its default is defined by the AvailableSettings.ARTIFACT_PROCESSING_ORDER setting if using property-based configuration.

        Parameters:
        sourceTypes - The types, in the order they should be processed
        Returns:
        this for method chaining
        See Also:
        AvailableSettings.ARTIFACT_PROCESSING_ORDER
      • applyAttributeConverter

        MetadataBuilder applyAttributeConverter​(ConverterDescriptor definition)
        Adds an AttributeConverter by an AttributeConverterDefinition
        Parameters:
        definition - The definition
        Returns:
        this for method chaining
      • applyAttributeConverter

        <O,​R> MetadataBuilder applyAttributeConverter​(Class<? extends jakarta.persistence.AttributeConverter<O,​R>> attributeConverterClass)
        Adds an AttributeConverter by its Class.
        Parameters:
        attributeConverterClass - The AttributeConverter class.
        Returns:
        this for method chaining
      • applyAttributeConverter

        <O,​R> MetadataBuilder applyAttributeConverter​(Class<? extends jakarta.persistence.AttributeConverter<O,​R>> attributeConverterClass,
                                                            boolean autoApply)
        Adds an AttributeConverter by its Class plus a boolean indicating whether to auto apply it.
        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

        <O,​R> MetadataBuilder applyAttributeConverter​(jakarta.persistence.AttributeConverter<O,​R> attributeConverter)
        Adds an AttributeConverter instance.
        Parameters:
        attributeConverter - The AttributeConverter instance.
        Returns:
        this for method chaining
      • applyAttributeConverter

        MetadataBuilder applyAttributeConverter​(jakarta.persistence.AttributeConverter attributeConverter,
                                                boolean autoApply)
        Adds an AttributeConverter instance, explicitly indicating whether to auto-apply.
        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
      • unwrap

        <T extends MetadataBuilder> T unwrap​(Class<T> type)
        Allows unwrapping this builder as another, more specific type.
        Type Parameters:
        T -
        Parameters:
        type -
        Returns:
        The unwrapped builder.
      • build

        Metadata build()
        Actually build the metamodel
        Returns:
        The built metadata.