Attachment #175854 for bug #321763

View | Details | Raw Unified | Return to bug 321763
Collapse All | Expand All

Lines 45-51 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/tools/sessionconsole/ProfileBrowser.java (-2 / +2 lines)
45	* PUBLIC:	45	* PUBLIC:
46	* Open a browser on the profiles.	46	* Open a browser on the profiles.
47	*/	47	*/
48	public static void browseProfiles(Vector profiles) {	48	public static void browseProfiles(List<Profile> profiles) {
49	try {	49	try {
50	UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());	50	UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
51	ProfileBrowser aProfileBrowserFrame;	51	ProfileBrowser aProfileBrowserFrame;
Lines 171-177 Link Here
171	// user code end	171	// user code end
172	}	172	}
173		173
174	public void setProfiles(Vector profiles) {	174	public void setProfiles(List<Profile> profiles) {
175	getProfileBrowserPanel().setProfiles(profiles);	175	getProfileBrowserPanel().setProfiles(profiles);
176	}	176	}
177	}	177	}




package org.eclipse.persistence.tools.sessionconsole;

import java.util.*;

import javax.swing.*;
import javax.swing.table.*;


 * This panel allows for the browsing of performance profiles.
 */
public class ProfileBrowserPanel extends JPanel {
    private List<Profile> fieldProfiles = new ArrayList();
    private JScrollPane ivjProfileScrollPane = null;
    private JTable ivjProfilesTable = null;
    private JComboBox ivjGroupByChoice = null;

