From 231929993098e1d5b406ace02de03482a2a91180 Mon Sep 17 00:00:00 2001
From: ailitchev <andrei.ilitchev@oracle.com>
Date: Wed, 6 Feb 2013 17:39:09 -0500
Subject: [PATCH] Some improvements for ResultSetOptimizedQuery (part of old
 bug 298985): now works with descriptor with multiple tables
 and handles reference mappings, too. Still to be done -
 proper cloning and registering all the objects.

---
 .../internal/databaseaccess/DatabaseAccessor.java  | 12 +++++
 .../internal/descriptors/ObjectBuilder.java        | 54 +++++++++++++++++++---
 .../mappings/foundation/AbstractDirectMapping.java | 43 +++++++++++++++--
 .../persistence/queries/ObjectLevelReadQuery.java  |  5 +-
 .../eclipse/persistence/queries/ReadAllQuery.java  |  4 +-
 .../persistence/queries/ReadObjectQuery.java       |  2 +-
 6 files changed, 105 insertions(+), 15 deletions(-)

diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseAccessor.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseAccessor.java
index ef37e18..d27d0de 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseAccessor.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseAccessor.java
@@ -1076,6 +1076,18 @@ public class DatabaseAccessor extends DatasourceAccessor {
         // Row creation is optimized through sharing the same fields for the entire result set.
         return new ArrayRecord(fields, fieldsArray, values);
     }
+    public void populateRow(DatabaseField[] fieldsArray, Object[] values, ResultSet resultSet, ResultSetMetaData metaData, AbstractSession session, int startIndex, int endIndex) throws DatabaseException {
+        // PERF: Pass platform and optimize data flag.
+        DatabasePlatform platform = getPlatform();
+        boolean optimizeData = platform.shouldOptimizeDataConversion();
+        for (int index = startIndex; index < endIndex; index++) {
+            DatabaseField field = fieldsArray[index];
+            // Field can be null for fetch groups.
+            if (field != null) {
+                values[index] = getObject(resultSet, field, metaData, index + 1, platform, optimizeData, session);
+            }
+        }
+    }
 
     /**
      * INTERNAL:
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java
index 16d5c86..eac1124 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java
@@ -1904,19 +1904,33 @@ public class ObjectBuilder extends CoreObjectBuilder<AbstractRecord, AbstractSes
      * so can avoid many of the normal checks, only queries that have this criteria
      * can use this method of building objects.
      */
-    public Object buildObjectFromResultSet(ObjectBuildingQuery query, JoinedAttributeManager joinManager, ResultSet resultSet, AbstractSession executionSession, DatabaseAccessor accessor, ResultSetMetaData metaData, DatabasePlatform platform) throws SQLException {
+    public Object buildObjectFromResultSet(ObjectBuildingQuery query, JoinedAttributeManager joinManager, ResultSet resultSet, AbstractSession executionSession, DatabaseAccessor accessor, ResultSetMetaData metaData, DatabasePlatform platform, Vector fieldsList, DatabaseField[] fieldsArray) throws SQLException {
         ClassDescriptor descriptor = this.descriptor;
-        DatabaseMapping primaryKeyMapping = this.primaryKeyMappings.get(0);
-        Object primaryKey = primaryKeyMapping.valueFromResultSet(resultSet, query, executionSession, accessor, metaData, 1, platform);
+        int pkFieldsSize = descriptor.getPrimaryKeyFields().size();
+        DatabaseMapping primaryKeyMapping = null;
+        AbstractRecord row = null;
+        Object[] values = null;
+        Object primaryKey;
+        if (isSimple && pkFieldsSize == 1) {
+            primaryKeyMapping = this.primaryKeyMappings.get(0);
+            primaryKey = primaryKeyMapping.valueFromResultSet(resultSet, query, executionSession, accessor, metaData, 1, platform);
+        } else {
+            values = new Object[fieldsArray.length];
+            row = new ArrayRecord(fieldsList, fieldsArray, values);
+            accessor.populateRow(fieldsArray, values, resultSet, metaData, executionSession, 0, pkFieldsSize);
+            primaryKey = extractPrimaryKeyFromRow(row, executionSession);
+        }
 
         UnitOfWorkImpl unitOfWork = null;
         AbstractSession session = executionSession;
         boolean isolated = !descriptor.getCachePolicy().isSharedIsolation();
         if (session.isUnitOfWork()) {
             unitOfWork = (UnitOfWorkImpl)executionSession;
+            isolated |= unitOfWork.wasTransactionBegunPrematurely() && descriptor.shouldIsolateObjectsInUnitOfWorkEarlyTransaction();
         }
         
         CacheKey cacheKey = session.getIdentityMapAccessorInstance().getIdentityMapManager().acquireLock(primaryKey, descriptor.getJavaClass(), false, descriptor, query.isCacheCheckComplete());
+        CacheKey cacheKeyToUse = cacheKey;
         CacheKey parentCacheKey = null;
         Object object = cacheKey.getObject();
         try {
@@ -1928,6 +1942,7 @@ public class ObjectBuilder extends CoreObjectBuilder<AbstractRecord, AbstractSes
                 // Need to lookup in the session.
                 session = unitOfWork.getParentIdentityMapSession(query);
                 parentCacheKey = session.getIdentityMapAccessorInstance().getIdentityMapManager().acquireLock(primaryKey, descriptor.getJavaClass(), false, descriptor, query.isCacheCheckComplete());
+                cacheKeyToUse = parentCacheKey;
                 object = parentCacheKey.getObject();
             }
             // If the object is not in the cache, it needs to be built, this is building in the unit of work if isolated.
@@ -1944,12 +1959,34 @@ public class ObjectBuilder extends CoreObjectBuilder<AbstractRecord, AbstractSes
                     }
                 }
                 
