java.lang.Object
- org.hibernate.jpa.internal.MutableJpaComplianceImpl

All Implemented Interfaces:: JpaCompliance, MutableJpaCompliance

public class MutableJpaComplianceImpl
extends Object
implements MutableJpaCompliance

Constructor Summary

Constructors
Constructor	Description
`MutableJpaComplianceImpl(Map<?,?> configurationSettings)`
`MutableJpaComplianceImpl(Map<?,?> configurationSettings, boolean jpaByDefault)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`JpaCompliance`	`immutableCopy()`
`boolean`	`isGlobalGeneratorScopeEnabled()`	Should the scope of `TableGenerator.name()` and `SequenceGenerator.name()` be considered globally or locally defined?
`boolean`	`isJpaCacheComplianceEnabled()`	Should Hibernate comply with all aspects of caching as defined by JPA? Or can it deviate to perform things it believes will be "better"?
`boolean`	`isJpaClosedComplianceEnabled()`	JPA defines specific exceptions on specific methods when called on `EntityManager` and `EntityManagerFactory` when those objects have been closed.
`boolean`	`isJpaListComplianceEnabled()`	Controls how Hibernate interprets a mapped `List` without no order column specified.
`boolean`	`isJpaOrderByMappingComplianceEnabled()`	Should we strictly handle `OrderBy` expressions?
`boolean`	`isJpaProxyComplianceEnabled()`	JPA spec says that an `EntityNotFoundException` should be thrown when accessing an entity proxy which does not have an associated table row in the database.
`boolean`	`isJpaQueryComplianceEnabled()`	Controls whether Hibernate's handling of JPA's `Query` (JPQL, Criteria and native-query) should strictly follow the JPA spec.
`boolean`	`isJpaTransactionComplianceEnabled()`	Indicates that Hibernate's `Transaction` should behave as defined by the specification for JPA's `EntityTransaction` since it extends it.
`boolean`	`isLoadByIdComplianceEnabled()`	JPA says that the id passed to `EntityManager.getReference(java.lang.Class<T>, java.lang.Object)` and `EntityManager.find(java.lang.Class<T>, java.lang.Object)` should be exactly the expected type, allowing no type coercion.
`void`	`setCachingCompliance(boolean cachingCompliance)`
`void`	`setClosedCompliance(boolean closedCompliance)`
`void`	`setGeneratorNameScopeCompliance(boolean enabled)`
`void`	`setListCompliance(boolean listCompliance)`
`void`	`setLoadByIdCompliance(boolean enabled)`
`void`	`setOrderByMappingCompliance(boolean orderByMappingCompliance)`
`void`	`setProxyCompliance(boolean proxyCompliance)`
`void`	`setQueryCompliance(boolean queryCompliance)`
`void`	`setTransactionCompliance(boolean transactionCompliance)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - MutableJpaComplianceImpl
```
public MutableJpaComplianceImpl(Map<?,?> configurationSettings)
```
  - MutableJpaComplianceImpl
```
public MutableJpaComplianceImpl(Map<?,?> configurationSettings,
                                boolean jpaByDefault)
```
- Method Detail
  - isJpaQueryComplianceEnabled
```
public boolean isJpaQueryComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    Controls whether Hibernate's handling of JPA's Query (JPQL, Criteria and native-query) should strictly follow the JPA spec. This includes parsing and translating a query as JPQL instead of HQL, as well as whether calls to the Query methods always throw the exceptions defined by the specification.
    Deviations result in an exception, if enabled.
    
    Specified by:
    
    isJpaQueryComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way
    
    See Also:
    
    AvailableSettings.JPA_QUERY_COMPLIANCE
  - isJpaTransactionComplianceEnabled
```
public boolean isJpaTransactionComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    Indicates that Hibernate's Transaction should behave as defined by the specification for JPA's EntityTransaction since it extends it.
    
    Specified by:
    
    isJpaTransactionComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way
    
    See Also:
    
    AvailableSettings.JPA_TRANSACTION_COMPLIANCE
  - isJpaListComplianceEnabled
```
public boolean isJpaListComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    Controls how Hibernate interprets a mapped List without no order column specified. Historically Hibernate treats this as a "bag", which is a concept JPA does not have.
    
    If enabled, Hibernate will recognize this case as a list.
    Otherwise, if disabled, Hibernate will treat it as a "bag".
    Specified by:
    
    isJpaListComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way, interpreting the mapping as a "list", rather than a "bag"
    
    See Also:
    
    AvailableSettings.JPA_LIST_COMPLIANCE
  - isJpaClosedComplianceEnabled
```
public boolean isJpaClosedComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    JPA defines specific exceptions on specific methods when called on EntityManager and EntityManagerFactory when those objects have been closed. This setting controls whether the spec defined behavior or Hibernate's behavior will be used.
    If enabled Hibernate will operate in the JPA specified way throwing exceptions when the spec says it should with regard to close checking
    
    Specified by:
    
    isJpaClosedComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way
    
    See Also:
    
    AvailableSettings.JPA_CLOSED_COMPLIANCE
  - isJpaProxyComplianceEnabled