    public Vector buildProfileSummaryByClass() {
        Hashtable summaries = new Hashtable();

        for (Profile profile : getProfiles()) {
             enumtr.hasMoreElements(); ) {
            Profile profile = (Profile)enumtr.nextElement();
            Class domainClass = profile.getDomainClass();
            if (domainClass == null) {
                domainClass = Void.class;

    public Vector buildProfileSummaryByQuery() {
        Hashtable summaries = new Hashtable();

        for (Profile profile : getProfiles()) {
             enumtr.hasMoreElements(); ) {
            Profile profile = (Profile)enumtr.nextElement();
            Class queryType = profile.getQueryClass();
            //CR 3050 PWK - If we don't know the query class, we need to use void.
            //This avoids a null pointer exception when adding to the hashtable.

    public Vector buildProfileSummaryByQueryAndClass() {
        Hashtable summaries = new Hashtable();

        for (Profile profile : getProfiles()) {
             enumtr.hasMoreElements(); ) {
            Profile profile = (Profile)enumtr.nextElement();
            Class queryType = profile.getQueryClass();
            Class queryClass = profile.getDomainClass();
            if (queryClass == null) {

        return ivjGroupByLabel;
    }

    public List<Profile> getProfiles() {
     * Gets the profiles property (java.util.Vector) value.
     * @return The profiles property value.
     * @see #setProfiles
     */
    public java.util.Vector getProfiles() {
        return fieldProfiles;
    }


        columns.addElement("SQL Generation");
        model.setColumnIdentifiers(columns);

        List<Profile> profiles = getProfiles();
        if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Query")) {
            profiles = buildProfileSummaryByQuery();
        } else if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Class")) {

            profiles = buildProfileSummaryByQueryAndClass();
        }

        for (Profile profile : profiles) {
             profileEnum.hasMoreElements(); ) {
            Profile profile = (Profile)profileEnum.nextElement();

            String items[] = new String[13];
            if (profile.getQueryClass() == null) {
                items[0] = "";

            items[4] = 
                    new Long(profile.getNumberOfInstancesEffected()).toString();
            items[5] = new Long(profile.getObjectsPerSecond()).toString();
            if (profile.getOperationTimings().containsKey(SessionProfiler.SqlPrepare)) {
                items[6] = 
                        profile.getOperationTimings().get(SessionProfiler.SqlPrepare).toString();
            } else {
                items[6] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.StatementExecute)) {
                items[7] = 
                        profile.getOperationTimings().get(SessionProfiler.StatementExecute).toString();
            } else {
                items[7] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.RowFetch)) {
                items[8] = 
                        profile.getOperationTimings().get(SessionProfiler.RowFetch).toString();
            } else {
                items[8] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.Caching)) {
                items[9] = 
                        profile.getOperationTimings().get(SessionProfiler.Caching).toString();
            } else {
                items[9] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.ObjectBuilding)) {
                items[10] = 
                        profile.getOperationTimings().get(SessionProfiler.ObjectBuilding).toString();
            } else {
                items[10] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.QueryPreparation)) {
                items[11] = 
                        profile.getOperationTimings().get(SessionProfiler.QueryPreparation).toString();
            } else {
                items[11] = "";
            }
            if (profile.getOperationTimings().containsKey(SessionProfiler.SqlGeneration)) {
                items[12] = 
                        profile.getOperationTimings().get(SessionProfiler.SqlGeneration).toString();
            } else {
                items[12] = "";
            }

     * @param profiles The new value for the property.
     * @see #getProfiles
     */
    public void setProfiles(List<Profile> profiles) {
        List<Profile> oldValue = fieldProfiles;
        fieldProfiles = profiles;
        firePropertyChange("profiles", oldValue, profiles);


Lines 29-34 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/ProfilerType.java (+1 lines)
29	//A tool used to provide high level performance profiling information	29	//A tool used to provide high level performance profiling information
30	public static final String PerformanceProfiler = "PerformanceProfiler";	30	public static final String PerformanceProfiler = "PerformanceProfiler";
31	public static final String QueryMonitor = "QueryMonitor";	31	public static final String QueryMonitor = "QueryMonitor";
		32	public static final String PerformanceMonitor = "PerformanceMonitor";
32	public static final String NoProfiler = "NoProfiler";	33	public static final String NoProfiler = "NoProfiler";
33		34
34	public static final String DEFAULT = NoProfiler;	35	public static final String DEFAULT = NoProfiler;

Lines 819-824 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorQueryManager.java (+1 lines)
819	readObjectQuery.setSelectionCriteria(getDescriptor().getObjectBuilder().getPrimaryKeyExpression());	819	readObjectQuery.setSelectionCriteria(getDescriptor().getObjectBuilder().getPrimaryKeyExpression());
820	setReadObjectQuery(readObjectQuery);	820	setReadObjectQuery(readObjectQuery);
821	}	821	}
		822	getReadObjectQuery().setName("readObject");
822		823
823	if (!hasInsertQuery()) {	824	if (!hasInsertQuery()) {
824	// Prepare insert query always.	825	// Prepare insert query always.




                session.log(SessionLog.FINE, SessionLog.SQL, call.getLogString(this), (Object[])null, this, false);
            }
            incrementCallCount(session);
            session.startOperationProfile(SessionProfiler.SqlPrepare, eisCall.getQuery(), SessionProfiler.ALL);
            Record input = null;
            Record output = null;
            try {

                input = getEISPlatform().createInputRecord(eisCall, this);
                output = getEISPlatform().createOutputRecord(eisCall, this);
            } finally {
                session.endOperationProfile(SessionProfiler.SqlPrepare, eisCall.getQuery(), SessionProfiler.ALL);
            }
            session.startOperationProfile(SessionProfiler.StatementExecute, eisCall.getQuery(), SessionProfiler.ALL);
            try {
                InteractionSpec interactionSpec = getEISPlatform().buildInteractionSpec(eisCall);
                if (output == null) {

                }
                session.log(SessionLog.FINEST, SessionLog.QUERY, "data_access_result", output);
            } finally {
                session.endOperationProfile(SessionProfiler.StatementExecute, eisCall.getQuery(), SessionProfiler.ALL);
            }
        } catch (ResourceException exception) {
            // Ensure each resource is released, but still ensure that the real exception is thrown.





        DatabaseQuery query = ((call == null)? null : call.getQuery());
        try {
            session.startOperationProfile(SessionProfiler.StatementExecute, query, SessionProfiler.ALL);
            statement.close();
        } finally {
            session.endOperationProfile(SessionProfiler.StatementExecute, query, SessionProfiler.ALL);
            decrementCallCount();
            // If this is the cached dynamic statement, release it.
            if (statement == this.dynamicStatement) {

            if (session.shouldLog(SessionLog.FINE, SessionLog.SQL)) {// Avoid printing if no logging required.
                session.log(SessionLog.FINE, SessionLog.SQL, dbCall.getLogString(this), (Object[])null, this, false);
            }
            session.startOperationProfile(SessionProfiler.SqlPrepare, dbCall.getQuery(), SessionProfiler.ALL);
            try {
                statement = dbCall.prepareStatement(this, translationRow, session);
            } finally {
                session.endOperationProfile(SessionProfiler.SqlPrepare, dbCall.getQuery(), SessionProfiler.ALL);
            }

            // effectively this means that someone is executing an update type query.

                    return dbCall;
                }

                session.startOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
                try {
                    if (dbCall.isOneRowReturned()) {
                        if (resultSet.next()) {

                    }
                    resultSet.close();// This must be closed in case the statement is cached and not closed.
                } finally {
                    session.endOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
                }
            }
            // Log any warnings on finest.

        final ThreadCursoredList results = new ThreadCursoredList(20);
        Thread thread = new Thread() {
            public void run() {
                session.startOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
                try {
                    // Initial next was already validated before this method is called.
                    boolean hasNext = true;

                    }
                    results.throwException(exception);
                } finally {
                    session.endOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
                }

                // This is in a separate try block to ensure that the real exception is not masked by the close exception.


        try {
            if (call != null) {
                session.startOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
            } else {
                session.startOperationProfile(SessionProfiler.StatementExecute, null, SessionProfiler.ALL);                
            }
            if ((call != null) && call.isDynamicCall(session)) {
                rowCount = statement.executeUpdate(call.getSQLString());

            }
        } finally {
            if (call != null) {
                session.endOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
            } else {
                session.endOperationProfile(SessionProfiler.StatementExecute, null, SessionProfiler.ALL);                
            }
        }


    public ResultSet executeSelect(DatabaseCall call, Statement statement, AbstractSession session) throws SQLException {
        ResultSet resultSet;

        session.startOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
        try {
            if (call.isDynamicCall(session)) {
                resultSet = statement.executeQuery(call.getSQLString());

                resultSet = ((PreparedStatement)statement).executeQuery();
            }
        } finally {
            session.endOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
        }

        // Allow for procs with outputs to be raised as events for error handling.

Lines 1433-1439 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabasePlatform.java (-2 / +2 lines)
1433	Object result = null;	1433	Object result = null;
1434	ResultSetMetaData metaData = resultSet.getMetaData();	1434	ResultSetMetaData metaData = resultSet.getMetaData();
1435		1435
1436	session.startOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	1436	session.startOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
1437	try {	1437	try {
1438	if (dbCall.isOneRowReturned()) {	1438	if (dbCall.isOneRowReturned()) {
1439	if (resultSet.next()) {	1439	if (resultSet.next()) {
Lines 1456-1462 Link Here
1456	}	1456	}
1457	resultSet.close();// This must be closed incase the statement is cached and not closed.	1457	resultSet.close();// This must be closed incase the statement is cached and not closed.
1458	} finally {	1458	} finally {
1459	session.endOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	1459	session.endOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
1460	}	1460	}
1461	return result;	1461	return result;
1462	}	1462	}




        session.log(SessionLog.FINER, SessionLog.TRANSACTION, "begin_transaction", (Object[])null, this);

        try {
            session.startOperationProfile(SessionProfiler.Transaction);
            incrementCallCount(session);
            basicBeginTransaction(session);
            this.isInTransaction = true;
        } finally {
            decrementCallCount();
            session.endOperationProfile(SessionProfiler.Transaction);
        }
    }


        session.log(SessionLog.FINER, SessionLog.TRANSACTION, "commit_transaction", (Object[])null, this);

        try {
            session.startOperationProfile(SessionProfiler.Transaction);
            incrementCallCount(session);
            basicCommitTransaction(session);


        } finally {
            sequencingCallback = null;
            decrementCallCount();
            session.endOperationProfile(SessionProfiler.Transaction);
        }
    }


     * Catch exceptions and re-throw as EclipseLink exceptions.
     */
    public void connect(Login login, AbstractSession session) throws DatabaseException {
        session.startOperationProfile(SessionProfiler.ConnectionManagement);
        session.incrementProfile(SessionProfiler.Connects);

        try {
            if (session.shouldLog(SessionLog.CONFIG, SessionLog.CONNECTION)) {// Avoid printing if no logging required.

                decrementCallCount();
            }
        } finally {
            session.endOperationProfile(SessionProfiler.ConnectionManagement);
        }
    }


        if (this.datasourceConnection == null) {
            return;
        }
        session.incrementProfile(SessionProfiler.Disconnects);
        session.startOperationProfile(SessionProfiler.ConnectionManagement);
        try {
            releaseCustomizer();
            closeDatasourceConnection();
            this.datasourceConnection = null;
            this.isInTransaction = true;
        } finally {
            session.endOperationProfile(SessionProfiler.ConnectionManagement);
        }
    }

    /**

     */
    protected void reconnect(AbstractSession session) throws DatabaseException {
        session.log(SessionLog.FINEST, SessionLog.CONNECTION, "reconnecting_to_external_connection_pool");
        session.startOperationProfile(SessionProfiler.ConnectionManagement);
        try {
            connectInternal(this.login, session);
        } finally {
            session.endOperationProfile(SessionProfiler.ConnectionManagement);
        }
    }

    /**

        session.log(SessionLog.FINER, SessionLog.TRANSACTION, "rollback_transaction", (Object[])null, this);

        try {
            session.startOperationProfile(SessionProfiler.Transaction);
            incrementCallCount(session);
            basicRollbackTransaction(session);
        } finally {
            this.isInTransaction = false;
            sequencingCallback = null;
            decrementCallCount();
            session.endOperationProfile(SessionProfiler.Transaction);
        }
    }





        writer.write(platform.getBatchEndString());

        try {
            session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
            try {
                statement = this.databaseAccessor.getConnection().prepareStatement(writer.toString());
            } finally {
                session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
            }
        } catch (SQLException exception) {
            //If this is a connection from an external pool then closeStatement will close the connection.

        Statement statement = null;

        try {
            session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
            try {
                statement = this.databaseAccessor.getConnection().createStatement();
                for (Iterator sqlStringsIterator = this.sqlStrings.iterator();

                	statement.setQueryTimeout(queryTimeoutCache);
                }
            } finally {
                session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
            }
        } catch (SQLException exception) {
            //If this is a connection from an external pool then closeStatement will close the connection.

Lines 166-172 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/ParameterizedSQLBatchWritingMechanism.java (-2 / +2 lines)
166	PreparedStatement statement = null;	166	PreparedStatement statement = null;
167		167
168	try {	168	try {
169	session.startOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	169	session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
170	try {	170	try {
171	boolean shouldUnwrapConnection = session.getPlatform().usesNativeBatchWriting();	171	boolean shouldUnwrapConnection = session.getPlatform().usesNativeBatchWriting();
172	statement = (PreparedStatement)this.databaseAccessor.prepareStatement(this.previousCall, session, shouldUnwrapConnection);	172	statement = (PreparedStatement)this.databaseAccessor.prepareStatement(this.previousCall, session, shouldUnwrapConnection);
Lines 191-197 Link Here
191	executionCount += this.databaseAccessor.getPlatform().addBatch(statement);	191	executionCount += this.databaseAccessor.getPlatform().addBatch(statement);
192	}	192	}
193	} finally {	193	} finally {
194	session.endOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	194	session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
195	}	195	}
196	} catch (SQLException exception) {	196	} catch (SQLException exception) {
197	// If this is a connection from an external pool then closeStatement will close the connection.	197	// If this is a connection from an external pool then closeStatement will close the connection.




    public Object buildObject(ObjectBuildingQuery query, AbstractRecord databaseRow, JoinedAttributeManager joinManager) throws DatabaseException, QueryException {
        // Profile object building.
        AbstractSession session = query.getSession();
        session.startOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);

        Object primaryKey = extractPrimaryKeyFromRow(databaseRow, session);

        // Check for null primary key, this is not allowed.
        if ((primaryKey == null) && (!query.hasPartialAttributeExpressions()) && (!this.descriptor.isAggregateCollectionDescriptor())) {
            // Profile object building.
            session.endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);

            //BUG 3168689: EJBQL: "Select Distinct s.customer from SpouseBean s"
            //BUG 3168699: EJBQL: "Select s.customer from SpouseBean s where s.id = '6'"
            //If we return either a single null, or a Collection containing at least 
            //one null, then we want the nulls returned/included if the indicated 
            //property is set in the query. (As opposed to throwing an Exception).
            if (query.shouldBuildNullForNullPk()) {
                return null;
            } else {
                throw QueryException.nullPrimaryKeyInBuildingObject(query, databaseRow);
            }
        }
        ClassDescriptor concreteDescriptor = this.descriptor;
        if (concreteDescriptor.hasInheritance() && concreteDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
            Class classValue = concreteDescriptor.getInheritancePolicy().classFromRow(databaseRow, session);
            concreteDescriptor = concreteDescriptor.getInheritancePolicy().getDescriptor(classValue);
            if ((concreteDescriptor == null) && query.hasPartialAttributeExpressions()) {
                concreteDescriptor = this.descriptor;
            }
            if (concreteDescriptor == null) {
                // Profile object building.
                session.endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);
                throw QueryException.noDescriptorForClassFromInheritancePolicy(query, classValue);
            }
        }
        Object domainObject = null;
        try {
            Object primaryKey = extractPrimaryKeyFromRow(databaseRow, session);
            // Check for null primary key, this is not allowed.
            if ((primaryKey == null) && (!query.hasPartialAttributeExpressions()) && (!this.descriptor.isAggregateCollectionDescriptor())) {
                //BUG 3168689: EJBQL: "Select Distinct s.customer from SpouseBean s"
                //BUG 3168699: EJBQL: "Select s.customer from SpouseBean s where s.id = '6'"
                //If we return either a single null, or a Collection containing at least 
                //one null, then we want the nulls returned/included if the indicated 
                //property is set in the query. (As opposed to throwing an Exception).
                if (query.shouldBuildNullForNullPk()) {
                    return null;
                } else {
                    throw QueryException.nullPrimaryKeyInBuildingObject(query, databaseRow);
                }
            }
            ClassDescriptor concreteDescriptor = this.descriptor;
            if (concreteDescriptor.hasInheritance() && concreteDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
                Class classValue = concreteDescriptor.getInheritancePolicy().classFromRow(databaseRow, session);
                concreteDescriptor = concreteDescriptor.getInheritancePolicy().getDescriptor(classValue);
                if ((concreteDescriptor == null) && query.hasPartialAttributeExpressions()) {
                    concreteDescriptor = this.descriptor;
                }
                if (concreteDescriptor == null) {
                    throw QueryException.noDescriptorForClassFromInheritancePolicy(query, classValue);
                }
            }
            if (session.isUnitOfWork()) {
                // Do not wrap yet if in UnitOfWork, as there is still much more
                // processing ahead.

                }
            }
        } finally {
            session.endOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);
        }
        return domainObject;
    }




 * @since TOPLink/Java 1.0
 */
public class IdentityMapManager implements Serializable, Cloneable {
    protected static final String MONITOR_PREFIX = "Info:Cache:";

    /** A table of identity maps with the key being the domain Class. */
    protected Map<Class, IdentityMap> identityMaps;

    public CacheKey acquireDeferredLock(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            IdentityMap identityMap = getIdentityMap(descriptor, false);
            try {
                cacheKey = identityMap.acquireDeferredLock(primaryKey);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (cacheKey.getObject() == null) {
                this.session.updateProfile(MONITOR_PREFIX + domainClass.getSimpleName(), identityMap.getSize());
            }
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireDeferredLock(primaryKey);
        }

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            IdentityMap identityMap = getIdentityMap(descriptor, false);
            try {
                cacheKey = identityMap.acquireLock(primaryKey, forMerge);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (cacheKey.getObject() == null) {
                this.session.updateProfile(MONITOR_PREFIX + domainClass.getSimpleName(), identityMap.getSize());
            }
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireLock(primaryKey, forMerge);
        }

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            IdentityMap identityMap = getIdentityMap(descriptor, false);
            try {
                cacheKey = identityMap.acquireLockNoWait(primaryKey, forMerge);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (cacheKey.getObject() == null) {
                this.session.updateProfile(MONITOR_PREFIX + domainClass.getSimpleName(), identityMap.getSize());
            }
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireLockNoWait(primaryKey, forMerge);
        }

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            IdentityMap identityMap = getIdentityMap(descriptor, false);
            try {
                cacheKey = identityMap.acquireLockWithWait(primaryKey, forMerge, wait);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (cacheKey.getObject() == null) {
                this.session.updateProfile(MONITOR_PREFIX + domainClass.getSimpleName(), identityMap.getSize());
            }
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireLockWithWait(primaryKey, forMerge, wait);
        }

     * Provides access for setting a concurrency lock on an IdentityMap.
     */
    public void acquireReadLock() {
        this.session.startOperationProfile(SessionProfiler.Caching);

        if (this.session.getDatasourceLogin().shouldSynchronizedReadOnWrite()) {
            getCacheMutex().acquireReadLock();
        }

        this.session.endOperationProfile(SessionProfiler.Caching);
    }

    /**

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = getIdentityMap(descriptor, false).acquireReadLockOnCacheKey(primaryKey);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireReadLockOnCacheKey(primaryKey);
        }

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = getIdentityMap(descriptor, false).acquireReadLockOnCacheKeyNoWait(primaryKey);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            cacheKey = getIdentityMap(descriptor, false).acquireReadLockOnCacheKeyNoWait(primaryKey);
        }

            return false;
        }
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                return map.containsKey(key);
            } finally {
                releaseReadLock();
                this.session.endOperationProfile(SessionProfiler.Caching);
            }
        } else {
            return map.containsKey(key);

     */
    public Vector getAllFromIdentityMap(Expression selectionCriteria, Class theClass, Record translationRow, int valueHolderPolicy, boolean shouldReturnInvalidatedObjects) {
        ClassDescriptor descriptor = this.session.getDescriptor(theClass);
        this.session.startOperationProfile(SessionProfiler.Caching);
        Vector objects = null;
        try {
            if (selectionCriteria != null) {

                if ((object.getClass() == theClass) || (theClass.isInstance(object))) {
                    if (selectionCriteria == null) {
                        objects.add(object);
                        this.session.incrementProfile(SessionProfiler.CacheHits);
                    } else {
                        try {
                            if (selectionCriteria.doesConform(object, this.session, (AbstractRecord)translationRow, valueHolderPolicy)) {
                                objects.add(object);
                                this.session.incrementProfile(SessionProfiler.CacheHits);
                            }
                        } catch (QueryException queryException) {
                            if (queryException.getErrorCode() == QueryException.MUST_INSTANTIATE_VALUEHOLDERS) {
                                if (valueHolderPolicy == InMemoryQueryIndirectionPolicy.SHOULD_IGNORE_EXCEPTION_RETURN_CONFORMED) {
                                    objects.add(object);
                                    this.session.incrementProfile(SessionProfiler.CacheHits);
                                } else if (valueHolderPolicy == InMemoryQueryIndirectionPolicy.SHOULD_THROW_INDIRECTION_EXCEPTION) {
                                    throw queryException;
                                }

                }
            }
        } finally {
            this.session.endOperationProfile(SessionProfiler.Caching);
        }
        return objects;
    }

     */
    public void invalidateObjects(Expression selectionCriteria, Class theClass, Record translationRow, boolean shouldInvalidateOnException) {
        ClassDescriptor descriptor = this.session.getDescriptor(theClass);
        this.session.startOperationProfile(SessionProfiler.Caching);
        try {
            IdentityMap map = getIdentityMap(descriptor, true);
            if(map == null) {

                }
            }
        } finally {
            this.session.endOperationProfile(SessionProfiler.Caching);
        }
    }


        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = map.getCacheKeyForLock(primaryKey);
            } finally {
                releaseReadLock();
                this.session.endOperationProfile(SessionProfiler.Caching);
            }
        } else {
            cacheKey = map.getCacheKeyForLock(primaryKey);

        }
        CacheKey cacheKey = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = map.getCacheKey(primaryKey);
            } finally {
                releaseReadLock();
                this.session.endOperationProfile(SessionProfiler.Caching);
            }
        } else {
            cacheKey = map.getCacheKey(primaryKey);

        }
        Object domainObject = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = map.getCacheKey(key);

        }

        if (this.isCacheAccessPreCheckRequired) {
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (domainObject == null) {
                this.session.incrementProfile(SessionProfiler.CacheMisses);
            } else {
                this.session.incrementProfile(SessionProfiler.CacheHits);
            }
        }

        return domainObject;


    public Object getFromIdentityMap(Expression selectionCriteria, Class theClass, Record translationRow, int valueHolderPolicy, boolean conforming, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor) {
        UnitOfWorkImpl unitOfWork = (conforming) ? (UnitOfWorkImpl)this.session : null;
        this.session.startOperationProfile(SessionProfiler.Caching);
        try {
            if (selectionCriteria != null) {
                // PERF: Avoid clone of expression.            

                    if (selectionCriteria == null) {
                        // bug 2782991: if first found was deleted nothing returned. 
                        if (!(conforming && unitOfWork.isObjectDeleted(object))) {
                            this.session.incrementProfile(SessionProfiler.CacheHits);
                            return object;
                        }
                    }

                        if (selectionCriteria.doesConform(object, this.session, (AbstractRecord)translationRow, valueHolderPolicy)) {
                            // bug 2782991: if first found was deleted nothing returned. 
                            if (!(conforming && unitOfWork.isObjectDeleted(object))) {
                                this.session.incrementProfile(SessionProfiler.CacheHits);
                                return object;
                            }
                        }

                            if (valueHolderPolicy == InMemoryQueryIndirectionPolicy.SHOULD_IGNORE_EXCEPTION_RETURN_CONFORMED) {
                                // bug 2782991: if first found was deleted nothing returned. 
                                if (!(conforming && unitOfWork.isObjectDeleted(object))) {
                                    this.session.incrementProfile(SessionProfiler.CacheHits);
                                    return object;
                                }
                            } else if (valueHolderPolicy == InMemoryQueryIndirectionPolicy.SHOULD_IGNORE_EXCEPTION_RETURN_NOT_CONFORMED) {

                }
            }
        } finally {
            this.session.endOperationProfile(SessionProfiler.Caching);
        }
        return null;
    }

     */
    public Object getFromIdentityMapWithDeferredLock(Object key, Class theClass, boolean shouldReturnInvalidatedObjects, ClassDescriptor descriptor) {
        if (key == null) {
            this.session.incrementProfile(SessionProfiler.CacheMisses);
            return null;
        }


        CacheKey cacheKey;
        Object domainObject = null;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                cacheKey = map.getCacheKey(key);



        if (this.isCacheAccessPreCheckRequired) {
            this.session.endOperationProfile(SessionProfiler.Caching);
            if (domainObject == null) {
                this.session.incrementProfile(SessionProfiler.CacheMisses);
            } else {
                this.session.incrementProfile(SessionProfiler.CacheHits);
            }
        }

        return domainObject;

        IdentityMap map = getIdentityMap(descriptor, false);
        Object wrapper;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                wrapper = map.getWrapper(primaryKey);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            wrapper = map.getWrapper(primaryKey);
        }

        IdentityMap map = getIdentityMap(descriptor, false);
        Object value;
        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            acquireReadLock();
            try {
                value = map.getWriteLockValue(primaryKey);
            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            value = map.getWriteLockValue(primaryKey);
        }

        CacheKey cacheKey;

        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            // This is atomic so considered a read lock.
            acquireReadLock();
            try {

            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            cacheKey = map.put(keys, implementation, writeLockValue, readTime);
        }

        Object value;

        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            // This is atomic so considered a read lock.
            acquireReadLock();
            try {

            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            value = map.remove(key, objectToRemove);
        }

        IdentityMap map = getIdentityMap(descriptor, false);

        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            // This is atomic so considered a read lock.
            acquireReadLock();
            try {

            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            map.setWrapper(primaryKey, wrapper);
        }

        IdentityMap map = getIdentityMap(descriptor, false);

        if (this.isCacheAccessPreCheckRequired) {
            this.session.startOperationProfile(SessionProfiler.Caching);
            // This is atomic so considered a read lock.
            acquireReadLock();
            try {

            } finally {
                releaseReadLock();
            }
            this.session.endOperationProfile(SessionProfiler.Caching);
        } else {
            map.setWriteLockValue(primaryKey, writeLockValue);
        }

Lines 236-242 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/oxm/XMLObjectBuilder.java (-2 / +2 lines)
236	if (!(isXmlDescriptor() \|\| getDescriptor().isDescriptorTypeAggregate())) {	236	if (!(isXmlDescriptor() \|\| getDescriptor().isDescriptorTypeAggregate())) {
237	return super.buildObject(query, databaseRow, joinManager);	237	return super.buildObject(query, databaseRow, joinManager);
238	}	238	}
239	query.getSession().startOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);	239	query.getSession().startOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);
240	ClassDescriptor concreteDescriptor = getDescriptor();	240	ClassDescriptor concreteDescriptor = getDescriptor();
241	Object domainObject = null;	241	Object domainObject = null;
242		242
Lines 303-309 Link Here
303	//EIS XML Cases won't have a doc pres policy set	303	//EIS XML Cases won't have a doc pres policy set
304	((DOMRecord)row).getDocPresPolicy().addObjectToCache(domainObject, ((DOMRecord)row).getDOM());	304	((DOMRecord)row).getDocPresPolicy().addObjectToCache(domainObject, ((DOMRecord)row).getDOM());
305	}	305	}
306	query.getSession().endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);	306	query.getSession().endOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);
307	if ((unmarshaller != null) && (unmarshaller.getUnmarshalListener() != null)) {	307	if ((unmarshaller != null) && (unmarshaller.getUnmarshalListener() != null)) {
308	unmarshaller.getUnmarshalListener().afterUnmarshal(domainObject, parent);	308	unmarshaller.getUnmarshalListener().afterUnmarshal(domainObject, parent);
309	}	309	}




     */
    protected void setCallFromStatement() {
        // Profile SQL generation.
        getSession().startOperationProfile(SessionProfiler.SqlGeneration, getQuery(), SessionProfiler.ALL);
        try {
            if (hasMultipleStatements()) {
                for (Enumeration statementEnum = getSQLStatements().elements(); statementEnum.hasMoreElements();) {
                    DatabaseCall call = null;
                    if (getDescriptor() != null) {
                        call = getDescriptor().buildCallFromStatement((SQLStatement)statementEnum.nextElement(), getSession());
                    } else {
                        call = ((SQLStatement)statementEnum.nextElement()).buildCall(getSession());
                    }
    
                    // In case of update call may be null if no update required.
                    if (call != null) {
                        addCall(call);
                    }
                }
            } else {
                DatabaseCall call = null;
                if (getDescriptor() != null) {
                    call = getDescriptor().buildCallFromStatement(getSQLStatement(), getSession());
                } else {
                    call = getSQLStatement().buildCall(getSession());
                }
    
                // In case of update call may be null if no update required.
                if (call != null) {
                    setCall(call);
                }
            }
        } finally {
            // Profile SQL generation.
            getSession().endOperationProfile(SessionProfiler.SqlGeneration, getQuery(), SessionProfiler.ALL);
                call = getDescriptor().buildCallFromStatement(getSQLStatement(), getSession());
            } else {
                call = getSQLStatement().buildCall(getSession());
            }

            // In case of update call may be null if no update required.
            if (call != null) {
                setCall(call);
            }
        }

        // Profile SQL generation.
        getSession().endOperationProfile(SessionProfiler.SQL_GENERATION, getQuery(), SessionProfiler.ALL);
    }

    /**





    /**
     * INTERNAL:
     * Updates the count of SessionProfiler event
     */
    public void incrementProfile(String operationName, DatabaseQuery query) {
        if (this.isInProfile) {
            getProfiler().occurred(operationName, query);
        }
    }

    /**
     * INTERNAL:
     * Overridden by subclasses that do more than just execute the call.
     * Executes the call directly on this session and does not check which
     * session it should have executed on.

Lines 642-647 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/DatabaseSessionImpl.java (+1 lines)
642	getProfiler().initialize();	642	getProfiler().initialize();
643	}	643	}
644	updateProfile(SessionProfiler.LoginTime, new Date(System.currentTimeMillis()));	644	updateProfile(SessionProfiler.LoginTime, new Date(System.currentTimeMillis()));
		645	updateProfile(SessionProfiler.SessionName, getName());
645		646
646	// Login and initialize	647	// Login and initialize
647	if (this.eventManager != null) {	648	if (this.eventManager != null) {




     */
    public void mergeChangesFromChangeSet(UnitOfWorkChangeSet uowChangeSet) {
        this.session.startOperationProfile(SessionProfiler.DistributedMerge);
        // Ensure concurrency if cache isolation requires.
        this.session.getIdentityMapAccessorInstance().acquireWriteLock();
        this.session.log(SessionLog.FINER, SessionLog.PROPAGATION, "received_updates_from_remote_server");
        if (this.session.hasEventManager()) {
            this.session.getEventManager().preDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
        }

        try {
            // Ensure concurrency if cache isolation requires.
            this.session.getIdentityMapAccessorInstance().acquireWriteLock();
            this.session.log(SessionLog.FINER, SessionLog.PROPAGATION, "received_updates_from_remote_server");
            if (this.session.hasEventManager()) {
                this.session.getEventManager().preDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
            }
            // Iterate over each clone and let the object build merge to clones into the originals.
            this.session.getIdentityMapAccessorInstance().getWriteLockManager().acquireRequiredLocks(this, uowChangeSet);
            Iterator objectChangeEnum = uowChangeSet.getAllChangeSets().keySet().iterator();

                while (deletedObjects.hasNext()) {
                    ObjectChangeSet changeSet = (ObjectChangeSet)deletedObjects.next();
                    changeSet.removeFromIdentityMap(this.session);
                    this.session.incrementProfile(SessionProfiler.DeletedObject);
                }
            }
        } catch (RuntimeException exception) {

        } finally {
            this.session.getIdentityMapAccessorInstance().getWriteLockManager().releaseAllAcquiredLocks(this);
            this.session.getIdentityMapAccessorInstance().releaseWriteLock();
            this.session.endOperationProfile(SessionProfiler.DistributedMerge);
            if (this.session.hasEventManager()) {
                this.session.getEventManager().postDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
            }
            this.session.endOperationProfile(SessionProfiler.DistributedMerge);
        }
    }





    protected void commitToDatabaseWithChangeSet(boolean commitTransaction) throws DatabaseException, OptimisticLockException {
        
        try {
            incrementProfile(SessionProfiler.UowCommits);
            startOperationProfile(SessionProfiler.UowCommit);
            // PERF: If this is an empty unit of work, do nothing (but still may need to commit SQL changes).
            boolean hasChanges = (this.unitOfWorkChangeSet != null) || hasCloneMapping() || hasDeletedObjects() || hasModifyAllQueries() || hasDeferredModifyAllQueries();

     * support.
     */
    public void performRemove(Object toBeDeleted, Map visitedObjects) {
        if (toBeDeleted == null) {
            return;
        }
        ClassDescriptor descriptor = getDescriptor(toBeDeleted);
        if ((descriptor == null) || descriptor.isDescriptorTypeAggregate()) {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("not_an_entity", new Object[] { toBeDeleted }));
        }
        logDebugMessage(toBeDeleted, "deleting_object");
            logDebugMessage(toBeDeleted, "deleting_object");

        //bug 4568370+4599010; fix EntityManager.remove() to handle new objects
        if (getDeletedObjects().containsKey(toBeDeleted)){
          return;
        }
        visitedObjects.put(toBeDeleted,toBeDeleted);
        Object registeredObject = checkIfAlreadyRegistered(toBeDeleted, descriptor);
        if (registeredObject == null) {
            Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(toBeDeleted, this);
            DoesExistQuery existQuery = descriptor.getQueryManager().getDoesExistQuery();
            existQuery = (DoesExistQuery)existQuery.clone();
            existQuery.setObject(toBeDeleted);
            existQuery.setPrimaryKey(primaryKey);
            existQuery.setDescriptor(descriptor);
            existQuery.setIsExecutionClone(true);
                existQuery.setIsExecutionClone(true);

            existQuery.setCheckCacheFirst(true);
            if (((Boolean)executeQuery(existQuery)).booleanValue()){
                throw new IllegalArgumentException(ExceptionLocalization.buildMessage("cannot_remove_detatched_entity", new Object[]{toBeDeleted}));
            }//else, it is a new or previously deleted object that should be ignored (and delete should cascade)
        } else {
            //fire events only if this is a managed object
            if (descriptor.getEventManager().hasAnyEventListeners()) {
                org.eclipse.persistence.descriptors.DescriptorEvent event = new org.eclipse.persistence.descriptors.DescriptorEvent(toBeDeleted);
                event.setEventCode(DescriptorEventManager.PreRemoveEvent);
                event.setSession(this);
                descriptor.getEventManager().executeEvent(event);
            }
            if (hasNewObjects() && getNewObjectsCloneToOriginal().containsKey(registeredObject)){
                unregisterObject(registeredObject, DescriptorIterator.NoCascading);
            } else {
                getDeletedObjects().put(toBeDeleted, toBeDeleted);
                if (descriptor.getEventManager().hasAnyEventListeners()) {
                    org.eclipse.persistence.descriptors.DescriptorEvent event = new org.eclipse.persistence.descriptors.DescriptorEvent(toBeDeleted);
                    event.setEventCode(DescriptorEventManager.PreRemoveEvent);
                    event.setSession(this);
                    descriptor.getEventManager().executeEvent(event);
                }
                if (hasNewObjects() && getNewObjectsCloneToOriginal().containsKey(registeredObject)){
                    unregisterObject(registeredObject, DescriptorIterator.NoCascading);
                } else {
                    getDeletedObjects().put(toBeDeleted, toBeDeleted);
                }
            }
            descriptor.getObjectBuilder().cascadePerformRemove(toBeDeleted, this, visitedObjects);
        } finally {
            endOperationProfile(SessionProfiler.DeletedObject);
        }
        descriptor.getObjectBuilder().cascadePerformRemove(toBeDeleted, this, visitedObjects);
    }

    /**

Lines 542-547 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/ManyToManyMapping.java (+1 lines)
542	if (!getDeleteAllQuery().hasSessionName()) {	542	if (!getDeleteAllQuery().hasSessionName()) {
543	getDeleteAllQuery().setSessionName(session.getName());	543	getDeleteAllQuery().setSessionName(session.getName());
544	}	544	}
		545	getDeleteAllQuery().setName(getAttributeName());
545		546
546	if (hasCustomDeleteAllQuery()) {	547	if (hasCustomDeleteAllQuery()) {
547	return;	548	return;

Lines 566-571 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/OneToManyMapping.java (+1 lines)
566	*/	566	*/
567	protected void initializeDeleteAllQuery() {	567	protected void initializeDeleteAllQuery() {
568	((DeleteAllQuery)getDeleteAllQuery()).setReferenceClass(getReferenceClass());	568	((DeleteAllQuery)getDeleteAllQuery()).setReferenceClass(getReferenceClass());
		569	getDeleteAllQuery().setName(getAttributeName());
569	if (!hasCustomDeleteAllQuery()) {	570	if (!hasCustomDeleteAllQuery()) {
570	// the selection criteria are re-used by the delete all query	571	// the selection criteria are re-used by the delete all query
571	if (getSelectionCriteria() == null) {	572	if (getSelectionCriteria() == null) {

Lines 542-547 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/RelationTableMechanism.java (+2 lines)
542	if (!getDeleteQuery().hasSessionName()) {	542	if (!getDeleteQuery().hasSessionName()) {
543	getDeleteQuery().setSessionName(session.getName());	543	getDeleteQuery().setSessionName(session.getName());
544	}	544	}
		545	getInsertQuery().setName(mapping.getAttributeName());
545	if (hasCustomDeleteQuery()) {	546	if (hasCustomDeleteQuery()) {
546	return;	547	return;
547	}	548	}
Lines 611-616 Link Here
611	if (!getInsertQuery().hasSessionName()) {	612	if (!getInsertQuery().hasSessionName()) {
612	getInsertQuery().setSessionName(session.getName());	613	getInsertQuery().setSessionName(session.getName());
613	}	614	}
		615	getInsertQuery().setName(mapping.getAttributeName());
614	if (hasCustomInsertQuery()) {	616	if (hasCustomInsertQuery()) {
615	return;	617	return;
616	}	618	}

Lines 362-372 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/platform/database/SQLServerPlatform.java (-2 / +2 lines)
362	} else {	362	} else {
363	// start the process of processing the result set and the output params. this is specific to Sybase JConnect 5.5	363	// start the process of processing the result set and the output params. this is specific to Sybase JConnect 5.5
364	// as we must process the result set before the output params.	364	// as we must process the result set before the output params.
365	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, dbCall.getQuery(), SessionProfiler.ALL);	365	session.startOperationProfile(SessionProfiler.StatementExecute, dbCall.getQuery(), SessionProfiler.ALL);
366	try {	366	try {
367	resultSet = statement.executeQuery();	367	resultSet = statement.executeQuery();
368	} finally {	368	} finally {
369	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, dbCall.getQuery(), SessionProfiler.ALL);	369	session.endOperationProfile(SessionProfiler.StatementExecute, dbCall.getQuery(), SessionProfiler.ALL);
370	}	370	}
371	dbCall.matchFieldOrder(resultSet, accessor, session);	371	dbCall.matchFieldOrder(resultSet, accessor, session);
372		372

Lines 261-271 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/platform/database/SybasePlatform.java (-2 / +2 lines)
261	} else {	261	} else {
262	// start the process of processing the result set and the output params. this is specific to Sybase JConnect 5.5	262	// start the process of processing the result set and the output params. this is specific to Sybase JConnect 5.5
263	// as we must process the result set before the output params.	263	// as we must process the result set before the output params.
264	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, dbCall.getQuery(), SessionProfiler.ALL);	264	session.startOperationProfile(SessionProfiler.StatementExecute, dbCall.getQuery(), SessionProfiler.ALL);
265	try {	265	try {
266	resultSet = statement.executeQuery();	266	resultSet = statement.executeQuery();
267	} finally {	267	} finally {
268	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, dbCall.getQuery(), SessionProfiler.ALL);	268	session.endOperationProfile(SessionProfiler.StatementExecute, dbCall.getQuery(), SessionProfiler.ALL);
269	}	269	}
270	dbCall.matchFieldOrder(resultSet, accessor, session);	270	dbCall.matchFieldOrder(resultSet, accessor, session);
271		271

Lines 263-270 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DatabaseQuery.java (-65 / +33 lines)
263		263
264	/** Allow connection unwrapping to be configured. */	264	/** Allow connection unwrapping to be configured. */
265	protected boolean isNativeConnectionRequired;	265	protected boolean isNativeConnectionRequired;
266		266
267	/**	267	/**
		268	* Return the name to use for the query in performance monitoring.
		269	*/
		270	protected String monitorName;
		271
		272	/**
268	* PUBLIC: Initialize the state of the query	273	* PUBLIC: Initialize the state of the query
269	*/	274	*/
270	public DatabaseQuery() {	275	public DatabaseQuery() {
Lines 284-289 Link Here
284	}	289	}
285		290
286	/**	291	/**
		292	* INTERNAL:
		293	* Return the name to use for the query in performance monitoring.
		294	*/
		295	public String getMonitorName() {
		296	if (monitorName == null) {
		297	resetMonitorName();
		298	}
		299	return monitorName;
		300	}
		301
		302	/**
		303	* INTERNAL:
		304	* Return the name to use for the query in performance monitoring.
		305	*/
		306	public void resetMonitorName() {
		307	if (getReferenceClassName() == null) {
		308	this.monitorName = getClass().getSimpleName() + ":" + getName();
		309	} else {
		310	this.monitorName = getClass().getSimpleName() + ":" + getReferenceClassName() + ":" + getName();
		311	}
		312	}
		313
		314	/**
287	* PUBLIC: Add the argument named argumentName. This will cause the	315	* PUBLIC: Add the argument named argumentName. This will cause the
288	* translation of references of argumentName in the receiver's expression,	316	* translation of references of argumentName in the receiver's expression,
289	* with the value of the argument as supplied to the query in order from	317	* with the value of the argument as supplied to the query in order from
Lines 481-491 Link Here
481	if (!this.isPrepared) {// Avoid the monitor is already prepare, must	509	if (!this.isPrepared) {// Avoid the monitor is already prepare, must
482	// check again for concurrency.	510	// check again for concurrency.
483	// Profile the query preparation time.	511	// Profile the query preparation time.
484	session.startOperationProfile(SessionProfiler.QUERY_PREPARE, this, SessionProfiler.ALL);	512	session.startOperationProfile(SessionProfiler.QueryPreparation, this, SessionProfiler.ALL);
485	// If this query will use the custom query, do not prepare.	513	// If this query will use the custom query, do not prepare.
486	if ((!force) && shouldPrepare() && (checkForCustomQuery(session, translationRow) != null)) {	514	if ((!force) && shouldPrepare() && (checkForCustomQuery(session, translationRow) != null)) {
487	// Profile the query preparation time.	515	// Profile the query preparation time.
488	session.endOperationProfile(SessionProfiler.QUERY_PREPARE, this, SessionProfiler.ALL);	516	session.endOperationProfile(SessionProfiler.QueryPreparation, this, SessionProfiler.ALL);
489	return;	517	return;
490	}	518	}
491	// Prepared queries cannot be custom as then they would never have	519	// Prepared queries cannot be custom as then they would never have
Lines 513-519 Link Here
513	}	541	}
514	}	542	}
515	// Profile the query preparation time.	543	// Profile the query preparation time.
516	session.endOperationProfile(SessionProfiler.QUERY_PREPARE, this, SessionProfiler.ALL);	544	session.endOperationProfile(SessionProfiler.QueryPreparation, this, SessionProfiler.ALL);
517	}	545	}
518	} catch (EclipseLinkException knownFailure) {	546	} catch (EclipseLinkException knownFailure) {
519	throw knownFailure;	547	throw knownFailure;
Lines 1518-1523 Link Here
1518	this.argumentFields = buildArgumentFields();	1546	this.argumentFields = buildArgumentFields();
1519		1547
1520	getQueryMechanism().prepare();	1548	getQueryMechanism().prepare();
		1549	resetMonitorName();
1521	}	1550	}
1522		1551
1523	/**	1552	/**
Lines 2244-2310 Link Here
2244	}	2273	}
2245		2274
2246	/**	2275	/**
2247	* INTERNAL: TopLink_sessionName_domainClass. Cached in properties
2248	*/
2249	public String getDomainClassNounName(String sessionName) {
2250	if (getProperty("DMSDomainClassNounName") == null) {
2251	StringBuffer buffer = new StringBuffer("EclipseLink");
2252	if (sessionName != null) {
2253	buffer.append(sessionName);
2254	}
2255	if (getReferenceClassName() != null) {
2256	buffer.append("_");
2257	buffer.append(getReferenceClassName());
2258	}
2259	setProperty("DMSDomainClassNounName", buffer.toString());
2260	}
2261	return (String) getProperty("DMSDomainClassNounName");
2262	}
2263
2264	/**
2265	* INTERNAL: TopLink_sessionName_domainClass_queryClass_queryName (if
2266	* exist). Cached in properties
2267	*/
2268	public String getQueryNounName(String sessionName) {
2269	if (getProperty("DMSQueryNounName") == null) {
2270	StringBuffer buffer = new StringBuffer(getDomainClassNounName(sessionName));
2271	buffer.append("_");
2272	buffer.append(getClass().getSimpleName());
2273	if (getName() != null) {
2274	buffer.append("_");
2275	buffer.append(getName());
2276	}
2277	setProperty("DMSQueryNounName", buffer.toString());
2278	}
2279	return (String) getProperty("DMSQueryNounName");
2280	}
2281
2282	/**
2283	* INTERNAL: TopLink_sessionName_domainClass_queryClass_queryName (if
2284	* exist)_operationName (if exist). Cached in properties
2285	*/
2286	public String getSensorName(String operationName, String sessionName) {
2287	if (operationName == null) {
2288	return getQueryNounName(sessionName);
2289	}
2290
2291	Hashtable sensorNames = (Hashtable) getProperty("DMSSensorNames");
2292	if (sensorNames == null) {
2293	sensorNames = new Hashtable();
2294	setProperty("DMSSensorNames", sensorNames);
2295	}
2296	Object sensorName = sensorNames.get(operationName);
2297	if (sensorName == null) {
2298	StringBuffer buffer = new StringBuffer(getQueryNounName(sessionName));
2299	buffer.append("_");
2300	buffer.append(operationName);
2301	sensorName = buffer.toString();
2302	sensorNames.put(operationName, sensorName);
2303	}
2304	return (String) sensorName;
2305	}
2306
2307	/**
2308	* ADVANCED: Set if the descriptor requires usage of a native (unwrapped)	2276	* ADVANCED: Set if the descriptor requires usage of a native (unwrapped)
2309	* JDBC connection. This may be required for some Oracle JDBC support when a	2277	* JDBC connection. This may be required for some Oracle JDBC support when a
2310	* wrapping DataSource is used.	2278	* wrapping DataSource is used.




     * Return the domain class associated with this query.
     */
    public Class getReferenceClass() {
        if (this.object == null) {
            if (this.descriptor != null) {
                return this.descriptor.getJavaClass();
            }
            return null;
        }
        return this.object.getClass();        
    }

    /**

     * is specified at runtime, this will not be an issue.
     */
    public String getReferenceClassName() {
        Class referenceClass = getReferenceClass();
        if (referenceClass != null) {
            return referenceClass.getName();
        } else {
            return null;
        }
    }

    /**
     * INTERNAL:
     * Return the name to use for the query in performance monitoring.
     */
    public void resetMonitorName() {
        this.monitorName = getClass().getSimpleName() + ":" + getReferenceClassName();
    }

    /**
     * PUBLIC:
     * Return if this is an object level modify query.
     */




            cloneQuery.orderByExpressions = new ArrayList<Expression>(this.orderByExpressions);
        }
        if (this.fetchGroup != null) {
            cloneQuery.fetchGroup = this.fetchGroup.clone();
            // don't clone immutable entityFetchGroup
        }
        return cloneQuery;

        ClassDescriptor referenceDescriptor = mapping.getReferenceDescriptor();

        // Add the fields defined by the nested fetch group - if it exists.
        if (referenceDescriptor != null && referenceDescriptor.hasFetchGroupManager()) {
            ObjectLevelReadQuery nestedQuery = getJoinedAttributeManager().getNestedJoinedMappingQuery(expression);
            FetchGroup nestedFetchGroup = nestedQuery.getExecutionFetchGroup();
            if(nestedFetchGroup != null) {
                List<DatabaseField> nestedFields = nestedQuery.getFetchGroupSelectionFields(mapping);
                for(DatabaseField field : nestedFields) {
                    fields.add(new FieldExpression(field, expression));
                }
                return;
            }




import org.eclipse.persistence.internal.sessions.UnitOfWorkImpl;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.sessions.SessionProfiler;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.tools.profiler.QueryMonitor;


                if (queryResults != null) {
                    if (QueryMonitor.shouldMonitor()) {
                        QueryMonitor.incrementReadAllHits(this);
                    }
                    session.incrementProfile(SessionProfiler.CacheHits, this);
                    // bug6138532 - check for "cached no results" (InvalidObject singleton) in query 
                    // results, and return an empty container instance as configured
                    if (queryResults == InvalidObject.instance) {

                    return results;
                }
            }
            session.incrementProfile(SessionProfiler.CacheMisses, this);
        }
        if (QueryMonitor.shouldMonitor()) {
            QueryMonitor.incrementReadAllMisses(this);




import org.eclipse.persistence.descriptors.DescriptorQueryManager;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.sessions.SessionProfiler;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.tools.profiler.QueryMonitor;



                // check locking.  If clone has not been locked, do not early return cached object
                if (isLockQuery() && (session.isUnitOfWork() && !((UnitOfWorkImpl)session).isPessimisticLocked(cachedObject))) {
                    if (QueryMonitor.shouldMonitor()) {
                        QueryMonitor.incrementReadObjectMisses(this);
                    }
                    return null;
                }
                if (QueryMonitor.shouldMonitor()) {
                    QueryMonitor.incrementReadObjectHits(this);
                }
                session.incrementProfile(SessionProfiler.CacheHits, this);
            } else {
                if (!session.isUnitOfWork()) {
                    if (QueryMonitor.shouldMonitor()) {
                        QueryMonitor.incrementReadObjectMisses(this);
                    }
                    session.incrementProfile(SessionProfiler.CacheMisses, this);
                }
            }
            if (shouldUseWrapperPolicy()) {

            }            
            return cachedObject;
        } else {
            if (!session.isUnitOfWork()) {
                if (QueryMonitor.shouldMonitor()) {
                    QueryMonitor.incrementReadObjectMisses(this);
                }
                session.incrementProfile(SessionProfiler.CacheMisses, this);
            }
            return null;
        }

Lines 215-224 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sequencing/QuerySequence.java (+6 lines)
215	if (getSelectQuery() == null) {	215	if (getSelectQuery() == null) {
216	setSelectQuery(buildSelectQuery());	216	setSelectQuery(buildSelectQuery());
217	wasSelectQueryCreated = getSelectQuery() != null;	217	wasSelectQueryCreated = getSelectQuery() != null;
		218	if (wasSelectQueryCreated) {
		219	getSelectQuery().setName(getName());
		220	}
218	}	221	}
219	if ((getUpdateQuery() == null) && !shouldSkipUpdate()) {	222	if ((getUpdateQuery() == null) && !shouldSkipUpdate()) {
220	setUpdateQuery(buildUpdateQuery());	223	setUpdateQuery(buildUpdateQuery());
221	wasUpdateQueryCreated = getUpdateQuery() != null;	224	wasUpdateQueryCreated = getUpdateQuery() != null;
		225	if (wasUpdateQueryCreated) {
		226	getUpdateQuery().setName(getName());
		227	}
222	}	228	}
223	}	229	}
224		230

