| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openjpa.conf; |
| |
| /** |
| * Struct encompassing backwards-compatibility options. |
| */ |
| public class Compatibility { |
| |
| /** |
| * If a JPQL statement is not compliant with the JPA specification, |
| * fail to parse it. |
| * |
| * @since 1.1.0 |
| */ |
| public static final int JPQL_STRICT = 0; |
| |
| /** |
| * If a JPQL statement is not compliant with the JPA specification, |
| * warn the first time that statement is parsed. |
| * |
| * @since 1.1.0 |
| */ |
| public static final int JPQL_WARN = 1; |
| |
| /** |
| * Allow non-compliant extensions of JPQL. |
| * |
| * @since 1.1.0 |
| */ |
| public static final int JPQL_EXTENDED = 2; |
| |
| private boolean _strictIdValues = false; |
| private boolean _hollowLookups = true; |
| private boolean _checkStore = false; |
| private boolean _copyIds = false; |
| private boolean _closeOnCommit = true; |
| private boolean _quotedNumbers = false; |
| private boolean _nonOptimisticVersionCheck = false; |
| private int _jpql = JPQL_WARN; |
| private boolean _storeMapCollectionInEntityAsBlob = false; |
| private boolean _flushBeforeDetach = false; |
| private boolean _cascadeWithDetach = false; |
| private boolean _useJPA2DefaultOrderColumnName = true; |
| private boolean _copyOnDetach = false; |
| private boolean _privatePersistentProperties = false; |
| private boolean _autoOff = true; |
| private boolean _superclassDiscriminatorStrategyByDefault = true; |
| private boolean _isAbstractMappingUniDirectional = false; |
| private boolean _isNonDefaultMappingAllowed = false; |
| private boolean _reloadOnDetach = false; |
| private boolean _ignoreDetachedStateFieldForProxySerialization = false; |
| private boolean _checkDatabaseForCascadePersistToDetachedEntity = false; |
| private boolean _overrideContextClassloader = true; |
| private boolean _parseAnnotationsForQueryMode = true; |
| private boolean _convertPositionalParametersToNamed = false; |
| |
| private boolean _useListAttributeForArrays = false; |
| private boolean _metaFactoriesAreStrict = false; |
| private boolean _resetFlushFlagForCascadePersist = true;//OPENJPA-2051 |
| private boolean _singletonLifecycleEventManager = false; |
| private boolean _filterPCRegistryClasses = false; // OPENJPA-2288 |
| private boolean _returnNullOnEmptyAggregateResult = true; // OPENJPA-1794 |
| private boolean _cacheNonDefaultFetchPlanQueries = false; // OPENJPA-2414 |
| |
| /** |
| * Whether to require exact identity value types when creating object |
| * ids from a class and value. Defaults to false. |
| */ |
| public boolean getStrictIdentityValues() { |
| return _strictIdValues; |
| } |
| |
| /** |
| * Whether to require exact identity value types when creating object |
| * ids from a class and value. Defaults to false. |
| */ |
| public void setStrictIdentityValues(boolean strictVals) { |
| _strictIdValues = strictVals; |
| } |
| |
| /** |
| * Whether to turn collection/map tracing off in case of more number of modifications. |
| * Defaults to true. |
| */ |
| public boolean getAutoOff() { |
| return _autoOff; |
| } |
| |
| /** |
| * Whether to turn collection/map tracing off in case of more number of modifications. |
| * Defaults to true. |
| */ |
| public void setAutoOff(boolean autoOff) { |
| _autoOff = autoOff; |
| } |
| |
| /** |
| * Whether to add class criteria for super class discreminator strategy. |
| * Defaults to false. |
| */ |
| public boolean getSuperclassDiscriminatorStrategyByDefault() { |
| return _superclassDiscriminatorStrategyByDefault; |
| } |
| |
| /** |
| * Whether to add class criteria for super class discreminator strategy. |
| * Defaults to false. |
| */ |
| public void setSuperclassDiscriminatorStrategyByDefault(boolean superclassDiscriminatorStrategyByDefault) { |
| _superclassDiscriminatorStrategyByDefault = superclassDiscriminatorStrategyByDefault; |
| } |
| |
| /** |
| * Whether to interpret quoted numbers in query strings as numbers. |
| * OpenJPA versions 0.3.1 and prior treated them as numbers; more recent |
| * versions treat them as strings. |
| */ |
| public boolean getQuotedNumbersInQueries() { |
| return _quotedNumbers; |
| } |
| |
| /** |
| * Whether to interpret quoted numbers in query strings as numbers. |
| * OpenJPA versions 0.3.1 and prior treated them as numbers; more recent |
| * versions treat them as strings. |
| */ |
| public void setQuotedNumbersInQueries(boolean quotedNumbers) { |
| _quotedNumbers = quotedNumbers; |
| } |
| |
| /** |
| * Whether to return hollow instances to broker lookups with a |
| * <code>validate</code> parameter of false. OpenJPA versions prior to |
| * 0.4.0 did not return hollow instances without special configuration |
| * (the <code>ObjectLookupMode</code>). Beginning with 0.4.0, hollow |
| * objects are the default. |
| */ |
| public boolean getValidateFalseReturnsHollow() { |
| return _hollowLookups; |
| } |
| |
| /** |
| * Whether to return hollow instances to broker lookups with a |
| * <code>validate</code> parameter of false. OpenJPA versions prior to |
| * 0.4.0 did not return hollow instances without special configuration |
| * (the <code>ObjectLookupMode</code>). Beginning with 0.4.0, hollow |
| * objects are the default. |
| */ |
| public void setValidateFalseReturnsHollow(boolean hollow) { |
| _hollowLookups = hollow; |
| } |
| |
| /** |
| * Whether to check the datastore for the existence of a nontransactional |
| * cached object in broker lookups with a <code>validate</code> parameter |
| * of true. OpenJPA versions prior to 0.4.0 checked the datastore. |
| */ |
| public boolean getValidateTrueChecksStore() { |
| return _checkStore; |
| } |
| |
| /** |
| * Whether to check the datastore for the existence of a nontransactional |
| * cached object in broker lookups with a <code>validate</code> parameter |
| * of true. OpenJPA versions prior to 0.4.0 checked the datastore. |
| */ |
| public void setValidateTrueChecksStore(boolean check) { |
| _checkStore = check; |
| } |
| |
| /** |
| * Whether to copy identity objects before returning them to client code. |
| * Versions of OpenJPA prior to 0.3.0 always copied identity objects. Also, |
| * you should configure OpenJPA to copy identity objects if you mutate them |
| * after use. |
| */ |
| public boolean getCopyObjectIds() { |
| return _copyIds; |
| } |
| |
| /** |
| * Whether to copy identity objects before returning them to client code. |
| * Versions of OpenJPA prior to 0.3.0 always copied identity objects. Also, |
| * you should configure OpenJPA to copy identity objects if you mutate them |
| * after use. |
| */ |
| public void setCopyObjectIds(boolean copy) { |
| _copyIds = copy; |
| } |
| |
| /** |
| * Whether to close the broker when the managed transaction commits. |
| * Versions of OpenJPA prior to 0.3.0 did not close the broker. |
| */ |
| public boolean getCloseOnManagedCommit() { |
| return _closeOnCommit; |
| } |
| |
| /** |
| * Whether to close the broker when the managed transaction commits. |
| * Versions of OpenJPA prior to 0.3.0 did not close the broker. |
| */ |
| public void setCloseOnManagedCommit(boolean close) { |
| _closeOnCommit = close; |
| } |
| |
| /** |
| * Whether or not to perform a version check on instances being updated |
| * in a datastore transaction. Version of OpenJPA prior to 0.4.1 always |
| * forced a version check. |
| */ |
| public void setNonOptimisticVersionCheck(boolean nonOptimisticVersionCheck){ |
| _nonOptimisticVersionCheck = nonOptimisticVersionCheck; |
| } |
| |
| /** |
| * Whether or not to perform a version check on instances being updated |
| * in a datastore transaction. Version of OpenJPA prior to 0.4.1 always |
| * forced a version check. |
| */ |
| public boolean getNonOptimisticVersionCheck() { |
| return _nonOptimisticVersionCheck; |
| } |
| |
| /** |
| * Whether or not JPQL extensions are allowed. Defaults to |
| * {@link #JPQL_STRICT}. |
| * |
| * @since 1.1.0 |
| * @see #JPQL_WARN |
| * @see #JPQL_STRICT |
| * @see #JPQL_EXTENDED |
| */ |
| public int getJPQL() { |
| return _jpql; |
| } |
| |
| /** |
| * Whether or not JPQL extensions are allowed. Possible values: "warn", |
| * "strict", "extended". |
| * |
| * @since 1.1.0 |
| * @see #JPQL_WARN |
| * @see #JPQL_STRICT |
| * @see #JPQL_EXTENDED |
| */ |
| public void setJPQL(String jpql) { |
| if ("warn".equals(jpql)) |
| _jpql = JPQL_WARN; |
| else if ("strict".equals(jpql)) |
| _jpql = JPQL_STRICT; |
| else if ("extended".equals(jpql)) |
| _jpql = JPQL_EXTENDED; |
| else |
| throw new IllegalArgumentException(jpql); |
| } |
| |
| /** |
| * Whether if map and collection in entity are stored as blob. |
| * Defaults to <code>false</code>. |
| * |
| * @since 1.1.0 |
| */ |
| |
| public boolean getStoreMapCollectionInEntityAsBlob() { |
| return _storeMapCollectionInEntityAsBlob; |
| } |
| |
| /** |
| * Whether if map and collection in entity are stored as blob. |
| * Defaults to <code>false</code>. |
| * |
| * @since 1.1.0 |
| */ |
| public void setStoreMapCollectionInEntityAsBlob(boolean storeAsBlob) { |
| _storeMapCollectionInEntityAsBlob = storeAsBlob; |
| } |
| |
| /** |
| * Whether OpenJPA should flush changes before detaching or serializing an |
| * entity. In JPA this is usually false, but other persistence frameworks |
| * (ie JDO) may expect it to be true. |
| * <P>Prior to version 1.0.3 and 1.2.0 changes were always flushed. |
| * |
| * @since 1.0.3 |
| * @since 1.2.0 |
| * @return true if changes should be flushed, otherwise false. |
| */ |
| public boolean getFlushBeforeDetach() { |
| return _flushBeforeDetach; |
| } |
| |
| /** |
| * Whether OpenJPA should ignore the DetachedStateField value when |
| * determining if our Proxy classes should be removed during serialization. |
| * <P>Starting with version 2.0.0, when the DetachedStateFiled==true, the |
| * build time $proxy classes will not be removed. |
| * <P>Prior to version 2.0.0, the DetachedStateFiled was not used and |
| * the $proxy classes were not being removed during serialization after |
| * the Persistence context was cleared. |
| * |
| * @param ignoreDSF if true the old Proxy serialization behavior will be used. |
| * |
| * @since 2.0.0 |
| */ |
| public void setIgnoreDetachedStateFieldForProxySerialization(boolean ignoreDSF) { |
| _ignoreDetachedStateFieldForProxySerialization = ignoreDSF; |
| } |
| |
| /** |
| * Whether OpenJPA should ignore the DetachedStateField value when |
| * determining if our Proxy classes should be removed during serialization. |
| * <P>Starting with version 2.0.0, when the DetachedStateFiled==true, the |
| * build time $proxy classes will not be removed. |
| * <P>Prior to version 2.0.0, the DetachedStateFiled was not used and |
| * the $proxy classes were not being removed during serialization after |
| * the Persistence context was cleared. |
| * |
| * @since 2.0.0 |
| * @return true if the old Proxy serialization will be used, otherwise false. |
| */ |
| public boolean getIgnoreDetachedStateFieldForProxySerialization() { |
| return _ignoreDetachedStateFieldForProxySerialization; |
| } |
| |
| public boolean getConvertPositionalParametersToNamed() { |
| return _convertPositionalParametersToNamed; |
| } |
| |
| public void setConvertPositionalParametersToNamed(boolean c) { |
| _convertPositionalParametersToNamed = c; |
| } |
| |
| /** |
| * Whether OpenJPA should flush changes before detaching or serializing an |
| * entity. In JPA this is usually false, but other persistence frameworks |
| * (ie JDO) may expect it to be true. |
| * <P>Prior to version 1.0.3 and 1.2.0 changes were always flushed. |
| * |
| * @param beforeDetach if true changes will be flushed before detaching or |
| * serializing an entity. |
| * |
| * @since 1.0.3 |
| * @since 1.2.0 |
| */ |
| public void setFlushBeforeDetach(boolean beforeDetach) { |
| _flushBeforeDetach = beforeDetach; |
| } |
| |
| /** |
| * Affirms if detached entities are copy of the managed instances. |
| * Before this option is introduced, detached entities were by default |
| * copies of the managed entities unless the entire cache is detached, only |
| * then the detachment was in-place. |
| * This option changes the default behavior such that detachment is now |
| * in-place by default. To emulate the previous copy-on-detach behavior |
| * set this option to true. |
| * |
| * If the entire cache is being detached (when the persistence context is |
| * closed, for example), the detachement |
| * |
| * @since 2.0.0 |
| */ |
| public boolean getCopyOnDetach() { |
| return _copyOnDetach; |
| } |
| |
| /** |
| * Sets if detached entities are copy of the managed instances. |
| * Before this option is introduced, detached entities were by default |
| * copies of the managed entities unless the entire cache is detached, only |
| * then the detachment was in-place. |
| * This option changes the default behavior such that detachment is now |
| * in-place by default. To emulate the previous copy-on-detach behavior |
| * set this option to true. |
| * |
| * @since 2.0.0 |
| */ |
| public void setCopyOnDetach(boolean copyOnDetach) { |
| _copyOnDetach = copyOnDetach; |
| } |
| |
| /** |
| * Whether openjpa will always cascade on detach, regardless of the |
| * cascade setting. |
| * |
| * @return true if cascade will always occur, false if cascade will only |
| * occur if it is specified in metadata |
| * |
| * @since 2.0.0 |
| */ |
| public boolean getCascadeWithDetach() { |
| return _cascadeWithDetach; |
| } |
| |
| /** |
| * Whether openjpa should always cascade on detach, regardless of the |
| * cascade setting. |
| * |
| * @param cascadeWithDetach true if cascade should always occur, false if |
| * it should only occur if specified in metadata |
| * |
| * @since 2.0.0 |
| */ |
| public void setCascadeWithDetach(boolean cascadeWithDetach) { |
| _cascadeWithDetach = cascadeWithDetach; |
| } |
| |
| /** |
| * Whether OpenJPA should use the new default order column name defined |
| * by JPA 2.0: name; "_"; "ORDER" or the pre-JPA 2.0 default name "ordr". |
| * |
| * @since 2.0.0 |
| * @return true if the JPA2 default name should be used |
| */ |
| public boolean getUseJPA2DefaultOrderColumnName() { |
| return _useJPA2DefaultOrderColumnName; |
| } |
| |
| /** |
| * Whether OpenJPA should use the new default order column name defined |
| * by JPA 2.0: name; "_"; "ORDER" or the pre-JPA 2.0 default name "ordr". |
| * |
| * @param useJPA2 true if the JPA 2.0 default name should be used. false if |
| * the 1.x name should be used. |
| * |
| * @since 2.0.0 |
| */ |
| public void setUseJPA2DefaultOrderColumnName(boolean useJPA2Name) { |
| _useJPA2DefaultOrderColumnName = useJPA2Name; |
| } |
| |
| |
| /** |
| * Whether OpenJPA allows private, non-transient properties to be |
| * persistent. Prior to OpenJPA 2.0, if property access was used, |
| * private properties were considered persistent. This is contrary to the |
| * JPA specification, which states that persistent properties must be |
| * public or protected. The default value is false. |
| * |
| * @since 2.0.0 |
| * @return true if non-transient private properties should be persistent |
| */ |
| public boolean getPrivatePersistentProperties() { |
| return _privatePersistentProperties; |
| } |
| |
| /** |
| * Whether OpenJPA allows private, non-transient properties to be |
| * persistent. Prior to OpenJPA 2.0, if property access was used, |
| * private properties were considered persistent. This is contrary to the |
| * JPA specification, which states that persistent properties must be |
| * public or protected. |
| * |
| * @param privateProps true if non-transient private properties |
| * should be persistent |
| * @since 2.0.0 |
| */ |
| public void setPrivatePersistentProperties(boolean privateProps) { |
| _privatePersistentProperties = privateProps; |
| } |
| |
| /** |
| * Whether OpenJPA allows bi-directional relationship in the MappedSuperclass. |
| * Prior to OpenJPA 2.0, the bi-directional relationship in the MappedSuperclass, |
| * is not blocked. This is contrary to the JPA specification, which states that |
| * persistent relationships defined by a mapped superclass must be |
| * unidirectional. |
| * |
| * @param isAbstractMappingUniDirectional true if relationship defined in the |
| * MappedSuperclass must be uni-directional |
| * @since 2.0.0 |
| */ |
| public void setAbstractMappingUniDirectional(boolean isAbstractMappingUniDirectional) { |
| _isAbstractMappingUniDirectional = isAbstractMappingUniDirectional; |
| } |
| |
| |
| /** |
| * Whether OpenJPA allows bi-directional relationship in the MappedSuperclass. |
| * Prior to OpenJPA 2.0, the bi-directional relationship in the MappedSuperclass, |
| * is not blocked. This is contrary to the JPA specification, which states that |
| * persistent relationships defined by a mapped superclass must be |
| * unidirectional. The default value is false. |
| * |
| * @since 2.0.0 |
| */ |
| public boolean isAbstractMappingUniDirectional() { |
| return _isAbstractMappingUniDirectional; |
| } |
| |
| /** |
| * Whether OpenJPA allows non-default entity relationship mapping. |
| * Prior to OpenJPA 2.0, the non-default entity relationship mapping |
| * is not allowed. JPA 2.0 spec relaxes this restriction. The |
| * default value is false. |
| * @since 2.0.0 |
| */ |
| public void setNonDefaultMappingAllowed(boolean isNonDefaultMappingAllowed) { |
| _isNonDefaultMappingAllowed = isNonDefaultMappingAllowed; |
| } |
| |
| /** |
| * Whether OpenJPA allows non-default entity relationship mapping. |
| * Prior to OpenJPA 2.0, the non-default entity relationship mapping |
| * is not allowed. JPA 2.0 spec relaxes this restriction. The |
| * default value is false. |
| * @since 2.0.0 |
| */ |
| public boolean isNonDefaultMappingAllowed() { |
| return _isNonDefaultMappingAllowed; |
| } |
| |
| /** |
| * Whether OpenJPA should attempt to load fields when the DetachState |
| * option is set to loaded. This also determines whether a |
| * redundant copy of the version field is made. Beginning in 2.0 |
| * it defaults to false. |
| * |
| * @return the _reloadOnDetach |
| * |
| * @since 1.2.2 |
| */ |
| public boolean getReloadOnDetach() { |
| return _reloadOnDetach; |
| } |
| |
| /** |
| * Whether OpenJPA should attempt to load fields when the DetachState |
| * option is set to loaded. This also determines whether a |
| * redundant copy of the version field is made. Beginning in 2.0 |
| * it defaults to false. |
| * |
| * @param reloadOnDetach the _reloadOnDetach to set |
| * |
| * @since 1.2.2 |
| */ |
| public void setReloadOnDetach(boolean reloadOnDetach) { |
| _reloadOnDetach = reloadOnDetach; |
| } |
| |
| /** |
| * Whether OpenJPA will check the database for an Entity when cascading a persist to another Entity. This property |
| * only applies for the case where we are trying to cascade a persist to an Entity which doesn't have a StateManager |
| * and we can't determine if it is detached. |
| * |
| * @since 2.1.1 |
| */ |
| public boolean getCheckDatabaseForCascadePersistToDetachedEntity(){ |
| return _checkDatabaseForCascadePersistToDetachedEntity; |
| } |
| |
| /** |
| * Whether OpenJPA will check the database for an Entity when cascading a persist to another Entity. This property |
| * only applies for the case where we are trying to cascade a persist to an Entity which doesn't have a StateManager |
| * and we can't determine if it is detached. |
| * |
| * @since 2.1.1 |
| */ |
| public void setCheckDatabaseForCascadePersistToDetachedEntity(boolean b){ |
| _checkDatabaseForCascadePersistToDetachedEntity = b; |
| } |
| |
| /** |
| * Whether to temporally override the thread's Context Classloader when processing |
| * ORM XML documents to avoid deadlock potential with certain Classloader hierarchy |
| * configurations. Defaults to false. |
| */ |
| public boolean getOverrideContextClassloader() { |
| return _overrideContextClassloader; |
| } |
| |
| /** |
| * Whether to temporally override the thread's Context Classloader when processing |
| * ORM XML documents to avoid deadlock potential with certain Classloader hierarchy |
| * configurations. Defaults to false. |
| */ |
| public void setOverrideContextClassloader(boolean overrideContextClassloader) { |
| _overrideContextClassloader = overrideContextClassloader; |
| } |
| |
| /** |
| * Whether OpenJPA will scan every persistent class in an XML mapping file for annotations prior to executing a |
| * query. In practice this scan is rarely needed, but the option to enable it is present for compatibility with |
| * prior releases. |
| * @since 2.0.2 |
| * @return true if the annotations should be re-parsed when resolving MetaData in MODE_QUERY. |
| */ |
| public boolean getParseAnnotationsForQueryMode() { |
| return _parseAnnotationsForQueryMode; |
| } |
| |
| /** |
| * Whether OpenJPA will scan every persistent class in an XML mapping file for annotations prior to executing a |
| * query. In practice this scan is rarely needed, but the option to enable it is present for compatibility with |
| * prior releases. |
| * @since 2.0.2 |
| */ |
| public void setParseAnnotationsForQueryMode(boolean parseAnnotationsForQueryMode) { |
| _parseAnnotationsForQueryMode = parseAnnotationsForQueryMode; |
| } |
| |
| /** |
| * This property can be used to allow OpenJPA to use ListAttributes for all types of Arrays, not just those with the |
| * @ PersistentCollection annotation. If the canonical metamodel classes were generated in an early version of |
| * OpenJPA (e.g. 2.0.0, 2.0.1, or 2.1.0) it is recommended to set this property to true. If |
| * you have generated your metamodel classes on later versions of OpenJPA (e.g. 2.2.0) you may |
| * want to have this set to false. |
| * |
| * @since 2.2.0 |
| * @return true if OpenJPA will use ListAttributes for <b>all</b> arrays, false if OpenJPA will use ListAttributes |
| * for <b>only</b> arrays which use the @PersistentCollection annotation. |
| */ |
| public boolean getUseListAttributeForArrays() { |
| return _useListAttributeForArrays; |
| } |
| |
| /** |
| * This property can be used to allow OpenJPA to use ListAttributes for all types of Arrays, not just those with the |
| * @PersistentCollection annotation. If the canonical metamodel classes were generated in an early version of |
| * OpenJPA (e.g. 2.0.0, 2.0.1, or 2.1.0) it is recommended to set this property to true. If |
| * you have generated your metamodel classes on later versions of OpenJPA (e.g. 2.2.0) you may |
| * want to have this set to false. |
| * @since 2.2.0 |
| * @param useListAttribute |
| * whether OpenJPA will use ListAttributes for all arrays. |
| */ |
| public void setUseListAttributeForArrays(boolean useListAttribute ) { |
| _useListAttributeForArrays = useListAttribute; |
| } |
| |
| /** |
| * Whether the MetaDataFactory and MappingFactory should be set to strict mode. If strict mode is used a |
| * MetaDataFactory will only resolve MetaData (no JDBC mappings), and a MappingFactory will only resolve Mapping |
| * information. |
| * |
| * @since 2.2.0 |
| * @return Whether strict mode should be used. |
| */ |
| public boolean getMetaFactoriesAreStrict() { |
| return _metaFactoriesAreStrict; |
| } |
| |
| /** |
| * Set whether MetaDataFactories and MappingFactories will be strictly separate. |
| * |
| * @since 2.2.0 |
| * |
| * @param metaFactoriesAreStrict |
| * True if the MetaDataFactory should only process metadata, and the MappingFactory should only process |
| * mappings. |
| */ |
| public void setMetaFactoriesAreStrict(boolean metaFactoriesAreStrict) { |
| _metaFactoriesAreStrict = metaFactoriesAreStrict; |
| } |
| |
| /** |
| * Whether OpenJPA should reset the internal state (flush flag) when cascading a persist to another |
| * Entity. That is, when a flush is performed, OpenJPA keep state to indicate the flush has been |
| * performed. In certain cascade persist scenarios the fact that a flush has been performed prior to |
| * a cascade persist can cause certain entities to not be written to the database given the prior |
| * flush. This property, when set, will cause the flush flag to be reset in cascade scenarios. For more |
| * details see JIRA OPENJPA-2051 |
| * |
| * @since 2.0.x |
| */ |
| public boolean getResetFlushFlagForCascadePersist(){ |
| return _resetFlushFlagForCascadePersist; |
| } |
| |
| /** |
| * Whether OpenJPA should reset the internal state (flush flag) when cascading a persist to another |
| * Entity. That is, when a flush is performed, OpenJPA keep state to indicate the flush has been |
| * performed. In certain cascade persist scenarios the fact that a flush has been performed prior to |
| * a cascade persist can cause certain entities to not be written to the database given the prior |
| * flush. This property, when set, will cause the flush flag to be reset in cascade scenarios. For more |
| * details see JIRA OPENJPA-2051 |
| * |
| * @since 2.0.x |
| */ |
| public void setResetFlushFlagForCascadePersist(boolean b){ |
| _resetFlushFlagForCascadePersist = b; |
| } |
| |
| /** |
| * Returns true if life cycle event manager is a singleton configuration. |
| */ |
| public boolean isSingletonLifecycleEventManager() { |
| return _singletonLifecycleEventManager; |
| } |
| |
| /** |
| * This property set whether each EntityManager has its own life cycle event manager. |
| By default, each EntityManager only fires events to the registered listeners to the entities |
| it manages. If the life cycle event manager is a singleton, events will be fired to listeners |
| registered to all instances of EntityManager in the same persistence unit. |
| */ |
| public void setSingletonLifecycleEventManager(boolean singleton) { |
| _singletonLifecycleEventManager = singleton; |
| } |
| |
| /** |
| * Whether the metadata processor should filter classes dispatched by the PCRegistry listener system. |
| **/ |
| public boolean getFilterPCRegistryClasses() { |
| return _filterPCRegistryClasses; |
| } |
| |
| /** |
| * Whether the metadata processor should filter classes dispatched by the PCRegistry listener system. |
| **/ |
| public void setFilterPCRegistryClasses(boolean bool) { |
| _filterPCRegistryClasses = bool; |
| } |
| |
| /** |
| * This property is used to specify whether the aggregate query functions |
| * SUM, AVG, MAX, and MIN return null if there is no query result. This will occur |
| * if no rows are returned for the specified query predicate. The default is |
| * false, meaning that 0 will be returned for functions operating on numeric |
| * data. |
| * |
| * In compliance with the JPA specification, the default value is true. |
| * |
| * @return true if the result of an aggregate with an empty query result returns null. |
| * @since |
| * |
| */ |
| public boolean getReturnNullOnEmptyAggregateResult() { |
| return _returnNullOnEmptyAggregateResult; |
| } |
| |
| /** |
| * This property is used to specify whether the aggregate query functions |
| * SUM, AVG, MAX, and MIN return null if there is no query result. This will occur |
| * if no rows are returned for the specified query predicate. The default is |
| * false, meaning that 0 will be returned for functions operating on numeric |
| * data. |
| * |
| * In compliance with the JPA specification, the default value is true. |
| * |
| * @since |
| * @param returnNullOnAggregate whether OpenJPA will return null for aggregate |
| * expressions when the query result is empty. |
| */ |
| public void setReturnNullOnAggregateResult(boolean returnNullOnEmptyAggregateResult) { |
| _returnNullOnEmptyAggregateResult = returnNullOnEmptyAggregateResult; |
| } |
| |
| /** |
| * Whether the SQL generated for queries executed with a modified fetch plan are cached. |
| */ |
| public boolean getCacheNonDefaultFetchPlanQueries() { |
| return _cacheNonDefaultFetchPlanQueries; |
| } |
| |
| /** |
| * Whether the SQL generated for queries executed with a modified fetch plan are cached. |
| */ |
| public void setCacheNonDefaultFetchPlanQueries(boolean bool) { |
| _cacheNonDefaultFetchPlanQueries = bool; |
| } |
| } |