Index: org/exolab/castor/jdo/drivers/MultiRSCallQuery.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/drivers/MultiRSCallQuery.java,v
retrieving revision 1.4
diff -u -r1.4 MultiRSCallQuery.java
--- org/exolab/castor/jdo/drivers/MultiRSCallQuery.java	25 Mar 2004 12:31:06 -0000	1.4
+++ org/exolab/castor/jdo/drivers/MultiRSCallQuery.java	15 Mar 2005 13:35:51 -0000
@@ -59,6 +59,7 @@
 import org.exolab.castor.jdo.QueryException;
 import org.exolab.castor.jdo.engine.SQLTypes;
 import org.exolab.castor.mapping.AccessMode;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.persist.spi.Complex;
 import org.exolab.castor.persist.spi.PersistenceQuery;
 import org.exolab.castor.util.Messages;
@@ -235,10 +236,12 @@
     }
 
 
-    public Object fetch(Object[] fields,Object identity) throws ObjectNotFoundException, PersistenceException
+    public Object fetch(ProposedObject proposedObject, Object identity) throws ObjectNotFoundException, PersistenceException
     {
         Object stamp = null;
 
+        Object[] fields = proposedObject.getFields();
+        
         try {
             // Load all the fields of the object including one-one relations
             // index 0 belongs to the identity
Index: org/exolab/castor/jdo/drivers/PostgreSQLCallQuery.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/drivers/PostgreSQLCallQuery.java,v
retrieving revision 1.4
diff -u -r1.4 PostgreSQLCallQuery.java
--- org/exolab/castor/jdo/drivers/PostgreSQLCallQuery.java	25 Mar 2004 12:32:01 -0000	1.4
+++ org/exolab/castor/jdo/drivers/PostgreSQLCallQuery.java	15 Mar 2005 13:35:51 -0000
@@ -60,6 +60,7 @@
 import org.exolab.castor.jdo.engine.JDBCSyntax;
 import org.exolab.castor.jdo.engine.SQLTypes;
 import org.exolab.castor.mapping.AccessMode;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.persist.spi.Complex;
 import org.exolab.castor.persist.spi.PersistenceQuery;
 import org.exolab.castor.util.Messages;
@@ -248,10 +249,10 @@
     }
 
 
-    public Object fetch(Object[] fields,Object identity) throws ObjectNotFoundException, PersistenceException
+    public Object fetch(ProposedObject proposedObject, Object identity) throws ObjectNotFoundException, PersistenceException
     {
         Object stamp = null;
-
+        Object[] fields = proposedObject.getFields();
         try {
 
             // Load all the fields of the object including one-one relations
Index: org/exolab/castor/jdo/drivers/ReturnedRSCallQuery.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/drivers/ReturnedRSCallQuery.java,v
retrieving revision 1.3
diff -u -r1.3 ReturnedRSCallQuery.java
--- org/exolab/castor/jdo/drivers/ReturnedRSCallQuery.java	25 Mar 2004 12:24:22 -0000	1.3
+++ org/exolab/castor/jdo/drivers/ReturnedRSCallQuery.java	15 Mar 2005 13:35:51 -0000
@@ -59,6 +59,7 @@
 import org.exolab.castor.jdo.QueryException;
 import org.exolab.castor.jdo.engine.SQLTypes;
 import org.exolab.castor.mapping.AccessMode;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.persist.spi.Complex;
 import org.exolab.castor.persist.spi.PersistenceQuery;
 import org.exolab.castor.util.Messages;
@@ -228,10 +229,10 @@
     }
 
 
-    public Object fetch(Object[] fields,Object identity) throws ObjectNotFoundException, PersistenceException
+    public Object fetch(ProposedObject proposedObject, Object identity) throws ObjectNotFoundException, PersistenceException
     {
         Object stamp = null;
-
+        Object[] fields = proposedObject.getFields();
         try {
 
             // Load all the fields of the object including one-one relations
Index: org/exolab/castor/jdo/engine/DatabaseImpl.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/engine/DatabaseImpl.java,v
retrieving revision 1.17
diff -u -r1.17 DatabaseImpl.java
--- org/exolab/castor/jdo/engine/DatabaseImpl.java	10 Jan 2005 21:22:46 -0000	1.17
+++ org/exolab/castor/jdo/engine/DatabaseImpl.java	15 Mar 2005 13:35:52 -0000
@@ -313,7 +313,15 @@
         if ( info == null )
             throw new ClassNotPersistenceCapableException( Messages.format( "persist.classNotPersistenceCapable", type.getName() ) );
 
-        return tx.load( info.engine, info.molder, identity, object, null );
+        ProposedObject proposedObject = new ProposedObject();
+        proposedObject.setObject(object);
+        if (object != null) {
+        	proposedObject.setProposedClass(object.getClass());
+        }
+        
+        Object loaded = tx.load( info.engine, info.molder, identity, proposedObject, null );
+        object = proposedObject.getObject();
+        return loaded;
     }
     public Object load( Class type, Complex identity )
             throws TransactionNotInProgressException, ObjectNotFoundException,
@@ -363,7 +371,11 @@
         if ( info == null )
             throw new ClassNotPersistenceCapableException( Messages.format("persist.classNotPersistenceCapable", type.getName()) );
         
-        return tx.load( info.engine, info.molder, identity, null, mode );
+        ProposedObject proposedObject = new ProposedObject();
+        proposedObject.setObject(null);
+        proposedObject.setProposedClass(null);
+        
+        return tx.load( info.engine, info.molder, identity, proposedObject, mode );
     }
 
     public void create( Object object )
Index: org/exolab/castor/jdo/engine/OQLQueryImpl.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/engine/OQLQueryImpl.java,v
retrieving revision 1.13
diff -u -r1.13 OQLQueryImpl.java
--- org/exolab/castor/jdo/engine/OQLQueryImpl.java	13 Dec 2004 10:29:19 -0000	1.13
+++ org/exolab/castor/jdo/engine/OQLQueryImpl.java	15 Mar 2005 13:35:52 -0000
@@ -47,6 +47,8 @@
 package org.exolab.castor.jdo.engine;
 
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.exolab.castor.jdo.*;
 import org.exolab.castor.jdo.oql.*;
 import org.exolab.castor.mapping.AccessMode;
@@ -75,6 +77,7 @@
     implements Query, OQLQuery
 {
 
+    private final static Log log = LogFactory.getLog (OQLQueryImpl.class);
 
     private LockEngine          _dbEngine;
 
@@ -249,7 +252,9 @@
 
         _objClass = walker.getObjClass();
         _clsDesc = walker.getClassDescriptor();
+        log.debug ("class descriptor = " + _clsDesc);
         _expr = walker.getQueryExpression();
+        log.debug ("sql expression = " + _expr);
         _paramInfo = walker.getParamInfo();
         _projectionType = walker.getProjectionType();
         _pathInfo = walker.getPathInfo();
Index: org/exolab/castor/jdo/engine/SQLEngine.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/engine/SQLEngine.java,v
retrieving revision 1.26
diff -u -r1.26 SQLEngine.java
--- org/exolab/castor/jdo/engine/SQLEngine.java	29 Oct 2004 14:40:05 -0000	1.26
+++ org/exolab/castor/jdo/engine/SQLEngine.java	15 Mar 2005 13:35:54 -0000
@@ -52,6 +52,7 @@
 import org.exolab.castor.jdo.*;
 import org.exolab.castor.mapping.*;
 import org.exolab.castor.mapping.loader.FieldHandlerImpl;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.persist.spi.*;
 import org.exolab.castor.util.Messages;
 import org.exolab.castor.util.SqlBindParser;
@@ -116,7 +117,7 @@
     private ColumnInfo[]         _ids;
 
     private SQLEngine           _extends;
-
+    
     private QueryExpression     _sqlFinder;
 
     private PersistenceFactory  _factory;
@@ -319,6 +320,10 @@
         }
     }
 
+    public Persistence.ColumnInfo[] getColumnInfoForIdentities() {
+    	return _ids;
+    }
+    
     public Persistence.FieldInfo[] getInfo() {
         return _fields;
     }
@@ -1058,23 +1063,46 @@
     }
 
 