Lines 59-64 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sequencing/Sequence.java (+1 lines)
59		59
60	public Sequence() {	60	public Sequence() {
61	super();	61	super();
		62	setName("SEQUENCE");
62	}	63	}
63		64
64	/**	65	/**

Lines 25-30 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/server/ConnectionPool.java (-2 / +7 lines)
25	* @see ServerSession	25	* @see ServerSession
26	*/	26	*/
27	public class ConnectionPool {	27	public class ConnectionPool {
		28	protected static final String MONITOR_HEADER = "Info:ConnectionPool:";
		29
28	protected boolean isConnected;	30	protected boolean isConnected;
29	protected int maxNumberOfConnections;	31	protected int maxNumberOfConnections;
30	protected int minNumberOfConnections;	32	protected int minNumberOfConnections;
Lines 96-101 Link Here
96	if ((this.connectionsUsed.size() + this.connectionsAvailable.size()) < this.maxNumberOfConnections) {	98	if ((this.connectionsUsed.size() + this.connectionsAvailable.size()) < this.maxNumberOfConnections) {
97	Accessor connection = buildConnection();	99	Accessor connection = buildConnection();
98	this.connectionsUsed.add(connection);	100	this.connectionsUsed.add(connection);
		101	if (this.owner.isInProfile()) {
		102	this.owner.updateProfile(MONITOR_HEADER + this.name, Integer.valueOf(this.connectionsUsed.size()));
		103	}
99	return connection;	104	return connection;
100	}	105	}
101	try {	106	try {
Lines 140-146 Link Here
140	}	145	}
141	this.connectionsUsed.add(connection);	146	this.connectionsUsed.add(connection);
142	if (this.owner.isInProfile()) {	147	if (this.owner.isInProfile()) {
143	this.owner.updateProfile(this.name, Integer.valueOf(this.connectionsUsed.size()));	148	this.owner.updateProfile(MONITOR_HEADER + this.name, Integer.valueOf(this.connectionsUsed.size()));
144	}	149	}
145	return connection;	150	return connection;
146	}	151	}
Lines 279-285 Link Here
279	}	284	}
280	}	285	}
281	if (this.owner.isInProfile()) {	286	if (this.owner.isInProfile()) {
282	this.owner.updateProfile(this.name, Integer.valueOf(this.connectionsUsed.size()));	287	this.owner.updateProfile(MONITOR_HEADER + this.name, Integer.valueOf(this.connectionsUsed.size()));
283	}	288	}
284	notify();	289	notify();
285	}	290	}




    public static final int HEAVY = 10;
    public static final int ALL = Integer.MAX_VALUE;

    // Sensors display name
    public static final String SessionName = "Info:SessionName";
    public static final String LoginTime = "Info:LoginTime";
    public static final String RcmStatus = "Info:CacheCoordinationStatus";
    public static final String CachedObjects = "Info:CachedObjects";//TODO
    
    public static final String ClientSessionCreated = "Counter:ClientSessionCreates";
    public static final String UowCreated = "Counter:UnitOfWorkCreates";
    public static final String UowCommits = "Counter:UnitOfWorkCommits";
    public static final String UowRollbacks = "Counter:UnitOfWorkRollbacks";
    public static final String OptimisticLockException = "Counter:OptimisticLocks";
    public static final String RcmReceived = "Counter:MessagesReceived";
    public static final String RcmSent = "Counter:MessagesSent";
    public static final String RemoteChangeSet = "Counter:RemoteChangeSets";
    public static final String Connects = "Counter:ConnectCalls";
    public static final String Disconnects = "Counter:DisconnectCalls";
    public static final String CacheHits = "Counter:CacheHits";
    public static final String CacheMisses = "Counter:CacheMisses";
    public static final String ChangeSetsProcessed = "Counter:ChangesProcessed";
    public static final String ChangeSetsNotProcessed = "Counter:ChangesNotProcessed";
    
    public static final String DescriptorEvent = "Timer:DescriptorEvents";
    public static final String SessionEvent = "Timer:SessionEvents";
    public static final String QueryPreparation = "Timer:QueryPreparation";
    public static final String SqlGeneration = "Timer:SqlGeneration";
    public static final String SqlPrepare = "Timer:SqlPrepare";
    public static final String StatementExecute = "Timer:StatementExecute";
    public static final String RowFetch = "Timer:RowFetch";
    public static final String ObjectBuilding = "Timer:ObjectBuilding";
    public static final String Register = "Timer:Register";
    public static final String Merge = "Timer:Merge";
    public static final String DistributedMerge = "Timer:DistributedMerge";
    public static final String AssignSequence = "Timer:Sequencing";
    public static final String Caching = "Timer:Caching";
    public static final String ConnectionManagement = "Timer:ConnectionManagement";
    public static final String Logging = "Timer:Logging";
    public static final String JtsBeforeCompletion = "Timer:TXBeforeCompletion";
    public static final String JtsAfterCompletion = "Timer:TXAfterCompletion";
    public static final String Transaction = "Timer:Transactions";
    public static final String UowCommit = "Timer:UnitOfWorkCommit";
    public static final String ConnectionPing = "Timer:ConnectionPing";

    //dms sensors display name
    public static final String SessionName = "SessionName";
    public static final String LoginTime = "loginTime";
    public static final String ClientSessionCreated = "ClientSession";
    public static final String UowCreated = "UnitOfWork";
    public static final String UowCommit = "UnitOfWorkCommits";
    public static final String UowRollbacks = "UnitOfWorkRollbacks";
    public static final String OptimisticLockException = "OptimisticLocks";
    public static final String RcmStatus = "RCMStatus";
    public static final String RcmReceived = "MessagesReceived";
    public static final String RcmSent = "MessagesSent";
    public static final String RemoteChangeSet = "RemoteChangeSets";
    public static final String TlConnects = "ConnectCalls";
    public static final String TlDisconnects = "DisconnectCalls";
    public static final String CachedObjects = "CachedObjects";
    public static final String CacheHits = "CacheHits";
    public static final String CacheMisses = "CacheMisses";
    public static final String ChangeSetsProcessed = "ChangesProcessed";
    public static final String ChangeSetsNotProcessed = "ChangesNotProcessed";
    public static final String DescriptorEvent = "DescriptorEvents";
    public static final String SessionEvent = "SessionEvents";
    public static final String ConnectionInUse = "ConnectionsInUse";
    public static final String QueryPreparation = "QueryPreparation";
    public static final String SqlGeneration = "SqlGeneration";
    public static final String DatabaseExecute = "DatabaseExecute";
    public static final String SqlPrepare = "SqlPrepare";
    public static final String RowFetch = "RowFetch";
    public static final String ObjectBuilding = "ObjectBuilding";
    public static final String MergeTime = "MergeTime";
    public static final String UnitOfWorkRegister = "UnitOfWorkRegister";
    public static final String DistributedMergeDmsDisplayName = "DistributedMerge";
    public static final String Sequencing = "Sequencing";
    public static final String Caching = "Caching";
    public static final String ConnectionManagement = "ConnectionManagement";
    public static final String LoggingDMSDisPlayName = "Logging";
    public static final String JtsBeforeCompletion = "TXBeforeCompletion";
    public static final String JtsAfterCompletion = "TXAfterCompletion";
    public static final String ConnectionPing = "ConnectionHealthTest";

    //Token used by existed default performance profiler 
    public static final String Register = "register";
    public static final String Merge = "merge";
    public static final String AssignSequence = "assign sequence";
    public static final String DistributedMerge = "distributed merge";
    public static final String DeletedObject = "deleted object";
    public static final String Wrapping = "wrapping";
    public static final String Logging = "logging";
    public static final String OBJECT_BUILDING = "object building";
    public static final String SQL_GENERATION = "sql generation";
    public static final String QUERY_PREPARE = "query prepare";
    public static final String STATEMENT_EXECUTE = "sql execute";
    public static final String ROW_FETCH = "row fetch";
    public static final String SQL_PREPARE = "sql prepare";
    public static final String TRANSACTION = "transactions";
    public static final String CONNECT = "connect";
    public static final String CACHE = "cache";

    /**
     * INTERNAL:
     * End the operation timing.

     * Increase DMS Event sensor occurrence.(DMS)
     */
    public void occurred(String operationName);
    
    /**
     * INTERNAL:
     * Increase DMS Event sensor occurrence.(DMS)
     */
    public void occurred(String operationName, DatabaseQuery query);

    /**
     * INTERNAL:




/*******************************************************************************
 * Copyright (c) 2010 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     James Sutherland (Oracle) - initial API and implementation
 ******************************************************************************/  
