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]