```
public boolean isJpaProxyComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    JPA spec says that an EntityNotFoundException should be thrown when accessing an entity proxy which does not have an associated table row in the database.
    Traditionally, Hibernate does not initialize an entity Proxy when accessing its identifier since we already know the identifier value, hence we can save a database round trip.
    If enabled Hibernate will initialize the entity proxy even when accessing its identifier.
    
    Specified by:
    
    isJpaProxyComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way
    
    See Also:
    
    AvailableSettings.JPA_PROXY_COMPLIANCE
  - isJpaCacheComplianceEnabled
```
public boolean isJpaCacheComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    Should Hibernate comply with all aspects of caching as defined by JPA? Or can it deviate to perform things it believes will be "better"?
    
    Specified by:
    
    isJpaCacheComplianceEnabled in interface JpaCompliance
    
    Returns:
    
    true indicates to behave in the spec-defined way
    
    See Also:
    
    AvailableSettings.JPA_CACHING_COMPLIANCE, AbstractEntityPersister.isCacheInvalidationRequired()
  - isGlobalGeneratorScopeEnabled
```
public boolean isGlobalGeneratorScopeEnabled()
```
    Description copied from interface: JpaCompliance
    
    Should the scope of TableGenerator.name() and SequenceGenerator.name() be considered globally or locally defined?
    
    Specified by:
    
    isGlobalGeneratorScopeEnabled in interface JpaCompliance
    
    Returns:
    
    true if the generator name scope is considered global
    
    See Also:
    
    AvailableSettings.JPA_ID_GENERATOR_GLOBAL_SCOPE_COMPLIANCE
  - isJpaOrderByMappingComplianceEnabled
```
public boolean isJpaOrderByMappingComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    Should we strictly handle OrderBy expressions?
    JPA says the order-items can only be attribute references whereas Hibernate supports a wide range of items. With this enabled, Hibernate will throw a compliance error when a non-attribute-reference is used.
    
    Specified by:
    
    isJpaOrderByMappingComplianceEnabled in interface JpaCompliance
    
    See Also:
    
    AvailableSettings.JPA_ORDER_BY_MAPPING_COMPLIANCE
  - isLoadByIdComplianceEnabled
```
public boolean isLoadByIdComplianceEnabled()
```
    Description copied from interface: JpaCompliance
    
    JPA says that the id passed to EntityManager.getReference(java.lang.Class<T>, java.lang.Object) and EntityManager.find(java.lang.Class<T>, java.lang.Object) should be exactly the expected type, allowing no type coercion.
    Historically, Hibernate behaved the same way. Since 6.0 however, Hibernate has the ability to coerce the passed type to the expected type. For example, an Integer may be widened to Long. Coercion is performed by calling JavaType.coerce(X, org.hibernate.type.descriptor.java.JavaType.CoercionContext).
    This setting controls whether such coercion should be allowed.
    
    Specified by:
    
    isLoadByIdComplianceEnabled in interface JpaCompliance
    
    See Also:
    
    AvailableSettings.JPA_LOAD_BY_ID_COMPLIANCE
  - setListCompliance
```
public void setListCompliance(boolean listCompliance)
```
    Specified by:
    
    setListCompliance in interface MutableJpaCompliance
  - setOrderByMappingCompliance
```
public void setOrderByMappingCompliance(boolean orderByMappingCompliance)
```
    Specified by:
    
    setOrderByMappingCompliance in interface MutableJpaCompliance
  - setProxyCompliance
```
public void setProxyCompliance(boolean proxyCompliance)
```
    Specified by:
    
    setProxyCompliance in interface MutableJpaCompliance
  - setGeneratorNameScopeCompliance
```
public void setGeneratorNameScopeCompliance(boolean enabled)
```
    Specified by:
    
    setGeneratorNameScopeCompliance in interface MutableJpaCompliance
  - setQueryCompliance
```
public void setQueryCompliance(boolean queryCompliance)
```
    Specified by:
    
    setQueryCompliance in interface MutableJpaCompliance
  - setTransactionCompliance
```
public void setTransactionCompliance(boolean transactionCompliance)
```
    Specified by:
    
    setTransactionCompliance in interface MutableJpaCompliance
  - setClosedCompliance
```
public void setClosedCompliance(boolean closedCompliance)
```
    Specified by:
    
    setClosedCompliance in interface MutableJpaCompliance
  - setCachingCompliance
```
public void setCachingCompliance(boolean cachingCompliance)
```
    Specified by:
    
    setCachingCompliance in interface MutableJpaCompliance
  - setLoadByIdCompliance
```
public void setLoadByIdCompliance(boolean enabled)
```
    Specified by:
    
    setLoadByIdCompliance in interface MutableJpaCompliance
  - immutableCopy
```
public JpaCompliance immutableCopy()
```
    Specified by:
    
    immutableCopy in interface MutableJpaCompliance

Class MutableJpaComplianceImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MutableJpaComplianceImpl

MutableJpaComplianceImpl

Method Detail

isJpaQueryComplianceEnabled

isJpaTransactionComplianceEnabled

isJpaListComplianceEnabled

isJpaClosedComplianceEnabled

isJpaProxyComplianceEnabled

isJpaCacheComplianceEnabled

isGlobalGeneratorScopeEnabled

isJpaOrderByMappingComplianceEnabled

isLoadByIdComplianceEnabled

setListCompliance

setOrderByMappingCompliance

setProxyCompliance

setGeneratorNameScopeCompliance

setQueryCompliance

setTransactionCompliance

setClosedCompliance

setCachingCompliance

setLoadByIdCompliance

immutableCopy