package org.eclipse.persistence.tools.profiler;

import java.text.NumberFormat;
import java.util.*;
import java.io.*;

import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.Record;
import org.eclipse.persistence.sessions.SessionProfiler;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.internal.sessions.AbstractSession;

/**
 * <p><b>Purpose</b>: A tool used to provide performance monitoring information in a server environment.
 *
 * @since EclipseLink 2.2
 * @author James Sutherland
 */
public class PerformanceMonitor implements Serializable, Cloneable, SessionProfiler {
    protected static final String COUNTER = "Counter:";
    protected static final String TIMER = "Timer:";
    
    transient protected AbstractSession session;
    protected Map<String, Object> operationTimings;
    protected Map<Integer, Map<String, Long>> operationStartTimesByThread;//facilitates concurrency
    protected long lastDumpTime;
    protected long dumpTime;
    protected int profileWeight;

    /**
     * PUBLIC:
     * Create a new profiler.
     * The profiler can be registered with a session to log performance information on queries.
     */
    public PerformanceMonitor() {
        this.operationTimings = new Hashtable();
        this.operationStartTimesByThread = new Hashtable();
        this.lastDumpTime = System.currentTimeMillis();
        this.dumpTime = 60000; // 1 minute
        this.profileWeight = SessionProfiler.ALL;
    }

    /**
     * Return the number of milliseconds after which the monitor results should be logged.
     */
    public long getDumpTime() {
        return dumpTime;
    }

    /**
     * Set the number of milliseconds after which the monitor results should be logged.
     */
    public void setDumpTime(long dumpTime) {
        this.dumpTime = dumpTime;
    }
    
    public PerformanceMonitor clone() {
        try {
            return (PerformanceMonitor)super.clone();
        } catch (CloneNotSupportedException exception) {
            throw new InternalError();
        }
    }
    
    /**
     * Log the results after a set amount of time has passed.
     */
    public void checkDumpTime() {
        if ((System.currentTimeMillis() - this.lastDumpTime) > this.dumpTime) {
            dumpResults();
        }
    }
    
    /**
     * Log the results to the session's log (System.out).
     */
    public void dumpResults() {
        this.lastDumpTime = System.currentTimeMillis();
        StringWriter writer = new StringWriter();
        writer.write("\nPerformance Monitor:");
        writer.write(String.valueOf(this.lastDumpTime));
        writer.write("\nOperation\tValue (ns)\n");
        Set<String> operations = new TreeSet<String>(this.operationTimings.keySet());
        NumberFormat formater = NumberFormat.getInstance();
        for (String operation : operations) {
            Object value = this.operationTimings.get(operation);
            if (value == null) {
                value = Long.valueOf(0);
            }
            writer.write(operation);
            writer.write("\t");
            if (value instanceof Long) {
                writer.write(formater.format(value));
            } else {
                writer.write(value.toString());
            }
            writer.write("\n");
        }
        try {
            this.session.getLog().write(writer.toString());
            this.session.getLog().flush();
        } catch (IOException error) {
            // ignore
        }
    }

    /**
     * INTERNAL:
     * End the operation timing.
     */
    public void endOperationProfile(String operationName) {
        if (this.profileWeight < SessionProfiler.HEAVY) {
            return;
        }
        long endTime = System.nanoTime();
        Long startTime = getOperationStartTimes().get(operationName);
        if (startTime == null) {
            return;
        }
        long time = endTime - startTime.longValue();

        synchronized (this.operationTimings) {
            Long totalTime = (Long)this.operationTimings.get(operationName);
            if (totalTime == null) {
                this.operationTimings.put(operationName, Long.valueOf(time));
            } else {
                this.operationTimings.put(operationName, Long.valueOf(totalTime.longValue() + time));
            }
        }
    }

    /**
     * INTERNAL:
     * End the operation timing.
     */
    public void endOperationProfile(String operationName, DatabaseQuery query, int weight) {
        if (this.profileWeight < weight) {
            return;
        }
        endOperationProfile(operationName);
        endOperationProfile(TIMER + query.getMonitorName() + ":" + operationName.substring(TIMER.length(), operationName.length()));
    }

    protected Map<String, Long> getOperationStartTimes() {
        Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
        Map<String, Long> times = this.operationStartTimesByThread.get(threadId);
        if (times == null) {
            times = new Hashtable<String, Long>();
            this.operationStartTimesByThread.put(threadId, times);
        }
        return times;
    }

    protected Map<Integer, Map<String, Long>> getOperationStartTimesByThread() {
        return operationStartTimesByThread;
    }

    protected Map<String, Object> getOperationTimings() {
        return operationTimings;
    }

    public AbstractSession getSession() {
        return session;
    }

    /**
     * INTERNAL:
     * Monitoring is done on the endOperation only.
     */
    public Object profileExecutionOfQuery(DatabaseQuery query, Record row, AbstractSession session) {
        if (this.profileWeight < SessionProfiler.HEAVY) {
            return session.internalExecuteQuery(query, (AbstractRecord)row);
        }
        startOperationProfile(TIMER + query.getMonitorName());
        startOperationProfile(TIMER + query.getClass().getSimpleName());
        occurred(COUNTER + query.getClass().getSimpleName());
        occurred(COUNTER + query.getMonitorName());
        try {
            return session.internalExecuteQuery(query, (AbstractRecord)row);
        } finally {
            endOperationProfile(TIMER + query.getMonitorName());
            endOperationProfile(TIMER + query.getClass().getSimpleName());
            checkDumpTime();
        }
    }

    public void setSession(org.eclipse.persistence.sessions.Session session) {
        this.session = (AbstractSession)session;
    }

    /**
     * INTERNAL:
     * Start the operation timing.
     */
    public void startOperationProfile(String operationName) {
        getOperationStartTimes().put(operationName, Long.valueOf(System.nanoTime()));
    }

    /**
     * INTERNAL:
     * Start the operation timing.
     */
    public void startOperationProfile(String operationName, DatabaseQuery query, int weight) {
        if (this.profileWeight < weight) {
            return;
        }
        startOperationProfile(operationName);
        startOperationProfile(TIMER + query.getMonitorName() + ":" + operationName.substring(TIMER.length(), operationName.length()));
    }

    public void update(String operationName, Object value) {
        this.operationTimings.put(operationName, value);
    }

    public void occurred(String operationName) {
        if (this.profileWeight < SessionProfiler.NORMAL) {
            return;
        }
        synchronized (this.operationTimings) {
            Long occurred = (Long)this.operationTimings.get(operationName);
            if (occurred == null) {
                this.operationTimings.put(operationName, Long.valueOf(1));
            } else {
                this.operationTimings.put(operationName, Long.valueOf(occurred.longValue() + 1));
            }
        }
    }

    public void occurred(String operationName, DatabaseQuery query) {
        if (this.profileWeight < SessionProfiler.NORMAL) {
            return;
        }
        occurred(operationName);
        occurred(COUNTER + query.getMonitorName() + ":" + operationName.substring(COUNTER.length(), operationName.length()));
    }

    /**
     * Set the level of profiling.
     * One of ALL, HEAVY, NORMAL, NONE.
     * The higher the level, the more operations are profiled.
     * @see SessiobProfiler
     */
    public void setProfileWeight(int profileWeight) {
        this.profileWeight = profileWeight;
    }

    /**
     * Return the level of profiling.
     * One of ALL, HEAVY, NORMAL, NONE.
     * @see SessiobProfiler
     */
    public int getProfileWeight() {
        return profileWeight;
    }

    public void initialize() {
    }
}




 * @author James Sutherland
 */
public class PerformanceProfiler implements Serializable, Cloneable, SessionProfiler {
    protected List<Profile> profiles;
    transient protected AbstractSession session;
    protected boolean shouldLogProfile;
    protected int nestLevel;
    protected long nestTime;
    protected long profileTime;
    protected Map<Integer, Map<String, Long>> operationTimingsByThread;//facilitates concurrency
    protected Map<Integer, Map<String, Long>> operationStartTimesByThread;//facilitates concurrency
    protected Hashtable operationTimingsByThread;//facilitates concurrency
    protected Hashtable operationStartTimesByThread;//facilitates concurrency

