diff --git a/foundation/eclipselink.core.test/.gitignore b/foundation/eclipselink.core.test/.gitignore
index 8ba548b..b28749f 100644
--- a/foundation/eclipselink.core.test/.gitignore
+++ b/foundation/eclipselink.core.test/.gitignore
@@ -1 +1,2 @@
 /classes
+/classes/
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/PersistenceUnitProperties.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/PersistenceUnitProperties.java
index b0d6f40..75bff5f 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/PersistenceUnitProperties.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/PersistenceUnitProperties.java
@@ -35,6 +35,8 @@
  *       - 438871 : Add support for writing statement terminator character(s) when generating ddl to script.
  *     02/19/2015 - Rick Curtis  
  *       - 458877 : Add national character support
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.config;
 
@@ -3024,16 +3026,33 @@
 
     /**
      * The "<code>javax.persistence.query.timeout</code>" property configures
-     * the default query timeout value.
+     * the default query timeout value. Defaults to seconds, but is configurable 
+     * with PersistenceUnitProperties.QUERY_TIMEOUT_UNIT
      * <p>
      * <b>Allowed Values:</b>
      * <ul>
      * <li>a string containing a zero or greater integer value
      * </ul>
+     * @see PersistenceUnitProperties.QUERY_TIMEOUT_UNIT
      */
     public static final String QUERY_TIMEOUT = "javax.persistence.query.timeout";
 
     /**
+     * The "<code>eclipselink.query.timeout.unit</code>" property
+     * configures the query timeout unit value. Allows users more refinement.
+     * Used in combination with PersistenceUnitProperties.QUERY_TIMEOUT
+     * <p>
+     * <b>Allowed Values:</b>
+     * <ul>
+     * <li>"<code>java.util.concurrent.TimeUnit.MILLISECONDS</code>",
+     * <li>"<code>java.util.concurrent.TimeUnit.SECONDS</code>" (DEFAULT),
+     * <li>"<code>java.util.concurrent.TimeUnit.MINUTES</code>".
+     * </ul>
+     * @see PersistenceUnitProperties.QUERY_TIMEOUT
+     */
+    public static final String QUERY_TIMEOUT_UNIT = "eclipselink.query.timeout.unit";
+
+    /**
      * The "<code>eclipselink.persistence-context.close-on-commit</code>"
      * property specifies that the EntityManager will be closed or not used
      * after commit (not extended). In general this is normally always the case
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/QueryHints.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/QueryHints.java
index 49b714d..d3f9ab2 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/QueryHints.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/QueryHints.java
@@ -15,6 +15,8 @@
  *       - 325167: Make reserved # bind parameter char generic to enable native SQL pass through
  *     06/30/2011-2.3.1 Guy Pelletier 
  *       - 341940: Add disable/enable allowing native queries    
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.config;
 
@@ -348,6 +350,28 @@
     public static final String JDBC_TIMEOUT = "eclipselink.jdbc.timeout";
     
     /**
+     * "javax.persistence.query.timeout" 
+     * <p>Configures the default query timeout value per the JPA specification.
+     * Valid values are strings containing a zero or greater integer value
+     * Defaults to use seconds as the unit of time.
+     * @see org.eclipse.persistence.queries.DatabaseQuery#setQueryTimeout(int)
+     */
+    public static final String QUERY_TIMEOUT = "javax.persistence.query.timeout";
+
+    /**
+     * "eclipselink.jdbc.timeout.unit"
+     * <p>Configures the query timeout unit value. Allows users more refinement.
+     * <b>Valid Values:</b>
+     * <ul>
+     * <li>"<code>java.util.concurrent.TimeUnit.MILLISECONDS</code>",
+     * <li>"<code>java.util.concurrent.TimeUnit.SECONDS</code>" (DEFAULT),
+     * <li>"<code>java.util.concurrent.TimeUnit.MINUTES</code>".
+     * </ul>
+     * @see org.eclipse.persistence.queries.DatabaseQuery#setQueryTimeoutUnit(TimeUnit)
+     */
+    public static final String QUERY_TIMEOUT_UNIT = "eclipselink.query.timeout.unit";
+
+    /**
      * "eclipselink.jdbc.fetch-size"
      * <p>Configures the JDBC fetch-size for the queries result-set.
      * This can improve the performance for queries that return large result-sets.
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorQueryManager.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorQueryManager.java
index 57c12d7..b1a427f 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorQueryManager.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorQueryManager.java
@@ -21,6 +21,8 @@
  *       - 356197: Add new VPD type to MultitenantType
  *     08/01/2012-2.5 Chris Delahunt
  *       - 371950: JPA Metadata caching
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.descriptors;
 
@@ -33,6 +35,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Vector;
+import java.util.concurrent.TimeUnit;
 import org.eclipse.persistence.exceptions.ConversionException;
 import org.eclipse.persistence.exceptions.DescriptorException;
 import org.eclipse.persistence.expressions.Expression;
@@ -124,6 +127,9 @@
     public static final int DefaultTimeout = -1;
     protected int queryTimeout;
 
+    public static final TimeUnit DefaultTimeoutUnit = TimeUnit.SECONDS;
+    protected TimeUnit queryTimeoutUnit;
+
     /**
      * INTERNAL:
      * Initialize the state of the descriptor query manager
@@ -132,6 +138,7 @@
         this.queries = new LinkedHashMap(5);
         setDoesExistQuery(new DoesExistQuery());// Always has a does exist.
         this.setQueryTimeout(DefaultTimeout);
+        this.setQueryTimeoutUnit(DefaultTimeoutUnit);
     }
 
     /**
@@ -889,6 +896,11 @@
                 setQueryTimeout(this.getParentDescriptorQueryManager().getQueryTimeout());
             }
         }
+        if (getQueryTimeoutUnit().equals(DefaultTimeoutUnit)) {
+            if (getDescriptor().hasInheritance() && (this.getDescriptor().getInheritancePolicy().getParentDescriptor() != null)) {
+                setQueryTimeoutUnit(this.getParentDescriptorQueryManager().getQueryTimeoutUnit());
+            }
+        }
 
         //if I have DefaultTimeout (via parent or not), set to NoTimeout
         if (getQueryTimeout() == DefaultTimeout) {
@@ -1686,6 +1698,10 @@
         return queryTimeout;
     }
 
+    public TimeUnit getQueryTimeoutUnit() {
+        return queryTimeoutUnit;
+    }
+
     /**
      * PUBLIC:
      * Set the number of seconds that queries will wait for their Statement to execute.
@@ -1699,6 +1715,10 @@
         this.queryTimeout = queryTimeout;
     }
 
+    public void setQueryTimeoutUnit(TimeUnit queryTimeoutUnit) {
+        this.queryTimeoutUnit = queryTimeoutUnit;
+    }
+
     /**
      * INTERNAL:
      * Returns the collection of cached Update calls.
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseCall.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseCall.java
index ea6c308..90d6120 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseCall.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/databaseaccess/DatabaseCall.java
@@ -19,12 +19,15 @@
  *       - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
  *     09/27/2012-2.5 Guy Pelletier
  *       - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.internal.databaseaccess;
 
 import java.util.*;
 import java.sql.*;
 import java.io.*;
+import java.util.concurrent.*;
 import org.eclipse.persistence.internal.helper.*;
 import org.eclipse.persistence.sessions.DatabaseRecord;
 import org.eclipse.persistence.queries.*;
@@ -103,6 +106,9 @@
     //query timeout limit in seconds
     protected int queryTimeout;
 
+    //query timeout unit
+    protected TimeUnit queryTimeoutUnit;
+
     //max rows returned in the result set by the call
     protected int maxRows;
 
@@ -161,6 +167,7 @@
         this.shouldCacheStatement = null;
         this.isFieldMatchingRequired = false;
         this.queryTimeout = 0;
+        this.queryTimeoutUnit = null;
         this.maxRows = 0;
         this.resultSetFetchSize = 0;
         this.isCursorOutputProcedure = false;
@@ -778,8 +785,18 @@
         Statement statement = accessor.prepareStatement(this, session);
 
         // Setup the max rows returned and query timeout limit.
-        if (this.queryTimeout > 0) { 
-            statement.setQueryTimeout(this.queryTimeout); 
+        if (this.queryTimeout > 0 && this.queryTimeoutUnit != null) {
+            long timeout = TimeUnit.SECONDS.convert(this.queryTimeout, this.queryTimeoutUnit);
+
+            if(timeout > Integer.MAX_VALUE){
+                timeout = Integer.MAX_VALUE;
+            }
+
+            //Round up the timeout if SECONDS are larger than the given units
+            if(TimeUnit.SECONDS.compareTo(this.queryTimeoutUnit) > 0 && this.queryTimeout % 1000 > 0){
+                timeout += 1;
+            }
+            statement.setQueryTimeout((int)timeout);
         } 
         if (!this.ignoreMaxResultsSetting && this.maxRows > 0) { 
             statement.setMaxRows(this.maxRows); 
@@ -914,6 +931,13 @@
     }
 
     /**
+     * set query timeout limit unit to the JDBC Statement
+     */
+    public void setQueryTimeoutUnit(TimeUnit queryTimeoutUnit) {
+        this.queryTimeoutUnit = queryTimeoutUnit;
+    }
+
+    /**
      * The result set is stored for the return value of cursor selects.
      */
     public void setResult(ResultSet result) {
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/CallQueryMechanism.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/CallQueryMechanism.java
index d02ccbc..a85119c 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/CallQueryMechanism.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/CallQueryMechanism.java
@@ -13,6 +13,8 @@
  *       - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
  *     08/24/2012-2.5 Guy Pelletier 
  *       - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.internal.queries;
 
@@ -148,6 +150,7 @@
             call.setShouldCacheStatement(this.query.shouldCacheStatement());
         }
         call.setQueryTimeout(this.query.getQueryTimeout());