-    public Object load( Object conn, Object[] fields, Object identity, AccessMode accessMode )
-            throws ObjectNotFoundException, PersistenceException {
+    /**
+     * Loads the object from persistence storage. This method will load
+     * the object fields from persistence storage based on the object's
+     * identity. This method may return a stamp which can be used at a
+     * later point to determine whether the copy of the object in
+     * persistence storage is newer than the cached copy (see {@link
+     * #store}). If <tt>lock</tt> is true the object must be
+     * locked in persistence storage to prevent concurrent updates.
+     *
+     * @param conn An open connection
+     * @param fields An Object[] to load field values into
+     * @param identity Identity of the object to load.
+     * @param accessMode The access mode (null equals shared)
+     * @return The object's stamp, or null
+     * @throws ObjectNotFoundException The object was not found in persistent storage
+     * @throws PersistenceException A persistence error occured
+     */
+    public Object load( Object conn, ProposedObject proposedObject, Object identity, AccessMode accessMode )
+            throws ObjectNotFoundException, PersistenceException 
+    {
 
         PreparedStatement stmt  = null;
         ResultSet         rs    = null;
         Object            stamp = null;
         boolean           notNull;
+        
+        Object[] fields = proposedObject.getFields();
+        int originalNumberOfFields = fields.length;
+        
+        _log.debug ("number of fields to load from persistence store: " + fields.length);
 
         try {
-            stmt = ( (Connection) conn ).prepareStatement( ( accessMode == AccessMode.DbLocked ) ? _sqlLoadLock : _sqlLoad );
+        	String sqlString = ( accessMode == AccessMode.DbLocked ) ? _sqlLoadLock : _sqlLoad; 
+            stmt = ( (Connection) conn ).prepareStatement(sqlString);
             
             if (_log.isDebugEnabled()) {
-                String generatedSQL = ( accessMode == AccessMode.DbLocked ) ? _sqlLoadLock : _sqlLoad;
-                _log.debug( Messages.format( "jdo.loading", _clsDesc.getJavaClass().getName(), generatedSQL ) );
+                _log.debug( Messages.format("jdo.loading", _clsDesc.getJavaClass().getName(), sqlString));
             }
             
-            int count = 1;
+            int fieldIndex = 1;
             // bind the identity of the preparedStatement
             if ( identity instanceof Complex ) {
                 Complex id = (Complex) identity;
@@ -1082,33 +1110,72 @@
                     throw new PersistenceException( "Size of complex field mismatched! expected: "+_ids.length+" found: "+id.size() );
 
                 for ( int i=0; i<_ids.length; i++ )
-                    stmt.setObject( count++, idToSQL( i, id.get(i) ) );
+                    stmt.setObject( fieldIndex++, idToSQL( i, id.get(i) ) );
 
             } else {
                 if ( _ids.length != 1 )
                     throw new PersistenceException( "Complex field expected!" );
-                stmt.setObject( count++, idToSQL( 0, identity ) );
+                stmt.setObject( fieldIndex++, idToSQL( 0, identity ) );
             }
 
-            // query the object
+            // execute the SQL query 
             rs = stmt.executeQuery();
             if ( ! rs.next() )
                 throw new ObjectNotFoundException( Messages.format("persist.objectNotFound", _clsDesc.getJavaClass().getName(), identity) );
 
+            int numberOfFields = _fields.length;
+            int numberOfIdentityColumns = _ids.length;
+            
+            int numberOfExtendLevels = numberOfExtendingClassDescriptors (getDescriptor());
+            
+            Collection extendingClassDescriptors = this.getDescriptor().getExtendedBy();
+
+            if (extendingClassDescriptors.size() > 0) {
+                Object[] returnValues = 
+                    calculateNumberOfFields(extendingClassDescriptors, 
+                            _ids.length, _fields.length, numberOfExtendLevels, rs);
+                JDOClassDescriptor potentialLeafDescriptor = (JDOClassDescriptor) returnValues[0];
+                
+            	
+                if (!potentialLeafDescriptor.getJavaClass().getName().equals (getDescriptor().getJavaClass().getName())) {
+                    Object[] expandedFields = new Object[potentialLeafDescriptor.getFields().length];
+                    
+                    fields = expandedFields;
+                    proposedObject.setFields (expandedFields);
+                    proposedObject.setActualClass (potentialLeafDescriptor.getJavaClass());
+                    proposedObject.setExpanded(true);
+                }
+
+            	return null;
+            }
+            
             // Load all the fields of the object including one-one relations
-            count = 1;
+            int columnIndex = 1; // index to use during ResultSet.getXXX()
+            fieldIndex = 1; // index in fields[] for storing result of SQLTypes.getObject()
+            String tableName = null;
+            String tableNameOld = tableName;
             Object[] temp = new Object[10]; // assume complex field max at 10
             for ( int i = 0 ; i < _fields.length ; ++i  ) {
+            	
+            	tableName = _fields[i].tableName;
+            	if (!tableName.equals (tableNameOld) && !_fields[i].joined) {
+            		for (int j = 0; j < _ids.length; j++) {
+            			columnIndex = columnIndex + 1; 
+            		}
+            	}
+            	
                 if ( !_fields[i].load )
                     continue;
 
                 if ( !_fields[i].multi ) {
                     notNull = false;
                     if ( _fields[i].columns.length == 1 ) {
-                        fields[i] = toJava( i, 0, SQLTypes.getObject( rs, count++, _fields[i].columns[0].sqlType ) );
+                        fields[i] = toJava( i, 0, SQLTypes.getObject( rs, columnIndex++, _fields[i].columns[0].sqlType ) );
+                        fieldIndex += 1;
                     } else {
                         for ( int j=0; j<_fields[i].columns.length; j++ ) {
-                            temp[j] = toJava( i, j, SQLTypes.getObject( rs, count++, _fields[i].columns[j].sqlType ) );
+                            temp[j] = toJava( i, j, SQLTypes.getObject( rs, columnIndex++, _fields[i].columns[j].sqlType ) );
+                            fieldIndex += 1;
                             if ( temp[j] != null ) {
                                 notNull = true;
                             }
@@ -1122,11 +1189,12 @@
                     ArrayList res = new ArrayList();
                     notNull = false;
                     for ( int j=0; j<_fields[i].columns.length; j++ ) {
-                        temp[j] = toJava( i, j, SQLTypes.getObject( rs, count, _fields[i].columns[j].sqlType ) );
+                        temp[j] = toJava( i, j, SQLTypes.getObject( rs, columnIndex, _fields[i].columns[j].sqlType ) );
                         if ( temp[j] != null ) {
                             notNull = true;
                         }
-                        count++;
+                        fieldIndex++;
+                        columnIndex += 1;
                     }
                     if ( notNull ) {
                         if ( _fields[i].columns.length == 1 )
@@ -1136,23 +1204,39 @@
                     }
                     fields[i] = res;
                 }
+                
+                tableNameOld = tableName;
             }
 
             while ( rs.next() ) {
-                count = 1;
+                fieldIndex = 1;
+                columnIndex = 1;
+
+                tableName = null;
+                tableNameOld = tableName;
+
                 for ( int i = 0; i < _fields.length ; ++i  ) {
-                    if ( !_fields[i].load )
+
+                	tableName = _fields[i].tableName;
+                	if (!tableName.equals (tableNameOld) && !_fields[i].joined) {
+                		for (int j = 0; j < _ids.length; j++) {
+                			columnIndex = columnIndex + 1; 
+                		}
+                	}
+                	
+                	if ( !_fields[i].load )
                         continue;
 
                     if ( _fields[i].multi ) {
                         ArrayList res = (ArrayList)fields[i];
                         notNull = false;
                         for ( int j=0; j<_fields[i].columns.length; j++ ) {
-                            temp[j] = toJava( i, j, SQLTypes.getObject( rs, count, _fields[i].columns[j].sqlType ) );
+                            temp[j] = toJava( i, j, SQLTypes.getObject( rs, columnIndex, _fields[i].columns[j].sqlType ) );
                             if ( temp[j] != null ) {
                                 notNull = true;
                             }
-                            count++;
+                            fieldIndex++;
+                            columnIndex += 1;
                         }
                         if ( notNull ) {
                             if ( _fields[i].columns.length == 1 ) {
@@ -1165,9 +1249,12 @@
                             }
                         }
                     } else {
-                        count += _fields[i].columns.length;
+                        fieldIndex += _fields[i].columns.length;
+                        columnIndex += _fields[i].columns.length;
                     }
                 }
+                
+                proposedObject.setFields (fields);
             }
         } catch ( SQLException except ) {
             _log.fatal( Messages.format( "jdo.loadFatal", _type, (( accessMode == AccessMode.DbLocked ) ? _sqlLoadLock : _sqlLoad ) ), except );
@@ -1187,7 +1274,105 @@
         }
         return stamp;
     }
-
+    
+    private int numberOfExtendingClassDescriptors (JDOClassDescriptor classDescriptor) {
+        int numberOfExtendLevels = 1;
+        JDOClassDescriptor currentClassDescriptor = getDescriptor();
+        while (currentClassDescriptor.getExtends() != null) {
+            currentClassDescriptor = (JDOClassDescriptor) currentClassDescriptor.getExtends();
+            numberOfExtendLevels += 1;
+        }
+        return numberOfExtendLevels;
+    }
+
+    private Object[] calculateNumberOfFields (Collection extendingClassDescriptors, 
+            int numberOfIdentityColumns,
+            int numberOfFields,
+            int numberOfExtendLevels, 
+            ResultSet rs)
+    throws SQLException
+    {
+        JDOClassDescriptor potentialLeafDescriptor = null;
+        int suggestedNumberOfFields = numberOfFields;
+        Collection potentialActualClassDescriptor = new LinkedList();
+        int numberOfIdentitiesToAnalyze = 0;
+        addExtendingClassDescriptors(potentialActualClassDescriptor, extendingClassDescriptors);
+        
+        JDOClassDescriptor potentialClassDescriptor = null;
+        JDOClassDescriptor potentialClassDescriptorPrevious = null;
+        int initialColumnIndex = numberOfFields + numberOfIdentityColumns * numberOfExtendLevels + 1;
+        int columnIndex = initialColumnIndex;
+        int numberOfExtendingClassDescriptors = 0;
+        for (Iterator iter = potentialActualClassDescriptor.iterator(); iter.hasNext(); ) {
+            potentialClassDescriptor = (JDOClassDescriptor) iter.next();
+            numberOfExtendingClassDescriptors += 1;
+            _log.debug ("Potential extending class descriptor: " + potentialClassDescriptor.getJavaClass().getName());
+            FieldDescriptor[] identityDescriptors = potentialClassDescriptor.getIdentities();
+            boolean isNull = true;
+            
+            for (int i = 0; i < identityDescriptors.length; i++) {
+                Object temp;
+                Object[] temps;
+                JDOFieldDescriptor jdoFieldDescriptor = (JDOFieldDescriptor) identityDescriptors[i];
+                if (jdoFieldDescriptor.getSQLName().length == 1 ) {
+                    temp = SQLTypes.getObject( rs, columnIndex++, java.sql.Types.JAVA_OBJECT);
+                    isNull = (temp == null);
+                } else {
+                    temps = new Object[jdoFieldDescriptor.getSQLName().length];
+                    for ( int j=0; j<jdoFieldDescriptor.getSQLName().length; j++ ) {
+                        temps[j] = SQLTypes.getObject( rs, columnIndex++, java.sql.Types.JAVA_OBJECT);
+                        isNull = (temps[j] == null);
+                    }
+                    temp = new Complex (jdoFieldDescriptor.getSQLName().length, temps);
+                }
+                
+                _log.debug ("Obtained value " + temp + " for additional (extending) identity " + 
+                        potentialClassDescriptor.getJavaClass().getName() + "/" + 
+                        identityDescriptors[i].getFieldName() + " at position " + 
+                        columnIndex);
+                isNull = (temp == null);
+                if (temp != null) {
+                    numberOfIdentitiesToAnalyze += 1;
+                    potentialClassDescriptorPrevious = potentialClassDescriptor;
+                }
+                
+            }
+            
+            if (!iter.hasNext() && !isNull && numberOfIdentitiesToAnalyze > 0) {
+                potentialLeafDescriptor = potentialClassDescriptor;
+                suggestedNumberOfFields += potentialClassDescriptor.getFields().length;
+            } else if (!iter.hasNext() && isNull && numberOfIdentitiesToAnalyze > 0){
+                potentialLeafDescriptor = potentialClassDescriptorPrevious; 
+                // suggestedNumberOfFields += potentialClassDescriptor.getFields().length;
+            } else {
+                FieldDescriptor[] potentialFields = 
+                    (FieldDescriptor[]) potentialClassDescriptor.getFields();
+                for (int i = 0; i < potentialFields.length; i++) {
+                    JDOFieldDescriptor jdoFieldDescriptor = (JDOFieldDescriptor) potentialFields[i];
+                    String[] columnNames = jdoFieldDescriptor.getSQLName();
+                    for (int j = 0; j < columnNames.length; j++) {
+                        columnIndex = columnIndex + 1;
+                    }
+                }
+                
+                // the JDOClassDescriptor we just looked at is definitely part of the extends hierarchy,
+                // and as such we need to increase the number of potential fields
+                if (!isNull) {
+                    suggestedNumberOfFields += potentialClassDescriptor.getFields().length;
+                }
+            }
+        }
+        
+        _log.debug ("In total " + numberOfIdentitiesToAnalyze + " (extending) identities analyzed.");
+        
+        if (potentialLeafDescriptor != null) {
+            _log.debug ("Most likely of type " + potentialLeafDescriptor.getJavaClass().getName());
+            _log.debug ("After analysis, " + suggestedNumberOfFields + " fields need to be loaded.");
+        }
+        
+        return new Object[] {potentialLeafDescriptor, new Integer (suggestedNumberOfFields) };
+        
+    }
     
     private void buildSqlCreate () throws QueryException {
         StringBuffer sql;
@@ -1345,7 +1530,8 @@
         
     }
     
-    private void buildFinder( JDOClassDescriptor clsDesc ) throws QueryException {
+    // private void buildFinder(JDOClassDescriptor clsDesc, ColumnInfo[] ids, FieldInfo[] fields, String mapTo) throws QueryException {
+    private void buildFinder(JDOClassDescriptor clsDesc) throws QueryException {
         QueryExpression expr;
         QueryExpression find;
 
@@ -1372,15 +1558,38 @@
             find.addInnerJoin(curDesc.getTableName(), curDesc.getIdentityColumnNames(),
                               baseDesc.getTableName(), baseDesc.getIdentityColumnNames());
             curDesc = baseDesc;
+            
+            // add identity column names to SELECT statement
+//            String[] identityColumnNames = baseDesc.getIdentityColumnNames();
+//            for (int j = 0; j < identityColumnNames.length; j++) {
+//            	expr.addColumn (baseDesc.getTableName(), identityColumnNames[j]);
+//            }
         }
+        
         for ( int i=0; i<_ids.length; i++ ) {
-            find.addColumn( _mapTo, idnames[i] );
+            // find.addColumn(_mapTo, idnames[i]);
+            // expr.addColumn(_mapTo, idnames[i]);
         }
 
         // join all the related/depended table
         Vector joinTables = new Vector();
+        String aliasOld = null;
+        String alias = null;
+        
         for ( int i=0; i<_fields.length; i++ ) {
-            String alias = _fields[i].tableName;
+        	if (i > 0) {
+        		aliasOld = alias;
+        	}
+            alias = _fields[i].tableName;
+            
+            // add id columns to select statement
+            if (!alias.equals (aliasOld) && !_fields[i].joined) {
+            	for (int j = 0; j < _ids.length; j++) {
+                	expr.addColumn (alias, _ids[j].getName());
+                    find.addColumn (alias, _ids[j].getName());
+            	}
+            }
+            
             if ( _fields[i].load ) {
                 if ( _fields[i].joined /*&& !joinTables.contains( _fields[i].tableName )*/ ) {
                     int offset = 0;
@@ -1404,10 +1613,71 @@
                     expr.addColumn( alias, _fields[i].columns[j].name );
                     find.addColumn( alias, _fields[i].columns[j].name );
                 }
+                
                 expr.addTable(_fields[i].tableName, alias);
                 find.addTable(_fields[i].tableName, alias);
             }
+            
+            
+        }
+
+        // 'join' all the extending tables 
+        curDesc = clsDesc;
+        List classDescriptorsToAdd = new LinkedList();
+        JDOClassDescriptor classDescriptor = null;
+        addExtendingClassDescriptors(classDescriptorsToAdd, curDesc.getExtendedBy());
+        
+        if (classDescriptorsToAdd.size() > 0) {
+        	for (Iterator iter = classDescriptorsToAdd.iterator(); iter.hasNext(); ) {
+        		classDescriptor = (JDOClassDescriptor) iter.next();
+        		_log.debug ("Adding outer left join for " + classDescriptor.getJavaClass().getName() + 
+        				" on table " + classDescriptor.getTableName());
+                expr.addOuterJoin( _mapTo, 
+                		curDesc.getIdentityColumnNames(), 
+                		classDescriptor.getTableName(), 
+                		classDescriptor.getIdentityColumnNames());
+                find.addOuterJoin( _mapTo, 
+                		curDesc.getIdentityColumnNames(), 
+                		classDescriptor.getTableName(), 
+                		classDescriptor.getIdentityColumnNames());
+
+                Persistence persistenceEngine;
+				try {
+					persistenceEngine = _factory.getPersistence (classDescriptor);
+				} catch (MappingException e) {
+					throw new QueryException ("Problem obtaining persistence engine for ClassDescriptor " + classDescriptor.getJavaClass().getName(), e);
+				}
+
+				SQLEngine.ColumnInfo[] idInfos = 
+					(SQLEngine.ColumnInfo[]) persistenceEngine.getColumnInfoForIdentities();
+                for (int i = 0; i < idInfos.length; i++) {
+                	_log.debug ("Adding column " + idInfos[i].name + " for table " + classDescriptor.getTableName());
+                	expr.addColumn (classDescriptor.getTableName(), idInfos[i].name);
+                	find.addColumn (classDescriptor.getTableName(), idInfos[i].name);
+                }
+                
+                SQLEngine.FieldInfo[] fieldInfos = (SQLEngine.FieldInfo[]) persistenceEngine.getInfo();
+                for (int i = 0; i < fieldInfos.length; i++) {
+                	boolean hasFieldToAdd = false;
+                	SQLEngine.ColumnInfo[] columnInfos = fieldInfos[i].columns;
+                	if (classDescriptor.getTableName().equals(fieldInfos[i].tableName)) {
+                		for ( int j = 0; j < columnInfos.length; j++ ) {
+                    		_log.debug ("Adding column " + fieldInfos[i].columns[j].name + " for table " + classDescriptor.getTableName());
+                    		expr.addColumn (classDescriptor.getTableName(), fieldInfos[i].columns[j].name);
+                    		find.addColumn (classDescriptor.getTableName(), fieldInfos[i].columns[j].name);
+                		}
+                		hasFieldToAdd = true;
+                	}
+                    
+                    if (hasFieldToAdd) {
+                    	expr.addTable(classDescriptor.getTableName());
+                    	find.addTable(classDescriptor.getTableName());
+                    }
+                }
+        	}
         }
+
+
         _sqlLoad = expr.getStatement( false );
         _sqlLoadLock = expr.getStatement( true );
 
@@ -1415,9 +1685,21 @@
 
         if(_log.isDebugEnabled()){
             _log.debug( Messages.format( "jdo.loading", _type, _sqlLoad ) );
+            _log.debug( Messages.format( "jdo.loading.with.lock", _type, _sqlLoadLock ) );
+            _log.debug( Messages.format( "jdo.finding", _type, _sqlFinder ) );
         }
         
     }
+    
+    private void addExtendingClassDescriptors (Collection classDescriptorsToAdd, Collection extendingClassDescriptors) {
+    	JDOClassDescriptor classDescriptor = null; 
+        for (Iterator iter = extendingClassDescriptors.iterator(); iter.hasNext(); ) {
+        	classDescriptor = (JDOClassDescriptor) iter.next(); 
+        	classDescriptorsToAdd.add (classDescriptor);
+        	addExtendingClassDescriptors(classDescriptorsToAdd, classDescriptor.getExtendedBy());
+        }
+    	
+    }
 
 
     public String toString() {
@@ -1443,10 +1725,17 @@
         final String[] joinFields;
 
         ColumnInfo[] columns;
+        
+        final FieldDescriptor fieldDescriptor;
+        
+        final ClassDescriptor classDescriptor;
 
         FieldInfo( JDOClassDescriptor clsDesc, FieldDescriptor fieldDesc, String classTable, boolean ext )
                 throws MappingException{
 
+        	fieldDescriptor = fieldDesc;
+        	classDescriptor = clsDesc;
+        	
             // for readability
             final int FIELD_TYPE = 0;
 
@@ -1591,16 +1880,31 @@
         }
     }
 
-    static final class ColumnInfo {
+    static final class ColumnInfo implements Persistence.ColumnInfo{
 
+        /**
+         * Name of the column
+         */
         final String  name;
 
+        /**
+         * SQL type of teh coplumn
+         */
         final int sqlType;
 
+        /**
+         * TypeConvertor to use when converting to the SQLType of this column.
+         */
         final TypeConvertor convertTo;
 
+        /**
+         * TypeConvertor to use when converting from the SQLType of this column.
+         */
         final TypeConvertor convertFrom;
 
+        /**
+         * Type conversion parameters
+         */
         final String convertParam;
 
         ColumnInfo( String name, int type, TypeConvertor convertTo,
@@ -1611,6 +1915,41 @@
             this.convertFrom = convertFrom;
             this.convertParam = convertParam;
         }
+
+		/* (non-Javadoc)
+		 * @see org.exolab.castor.persist.spi.Persistence.ColumnInfo#getName()
+		 */
+		public String getName() {
+			return name;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.exolab.castor.persist.spi.Persistence.ColumnInfo#getSqlType()
+		 */
+		public int getSqlType() {
+			return sqlType;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.exolab.castor.persist.spi.Persistence.ColumnInfo#getConvertTo()
+		 */
+		public TypeConvertor getConvertTo() {
+			return convertTo;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.exolab.castor.persist.spi.Persistence.ColumnInfo#getConvertFrom()
+		 */
+		public TypeConvertor getConvertFrom() {
+			return convertFrom;
+		}
+
+		/* (non-Javadoc)
+		 * @see org.exolab.castor.persist.spi.Persistence.ColumnInfo#getConvertParam()
+		 */
+		public String getConvertParam() {
+			return convertParam;
+		}
     }
 
     static final class SQLQuery implements PersistenceQuery {
@@ -1619,7 +1958,8 @@
 
         private ResultSet         _rs;
 
-        private final SQLEngine _engine;
+        private /*final*/ SQLEngine _engine;
+        private SQLEngine _requestedEngine;
 
         private final Class[]   _types;
 
@@ -1638,6 +1978,7 @@
         SQLQuery( SQLEngine engine, String sql, Class[] types )
         {
             _engine = engine;
+            _requestedEngine = engine;
             _types = types;
             _values = new Object[ _types.length ];
             _sql = sql;
@@ -1677,8 +2018,11 @@
         /**
          * use the jdbc 2.0 method to move to an absolute position in the
          * resultset.
+         * @param row Row number to move to.
+         * @return True if the pointer has been moved to the indicated row number.
+         * @exception PersistenceException If an underlying SQLException is is reported.
          */
-         public boolean absolute(int row)
+        public boolean absolute(int row)
             throws PersistenceException
          {
             boolean retval = false;
@@ -1691,7 +2035,7 @@
             }
             catch (SQLException e)
             {
-               throw new PersistenceException(e.getMessage());
+               throw new PersistenceException(e.getMessage(), e);
             }
             return retval;
          }
@@ -1896,19 +2240,43 @@
         }
 
 
-        private Object loadSingleField( int i, int count ) throws SQLException, PersistenceException
+        private Object loadSingleField( int i, CounterRef counterReference) throws SQLException, PersistenceException
         {
+            String currentTableName = counterReference.getTableName();
+            int count = counterReference.getCounter();
             Object[] temp = new Object[_engine._fields[i].columns.length];
             boolean notNull = false;
             Object   field;
+            
+            String fieldTableName = _engine._fields[i].tableName;
+            
+            ResultSetMetaData metaData = _rs.getMetaData();
+            String columnTableName = metaData.getTableName(count);
+            _log.debug("Current column: " + columnTableName + "." + metaData.getColumnName(count) + "/" + metaData.getColumnLabel(count));
+            
+            while (!columnTableName.equals(fieldTableName)) {
+                _log.debug("Skipping " + metaData.getTableName(count) + "." + metaData.getColumnName(count) + " due to wrong table name.");
+                count++;
+                columnTableName = metaData.getTableName(count);
+            }
 
+            String firstColumnOfField = _engine._fields[i].columns[0].name;
+            while (!metaData.getColumnName(count).equals(firstColumnOfField)) {
+                _log.debug("Skipping " + metaData.getTableName(count) + "." + metaData.getColumnName(count));
+                count++;
+            }
+            
             if ( _engine._fields[i].columns.length == 1 ) {
-                field = _engine.toJava( i, 0, SQLTypes.getObject( _rs, count++,
+                field = _engine.toJava( i, 0, SQLTypes.getObject( _rs, count,
                         _engine._fields[i].columns[0].sqlType ) );
+                _log.debug ("Got value for " + metaData.getTableName(count) + "." + metaData.getColumnName(count) + ": " + field);
+                count++;
             } else {
                 for ( int j=0; j<_engine._fields[i].columns.length; j++ ) {
-                    temp[j] = _engine.toJava( i, j, SQLTypes.getObject( _rs, count++,
+                    temp[j] = _engine.toJava( i, j, SQLTypes.getObject( _rs, count,
                               _engine._fields[i].columns[j].sqlType ) );
+                    _log.debug ("Got value for " + metaData.getTableName(count) + "." + metaData.getColumnName(count) + ": " + temp[j]);
+                    count++;
                     if ( temp[j] != null ) {
                         notNull = true;
                     }
@@ -1918,12 +2286,16 @@
                 else
                     field = null;
             }
+            _log.debug("Loaded field " + _engine._fields[i].getFieldName() + ": " + field);
+            counterReference.setCounter(count);
+            counterReference.setTableName(currentTableName);
             return field;
         }
 
 
-        private Object loadMultiField( int i, int count, Object field ) throws SQLException, PersistenceException
+        private Object loadMultiField( int i, CounterRef counterReference, Object field ) throws SQLException, PersistenceException
         {
+            int count = counterReference.getCounter();
             Object[]  temp = new Object[_engine._fields[i].columns.length];
             boolean notNull = false;
             ArrayList res;
@@ -1951,27 +2323,43 @@
                         res.add( com );
                 }
             }
+            counterReference.setCounter(count);
+            
             return res;
         }
 
 
-        private int loadRow( Object[] fields, boolean isFirst ) throws SQLException, PersistenceException
+        private int loadRow( Object[] fields, int numberOfFields, boolean isFirst ) throws SQLException, PersistenceException
         {
             int count = _engine._ids.length + 1;
 
+            String tableName = null;
+
+            // TODO: wrong, as it could be that the first field is not part of the root class. 
+            tableName = _engine._fields[0].tableName;
+
             // Load all the fields.
-            for ( int i = 0 ; i < _engine._fields.length ; ++i  ) {
+            CounterRef counterReference = new CounterRef ();
+            counterReference.setCounter(count);
+            counterReference.setTableName(tableName);
+            
+            for ( int i = 0 ; i < numberOfFields ; ++i  ) {
+                
                 if ( !_engine._fields[i].load )
                     continue;
 
                 if ( _engine._fields[i].multi ) {
-                    fields[i] = loadMultiField( i, count, fields[i] );
+                    counterReference.setCounter(count);
+                    fields[i] = loadMultiField( i, counterReference, fields[i] );
+                    count = counterReference.getCounter(); 
                 } else if( isFirst ) {
                     // Non-multi fields have to be done one only once, so this is skipped
                     // if we have already read the first row.
-                    fields[i] = loadSingleField( i, count );
+                    counterReference.setCounter (count);
+                    fields[i] = loadSingleField( i, counterReference);
+                    count = counterReference.getCounter();
                 }
-                count += _engine._fields[i].columns.length;
+                // count += _engine._fields[i].columns.length;
             }
             return count;
         }
@@ -2004,12 +2392,19 @@
         }
 
 
-        // Fill the given fields[] with the "cached" stuff from our _fields[] .
-        public Object fetch( Object[] fields, Object identity ) throws ObjectNotFoundException, PersistenceException
+        /**
+         * @see org.exolab.castor.persist.spi.PersistenceQuery#fetch(org.exolab.castor.persist.ProposedObject, java.lang.Object)
+         */
+        public Object fetch( ProposedObject proposedObject, Object identity ) 
+            throws ObjectNotFoundException, PersistenceException
         {
+            Object[] fields = proposedObject.getFields();
+            
+            // Fill the given fields[] with the "cached" stuff from our _fields[] .
             for( int i = 0; i < _fields.length; i++ ) {
                 fields[i] = _fields[i];
             }
+            
             return null;
         }
 
@@ -2019,7 +2414,48 @@
             // maybe we can optimize a little bit here when we have time.
             // Instead of creating new Object[] and ArrayList for each 
             // "multi field" each fetchRaw is called, we might reuse them.
-            _fields = new Object[_engine._fields.length];
+
+            SQLEngine oldEngine = null;
+            int originalFieldNumber = _requestedEngine._fields.length;
+            if (_requestedEngine.getDescriptor().isExtended()) {
+                Collection extendingClassDescriptors = _requestedEngine.getDescriptor().getExtendedBy();
+                int numberOfExtendLevels = _requestedEngine.numberOfExtendingClassDescriptors(_requestedEngine.getDescriptor());
+                JDOClassDescriptor leafDescriptor = null;
+                Object[] returnValues = null;
+                try {
+                        returnValues =_requestedEngine.calculateNumberOfFields(extendingClassDescriptors, _requestedEngine._ids.length, _requestedEngine._fields.length, numberOfExtendLevels, this._rs);
+                } 
+                catch (SQLException e) {
+                    _log.error ("Problem calculating number of concrete fields.", e);
+                    throw new PersistenceException ("Problem calculating number of concrete fields.", e);
+                }
+                
+                leafDescriptor = (JDOClassDescriptor) returnValues[0];
+                
+                if (leafDescriptor != null) {
+                    _log.debug("potential leaf descriptor = " + leafDescriptor.getJavaClass().getName());
+                    
+                    
+                    if (!leafDescriptor.getJavaClass().getName().equals(_requestedEngine.getDescriptor().getJavaClass().getName())) {
+                        _log.debug ("Increasing number of fields to load from " + originalFieldNumber + " to " 
+                                + ((Integer) returnValues[1]).intValue());
+                        originalFieldNumber = ((Integer) returnValues[1]).intValue();
+                        
+                        Persistence newEngine =null;
+                        try {
+                            newEngine = _requestedEngine._factory.getPersistence(leafDescriptor);
+                        } catch (MappingException e) {
+                            _log.error ("Problem obtaining persistence engine for " + leafDescriptor.getJavaClass().getName(), e);
+                            throw new PersistenceException ("Problem obtaining persistence engine for " + leafDescriptor.getJavaClass().getName(), e);
+                        } 
+                        _log.debug ("About to start using persistence engine for " + ((SQLEngine) newEngine).getDescriptor());
+                        _engine = (SQLEngine) newEngine;
+                    }
+                }
+            }
+            
+            
+            _fields = new Object[originalFieldNumber];
 
             // It would prove a little difficult to fetch if we don't have any rows with data left :-)
             if ( _resultSetDone )
@@ -2042,7 +2478,7 @@
                 // As we assume that we have called fetch() immediatly after nextIdentity(),
                 // we can be sure that it belongs to the object we want. This is probably not the
                 // safest programming style, but has to suffice currently :-)
-                loadRow( _fields, true );
+                loadRow( _fields, originalFieldNumber, true );
 
                 // We move forward in the ResultSet, until we see another identity or run out of rows.
                 while ( _rs.next() ) {
@@ -2054,7 +2490,7 @@
                     if( identitiesEqual( wantedIdentity, currentIdentity ) ) {
 
                         // Load next row of object data from _rs into <_fields> array.
-                        loadRow( _fields, false );
+                        loadRow( _fields, originalFieldNumber, false );
 
                     } else {
                         // We are done with all the rows for our obj. and still have rows left.
@@ -2069,7 +2505,7 @@
                 // We are done with all the rows for our obj. and don't have any rows left.
                 _resultSetDone = true;
                 _lastIdentity = null;
-
+                
             } catch ( SQLException except ) {
                 throw new PersistenceException( Messages.format("persist.nested", except), except );
             }
Index: org/exolab/castor/jdo/engine/SQLTypes.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/jdo/engine/SQLTypes.java,v
retrieving revision 1.10
diff -u -r1.10 SQLTypes.java
--- org/exolab/castor/jdo/engine/SQLTypes.java	29 Oct 2004 14:06:17 -0000	1.10
+++ org/exolab/castor/jdo/engine/SQLTypes.java	15 Mar 2005 13:35:56 -0000
@@ -361,7 +361,6 @@
         return java.toString();
     }
 
-
     public static Object getObject( ResultSet rs, int index, int sqlType )
             throws SQLException
     {
Index: org/exolab/castor/mapping/loader/ClassDescriptorImpl.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/mapping/loader/ClassDescriptorImpl.java,v
retrieving revision 1.2
diff -u -r1.2 ClassDescriptorImpl.java
--- org/exolab/castor/mapping/loader/ClassDescriptorImpl.java	5 Mar 2005 13:41:52 -0000	1.2
+++ org/exolab/castor/mapping/loader/ClassDescriptorImpl.java	15 Mar 2005 13:35:56 -0000
@@ -47,6 +47,12 @@
 package org.exolab.castor.mapping.loader;
 
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.exolab.castor.mapping.ValidityException;
 import org.exolab.castor.mapping.ClassDescriptor;
 import org.exolab.castor.mapping.FieldDescriptor;
@@ -66,7 +72,7 @@
 public class ClassDescriptorImpl
     implements ClassDescriptor
 {
-
+	private static final Log _log = LogFactory.getLog (ClassDescriptorImpl.class);
 
     private ClassMapping         _map;
     /**
@@ -85,6 +91,12 @@
      * or null if this is a top-level class.
      */
     private final ClassDescriptor     _extends;
+    
+    /**
+     * A collection of class descriptors that extend this class, or 
+     * an empty collection if this is a leaf class.
+     */
+    private final Collection	  _extendedBy = new LinkedList();
 
 
     private final ClassDescriptor     _depends;
@@ -166,6 +178,13 @@
                 throw new MappingException( "mapping.classDoesNotExtend",
                                             _javaClass.getName(), extend.getJavaClass().getName() );
             _extends = extend;
+            
+            _log.debug (_extends.getClass().getName());
+            if ( _extends.getClass().getName().equals("org.exolab.castor.jdo.engine.JDOClassDescriptor") &&
+            	this.getClass().getName().equals ("org.exolab.castor.jdo.engine.JDOClassDescriptor")) {
+            	((ClassDescriptorImpl) _extends).addExtendedBy (this);
+            }
+            
             if ( _extends instanceof ClassDescriptorImpl )
                 _identities = ( identities == null ? ((ClassDescriptorImpl)_extends).getIdentities() : identities );
             else
@@ -232,6 +251,31 @@
     public ClassDescriptor getExtends()
     {
         return _extends;
+    }
+    
+    public boolean isExtending() 
+    {
+        return (_extends != null);
+    }
+    
+    /**
+     * Returns a collection of class descriptors that extend this class descriptor.
+     * @return A collection of class descriptors.
+     */
+    public Collection getExtendedBy() 
+    {
+    	return _extendedBy;
+    }
+    
+    public boolean isExtended() 
+    {
+        return (_extendedBy.size() > 0);
+    }
+    
+    public void addExtendedBy (ClassDescriptor classDesc) 
+    {
+    	_log.debug ("Adding ClassDescriptor of type " + classDesc.getClass().getName());
+    	_extendedBy.add (classDesc);
     }
 
     public ClassDescriptor getDepends() {
Index: org/exolab/castor/persist/ClassMolder.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/ClassMolder.java,v
retrieving revision 1.19
diff -u -r1.19 ClassMolder.java
--- org/exolab/castor/persist/ClassMolder.java	8 Mar 2005 20:46:01 -0000	1.19
+++ org/exolab/castor/persist/ClassMolder.java	15 Mar 2005 13:35:59 -0000
@@ -65,6 +65,7 @@
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
@@ -463,17 +464,31 @@
             extendFields = getFullFields( extend );
             thisFields = clsMap.getFieldMapping();
 
-            fieldList = new ArrayList(extendFields.length + thisFields.length);
+            fieldList = new ArrayList(extendFields.length + thisFields.length - identities.length);
             for (int i = 0; i < extendFields.length; i++) {
                 fieldList.add(extendFields[i]);
             }
-            for ( int i=0; i<thisFields.length; i++ ) {
+            for ( int i=0,j=0; i<thisFields.length; i++ ) {
+                // start patch for bug 1899
+                idfield = false;
+                IDSEARCH:
                 for ( int k=0; k<identities.length; k++ ) {
-                    if ( ! thisFields[i].getName().equals( identities[k] ) ) {
-                        fieldList.add(thisFields[i]);
-                        break;
+                    if ( thisFields[i].getName().equals( identities[k] ) ) {
+                        idfield = true;
+                        break IDSEARCH;
                     }
                 }
+                if ( !idfield ) {
+                    fieldList.add(thisFields[i]);
+                    j++;
+                }
+                // end patch for bug 1899
+//                for ( int k=0; k<identities.length; k++ ) {
+//                    if ( ! thisFields[i].getName().equals( identities[k] ) ) {
+//                        fieldList.add(thisFields[i]);
+//                        break;
+//                    }
+//                }
             }
             fields = new FieldMapping[fieldList.size()];
             fieldList.toArray(fields);
@@ -674,51 +689,129 @@
      * @return the object stamp for the object in the persistent storage
      */
     public Object load( TransactionContext tx, OID oid, DepositBox locker,
-            Object object, AccessMode suggestedAccessMode )
+            ProposedObject proposedObject, AccessMode suggestedAccessMode )
             throws ObjectNotFoundException, PersistenceException {
-            return load( tx, oid, locker, object, suggestedAccessMode, null );
+            return load( tx, oid, locker, proposedObject, suggestedAccessMode, null );
     }
 
-    public Object load( TransactionContext tx, OID oid, DepositBox locker,
-            Object object, AccessMode suggestedAccessMode, QueryResults results )
+    private Object loadFields( TransactionContext tx, OID oid, DepositBox locker,
+            ProposedObject proposedObject, AccessMode suggestedAccessMode, QueryResults results )
             throws ObjectNotFoundException, PersistenceException {
+    	
 
         Connection conn;
-        ClassMolder fieldClassMolder;
-        LockEngine fieldEngine;
         Object[] fields;
-        Object ids;
         Object stamp = null;
-        Object temp;
-        int fieldType;
-        AccessMode accessMode = getAccessMode( suggestedAccessMode );
 
-        if ( oid.getIdentity() == null )
-            throw new PersistenceException("The identities of the object to be loaded is null");
+        AccessMode accessMode = getAccessMode( suggestedAccessMode );
 
         // load the fields from the persistent storage if the cache is empty
         // and the accessMode is readOnly.
         fields = (Object[]) locker.getObject( tx );
+        proposedObject.setFields (fields);
+        
         if ( fields == null || accessMode == AccessMode.DbLocked ) {
             fields = new Object[_fhs.length];
+            proposedObject.setFields (fields);
             if( results != null ) {
-                stamp = results.getQuery().fetch( fields, oid.getIdentity() );
+                _log.debug ("Trying to load " + fields.length + " fields from persistence store.");
+                stamp = results.getQuery().fetch( proposedObject, oid.getIdentity() );
+                fields = proposedObject.getFields();
+                _log.debug ("Actually loaded " + fields.length + " fields from persistence store.");
             } else {
                 conn = (Connection)tx.getConnection(oid.getLockEngine());
-                stamp = _persistence.load( conn, fields, oid.getIdentity(), accessMode );
+                _log.debug ("Trying to load " + fields.length + " from persistence store.");
+                stamp = _persistence.load( conn, proposedObject, oid.getIdentity(), accessMode );
+                fields = proposedObject.getFields();
+                _log.debug ("Actually loaded " + fields.length + " from persistence store.");
             }
-            oid.setDbLock( accessMode == AccessMode.DbLocked );
-            locker.setObject( tx, fields );
+            
+            if (proposedObject.isExpanded()) {
+            	_log.debug ("Actual object has been expanded from " + proposedObject.getProposedClass() 
+            			+ " to " + proposedObject.getActualClass() + ", with the field values to set as follows:");
+            	
+            	for (int i = 0; i < fields.length; i++) {
+            		_log.debug ("field " + (i + 1) + ": " + fields[i]);
+            	}
+            } else {
+                oid.setDbLock( accessMode == AccessMode.DbLocked );
+                locker.setObject( tx, fields );
+            }
+        }
+        
+        return stamp;
+    }
+
+    public Object load( TransactionContext tx, OID oid, DepositBox locker,
+            ProposedObject proposedObject, AccessMode suggestedAccessMode, QueryResults results )
+            throws ObjectNotFoundException, PersistenceException {
+
+        Connection conn;
+        ClassMolder fieldClassMolder;
+        LockEngine fieldEngine;
+        Object[] fields;
+        Object ids;
+        Object stamp = null;
+        Object temp;
+        int fieldType;
+        AccessMode accessMode = getAccessMode( suggestedAccessMode );
+
+        if ( oid.getIdentity() == null )
+            throw new PersistenceException("The identities of the object to be loaded is null");
+
+        // obtain field values
+    	_log.debug ("About to call loadFields() with ProposedObject instance of " + proposedObject);
+        stamp = loadFields (tx, oid, locker, proposedObject, suggestedAccessMode, results);
+    	_log.debug ("loadFields() returned ProposedObject instance of " + proposedObject);
+        
+        // if the obejct has been expanded, call ClassMolder.load() recursively
+        if (proposedObject.isExpanded()) {
+        	ClassMolder molder = oid.getLockEngine().getClassMolder(proposedObject.getActualClass());
+        	
+        	Object expandedObject = null;
+        	try {
+				expandedObject = molder.newInstance(tx.getClassLoader());
+			} catch (InstantiationException e) {
+				_log.error ("Cannot create instance of " + molder.getName());
+				throw new PersistenceException ("Cannot craete instance of " + molder.getName());
+			} catch (IllegalAccessException e) {
+				_log.error ("Cannot create instance of " + molder.getName());
+				throw new PersistenceException ("Cannot craete instance of " + molder.getName());
+			} catch (ClassNotFoundException e) {
+				_log.error ("Cannot create instance of " + molder.getName());
+				throw new PersistenceException ("Cannot craete instance of " + molder.getName());
+			}
+        	
+        	ProposedObject proposedExpanded = new ProposedObject();
+        	proposedExpanded.setProposedClass(proposedObject.getActualClass());
+            proposedExpanded.setActualClass(proposedObject.getActualClass());
+        	proposedExpanded.setObject(expandedObject);
+        	proposedExpanded.setFields(proposedObject.getFields());
+        	
+        	_log.debug ("About to call ClassMolder.load() recursively, with a ProposedObject instance of " 
+        			+ proposedExpanded);
+        	
+        	stamp = molder.load (tx, oid, locker, proposedExpanded, suggestedAccessMode, results);
+        	
+        	// store expanded information 
+        	proposedObject.setActualClass(proposedExpanded.getActualClass());
+        	proposedObject.setFields(proposedExpanded.getFields());
+        	proposedObject.setObject(proposedExpanded.getObject());
+        	
+        	
+        	return stamp;
         }
+        
+        fields = proposedObject.getFields();
 
         // set the timeStamp of the data object to locker's timestamp
-        if ( object instanceof TimeStampable ) {
-            ((TimeStampable)object).jdoSetTimeStamp( locker.getTimeStamp() );
+        if ( proposedObject.getObject() instanceof TimeStampable ) {
+            ((TimeStampable) proposedObject.getObject()).jdoSetTimeStamp( locker.getTimeStamp() );
         }
 
         // set the identities into the target object
         ids = oid.getIdentity();
-        setIdentity( tx, object, ids );
+        setIdentity( tx, proposedObject.getObject(), ids );
 
         // iterates thur all the field of the object and bind all field.
         for ( int i = 0; i < _fhs.length; i++ ) {
@@ -726,11 +819,12 @@
             switch (fieldType) {
             case FieldMolder.PRIMITIVE:
                 // simply set the corresponding Persistent field value into the object
+            	_log.debug ("Loading field " + _fhs[i].getName() + " with value '" + fields[i] + "'");
                 temp = fields[i];
                 if ( temp != null )
-                    _fhs[i].setValue( object, temp, tx.getClassLoader() );
+                    _fhs[i].setValue( proposedObject.getObject(), temp, tx.getClassLoader() );
                 else
-                    _fhs[i].setValue( object, null, tx.getClassLoader() );
+                    _fhs[i].setValue( proposedObject.getObject(), null, tx.getClassLoader() );
                 break;
 
             case FieldMolder.SERIALIZABLE:
@@ -743,9 +837,9 @@
                         ByteArrayInputStream bis = new ByteArrayInputStream( bytes );
                         ObjectInputStream os = new ObjectInputStream( bis );
                         Object o = os.readObject();
-                        _fhs[i].setValue( object, o, tx.getClassLoader() );
+                        _fhs[i].setValue( proposedObject.getObject(), o, tx.getClassLoader() );
                     } else {
-                        _fhs[i].setValue( object, null, tx.getClassLoader() );
+                        _fhs[i].setValue( proposedObject.getObject(), null, tx.getClassLoader() );
                     }
                 } catch ( OptionalDataException e ) {
                     throw new PersistenceException( "Error while deserializing an dependent object", e );
@@ -771,14 +865,17 @@
 						if (_fhs[i].isLazy()) {
 							temp = SingleProxy.getProxy(tx, fieldEngine, fieldClassMolder, fields[i], null, suggestedAccessMode);
 						} else {
-							temp = tx.load(fieldEngine, fieldClassMolder, fields[i], null, suggestedAccessMode);
+							ProposedObject proposedTemp = new ProposedObject();
+							proposedTemp.setObject (null);
+							proposedTemp.setProposedClass(null);
+							temp = tx.load(fieldEngine, fieldClassMolder, fields[i], proposedTemp, suggestedAccessMode);
 						}
                     } catch (ObjectNotFoundException ex) {
                         temp = null;
                     }
-                    _fhs[i].setValue( object, temp, tx.getClassLoader() );
+                    _fhs[i].setValue( proposedObject.getObject(), temp, tx.getClassLoader() );
                 } else {
-                    _fhs[i].setValue( object, null, tx.getClassLoader() );
+                    _fhs[i].setValue( proposedObject.getObject(), null, tx.getClassLoader() );
                 }
                 break;
             case FieldMolder.ONE_TO_MANY:
@@ -795,25 +892,31 @@
                     // field.
                     ArrayList v = (ArrayList)fields[i];
                     if ( v != null ) {
-                      // simple array type support
-                      Class collectionType = _fhs[i].getCollectionType();
-                      if (collectionType.isArray()) {
-                        Object[] value = (Object[])java.lang.reflect.Array.newInstance(
-                                collectionType.getComponentType(), v.size());
-                        for ( int j=0,l=v.size(); j<l; j++ ) {
-                          value[j] = tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), null, suggestedAccessMode );
-                        }
-                        _fhs[i].setValue( object, value, tx.getClassLoader() );
-                      } else {
-                        CollectionProxy cp = CollectionProxy.create( _fhs[i], object, tx.getClassLoader() );
-                        for ( int j=0,l=v.size(); j<l; j++ ) {
-                            cp.add( v.get(j), tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), null, suggestedAccessMode ) );
-                        }
-                        cp.close();
-                        //_fhs[i].setValue( object, cp.getCollection() );
-                      }
+                    	// simple array type support
+                    	Class collectionType = _fhs[i].getCollectionType();
+                    	if (collectionType.isArray()) {
+                    		Object[] value = (Object[])java.lang.reflect.Array.newInstance(
+                    				collectionType.getComponentType(), v.size());
+                    		for ( int j=0,l=v.size(); j<l; j++ ) {
+                    			ProposedObject proposedValue = new ProposedObject ();
+                    			proposedValue.setProposedClass(null);
+                    			proposedValue.setObject(null);
+                    			value[j] = tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), proposedValue, suggestedAccessMode );
+                    		}
+                    		_fhs[i].setValue( proposedObject.getObject(), value, tx.getClassLoader() );
+                    	} else {
+                    		CollectionProxy cp = CollectionProxy.create( _fhs[i], proposedObject.getObject(), tx.getClassLoader() );
+                    		for ( int j=0,l=v.size(); j<l; j++ ) {
+                    			ProposedObject proposedValue = new ProposedObject ();
+                    			proposedValue.setProposedClass(null);
+                    			proposedValue.setObject(null);
+                    			cp.add( v.get(j), tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), proposedValue, suggestedAccessMode ) );
+                    		}
+                    		cp.close();
+                    		//_fhs[i].setValue( object, cp.getCollection() );
+                    	}
                     } else {
-                        _fhs[i].setValue( object, null, tx.getClassLoader() );
+                    	_fhs[i].setValue( proposedObject.getObject(), null, tx.getClassLoader() );
                     }
                 } else {
                     // lazy loading is specified. Related object will not be loaded.
@@ -821,7 +924,7 @@
                     // will constructed and set as the data object's field.
                     ArrayList list = (ArrayList) fields[i];
                     RelationCollection relcol = new RelationCollection( tx, oid, fieldEngine, fieldClassMolder, accessMode, list );
-                    _fhs[i].setValue( object, relcol, tx.getClassLoader() );
+                    _fhs[i].setValue( proposedObject.getObject(), relcol, tx.getClassLoader() );
                 }
                 break;
             default:
@@ -1442,7 +1545,12 @@
                         // must be loaded thur transaction, so that the related object
                         // is properly locked and updated before we delete it.
                         if ( !tx.isDeletedByOID( new OID( fieldEngine, fieldClassMolder, id ) ) ) {
-                            Object reldel = tx.load( fieldEngine, fieldClassMolder, id, null, null );
+                        	
+                			ProposedObject proposedValue = new ProposedObject ();
+                			proposedValue.setProposedClass(null);
+                			proposedValue.setObject(null);
+                        	
+                            Object reldel = tx.load( fieldEngine, fieldClassMolder, id, proposedValue, null );
                             if ( reldel != null && tx.isPersistent( reldel ) ) {
                                 tx.writeLock( reldel, tx.getLockTimeout() );
 
@@ -1837,7 +1945,12 @@
                 // allow a dependent object not implements timeStampable
                 fields = new Object[_fhs.length];
                 Connection conn = (Connection)tx.getConnection(oid.getLockEngine());
-                stamp = _persistence.load( conn, fields, oid.getIdentity(), accessMode );
+                ProposedObject proposedObject = new ProposedObject();
+                proposedObject.setProposedClass(object.getClass());
+                proposedObject.setObject (object);
+                proposedObject.setFields (fields);
+                stamp = _persistence.load( conn, proposedObject, oid.getIdentity(), accessMode );
+                fields = proposedObject.getFields();
                 oid.setDbLock( accessMode == AccessMode.DbLocked );
                 locker.setObject( tx, fields );
             }
@@ -1865,14 +1978,22 @@
 
                             // load the cached dependent object from the data store.
                             // The loaded will be compared with the new one
-                            if ( fields[i] != null )
-                                tx.load( fieldEngine, fieldClassMolder, fields[i], null, suggestedAccessMode );
+                            if ( fields[i] != null ) {
+                    			ProposedObject proposedValue = new ProposedObject ();
+                            	proposedValue.setProposedClass(null);
+                            	proposedValue.setObject(null);
+                                tx.load( fieldEngine, fieldClassMolder, fields[i], proposedValue, suggestedAccessMode );
+                            }
                         } else if ( tx.isAutoStore() ) {
                             if ( o != null && !tx.isRecorded(o) )
                                 tx.markUpdate( fieldEngine, fieldClassMolder, o, null );
 
-                            if ( fields[i] != null )
-                                tx.load( fieldEngine, fieldClassMolder, fields[i], null, suggestedAccessMode );
+                            if ( fields[i] != null ) {
+                    			ProposedObject proposedValue = new ProposedObject ();
+                    			proposedValue.setProposedClass(null);
+                    			proposedValue.setObject(null);
+                                tx.load( fieldEngine, fieldClassMolder, fields[i], proposedValue, suggestedAccessMode );
+                            }
                         }
                         break;
 
@@ -1905,7 +2026,10 @@
                                         if ( !newSetOfIds.contains( v.get(j) ) ) {
                                             // load all the dependent object in cache for modification
                                             // check at commit time.
-                                            tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), null, suggestedAccessMode );
+                                			ProposedObject proposedValue = new ProposedObject ();
+                                			proposedValue.setProposedClass(null);
+                                			proposedValue.setObject(null);
+                                            tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), proposedValue, suggestedAccessMode );
 
                                         }
                                     }
@@ -1940,7 +2064,10 @@
                                     if ( !newSetOfIds.contains( v.get(j) ) ) {
                                         // load all the dependent object in cache for modification
                                         // check at commit time.
-                                        tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), null, suggestedAccessMode );
+                            			ProposedObject proposedValue = new ProposedObject ();
+                            			proposedValue.setProposedClass(null);
+                            			proposedValue.setObject(null);
+                                        tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), proposedValue, suggestedAccessMode );
                                     }
                                 }
                             }