    /**
     * PUBLIC:

    }

    protected void addProfile(Profile profile) {
        getProfiles().add(profile);
    }

    /**

        Profile summary = new Profile();
        summary.setDomainClass(Void.class);
        summary.setQueryClass(Void.class);
        for (Profile profile : getProfiles()) {
            Profile profile = (Profile)enumtr.nextElement();

            if ((summary.getShortestTime() == -1) || (profile.getTotalTime() < summary.getShortestTime())) {
                summary.setShortestTime(profile.getTotalTime());
            }

    public Hashtable buildProfileSummaryByClass() {
        Hashtable summaries = new Hashtable();

        for (Profile profile : getProfiles()) {
            Profile profile = (Profile)enumtr.nextElement();
            Class domainClass = profile.getDomainClass();
            if (domainClass == null) {
                domainClass = Void.class;

    public Hashtable buildProfileSummaryByQuery() {
        Hashtable summaries = new Hashtable();

        for (Profile profile : getProfiles()) {
            Profile profile = (Profile)enumtr.nextElement();
            Class queryType = profile.getQueryClass();
            if (queryType == null) {
                queryType = Void.class;

        return summaries;
    }

    public PerformanceProfiler clone() {
        try {
            return (PerformanceProfiler)super.clone();
        } catch (CloneNotSupportedException exception) {
            throw new InternalError();
        }

        return null;
    }

    /**

     * End the operation timing.
     */
    public void endOperationProfile(String operationName) {
        long endTime = System.nanoTime();
        Long startTime = getOperationStartTimes().get(operationName);
        if (startTime == null) {
            return;
        }

            }
        }

        Long totalTime = getOperationTimings().get(operationName);
        if (totalTime == null) {
            getOperationTimings().put(operationName, Long.valueOf(time));
        } else {

        return nestTime;
    }

    protected Map<String, Long> getOperationStartTimes() {
        Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
        if (getOperationStartTimesByThread().get(threadId) == null) {
            getOperationStartTimesByThread().put(threadId, new Hashtable(10));
        }
        return getOperationStartTimesByThread().get(threadId);
    }

    protected Map<Integer, Map<String, Long>> getOperationStartTimesByThread() {
        return operationStartTimesByThread;
    }

    protected Map<String, Long> getOperationTimings() {
        Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
        if (getOperationTimingsByThread().get(threadId) == null) {
            getOperationTimingsByThread().put(threadId, new Hashtable(10));
        }
        return getOperationTimingsByThread().get(threadId);
    }

    protected Map<Integer, Map<String, Long>> getOperationTimingsByThread() {
        return operationTimingsByThread;
    }

    /**
     * Return the profiles logged in this profiler.
     */
    public List<Profile> getProfiles() {
        return profiles;
    }


     * @return the execution result of the query.
     */
    public Object profileExecutionOfQuery(DatabaseQuery query, Record row, AbstractSession session) {
        long profileStartTime = System.nanoTime();
        long nestedProfileStartTime = getProfileTime();
        Profile profile = new Profile();
        profile.setQueryClass(query.getClass());


            setNestLevel(getNestLevel() + 1);
            long startNestTime = getNestTime();
            Map<String, Long> timingsBeforeExecution = (Map<String, Long>)((Hashtable)getOperationTimings()).clone();
            Map<String, Long> startTimingsBeforeExecution = (Map<String, Long>)((Hashtable)getOperationStartTimes()).clone();
            long startTime = System.nanoTime();
            try {
                result = session.internalExecuteQuery(query, (AbstractRecord)row);
                return result;
            } finally {
                long endTime = System.nanoTime();
                setNestLevel(getNestLevel() - 1);
    
                for (String name : getOperationTimings().keySet()) {
                    Long operationStartTime = timingsBeforeExecution.get(name);
                    long operationEndTime = getOperationTimings().get(name).longValue();
                    long operationTime;
                    if (operationStartTime != null) {
                        operationTime = operationEndTime - operationStartTime.longValue();
                    } else {
                        operationTime = operationEndTime;
                    }
                    profile.addTiming(name, operationTime);
                }
    
                profile.setTotalTime((endTime - startTime) - (getProfileTime() - nestedProfileStartTime));// Remove the profile time from the total time.;);
                profile.setLocalTime(profile.getTotalTime() - (getNestTime() - startNestTime));
                if (result instanceof Collection) {
                    profile.setNumberOfInstancesEffected(((Collection)result).size());
                } else {
                    profile.setNumberOfInstancesEffected(1);
                }
    
                addProfile(profile);
                if (shouldLogProfile()) {
                    writeNestingTabs(writer);
                    long profileEndTime = System.nanoTime();
                    long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                    profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
                    profile.write(writer, this);
                    writer.write(Helper.cr());
                    writeNestingTabs(writer);
                    writer.write("}" + ToStringLocalization.buildMessage("end_profile", (Object[])null));
                    writer.write(Helper.cr());
                    writer.flush();
                writeNestingTabs(writer);
                long profileEndTime = System.currentTimeMillis();
                long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
                profile.write(writer, this);
                writer.write(Helper.cr());
                writeNestingTabs(writer);
                writer.write("}" + ToStringLocalization.buildMessage("end_profile", (Object[])null));
                writer.write(Helper.cr());
                writer.flush();
            }

            if (getNestLevel() == 0) {
                setNestTime(0);
                setProfileTime(0);
                setOperationTimings(new Hashtable(5));
                setOperationStartTimes(new Hashtable(5));
                long profileEndTime = System.currentTimeMillis();
                long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
            } else {
                setNestTime(startNestTime + profile.getTotalTime());
                setOperationTimings(timingsBeforeExecution);
                setOperationStartTimes(startTimingsBeforeExecution);
                long profileEndTime = System.currentTimeMillis();
                long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                setProfileTime(getProfileTime() + (totalTimeIncludingProfiling - (endTime - startTime)));
                profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
                for (Enumeration timingsEnum = ((Hashtable)startTimingsBeforeExecution.clone()).keys();
                         timingsEnum.hasMoreElements();) {
                    String timingName = (String)timingsEnum.nextElement();
                    startTimingsBeforeExecution.put(timingName, Long.valueOf(((Number)startTimingsBeforeExecution.get(timingName)).longValue() + totalTimeIncludingProfiling));
                }
    
                if (getNestLevel() == 0) {
                    setNestTime(0);
                    setProfileTime(0);
                    setOperationTimings(new Hashtable());
                    setOperationStartTimes(new Hashtable());
                    long profileEndTime = System.nanoTime();
                    long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                    profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
                } else {
                    setNestTime(startNestTime + profile.getTotalTime());
                    setOperationTimings(timingsBeforeExecution);
                    setOperationStartTimes(startTimingsBeforeExecution);
                    long profileEndTime = System.nanoTime();
                    long totalTimeIncludingProfiling = profileEndTime - profileStartTime;// Try to remove the profiling time from the total time.
                    setProfileTime(getProfileTime() + (totalTimeIncludingProfiling - (endTime - startTime)));
                    profile.setProfileTime(totalTimeIncludingProfiling - profile.getTotalTime());
                    for (String timingName : ((Map<String, Long>)(((Hashtable)startTimingsBeforeExecution).clone())).keySet()) {
                        startTimingsBeforeExecution.put(timingName, Long.valueOf(((Number)startTimingsBeforeExecution.get(timingName)).longValue() + totalTimeIncludingProfiling));
                    }
                }
            }
        } catch (IOException ioe) {
        }

        return result;
    }


        this.nestTime = nestTime;
    }

    protected void setOperationStartTimes(Map<String, Long> operationStartTimes) {
        Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
        getOperationStartTimesByThread().put(threadId, operationStartTimes);
    }

        this.operationStartTimesByThread = operationStartTimesByThread;
    }

    protected void setOperationTimings(Map<String, Long> operationTimings) {
        Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
        getOperationTimingsByThread().put(threadId, operationTimings);
    }

     * Start the operation timing.
     */
    public void startOperationProfile(String operationName) {
        getOperationStartTimes().put(operationName, Long.valueOf(System.nanoTime()));
    }

    /**


    public void occurred(String operationName) {
    }
    
    public void occurred(String operationName, DatabaseQuery query) {
    }

    public void setProfileWeight(int weight) {
    }

Lines 105-110 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java (-2 / +9 lines)
105	import org.eclipse.persistence.internal.security.SecurableObjectHolder;	105	import org.eclipse.persistence.internal.security.SecurableObjectHolder;
106	import org.eclipse.persistence.platform.database.converters.StructConverter;	106	import org.eclipse.persistence.platform.database.converters.StructConverter;
107	import org.eclipse.persistence.platform.server.ServerPlatformBase;	107	import org.eclipse.persistence.platform.server.ServerPlatformBase;
		108	import org.eclipse.persistence.tools.profiler.PerformanceMonitor;
108	import org.eclipse.persistence.tools.profiler.PerformanceProfiler;	109	import org.eclipse.persistence.tools.profiler.PerformanceProfiler;
109	import org.eclipse.persistence.tools.profiler.QueryMonitor;	110	import org.eclipse.persistence.tools.profiler.QueryMonitor;
110		111
Lines 643-648 Link Here
643	session.setProfiler(new PerformanceProfiler());	644	session.setProfiler(new PerformanceProfiler());
644	return;	645	return;
645	}	646	}
		647	if (newProfilerClassName.equals(ProfilerType.PerformanceMonitor)) {
		648	session.setProfiler(new PerformanceMonitor());
		649	return;
		650	}
646		651
647	String originalProfilerClassNamer = null;	652	String originalProfilerClassNamer = null;
648	if (session.getProfiler() != null) {	653	if (session.getProfiler() != null) {
Lines 1542-1547 Link Here
1542	while (it.hasNext()) {	1547	while (it.hasNext()) {
1543	Map.Entry entry = (Map.Entry)it.next();	1548	Map.Entry entry = (Map.Entry)it.next();
1544	String name = (String)entry.getKey();	1549	String name = (String)entry.getKey();
		1550	String customizerClassName = (String)entry.getValue();
1545		1551
1546	ClassDescriptor descriptor = session.getDescriptorForAlias(name);	1552	ClassDescriptor descriptor = session.getDescriptorForAlias(name);
1547	if (descriptor == null) {	1553	if (descriptor == null) {
Lines 1549-1559 Link Here
1549	Class javaClass = findClass(name, loader);	1555	Class javaClass = findClass(name, loader);
1550	descriptor = session.getDescriptor(javaClass);	1556	descriptor = session.getDescriptor(javaClass);
1551	} catch (Exception ex) {	1557	} catch (Exception ex) {
1552	// Ignore exception	1558	throw EntityManagerSetupException.failedWhileProcessingProperty(PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, customizerClassName, ex);
1553	}	1559	}
1554	}	1560	}
1555	if (descriptor != null) {	1561	if (descriptor != null) {
1556	String customizerClassName = (String)entry.getValue();
1557	Class customizerClass = findClassForProperty(customizerClassName, PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, loader);	1562	Class customizerClass = findClassForProperty(customizerClassName, PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, loader);
1558	try {	1563	try {
1559	DescriptorCustomizer customizer = (DescriptorCustomizer)customizerClass.newInstance();	1564	DescriptorCustomizer customizer = (DescriptorCustomizer)customizerClass.newInstance();
Lines 1561-1566 Link Here
1561	} catch (Exception ex) {	1566	} catch (Exception ex) {
1562	throw EntityManagerSetupException.failedWhileProcessingProperty(PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, customizerClassName, ex);	1567	throw EntityManagerSetupException.failedWhileProcessingProperty(PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, customizerClassName, ex);
1563	}	1568	}
		1569	} else {
		1570	throw EntityManagerSetupException.failedWhileProcessingProperty(PersistenceUnitProperties.DESCRIPTOR_CUSTOMIZER_ + name, customizerClassName, null);
1564	}	1571	}
1565	}	1572	}
1566	}	1573	}

Return to bug 321763

Lines 378-387 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseAccessor.java (-14 / +14 lines)
378		378
379	DatabaseQuery query = ((call == null)? null : call.getQuery());	379	DatabaseQuery query = ((call == null)? null : call.getQuery());
380	try {	380	try {
381	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, query, SessionProfiler.ALL);	381	session.startOperationProfile(SessionProfiler.StatementExecute, query, SessionProfiler.ALL);
382	statement.close();	382	statement.close();
383	} finally {	383	} finally {
384	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, query, SessionProfiler.ALL);	384	session.endOperationProfile(SessionProfiler.StatementExecute, query, SessionProfiler.ALL);
385	decrementCallCount();	385	decrementCallCount();
386	// If this is the cached dynamic statement, release it.	386	// If this is the cached dynamic statement, release it.
387	if (statement == this.dynamicStatement) {	387	if (statement == this.dynamicStatement) {
Lines 571-581 Link Here
571	if (session.shouldLog(SessionLog.FINE, SessionLog.SQL)) {// Avoid printing if no logging required.	571	if (session.shouldLog(SessionLog.FINE, SessionLog.SQL)) {// Avoid printing if no logging required.
572	session.log(SessionLog.FINE, SessionLog.SQL, dbCall.getLogString(this), (Object[])null, this, false);	572	session.log(SessionLog.FINE, SessionLog.SQL, dbCall.getLogString(this), (Object[])null, this, false);
573	}	573	}
574	session.startOperationProfile(SessionProfiler.SQL_PREPARE, dbCall.getQuery(), SessionProfiler.ALL);	574	session.startOperationProfile(SessionProfiler.SqlPrepare, dbCall.getQuery(), SessionProfiler.ALL);
575	try {	575	try {
576	statement = dbCall.prepareStatement(this, translationRow, session);	576	statement = dbCall.prepareStatement(this, translationRow, session);
577	} finally {	577	} finally {
578	session.endOperationProfile(SessionProfiler.SQL_PREPARE, dbCall.getQuery(), SessionProfiler.ALL);	578	session.endOperationProfile(SessionProfiler.SqlPrepare, dbCall.getQuery(), SessionProfiler.ALL);
579	}	579	}
580		580
581	// effectively this means that someone is executing an update type query.	581	// effectively this means that someone is executing an update type query.
Lines 611-617 Link Here
611	return dbCall;	611	return dbCall;
612	}	612	}
613		613
614	session.startOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	614	session.startOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
615	try {	615	try {
616	if (dbCall.isOneRowReturned()) {	616	if (dbCall.isOneRowReturned()) {
617	if (resultSet.next()) {	617	if (resultSet.next()) {
Lines 657-663 Link Here
657	}	657	}
658	resultSet.close();// This must be closed in case the statement is cached and not closed.	658	resultSet.close();// This must be closed in case the statement is cached and not closed.
659	} finally {	659	} finally {
660	session.endOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	660	session.endOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
661	}	661	}
662	}	662	}
663	// Log any warnings on finest.	663	// Log any warnings on finest.
Lines 717-723 Link Here
717	final ThreadCursoredList results = new ThreadCursoredList(20);	717	final ThreadCursoredList results = new ThreadCursoredList(20);
718	Thread thread = new Thread() {	718	Thread thread = new Thread() {
719	public void run() {	719	public void run() {
720	session.startOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	720	session.startOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
721	try {	721	try {
722	// Initial next was already validated before this method is called.	722	// Initial next was already validated before this method is called.
723	boolean hasNext = true;	723	boolean hasNext = true;
Lines 748-754 Link Here
748	}	748	}
749	results.throwException(exception);	749	results.throwException(exception);
750	} finally {	750	} finally {
751	session.endOperationProfile(SessionProfiler.ROW_FETCH, dbCall.getQuery(), SessionProfiler.ALL);	751	session.endOperationProfile(SessionProfiler.RowFetch, dbCall.getQuery(), SessionProfiler.ALL);
752	}	752	}
753		753
754	// This is in a separate try block to ensure that the real exception is not masked by the close exception.	754	// This is in a separate try block to ensure that the real exception is not masked by the close exception.
Lines 778-786 Link Here
778		778
779	try {	779	try {
780	if (call != null) {	780	if (call != null) {
781	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, call.getQuery(), SessionProfiler.ALL);	781	session.startOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
782	} else {	782	} else {
783	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, null, SessionProfiler.ALL);	783	session.startOperationProfile(SessionProfiler.StatementExecute, null, SessionProfiler.ALL);
784	}	784	}
785	if ((call != null) && call.isDynamicCall(session)) {	785	if ((call != null) && call.isDynamicCall(session)) {
786	rowCount = statement.executeUpdate(call.getSQLString());	786	rowCount = statement.executeUpdate(call.getSQLString());
Lines 798-806 Link Here
798	}	798	}
799	} finally {	799	} finally {
800	if (call != null) {	800	if (call != null) {
801	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, call.getQuery(), SessionProfiler.ALL);	801	session.endOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
802	} else {	802	} else {
803	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, null, SessionProfiler.ALL);	803	session.endOperationProfile(SessionProfiler.StatementExecute, null, SessionProfiler.ALL);
804	}	804	}
805	}	805	}
806		806
Lines 880-886 Link Here
880	public ResultSet executeSelect(DatabaseCall call, Statement statement, AbstractSession session) throws SQLException {	880	public ResultSet executeSelect(DatabaseCall call, Statement statement, AbstractSession session) throws SQLException {
881	ResultSet resultSet;	881	ResultSet resultSet;
882		882
883	session.startOperationProfile(SessionProfiler.STATEMENT_EXECUTE, call.getQuery(), SessionProfiler.ALL);	883	session.startOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
884	try {	884	try {
885	if (call.isDynamicCall(session)) {	885	if (call.isDynamicCall(session)) {
886	resultSet = statement.executeQuery(call.getSQLString());	886	resultSet = statement.executeQuery(call.getSQLString());
Lines 888-894 Link Here
888	resultSet = ((PreparedStatement)statement).executeQuery();	888	resultSet = ((PreparedStatement)statement).executeQuery();
889	}	889	}
890	} finally {	890	} finally {
891	session.endOperationProfile(SessionProfiler.STATEMENT_EXECUTE, call.getQuery(), SessionProfiler.ALL);	891	session.endOperationProfile(SessionProfiler.StatementExecute, call.getQuery(), SessionProfiler.ALL);
892	}	892	}
893		893
894	// Allow for procs with outputs to be raised as events for error handling.	894	// Allow for procs with outputs to be raised as events for error handling.

Lines 967-972 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AbstractSession.java (+10 lines)
967		967
968	/**	968	/**
969	* INTERNAL:	969	* INTERNAL:
		970	* Updates the count of SessionProfiler event
		971	*/
		972	public void incrementProfile(String operationName, DatabaseQuery query) {
		973	if (this.isInProfile) {
		974	getProfiler().occurred(operationName, query);
		975	}
		976	}
		977
		978	/**
		979	* INTERNAL:
970	* Overridden by subclasses that do more than just execute the call.	980	* Overridden by subclasses that do more than just execute the call.
971	* Executes the call directly on this session and does not check which	981	* Executes the call directly on this session and does not check which
972	* session it should have executed on.	982	* session it should have executed on.

Lines 1495-1500 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkImpl.java (-43 / +39 lines)
1495	protected void commitToDatabaseWithChangeSet(boolean commitTransaction) throws DatabaseException, OptimisticLockException {	1495	protected void commitToDatabaseWithChangeSet(boolean commitTransaction) throws DatabaseException, OptimisticLockException {
1496		1496
1497	try {	1497	try {
		1498	incrementProfile(SessionProfiler.UowCommits);
1498	startOperationProfile(SessionProfiler.UowCommit);	1499	startOperationProfile(SessionProfiler.UowCommit);
1499	// PERF: If this is an empty unit of work, do nothing (but still may need to commit SQL changes).	1500	// PERF: If this is an empty unit of work, do nothing (but still may need to commit SQL changes).
1500	boolean hasChanges = (this.unitOfWorkChangeSet != null) \|\| hasCloneMapping() \|\| hasDeletedObjects() \|\| hasModifyAllQueries() \|\| hasDeferredModifyAllQueries();	1501	boolean hasChanges = (this.unitOfWorkChangeSet != null) \|\| hasCloneMapping() \|\| hasDeletedObjects() \|\| hasModifyAllQueries() \|\| hasDeferredModifyAllQueries();
Lines 3562-3615 Link Here
3562	* support.	3563	* support.
3563	*/	3564	*/
3564	public void performRemove(Object toBeDeleted, Map visitedObjects) {	3565	public void performRemove(Object toBeDeleted, Map visitedObjects) {
3565	try {	3566	if (toBeDeleted == null) {
3566	if (toBeDeleted == null) {	3567	return;
3567	return;	3568	}
3568	}	3569	ClassDescriptor descriptor = getDescriptor(toBeDeleted);
3569	ClassDescriptor descriptor = getDescriptor(toBeDeleted);	3570	if ((descriptor == null) \|\| descriptor.isDescriptorTypeAggregate()) {
3570	if ((descriptor == null) \|\| descriptor.isDescriptorTypeAggregate()) {	3571	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("not_an_entity", new Object[] { toBeDeleted }));
3571	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("not_an_entity", new Object[] { toBeDeleted }));	3572	}
3572	}	3573	logDebugMessage(toBeDeleted, "deleting_object");
3573	logDebugMessage(toBeDeleted, "deleting_object");
3574		3574
3575	startOperationProfile(SessionProfiler.DeletedObject);	3575	//bug 4568370+4599010; fix EntityManager.remove() to handle new objects
3576	//bug 4568370+4599010; fix EntityManager.remove() to handle new objects	3576	if (getDeletedObjects().containsKey(toBeDeleted)){
3577	if (getDeletedObjects().containsKey(toBeDeleted)){	3577	return;
3578	return;	3578	}
3579	}	3579	visitedObjects.put(toBeDeleted,toBeDeleted);
3580	visitedObjects.put(toBeDeleted,toBeDeleted);	3580	Object registeredObject = checkIfAlreadyRegistered(toBeDeleted, descriptor);
3581	Object registeredObject = checkIfAlreadyRegistered(toBeDeleted, descriptor);	3581	if (registeredObject == null) {
3582	if (registeredObject == null) {	3582	Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(toBeDeleted, this);
3583	Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(toBeDeleted, this);	3583	DoesExistQuery existQuery = descriptor.getQueryManager().getDoesExistQuery();
3584	DoesExistQuery existQuery = descriptor.getQueryManager().getDoesExistQuery();	3584	existQuery = (DoesExistQuery)existQuery.clone();
3585	existQuery = (DoesExistQuery)existQuery.clone();	3585	existQuery.setObject(toBeDeleted);
3586	existQuery.setObject(toBeDeleted);	3586	existQuery.setPrimaryKey(primaryKey);
3587	existQuery.setPrimaryKey(primaryKey);	3587	existQuery.setDescriptor(descriptor);
3588	existQuery.setDescriptor(descriptor);	3588	existQuery.setIsExecutionClone(true);
3589	existQuery.setIsExecutionClone(true);
3590		3589
3591	existQuery.setCheckCacheFirst(true);	3590	existQuery.setCheckCacheFirst(true);
3592	if (((Boolean)executeQuery(existQuery)).booleanValue()){	3591	if (((Boolean)executeQuery(existQuery)).booleanValue()){
3593	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("cannot_remove_detatched_entity", new Object[]{toBeDeleted}));	3592	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("cannot_remove_detatched_entity", new Object[]{toBeDeleted}));
3594	}//else, it is a new or previously deleted object that should be ignored (and delete should cascade)	3593	}//else, it is a new or previously deleted object that should be ignored (and delete should cascade)
		3594	} else {
		3595	//fire events only if this is a managed object
		3596	if (descriptor.getEventManager().hasAnyEventListeners()) {
		3597	org.eclipse.persistence.descriptors.DescriptorEvent event = new org.eclipse.persistence.descriptors.DescriptorEvent(toBeDeleted);
		3598	event.setEventCode(DescriptorEventManager.PreRemoveEvent);
		3599	event.setSession(this);
		3600	descriptor.getEventManager().executeEvent(event);
		3601	}
		3602	if (hasNewObjects() && getNewObjectsCloneToOriginal().containsKey(registeredObject)){
		3603	unregisterObject(registeredObject, DescriptorIterator.NoCascading);
3595	} else {	3604	} else {
3596	//fire events only if this is a managed object	3605	getDeletedObjects().put(toBeDeleted, toBeDeleted);
3597	if (descriptor.getEventManager().hasAnyEventListeners()) {
3598	org.eclipse.persistence.descriptors.DescriptorEvent event = new org.eclipse.persistence.descriptors.DescriptorEvent(toBeDeleted);
3599	event.setEventCode(DescriptorEventManager.PreRemoveEvent);
3600	event.setSession(this);
3601	descriptor.getEventManager().executeEvent(event);
3602	}
3603	if (hasNewObjects() && getNewObjectsCloneToOriginal().containsKey(registeredObject)){
3604	unregisterObject(registeredObject, DescriptorIterator.NoCascading);
3605	} else {
3606	getDeletedObjects().put(toBeDeleted, toBeDeleted);
3607	}
3608	}	3606	}
3609	descriptor.getObjectBuilder().cascadePerformRemove(toBeDeleted, this, visitedObjects);
3610	} finally {
3611	endOperationProfile(SessionProfiler.DeletedObject);
3612	}	3607	}
		3608	descriptor.getObjectBuilder().cascadePerformRemove(toBeDeleted, this, visitedObjects);