+        call.setQueryTimeoutUnit(this.query.getQueryTimeoutUnit());
         if (this.query.isNativeConnectionRequired()) {
             call.setIsNativeConnectionRequired(true);
         }
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AbstractSession.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AbstractSession.java
index c1e341a..c37793c 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AbstractSession.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AbstractSession.java
@@ -25,6 +25,8 @@
  *       - 395406: Fix nightly static weave test errors
  *     08/11/2014-2.5 Rick Curtis 
  *       - 440594: Tolerate invalid NamedQuery at EntityManager creation.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.internal.sessions;
 
@@ -43,6 +45,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+import java.util.concurrent.TimeUnit;
 
 import org.eclipse.persistence.config.PersistenceUnitProperties;
 import org.eclipse.persistence.config.ReferenceMode;
@@ -292,6 +295,8 @@
 
     protected int queryTimeoutDefault;
     
+    protected TimeUnit queryTimeoutUnitDefault;
+
     /** Allow a session to enable concurrent processing. */
     protected boolean isConcurrent;
     
@@ -347,6 +352,7 @@
      */
     protected AbstractSession() {
         this.name = "";
+        this.queryTimeoutUnitDefault = DescriptorQueryManager.DefaultTimeoutUnit;
         initializeIdentityMapAccessor();
         // PERF - move to lazy init (3286091)
     }