@@ -1973,7 +2100,10 @@
                                     if ( !newSetOfIds.contains( v.get(j) ) ) {
                                         // load all the dependent object in cache for modification
                                         // check at commit time.
-                                        tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), null, suggestedAccessMode );
+                            			ProposedObject proposedValue = new ProposedObject ();
+                            			proposedValue.setProposedClass(null);
+                            			proposedValue.setObject(null);
+                                        tx.load( oid.getLockEngine(), fieldClassMolder, v.get(j), proposedValue, suggestedAccessMode );
                                     }
                                 }
                             }
@@ -2245,8 +2375,13 @@
                     if ( persistFields == null ) {
 
                         persistFields = new Object[extend._fhs.length];
+                        ProposedObject proposedObject = new ProposedObject();
+                        proposedObject.setProposedClass(null);
+                        proposedObject.setObject (null);
+                        proposedObject.setFields (persistFields);
                         extend._persistence.load( (Connection)tx.getConnection(extend._engine),
-                        persistFields, identity, AccessMode.ReadOnly );
+                        proposedObject, identity, AccessMode.ReadOnly );
+                        persistFields = proposedObject.getFields();
                     }
 
                     if ( extend._fhs[i].isMulti() ) {
@@ -3331,7 +3466,13 @@
 		if ( _log.isDebugEnabled() && _classMolder != null ) {
 			_log.debug("load object " + _classMolder.getName() + " with id " + _identity);
 		}
-		instance = _tx.load(_engine, _classMolder, _identity, _object, _accessMode);
+		ProposedObject proposedValue = new ProposedObject ();
+		
+		// TODO [WG]: using _object.getClass() is actually wrong !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+		
+		proposedValue.setProposedClass(_object.getClass());
+		proposedValue.setObject(_object);
+		instance = _tx.load(_engine, _classMolder, _identity, proposedValue, _accessMode);
 		hasMaterialized = true;
 		return instance;
 	}