3613	}	3609	}
3614		3610
3615	/**	3611	/**

Lines 13-18 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/tools/sessionconsole/ProfileBrowserPanel.java (-37 / +24 lines)
13	package org.eclipse.persistence.tools.sessionconsole;	13	package org.eclipse.persistence.tools.sessionconsole;
14		14
15	import java.util.*;	15	import java.util.*;
		16
16	import javax.swing.*;	17	import javax.swing.*;
17	import javax.swing.table.*;	18	import javax.swing.table.*;
18		19
Lines 25-31 Link Here
25	* This panel allows for the browsing of performance profiles.	26	* This panel allows for the browsing of performance profiles.
26	*/	27	*/
27	public class ProfileBrowserPanel extends JPanel {	28	public class ProfileBrowserPanel extends JPanel {
28	private java.util.Vector fieldProfiles = new java.util.Vector();	29	private List<Profile> fieldProfiles = new ArrayList();
29	private JScrollPane ivjProfileScrollPane = null;	30	private JScrollPane ivjProfileScrollPane = null;
30	private JTable ivjProfilesTable = null;	31	private JTable ivjProfilesTable = null;
31	private JComboBox ivjGroupByChoice = null;	32	private JComboBox ivjGroupByChoice = null;
Lines 88-96 Link Here
88	public Vector buildProfileSummaryByClass() {	89	public Vector buildProfileSummaryByClass() {
89	Hashtable summaries = new Hashtable();	90	Hashtable summaries = new Hashtable();
90		91
91	for (Enumeration enumtr = getProfiles().elements();	92	for (Profile profile : getProfiles()) {
92	enumtr.hasMoreElements(); ) {
93	Profile profile = (Profile)enumtr.nextElement();
94	Class domainClass = profile.getDomainClass();	93	Class domainClass = profile.getDomainClass();
95	if (domainClass == null) {	94	if (domainClass == null) {
96	domainClass = Void.class;	95	domainClass = Void.class;
Lines 140-148 Link Here
140	public Vector buildProfileSummaryByQuery() {	139	public Vector buildProfileSummaryByQuery() {
141	Hashtable summaries = new Hashtable();	140	Hashtable summaries = new Hashtable();
142		141
143	for (Enumeration enumtr = getProfiles().elements();	142	for (Profile profile : getProfiles()) {
144	enumtr.hasMoreElements(); ) {
145	Profile profile = (Profile)enumtr.nextElement();
146	Class queryType = profile.getQueryClass();	143	Class queryType = profile.getQueryClass();
147	//CR 3050 PWK - If we don't know the query class, we need to use void.	144	//CR 3050 PWK - If we don't know the query class, we need to use void.
148	//This avoids a null pointer exception when adding to the hashtable.	145	//This avoids a null pointer exception when adding to the hashtable.
Lines 193-201 Link Here
193	public Vector buildProfileSummaryByQueryAndClass() {	190	public Vector buildProfileSummaryByQueryAndClass() {
194	Hashtable summaries = new Hashtable();	191	Hashtable summaries = new Hashtable();
195		192
196	for (Enumeration enumtr = getProfiles().elements();	193	for (Profile profile : getProfiles()) {
197	enumtr.hasMoreElements(); ) {
198	Profile profile = (Profile)enumtr.nextElement();
199	Class queryType = profile.getQueryClass();	194	Class queryType = profile.getQueryClass();
200	Class queryClass = profile.getDomainClass();	195	Class queryClass = profile.getDomainClass();
201	if (queryClass == null) {	196	if (queryClass == null) {
Lines 333-344 Link Here
333	return ivjGroupByLabel;	328	return ivjGroupByLabel;
334	}	329	}
335		330
336	/**	331	public List<Profile> getProfiles() {
337	* Gets the profiles property (java.util.Vector) value.
338	* @return The profiles property value.
339	* @see #setProfiles
340	*/
341	public java.util.Vector getProfiles() {
342	return fieldProfiles;	332	return fieldProfiles;
343	}	333	}
344		334
Lines 501-507 Link Here
501	columns.addElement("SQL Generation");	491	columns.addElement("SQL Generation");
502	model.setColumnIdentifiers(columns);	492	model.setColumnIdentifiers(columns);
503		493
504	Vector profiles = getProfiles();	494	List<Profile> profiles = getProfiles();
505	if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Query")) {	495	if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Query")) {
506	profiles = buildProfileSummaryByQuery();	496	profiles = buildProfileSummaryByQuery();
507	} else if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Class")) {	497	} else if (getGroupByChoice().getModel().getSelectedItem().equals("Group By Class")) {
Lines 510-519 Link Here
510	profiles = buildProfileSummaryByQueryAndClass();	500	profiles = buildProfileSummaryByQueryAndClass();
511	}	501	}
512		502
513	for (Enumeration profileEnum = profiles.elements();	503	for (Profile profile : profiles) {
514	profileEnum.hasMoreElements(); ) {
515	Profile profile = (Profile)profileEnum.nextElement();
516
517	String items[] = new String[13];	504	String items[] = new String[13];
518	if (profile.getQueryClass() == null) {	505	if (profile.getQueryClass() == null) {
519	items[0] = "";	506	items[0] = "";
Lines 535-579 Link Here
535	items[4] =	522	items[4] =
536	new Long(profile.getNumberOfInstancesEffected()).toString();	523	new Long(profile.getNumberOfInstancesEffected()).toString();
537	items[5] = new Long(profile.getObjectsPerSecond()).toString();	524	items[5] = new Long(profile.getObjectsPerSecond()).toString();
538	if (profile.getOperationTimings().containsKey(SessionProfiler.SQL_PREPARE)) {	525	if (profile.getOperationTimings().containsKey(SessionProfiler.SqlPrepare)) {
539	items[6] =	526	items[6] =
540	profile.getOperationTimings().get(SessionProfiler.SQL_PREPARE).toString();	527	profile.getOperationTimings().get(SessionProfiler.SqlPrepare).toString();
541	} else {	528	} else {
542	items[6] = "";	529	items[6] = "";
543	}	530	}
544	if (profile.getOperationTimings().containsKey(SessionProfiler.STATEMENT_EXECUTE)) {	531	if (profile.getOperationTimings().containsKey(SessionProfiler.StatementExecute)) {
545	items[7] =	532	items[7] =
546	profile.getOperationTimings().get(SessionProfiler.STATEMENT_EXECUTE).toString();	533	profile.getOperationTimings().get(SessionProfiler.StatementExecute).toString();
547	} else {	534	} else {
548	items[7] = "";	535	items[7] = "";
549	}	536	}
550	if (profile.getOperationTimings().containsKey(SessionProfiler.ROW_FETCH)) {	537	if (profile.getOperationTimings().containsKey(SessionProfiler.RowFetch)) {
551	items[8] =	538	items[8] =
552	profile.getOperationTimings().get(SessionProfiler.ROW_FETCH).toString();	539	profile.getOperationTimings().get(SessionProfiler.RowFetch).toString();
553	} else {	540	} else {
554	items[8] = "";	541	items[8] = "";
555	}	542	}
556	if (profile.getOperationTimings().containsKey(SessionProfiler.CACHE)) {	543	if (profile.getOperationTimings().containsKey(SessionProfiler.Caching)) {
557	items[9] =	544	items[9] =
558	profile.getOperationTimings().get(SessionProfiler.CACHE).toString();	545	profile.getOperationTimings().get(SessionProfiler.Caching).toString();
559	} else {	546	} else {
560	items[9] = "";	547	items[9] = "";
561	}	548	}
562	if (profile.getOperationTimings().containsKey(SessionProfiler.OBJECT_BUILDING)) {	549	if (profile.getOperationTimings().containsKey(SessionProfiler.ObjectBuilding)) {
563	items[10] =	550	items[10] =
564	profile.getOperationTimings().get(SessionProfiler.OBJECT_BUILDING).toString();	551	profile.getOperationTimings().get(SessionProfiler.ObjectBuilding).toString();
565	} else {	552	} else {
566	items[10] = "";	553	items[10] = "";
567	}	554	}
568	if (profile.getOperationTimings().containsKey(SessionProfiler.QUERY_PREPARE)) {	555	if (profile.getOperationTimings().containsKey(SessionProfiler.QueryPreparation)) {
569	items[11] =	556	items[11] =
570	profile.getOperationTimings().get(SessionProfiler.QUERY_PREPARE).toString();	557	profile.getOperationTimings().get(SessionProfiler.QueryPreparation).toString();
571	} else {	558	} else {
572	items[11] = "";	559	items[11] = "";
573	}	560	}
574	if (profile.getOperationTimings().containsKey(SessionProfiler.SQL_GENERATION)) {	561	if (profile.getOperationTimings().containsKey(SessionProfiler.SqlGeneration)) {
575	items[12] =	562	items[12] =
576	profile.getOperationTimings().get(SessionProfiler.SQL_GENERATION).toString();	563	profile.getOperationTimings().get(SessionProfiler.SqlGeneration).toString();
577	} else {	564	} else {
578	items[12] = "";	565	items[12] = "";
579	}	566	}
Lines 588-595 Link Here
588	* @param profiles The new value for the property.	575	* @param profiles The new value for the property.
589	* @see #getProfiles	576	* @see #getProfiles
590	*/	577	*/
591	public void setProfiles(java.util.Vector profiles) {	578	public void setProfiles(List<Profile> profiles) {
592	java.util.Vector oldValue = fieldProfiles;	579	List<Profile> oldValue = fieldProfiles;
593	fieldProfiles = profiles;	580	fieldProfiles = profiles;
594	firePropertyChange("profiles", oldValue, profiles);	581	firePropertyChange("profiles", oldValue, profiles);
595		582

Lines 231-243 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatasourceAccessor.java (-19 / +25 lines)
231	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "begin_transaction", (Object[])null, this);	231	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "begin_transaction", (Object[])null, this);
232		232
233	try {	233	try {
234	session.startOperationProfile(SessionProfiler.TRANSACTION);	234	session.startOperationProfile(SessionProfiler.Transaction);
235	incrementCallCount(session);	235	incrementCallCount(session);
236	basicBeginTransaction(session);	236	basicBeginTransaction(session);
237	this.isInTransaction = true;	237	this.isInTransaction = true;
238	} finally {	238	} finally {
239	decrementCallCount();	239	decrementCallCount();
240	session.endOperationProfile(SessionProfiler.TRANSACTION);	240	session.endOperationProfile(SessionProfiler.Transaction);
241	}	241	}
242	}	242	}
243		243
Lines 381-387 Link Here
381	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "commit_transaction", (Object[])null, this);	381	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "commit_transaction", (Object[])null, this);
382		382
383	try {	383	try {
384	session.startOperationProfile(SessionProfiler.TRANSACTION);	384	session.startOperationProfile(SessionProfiler.Transaction);
385	incrementCallCount(session);	385	incrementCallCount(session);
386	basicCommitTransaction(session);	386	basicCommitTransaction(session);
387		387
Lines 392-398 Link Here
392	} finally {	392	} finally {
393	sequencingCallback = null;	393	sequencingCallback = null;
394	decrementCallCount();	394	decrementCallCount();
395	session.endOperationProfile(SessionProfiler.TRANSACTION);	395	session.endOperationProfile(SessionProfiler.Transaction);
396	}	396	}
397	}	397	}
398		398
Lines 401-408 Link Here
401	* Catch exceptions and re-throw as EclipseLink exceptions.	401	* Catch exceptions and re-throw as EclipseLink exceptions.
402	*/	402	*/
403	public void connect(Login login, AbstractSession session) throws DatabaseException {	403	public void connect(Login login, AbstractSession session) throws DatabaseException {
404	session.startOperationProfile(SessionProfiler.CONNECT);	404	session.startOperationProfile(SessionProfiler.ConnectionManagement);
405	session.incrementProfile(SessionProfiler.TlConnects);	405	session.incrementProfile(SessionProfiler.Connects);
406		406
407	try {	407	try {
408	if (session.shouldLog(SessionLog.CONFIG, SessionLog.CONNECTION)) {// Avoid printing if no logging required.	408	if (session.shouldLog(SessionLog.CONFIG, SessionLog.CONNECTION)) {// Avoid printing if no logging required.
Lines 427-433 Link Here
427	decrementCallCount();	427	decrementCallCount();
428	}	428	}
429	} finally {	429	} finally {
430	session.endOperationProfile(SessionProfiler.CONNECT);	430	session.endOperationProfile(SessionProfiler.ConnectionManagement);
431	}	431	}
432	}	432	}
433		433
Lines 471-483 Link Here
471	if (this.datasourceConnection == null) {	471	if (this.datasourceConnection == null) {
472	return;	472	return;
473	}	473	}
474	session.incrementProfile(SessionProfiler.TlDisconnects);	474	session.incrementProfile(SessionProfiler.Disconnects);
475	session.startOperationProfile(SessionProfiler.CONNECT);	475	session.startOperationProfile(SessionProfiler.ConnectionManagement);
476	releaseCustomizer();	476	try {
477	closeDatasourceConnection();	477	releaseCustomizer();
478	this.datasourceConnection = null;	478	closeDatasourceConnection();
479	this.isInTransaction = true;	479	this.datasourceConnection = null;
480	session.endOperationProfile(SessionProfiler.CONNECT);	480	this.isInTransaction = true;
		481	} finally {
		482	session.endOperationProfile(SessionProfiler.ConnectionManagement);
		483	}
481	}	484	}
482		485
483	/**	486	/**
Lines 554-562 Link Here
554	*/	557	*/
555	protected void reconnect(AbstractSession session) throws DatabaseException {	558	protected void reconnect(AbstractSession session) throws DatabaseException {
556	session.log(SessionLog.FINEST, SessionLog.CONNECTION, "reconnecting_to_external_connection_pool");	559	session.log(SessionLog.FINEST, SessionLog.CONNECTION, "reconnecting_to_external_connection_pool");
557	session.startOperationProfile(SessionProfiler.CONNECT);	560	session.startOperationProfile(SessionProfiler.ConnectionManagement);
558	connectInternal(this.login, session);	561	try {
559	session.endOperationProfile(SessionProfiler.CONNECT);	562	connectInternal(this.login, session);
		563	} finally {
		564	session.endOperationProfile(SessionProfiler.ConnectionManagement);
		565	}
560	}	566	}
561		567
562	/**	568	/**
Lines 658-671 Link Here
658	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "rollback_transaction", (Object[])null, this);	664	session.log(SessionLog.FINER, SessionLog.TRANSACTION, "rollback_transaction", (Object[])null, this);
659		665
660	try {	666	try {
661	session.startOperationProfile(SessionProfiler.TRANSACTION);	667	session.startOperationProfile(SessionProfiler.Transaction);
662	incrementCallCount(session);	668	incrementCallCount(session);
663	basicRollbackTransaction(session);	669	basicRollbackTransaction(session);
664	} finally {	670	} finally {
665	this.isInTransaction = false;	671	this.isInTransaction = false;
666	sequencingCallback = null;	672	sequencingCallback = null;
667	decrementCallCount();	673	decrementCallCount();
668	session.endOperationProfile(SessionProfiler.TRANSACTION);	674	session.endOperationProfile(SessionProfiler.Transaction);
669	}	675	}
670	}	676	}
671		677

Lines 185-195 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DynamicSQLBatchWritingMechanism.java (-4 / +4 lines)
185	writer.write(platform.getBatchEndString());	185	writer.write(platform.getBatchEndString());
186		186
187	try {	187	try {
188	session.startOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	188	session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
189	try {	189	try {
190	statement = this.databaseAccessor.getConnection().prepareStatement(writer.toString());	190	statement = this.databaseAccessor.getConnection().prepareStatement(writer.toString());
191	} finally {	191	} finally {
192	session.endOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	192	session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
193	}	193	}
194	} catch (SQLException exception) {	194	} catch (SQLException exception) {
195	//If this is a connection from an external pool then closeStatement will close the connection.	195	//If this is a connection from an external pool then closeStatement will close the connection.
Lines 221-227 Link Here
221	Statement statement = null;	221	Statement statement = null;
222		222
223	try {	223	try {
224	session.startOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	224	session.startOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
225	try {	225	try {
226	statement = this.databaseAccessor.getConnection().createStatement();	226	statement = this.databaseAccessor.getConnection().createStatement();
227	for (Iterator sqlStringsIterator = this.sqlStrings.iterator();	227	for (Iterator sqlStringsIterator = this.sqlStrings.iterator();
Lines 233-239 Link Here
233	statement.setQueryTimeout(queryTimeoutCache);	233	statement.setQueryTimeout(queryTimeoutCache);
234	}	234	}
235	} finally {	235	} finally {
236	session.endOperationProfile(SessionProfiler.SQL_PREPARE, null, SessionProfiler.ALL);	236	session.endOperationProfile(SessionProfiler.SqlPrepare, null, SessionProfiler.ALL);
237	}	237	}
238	} catch (SQLException exception) {	238	} catch (SQLException exception) {
239	//If this is a connection from an external pool then closeStatement will close the connection.	239	//If this is a connection from an external pool then closeStatement will close the connection.

Lines 461-501 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java (-34 / +27 lines)
461	public Object buildObject(ObjectBuildingQuery query, AbstractRecord databaseRow, JoinedAttributeManager joinManager) throws DatabaseException, QueryException {	461	public Object buildObject(ObjectBuildingQuery query, AbstractRecord databaseRow, JoinedAttributeManager joinManager) throws DatabaseException, QueryException {
462	// Profile object building.	462	// Profile object building.
463	AbstractSession session = query.getSession();	463	AbstractSession session = query.getSession();
464	session.startOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);	464	session.startOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);
465
466	Object primaryKey = extractPrimaryKeyFromRow(databaseRow, session);
467
468	// Check for null primary key, this is not allowed.
469	if ((primaryKey == null) && (!query.hasPartialAttributeExpressions()) && (!this.descriptor.isAggregateCollectionDescriptor())) {
470	// Profile object building.
471	session.endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);
472
473	//BUG 3168689: EJBQL: "Select Distinct s.customer from SpouseBean s"
474	//BUG 3168699: EJBQL: "Select s.customer from SpouseBean s where s.id = '6'"
475	//If we return either a single null, or a Collection containing at least
476	//one null, then we want the nulls returned/included if the indicated
477	//property is set in the query. (As opposed to throwing an Exception).
478	if (query.shouldBuildNullForNullPk()) {
479	return null;
480	} else {
481	throw QueryException.nullPrimaryKeyInBuildingObject(query, databaseRow);
482	}
483	}
484	ClassDescriptor concreteDescriptor = this.descriptor;
485	if (concreteDescriptor.hasInheritance() && concreteDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
486	Class classValue = concreteDescriptor.getInheritancePolicy().classFromRow(databaseRow, session);
487	concreteDescriptor = concreteDescriptor.getInheritancePolicy().getDescriptor(classValue);
488	if ((concreteDescriptor == null) && query.hasPartialAttributeExpressions()) {
489	concreteDescriptor = this.descriptor;
490	}
491	if (concreteDescriptor == null) {
492	// Profile object building.
493	session.endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);
494	throw QueryException.noDescriptorForClassFromInheritancePolicy(query, classValue);
495	}
496	}
497	Object domainObject = null;	465	Object domainObject = null;
498	try {	466	try {
		467	Object primaryKey = extractPrimaryKeyFromRow(databaseRow, session);
		468	// Check for null primary key, this is not allowed.
		469	if ((primaryKey == null) && (!query.hasPartialAttributeExpressions()) && (!this.descriptor.isAggregateCollectionDescriptor())) {
		470	//BUG 3168689: EJBQL: "Select Distinct s.customer from SpouseBean s"
		471	//BUG 3168699: EJBQL: "Select s.customer from SpouseBean s where s.id = '6'"
		472	//If we return either a single null, or a Collection containing at least
		473	//one null, then we want the nulls returned/included if the indicated
		474	//property is set in the query. (As opposed to throwing an Exception).
		475	if (query.shouldBuildNullForNullPk()) {
		476	return null;
		477	} else {
		478	throw QueryException.nullPrimaryKeyInBuildingObject(query, databaseRow);
		479	}
		480	}
		481	ClassDescriptor concreteDescriptor = this.descriptor;
		482	if (concreteDescriptor.hasInheritance() && concreteDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
		483	Class classValue = concreteDescriptor.getInheritancePolicy().classFromRow(databaseRow, session);
		484	concreteDescriptor = concreteDescriptor.getInheritancePolicy().getDescriptor(classValue);
		485	if ((concreteDescriptor == null) && query.hasPartialAttributeExpressions()) {
		486	concreteDescriptor = this.descriptor;
		487	}
		488	if (concreteDescriptor == null) {
		489	throw QueryException.noDescriptorForClassFromInheritancePolicy(query, classValue);
		490	}
		491	}
499	if (session.isUnitOfWork()) {	492	if (session.isUnitOfWork()) {
500	// Do not wrap yet if in UnitOfWork, as there is still much more	493	// Do not wrap yet if in UnitOfWork, as there is still much more
501	// processing ahead.	494	// processing ahead.
Lines 512-518 Link Here
512	}	505	}
513	}	506	}
514	} finally {	507	} finally {
515	session.endOperationProfile(SessionProfiler.OBJECT_BUILDING, query, SessionProfiler.ALL);	508	session.endOperationProfile(SessionProfiler.ObjectBuilding, query, SessionProfiler.ALL);
516	}	509	}
517	return domainObject;	510	return domainObject;
518	}	511	}

Lines 365-401 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/StatementQueryMechanism.java (-22 / +24 lines)
365	*/	365	*/
366	protected void setCallFromStatement() {	366	protected void setCallFromStatement() {
367	// Profile SQL generation.	367	// Profile SQL generation.
368	getSession().startOperationProfile(SessionProfiler.SQL_GENERATION, getQuery(), SessionProfiler.ALL);	368	getSession().startOperationProfile(SessionProfiler.SqlGeneration, getQuery(), SessionProfiler.ALL);
369	if (hasMultipleStatements()) {	369	try {
370	for (Enumeration statementEnum = getSQLStatements().elements(); statementEnum.hasMoreElements();) {	370	if (hasMultipleStatements()) {
		371	for (Enumeration statementEnum = getSQLStatements().elements(); statementEnum.hasMoreElements();) {
		372	DatabaseCall call = null;
		373	if (getDescriptor() != null) {
		374	call = getDescriptor().buildCallFromStatement((SQLStatement)statementEnum.nextElement(), getSession());
		375	} else {
		376	call = ((SQLStatement)statementEnum.nextElement()).buildCall(getSession());
		377	}
		378
		379	// In case of update call may be null if no update required.
		380	if (call != null) {
		381	addCall(call);
		382	}
		383	}
		384	} else {
371	DatabaseCall call = null;	385	DatabaseCall call = null;
372	if (getDescriptor() != null) {	386	if (getDescriptor() != null) {
373	call = getDescriptor().buildCallFromStatement((SQLStatement)statementEnum.nextElement(), getSession());	387	call = getDescriptor().buildCallFromStatement(getSQLStatement(), getSession());
374	} else {	388	} else {
375	call = ((SQLStatement)statementEnum.nextElement()).buildCall(getSession());	389	call = getSQLStatement().buildCall(getSession());
376	}	390	}
377		391
378	// In case of update call may be null if no update required.	392	// In case of update call may be null if no update required.
379	if (call != null) {	393	if (call != null) {
380	addCall(call);	394	setCall(call);
381	}	395	}
382	}	396	}
383	} else {	397	} finally {
384	DatabaseCall call = null;	398	// Profile SQL generation.
385	if (getDescriptor() != null) {	399	getSession().endOperationProfile(SessionProfiler.SqlGeneration, getQuery(), SessionProfiler.ALL);
386	call = getDescriptor().buildCallFromStatement(getSQLStatement(), getSession());
387	} else {
388	call = getSQLStatement().buildCall(getSession());
389	}
390
391	// In case of update call may be null if no update required.
392	if (call != null) {
393	setCall(call);
394	}
395	}	400	}
396
397	// Profile SQL generation.
398	getSession().endOperationProfile(SessionProfiler.SQL_GENERATION, getQuery(), SessionProfiler.ALL);
399	}	401	}
400		402
401	/**	403	/**

Lines 327-340 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/MergeManager.java (-9 / +7 lines)
327	*/	327	*/
328	public void mergeChangesFromChangeSet(UnitOfWorkChangeSet uowChangeSet) {	328	public void mergeChangesFromChangeSet(UnitOfWorkChangeSet uowChangeSet) {
329	this.session.startOperationProfile(SessionProfiler.DistributedMerge);	329	this.session.startOperationProfile(SessionProfiler.DistributedMerge);
330	// Ensure concurrency if cache isolation requires.
331	this.session.getIdentityMapAccessorInstance().acquireWriteLock();
332	this.session.log(SessionLog.FINER, SessionLog.PROPAGATION, "received_updates_from_remote_server");
333	if (this.session.hasEventManager()) {
334	this.session.getEventManager().preDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
335	}
336
337	try {	330	try {
		331	// Ensure concurrency if cache isolation requires.
		332	this.session.getIdentityMapAccessorInstance().acquireWriteLock();
		333	this.session.log(SessionLog.FINER, SessionLog.PROPAGATION, "received_updates_from_remote_server");
		334	if (this.session.hasEventManager()) {
		335	this.session.getEventManager().preDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
		336	}
338	// Iterate over each clone and let the object build merge to clones into the originals.	337	// Iterate over each clone and let the object build merge to clones into the originals.
339	this.session.getIdentityMapAccessorInstance().getWriteLockManager().acquireRequiredLocks(this, uowChangeSet);	338	this.session.getIdentityMapAccessorInstance().getWriteLockManager().acquireRequiredLocks(this, uowChangeSet);
340	Iterator objectChangeEnum = uowChangeSet.getAllChangeSets().keySet().iterator();	339	Iterator objectChangeEnum = uowChangeSet.getAllChangeSets().keySet().iterator();
Lines 358-364 Link Here
358	while (deletedObjects.hasNext()) {	357	while (deletedObjects.hasNext()) {
359	ObjectChangeSet changeSet = (ObjectChangeSet)deletedObjects.next();	358	ObjectChangeSet changeSet = (ObjectChangeSet)deletedObjects.next();
360	changeSet.removeFromIdentityMap(this.session);	359	changeSet.removeFromIdentityMap(this.session);
361	this.session.incrementProfile(SessionProfiler.DeletedObject);
362	}	360	}
363	}	361	}
364	} catch (RuntimeException exception) {	362	} catch (RuntimeException exception) {
Lines 366-375 Link Here
366	} finally {	364	} finally {
367	this.session.getIdentityMapAccessorInstance().getWriteLockManager().releaseAllAcquiredLocks(this);	365	this.session.getIdentityMapAccessorInstance().getWriteLockManager().releaseAllAcquiredLocks(this);
368	this.session.getIdentityMapAccessorInstance().releaseWriteLock();	366	this.session.getIdentityMapAccessorInstance().releaseWriteLock();
		367	this.session.endOperationProfile(SessionProfiler.DistributedMerge);
369	if (this.session.hasEventManager()) {	368	if (this.session.hasEventManager()) {
370	this.session.getEventManager().postDistributedMergeUnitOfWorkChangeSet(uowChangeSet);	369	this.session.getEventManager().postDistributedMergeUnitOfWorkChangeSet(uowChangeSet);
371	}	370	}
372	this.session.endOperationProfile(SessionProfiler.DistributedMerge);
373	}	371	}
374	}	372	}
375		373

Lines 149-158 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelModifyQuery.java (-4 / +16 lines)
149	* Return the domain class associated with this query.	149	* Return the domain class associated with this query.
150	*/	150	*/
151	public Class getReferenceClass() {	151	public Class getReferenceClass() {
152	if (getObject() == null) {	152	if (this.object == null) {
		153	if (this.descriptor != null) {
		154	return this.descriptor.getJavaClass();
		155	}
153	return null;	156	return null;
154	}	157	}
155	return getObject().getClass();	158	return this.object.getClass();
156	}	159	}
157		160
158	/**	161	/**
Lines 162-175 Link Here
162	* is specified at runtime, this will not be an issue.	165	* is specified at runtime, this will not be an issue.
163	*/	166	*/
164	public String getReferenceClassName() {	167	public String getReferenceClassName() {
165	if (getReferenceClass() != null) {	168	Class referenceClass = getReferenceClass();
166	return getReferenceClass().getName();	169	if (referenceClass != null) {
		170	return referenceClass.getName();
167	} else {	171	} else {
168	return null;	172	return null;
169	}	173	}
170	}	174	}
171		175
172	/**	176	/**
		177	* INTERNAL:
		178	* Return the name to use for the query in performance monitoring.
		179	*/
		180	public void resetMonitorName() {
		181	this.monitorName = getClass().getSimpleName() + ":" + getReferenceClassName();
		182	}
		183
		184	/**
173	* PUBLIC:	185	* PUBLIC:
174	* Return if this is an object level modify query.	186	* Return if this is an object level modify query.
175	*/	187	*/

Lines 416-422 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java (-3 / +3 lines)
416	cloneQuery.orderByExpressions = new ArrayList<Expression>(this.orderByExpressions);	416	cloneQuery.orderByExpressions = new ArrayList<Expression>(this.orderByExpressions);
417	}	417	}
418	if (this.fetchGroup != null) {	418	if (this.fetchGroup != null) {
419	cloneQuery.fetchGroup = (FetchGroup)this.fetchGroup.clone();	419	cloneQuery.fetchGroup = this.fetchGroup.clone();
420	// don't clone immutable entityFetchGroup	420	// don't clone immutable entityFetchGroup
421	}	421	}
422	return cloneQuery;	422	return cloneQuery;
Lines 637-649 Link Here
637	ClassDescriptor referenceDescriptor = mapping.getReferenceDescriptor();	637	ClassDescriptor referenceDescriptor = mapping.getReferenceDescriptor();
638		638
639	// Add the fields defined by the nested fetch group - if it exists.	639	// Add the fields defined by the nested fetch group - if it exists.
640	if(referenceDescriptor != null && referenceDescriptor.hasFetchGroupManager()) {	640	if (referenceDescriptor != null && referenceDescriptor.hasFetchGroupManager()) {
641	ObjectLevelReadQuery nestedQuery = getJoinedAttributeManager().getNestedJoinedMappingQuery(expression);	641	ObjectLevelReadQuery nestedQuery = getJoinedAttributeManager().getNestedJoinedMappingQuery(expression);
642	FetchGroup nestedFetchGroup = nestedQuery.getExecutionFetchGroup();	642	FetchGroup nestedFetchGroup = nestedQuery.getExecutionFetchGroup();
643	if(nestedFetchGroup != null) {	643	if(nestedFetchGroup != null) {
644	List<DatabaseField> nestedFields = nestedQuery.getFetchGroupSelectionFields(mapping);	644	List<DatabaseField> nestedFields = nestedQuery.getFetchGroupSelectionFields(mapping);
645	for(DatabaseField field : nestedFields) {	645	for(DatabaseField field : nestedFields) {
646	fields.add(new FieldExpression((DatabaseField)field, expression));	646	fields.add(new FieldExpression(field, expression));
647	}	647	}
648	return;	648	return;
649	}	649	}

Lines 28-33 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java (-7 / +12 lines)
28	import org.eclipse.persistence.descriptors.DescriptorQueryManager;	28	import org.eclipse.persistence.descriptors.DescriptorQueryManager;
29	import org.eclipse.persistence.exceptions.*;	29	import org.eclipse.persistence.exceptions.*;
30	import org.eclipse.persistence.expressions.*;	30	import org.eclipse.persistence.expressions.*;
		31	import org.eclipse.persistence.sessions.SessionProfiler;
31	import org.eclipse.persistence.sessions.remote.*;	32	import org.eclipse.persistence.sessions.remote.*;
32	import org.eclipse.persistence.tools.profiler.QueryMonitor;	33	import org.eclipse.persistence.tools.profiler.QueryMonitor;
33		34
Lines 251-267 Link Here
251		252
252	// check locking. If clone has not been locked, do not early return cached object	253	// check locking. If clone has not been locked, do not early return cached object
253	if (isLockQuery() && (session.isUnitOfWork() && !((UnitOfWorkImpl)session).isPessimisticLocked(cachedObject))) {	254	if (isLockQuery() && (session.isUnitOfWork() && !((UnitOfWorkImpl)session).isPessimisticLocked(cachedObject))) {
254	if (QueryMonitor.shouldMonitor()) {
255	QueryMonitor.incrementReadObjectMisses(this);
256	}
257	return null;	255	return null;
258	}	256	}
259	if (QueryMonitor.shouldMonitor()) {	257	if (QueryMonitor.shouldMonitor()) {
260	QueryMonitor.incrementReadObjectHits(this);	258	QueryMonitor.incrementReadObjectHits(this);
261	}	259	}
		260	session.incrementProfile(SessionProfiler.CacheHits, this);
262	} else {	261	} else {
263	if (QueryMonitor.shouldMonitor()) {	262	if (!session.isUnitOfWork()) {
264	QueryMonitor.incrementReadObjectMisses(this);	263	if (QueryMonitor.shouldMonitor()) {
		264	QueryMonitor.incrementReadObjectMisses(this);
		265	}
		266	session.incrementProfile(SessionProfiler.CacheMisses, this);
265	}	267	}
266	}	268	}
267	if (shouldUseWrapperPolicy()) {	269	if (shouldUseWrapperPolicy()) {
Lines 269-276 Link Here
269	}	271	}
270	return cachedObject;	272	return cachedObject;
271	} else {	273	} else {
272	if (QueryMonitor.shouldMonitor()) {	274	if (!session.isUnitOfWork()) {
273	QueryMonitor.incrementReadObjectMisses(this);	275	if (QueryMonitor.shouldMonitor()) {
		276	QueryMonitor.incrementReadObjectMisses(this);
		277	}
		278	session.incrementProfile(SessionProfiler.CacheMisses, this);
274	}	279	}
275	return null;	280	return null;
276	}	281	}

