antonio 2004/02/03 03:12:05
Modified: tools/src blocks-build.xsl
Added: src/blocks/ojb build.xml
src/blocks/ojb/conf/java Department.java Employee.java
src/blocks/ojb/conf OJB.properties package.jdo
repository.dtd repository.xml EmployeeImpl.java
src/blocks/ojb/lib db-ojb-1.0.rc5-20040203.jar
Removed: src/blocks/ojb/WEB-INF/classes/org/apache/cocoon/ojb/samples
Employee.class Department.class
src/blocks/ojb/lib db-ojb-1.0.rc5-20040125.jar
src/blocks/ojb/java/org/apache/cocoon/ojb/samples
EmployeeImpl.java Department.java jdo.dtd
Employee.java
src/blocks/ojb/WEB-INF/classes/org/apache/cocoon/ojb jdo.dtd
samples.jdo
src/blocks/ojb/WEB-INF/classes OJB.properties repository.dtd
repository.xml
src/blocks/ojb/java/org/apache/cocoon/ojb samples.jdo
Log:
Fixing OJB-JDO samples.
No more precompiled classes needed.
JDO Enhancer now run at compiler time. It run only if jdo jars is present at
compiled time to avoid breaking the build.
Revision Changes Path
1.1 cocoon-2.1/src/blocks/ojb/build.xml
Index: build.xml
===================================================================
<project default="main" >
<property name="jdoEnhancer" value="com.sun.jdori.enhancer.Main"/>
<property name="jdobuildpath" value="${build.webapp.webinf}/classes"/>
<property name="packagebuildpath"
value="${jdobuildpath}/org/apache/cocoon/ojb/samples"/>
<property name="jdofile" value="${packagebuildpath}/package.jdo"/>
<path id="ojb.classpath">
<!-- <path refid="classpath"/> -->
<pathelement path="${jdobuildpath}"/>
<fileset dir="${block.dir}/lib">
<include name="**/*.jar"/>
</fileset>
<fileset dir="${basedir}/lib/local">
<include name="**/*.jar"/>
</fileset>
</path>
<available classname="${jdoEnhancer}" classpathref="ojb.classpath"
property="jdo.present"/>
<target name="main" unless="unless.exclude.webapp.samples"
depends="compile, jdo"/>
<target name="compile" unless="unless.exclude.webapp.samples">
<copy file="${block.dir}/conf/package.jdo" tofile="${jdofile}"/>
<copy file="${block.dir}/conf/repository.dtd"
tofile="${jdobuildpath}/repository.dtd"/>
<copy file="${block.dir}/conf/OJB.properties"
tofile="${jdobuildpath}/OJB.properties"/>
<copy file="${block.dir}/conf/EmployeeImpl.java"
tofile="${build.blocks}/ojb/dest/java/EmployeeImpl.java"/>
<!-- Build the Bean samples classes -->
<mkdir dir="${jdobuildpath}"/>
<javac destdir="${jdobuildpath}"
debug="${compiler.debug}"
optimize="${compiler.optimize}"
deprecation="${compiler.deprecation}"
target="${target.vm}"
nowarn="${compiler.nowarn}"
compiler="${compiler}">
<src path="${block.dir}/conf/java"/>
</javac>
</target>
<target name="jdo" if="jdo.present"
unless="unless.exclude.webapp.samples">
<!-- Run the JDO Enhancer -->
<echo>Running JDO Enhancer because ${jdo.present} ...</echo>
<java fork="yes" failonerror="yes" classname="${jdoEnhancer}"
classpathref="ojb.classpath">
<arg line="-f -d ${jdobuildpath} ${jdofile}
${packagebuildpath}/Employee.class"/>
</java>
<java fork="yes" failonerror="yes" classname="${jdoEnhancer}"
classpathref="ojb.classpath">
<arg line="-f -d ${jdobuildpath} ${jdofile}
${packagebuildpath}/Department.class"/>
</java>
</target>
</project>
1.1 cocoon-2.1/src/blocks/ojb/conf/java/Department.java
Index: Department.java
===================================================================
/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Apache Cocoon" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
[EMAIL PROTECTED]
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
Stefano Mazzocchi <[EMAIL PROTECTED]>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.cocoon.ojb.samples;
import java.io.Serializable;
/**
* Department's Bean
*
* @author <a href="mailto:[EMAIL PROTECTED]">Antonio Gallardo</a>
* @version CVS $Id: Department.java,v 1.1 2004/02/03 11:12:04 antonio Exp $
*/
public class Department implements Serializable {
private int id;
protected String name;
public Department(){
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setId(int newId) {
id = newId;
}
public void setName(String newName) {
name = newName;
}
}
1.1 cocoon-2.1/src/blocks/ojb/conf/java/Employee.java
Index: Employee.java
===================================================================
/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Apache Cocoon" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
[EMAIL PROTECTED]
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
Stefano Mazzocchi <[EMAIL PROTECTED]>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.cocoon.ojb.samples;
import java.io.Serializable;
/**
* Employee's Bean
*
* @author <a href="mailto:[EMAIL PROTECTED]">Antonio Gallardo</a>
* @version CVS $Id: Employee.java,v 1.1 2004/02/03 11:12:04 antonio Exp $
*/
public class Employee implements Serializable {
private int id;
protected int departmentId;
protected String name;
public Employee(){
this.id = 1;
this.departmentId = 1;
this.name = "My Name";
}
public int getId() {
return this.id;
}
public int getDepartmentId() {
return this.departmentId;
}
public String getName() {
return this.name;
}
public void setId(int newId) {
this.id = newId;
}
public void setDepartmentId(int newDepartmentId) {
this.departmentId = newDepartmentId;
}
public void setName(String newName) {
this.name = newName;
}
}
1.1 cocoon-2.1/src/blocks/ojb/conf/OJB.properties
Index: 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
# @version $Id: OJB.properties,v 1.1 2004/02/03 11:12:04 antonio Exp $
#
#----------------------------------------------------------------------------------------
# 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.PersistenceBrokerFactoryDefaultImpl
#
# 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 is an implementation that uses Prevayler (prevayler.sf.net) as the
persistent storage.
# Using this implementation OJB works as a simple OODBMS
#PersistenceBrokerClass=org.apache.ojb.broker.prevayler.PBPrevaylerImpl
#
#
#----------------------------------------------------------------------------------------
# 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. ConnectionFactoryAvalonDatasource
# Uses a Cocoon configured DataSource specified with the jcd-alias
attribute value in
# a jdbc-connection-descriptor element in the repository.xml file.
# 2. ConnectionFactoryNotPooledImpl
# No pooling, no playing around.
# Every connection request returns a new connection,
# every connection release close the connection.
# 3. ConnectionFactoryPooledImpl
# This implementation supports connection pooling.
# 4. ConnectionFactoryDBCPImpl
# Using the jakarta-DBCP api for connection management, support
# connection- and prepared statement-pooling, abandoned connection
handling.
# 5. 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.cocoon.ojb.components.ConnectionFactoryAvalonDataSource
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryPooledImpl
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryNotPooledImpl
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryManagedImpl
#ConnectionFactoryClass=org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl
#
#
#----------------------------------------------------------------------------------------
# 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
#
#
#----------------------------------------------------------------------------------------
# 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
#
#
#----------------------------------------------------------------------------------------
# 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
#
#
#----------------------------------------------------------------------------------------
# Object cache
#----------------------------------------------------------------------------------------
# The ObjectCacheClass entry tells OJB which concrete ObjectCache
# implementation is to be used as standard cache.
# Its also possible to override this entry adding object-cache elements
# on jdbc-connection-descriptor level and
# per class-descriptor in repository file. More info see documentation.
#
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.ObjectCacheJCSPerClassImpl
#ObjectCacheClass=org.apache.ojb.broker.cache.ObjectCachePerClassImpl
#
#
# This property is only relevant if the per class-descriptor object-cache
# declaration was used in conjunction with metadata runtime changes.
# If set 'flase' 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
#
#
# 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.apache.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
#
# Global default log level used for all logging
# entities if not specified
ROOT.LogLevel=ERROR
#
# The Default Logger instance used within OJB
DEFAULT.LogLevel=WARN
# Logger for PersistenceBrokerImpl class
org.apache.ojb.broker.core.PersistenceBrokerImpl.LogLevel=WARN
# Logger for PersistenceBrokerFactory class
PersistenceBrokerFactoryDefaultImpl
org.apache.ojb.broker.core.PersistenceBrokerFactoryDefaultImpl.LogLevel=WARN
# Logger for RepositoryXmlHandler, useful for debugging parsing of
repository.xml!
org.apache.ojb.broker.metadata.RepositoryXmlHandler.LogLevel=WARN
# Logger for JdbcAccess, useful for debugging JDBC related problems
org.apache.ojb.broker.accesslayer.JdbcAccessImpl.LogLevel=WARN
# Logger for RsIterator, useful for debugging problems with Object
materialization
org.apache.ojb.broker.accesslayer.RsIterator.LogLevel=WARN
# Logger for StatementsForClass, useful for debugging JDBC Connection related
problems
org.apache.ojb.broker.accesslayer.StatementsForClassImpl.LogLevel=WARN
# Logger for SqlGenerator, useful for debugging generation of SQL
org.apache.ojb.broker.accesslayer.sql.SqlGeneratorDefaultImpl.LogLevel=WARN
# Logger for RepositoryPersistor
org.apache.ojb.broker.metadata.RepositoryPersistor.LogLevel=WARN
# Logger for ConnectionFactory base class
org.apache.ojb.broker.accesslayer.ConnectionFactoryAbstractImpl.LogLevel=WARN
# Logger for ConnectionManager
org.apache.ojb.broker.accesslayer.ConnectionManagerImpl.LogLevel=WARN
#
# Special Logger categories used in test suite and tutorials
#
# Logger for the ODMG Implementation
ODMG.LogLevel=WARN
# Logger for the JDO RI Implementation
JDO.LogLevel=DEBUG
# Logger for the performance tests
performance.LogLevel=INFO
# Logger for the soda api
soda.LogLevel=WARN
# Logger for the factory service
ConfigurableFactory.LogLevel=WARN
#
#
#----------------------------------------------------------------------------------------
# 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. See also section 'ODMG settings'.
# 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_2
#
OqlCollectionClass=org.apache.ojb.broker.util.collections.ManageableArrayList
# 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
#
#
#----------------------------------------------------------------------------------------
# ODMG settings
#----------------------------------------------------------------------------------------
# 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_2
#DListClass=org.apache.ojb.odmg.collections.DListImpl
#
# org.odmg.DArray implementation class
DArrayClass=org.apache.ojb.odmg.collections.DListImpl_2
#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
#
#
#----------------------------------------------------------------------------------------
# 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).
#
# - PersistentFieldDirectAccessImpl
# 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
# - PersistentFieldPrivilegedImpl
# Same as above, but does cooperate with AccessController and do not
# suppress the java language access check.
# - 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.
#
PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDirectAccessImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldPrivilegedImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldIntrospectorImpl
#PersistentFieldClass=org.apache.ojb.broker.metadata.fieldaccess.PersistentFieldDynaBeanAccessImpl
#
#
#----------------------------------------------------------------------------------------
# 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
#
#----------------------------------------------------------------------------------------
# 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.JBossTransactionManagerFactory
# Weblogic Transaction Manager Factory
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WeblogicTransactionManagerFactory
# WebSphere transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.WebSphereTransactionManagerFactory
# Orion transaction manager factory
#JTATransactionManagerClass=org.apache.ojb.odmg.transaction.OrionTransactionManagerFactory
#
#----------------------------------------------------------------------------------------
# End of OJB.properties file
#----------------------------------------------------------------------------------------
1.1 cocoon-2.1/src/blocks/ojb/conf/package.jdo
Index: package.jdo
===================================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jdo SYSTEM "file:/javax/jdo/jdo.dtd">
<jdo>
<package name="org.apache.cocoon.ojb.samples">
<class name="Employee" identity-type="datastore">
<extension vendor-name="ojb" key="table" value="EMPLOYEE"/>
<field name="id" persistence-modifier="persistent">
<extension vendor-name="ojb" key="column" value="ID"/>
</field>
<field name="departmentId" persistence-modifier="persistent">
<extension vendor-name="ojb" key="column"
value="DEPARTMENT_ID"/>
</field>
<field name="name" persistence-modifier="persistent">
<extension vendor-name="ojb" key="column" value="NAME"/>
</field>
</class>
<class name="Department" identity-type="datastore">
<extension vendor-name="ojb" key="table" value="DEPARTMENT"/>
<field name="id" persistence-modifier="persistent">
<extension vendor-name="ojb" key="column" value="ID"/>
</field>
<field name="name" persistence-modifier="persistent">
<extension vendor-name="ojb" key="column" value="NAME"/>
</field>
</class>
</package>
</jdo>
1.1 cocoon-2.1/src/blocks/ojb/conf/repository.dtd
Index: repository.dtd
===================================================================
<!-- @version $Id: $ -->
<!--
ObJectRelationalBridge - Bridging Java objects and relational dabatases
This DTD describes the grammar of the Descriptor repository
Author: Thomas Mahler, (c) 2000, 2001, 2002, 2003
-->
<!--
The descriptor-repository is the root element of a
repository.xml file.
It consists of one jdbc-connection-descriptor and at least one
class-descriptor element.
The attribute element allows to add custom attributes.
The jdbc-connection-descriptor element specifies the default jdbc
connection for the repository.
class-descriptor elements specify o/r mapping information for
persistent classes.
-->
<!ELEMENT descriptor-repository (documentation?, attribute*,
jdbc-connection-descriptor*, class-descriptor*)>
<!--
The version attribute is used to bind a repository.xml
file to a given version of this dtd. This will help to
avoid versions conflicts.
The isolation attribute defines the default isolation level for
class-descriptor on ODMG api level that do not define a
specific isolation level (this does NOT touch the jdbc-level
of the connection).
-->
<!ATTLIST descriptor-repository
version (1.0) #REQUIRED
isolation-level (read-uncommitted | read-committed | repeatable-read |
serializable | optimistic) "read-uncommitted"
proxy-prefetching-limit CDATA "50"
>
<!--
The documentation element can be used to store arbitrary
information on all repository entries.
-->
<!ELEMENT documentation (#PCDATA)>
<!--
The attribute element allows to add custom attributes.
The jdbc-connection-descriptor element specifies the a jdbc
connection for the repository.
The object-cache element specifies the object-cache implementation
class associated with this class.
A connection-pool element may be used to define connection pool
properties for the specified JDBC connection.
A sequence-manager element may be used to
define which sequence manager implementation should be used within
the defined connection.
-->
<!ELEMENT jdbc-connection-descriptor (documentation?, attribute*,
object-cache?, connection-pool?, sequence-manager?)>
<!--
The jcdAlias attribute is a shortcut name for the defined connection
descriptor. OJB use jcdAlias as key for the defined connections.
The default-connection attribute used to define if this connection
should used as default connection with OJB. You could define only
one connection as default connection. It is also possible to set
the default connection at runtime using
PersistenceBrokerFactory#setDefaultKey(...) method.
If set 'true' you could use on PB-api a shortcut-method of the
PersistenceBrokerFactory to lookup PersistenceBroker instances.
The platform attribute is used to define the specific RDBMS
Platform. This attribute corresponds to a
org.apache.ojb.broker.platforms.PlatformXXXImpl class.
The jdbc-level attribute is used to specify the Jdbc compliance
level of the used Jdbc driver.
The eager-release attribute was adopt to solve a problem occured when
using OJB within JBoss (3.0 <= version < 3.2.2, seems to be fixed in
jboss 3.2.2).
Only use within JBoss.
The batch-mode attribute allow to set batch mode modus global
from the used connection. It is also possible to change
batch mode at runtime, using the
PB.serviceConnectionManager.setBatchMode(...) method.
The useAutoCommit attribute allow to set how OJB uses
the autoCommit state of the used connections. The default mode
was 1. When using mode 0 or 2 with the PB-api, you must use PB
transaction demarcation.
0 - OJB ignores the autoCommit setting of the connection and do not
try to change it. This mode could be helpfully if the
connection don't let you set the autoCommit state
(e.g. using datasources from application server).
1 - set autoCommit explicit 'true' when connection was created
and temporary set to 'false' when necessary (default mode).
2 - set autoCommit explicit 'false' when connection was created.
If the ignoreAutoCommitExceptions attribute is set 'true', all
exceptions caused by setting autocommit state, will be ignored.
Default mode 'false'.
If a jndi-datasource-name for JNDI based lookup of Jdbc
connections is specified, the four attributes driver, protocol,
subprotocol, dbalias used for Jdbc DriverManager based construction
of Jdbc Connections must not be declared.
The username and password attributes are used as credentials
for obtaining a jdbc connections.
If users don't want to keep this information the
repository.xml file, they could pass user/password
using PBKey.java to obtain a PersistenceBroker
-->
<!ATTLIST jdbc-connection-descriptor
jcd-alias CDATA #REQUIRED
default-connection (true | false) "false"
platform (Db2 | Hsqldb | Informix | MsAccess | MsSQLServer |
MySQL | Oracle | PostgreSQL | Sybase | SybaseASE |
SybaseASA | Sapdb | Firebird | Axion | NonstopSql |
Oracle9i | MaxDB ) "Hsqldb"
jdbc-level (1.0 | 2.0 | 3.0) "1.0"
eager-release (true | false) "false"
batch-mode (true | false) "false"
useAutoCommit (0 | 1 | 2) "1"
ignoreAutoCommitExceptions (true | false) "false"
jndi-datasource-name CDATA #IMPLIED
driver CDATA #IMPLIED
protocol CDATA #IMPLIED
subprotocol CDATA #IMPLIED
dbalias CDATA #IMPLIED
username CDATA #IMPLIED
password CDATA #IMPLIED
>
<!--
The object-cache element can be used to specify the ObjectCache
implementation used by OJB. There are three levels of
declaration:
1. in OJB.properties file, to declare the standard (default)
ObjectCache implementation.
2. on jdbc-connection-descriptor level, to declare ObjectCache
implementation
on a per connection/user level
3. on class-descriptor level, to declare ObjectCache implementation
on a per class level
The priority of the declared object-cache elements are:
per class > per jdbc descriptor > standard
E.g. if you declare ObjectCache 'cacheDef' as standard, set
ObjectCache 'cacheA' in class-descriptor for class A and class B
does not declare an object-cache element. Then OJB use cacheA as
ObjectCache
for class A and cacheDef for class B
-->
<!ELEMENT object-cache (documentation?, attribute*)>
<!--
Attribute 'class' specifies the full qualified class name of
the used ObjectCache implementation.
-->
<!ATTLIST object-cache
class CDATA #REQUIRED
>
<!--
The connection-pool element specifies the connection pooling
parameter.
-->
<!ELEMENT connection-pool (documentation?)>
<!--
maxActive
maximum number of connections that can be borrowed from the
pool at one time. When non-positive, there is no limit.
maxIdle
controls the maximum number of connections that can sit idle in the
pool at any time. When non-positive, there is no limit
maxWait
max time block to get connection instance from pool, after that
exception is thrown.
When non-positive, block till last judgement
whenExhaustedAction
0 - fail when pool is exhausted
1 - block when pool is exhausted
2 - grow when pool is exhausted
testOnBorrow
The pool will attempt to validate each object before it is returned
from the pool
testOnReturn
The pool will attempt to validate each object before it is returned to
the pool
testWhileIdle
Indicates whether or not idle objects should be validated.
Objects that fail to validate will be dropped from the pool
timeBetweenEvictionRunsMillis
indicates how long the eviction thread should sleep before "runs" of
examining
idle objects. When non-positive, no eviction thread will be launched.
minEvictableIdleTimeMillis
specifies the minimum amount of time that a connection may sit idle
in the pool before it is eligable for eviction due to idle time.
When non-positive, no connection will be dropped from the pool due
to idle time alone (depends on timeBetweenEvictionRunsMillis > 0)
numTestsPerEvictionRun
The number of connections to examine during each run of the
idle object evictor thread (if any)
validationQuery
Here you could specify a validation query used by pool to test a
obtained connection (e.g. "select 1 from dual"), else a default query was
used - if defined in the platform class for your database.
logAbandoned
Only supported when using
org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl
ConnectionFactory implementation.
Flag to log stack traces for application code which abandoned
a Statement or Connection. Defaults to false. Logging of
abandoned Statements and Connections adds overhead for
every Connection open or new Statement because a
stack trace has to be generated.
removeAbandoned/removeAbandonedTimeout
Only supported when using
org.apache.ojb.broker.accesslayer.ConnectionFactoryDBCPImpl
ConnectionFactory implementation.
Flag to remove abandoned connections if they exceed the
removeAbandonedTimeout. Set to true or false, default false.
If set to true a connection is considered abandoned and
eligible for removal if it has been idle longer than the
removeAbandonedTimeout. Setting this to true can recover
db connections from poorly written applications which
fail to close a connection.
-->
<!ATTLIST connection-pool
maxActive CDATA #IMPLIED
maxIdle CDATA #IMPLIED
maxWait CDATA #IMPLIED
minEvictableIdleTimeMillis CDATA #IMPLIED
numTestsPerEvictionRun CDATA #IMPLIED
testOnBorrow (true|false) #IMPLIED
testOnReturn (true|false) #IMPLIED
testWhileIdle (true|false) #IMPLIED
timeBetweenEvictionRunsMillis CDATA #IMPLIED
whenExhaustedAction (0|1|2) #IMPLIED
validationQuery CDATA #IMPLIED
logAbandoned (true|false) #IMPLIED
removeAbandoned (true|false) #IMPLIED
removeAbandonedTimeout CDATA #IMPLIED
>
<!--
The sequence-manager element specifies the sequence
manager implementation used for key generation. All
sequence manager implementations shipped with OJB
you will find under org.apache.ojb.broker.util.sequence
If no sequence-manager is defined, OJB use a default one.
For configuration examples please consult documentation.
Use the attribute element to pass implementation specific
properties. This depends on the used implementation class.
-->
<!ELEMENT sequence-manager (documentation?, attribute*)>
<!--
The className attribute represents the full qualified class name
of the desired sequence manager implementation - it is mandatory
when using the sequence-manager element.
All sequence manager implementations you find will under
org.apache.ojb.broker.util.sequence package named as
SequenceManagerXXXImpl.
For configuration examples please consult documentation.
-->
<!ATTLIST sequence-manager
className CDATA #REQUIRED
>
<!--
For interfaces or abstract classes a class-descriptor holds a sequence
of
extent-class elements.
For concrete classes it must have field-descriptors that describe
primitive
typed instance variables.
References to other persistent entity classes are specified by
reference-descriptor elements.
Collections or arrays attributes that contain other persistent entity
classes are specified by collection-descriptor elements
Concrete base classes, may specify a sequence of extent-class elements,
naming the derived classes.
A class-descriptor may contain user defined custom attribute elements.
The insert-procedure, update-procedure and delete-procedure elements
identify the procedure/function that is defined in the database which
will handle the insertion, update or deletion of an instance of this
class. These elements are all optional. If they are absent then basic
sql statements (INSERT INTO xxx..., UPDATE xxx, DELETE FROM xxx) will
be utilized.
-->
<!ELEMENT class-descriptor
((documentation?, extent-class+, attribute*) |
(documentation?, object-cache?, extent-class*, field-descriptor+,
reference-descriptor*, collection-descriptor*,
index-descriptor*, attribute*,
insert-procedure?, update-procedure?, delete-procedure?))>
<!--
The class attribute contains the full qualified name of the specified
class.
As this attribute is of type ID there can only be one class-descriptor
per
class.
The isolation-level attribute specifies the transactional isolation to
be
used for this class on ODMG api level (this does NOT touch the
jdbc-level
of the connection).
If the proxy attribute is set, proxies are used for all loading
operations
of instances of this class. If set to "dynamic", dynamic proxies are
used.
If set to another value this value is interpreted as the full-qualified
name of the proxy class to use.
If the proxy-prefetching-limit attribute (used with the proxy attribute)
is set to the value > 0, the collections of objects of this class are
materialized
by groups of the specified size, say when user tries to access the first
object of the collection, next proxy-prefetching-limit objects are loaded
by one database query.
Set this parameter to 0 if you want to turn this feature off.
The schema attribute may contain the database schema owning the table
mapped to this class.
The table attribute specifies the table name this class is mapped to.
The row-reader attribute may contain a full qualified class name.
This class will be used as the RowReader implementation used to
materialize instances of the persistent class.
The accept-locks attribute specifies whether implicit locking should
propagate to this class. Currently relevant for the ODMG layer only.
The optional initialization-method specifies a no-argument instance
method that is invoked after reading an instance from a database row.
It can be used to do initialization and validations.
The optional factory-class specifies a factory-class that
that is to be used instead of a no argument constructor.
If the factory-class is specified the factory-method
also must be defined.
factory-method refers to a static no-argument method
of the factory-class class.
The refresh attribute can be set to true to force OJB to refresh
instances when loaded from cache. It's set to false by default.
-->
<!ATTLIST class-descriptor
class ID #REQUIRED
isolation-level (read-uncommitted | read-committed | repeatable-read |
serializable | optimistic) "read-uncommitted"
proxy CDATA #IMPLIED
proxy-prefetching-limit CDATA #IMPLIED
schema CDATA #IMPLIED
table CDATA #IMPLIED
row-reader CDATA #IMPLIED
extends IDREF #IMPLIED
accept-locks (true | false) "true"
initialization-method CDATA #IMPLIED
factory-class CDATA #IMPLIED
factory-method CDATA #IMPLIED
refresh (true | false) "false"
>
<!--
An extent-class element is used to specify an implementing class or a
derived class that belongs to the extent of all instances of the
interface
or base class.
-->
<!ELEMENT extent-class (documentation?)>
<!--
The class-ref attribute must contain a fully qualified classname.
The repository file must contain a class-descriptor for this class.
-->
<!ATTLIST extent-class
class-ref IDREF #REQUIRED
>
<!--
A field descriptor contains mapping info for a primitive typed
attribute of a persistent class.
A field descriptor may contain custom attribute elements.
-->
<!ELEMENT field-descriptor (documentation?, attribute*)>
<!--
<b>The id attribute is optional.</b> If not specified, OJB internally
sorts field-descriptors according to their order of appearance in the
repository file.
If a different sort order is intended the id attribute may be used to
hold a unique number identifying the decriptors position in the
sequence of
field-descriptors.
The order of the numbers for the field-descriptors must correspond to
the order of columns in the mapped table.
The name attribute holds the name of the persistent classes attribute.
If the PersistentFieldDefaultImpl is used there must be an attribute
in the persistent class with this name.
If the PersistentFieldPropertyImpl is used there must be a JavaBeans
compliant property of this name.
The table attribute may specify a table different from the mapped
table for the persistent class. (currently not implemented).
The column attribute specifies the column the persistent classes field
is mapped to.
The optional jdbc-type attribute specifies the JDBC type of the column.
If not specified OJB tries to identify the JDBC type by inspecting the
Java attribute by reflection.
The primarykey specifies if the column is a primary key column.
The nullable attribute specifies if the column may contain null values.
The indexed attribute specifies if there is an index on this column
The autoincrement attribute specifies if the values for the persistent
attribute are automatically generated by OJB.
The sequence-name attribute can be used to state explicitly a sequence
name used by the sequence manager implementations. Check the docs/javadocs
of the used sequence manager implementation to get information if this
is a mandatory attribute. OJB standard sequence manager implementations
build a sequence name by its own, if the attribute was not set.
The locking attribute is set to true if the persistent attribute is
used for optimistic locking. can only be set for TIMESTAMP and INTEGER
columns.
The updatelock attribute is set to false if the persistent attribute is
used for optimistic locking AND the dbms should update the lock column
itself. The default is true which means that when locking is true then
OJB will update the locking fields. Can only be set for TIMESTAMP and
INTEGER
columns.
The default-fetch attribute specifies whether the persistent attribute
belongs to the JDO default fetch group.
The conversion attribute contains a fully qualified class name.
This class must implement the interface
org.apache.ojb.accesslayer.conversions.FieldConversion.
A FieldConversion can be used to implement conversions between Java-
attributes and database columns.
The length attribute can be used to specify a length setting, if
required by the jdbc-type of the underlying database column.
The precision attribute can be used to specify a precision setting, if
required by the jdbc-type of the underlying database column.
The scale attribute can be used to specify a scale setting, if
required by the jdbc-type of the underlying database column.
The access attribute specifies the accessibility of the field.
"readonly" marks fields that are not to modified. "readwrite" marks
fields that may be read and written to. "anonymous" marks anonymous
fields.
An anonymous field has a database representation (column) but no
corresponding Java attribute. Hence the name of such a field does not
refer to a Java attribute of the class, but is used as a unique
identifier only.
-->
<!ATTLIST field-descriptor
id CDATA #IMPLIED
name CDATA #REQUIRED
table CDATA #IMPLIED
column CDATA #REQUIRED
jdbc-type (BIT | TINYINT | SMALLINT | INTEGER | BIGINT | DOUBLE |
FLOAT | REAL | NUMERIC | DECIMAL | CHAR | VARCHAR |
LONGVARCHAR | DATE | TIME | TIMESTAMP | BINARY |
VARBINARY | LONGVARBINARY | CLOB | BLOB | STRUCT |
ARRAY | REF | BOOLEAN | DATALINK) #IMPLIED
primarykey (true | false) "false"
nullable (true | false) "true"
indexed (true | false) "false"
autoincrement (true | false) "false"
sequence-name CDATA #IMPLIED
locking (true | false) "false"
update-lock (true | false) "true"
default-fetch (true | false) "false"
conversion CDATA #IMPLIED
length CDATA #IMPLIED
precision CDATA #IMPLIED
scale CDATA #IMPLIED
access (readonly | readwrite | anonymous) "readwrite"
>
<!--
An attribute element allows arbitrary name/value pairs to
be represented in the repository.
-->
<!ELEMENT attribute (documentation?)>
<!--
The attribute-name identifies the name of the attribute.
The attribute-value identifies the value of the attribute.
-->
<!ATTLIST attribute
attribute-name CDATA #REQUIRED
attribute-value CDATA #REQUIRED
>
<!--
A reference-descriptor contains mapping info for an attribute of a
persistent class that is not primitive but references another
persistent entity Object.
A foreignkey element contains information on foreign key columns that
implement the association on the database level.
A reference-decriptor may contain user defined attribute elements.
-->
<!ELEMENT reference-descriptor (documentation?, foreignkey+, attribute*)>
<!--
The name attribute holds the name of the persistent classes attribute.
If the PersistentFieldDefaultImpl is used there must be an attribute
in the persistent class with this name.
If the PersistentFieldPropertyImpl is used there must be a JavaBeans
compliant property of this name.
The class-ref attribute contains a fully qualified class name.
This class is the Object type of the persistent reference attribute.
As this is an IDREF there must be a class-descriptor for this class
in the repository too.
The proxy attribute can be set to true to specify that proxy based
lazy loading should be used for this attribute.
If the proxy-prefetching-limit attribute (used with the proxy attribute)
is set to the value > 0, then loading of the reference for the first
object of some collection causes loading of the references for
the next proxy-prefetching-limit objects.
Set this parameter to 0 if you want to turn this feature off.
The refresh attribute can be set to true to force OJB to refresh
object references on instance loading.
The auto-retrieve attribute specifies whether OJB automatically
retrieves
this reference attribute on loading the persistent object.
If set to false the reference attribute is set to null. In this case the
user is responsible to fill the reference attribute.
The auto-update attribute specifies whether OJB automatically stores
this reference attribute on storing the persistent object.
This attribute must be set to false if using the OTM, ODMG or JDO layer.
The auto-delete attribute specifies whether OJB automatically deletes
this reference attribute on deleting the persistent object.
This attribute must be set to false if using the OTM, ODMG or JDO layer.
The otm-dependent attribute specifies whether the OTM layer
automatically
creates the referred object or deletes it if the reference field is set
to null.
Also otm-dependent references behave as if auto-update and auto-delete
were set to true, but the auto-update and auto-delete attributes themself
must be always set to false for use with OTM layer.
-->
<!ATTLIST reference-descriptor
name CDATA #REQUIRED
class-ref IDREF #REQUIRED
proxy (true | false) "false"
proxy-prefetching-limit CDATA #IMPLIED
refresh (true | false) "false"
auto-retrieve (true | false) "true"
auto-update (true | false) "false"
auto-delete (true | false) "false"
otm-dependent (true | false) "false"
>
<!--
A foreignkey element contains information on a foreign-key persistent
attribute that implement the association on the database level.
-->
<!ELEMENT foreignkey (documentation?)>
<!--
The field-id-ref contains the id attribute of the field-descriptor
used as a foreign key.
-->
<!ATTLIST foreignkey
field-id-ref CDATA #IMPLIED
field-ref CDATA #IMPLIED
>
<!--
A collection-descriptor contains mapping info for a Collection- or
Array-attribute of a persistent class that contains persistent
entity Objects.
The inverse-foreignkey elements contains information on foreign-key
attributes that implement the association on the database level.
The fk-pointing-to-this-class and fk-pointing-to-element-class elements
are only needed if the Collection or array implements a m:n association.
In this case they contain information on the foreign-key columns of
the intermediary table.
A collection-descriptor may contain user defined attribute elements.
-->
<!ELEMENT collection-descriptor (
documentation?,
orderby*,
inverse-foreignkey*,
fk-pointing-to-this-class*,
fk-pointing-to-element-class*,
query-customizer?,
attribute*)>
<!--
The name attribute holds the name of the persistent classes attribute.
If the PersistentFieldDefaultImpl is used there must be an attribute
in the persistent class with this name.
If the PersistentFieldPropertyImpl is used there must be a JavaBeans
compliant property of this name.
The collection-class may hold a fully qualified class name.
This class must be the Java type of the Collection attribute.
This attribute must only specified if the attribute type is not
a java.util.Collection (or subclass) or Array type.
The element-class-ref attribute contains a fully qualified class name.
This class is the Object type of the elements of persistent collection
or Array attribute.
As this is an IDREF there must be a class-descriptor for this class
in the repository too.
The orderby attribute may specify a field of the element class.
The Collection or Array will be sorted according to the specified
attribute.
The sort attribute may be used to specify ascending or descending order
for
this operation.
The indirection-table must specify the name of an intermediary table,
if the persistent collection attribute implements a m:n association.
The proxy attribute can be set to true to specify that proxy based
lazy loading should be used for this attribute.
If the proxy-prefetching-limit attribute (used with the proxy attribute)
is set to the value > 0, then loading of the collection for the first
object of some other collection causes loading of the collections for
the next proxy-prefetching-limit objects.
Set this parameter to 0 if you want to turn this feature off.
The refresh attribute can be set to true to force OJB to refresh
object and collection references on instance loading.
The auto-retrieve attribute specifies whether OJB automatically
retrieves
this attribute on loading the persistent object.
If set to false the persistent attribute is set to null. In this case
the
user is responsible to fill the persistent attribute.
The auto-update attribute specifies whether OJB automatically stores
this reference attribute on storing the persistent object.
This attribute must be set to false if using the OTM, ODMG or JDO layer.
The auto-delete attribute specifies whether OJB automatically deletes
this reference attribute on deleting the persistent object.
This attribute must be set to false if using the OTM, ODMG or JDO layer.
The otm-dependent attribute specifies whether the OTM layer
automatically
creates collection elements that were included into the collectionelements
and deletes collection elements that were excluded from the collection.
Also otm-dependent references behave as if auto-update and auto-delete
were set to true, but the auto-update and auto-delete attributes themself
must be always set to false for use with OTM layer.
-->
<!ATTLIST collection-descriptor
name CDATA #IMPLIED
collection-class CDATA #IMPLIED
element-class-ref IDREF #REQUIRED
orderby CDATA #IMPLIED
sort (ASC | DESC) "ASC"
indirection-table CDATA #IMPLIED
proxy (true | false) "false"
proxy-prefetching-limit CDATA #IMPLIED
refresh (true | false) "false"
auto-retrieve (true | false) "true"
auto-update (true | false) "false"
auto-delete (true | false) "false"
otm-dependent (true | false) "false"
>
<!--
an OrderBy elemnent contains an attribute name and a sort order
-->
<!ELEMENT orderby (documentation?)>
<!ATTLIST orderby
name CDATA #REQUIRED
sort (ASC | DESC) "ASC"
>
<!--
A inverse-foreignkey element contains information on a foreign-key
persistent attribute that implement the association on the database level.
-->
<!ELEMENT inverse-foreignkey (documentation?)>
<!--
The field-id-ref contains the id attribute of the field-descriptor
in the class of the collection elements that is used as a foreign key.
-->
<!ATTLIST inverse-foreignkey
field-id-ref CDATA #IMPLIED
field-ref CDATA #IMPLIED
>
<!--
A fk-pointing-to-this-class element contains information on a foreign-key
column of an intermediary table in a m:n scenario.
-->
<!ELEMENT fk-pointing-to-this-class (documentation?)>
<!--
The column attribute specifies the foreign-key column in the
intermediary
table that points to the class holding the collection.
-->
<!ATTLIST fk-pointing-to-this-class
column CDATA #REQUIRED
>
<!--
A fk-pointing-to-element-class element contains information on a
foreign-key
column of an intermediary table in a m:n scenario.
-->
<!ELEMENT fk-pointing-to-element-class (documentation?)>
<!--
The column attribute specifies the foreign-key column in the
intermediary
table that points to the class of the collection elements.
-->
<!ATTLIST fk-pointing-to-element-class
column CDATA #REQUIRED
>
<!--
a queryEnhancer element to enhance the 1:n query
-->
<!ELEMENT query-customizer (
documentation?,
attribute*)>
<!ATTLIST query-customizer
class CDATA #REQUIRED
>
<!--
An index-descriptor describes an index by listing its columns. It may be
unique or not.
-->
<!ELEMENT index-descriptor (documentation?, index-column+)>
<!ATTLIST index-descriptor
name CDATA #REQUIRED
unique (true | false) "false">
<!--
An index-column is just the name of a column in an index.
-->
<!ELEMENT index-column (documentation?)>
<!ATTLIST index-column
name CDATA #REQUIRED>
<!--
Identifies the procedure/function that should be used to handle
insertions for a specific class-descriptor.
The nested 'argument' elements define the argument list for the
procedure/function as well as the source for each argument.
The name attribute identifies the name of the procedure/function to use
The return-field-ref identifies the field-descriptor that will receive
the value that is returned by the procedure/function. If the procedure/
function does not include a return value, then do not specify a value
for this attribute.
The include-all-fields attribute indicates if all field-descriptors in
the corresponding class-descriptor are to be passed to the procedure/
function. If include-all-fields is 'true', any nested 'argument'
elements will be ignored. In this case, values for all field-descriptors
will be passed to the procedure/function. The order of values that are
passed to the procedure/function will match the order of field-descriptors
on the corresponding class-descriptor. If include-all-fields is false,
then values will be passed to the procedure/function based on the
information in the nested 'argument' elements.
-->
<!ELEMENT insert-procedure
(documentation?, (runtime-argument | constant-argument)*, attribute*)>
<!ATTLIST insert-procedure
name CDATA #REQUIRED
return-field-ref CDATA #IMPLIED
include-all-fields (true | false) "false"
>
<!--
Identifies the procedure/function that should be used to handle
updates for a specific class-descriptor.
The nested 'argument' elements define the argument list for the
procedure/function as well as the source for each argument.
The name attribute identifies the name of the procedure/function to use
The return-field-ref identifies the field-descriptor that will receive
the value that is returned by the procedure/function. If the procedure/
function does not include a return value, then do not specify a value
for this attribute.
The include-all-fields attribute indicates if all field-descriptors in
the corresponding class-descriptor are to be passed to the procedure/
function. If include-all-fields is 'true', any nested 'argument'
elements will be ignored. In this case, values for all field-descriptors
will be passed to the procedure/function. The order of values that are
passed to the procedure/function will match the order of field-descriptors
on the corresponding class-descriptor. If include-all-fields is false,
then values will be passed to the procedure/function based on the
information in the nested 'argument' elements.
-->
<!ELEMENT update-procedure
(documentation?, (runtime-argument | constant-argument)*, attribute*)>
<!ATTLIST update-procedure
name CDATA #REQUIRED
return-field-ref CDATA #IMPLIED
include-all-fields (true | false) "false"
>
<!--
Identifies the procedure/function that should be used to handle
deletions for a specific class-descriptor.
The nested 'runtime-argument' and 'constant-argument' elements define
the argument list for the procedure/function as well as the source
for each argument.
The name attribute identifies the name of the procedure/function to use
The return-field-ref identifies the field-descriptor that will receive
the value that is returned by the procedure/function. If the procedure/
function does not include a return value, then do not specify a value
for this attribute.
The include-pk-only attribute indicates if all field-descriptors in
the corresponding class-descriptor that are identified as being part of
the primary key are to be passed to the procedure/function. If
include-pk-only is 'true', any nested 'argument' elements will be
ignored. In this case, values for all field-descriptors that are
identified
as being part of the primary key will be passed to the procedure/function.
The order of values that are passed to the procedure/function will match
the order of field-descriptors on the corresponding class-descriptor.
If include-pk-only is false, then values will be passed to the procedure/
function based on the information in the nested 'argument' elements.
-->
<!ELEMENT delete-procedure
(documentation?, (runtime-argument | constant-argument)*, attribute*)>
<!ATTLIST delete-procedure
name CDATA #REQUIRED
return-field-ref CDATA #IMPLIED
include-pk-only (true | false) "false"
>
<!--
Defines an argument that is passed to a procedure/function. Each argument
will be set to a value from a field-descriptor or null.
The field-ref attribute identifies the field-descriptor in the
corresponding
class-descriptor that provides the value for this argument. If this
attribute
is unspecified, then this argument will be set to null.
-->
<!ELEMENT runtime-argument
(documentation?, attribute*)>
<!ATTLIST runtime-argument
field-ref CDATA #IMPLIED
return (true | false) "false"
>
<!--
Defines a constant value that is passed to a procedure/function.
The value attribute identifies the value that is passed to the procedure/
function.
-->
<!ELEMENT constant-argument
(documentation?, attribute*)>
<!ATTLIST constant-argument
value CDATA #REQUIRED
>
1.1 cocoon-2.1/src/blocks/ojb/conf/repository.xml
Index: repository.xml
===================================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE descriptor-repository PUBLIC "-//Apache Software Foundation//DTD
OJB Repository//EN" "repository.dtd">
<descriptor-repository version="1.0" isolation-level="read-uncommitted">
<!--
Define here all used connections.
One defined connection should be defined as the default one,
by set default-connection="true" - this could be done at runtime too.
It is possible to set user/password at
runtime or let login different users at runtime using the same
database. Use different PBKey with same jcdAlias name but
different user/password.
Ditto it is possible to add jdbc-connection-descriptor at runtime
using the MetadataManager.
-->
<jdbc-connection-descriptor
jcd-alias="default"
default-connection="true"
platform="Hsqldb"
jdbc-level="3.0"
driver="org.hsqldb.jdbcDriver"
protocol="jdbc"
subprotocol="hsqldb"
dbalias="hsql://localhost:9002"
username="sa"
password=""
batch-mode="false"
useAutoCommit="1"
ignoreAutoCommitExceptions="false"
>
<connection-pool
maxActive="2"
maxIdle="2"
whenExhaustedAction="2"
validationQuery="select count(*) from Department"
/>
<sequence-manager
className="org.apache.ojb.broker.util.sequence.SequenceManagerHighLowImpl">
<attribute attribute-name="grabSize" attribute-value="5"/>
</sequence-manager>
</jdbc-connection-descriptor>
<jdbc-connection-descriptor jcd-alias="personnel">
<sequence-manager
className="org.apache.ojb.broker.util.sequence.SequenceManagerHighLowImpl">
<attribute attribute-name="grabSize" attribute-value="5"/>
</sequence-manager>
</jdbc-connection-descriptor>
<class-descriptor class="org.apache.cocoon.ojb.samples.Department"
table="DEPARTMENT">
<field-descriptor name="id" column="ID" jdbc-type="INTEGER"
primarykey="true"/>
<field-descriptor name="name" column="NAME" jdbc-type="VARCHAR"/>
</class-descriptor>
<class-descriptor class="org.apache.cocoon.ojb.samples.Employee"
table="EMPLOYEE">
<field-descriptor name="id" column="ID"
jdbc-type="INTEGER" primarykey="true"/>
<field-descriptor name="departmentId" column="DEPARTMENT_ID"
jdbc-type="INTEGER"/>
<field-descriptor name="name" column="NAME"
jdbc-type="VARCHAR"/>
</class-descriptor>
</descriptor-repository>
1.1 cocoon-2.1/src/blocks/ojb/conf/EmployeeImpl.java
Index: EmployeeImpl.java
===================================================================
/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Apache Cocoon" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
[EMAIL PROTECTED]
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation and was originally created by
Stefano Mazzocchi <[EMAIL PROTECTED]>. For more information on the Apache
Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.cocoon.ojb.samples;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;
import org.apache.cocoon.ojb.jdo.components.JdoPMF;
import org.apache.ojb.broker.Identity;
import org.apache.ojb.broker.PersistenceBroker;
import org.apache.ojb.broker.PersistenceBrokerFactory;
/**
* Employee's Impl
*
* @author <a href="mailto:[EMAIL PROTECTED]">Antonio Gallardo</a>
* @version CVS $Id: EmployeeImpl.java,v 1.1 2004/02/03 11:12:04 antonio Exp $
*/
public class EmployeeImpl {
public EmployeeImpl(){}
public void retrieve(Employee bean, JdoPMF pmf) {
/* 1. Get the PersistenceManager */
PersistenceManager persistenceManager =
pmf.getPersistenceManager();
Employee e = new Employee();
e.setId(bean.getId());
PersistenceBroker broker =
PersistenceBrokerFactory.defaultPersistenceBroker();
Identity oid = new Identity(e, broker);
Employee b = new Employee();
// 2. start transaction
persistenceManager.currentTransaction().begin();
// 3. Get the Object based on the primary key
b = (Employee) persistenceManager.getObjectById(oid, false);
// 4. Copy data to bean
copyData(b, bean);
// 5. End transaction
persistenceManager.currentTransaction().commit();
}
public void insert(Employee e, JdoPMF pmf) {
/* 1. Get the PersistenceManager */
PersistenceManager persistenceManager =
pmf.getPersistenceManager();
// 2. Get current transaction
Transaction tx = persistenceManager.currentTransaction();
// 3. Start a Transaction
tx.begin();
// 4. now perform persistence operations. Store the Employee
persistenceManager.makePersistent(e);
// 5. Commit the transaction
tx.commit();
}
public void update(Employee bean, JdoPMF pmf) {
/* 1. Get the PersistenceManager */
PersistenceManager persistenceManager =
pmf.getPersistenceManager();
Employee e = new Employee();
e.setId(bean.getId());
PersistenceBroker broker =
PersistenceBrokerFactory.defaultPersistenceBroker();
Identity oid = new Identity(e, broker);
Employee b = new Employee();
// 2. start transaction
persistenceManager.currentTransaction().begin();
// 3. Get the Object based on the primary key
b = (Employee) persistenceManager.getObjectById(oid, false);
// 4. Copy data from bean
copyData(bean, b);
// Store to database
// persistenceManager.makePersistent(b);
// 5. End transaction
persistenceManager.currentTransaction().commit();
}
public void remove(Employee bean, JdoPMF pmf) {
/* 1. Get the PersistenceManager */
PersistenceManager persistenceManager =
pmf.getPersistenceManager();
Employee e = new Employee();
e.setId(bean.getId());
PersistenceBroker broker =
PersistenceBrokerFactory.defaultPersistenceBroker();
Identity oid = new Identity(e, broker);
Employee b = new Employee();
// 2. start transaction
persistenceManager.currentTransaction().begin();
// 3. Get the Object based on the primary key
b = (Employee) persistenceManager.getObjectById(oid,
false);
// Delete in the database
persistenceManager.deletePersistent(b);
// 5. End transaction
persistenceManager.currentTransaction().commit();
}
private void copyData(Employee from, Employee to)
{
to.setId(from.getId());
to.setDepartmentId(from.getDepartmentId());
to.setName(from.getName());
}
}
1.1 cocoon-2.1/src/blocks/ojb/lib/db-ojb-1.0.rc5-20040203.jar
<<Binary file>>
1.45 +1 -0 cocoon-2.1/tools/src/blocks-build.xsl
Index: blocks-build.xsl
===================================================================
RCS file: /home/cvs//cocoon-2.1/tools/src/blocks-build.xsl,v
retrieving revision 1.44
retrieving revision 1.45
diff -u -r1.44 -r1.45
--- blocks-build.xsl 1 Jan 2004 22:43:29 -0000 1.44
+++ blocks-build.xsl 3 Feb 2004 11:12:05 -0000 1.45
@@ -27,6 +27,7 @@
</fileset>
<path location="{string('${build.mocks}')}"/>
<path location="{string('${build.dest}')}"/>
+ <pathelement path="{string('${build.webapp.webinf}/classes/')}"/>
</path>
<path id="test.classpath">