@@ -2288,6 +2294,10 @@
         return queryTimeoutDefault;
     }
 
+    public TimeUnit getQueryTimeoutUnitDefault() {
+        return queryTimeoutUnitDefault;
+    }
+
     public EntityListenerInjectionManager getEntityListenerInjectionManager() {
         if (entityListenerInjectionManager == null){
             entityListenerInjectionManager = createEntityListenerInjectionManager(this.getProperty(PersistenceUnitProperties.CDI_BEANMANAGER));
@@ -4029,6 +4039,11 @@
         this.queryTimeoutDefault = queryTimeoutDefault;
     }
 
+    @Override
+    public void setQueryTimeoutUnitDefault(TimeUnit queryTimeoutUnitDefault) {
+        this.queryTimeoutUnitDefault = queryTimeoutUnitDefault;
+    }
+
     /**
      * PUBLIC:
      * Set the profiler for the session.
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/DatabaseSessionImpl.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/DatabaseSessionImpl.java
index 36e6fda..8891fe9 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/DatabaseSessionImpl.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/DatabaseSessionImpl.java
@@ -23,6 +23,8 @@
  *       - 462586 : Add national character support for z/OS.
  *     04/14/2015 - Will Dazey
  *       - 464641 : Fixed platform matching returning CNF.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  *       ******************************************************************************/  
 package org.eclipse.persistence.internal.sessions;
 
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/PropertiesHandler.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/PropertiesHandler.java
index 8ee04a3..186fbe2 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/PropertiesHandler.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/PropertiesHandler.java
@@ -14,12 +14,15 @@
  *     Rick Curtis - Add support for WebSphere Liberty platform.
  *     08/11/2014-2.5 Rick Curtis 
  *       - 440594: Tolerate invalid NamedQuery at EntityManager creation.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.internal.sessions;
 
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
@@ -36,6 +39,7 @@
 import org.eclipse.persistence.config.ReferenceMode;
 import org.eclipse.persistence.config.TargetDatabase;
 import org.eclipse.persistence.config.TargetServer;
+import org.eclipse.persistence.descriptors.DescriptorQueryManager;
 import org.eclipse.persistence.internal.localization.ExceptionLocalization;
 import org.eclipse.persistence.logging.SessionLog;
 import org.eclipse.persistence.queries.ObjectLevelReadQuery;
@@ -214,6 +218,8 @@
             addProp(new BooleanProp(PersistenceUnitProperties.JPQL_TOLERATE, "false"));
             addProp(new BooleanProp(PersistenceUnitProperties.MULTITENANT_SHARED_CACHE, "false"));
             addProp(new BooleanProp(PersistenceUnitProperties.MULTITENANT_SHARED_EMF, "true"));
+            //Enhancement
+            addProp(new QueryTimeoutUnitProp());
         }
         
         Prop(String name) {
@@ -667,4 +673,15 @@
             };
         }
     }
+
+    protected static class QueryTimeoutUnitProp extends Prop {
+        QueryTimeoutUnitProp() {
+            super(PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, DescriptorQueryManager.DefaultTimeoutUnit.toString());
+            valueArray = new Object[] {
+                TimeUnit.MILLISECONDS.toString(),
+                TimeUnit.SECONDS.toString(),
+                TimeUnit.MINUTES.toString()
+            };
+        }
+    }
 }
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkImpl.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkImpl.java
index 6b99677..0662a5a 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkImpl.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkImpl.java
@@ -30,6 +30,8 @@
  *       - 376603: Provide for table per tenant support for multitenant applications
  *     08/11/2012-2.5 Guy Pelletier  
  *       - 393867: Named queries do not work when using EM level Table Per Tenant Multitenancy.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.internal.sessions;
 
@@ -323,6 +325,7 @@
         this.exceptionHandler = parent.exceptionHandler;
         this.pessimisticLockTimeoutDefault = parent.pessimisticLockTimeoutDefault;
         this.queryTimeoutDefault = parent.queryTimeoutDefault;
+        this.queryTimeoutUnitDefault = parent.queryTimeoutUnitDefault;
         this.shouldOptimizeResultSetAccess = parent.shouldOptimizeResultSetAccess;
         this.serializer = parent.serializer;
         this.isConcurrent = parent.isConcurrent;
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DatabaseQuery.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DatabaseQuery.java
index 060515d..da06cf7 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DatabaseQuery.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DatabaseQuery.java
@@ -29,11 +29,15 @@
  *       - 393867: Named queries do not work when using EM level Table Per Tenant Multitenancy.
  *     08/11/2014-2.5 Rick Curtis 
  *       - 440594: Tolerate invalid NamedQuery at EntityManager creation.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.queries;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.io.*;