Lines 27-99 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/SessionProfiler.java (-66 / +47 lines)
27	public static final int HEAVY = 10;	27	public static final int HEAVY = 10;
28	public static final int ALL = Integer.MAX_VALUE;	28	public static final int ALL = Integer.MAX_VALUE;
29		29
30	//nouns type display name	30	// Sensors display name
31	public static final String TopLinkRootNoun = "/TopLink";	31	public static final String SessionName = "Info:SessionName";
32	public static final String SessionNounType = "TopLink Session";	32	public static final String LoginTime = "Info:LoginTime";
33	public static final String TransactionNounType = "TopLink Transaction";	33	public static final String RcmStatus = "Info:CacheCoordinationStatus";
34	public static final String QueryNounType = "TopLink Queries";	34	public static final String CachedObjects = "Info:CachedObjects";//TODO
35	public static final String RcmNounType = "TopLink RCM";	35
36	public static final String ConnectionNounType = "TopLink Connections";	36	public static final String ClientSessionCreated = "Counter:ClientSessionCreates";
37	public static final String CacheNounType = "TopLink Cache";	37	public static final String UowCreated = "Counter:UnitOfWorkCreates";
38	public static final String MiscellaneousNounType = "TopLink Miscellaneous";	38	public static final String UowCommits = "Counter:UnitOfWorkCommits";
		39	public static final String UowRollbacks = "Counter:UnitOfWorkRollbacks";
		40	public static final String OptimisticLockException = "Counter:OptimisticLocks";
		41	public static final String RcmReceived = "Counter:MessagesReceived";
		42	public static final String RcmSent = "Counter:MessagesSent";
		43	public static final String RemoteChangeSet = "Counter:RemoteChangeSets";
		44	public static final String Connects = "Counter:ConnectCalls";
		45	public static final String Disconnects = "Counter:DisconnectCalls";
		46	public static final String CacheHits = "Counter:CacheHits";
		47	public static final String CacheMisses = "Counter:CacheMisses";
		48	public static final String ChangeSetsProcessed = "Counter:ChangesProcessed";
		49	public static final String ChangeSetsNotProcessed = "Counter:ChangesNotProcessed";
		50
		51	public static final String DescriptorEvent = "Timer:DescriptorEvents";
		52	public static final String SessionEvent = "Timer:SessionEvents";
		53	public static final String QueryPreparation = "Timer:QueryPreparation";
		54	public static final String SqlGeneration = "Timer:SqlGeneration";
		55	public static final String SqlPrepare = "Timer:SqlPrepare";
		56	public static final String StatementExecute = "Timer:StatementExecute";
		57	public static final String RowFetch = "Timer:RowFetch";
		58	public static final String ObjectBuilding = "Timer:ObjectBuilding";
		59	public static final String Register = "Timer:Register";
		60	public static final String Merge = "Timer:Merge";
		61	public static final String DistributedMerge = "Timer:DistributedMerge";
		62	public static final String AssignSequence = "Timer:Sequencing";
		63	public static final String Caching = "Timer:Caching";
		64	public static final String ConnectionManagement = "Timer:ConnectionManagement";
		65	public static final String Logging = "Timer:Logging";
		66	public static final String JtsBeforeCompletion = "Timer:TXBeforeCompletion";
		67	public static final String JtsAfterCompletion = "Timer:TXAfterCompletion";
		68	public static final String Transaction = "Timer:Transactions";
		69	public static final String UowCommit = "Timer:UnitOfWorkCommit";
		70	public static final String ConnectionPing = "Timer:ConnectionPing";
