Thanks so much Armin. Now After writing one object to the db, I get no
errros but no more objects written to the database. DEBUG tells me it is
now updating an object rather than doing a new insert even though a new
object is attempted to be written.
My repository.xml has changed to this:
<jdbc-connection-descriptor jcd-alias="mysql" default-connection="true"
platform="MySQL" jdbc-level="3.0" driver="org.gjt.mm.mysql.Driver"
protocol="jdbc"
subprotocol="mysql" dbalias="//127.0.0.1/wolfbot" username="wolfbot"
password="wb0t"
eager-release="false" batch-mode="true" useAutoCommit="2"
ignoreAutoCommitExceptions="true">
<connection-pool maxActive="10" maxIdle="2" maxWait="3"
whenExhaustedAction="2" />
<sequence-manager
className="org.apache.ojb.broker.util.sequence.SequenceManagerMySQLImpl"/>
</jdbc-connection-descriptor>
Thanks again,
Chuck
----- Original Message -----
From: "Armin Waibel" <[EMAIL PROTECTED]>
To: "OJB Users List" <[EMAIL PROTECTED]>
Sent: Wednesday, June 04, 2003 5:00 AM
Subject: Re: OJB will not persist a simple object :-(
> Hi Chuck,
>
> ----- Original Message -----
> From: "Chuck Grohowski" <[EMAIL PROTECTED]>
> To: "OJB Users List" <[EMAIL PROTECTED]>
> Sent: Wednesday, June 04, 2003 7:09 AM
> Subject: OJB will not persist a simple object :-(
>
>
> > Hello
> > I successfully have OJB 0.9.9 working in a web app and am trying to
> get OJB
> > 1.0rc3 working correctly in a standalone app I am developing. When
> trying
> > to persist a simple object all that is returned in the log is this :
> >
> > [org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl] INFO:
> > Destroy object was called, try to close connection:
> > [EMAIL PROTECTED]
>
> This is called by the commons-pool api when a corrupted
> connection was found (asking the pool for a connection)
> or commons-pool shrink the connection-pool and destory(close)
> idle connections.
>
> > eager-release="true"
> It's recommended to set 'eager-release' false (introduced only for
> use OJB within jboss).
>
> > logAbandoned="true"
> detection of abandoned connections only
> supported by ConnectionFactoryDBCPImpl
> implementation (before use, please get latest
> version from CVS - was refactored).
> All other ConnectionFactory implementations
> ignore these properties.
>
> regards,
> Armin
>
> >
> > Any help would be appreciated. No exceptions are being thrown so I
> really
> > don't know where to start looking. :(
> > My database is mysql Ver 12.20 Distrib 4.0.13, for pc-linux (i686)
> >
> > TIA,
> > Chuck Grohowski
> >
> > repository.xml:
> >
> > <?xml version="1.0" encoding="UTF-8"?>
> > <!-- This is a sample metadata repository for the ObJectBridge System.
> > Use this file as a template for building your own mappings-->
> >
> > <!-- defining entities for include-files -->
> > <!DOCTYPE descriptor-repository SYSTEM "repository.dtd" [
> > <!ENTITY user SYSTEM "repository_user.xml">
> > <!ENTITY internal SYSTEM "repository_internal.xml">
> > ]>
> >
> >
> > <descriptor-repository version="1.0"
> isolation-level="read-uncommitted">
> > <!-- The Default JDBC Connection. If a class-descriptor does not
> > specify its own JDBC Connection,
> > the Connection specified here will be used. -->
> >
> > <jdbc-connection-descriptor jcd-alias="mysql"
> default-connection="true"
> > platform="MySQL" jdbc-level="3.0" driver="org.gjt.mm.mysql.Driver"
> > protocol="jdbc"
> > subprotocol="mysql" dbalias="//127.0.0.1/wolfbot" username="wolfbot"
> > password="xxxx"
> > eager-release="true"
> > batch-mode="true"
> > useAutoCommit="2"
> > ignoreAutoCommitExceptions="true">
> > <connection-pool maxActive="10" maxIdle="2" maxWait="3"
> > minEvictableIdleTimeMillis="4"
> > numTestsPerEvictionRun="5" testOnBorrow="true" testOnReturn="true"
> > testWhileIdle="true"
> > timeBetweenEvictionRunsMillis="6" whenExhaustedAction="2"
> > validationQuery="select * from test limit 0,1"
> > logAbandoned="true" removeAbandoned="true"
> removeAbandonedTimeout="8" />
> >
> > <sequence-manager
> >
> className="org.apache.ojb.broker.util.sequence.SequenceManagerMySQLImpl"
> />
> > </jdbc-connection-descriptor>
> >
> > <!-- include user defined mappings here -->
> > &user;
> >
> > <!-- include ojb internal mappings here -->
> > &internal;
> >
> > </descriptor-repository>
> >
> > repository_user.xml:
> >
> > <class-descriptor class="Kills" table="kills">
> > <field-descriptor name="id" column="id" jdbc-type="INTEGER"
> > nullable="false" primarykey="true" autoincrement="true"/>
> > <field-descriptor name="prawner" column="prawner"
> jdbc-type="INTEGER"
> > nullable="false"/>
> > <field-descriptor name="prawned" column="prawned"
> jdbc-type="INTEGER"
> > nullable="false"/>
> > <field-descriptor name="deathBy" column="death_by"
> jdbc-type="INTEGER"
> > nullable="false"/>
> > <field-descriptor name="timeOfDeath" column="time_of_death"
> > jdbc-type="TIME" nullable="false"/>
> > </class-descriptor>
> >
> > offending code:
> > public static void recordKill( Kills k ) {
> >
> > PersistenceBroker broker = null;
> > try {
> >
> > broker =
> PersistenceBrokerFactory.defaultPersistenceBroker();
> > broker.beginTransaction();
> > broker.store( k );
> > broker.commitTransaction();
> > }
> > catch( PBFactoryException pbe ) {
> >
> > broker.abortTransaction();
> > pbe.printStackTrace();
> > }
> > catch( Exception e ) {
> > broker.abortTransaction();
> > e.printStackTrace();
> > }
> > finally {
> > if( broker != null ) {
> >
> > broker.close();
> > }
> > }
> > }
> >
> > OJB.properties:
> > # OJB.properties -- configuration of the OJB runtime environment
> > # Version: 1.0
> > # (c) 2001, 2002, 2003 Apache Software Foundation
> > # Author: Thomas Mahler and many others
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # repository file settings
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The repositoryFile entry tells OJB to use this file as as its
> standard
> > mapping
> > # repository. The file is looked up from the classpath.
> > #
> > 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=.
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # PersistenceBrokerFactory / PersistenceBroker
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The PersistenceBrokerFactoryClass entry decides which concrete
> > # PersistenceBrokerFactory implemention is to be used.
> >
> PersistenceBrokerFactoryClass=org.apache.ojb.broker.core.PersistenceBrok
> erFa
> > ctoryDefaultImpl
> > #
> > # 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
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # PersistenceBrokerFactory 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.ConnectionFacto
> ryPo
> > oledImpl
> >
> #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> oryN
> > otPooledImpl
> >
> #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> oryM
> > anagedImpl
> >
> #ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFact
> oryD
> > BCPImpl
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # ConnectionManager
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The ConnectionManagerClass entry defines the ConnectionManager
> > implemementation to be used
> >
> ConnectionManagerClass=org.apache.ojb.broker.accesslayer.ConnectionManag
> erIm
> > pl
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # SqlGenerator
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The SqlGeneratorClass entry defines the SqlGenerator
> implemementation to
> > be used
> >
> SqlGeneratorClass=org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefa
> ultI
> > mpl
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # CollectionProxy class
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The optional CollectionProxy entry defines the class to be used for
> > CollectionProxies
> > # if this entry is null org.apache.ojb.broker.accesslayer.ListProxy is
> used
> > for Lists
> > # and org.apache.ojb.broker.accesslayer.CollectionProxy for
> Collections
> > #
> > #CollectionProxyClass=
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # StatementManager
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The StatementManagerClass entry defines the StatementManager
> > implemementation to be used
> >
> StatementManagerClass=org.apache.ojb.broker.accesslayer.StatementManager
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # JdbcAccess
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The JdbcAccessClass entry defines the JdbcAccess implemementation to
> be
> > used
> > JdbcAccessClass=org.apache.ojb.broker.accesslayer.JdbcAccessImpl
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Object cache
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The ObjectCacheClass entry tells OJB which concrete instance Cache
> > # implementation is to be used.
> > ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCacheDefaultImpl
> > #ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCacheEmptyImpl
> > #ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCachePerBrokerImpl
> > #ObjectCacheClass=org.apache.ojb.broker.cache.MetaObjectCacheJCSImpl
> >
> #ObjectCacheClass=org.apache.ojb.broker.cache.MetaObjectCachePerClassImp
> l
> > #
> > #
> > # Use CacheFilters to do filter operations before caching methods were
> > # called. Build your own filter class by implementing
> > org.apache.ojb.cache.CacheFilter.
> > # It is possible to use a arbitrary number of CacheFilters, but this
> slows
> > # down the performance of the cache, thus handle with care.
> > #
> > # - org.apache.ojb.broker.cache.CacheFilterClassImpl
> > # allows filtering of classes
> > # - org.apache.ojb.broker.cache.CacheFilterPackageImpl
> > # allows filtering of packages
> > # More info see Javadoc of the according classes.
> > # Set a comma separated list of CacheFilter.
> >
> #ObjectCacheFilter=org.apache.ojb.broker.cache.CacheFilterClassImpl,org.
> apac
> > he.ojb.broker.cache.CacheFilterPackageImpl
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Locking
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The LockManagerClass entry tells OJB which concrete LockManager
> > # implementation is to be used.
> > 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 PersistentLockMapImpl. It guarantees to provide
> > # Lockamanagement across multiple JVMs.
> > # 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 InMemoryLockMapImpl. Using it will
> result
> > # in a large performance gain.
> > # LockMapClass=org.apache.ojb.odmg.locking.PersistentLockMapImpl
> > LockMapClass=org.apache.ojb.odmg.locking.InMemoryLockMapImpl
> > #
> > # The LockTimeout entry defines the maximum time in milliseconds
> > # that a lock may be hold. Defaults to 60000 = 1 minute
> > LockTimeout=60000
> > #
> > # The ImplicitLocking entry defines if implicit lock acquisition is
> > # to be used. If set to true OJB implicitely locks objects to ODMG
> > # transactions after performing OQL queries.
> > # 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 and there is also no recursive locking.
> > 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 thus allways results in implicit
> read-locks
> > # on all associated objects.
> > #LockAssociations=READ
> > LockAssociations=WRITE
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Logging
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The LoggerClass entry tells OJB which concrete Logger
> > # implementation is to be used.
> > #
> > # Commons-logging
> > #LoggerClass=org.apache.ojb.broker.util.logging.CommonsLoggerImpl
> > # log4j based logging
> > #LoggerClass=org.apache.ojb.broker.util.logging.Log4jLoggerImpl
> > # OJB's own simple looging support
> > LoggerClass=org.apache.ojb.broker.util.logging.PoorMansLoggerImpl
> > LoggerConfigFile=log4j.properties
> > #
> > # The LogLevel entries tells OJB which LogLevels are active
> > # for the different loggers used within OJB
> > # Loglevels: DEBUG < INFO < WARN < ERROR < FATAL
> > # That is loglevel WARN won't log DEBUG and INFO messages,
> > # but will log WARN, ERROR, and FATAL messages
> > #
> > # The Default Logger
> > DEFAULT.LogLevel=DEBUG
> > org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl=DEBUG
> > # Logger for PersistenceBrokerImpl class
> > org.apache.ojb.broker.core.PersistenceBrokerImpl.LogLevel=DEBUG
> > # Logger for PersistenceBrokerFactory class
> > org.apache.ojb.broker.PersistenceBrokerFactory.LogLevel=DEBUG
> > # Logger for RepositoryXmlHandler, useful for debugging parsing of
> > repository.xml!
> > org.apache.ojb.broker.metadata.RepositoryXmlHandler.LogLevel=DEBUG
> > # Logger for JdbcAccess, useful for debugging JDBC related problems
> > org.apache.ojb.broker.accesslayer.JdbcAccess.LogLevel=DEBUG
> > # Logger for RsIterator, useful for debugging problems with Object
> > materialization
> > org.apache.ojb.broker.accesslayer.RsIterator.LogLevel=DEBUG
> > # Logger for StatementsForClass, useful for debugging JDBC Connection
> > related problems
> > org.apache.ojb.broker.accesslayer.StatementsForClass.LogLevel=DEBUG
> > # Logger for SqlGenerator, useful for debugging generation of SQL
> >
> org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl.LogLevel=D
> EBUG
> > # Logger for RepositoryPersistor
> > org.apache.ojb.broker.metadata.RepositoryPersistor.LogLevel=DEBUG
> > # Logger for PersistenceBrokerFactoryDefaultImpl
> >
> org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl.LogLevel=
> WARN
> > # Logger for the ODMG Implementation
> > ODMG.LogLevel=DEBUG
> > # Logger for the JDO RI Implementation
> > JDO.LogLevel=DEBUG
> > # Logger for the performance tests
> > performance.LogLevel=DEBUG
> > # Logger for the soda api
> > soda.LogLevel=DEBUG
> > # Logger for the factory service
> > ConfigurableFactory.LogLevel=DEBUG
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # OQL / SQL settings
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The OqlCollectionClass entry defines the collection type returned
> > # from OQL queries. By default this value is set to DListImpl.
> > # This will be good for most situations as DList allows maximum
> flexibility
> > # in a ODMG environment.
> > # 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.
> > #
> > OqlCollectionClass=org.apache.ojb.odmg.collections.DListImpl
> > #
> >
> OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableArra
> yLis
> > t
> > # OqlCollectionClass=org.apache.ojb.broker.util.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
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Meta data / mapping settings
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # The PersistentFieldClass property defines the implementation class
> > # for PersistentField attributes used in the OJB MetaData layer.
> > # By default a attribute based Version using Reflection is selected.
> > # using this Class persistent attributes don't need getters and
> setters
> > # and don't have to be declared public or protected.
> > #
> >
> PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persiste
> ntFi
> > eldDefaultImpl
> > #
> > # There is also a high-speed version of this access strategy
> avalaible.
> > # The PersistentFieldMaxPerformanceImpl does not cooperate with
> > # an AccessController, but accesses the fields directly.
> >
> #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persist
> entF
> > ieldMaxPerformanceImpl
> > #
> > # The PersistentFieldPropertyImpl uses JavaBeans comformant calls only
> > # to access persistent attributes. No Reflection is needed.
> > # But for each attribute xxx there must be public getXxx() and
> setXxx()
> > methods.
> > #
> >
> #PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.Persist
> entF
> > ieldPropertyImpl
> > #
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # 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.TracingIntercep
> tor
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Transaction Management and assocation
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # Use the LocalTxManager if you want the transaction to be associated
> by a
> > thread
> > OJBTxManagerClass=org.apache.ojb.odmg.LocalTxManager
> > # Use the JTATxManager if you want the transaction to be associated
> via the
> > Transaction
> > # manager that is in your application server.
> > #OJBTxManagerClass=org.apache.ojb.odmg.JTATxManager
> > #
> > # 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.odmg.transaction.JBossTransact
> ionM
> > anagerFactory
> > # Weblogic Transaction Manager Factory
> >
> #JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WeblogicTran
> sact
> > ionManagerFactory
> > # WebSphere transaction manager factory
> >
> #JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WebSphereTra
> nsac
> > tionManagerFactory
> > # Orion transaction manager factory
> >
> #JTATransactionManagerClass=org.apache.ojb.odmg.transaction.OrionTransac
> tion
> > ManagerFactory
> > #
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> > # End of OJB.properties file
> >
> #-----------------------------------------------------------------------
> ----
> > -------------
> >
> >
> >
> > ---------------------------------------------------------------------
> > To unsubscribe, e-mail: [EMAIL PROTECTED]
> > For additional commands, e-mail: [EMAIL PROTECTED]
> >
> >
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: [EMAIL PROTECTED]
> For additional commands, e-mail: [EMAIL PROTECTED]
>
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