+
 import org.eclipse.persistence.internal.helper.*;
 import org.eclipse.persistence.config.ParameterDelimiterType;
 import org.eclipse.persistence.descriptors.ClassDescriptor;
@@ -259,6 +263,8 @@
      */
     protected int queryTimeout;
 
+    protected TimeUnit queryTimeoutUnit;
+
     /* Used as default for read, means shallow write for modify. */
     public static final int NoCascading = 1;
 
@@ -339,6 +345,7 @@
         this.isPrepared = false;
         this.shouldUseWrapperPolicy = true;
         this.queryTimeout = DescriptorQueryManager.DefaultTimeout;
+        this.queryTimeoutUnit = DescriptorQueryManager.DefaultTimeoutUnit;
         this.shouldPrepare = true;
         this.shouldCloneCall = false;
         this.shouldBindAllParameters = null;
@@ -1246,6 +1253,16 @@
     }
 
     /**
+     * PUBLIC: Return the unit of time the driver will wait for a Statement to
+     * execute.
+     * 
+     * @see DescriptorQueryManager#getQueryTimeoutUnit()
+     */
+    public TimeUnit getQueryTimeoutUnit() {
+        return queryTimeoutUnit;
+    }
+
+    /**
      * INTERNAL: Returns the specific default redirector for this query type.
      * There are numerous default query redirectors. See ClassDescriptor for
      * their types.
@@ -1818,6 +1835,10 @@
         if (this.queryTimeout == DescriptorQueryManager.DefaultTimeout) {
             if (this.descriptor == null) {
                 setQueryTimeout(this.session.getQueryTimeoutDefault());
+                if(this.session.getQueryTimeoutUnitDefault() == null){
+                    this.session.setQueryTimeoutUnitDefault(DescriptorQueryManager.DefaultTimeoutUnit);
+                }
+                setQueryTimeoutUnit(this.session.getQueryTimeoutUnitDefault());
             } else {
                 int timeout = this.descriptor.getQueryManager().getQueryTimeout();
                 // No timeout means none set, so use the session default.
@@ -1825,6 +1846,13 @@
                     timeout = this.session.getQueryTimeoutDefault();
                 }
                 setQueryTimeout(timeout);
+                
+                //Bug #456067
+                TimeUnit timeoutUnit = this.descriptor.getQueryManager().getQueryTimeoutUnit();
+                if(timeoutUnit == DescriptorQueryManager.DefaultTimeoutUnit){
+                    timeoutUnit = this.session.getQueryTimeoutUnitDefault();
+                }
+                setQueryTimeoutUnit(timeoutUnit);
             }
         }
 
@@ -2277,6 +2305,11 @@
         this.shouldCloneCall = true;
     }
 
+    public void setQueryTimeoutUnit(TimeUnit queryTimeoutUnit) {
+        this.queryTimeoutUnit = queryTimeoutUnit;
+        this.shouldCloneCall = true;
+    }
+
     /**
      * PUBLIC: Set the query redirector. A redirector can be used in a query to
      * replace its execution with the execution of code. This can be used for
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/Session.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/Session.java
index ab370e8..18688e6 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/Session.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/Session.java
@@ -9,11 +9,15 @@
  *
  * Contributors:
  *     Oracle - initial API and implementation from Oracle TopLink
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.sessions;
 
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.io.*;
+
 import org.eclipse.persistence.config.ReferenceMode;
 import org.eclipse.persistence.core.sessions.CoreSession;
 import org.eclipse.persistence.descriptors.ClassDescriptor;
@@ -999,6 +1003,14 @@
     
     /**
      * PUBLIC:
+     * Set the default query timeout units for this session.
+     * This timeout unit will apply to any queries that do not have a unit value set,
+     * and that do not have a default timeout unit defined in their descriptor.
+     */
+    public void setQueryTimeoutUnitDefault(TimeUnit queryTimeoutDefault);
+
+    /**
+     * PUBLIC:
      * Return the session's partitioning policy.
      */
     public PartitioningPolicy getPartitioningPolicy();
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/factories/ProjectClassGenerator.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/factories/ProjectClassGenerator.java
index e25e8bf..0adf552 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/factories/ProjectClassGenerator.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/factories/ProjectClassGenerator.java
@@ -11,6 +11,8 @@
  *     Oracle - initial API and implementation from Oracle TopLink
  *     11/10/2011-2.4 Guy Pelletier
  *       - 357474: Address primaryKey option from tenant discriminator column
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.sessions.factories;
 
@@ -830,6 +832,9 @@
         if (descriptor.getQueryManager().getQueryTimeout() != DescriptorQueryManager.DefaultTimeout) {
             method.addLine("descriptor.getQueryManager().setQueryTimeout(" + descriptor.getQueryManager().getQueryTimeout() + ");");
         }