39		71
40	//dms sensors display name
41	public static final String SessionName = "SessionName";
42	public static final String LoginTime = "loginTime";
43	public static final String ClientSessionCreated = "ClientSession";
44	public static final String UowCreated = "UnitOfWork";
45	public static final String UowCommit = "UnitOfWorkCommits";
46	public static final String UowRollbacks = "UnitOfWorkRollbacks";
47	public static final String OptimisticLockException = "OptimisticLocks";
48	public static final String RcmStatus = "RCMStatus";
49	public static final String RcmReceived = "MessagesReceived";
50	public static final String RcmSent = "MessagesSent";
51	public static final String RemoteChangeSet = "RemoteChangeSets";
52	public static final String TlConnects = "ConnectCalls";
53	public static final String TlDisconnects = "DisconnectCalls";
54	public static final String CachedObjects = "CachedObjects";
55	public static final String CacheHits = "CacheHits";
56	public static final String CacheMisses = "CacheMisses";
57	public static final String ChangeSetsProcessed = "ChangesProcessed";
58	public static final String ChangeSetsNotProcessed = "ChangesNotProcessed";
59	public static final String DescriptorEvent = "DescriptorEvents";
60	public static final String SessionEvent = "SessionEvents";
61	public static final String ConnectionInUse = "ConnectionsInUse";
62	public static final String QueryPreparation = "QueryPreparation";
63	public static final String SqlGeneration = "SqlGeneration";
64	public static final String DatabaseExecute = "DatabaseExecute";
65	public static final String SqlPrepare = "SqlPrepare";
66	public static final String RowFetch = "RowFetch";
67	public static final String ObjectBuilding = "ObjectBuilding";
68	public static final String MergeTime = "MergeTime";
69	public static final String UnitOfWorkRegister = "UnitOfWorkRegister";
70	public static final String DistributedMergeDmsDisplayName = "DistributedMerge";
71	public static final String Sequencing = "Sequencing";
72	public static final String Caching = "Caching";
73	public static final String ConnectionManagement = "ConnectionManagement";
74	public static final String LoggingDMSDisPlayName = "Logging";
75	public static final String JtsBeforeCompletion = "TXBeforeCompletion";
76	public static final String JtsAfterCompletion = "TXAfterCompletion";
77	public static final String ConnectionPing = "ConnectionHealthTest";
78
79	//Token used by existed default performance profiler
80	public static final String Register = "register";
81	public static final String Merge = "merge";
82	public static final String AssignSequence = "assign sequence";
83	public static final String DistributedMerge = "distributed merge";
84	public static final String DeletedObject = "deleted object";
85	public static final String Wrapping = "wrapping";
86	public static final String Logging = "logging";
87	public static final String OBJECT_BUILDING = "object building";
88	public static final String SQL_GENERATION = "sql generation";
89	public static final String QUERY_PREPARE = "query prepare";
90	public static final String STATEMENT_EXECUTE = "sql execute";
91	public static final String ROW_FETCH = "row fetch";
92	public static final String SQL_PREPARE = "sql prepare";
93	public static final String TRANSACTION = "transactions";
94	public static final String CONNECT = "connect";
95	public static final String CACHE = "cache";
96
97	/**	72	/**
98	* INTERNAL:	73	* INTERNAL:
99	* End the operation timing.	74	* End the operation timing.
Lines 145-150 Link Here
145	* Increase DMS Event sensor occurrence.(DMS)	120	* Increase DMS Event sensor occurrence.(DMS)
146	*/	121	*/
147	public void occurred(String operationName);	122	public void occurred(String operationName);
		123
		124	/**
		125	* INTERNAL:
		126	* Increase DMS Event sensor occurrence.(DMS)
		127	*/
		128	public void occurred(String operationName, DatabaseQuery query);
148		129
149	/**	130	/**
150	* INTERNAL:	131	* INTERNAL:

Line 0 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/tools/profiler/PerformanceMonitor.java (+270 lines)
		1	/*******************************************************************************
		2	* Copyright (c) 2010 Oracle. All rights reserved.
		3	* This program and the accompanying materials are made available under the
		4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
		5	* which accompanies this distribution.
		6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
		7	* and the Eclipse Distribution License is available at
		8	* http://www.eclipse.org/org/documents/edl-v10.php.
		9	*
		10	* Contributors:
		11	* James Sutherland (Oracle) - initial API and implementation
		12	******************************************************************************/
		13	package org.eclipse.persistence.tools.profiler;
		14
		15	import java.text.NumberFormat;
		16	import java.util.*;
		17	import java.io.*;
		18
		19	import org.eclipse.persistence.queries.*;
		20	import org.eclipse.persistence.sessions.Record;
		21	import org.eclipse.persistence.sessions.SessionProfiler;
		22	import org.eclipse.persistence.internal.sessions.AbstractRecord;
		23	import org.eclipse.persistence.internal.sessions.AbstractSession;
		24
		25	/**
		26	* <p><b>Purpose</b>: A tool used to provide performance monitoring information in a server environment.
		27	*
		28	* @since EclipseLink 2.2
		29	* @author James Sutherland
		30	*/
		31	public class PerformanceMonitor implements Serializable, Cloneable, SessionProfiler {
		32	protected static final String COUNTER = "Counter:";
		33	protected static final String TIMER = "Timer:";
		34
		35	transient protected AbstractSession session;
		36	protected Map<String, Object> operationTimings;
		37	protected Map<Integer, Map<String, Long>> operationStartTimesByThread;//facilitates concurrency
		38	protected long lastDumpTime;
		39	protected long dumpTime;
		40	protected int profileWeight;
		41
		42	/**
		43	* PUBLIC:
		44	* Create a new profiler.
		45	* The profiler can be registered with a session to log performance information on queries.
		46	*/
		47	public PerformanceMonitor() {
		48	this.operationTimings = new Hashtable();
		49	this.operationStartTimesByThread = new Hashtable();
		50	this.lastDumpTime = System.currentTimeMillis();
		51	this.dumpTime = 60000; // 1 minute
		52	this.profileWeight = SessionProfiler.ALL;
		53	}
		54
		55	/**
		56	* Return the number of milliseconds after which the monitor results should be logged.
		57	*/
		58	public long getDumpTime() {
		59	return dumpTime;
		60	}
		61
		62	/**
		63	* Set the number of milliseconds after which the monitor results should be logged.
		64	*/
65	public void setDumpTime(long dumpTime) {
66	this.dumpTime = dumpTime;
67	}
68
69	public PerformanceMonitor clone() {
70	try {
71	return (PerformanceMonitor)super.clone();
72	} catch (CloneNotSupportedException exception) {
73	throw new InternalError();
74	}
75	}
76
77	/**
78	* Log the results after a set amount of time has passed.
79	*/
80	public void checkDumpTime() {
81	if ((System.currentTimeMillis() - this.lastDumpTime) > this.dumpTime) {
82	dumpResults();
83	}
84	}
85
86	/**
87	* Log the results to the session's log (System.out).
88	*/
89	public void dumpResults() {
90	this.lastDumpTime = System.currentTimeMillis();
91	StringWriter writer = new StringWriter();
92	writer.write("\nPerformance Monitor:");
93	writer.write(String.valueOf(this.lastDumpTime));
94	writer.write("\nOperation\tValue (ns)\n");
95	Set<String> operations = new TreeSet<String>(this.operationTimings.keySet());
96	NumberFormat formater = NumberFormat.getInstance();
97	for (String operation : operations) {
98	Object value = this.operationTimings.get(operation);
99	if (value == null) {
100	value = Long.valueOf(0);
101	}
102	writer.write(operation);
103	writer.write("\t");
104	if (value instanceof Long) {
105	writer.write(formater.format(value));
106	} else {
107	writer.write(value.toString());
108	}
109	writer.write("\n");
110	}
111	try {
112	this.session.getLog().write(writer.toString());
113	this.session.getLog().flush();
114	} catch (IOException error) {
115	// ignore
116	}
117	}
118
119	/**
120	* INTERNAL:
121	* End the operation timing.
122	*/
123	public void endOperationProfile(String operationName) {
124	if (this.profileWeight < SessionProfiler.HEAVY) {
125	return;
126	}
127	long endTime = System.nanoTime();
128	Long startTime = getOperationStartTimes().get(operationName);
129	if (startTime == null) {
130	return;
131	}
132	long time = endTime - startTime.longValue();
133
134	synchronized (this.operationTimings) {
135	Long totalTime = (Long)this.operationTimings.get(operationName);
136	if (totalTime == null) {
137	this.operationTimings.put(operationName, Long.valueOf(time));
138	} else {
139	this.operationTimings.put(operationName, Long.valueOf(totalTime.longValue() + time));
140	}
141	}
142	}
143
144	/**
145	* INTERNAL:
146	* End the operation timing.
147	*/
148	public void endOperationProfile(String operationName, DatabaseQuery query, int weight) {
149	if (this.profileWeight < weight) {
150	return;
151	}
152	endOperationProfile(operationName);
153	endOperationProfile(TIMER + query.getMonitorName() + ":" + operationName.substring(TIMER.length(), operationName.length()));
154	}
155
156	protected Map<String, Long> getOperationStartTimes() {
157	Integer threadId = Integer.valueOf(Thread.currentThread().hashCode());
158	Map<String, Long> times = this.operationStartTimesByThread.get(threadId);
159	if (times == null) {
160	times = new Hashtable<String, Long>();
161	this.operationStartTimesByThread.put(threadId, times);
162	}
163	return times;
164	}
165
166	protected Map<Integer, Map<String, Long>> getOperationStartTimesByThread() {
167	return operationStartTimesByThread;
168	}
169
170	protected Map<String, Object> getOperationTimings() {
171	return operationTimings;
172	}
173
174	public AbstractSession getSession() {
175	return session;
176	}
177
178	/**
179	* INTERNAL:
180	* Monitoring is done on the endOperation only.
181	*/
182	public Object profileExecutionOfQuery(DatabaseQuery query, Record row, AbstractSession session) {
183	if (this.profileWeight < SessionProfiler.HEAVY) {
184	return session.internalExecuteQuery(query, (AbstractRecord)row);
185	}
186	startOperationProfile(TIMER + query.getMonitorName());
187	startOperationProfile(TIMER + query.getClass().getSimpleName());
188	occurred(COUNTER + query.getClass().getSimpleName());
189	occurred(COUNTER + query.getMonitorName());
190	try {
191	return session.internalExecuteQuery(query, (AbstractRecord)row);
192	} finally {
193	endOperationProfile(TIMER + query.getMonitorName());
194	endOperationProfile(TIMER + query.getClass().getSimpleName());
195	checkDumpTime();
196	}
197	}
198
199	public void setSession(org.eclipse.persistence.sessions.Session session) {
200	this.session = (AbstractSession)session;
201	}
202
203	/**
204	* INTERNAL:
205	* Start the operation timing.
206	*/
207	public void startOperationProfile(String operationName) {
208	getOperationStartTimes().put(operationName, Long.valueOf(System.nanoTime()));
209	}
210
211	/**
212	* INTERNAL:
213	* Start the operation timing.
214	*/
215	public void startOperationProfile(String operationName, DatabaseQuery query, int weight) {
216	if (this.profileWeight < weight) {
217	return;
218	}
219	startOperationProfile(operationName);
220	startOperationProfile(TIMER + query.getMonitorName() + ":" + operationName.substring(TIMER.length(), operationName.length()));
221	}
222
223	public void update(String operationName, Object value) {
224	this.operationTimings.put(operationName, value);
225	}
226
227	public void occurred(String operationName) {
228	if (this.profileWeight < SessionProfiler.NORMAL) {
229	return;
230	}
231	synchronized (this.operationTimings) {
232	Long occurred = (Long)this.operationTimings.get(operationName);
233	if (occurred == null) {
234	this.operationTimings.put(operationName, Long.valueOf(1));
235	} else {
236	this.operationTimings.put(operationName, Long.valueOf(occurred.longValue() + 1));
237	}
238	}
239	}
240
241	public void occurred(String operationName, DatabaseQuery query) {
242	if (this.profileWeight < SessionProfiler.NORMAL) {
243	return;
244	}
245	occurred(operationName);
246	occurred(COUNTER + query.getMonitorName() + ":" + operationName.substring(COUNTER.length(), operationName.length()));
247	}
248
249	/**
250	* Set the level of profiling.
251	* One of ALL, HEAVY, NORMAL, NONE.
252	* The higher the level, the more operations are profiled.
253	* @see SessiobProfiler
254	*/
255	public void setProfileWeight(int profileWeight) {
256	this.profileWeight = profileWeight;
257	}
258
259	/**
260	* Return the level of profiling.
261	* One of ALL, HEAVY, NORMAL, NONE.
262	* @see SessiobProfiler
263	*/
264	public int getProfileWeight() {
265	return profileWeight;
266	}
267
268	public void initialize() {
269	}
270	}