-                primaryKeyMapping.setAttributeValueInObject(object, primaryKey);
                 List mappings = descriptor.getMappings();            
                 int size = mappings.size();
-                for (int index = 1; index < size; index++) {
-                    DatabaseMapping mapping = (DatabaseMapping)mappings.get(index);
-                    mapping.readFromResultSetIntoObject(resultSet, object, query, session, accessor, metaData, index + 1, platform);
+                
+                if (isSimple) {
+                    int shift = descriptor.getTables().size() * pkFieldsSize;
+                    if (primaryKeyMapping != null) {
+                        // simple primary key - set pk directly through the mapping
+                        primaryKeyMapping.setAttributeValueInObject(object, primaryKey);
+                    } else {
+                        // composite primary key - set pk using pkRow
+                        boolean isTargetProtected = session.isProtectedSession();
+                        for (int index = 0; index < pkFieldsSize; index++) {
+                            DatabaseMapping mapping = (DatabaseMapping)mappings.get(index);
+                            mapping.readFromRowIntoObject(row, joinManager, object, cacheKeyToUse, query, session, isTargetProtected);
+                        }
+                    }
+                    // set the rest using mappings directly
+                    for (int index = pkFieldsSize; index < size; index++) {
+                        DatabaseMapping mapping = (DatabaseMapping)mappings.get(index);
+                        mapping.readFromResultSetIntoObject(resultSet, object, query, session, accessor, metaData, index + shift, platform);
+                    }
+                } else {
+                    boolean isTargetProtected = session.isProtectedSession();
+                    accessor.populateRow(fieldsArray, values, resultSet, metaData, session, pkFieldsSize, fieldsArray.length);
+                    for (int index = 0; index < size; index++) {
+                        DatabaseMapping mapping = (DatabaseMapping)mappings.get(index);
+                        mapping.readFromRowIntoObject(row, joinManager, object, cacheKeyToUse, query, session, isTargetProtected);
+                    }
                 }
                 
                 ((PersistenceEntity)object)._persistence_setId(primaryKey);
@@ -1960,6 +1997,9 @@ public class ObjectBuilder extends CoreObjectBuilder<AbstractRecord, AbstractSes
             }
             if ((unitOfWork != null) && !isolated) {
                 // Need to clone the object in the unit of work.
+                // TODO: Doesn't work all the time
+                // With one setup (jpa2.performance tests) produces a shallow clone (which is good enough for isSimple==true case only),
+                // in other (jpa.advanced tests) - just a brand new empty object.
                 Object clone = instantiateWorkingCopyClone(object, unitOfWork);
                 ((PersistenceEntity)clone)._persistence_setId(cacheKey.getKey());
                 unitOfWork.getCloneMapping().put(clone, clone);
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/foundation/AbstractDirectMapping.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/foundation/AbstractDirectMapping.java
index ea2c1ee..99a7255 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/foundation/AbstractDirectMapping.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/foundation/AbstractDirectMapping.java
@@ -633,6 +633,40 @@ public abstract class AbstractDirectMapping extends AbstractColumnMapping implem
 
     /**
      * INTERNAL:
+     * Same as getObjectValue method, but without checking fieldValue's class.
+     * Used in case the fieldValue class is already known to be the same as attributeClassification.
+     */
+    public Object getObjectValueWithoutClassCheck(Object fieldValue, Session session) {
+        if ((fieldValue == null) && (this.nullValue != null)) {// Translate default null value
+            return this.nullValue;
+        }
+        // PERF: Direct variable access.
+        Object attributeValue = fieldValue;
+
+        // Allow for user defined conversion to the object value.
+        if (this.converter != null) {
+            attributeValue = this.converter.convertDataValueToObjectValue(attributeValue, session);
+        } else {
+            // PERF: Avoid conversion check when not required.
+            if (attributeValue == null) {
+                if (!this.bypassDefaultNullValueCheck) {                    
+                    try {
+                        attributeValue = session.getDatasourcePlatform().convertObject(null, this.attributeClassification);
+                    } catch (ConversionException e) {
+                        throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
+                    }
+                }
+            }
+        }
+        if (attributeValue == null) {// Translate default null value, conversion may have produced null.
+            attributeValue = this.nullValue;
+        }
+
+        return attributeValue;
+    }
+
+    /**
+     * INTERNAL:
      */
     @Override
     public boolean isAbstractDirectMapping() {
@@ -1191,13 +1225,14 @@ public abstract class AbstractDirectMapping extends AbstractColumnMapping implem
     @Override
     public Object valueFromResultSet(ResultSet resultSet, ObjectBuildingQuery query, AbstractSession session, DatabaseAccessor accessor, ResultSetMetaData metaData, int columnNumber, DatabasePlatform platform) throws SQLException {
         if (this.attributeObjectClassification == ClassConstants.STRING) {
-            return resultSet.getString(columnNumber);
+            return getObjectValueWithoutClassCheck(resultSet.getString(columnNumber), session);
         } else if (this.attributeObjectClassification == ClassConstants.LONG) {
-            return resultSet.getLong(columnNumber);
+            return getObjectValueWithoutClassCheck(resultSet.getLong(columnNumber), session);
         } else if (this.attributeObjectClassification == ClassConstants.INTEGER) {
-            return resultSet.getInt(columnNumber);
+            return getObjectValueWithoutClassCheck(resultSet.getInt(columnNumber), session);
         }
-        return accessor.getObject(resultSet, getField(), metaData, columnNumber, platform, true, session);
+        Object fieldValue = accessor.getObject(resultSet, getField(), metaData, columnNumber, platform, true, session);
+        return getObjectValue(fieldValue, session);
     }
 
     protected abstract void writeValueIntoRow(AbstractRecord row, DatabaseField field, Object value);
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java
index d39b9e4..3c508ec 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java
@@ -2715,7 +2715,10 @@ public abstract class ObjectLevelReadQuery extends ObjectBuildingQuery {
      * singleton primary key, direct mapped, simple type, no inheritance, uow isolated objects.
      */
     public void setIsResultSetOptimizedQuery(boolean isResultSetOptimizedQuery) {
-        this.isResultSetOptimizedQuery = isResultSetOptimizedQuery;
+        if (this.isResultSetOptimizedQuery != isResultSetOptimizedQuery) {
+            setIsPrepared(false);
+            this.isResultSetOptimizedQuery = isResultSetOptimizedQuery;
+        }
     }
     
     /**
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadAllQuery.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadAllQuery.java
index 4d34b3b..fcd999d 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadAllQuery.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadAllQuery.java
@@ -479,14 +479,14 @@ public class ReadAllQuery extends ObjectLevelReadQuery {
         call = this.queryMechanism.cursorSelectAllRows();
         Statement statement = call.getStatement();
         ResultSet resultSet = call.getResult();
-        DatabaseAccessor accessor = (DatabaseAccessor)((List<Accessor>)this.accessors).get(0);
+        DatabaseAccessor accessor = (DatabaseAccessor)getAccessor();
         boolean exceptionOccured = false;
         try {
             ResultSetMetaData metaData = resultSet.getMetaData();
             List results = new ArrayList();
             ObjectBuilder builder = this.descriptor.getObjectBuilder();
             while (resultSet.next()) {
-                results.add(builder.buildObjectFromResultSet(this, this.joinedAttributeManager, resultSet, session, accessor, metaData, platform));
+                results.add(builder.buildObjectFromResultSet(this, this.joinedAttributeManager, resultSet, session, accessor, metaData, platform, call.getFields(), call.getFieldsArray()));
             }
             return results;
         } catch (SQLException exception) {
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java
index b1fdcd6..f56b329 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java
@@ -505,7 +505,7 @@ public class ReadObjectQuery extends ObjectLevelReadQuery {
                 return null;
             }
             ResultSetMetaData metaData = resultSet.getMetaData();
-            return this.descriptor.getObjectBuilder().buildObjectFromResultSet(this, null, resultSet, session, accessor, metaData, platform);
+            return this.descriptor.getObjectBuilder().buildObjectFromResultSet(this, null, resultSet, session, accessor, metaData, platform, call.getFields(), call.getFieldsArray());
         } catch (SQLException exception) {
             exceptionOccured = true;
             DatabaseException commException = accessor.processExceptionForCommError(session, exception, call);
-- 
1.7.11.msysgit.1