+        if (!descriptor.getQueryManager().getQueryTimeoutUnit().equals(DescriptorQueryManager.DefaultTimeoutUnit)) {
+            method.addLine("descriptor.getQueryManager().setQueryTimeoutUnit(" + descriptor.getQueryManager().getQueryTimeoutUnit() + ");");
+        }
 
         // Custom SQL.
         if (descriptor.getQueryManager().hasReadObjectQuery() && descriptor.getQueryManager().getReadObjectQuery().isSQLCallQuery()) {
diff --git a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/server/ClientSession.java b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/server/ClientSession.java
index a47585b..981a108 100644
--- a/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/server/ClientSession.java
+++ b/foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/server/ClientSession.java
@@ -16,6 +16,8 @@
  *       - 376603: Provide for table per tenant support for multitenant applications
  *     08/11/2012-2.5 Guy Pelletier  
  *       - 393867: Named queries do not work when using EM level Table Per Tenant Multitenancy.
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.sessions.server;
 
@@ -111,6 +113,7 @@
         this.exceptionHandler = parent.getExceptionHandler();
         this.pessimisticLockTimeoutDefault = parent.getPessimisticLockTimeoutDefault();
         this.queryTimeoutDefault = parent.getQueryTimeoutDefault();
+        this.queryTimeoutUnitDefault = parent.getQueryTimeoutUnitDefault();
         this.isConcurrent = parent.isConcurrent();
         this.shouldOptimizeResultSetAccess = parent.shouldOptimizeResultSetAccess();
         this.properties = properties;
diff --git a/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryHints.java b/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
index 6504a04..5e198c3 100644
--- a/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
+++ b/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryHints.java
@@ -10,6 +10,8 @@
  * Contributors:
  *     06/30/2015-2.6.0 Will Dazey
  *       - 471487: Added test for QueryHints.JDBC_TIMEOUT that checks the executed sql statement
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added tests to check query timeout units
  ******************************************************************************/
 package org.eclipse.persistence.jpa.test.query;
 
@@ -20,6 +22,7 @@
 import java.sql.PreparedStatement;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManagerFactory;
@@ -32,6 +35,7 @@
 import org.eclipse.persistence.jpa.test.framework.Emf;
 import org.eclipse.persistence.jpa.test.framework.EmfRunner;
 import org.eclipse.persistence.jpa.test.framework.PUPropertiesProvider;
+import org.eclipse.persistence.jpa.test.framework.Property;
 import org.eclipse.persistence.sessions.Connector;
 import org.eclipse.persistence.sessions.DatabaseLogin;
 import org.eclipse.persistence.sessions.Session;
@@ -46,9 +50,16 @@
 
     private static int setTimeout;
 
-    @Emf(classes = { Employee.class })
+    private final static int realTimeout = 3099;
+
+    @Emf(name = "defaultEMF", classes = { Employee.class } )
     private EntityManagerFactory emf;
 
+    @Emf(name = "TimeoutPropertiesEMF", classes = { Employee.class }, properties = { 
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT, value = "" + TestQueryHints.realTimeout),
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, value = "MINUTES") })
+    private EntityManagerFactory emfTimeoutProperties;
+
     /**
      * Test that setting the Query Hint: QueryHints.JDBC_TIMEOUT sets the
      * timeout accordingly on the executed java.sql.Statement.
@@ -64,13 +75,11 @@
         try {
             em = emf.createEntityManager();
 
-            int queryTimeout = 3000;
-
             em.getTransaction().begin();
-            Query q = em.createQuery("SELECT x FROM Employee x").setHint(QueryHints.JDBC_TIMEOUT, queryTimeout);
+            Query q = em.createQuery("SELECT x FROM Employee x").setHint(QueryHints.JDBC_TIMEOUT, TestQueryHints.realTimeout);
             q.getResultList();
 
-            Assert.assertEquals(queryTimeout, TestQueryHints.setTimeout);
+            Assert.assertEquals(TestQueryHints.realTimeout, TestQueryHints.setTimeout);
 
             em.getTransaction().rollback();
         } catch (Exception e) {
@@ -82,6 +91,66 @@
         }
     }
 
+    /**
+     * Test that setting the Query Hint: QueryHints.JDBC_TIMEOUT_UNIT sets the
+     * timeout accordingly on the executed java.sql.Statement.
+     * 
+     * QueryHints.JDBC_TIMEOUT expects seconds by default.
+     * java.sql.Statement.getQueryTimeout() will return a value in seconds.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testQueryTimeoutUnit() throws Exception {
+        EntityManager em = null;
+        try {
+            em = emf.createEntityManager();
+
+            /*
+             * Default Case: Seconds
+             * Without being set, the units should be in seconds already.
+             */
+            em.getTransaction().begin();
+            Query q = em.createQuery("SELECT x FROM Employee x").setHint(QueryHints.JDBC_TIMEOUT, TestQueryHints.realTimeout);
+            q.getResultList();
+            int queryTimeoutSeconds = TestQueryHints.realTimeout;
+            Assert.assertEquals(queryTimeoutSeconds, TestQueryHints.setTimeout);
+            em.getTransaction().rollback();
+
+            /*
+             * Case 2: Minutes
+             * Setting units to Minutes, value should come back converted to Seconds
+             */
+            em.getTransaction().begin();
+            q = em.createQuery("SELECT x FROM Employee x").setHint(QueryHints.JDBC_TIMEOUT, TestQueryHints.realTimeout).setHint(QueryHints.QUERY_TIMEOUT_UNIT, TimeUnit.MINUTES.toString());
+            q.getResultList();
+            queryTimeoutSeconds = TestQueryHints.realTimeout * 60;
+            Assert.assertEquals(queryTimeoutSeconds, TestQueryHints.setTimeout);
+            em.getTransaction().rollback();
+
+            /*
+             * Case 3: Milliseconds
+             * Setting units to Milliseconds, value should come back converted to Seconds
+             */
+            em.getTransaction().begin();
+            q = em.createQuery("SELECT x FROM Employee x").setHint(QueryHints.JDBC_TIMEOUT, TestQueryHints.realTimeout).setHint(QueryHints.QUERY_TIMEOUT_UNIT, TimeUnit.MILLISECONDS.toString());
+            q.getResultList();
+            double queryTimeoutSecondsDouble = TestQueryHints.realTimeout / 1000d;
+            //if there was a remainder, it should round up
+            if(queryTimeoutSecondsDouble % 1 > 0){
+                queryTimeoutSecondsDouble += 1;
+            }
+            Assert.assertEquals((int)queryTimeoutSecondsDouble, TestQueryHints.setTimeout);
+            em.getTransaction().rollback();
+        } catch (Exception e) {
+            Assert.fail(e.getLocalizedMessage());
+        } finally {
+            if (em != null) {
+                em.close();
+            }
+        }
+    }
+
     @Override
     public Map<String, Object> getAdditionalPersistenceProperties(String puName) {
         Map<String, Object> map = new HashMap<String, Object>();
diff --git a/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryProperties.java b/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryProperties.java
new file mode 100644
index 0000000..ea1a9bf
--- /dev/null
+++ b/jpa/eclipselink.jpa.test.jse/src/org/eclipse/persistence/jpa/test/query/TestQueryProperties.java
@@ -0,0 +1,245 @@
+/*******************************************************************************
+ * Copyright (c) 2015 IBM Corporation. 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:
+ *     06/30/2015-2.6.0 Will Dazey
+ *       - 471487: Added test for QueryHints.JDBC_TIMEOUT that checks the executed sql statement
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added tests to check query timeout units
+ ******************************************************************************/
+package org.eclipse.persistence.jpa.test.query;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.Query;
+
+import org.eclipse.persistence.config.PersistenceUnitProperties;
+import org.eclipse.persistence.config.SessionCustomizer;
+import org.eclipse.persistence.jpa.test.basic.model.Employee;
+import org.eclipse.persistence.jpa.test.framework.Emf;
+import org.eclipse.persistence.jpa.test.framework.EmfRunner;
+import org.eclipse.persistence.jpa.test.framework.PUPropertiesProvider;
+import org.eclipse.persistence.jpa.test.framework.Property;
+import org.eclipse.persistence.sessions.Connector;
+import org.eclipse.persistence.sessions.DatabaseLogin;
+import org.eclipse.persistence.sessions.Session;
+import org.eclipse.persistence.sessions.SessionEvent;
+import org.eclipse.persistence.sessions.SessionEventAdapter;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(EmfRunner.class)
+public class TestQueryProperties implements PUPropertiesProvider {
+
+    private static int setTimeout;
+    
+    private final static int realTimeout = 3099;
+
+    @Emf(name = "timeoutEMF", classes = { Employee.class }, properties = { 
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT, value = "" + TestQueryProperties.realTimeout) })
+    private EntityManagerFactory emfTimeout;
+
+    @Emf(name = "timeoutWithUnitMintuesEMF", classes = { Employee.class }, properties = { 
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT, value = "" + TestQueryProperties.realTimeout),
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, value = "MINUTES") })
+    private EntityManagerFactory emfTimeoutMinutes;
+    
+    @Emf(name = "timeoutWithUnitMillisecondsEMF", classes = { Employee.class }, properties = { 
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT, value = "" + TestQueryProperties.realTimeout),
+            @Property(name = PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, value = "MILLISECONDS") })
+    private EntityManagerFactory emfTimeoutMilliseconds;
+
+    /**
+     * Test that setting the property "PersistenceUnitProperties.QUERY_TIMEOUT_UNIT" sets the
+     * timeout accordingly on the executed java.sql.Statement.
+     * 
+     * Assumes value will be converted to Seconds for JDBC.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testTimeoutUnitDefault() throws Exception {
+        EntityManager em = null;
+        try {
+            em = emfTimeout.createEntityManager();
+
+            em.getTransaction().begin();
+            Query q = em.createQuery("SELECT x FROM Employee x");
+            q.getResultList();
+            
+            int queryTimeoutSeconds = TestQueryProperties.realTimeout;
+
+            Assert.assertEquals(queryTimeoutSeconds, TestQueryProperties.setTimeout);
+
+            em.getTransaction().rollback();
+        } catch (Exception e) {
+            Assert.fail(e.getLocalizedMessage());
+        } finally {
+            if (em != null) {
+                em.close();
+            }
+        }
+    }
+
+    /**
+     * Test that setting the property "PersistenceUnitProperties.QUERY_TIMEOUT_UNIT" sets the
+     * timeout accordingly on the executed java.sql.Statement.
+     * 
+     * Assumes value will be converted to Seconds for JDBC.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testTimeoutUnitMinutes() throws Exception {
+        EntityManager em = null;
+        try {
+            em = emfTimeoutMinutes.createEntityManager();
+
+            em.getTransaction().begin();
+            Query q = em.createQuery("SELECT x FROM Employee x");
+            q.getResultList();
+            
+            int queryTimeoutSeconds = TestQueryProperties.realTimeout * 60;
+
+            Assert.assertEquals(queryTimeoutSeconds, TestQueryProperties.setTimeout);
+
+            em.getTransaction().rollback();
+        } catch (Exception e) {
+            Assert.fail(e.getLocalizedMessage());
+        } finally {
+            if (em != null) {
+                em.close();
+            }
+        }
+    }
+
+    /**
+     * Test that setting the property "PersistenceUnitProperties.QUERY_TIMEOUT_UNIT" sets the
+     * timeout accordingly on the executed java.sql.Statement.
+     * 
+     * Assumes value will be converted to Seconds for JDBC.
+     * 
+     * @throws Exception
+     */
+    @Test
+    public void testTimeoutUnitMilliseconds() throws Exception {
+        EntityManager em = null;
+        try {
+            em = emfTimeoutMilliseconds.createEntityManager();
+
+            em.getTransaction().begin();
+            Query q = em.createQuery("SELECT x FROM Employee x");
+            q.getResultList();
+            
+            double queryTimeoutSeconds = TestQueryProperties.realTimeout / 1000d;
+            //if there was a remainder, it should round up
+            if(queryTimeoutSeconds % 1 > 0){
+                queryTimeoutSeconds += 1;
+            }
+
+            Assert.assertEquals((int)queryTimeoutSeconds, TestQueryProperties.setTimeout);
+
+            em.getTransaction().rollback();
+        } catch (Exception e) {
+            Assert.fail(e.getLocalizedMessage());
+        } finally {
+            if (em != null) {
+                em.close();
+            }
+        }
+    }
+
+    @Override
+    public Map<String, Object> getAdditionalPersistenceProperties(String puName) {
+        Map<String, Object> map = new HashMap<String, Object>();
+        map.put(PersistenceUnitProperties.SESSION_CUSTOMIZER, Customizer.class.getName());
+        return map;
+    }
+
+    public static class Customizer implements SessionCustomizer {
+        @Override
+        public void customize(Session session) throws Exception {
+            session.getEventManager().addListener(new SessionEventAdapter() {
+                @Override
+                public void preLogin(SessionEvent event) {
+                    DatabaseLogin login = event.getSession().getLogin();
+                    login.setConnector(ConnectorInvocationHandler.createStatementProxy(login.getConnector()));
+                }
+            });
+        }
+    }
+
+    public static class ConnectorInvocationHandler implements InvocationHandler {
+        private Connector wrappedConnector;
+
+        public ConnectorInvocationHandler(Connector stmt) {
+            wrappedConnector = stmt;
+        }
+
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if (method.getName().equals("connect") && proxy instanceof Connector) {
+                return ConnectionInvocationHandler.createStatementProxy((Connection) method.invoke(wrappedConnector, args));
+            }
+            return method.invoke(wrappedConnector, args);
+        }
+
+        public static Connector createStatementProxy(Connector toWrap) {
+            return (Connector) Proxy.newProxyInstance(Connector.class.getClassLoader(), new Class[] { Connector.class }, new ConnectorInvocationHandler(toWrap));
+        }
+    }
+
+    public static class ConnectionInvocationHandler implements InvocationHandler {
+        private Connection wrappedConnection;
+
+        public ConnectionInvocationHandler(Connection stmt) {
+            wrappedConnection = stmt;
+        }
+
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if (method.getName().equals("prepareStatement") && proxy instanceof Connection) {
+                return PreparedStatementInvocationHandler.createStatementProxy((PreparedStatement) method.invoke(wrappedConnection, args));
+            }
+            return method.invoke(wrappedConnection, args);
+        }
+
+        public static Connection createStatementProxy(Connection toWrap) {
+            return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class[] { Connection.class }, new ConnectionInvocationHandler(toWrap));
+        }
+    }
+
+    public static class PreparedStatementInvocationHandler implements InvocationHandler {
+        private PreparedStatement wrappedStatement;
+
+        public PreparedStatementInvocationHandler(PreparedStatement stmt) {
+            wrappedStatement = stmt;
+        }
+
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if (method.getName().equals("setQueryTimeout") && proxy instanceof PreparedStatement) {
+                if (args.length > 0) {
+                    TestQueryProperties.setTimeout = (Integer) args[0];
+                }
+            }
+            return method.invoke(wrappedStatement, args);
+        }
+
+        public static PreparedStatement createStatementProxy(PreparedStatement toWrap) {
+            return (PreparedStatement) Proxy.newProxyInstance(PreparedStatement.class.getClassLoader(), new Class[] { PreparedStatement.class }, new PreparedStatementInvocationHandler(toWrap));
+        }
+    }
+}
diff --git a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java
index 02a6ed6..a9da2fe 100644
--- a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java
+++ b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java
@@ -60,6 +60,8 @@
  *       - 458877 : Add national character support
  *     03/04/2015 - Will Dazey 
  *       - 460862 : Added support for JTA schema generation without JTA-DS
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  *****************************************************************************/  
 package org.eclipse.persistence.internal.jpa;
 
