datanucleus.IgnoreCache |
Whether to ignore the cache for queries. If the user sets this to true then the query will evaluate in the datastore, but the instances returned will be formed
from the datastore; this means that if an instance has been modified and its datastore values match the query then the instance returned will not be the currently
cached (updated) instance, instead an instance formed using the datastore values. {true, false} |
datanucleus.Multithreaded |
Whether to run the PM multithreaded.
Note that this is only a hint to try to allow thread-safe operations on the PM.
Users are always advised to run a PM as single threaded, since some operations are not currently locked and so could cause issues multi-threaded.
{true, false} |
datanucleus.Optimistic |
Whether to use optimistic locking.
{true, false} |
datanucleus.RetainValues |
Whether to suppress the clearing of values from persistent instances on transaction completion.
{true, false} |
datanucleus.RestoreValues |
Whether persistent object have transactional field values restored when transaction rollback occurs.
{true, false} |
datanucleus.Mapping |
Name for the ORM MetaData mapping files to use with this PMF. For example if this is set to "mysql" then the implementation looks for MetaData mapping files called
{classname}-mysql.orm or package-mysql.orm . If this is not specified then the JDO implementation assumes that all is specified in the JDO MetaData file. |
datanucleus.mapping.Catalog |
Name of the catalog to use by default for all classes persisted using this PMF.
This can be overridden in the MetaData where required, and is optional.
DataNucleus will prefix all table names with this catalog name if the RDBMS supports specification of catalog names in DDL. RDBMS datastores only |
datanucleus.mapping.Schema |
Name of the schema to use by default for all classes persisted using this PMF.
This can be overridden in the MetaData where required, and is optional.
DataNucleus will prefix all table names with this schema name if the RDBMS supports specification of schema names in DDL. RDBMS datastores only |
datanucleus.TenantId |
String id to use as a discriminator on all persistable class tables to restrict data for the tenant using this application instance
(aka multi-tenancy via discriminator). RDBMS, MongoDB, HBase, Neo4j, Cassandra datastores only |
datanucleus.TenantProvider |
Instance of a class that implements org.datanucleus.store.schema.MultiTenancyProvider
which will return the tenant name to use for each call. RDBMS, MongoDB, HBase, Neo4j, Cassandra datastores only |
datanucleus.CurrentUser |
String defining the current user for the persistence process. Used by auditing. RDBMS datastores only |
datanucleus.CurrentUserProvider |
Instance of a class that implements org.datanucleus.store.schema.CurrentUserProvider
which will return the current user to use for each call. Used by auditing. RDBMS datastores only |
datanucleus.DetachAllOnCommit |
Allows the user to select that when a transaction is committed all objects enlisted in that transaction will be automatically detached.
{true, false} |
datanucleus.detachAllOnRollback |
Allows the user to select that when a transaction is rolled back all objects enlisted in that transaction will be automatically detached.
{true, false} |
datanucleus.CopyOnAttach |
Whether, when attaching a detached object, we create an attached copy or simply migrate the detached object to attached state
{true, false} |
datanucleus.attachSameDatastore |
When attaching an object DataNucleus by default assumes that you’re attaching to the same datastore as you detached from.
DataNucleus does though allow you to attach to a different datastore (for things like replication).
Set this to false if you want to attach to a different datastore to what you detached from.
This property is also useful if you are attaching and want it to check for existence of the object in the datastore
before attaching, and create it if not present (true assumes that the object exists).
{true, false} |
datanucleus.detachAsWrapped |
When detaching, any mutable second class objects (Collections, Maps, Dates etc) are typically detached as the basic form (so you can use them on client-side
of your application). This property allows you to select to detach as wrapped objects. It only works with "detachAllOnCommit" situations (not with detachCopy) currently
{true, false} |
datanucleus.DetachOnClose |
This allows the user to specify whether, when a PM is closed, that all objects in the L1 cache are automatically detached.
Users are recommended to use the datanucleus.DetachAllOnCommit wherever possible. This will not work in JCA mode.
{false, true} |
datanucleus.detachmentFields |
When detaching you can control what happens to loaded/unloaded fields of the FetchPlan.
The default for JDO is to load any unloaded fields of the current FetchPlan before detaching.
You can also unload any loaded fields that are not in the current FetchPlan (so you only get the fields you require) as well as a combination of both options
{load-fields, unload-fields, load-unload-fields} |
datanucleus.maxFetchDepth |
Specifies the default maximum fetch depth to use for fetching operations.
The JDO spec defines a default of 1, meaning that only the first level of related objects will be fetched by default.
{-1, 1, positive integer (non-zero)} |
datanucleus.detachedState |
Allows control over which mechanism to use to determine the fields to be detached.
By default DataNucleus uses the defined "fetch-groups".
JPA doesn’t have that (although it is an option with DataNucleus), so we also allow loaded which will detach just the currently loaded fields, and all which will
detach all fields of the object. Be careful with this option since it, when used with maxFetchDepth of -1 will detach a whole object graph!
{fetch-groups, all, loaded} |
datanucleus.ServerTimeZoneID |
Id of the TimeZone under which the datastore server is running. If this is not specified or is set to null it is assumed that the
datastore server is running in the same timezone as the JVM under which DataNucleus is running. |
datanucleus.PersistenceUnitName |
Name of a persistence-unit to be found in a persistence.xml file (under META-INF) that defines the persistence properties to use
and the classes to use within the persistence process. |
datanucleus.PersistenceUnitLoadClasses |
Used when we have specified the persistence-unit name for a PMF and where we want the datastore "tables" for all classes of that persistence-unit
loading up into the StoreManager. Defaults to false since some databases are slow so such an operation would slow down the startup process.
{true, false} |
datanucleus.persistenceXmlFilename |
URL name of the persistence.xml file that should be used instead of using META-INF/persistence.xml . |
datanucleus.datastoreReadTimeout |
The timeout to apply to all reads (millisecs), e.g by query or by PM.getObjectById(). Only applies if the underlying datastore supports it
{0, A positive value (MILLISECONDS)} |
datanucleus.datastoreWriteTimeout |
The timeout to apply to all writes (millisecs), e.g by makePersistent, or by an update. Only applies if the underlying datastore supports it
{0, A positive value (MILLISECONDS)} |
datanucleus.singletonPMFForName |
Whether to only allow a singleton PMF for a particular name (the name can be either the name of the PMF in jdoconfig.xml , or the name of the persistence-unit).
If a subsequent request is made for a PMF with a name that already exists then a warning will be logged and the original PMF returned.
{true, false} |
datanucleus.allowListenerUpdateAfterInit |
Whether you want to be able to add/remove listeners on the JDO PMF after it is marked as not configurable (when the first PM is created).
The default matches the JDO spec, not allowing changes to the listeners in use.
{true, false} |
datanucleus.cdi.bean.manager |
Specifies a CDI BeanManager object that will be used to allow injection of dependencies into AttributeConverter objects. |
datanucleus.jmxType |
Which JMX server to use when hooking into JMX. Please refer to the Monitoring Guide
{platform} |
datanucleus.deletionPolicy |
Allows the user to decide the policy when deleting objects. The default is "JDO2" which firstly checks if the field is dependent and if so deletes dependents,
and then for others will null any foreign keys out. The problem with this option is that it takes no account of whether the user has also
defined <foreign-key> elements, so we provide a "DataNucleus" mode that does the dependent field part first and then if a FK element is defined
will leave it to the FK in the datastore to perform any actions, and otherwise does the nulling.
{JDO2, DataNucleus} |
datanucleus.identityStringTranslatorType |
You can allow identities input to pm.getObjectById(id) be translated into valid JDO ids if there is a suitable translator.
See Identity String Translator |
datanucleus.identityKeyTranslatorType |
You can allow identities input to pm.getObjectById(cls, key) be translated into valid JDO ids if there is a suitable key translator.
See Identity Key Translator |
datanucleus.datastoreIdentityType |
Which "datastore-identity" class plugin to use to represent datastore identities.
Refer to Datastore Identity
{datanucleus, kodo, xcalia, {user-supplied plugin}} |
datanucleus.executionContext.maxIdle |
Specifies the maximum number of ExecutionContext objects that are pooled ready for use
{20, integer value greater than 0} |
datanucleus.executionContext.reaperThread |
Whether to start a reaper thread that continually monitors the pool of ExecutionContext objects and frees them off after they have surpassed their expiration period
{false, true} |
datanucleus.executionContext.closeActiveTxAction |
Defines the action if a PM is closed and there is an active transaction present
{rollback, exception} |
datanucleus.stateManager.className |
Class name for the StateManager to use when managing object state. The default for RDBMS is ReferentialStateManagerImpl, and is StateManagerImpl for all other datastores. |
datanucleus.type.wrapper.basis |
Whether to use the "instantiated" type of a field, or the "declared" type of a field to determine which wrapper to use when the field is SCO mutable.
{instantiated, declared} |
datanucleus.type.treatJavaUtilDateAsMutable |
Whether to treat java.util.Date and subtypes as mutable (and hence wrapped by a proxy). If you dont intend on calling setTime() on the object then
setting this to false will give an efficiency benefit.
{true, false} |
datanucleus.useImplementationCreator |
Whether to allow use of the implementation-creator (feature of JDO to dynamically create implementations of persistent interfaces).
{true, false} |
datanucleus.manageRelationships |
This allows the user control over whether DataNucleus will try to manage bidirectional relations, correcting the input objects so that all relations are consistent.
This process runs when flush()/commit() is called. You can set it to false if you always set both sides of a relation when persisting/updating.
{true, false} |
datanucleus.manageRelationshipsChecks |
This allows the user control over whether DataNucleus will make consistency checks on bidirectional relations.
If "datanucleus.managedRelationships" is not selected then no checks are performed.
If a consistency check fails at flush()/commit() then a JDOUserException is thrown.
You can set it to false if you want to omit all consistency checks.
{true, false} |
datanucleus.persistenceByReachabilityAtCommit |
Whether to run the "persistence-by-reachability" algorithm at commit() time.
This means that objects that were reachable at a call to makePersistent() but that are no longer persistent will be removed from persistence.
For performance improvements, consider turning this off.
{true, false} |
datanucleus.classLoaderResolverName |
Name of a ClassLoaderResolver to use in class loading. DataNucleus provides a default that loosely follows the JDO specification for class loading.
This property allows the user to override this with their own class better suited to their own loading requirements.
{datanucleus, {name of class-loader-resolver plugin}} |
datanucleus.primaryClassLoader |
Sets a primary classloader for situations where a primary classloader is not accessible.
This ClassLoader is used when the class is not found in the default ClassLoader search path.
As example, when the database driver is loaded by a different ClassLoader not in the ClassLoader search path for JDO specification. |
datanucleus.plugin.pluginRegistryClassName |
Name of a class that acts as registry for plug-ins.
This defaults to org.datanucleus.plugin.NonManagedPluginRegistry (for when not using OSGi).
If you are within an OSGi environment you can set this to org.datanucleus.plugin.OSGiPluginRegistry |
datanucleus.plugin.pluginRegistryBundleCheck |
Defines what happens when plugin bundles are found and are duplicated
{EXCEPTION, LOG, NONE} |
datanucleus.plugin.allowUserBundles |
Defines whether user-provided bundles providing DataNucleus extensions will be registered. This is only respected if used in a non-Eclipse OSGi environment.
{true, false} |
datanucleus.plugin.validatePlugins |
Defines whether a validation step should be performed checking for plugin dependencies etc. This is only respected if used in a non-Eclipse OSGi environment.
{false, true} |
datanucleus.findObject.validateWhenCached |
When a user calls getObjectById (JDO) and they request validation this allows the turning off of validation when an object is found in the (L2) cache.
Can be useful for performance reasons, but should be used with care.
{true, false} |
datanucleus.findObject.typeConversion |
When calling PM.getObjectById(Class, Object) the second argument really ought to be the exact type of the primary-key field.
This property enables conversion of basic numeric types (Long, Integer, Short) to the appropriate numeric type (if the PK is a numeric type).
{true, false} |