Index: org/exolab/castor/persist/FieldMolder.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/FieldMolder.java,v
retrieving revision 1.7
diff -u -r1.7 FieldMolder.java
--- org/exolab/castor/persist/FieldMolder.java	4 Oct 2004 19:17:09 -0000	1.7
+++ org/exolab/castor/persist/FieldMolder.java	15 Mar 2005 13:36:00 -0000
@@ -352,6 +352,7 @@
             // Graceful way of dealing with unwrapping exception
             if ( value == null )
                 throw new DataObjectAccessException( Messages.format( "mapping.typeConversionNull", toString() ) );
+                // throw new DataObjectAccessException( Messages.format( "mapping.typeConversionNull", toString() ) );
             else
                 throw new DataObjectAccessException( Messages.format( "mapping.typeConversion",
                                                             toString(), value.getClass().getName() ) );
Index: org/exolab/castor/persist/LockEngine.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/LockEngine.java,v
retrieving revision 1.15
diff -u -r1.15 LockEngine.java
--- org/exolab/castor/persist/LockEngine.java	14 Dec 2004 13:59:32 -0000	1.15
+++ org/exolab/castor/persist/LockEngine.java	15 Mar 2005 13:36:01 -0000
@@ -320,13 +320,13 @@
      *  persistent capable
      * @throws ObjectDeletedWaitingForLockException The object has been deleted, but is waiting for a lock.
      */