@@ -125,6 +127,7 @@
 import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
 
 import javax.persistence.OptimisticLockException;
 import javax.persistence.PersistenceException;
@@ -2769,6 +2772,7 @@
             updateIdValidation(m);
             updatePessimisticLockTimeout(m);
             updateQueryTimeout(m);
+            updateQueryTimeoutUnit(m);
             if (!session.hasBroker()) {
                 updateCacheCoordination(m, loader);
             }
@@ -3494,7 +3498,6 @@
 
     private void updateQueryTimeout(Map persistenceProperties) {
         String timeout = EntityManagerFactoryProvider.getConfigPropertyAsStringLogDebug(PersistenceUnitProperties.QUERY_TIMEOUT, persistenceProperties, session);
-
         try {
             if (timeout != null) {
                 session.setQueryTimeoutDefault(Integer.parseInt(timeout));
@@ -3504,6 +3507,19 @@
         }
     }
 
+    //Bug #456067: Added persistence unit support for timeout units
+    private void updateQueryTimeoutUnit(Map persistenceProperties) {
+        String timeoutUnit = EntityManagerFactoryProvider.getConfigPropertyAsStringLogDebug(PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, persistenceProperties, session);
+        try {
+            if (timeoutUnit != null) {
+                TimeUnit unit = TimeUnit.valueOf(timeoutUnit);
+                session.setQueryTimeoutUnitDefault(unit);
+            }
+        } catch (IllegalArgumentException exception) {
+            this.session.handleException(ValidationException.invalidValueForProperty(timeoutUnit, PersistenceUnitProperties.QUERY_TIMEOUT_UNIT, exception));
+        }
+    }
+
     /**
      * If Bean Validation is enabled, bootstraps Bean Validation on descriptors.
      * @param puProperties merged properties for this persistence unit
diff --git a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/QueryHintsHandler.java b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/QueryHintsHandler.java
index 0513f95..73dc13f 100644
--- a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/QueryHintsHandler.java
+++ b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/QueryHintsHandler.java
@@ -19,6 +19,8 @@
  *       - 341940: Add disable/enable allowing native queries 
  *     06/30/2015-2.6.0 Will Dazey
  *       - 471487: Fixed eclipselink.jdbc.timeout hint not applying correctly to SQLCall
+ *     09/03/2015 - Will Dazey
+ *       - 456067 : Added support for defining query timeout units
  ******************************************************************************/  
 package org.eclipse.persistence.internal.jpa;
 
@@ -31,6 +33,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.StringTokenizer;
+import java.util.concurrent.TimeUnit;
 
 import javax.persistence.CacheRetrieveMode;
 import javax.persistence.CacheStoreMode;
@@ -249,6 +252,10 @@
             addHint(new LeftFetchHint());
             addHint(new ReadOnlyHint());
             addHint(new JDBCTimeoutHint());
+            //Enhancement
+            addHint(new QueryTimeoutUnitHint());
+            //Enhancement
+            addHint(new QueryTimeoutHint());
             addHint(new JDBCFetchSizeHint());
             addHint(new JDBCMaxRowsHint());
             addHint(new JDBCFirstResultHint());
@@ -1868,6 +1875,36 @@
         }
     }
         
