#
# 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.
#
# OJB.properties -- configuration of the OJB runtime environment
# Version: 1.0
# (c) 2001, 2002, 2003 Apache Software Foundation
# Author: Thomas Mahler and many others
# @version $Id: OJB.properties 492872 2007-01-05 03:37:46 +0100 (Fr, 05 Jan 2007) arminw $
#
#----------------------------------------------------------------------------------------
# PersistenceBrokerFactory / PersistenceBroker
#----------------------------------------------------------------------------------------
# The PersistenceBrokerFactoryClass entry decides which concrete
# PersistenceBrokerFactory implemention is to be used.
PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl
# If in managed environment *only* the PB-api was used it's recommended to use this factory
# to enable the PersistenceBroker instances to participate in the JTA transaction. This makes
# e.g. PBStateListener work properly in managed environments.
#PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrokerFactorySyncImpl
#
# The PersistenceBrokerClass entry decides which concrete PersistenceBroker
# implementation is to be served by the PersistenceBrokerFactory.
# This is the singlevm implementation:
PersistenceBrokerClass=org.apache.ojb.broker.core.PersistenceBrokerImpl
#
#
# This setting can be helpful during development if the PersistenceBroker transaction
# demarcation was used (this is true in most cases). If set 'true' on PB#store(...)
# and PB#delete(...) methods calls OJB check for active PB-tx and if no active tx is
# found a error is logged. This can help to avoid store/delete calls without a running
# PB-tx while development. Default setting is 'false'. (Note: When using OJB in a managed
# environment *without* OJB-caching, it's valid to use store/delete calls without a running
# PB-tx - if the used PB instance is immediately closed after use)
TxCheck=false
#
# This setting can be helpful during development to detect PersistenceBroker leaks
# (PB instances which are not closed after use). If enabled an error message including
# the caller stack trace is logged when garbage collector free unclosed PB instances.
# Default setting is 'false'.
BrokerLeakDetection=false
#
#----------------------------------------------------------------------------------------
# PersistenceBroker pool
#----------------------------------------------------------------------------------------
# PersistenceBroker pool configuration
# This pool uses the jakarta-commons-pool api.
# There you can find things described in detail.
#
# maximum number of brokers that can be borrowed from the
# pool at one time. When non-positive, there is no limit.
maxActive=100
#
# controls the maximum number of brokers that can sit idle in the
# pool (per key) at any time. When non-positive, there is no limit
maxIdle=-1
#
# max time block to get broker instance from pool, after that exception is thrown.
# When non-positive, block till last judgement
maxWait=2000
#
# indicates how long the eviction thread should sleep before "runs" of examining
# idle objects. When non-positive, no eviction thread will be launched.
timeBetweenEvictionRunsMillis=-1
#
# specifies the minimum amount of time that an broker may sit idle
# in the pool before it is eligable for eviction due to idle time.
# When non-positive, no object will be dropped from the pool due
# to idle time alone (depends on timeBetweenEvictionRunsMillis > 0)
minEvictableIdleTimeMillis=1000000
#
# specifies the behaviour of the pool when broker capacity is
# exhausted (see maxActive above)
# 0 - fail
# 1 - block
# 2 - grow
whenExhaustedAction=0
#
#
#----------------------------------------------------------------------------------------
# ConnectionFactory / Default ConnectionPool
#----------------------------------------------------------------------------------------
# The ConnectionFactoryClass entry determines which kind of ConnectionFactory
# is to be used within org.apache.ojb as connection factory.
# A ConnectionFactory is responsible for creating
# JDBC Connections. Current version ships four implementations:
#
# 1. ConnectionFactoryNotPooledImpl
#    No pooling, no playing around.
#    Every connection request returns a new connection,
#    every connection release close the connection.
# 2. ConnectionFactoryPooledImpl
#    This implementation supports connection pooling.
# 3. ConnectionFactoryDBCPImpl
#    Using the jakarta-DBCP api for connection management, support
#    connection- and prepared statement-pooling, abandoned connection handling.
# 4. ConnectionFactoryManagedImpl
#    Connection factory for use within managed environments - e.g. JBoss.
#    Every obtained DataSource was wrapped within OJB (and ignore
#    e.g. con.commit() calls within OJB).
#    Use this implementation e.g if you use Datasources from an application server.
#
# Use the OJB performance tests to decide, which implementation is best for you.
# The proper way of obtaining a connection is configured in
# JDBCConnectionDescriptor entries in the repository.xml file.
# If want a more fine grained control of each connection pool used by OJB,
# take a look at the repository.dtd, there was a possibility to override
# this default connection factory entry in each JDBCConnectionDescriptor.
#
ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryNotPooledImpl
# Only needed when using OJB 1.0.3 or earlier in managed environments. Since version
# 1.0.4 OJB detects datasources from managed environments automatically.
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryManagedImpl
#
#
#----------------------------------------------------------------------------------------
# ProxyFactory and IndirectionHandler
#----------------------------------------------------------------------------------------
# The ProxyFactoryClass entry defines which ProxyFactory implementation is to be used.
# By default, a 1.0 compatiable, JDK-based version is used. However, a the CGLIB based entry
# is available.
#
#	- ProxyFactoryCGLIBImpl: Refernece proxies are generated using bytecode manipulation
#			from the CGLIB library. Any class can become a dynamic proxy, and not just ones
#			that implement an interface.
#   - ProxyFactoryJDKImpl: OJB 1.0 compatiable Proxy implementation. Proxies in this method
#			can only be generated from classes that implement an interface, and the generated
#			Proxy will implement all methods of that interface.
#
# NOTE: The appropriate cooresponding IndirectionHandler must be choosen as well
#
ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryCGLIBImpl
#ProxyFactoryClass=org.apache.ojb.broker.core.proxy.ProxyFactoryJDKImpl
#
# The optional IndirectionHandlerClass entry defines the class to be used by OJB's proxies to
# handle method invocations. The IndirectionHandler implementation must match the implementation
# of the ProxyFactory, i.e. it must implement the corresponding IndirectionHandler-derived
# interface (IndirectionHandlerCGLIB, IndirectionHandlerJDK).
# If this setting is unspecifies, then the default IndirectionHandler for the specified ProxyFactory
# will be used.
#
IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerCGLIBImpl
#IndirectionHandlerClass=org.apache.ojb.broker.core.proxy.IndirectionHandlerJDKImpl
#
#----------------------------------------------------------------------------------------
# ListProxy
#----------------------------------------------------------------------------------------
# The ListProxyClass entry defines the proxy class to be used for collections that
# implement the java.util.List interface.
#
ListProxyClass=org.apache.ojb.broker.core.proxy.ListProxyDefaultImpl
#
#----------------------------------------------------------------------------------------
# SetProxy
#----------------------------------------------------------------------------------------
# The SetProxyClass entry defines the proxy class to be used for collections that
# implement the java.util.Set interface.
#
SetProxyClass=org.apache.ojb.broker.core.proxy.SetProxyDefaultImpl
#
#----------------------------------------------------------------------------------------
# CollectionProxy
#----------------------------------------------------------------------------------------
# The CollectionProxyClass entry defines the proxy class to be used for collections that
# do not implement java.util.List or java.util.Set.
#
CollectionProxyClass=org.apache.ojb.broker.core.proxy.CollectionProxyDefaultImpl
#
#
#----------------------------------------------------------------------------------------
# LobHelper
#----------------------------------------------------------------------------------------
# Set the LobHelper implementation.
LobHelperClass=org.apache.ojb.broker.lob.LobHelperImpl
#
# LOB-locator objects (Blob and Clob fields in persistence capable objects) are only
# valid as long as the current PersistenceBroker transaction is active. After commit or
# rollback the LOB-object will be invalidated and before next access to the LOB-locator
# object it must be refreshed. Cached persistent objects with LOB-content need refresh
# too. OJB will automatically refresh all objects requested by query or identity lookup.
# Set this property to 'false' to disable this service.
LobAutoRefresh=true
#
#
#----------------------------------------------------------------------------------------
# Object cache
#----------------------------------------------------------------------------------------
# NOTE: ObjectCacheClass declaration in OJB.properties file was removed (since OJB 1.0.2).
# The concrete ObjectCache implementation has to specified in the repository file using
# the 'object-cache' element. See documentation for more detailed info.
#
# This property is only relevant if the per class-descriptor object-cache
# declaration was used in conjunction with metadata runtime changes.
# If set 'false' the class name of the object is used
# to find a per class ObjectCache implementation.
# If set 'true' the ObjectCacheDescriptor instance is used as key to
# find a per class ObjectCache, this enables to use different ObjectCache
# instances for the same class.
descriptorBasedCaches=false
#
# NOTE: CacheFilters declaration was removed (since OJB 1.0.2). To exclude
# object of whole packages from being cache use a specific property in
# cache declaration - see caching guide in reference docs.
#
#
#----------------------------------------------------------------------------------------
# Locking
#----------------------------------------------------------------------------------------
# The 'LockManagerClass' specify the internal used LockManager implementation.
# If OJB is running in distributed environment it is recommended to use the remote
# lock manager. It guarantees to provide Lockmanagement across multiple JVM's.
#
# A servlet based lock implementation for distributed environments, needs enabled
# property 'LockServletUrl' too.
#LockManagerClass=org.apache.ojb.broker.locking.LockManagerRemoteImpl
# Lock manager implementation using apache's commons-transaction locking api
#LockManagerClass=org.apache.ojb.broker.locking.LockManagerCommonsImpl
LockManagerClass=org.apache.ojb.broker.locking.LockManagerInMemoryImpl
#
# The LockTimeout entry defines the maximum time in milliseconds
# that a lock may be hold. Defaults to 120000 = 2 minutes
LockTimeout=120000
#
# The LockServletUrl entry points to the Lockserver servlet.
# This Servlet is addressed by all distributed JVMs if LockManagerRemoteImpl
# is used.
#LockServletUrl=http://127.0.0.1:8080/ojb-lockserver
#
#
# ------ deprecated ------
# The deprecated odmg locking implementation. Needs enabled 'LockMapClass' too.
#@deprecated LockManagerClass=org.apache.ojb.odmg.locking.LockManagerDefaultImpl
#
# The LockMapClass entry tells OJB which concrete LockMap
# implementation is to be used.
# If OJB is running on multiple concurrent clients it is recommended
# to use the LockMapRemoteImpl. It guarantees to provide
# Lockmanagement across multiple JVMs.
# This Implemenation relies on a Servlet based Lockserver. To use it you have to
# deploy the ojb-lockserver.war into a Servlet engine.
# and you have to set the Property LockServletUrl to point to this servlet.
# (see LockServletUrl section below).
# If OJB is running in a single JVM (e.g. in a desktop app, or in a servlet
# engine) it is save to use the LockMapInMemoryImpl. Using it will result
# in a large performance gain.
# These settings are deprecated, only needed in conjunction with the old odmg 'LockManagerClass'
# @deprecated LockMapClass=org.apache.ojb.odmg.locking.RemoteLockMapImpl
# @deprecated LockMapClass=org.apache.ojb.odmg.locking.InMemoryLockMapImpl
#
#
#----------------------------------------------------------------------------------------
# Meta data / mapping settings
#----------------------------------------------------------------------------------------
# The PersistentFieldClass property defines the implementation class
# for PersistentField attributes used in the OJB MetaData layer.
# By default the best performing attribute/refection based implementation
# is selected (PersistentFieldDirectAccessImpl).
#
# - PersistentFieldDirectImpl
#   is a high-speed version of the access strategies.
#   It does not cooperate with an AccessController,
#   but accesses the fields directly. Persistent
#   attributes don't need getters and setters
#   and don't have to be declared public or protected
# - PersistentFieldCGLibImpl
#   A very fast beans compliant (getter/setter access based) PersistentField
#   implementation. Needs public getter/setter for all declared fields.
# - PersistentFieldPrivilegedImpl
#   Same as above, but does cooperate with AccessController and do not
#   suppress the java language access check (but is slow compared with direct access).
# - PersistentFieldIntrospectorImpl
#   uses JavaBeans compliant calls only to access persistent attributes.
#   No Reflection is needed. But for each attribute xxx there must be
#   public getXxx() and setXxx() methods.
# - PersistentFieldDynaBeanAccessImpl
#   implementation used to access a property from a
#   org.apache.commons.beanutils.DynaBean.
#   (DynaBean implementation does not support nested fields)
# - PersistentFieldAutoProxyImpl
#   for each field determines upon first access how to access this particular field
#   (cglib based, directly, as a bean, as a dyna bean) and then uses that strategy.
#   The order of field access testing goes from the fastest to slowest, so you will always
#   get the best performance.
#
PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDirectImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldCGLibImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldPrivilegedImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldIntrospectorImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDynaBeanImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldAutoProxyImpl
#
#
# This property allows to extend class RepositoryPersistor used to read and write (write is deprecated)
# OJB's metadata.
RepositoryPersistorClass=org.apache.ojb.broker.metadata.RepositoryPersistor
#
#
#----------------------------------------------------------------------------------------
# Transaction Management and assocation
#----------------------------------------------------------------------------------------
# (optional, only used if OJB runs within managed environments)
# To praticipate in JTA transaction OJB needs access to the underlying transaction manager.
# The TransactionManager is acquired in different ways dependent on the application server.
# The JTATransactionManagerClass property allows you to specify the class that implements
# the proper behaviour for finding the transaction manager. Only use when OJBTxManagerClass
# is set to a factory that uses the application server transaction manager
# (org.apache.ojb.odmg.JTATxManager)
#
# JBoss Transaction Manager Factory
JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JBossTransactionManagerFactory
# Weblogic Transaction Manager Factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WeblogicTransactionManagerFactory
# WebSphere transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.WebSphereTransactionManagerFactory
# Orion transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.OrionTransactionManagerFactory
# SunOne transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.SunOneTransactionManagerFactory
# JOnAs transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JOnASTransactionManagerFactory
# OC4J transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.OC4JTransactionManagerFactory
# Resin transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.ResinTransactionManagerFactory
# JRun transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.broker.transaction.tm.JRunTransactionManagerFactory
#
#
#----------------------------------------------------------------------------------------
# ManageableCollection default settings
#----------------------------------------------------------------------------------------
# OJB use specific collection class implementations to provide 1:n and m:n references.
# It's also possible to define specific collection classes for each defined 1:n or m:n
# reference - please see documentation (repository mapping docs).
# A removal aware collection implementation will always delete objects removed from the
# reference collection/list/set (delete of orphan objects) when the main object is stored.
#
# Default collection classes for 1:n references are:
#CollectionTypes.OneToManyCollection=org.apache.ojb.broker.util.collections.RemovalAwareCollection
CollectionTypes.OneToManyCollection=org.apache.ojb.broker.util.collections.ManageableArrayList
#
#CollectionTypes.OneToManyList=org.apache.ojb.broker.util.collections.RemovalAwareList
CollectionTypes.OneToManyList=org.apache.ojb.broker.util.collections.ManageableArrayList
#
#CollectionTypes.OneToManyVector=org.apache.ojb.broker.util.collections.RemovalAwareVector
CollectionTypes.OneToManyVector=org.apache.ojb.broker.util.collections.ManageableVector
#
#CollectionTypes.OneToManySet=org.apache.ojb.broker.util.collections.RemovalAwareSet
CollectionTypes.OneToManySet=org.apache.ojb.broker.util.collections.ManageableSet
#
# (collection for array - for internal use only)
CollectionTypes.OneToManyArray=org.apache.ojb.broker.util.collections.RemovalAwareCollection
#
# Default collection classes for m:n references (never use a removal aware collection
# implementation for m:n relation)
CollectionTypes.ManyToManyCollection=org.apache.ojb.broker.util.collections.ManageableArrayList
CollectionTypes.ManyToManyList=org.apache.ojb.broker.util.collections.ManageableArrayList
CollectionTypes.ManyToManyVector=org.apache.ojb.broker.util.collections.ManageableVector
CollectionTypes.ManyToManySet=org.apache.ojb.broker.util.collections.ManageableHashSet
# (collection for array - for internal use only)
CollectionTypes.ManyToManyArray=org.apache.ojb.broker.util.collections.ManageableArrayList
#
#
# The Query/OQLQuery entries define the collection types returned
# from Criteria-based queries/OQL-queries. By default this value is set to a List.
# This will be good for most situations. If you need the additional features replace
# the implementation.
# Default collection classes query results
CollectionTypes.Query=org.apache.ojb.broker.util.collections.ManageableArrayList
CollectionTypes.OQLQuery=org.apache.ojb.broker.util.collections.ManageableArrayList
#
#
#----------------------------------------------------------------------------------------
# repository file settings
#----------------------------------------------------------------------------------------
# The repositoryFile entry tells OJB to use this file as as its standard mapping
# repository. First OJB lookup the file as resource from classpath, second as ordinary file.
repositoryFile=repository.xml
#
# If the useSerializedRepository entry is set to true, OJB tries to load a
# serialized version of the repository for performance reasons.
# if set to false, OJB always loads the xml file.
# Setting this flag to true will accelerate the startup sequence of OJB.
# If set to true changes to the repository.xml file will only be detected
# after maually deleting the repository.xml.serialized file.
useSerializedRepository=false
#
# If Repository serialization is used the entry serializedRepositoryPath defines the
# directory where the Repository is written to and read from.
# this entry is used only when the useSerializedRepository flag is set to true
serializedRepositoryPath=.
#
#
#----------------------------------------------------------------------------------------
# ConnectionManager
#----------------------------------------------------------------------------------------
# The ConnectionManagerClass entry defines the ConnectionManager implemementation to be used
ConnectionManagerClass=org.apache.ojb.broker.accesslayer.ConnectionManagerImpl
#
#
#----------------------------------------------------------------------------------------
# SqlGenerator
#----------------------------------------------------------------------------------------
# The SqlGeneratorClass entry defines the SqlGenerator implemementation to be used
SqlGeneratorClass=org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl
#
#
#----------------------------------------------------------------------------------------
# StatementManager
#----------------------------------------------------------------------------------------
# The StatementManagerClass entry defines the StatementManager implemementation to be used
StatementManagerClass=org.apache.ojb.broker.accesslayer.StatementManager
#
#
#----------------------------------------------------------------------------------------
# StatementsForClass
#----------------------------------------------------------------------------------------
# The StatementsForClassClass entry defines the StatementsForClass implemementation to be used
# to implement cached statements.
StatementsForClassClass=org.apache.ojb.broker.accesslayer.StatementsForClassImpl
#
#
#----------------------------------------------------------------------------------------
# JdbcAccess
#----------------------------------------------------------------------------------------
# The JdbcAccessClass entry defines the JdbcAccess implemementation to be used
JdbcAccessClass=org.apache.ojb.broker.accesslayer.JdbcAccessImpl
#
#
#----------------------------------------------------------------------------------------
# RowReader
#----------------------------------------------------------------------------------------
# Set the standard RowReader implementation. It is also possible to specify the
# RowReader on class-descriptor level.
RowReaderDefaultClass=org.apache.ojb.broker.accesslayer.RowReaderDefaultImpl
#
#
#----------------------------------------------------------------------------------------
# IdentityFactory
#----------------------------------------------------------------------------------------
# Specify implementation class for object identity creation, defined by
# org.apache.ojb.broker.IdenityFactory.
IdentityFactoryClass=org.apache.ojb.broker.core.IdentityFactoryImpl
#
#
#----------------------------------------------------------------------------------------
# OQL / SQL settings
#----------------------------------------------------------------------------------------
# The OqlCollectionClass entry defines the collection type returned
# from OQL queries. By default this value is set to a List.
# This will be good for most situations. If you need the additional features of
# DList (DList itself is persistable, support of predicate) comment in the DList
# implementation. See also section 'ODMG settings' (DListClass entry).
# Using DLists for large resultsets may be bad for application performance.
# For these scenarios you can use ArrayLists or Vectors.
# Important note: the collections class to be used MUST implement the
# interface 'org.apache.ojb.broker.ManageableCollection'.
#
#DEPRECATED (use property 'CollectionTypes.OQLQuery' instead)
# OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableArrayList
# OqlCollectionClass=org.apache.ojb.odmg.collections.DListImpl
# OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableVector
#
# The SqlInLimit entry limits the number of values in IN-sql statement,
# -1 for no limits. This hint is used in Criteria.
SqlInLimit=200
#
#
#----------------------------------------------------------------------------------------
# ODMG-api settings
#----------------------------------------------------------------------------------------
# Specify the used base class for ODMG API
# - ImplementationDefaultImpl is the default class
# - ImplementationJTAImpl is for use in managed environments like J2EE conform
# Application Server
#
ImplementationClass=org.apache.ojb.odmg.ImplementationImpl
#ImplementationClass=org.apache.ojb.odmg.ImplementationJTAImpl
#
# Specify the used tx handling.
# - LocalTxManager use if you want the transaction to be associated by a thread
# - JTATxManager use if you want the transaction to be associated via the Transaction
# manager that is in your application server.
#
OJBTxManagerClass=org.apache.ojb.odmg.LocalTxManager
#OJBTxManagerClass=org.apache.ojb.odmg.JTATxManager
#
#
# The ImplicitLocking entry defines if implicit lock acquisition is
# to be used. If set to 'true' OJB implicitly locks objects to ODMG
# transactions after performing OQL queries.
# Also if implicit locking is used locking objects is recursive, that is
# associated objects are also locked.
# If ImplicitLocking is set to 'false', no locks are obtained in OQL
# queries, lookup objects and there is also no recursive locking.
# This setting can be changed at runtime using OJB's ODMG extensions.
ImplicitLocking=true
#ImplicitLocking=false
#
# The LockAssociations entry defines the behaviour for the OJB
# implicit locking feature. If set to WRITE (default) acquiring a write-
# lock on a given object x implies write locks on all objects associated
# to x. If set to READ implicit read-locks are acquired.
# Acquiring a read-lock on x allways results in implicit read-locks
# on all associated objects (if 'implicit locking' is enabled).
# This setting can be changed at runtime using OJB's ODMG extensions.
#LockAssociations=READ
LockAssociations=WRITE
#
# Enable/Disable OJB's persistent object ordering algorithm on commit
# of a transaction. If enabled OJB try to calculate a valid order for
# all new/modified objects (and referenced objects).
# If the used databases support 'deferred checks' it's recommended to use this
# feature and to disable OJB's object ordering.
# This setting can be changed at runtime using OJB's ODMG extensions.
Ordering=true
#
# If set 'true' an optimized and performant way is used to detect the
# state (persistent/transient) of an object.
# The detection of transient objects could be costly (e.g. if a
# select of ID in database is used to check if object already
# exists) we do:
# a.
# Check if the object Identity mark the specified object as transient.
# If this is 'false' the object has populated primary key fields,
# if 'true' at least one PK field is <em>null</em>
# and the object is transient.
# b.
# Then we check if the object was already registered in current transaction.
# if 'true' we can ask for transient state.
# c.
# If the primary key fields are defined/mapped as 'autoIncrement' fields and
# 'optimizedTransientObjectDetection' is enabled OJB assume that the object
# is persistent. If the PK fields are not 'autoIncrement' fields or the
# optimized detection is disabled a database "exists object"-query is
# performed to check if the object is persistent or transient.
OptimizedTransientObjectDetection=true
#
#
# Used ODMG collection implementation classes
# (e.g. when do a Implementation#newDlist() call)
#
# org.odmg.DList implementation class
DListClass=org.apache.ojb.odmg.collections.DListImpl
#
# org.odmg.DArray implementation class
DArrayClass=org.apache.ojb.odmg.collections.DListImpl
#
# org.odmg.DMap implementation class
DMapClass=org.apache.ojb.odmg.collections.DMapImpl
#
# org.odmg.DBag implementation class
DBagClass=org.apache.ojb.odmg.collections.DBagImpl
#
# org.odmg.DSet implementation class
DSetClass=org.apache.ojb.odmg.collections.DSetImpl
#
# ------------------
# @deprecated property for backward compatibility.
# If set 'true' the behavior of method
# ImplementationImpl#setImplicitLocking(...) will be the same as
# in OJB <=1.0.3 (set the implicit locking behavior of the current used transaction)
# and disable the new possibility of global 'implicit locking'
# setting at runtime with ImplementationExt#setImplicitLocking.
# This is only for backward compatibility and will
# be removed at a later date.
ImplicitLockingBackward=false
#
#
#----------------------------------------------------------------------------------------
# Component Intercepting for Profiling and Tracing
#----------------------------------------------------------------------------------------
# By enabling an InterceptorClass all OJB components will use
# this Interceptor. Interceptors allow advanced tracing and Profiling
# of all component method calls.
# This is currently an experimental feature useful only for OJB kernel developers.
#
#InterceptorClass=org.apache.ojb.broker.util.interceptor.TracingInterceptor
#
#
#----------------------------------------------------------------------------------------
# Logging settings are now in their own file, OJB-logging.properties
#----------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------
# End of OJB.properties file
#----------------------------------------------------------------------------------------