-    public OID load( TransactionContext tx, OID oid, Object object, AccessMode suggestedAccessMode, int timeout )
+    public OID load( TransactionContext tx, OID oid, ProposedObject proposedObject, AccessMode suggestedAccessMode, int timeout )
             throws ObjectNotFoundException, LockNotGrantedException, PersistenceException,
             ClassNotPersistenceCapableException, ObjectDeletedWaitingForLockException {
-        return load( tx, oid, object, suggestedAccessMode, timeout, null );
+        return load( tx, oid, proposedObject, suggestedAccessMode, timeout, null );
     }
 
-    public OID load( TransactionContext tx, OID oid, Object object, AccessMode suggestedAccessMode, int timeout, QueryResults results )
+    public OID load( TransactionContext tx, OID oid, ProposedObject proposedObject, AccessMode suggestedAccessMode, int timeout, QueryResults results )
             throws ObjectNotFoundException, LockNotGrantedException, PersistenceException,
             ClassNotPersistenceCapableException, ObjectDeletedWaitingForLockException {
 
@@ -358,7 +358,16 @@
 
             lockedOid = lock.getOID();
 
-            Object stamp = typeInfo.molder.load( tx, lockedOid, lock, object, suggestedAccessMode, results );
+            Object stamp = typeInfo.molder.load( tx, lockedOid, lock, proposedObject, suggestedAccessMode, results );
+            
+            if (proposedObject.isExpanded()) {
+                _log.debug ("Looking at proposed object " + proposedObject);
+
+                _log.debug("Need to modify lock " + lock);
+                
+                // TODO [WG]: delete original lock, create a new one (HOW ?)
+            }
+            
             // proposal change: lockedOid parameter is not really neccesary.
             // we can added getOID() method in DepositBox. It make code a little
             // bit clear?
@@ -372,7 +381,11 @@
                 oid = lockedOid;
 
             if (_log.isDebugEnabled()) {
-            	_log.debug( Messages.format( "jdo.loading.with.id", typeInfo.molder.getName(), oid.getIdentity() ) );
+                if (proposedObject.isExpanded()) {
+                    _log.debug( Messages.format( "jdo.loading.with.id", proposedObject.getActualClass(), oid.getIdentity() ) );
+                } else {
+                    _log.debug( Messages.format( "jdo.loading.with.id", typeInfo.molder.getName(), oid.getIdentity() ) );
+                }
             }
         } catch ( ObjectDeletedWaitingForLockException except ) {
             // This is equivalent to object does not exist
Index: org/exolab/castor/persist/QueryResults.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/QueryResults.java,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 QueryResults.java
--- org/exolab/castor/persist/QueryResults.java	3 Mar 2003 07:08:47 -0000	1.1.1.1
+++ org/exolab/castor/persist/QueryResults.java	15 Mar 2005 13:36:01 -0000
@@ -48,6 +48,9 @@
 
 
 import javax.transaction.Status;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.exolab.castor.jdo.Database;
 import org.exolab.castor.jdo.TransactionNotInProgressException;
 import org.exolab.castor.jdo.PersistenceException;
@@ -70,7 +73,7 @@
 public final class QueryResults
 {
 
-    
+    private static final Log log = LogFactory.getLog (QueryResults.class); 
     /**
      * The transaction context in which this query was executed.
      */
@@ -215,7 +218,7 @@
         TransactionContext.ObjectEntry entry;
         OID              oid;
         ClassMolder     handler;
-        Object           object;
+        Object object = null;
         
         // Make sure transaction is still open.
         if ( _tx.getStatus() != Status.STATUS_ACTIVE )
@@ -223,11 +226,24 @@
         if ( _lastIdentity == null )
             throw new IllegalStateException( Messages.message( "jdo.fetchNoNextIdentity" ) );
 
-        handler = _engine.getClassMolder( _query.getResultType() );
+        Class resultType =  _query.getResultType();
+        log.debug("return type of OQL query = " + resultType.getName());
+        handler = _engine.getClassMolder(resultType);
 
         // load the object thur the transaction of the query
-        object = _tx.load( _engine, handler, _lastIdentity, null, _accessMode, this );
+		ProposedObject proposedValue = new ProposedObject ();
+		proposedValue.setProposedClass(resultType);
+		proposedValue.setObject(null);
+        log.debug ("About to load " + proposedValue);
+        object = _tx.load( _engine, handler, _lastIdentity, proposedValue, _accessMode, this );
+        log.debug ("Actually loaded " + proposedValue);
+        
+        if (proposedValue.isExpanded()) {
+            log.debug ("Proposed object = " + proposedValue);
+            object = proposedValue.getObject();
+        }
 
+        log.debug("Returning object " + object + " of type " + object.getClass().getName());
         return object;
 
     }
Index: org/exolab/castor/persist/RelationCollection.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/RelationCollection.java,v
retrieving revision 1.4
diff -u -r1.4 RelationCollection.java
--- org/exolab/castor/persist/RelationCollection.java	1 May 2004 08:45:31 -0000	1.4
+++ org/exolab/castor/persist/RelationCollection.java	15 Mar 2005 13:36:01 -0000
@@ -281,7 +281,10 @@
                 throw new RuntimeException("Transaction is closed!");
 
             try {
-                o = parent._tx.load( parent._engine, parent._molder, ids, null, null );
+    			ProposedObject proposedValue = new ProposedObject ();
+    			proposedValue.setProposedClass(null);
+    			proposedValue.setObject(null);
+                o = parent._tx.load( parent._engine, parent._molder, ids, proposedValue, null );
                 parent._loaded.put( ids, o );
                 return o;
             } catch ( LockNotGrantedException e ) {
Index: org/exolab/castor/persist/TransactionContext.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/TransactionContext.java,v
retrieving revision 1.16
diff -u -r1.16 TransactionContext.java
--- org/exolab/castor/persist/TransactionContext.java	5 Mar 2005 13:41:54 -0000	1.16
+++ org/exolab/castor/persist/TransactionContext.java	15 Mar 2005 13:36:03 -0000
@@ -598,10 +598,10 @@
      * @return object being loaded
      */
     public synchronized Object load( LockEngine engine, ClassMolder molder,
-                                     Object identity, Object objectToBeLoaded,
+                                     Object identity, ProposedObject proposedObject,
                                      AccessMode suggestedAccessMode )
             throws ObjectNotFoundException, LockNotGrantedException, PersistenceException {
-        return load( engine, molder, identity, objectToBeLoaded, suggestedAccessMode, null );
+        return load( engine, molder, identity, proposedObject, suggestedAccessMode, null );
     }
 
     /**
@@ -615,7 +615,7 @@
      * @param engine The persistence engine
      * @param molder The class persistence molder
      * @param identity The object's identity
-     * @param objectToBeLoaded The object to fetch (single instance per transaction)
+     * @param proposedObject The object to fetch (single instance per transaction)
      * @param suggestedAccessMode The access mode (see {@link AccessMode})
      *  the values in persistent storage
      * @param results The QueryResult that the data to be loaded from.
@@ -628,7 +628,7 @@
      * @return object being loaded
      */
     public synchronized Object load( LockEngine engine, ClassMolder molder,
-              Object identity, Object objectToBeLoaded, AccessMode suggestedAccessMode,
+              Object identity, ProposedObject proposedObject, AccessMode suggestedAccessMode,
               QueryResults results )
             throws ObjectNotFoundException, LockNotGrantedException, PersistenceException {
 
@@ -641,9 +641,9 @@
 
         oid = new OID( engine, molder, identity );
 
-        if ( objectToBeLoaded != null
-            && !molder.getJavaClass( _db.getClassLoader() ).isAssignableFrom( objectToBeLoaded.getClass() ) )
-            throw new PersistenceException( Messages.format("persist.typeMismatch", molder.getName(), objectToBeLoaded.getClass() ) );
+        if ( proposedObject.getObject() != null
+            && !molder.getJavaClass( _db.getClassLoader() ).isAssignableFrom( proposedObject.getProposedClass() ) )
+            throw new PersistenceException( Messages.format("persist.typeMismatch", molder.getName(), proposedObject.getProposedClass() ) );
         AccessMode accessMode = molder.getAccessMode( suggestedAccessMode );
         if ( accessMode == AccessMode.ReadOnly )
             entry = getReadOnlyObjectEntry( oid );
@@ -653,7 +653,7 @@
             // If the object has been loaded, but the instance sugguested to
             // be loaded into is not the same as the loaded instance,
             // error is reported.
-            if ( objectToBeLoaded != null && objectToBeLoaded != entry.object )
+            if ( proposedObject.getObject() != null && proposedObject != entry.object )
                 throw new PersistenceException( Messages.format("persist.multipleLoad", molder.getName(), identity ) );
             // If the object has been loaded in this transaction from a
             // different engine this is an error. If the object has been
@@ -677,28 +677,43 @@
             }
             return entry.object;
         }
-        // Load (or reload) the object through the persistence engine with the
-        // requested lock. This might report failure (object no longer exists),
-        // hold until a suitable lock is granted (or fail to grant), or
+        // Load (or reload, in case the object is stored in a acache) the object through the 
+        // persistence engine with the requested lock. This might report failure (object no 
+        // longer exists), hold until a suitable lock is granted (or fail to grant), or
         // report error with the persistence engine.
         try {
             // ssa, multi classloader feature
             // ssa, FIXME : No better way to do that ?
             //object = molder.newInstance();
-            if ( objectToBeLoaded != null )
-                object = objectToBeLoaded;
+            if ( proposedObject.getObject() != null )
+                object = proposedObject.getObject();
             else {
                 if ( _instanceFactory != null ) {
                     object = _instanceFactory.newInstance( molder.getName(), _db.getClassLoader() );
                 } else {
                     object = molder.newInstance( _db.getClassLoader() );
                 }
+                
+                proposedObject.setProposedClass(object.getClass());
+                proposedObject.setActualClass(object.getClass());
+                proposedObject.setObject(object);
+                
             }
             entry = addObjectEntry( oid, object );
-            oid = engine.load( this, oid, object, suggestedAccessMode, _lockTimeout, results );
-
-            // rehash the object entry, because oid might have changed!
-            entry = rehash( object, oid );
+            
+            // load object through LockEngine
+            oid = engine.load( this, oid, proposedObject, suggestedAccessMode, _lockTimeout, results );
+            if (proposedObject.isExpanded()) {
+                _log.debug ("Proposed object = " + proposedObject);
+                
+                removeObjectEntry (object);
+                entry = addObjectEntry (oid, proposedObject.getObject());
+                object = proposedObject.getObject();
+            } else {
+                
+                // rehash the object entry, because oid might have changed!
+                entry = rehash( object, oid );
+            }
 
         } catch ( ObjectNotFoundException except ) {
             removeObjectEntry( object );
Index: org/exolab/castor/persist/spi/Persistence.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/spi/Persistence.java,v
retrieving revision 1.2
diff -u -r1.2 Persistence.java
--- org/exolab/castor/persist/spi/Persistence.java	27 Sep 2004 20:21:02 -0000	1.2
+++ org/exolab/castor/persist/spi/Persistence.java	15 Mar 2005 13:36:03 -0000
@@ -47,7 +47,10 @@
 package org.exolab.castor.persist.spi;
 
 
+import java.util.List;
+
 import org.exolab.castor.mapping.AccessMode;
+import org.exolab.castor.mapping.TypeConvertor;
 import org.exolab.castor.jdo.DuplicateIdentityException;
 import org.exolab.castor.jdo.ObjectNotFoundException;
 import org.exolab.castor.jdo.ObjectDeletedException;
@@ -55,6 +58,7 @@
 import org.exolab.castor.jdo.PersistenceException;
 import org.exolab.castor.jdo.ObjectModifiedException;
 import org.exolab.castor.jdo.Database;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.persist.TransactionContext;
 
 
@@ -134,7 +138,7 @@
      *   persistent storage
      * @throws PersistenceException A persistence error occured
      */
-    public Object load( Object conn, Object[] fields, Object identity,
+    public Object load( Object conn, ProposedObject proposedObject, Object identity,
                         AccessMode accessMode )
         throws ObjectNotFoundException, PersistenceException;
 
@@ -224,16 +228,33 @@
     public PersistenceQuery createQuery( QueryExpression query, Class[] types, AccessMode accessMode )
         throws QueryException;
 
-
+    /**
+     * Returns ColumnInfos for identifiers.
+     * @return An array of FieldInfo instances.
+     */
+    public Persistence.ColumnInfo[] getColumnInfoForIdentities();
     
+    /**
+     * Returns FieldInfos for fields (exclusing identifiers).
+     * @return An array of ColumnInfo instances.
+     */
 	public Persistence.FieldInfo[] getInfo();
 
+    
     public interface FieldInfo {
 		public boolean isComplex();
 
 		public boolean isPersisted();
 
 		public String getFieldName();
+    }
+    
+    public interface ColumnInfo {
+        public String getName();
+        public int getSqlType();
+        public TypeConvertor getConvertTo();
+        public TypeConvertor getConvertFrom();
+        public String getConvertParam();
     }
 }
 
Index: org/exolab/castor/persist/spi/PersistenceQuery.java
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/persist/spi/PersistenceQuery.java,v
retrieving revision 1.2
diff -u -r1.2 PersistenceQuery.java
--- org/exolab/castor/persist/spi/PersistenceQuery.java	5 Mar 2005 13:41:55 -0000	1.2
+++ org/exolab/castor/persist/spi/PersistenceQuery.java	15 Mar 2005 13:36:03 -0000
@@ -48,6 +48,7 @@
 
 
 import org.exolab.castor.mapping.AccessMode;
+import org.exolab.castor.persist.ProposedObject;
 import org.exolab.castor.jdo.QueryException;
 import org.exolab.castor.jdo.PersistenceException;
 import org.exolab.castor.jdo.ObjectNotFoundException;
@@ -183,7 +184,7 @@
      * @throws PersistenceException A persistence error occured
      * @see Persistence#load
      */
-    public Object fetch( Object[] fields, Object identity )
+    public Object fetch( ProposedObject proposedObject, Object identity )
         throws ObjectNotFoundException, PersistenceException;
 
 
Index: org/exolab/castor/util/resources/messages.properties
===================================================================
RCS file: /scm/castor/castor/src/main/org/exolab/castor/util/resources/messages.properties,v
retrieving revision 1.24
diff -u -r1.24 messages.properties
--- org/exolab/castor/util/resources/messages.properties	13 Dec 2004 10:27:37 -0000	1.24
+++ org/exolab/castor/util/resources/messages.properties	15 Mar 2005 13:36:04 -0000
@@ -65,6 +65,10 @@
     use UserTransaction or container managed transactions instead
 jdo.loading=\
     Loading class: {0} using SQL: {1}
+jdo.loading.with.lock=\
+    Loading class: {0} using SQL: {1}
+jdo.finding=\
+    Fincing class: {0} using SQL: {1}
 jdo.loading.with.id=\
     Loading class: {0} with id: {1}
 jdo.creating=\
Index: org/exolab/castor/jdo/engine/CounterRef.java
===================================================================
RCS file: org/exolab/castor/jdo/engine/CounterRef.java
diff -N org/exolab/castor/jdo/engine/CounterRef.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ org/exolab/castor/jdo/engine/CounterRef.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,34 @@
+/**
+ * Created on 11.03.2005 at 15:42:46
+ *
+ * TODO Insert class description here
+ *
+ * @author werner.guttmann
+ *
+ * Copyright (c) Vector SW DV GmbH, 2005
+ */
+package org.exolab.castor.jdo.engine;
+
+/**
+ * @author werner.guttmann
+ *
+ * This is a type.
+ */
+public class CounterRef {
+
+    private int counter;
+    private String tableName;
+    
+    public String getTableName() {
+        return this.tableName;
+    }
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
+    }
+    public int getCounter() {
+        return this.counter;
+    }
+    public void setCounter(int counter) {
+        this.counter = counter;
+    }
+}
Index: org/exolab/castor/persist/ProposedObject.java
===================================================================
RCS file: org/exolab/castor/persist/ProposedObject.java
diff -N org/exolab/castor/persist/ProposedObject.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ org/exolab/castor/persist/ProposedObject.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,110 @@
+/*
+ * Created on 25.02.2005
+ *
+ * To change the template for this generated file go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+package org.exolab.castor.persist;
+
+/**
+ * @author Administrator
+ *
+ * To change the template for this generated type comment go to
+ * Window - Preferences - Java - Code Generation - Code and Comments
+ */
+public class ProposedObject {
+
+	private Class proposedClass;
+	private Class actualClass;
+	private Object object;
+	private Object[] fields;
+	
+	boolean isExpanded = false;
+	
+	/**
+	 * @return Returns the fields.
+	 */
+	public Object[] getFields() {
+		return fields;
+	}
+	/**
+	 * @param fields The fields to set.
+	 */
+	public void setFields(Object[] fields) {
+		this.fields = fields;
+	}
+	/**
+	 * @return Returns the object.
+	 */
+	public Object getObject() {
+		return object;
+	}
+	/**
+	 * @param object The object to set.
+	 */
+	public void setObject(Object object) {
+		this.object = object;
+	}
+	/**
+	 * @return Returns the proposedClass.
+	 */
+	public Class getProposedClass() {
+		return proposedClass;
+	}
+	/**
+	 * @param proposedClass The proposedClass to set.
+	 */
+	public void setProposedClass(Class proposedClass) {
+		this.proposedClass = proposedClass;
+	}
+	/**
+	 * 
+	 */
+	public ProposedObject() {
+		super();
+	}
+
+	/**
+	 * @return Returns the isExpanded.
+	 */
+	public boolean isExpanded() {
+		return isExpanded;
+	}
+	/**
+	 * @param isExpanded The isExpanded to set.
+	 */
+	public void setExpanded(boolean isExpanded) {
+		this.isExpanded = isExpanded;
+	}
+	/**
+	 * @return Returns the actualClass.
+	 */
+	public Class getActualClass() {
+		return actualClass;
+	}
+	/**
+	 * @param actualClass The actualClass to set.
+	 */
+	public void setActualClass(Class actualClass) {
+		this.actualClass = actualClass;
+	}
+	
+	
+	/* (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	public String toString() {
+		StringBuffer buffer = new StringBuffer();
+		buffer.append ("<");
+		buffer.append ("proposedClass=" + proposedClass);
+		buffer.append ("; actualClass=" + actualClass);
+		buffer.append ("; object=" + object + "; ");
+		if (fields != null) {
+			for (int i = 0; i < fields.length; i++) {
+				buffer.append("fields[" + i + "]='" + fields[i] + "':"); 
+			}
+		}
+		buffer.append (">");
+		return buffer.toString();
+	}
+}