+    //Bug #456067: Added support for user defining the timeout units to use
+    protected static class QueryTimeoutUnitHint extends Hint {
+        QueryTimeoutUnitHint() {
+            super(QueryHints.QUERY_TIMEOUT_UNIT, "");
+        }
+
+        DatabaseQuery applyToDatabaseQuery(Object valueToApply, DatabaseQuery query, ClassLoader loader, AbstractSession activeSession) {
+            try {
+                TimeUnit unit = TimeUnit.valueOf((String)valueToApply);
+                query.setQueryTimeoutUnit(unit);
+            }
+            catch(IllegalArgumentException e) {
+                throw new IllegalArgumentException(ExceptionLocalization.buildMessage("ejb30-wrong-type-for-query-hint",new Object[]{getQueryId(query), name, getPrintValue(valueToApply)}));
+            }
+            return query;
+        }
+    }
+
+    //Bug #456067: Added support for query hint "javax.persistence.query.timeout" defined in the spec
+    protected static class QueryTimeoutHint extends Hint {
+        QueryTimeoutHint() {
+            super(QueryHints.QUERY_TIMEOUT, "");
+        }
+
+        DatabaseQuery applyToDatabaseQuery(Object valueToApply, DatabaseQuery query, ClassLoader loader, AbstractSession activeSession) {
+            query.setQueryTimeout(QueryHintsHandler.parseIntegerHint(valueToApply, QueryHints.QUERY_TIMEOUT));
+            return query;
+        }
+    }
+
     protected static class JDBCFetchSizeHint extends Hint {
         JDBCFetchSizeHint() {
             super(QueryHints.JDBC_FETCH_SIZE, "");
@@ -2064,5 +2101,4 @@
             return query;
         }
     }
-
 }