/*******************************************************************************
 * Copyright (c) 1998, 2014 Oracle and/or its affiliates, 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:
 *     Oracle - initial API and implementation from Oracle TopLink
 *     dclarke - Bug 294985: update of comments and addition of connection logging property
 *     cdelahun - Bug 214534: added COORDINATION_JMS_REUSE_PUBLISHER property to enable JMS rcm legacy behavior
 *     04/01/2011-2.3 Guy Pelletier 
 *       - 337323: Multi-tenant with shared schema support (part 2)
 *     06/30/2011-2.3.1 Guy Pelletier 
 *       - 341940: Add disable/enable allowing native queries 
 *     09/20/2011-2.3.1 Guy Pelletier 
 *       - 357476: Change caching default to ISOLATED for multitenant's using a shared EMF.
 *     12/24/2012-2.5 Guy Pelletier 
 *       - 389090: JPA 2.1 DDL Generation Support
 *     01/08/2013-2.5 Guy Pelletier 
 *       - 389090: JPA 2.1 DDL Generation Support
 *     01/11/2013-2.5 Guy Pelletier 
 *       - 389090: JPA 2.1 DDL Generation Support
 *     02/04/2013-2.5 Guy Pelletier 
 *       - 389090: JPA 2.1 DDL Generation Support
 *     02/19/2013-2.5 Guy Pelletier 
 *       - 389090: JPA 2.1 DDL Generation Support
 *     08/11/2014-2.5 Rick Curtis 
 *       - 440594: Tolerate invalid NamedQuery at EntityManager creation.
 ******************************************************************************/
package org.eclipse.persistence.config;

import java.io.File;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.FlushModeType;
import javax.persistence.Persistence;

import org.eclipse.persistence.annotations.Cache;
import org.eclipse.persistence.exceptions.ExceptionHandler;
import org.eclipse.persistence.internal.databaseaccess.BatchWritingMechanism;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.logging.SessionLog;
import org.eclipse.persistence.platform.database.DatabasePlatform;
import org.eclipse.persistence.platform.database.events.DatabaseEventListener;
import org.eclipse.persistence.platform.server.ServerPlatform;
import org.eclipse.persistence.queries.JPAQueryBuilder;
import org.eclipse.persistence.sessions.DatabaseLogin;
import org.eclipse.persistence.sessions.Project;
import org.eclipse.persistence.sessions.SessionEventListener;
import org.eclipse.persistence.sessions.SessionProfiler;
import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;
import org.eclipse.persistence.sessions.factories.SessionManager;
import org.eclipse.persistence.tools.profiler.PerformanceMonitor;
import org.eclipse.persistence.sessions.remote.RemoteSession;
import org.eclipse.persistence.sessions.serializers.Serializer;
import org.eclipse.persistence.tools.profiler.PerformanceProfiler;
import org.eclipse.persistence.tools.profiler.QueryMonitor;
import org.eclipse.persistence.tools.tuning.SafeModeTuner;
import org.eclipse.persistence.tools.tuning.SessionTuner;

/**
 * The class defines EclipseLink persistence unit property names. These values
 * are used to assist in the configuration of properties passed to
 * {@link Persistence#createEntityManagerFactory(String, Map)} which override
 * the values specified in the persistence.xml file.
 * <p>
 * <b>Usage Example:</b> <code>
 * Map<String, Object> props = new HashMap<String, Object>();</br>
 * </br>
 * props.put(PersistenceUnitProperties.JDBC_USER, "user-name");</br>
 * props.put(PersistenceUnitProperties.JDBC_PASSWORD, "password");</br>
 * </br>
 * EntityManagerFactory emf = Persistence.createEntityManagerFactory("pu-name", props);
 * </code>
 * <p>
 * Property values are usually case-insensitive with some common sense
 * exceptions, for instance class names.
 * 
 * @see Persistence#createEntityManagerFactory(String, Map)
 */
public class PersistenceUnitProperties {

    /**
     * The <code>javax.persistence.transactionType"</code> property specifies the
     * transaction type for the persistence unit. This property overrides the
     * value specified in the persistence.xml.
     * <p>
     * Values: A string value of "JTA" or "RESOURCE_LOCAL"
     */
    public static final String TRANSACTION_TYPE = "javax.persistence.transactionType";

    /**
     * The <code>javax.persistence.jtaDataSource"</code> property specifies the JTA data
     * source name that will look up a valid {@link javax.sql.DataSource}. This
     * property is used to override the value specified in the persistence.xml.
     * <p>
     * Values: A well formed JNDI resource name that can locate the data source
     * in the target container or an instance of {@link javax.sql.DataSource}
     */
    public static final String JTA_DATASOURCE = "javax.persistence.jtaDataSource";

    /**
     * The <code>javax.persistence.nonJtaDataSource"</code> property specifies the
     * non-JTA data source name that will look up a valid
     * {@link javax.sql.DataSource}. This can be used to override the value
     * specified in the persistence.xml.
     * <p>
     * Values: A well formed JNDI resource name that can locate the data source
     * in the target container or an instance of {@link javax.sql.DataSource}
     */
    public static final String NON_JTA_DATASOURCE = "javax.persistence.nonJtaDataSource";

    // JDBC Properties for internal connection pooling

    /**
     * The <code>javax.persistence.jdbc.driver"</code> property specifies the JDBC
     * DriverManager class name used for internal connection pooling when a data
     * source is not being used. The value must be a string which is the
     * qualified class name for a valid class that implements
     * <code>java.sql.Driver</code>.
     * <p>
     * <b>Persistence XML example:</b> <code>
     * <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
     * </code>
     * <p>
     * The previous value for this property <code>"eclipselink.jdbc.driver</code> is now deprecated and should
     * be replaced with this new name.
     */
    public static final String JDBC_DRIVER = "javax.persistence.jdbc.driver";

    /**
     * The <code>javax.persistence.jdbc.url"</code> property specifies the JDBC URL used
     * for internal connection pooling when a data source is not being used. The
     * value must be a string which represents a valid URL for the specified
     * JDBC driver.
     * <p>
     * <b>Persistence XML example:</b> <code>
     * <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost/mysql" />
     * </code>
     * <p>
     * The previous value for this property <code>"eclipselink.jdbc.url</code> is now deprecated and should
     * be replaced with this new name.
     */
    public static final String JDBC_URL = "javax.persistence.jdbc.url";

    /**
     * The <code>javax.persistence.jdbc.user"</code> property specifies the data source
     * or JDBC user name.
     * <p>
     * <b>Persistence XML example:</b> <code>
     * <property name="javax.persistence.jdbc.user" value="user-name" />
     * </code>
     * <p>
     * The previous value for this property <code>"eclipselink.jdbc.user</code> is now deprecated and should
     * be replaced with this new name.
     */
    public static final String JDBC_USER = "javax.persistence.jdbc.user";

    /**
     * The <code>javax.persistence.jdbc.password"</code> property specifies the data
     * source or JDBC password.
     * <p>
     * <b>Persistence XML example:</b> <code>
     * <property name="javax.persistence.jdbc.password" value="password" />
     * </code> The previous value for this
     * property <code>"eclipselink.jdbc.password</code> is now deprecated and should be replaced with this new
     * name.
     */
    public static final String JDBC_PASSWORD = "javax.persistence.jdbc.password";

    /**
     * The <code>"eclipselink.jdbc.native-sql"</code> property specifies whether
     * generic SQL should be used or platform specific 'native' SQL. The
     * platform specific SQL customizes join syntax, date operators, sequencing,
     * ...
     * <p>
     * Allowed Values (String):
     * <ul>
     * <li>"true" - use database specific SQL
     * <li>"false" (DEFAULT) - use generic SQL
     * </ul>
     * 
     * @see DatabaseLogin#setUsesNativeSQL(boolean)
     */
    public static final String NATIVE_SQL = "eclipselink.jdbc.native-sql";

    /**
     * The <code>"eclipselink.jdbc.sql-cast"</code> property specifies if
     * platform specific CAST SQL operations should be used. Casting is normally
     * not required, and can cause issues when used. Allowed Values (String):
     * <ul>
     * <li>"true" - enable platform specific cast
     * <li>"false" (DEFAULT) - disable platform specific cast
     * </ul>
     * 
     * @see DatabasePlatform#setIsCastRequired(boolean)
     */
    public static final String SQL_CAST = "eclipselink.jdbc.sql-cast";

    /**
     * The <code>"eclipselink.jpql.parser"</code> property allows the
     * JPQL parser to be configured.
     * Two JPQL parsers are provided:
     * <ul>
     * <li>"org.eclipse.persistence.internal.jpa.jpql.HermesParser" (DEFAULT) - new parser as of EclipseLink 2.4, provides extended JPQL support.
     * <li>"org.eclipse.persistence.queries.ANTLRQueryBuilder" - old parser used previous to EclipseLink 2.4, can be used for backward compatibility.
     * </ul>
     * 
     * @see ParserType
     * @see JPAQueryBuilder
     */
    public static final String JPQL_PARSER = "eclipselink.jpql.parser";
    
    /**
     * The <code>"eclipselink.jpql.validation"</code> property allows the
     * JPQL parser validation level to be configured.
     * This setting is only supported in the Hermes parser.
     * Valid values are:
     * <ul>
     * <li>"EclipseLink" (DEFAULT) - allows EclipseLink JPQL extensions.
     * <li>"JPA 1.0" - only allows valid JPA 1.0 JPQL.
     * <li>"JPA 2.0" - only allows valid JPA 2.0 JPQL.
     * <li>"JPA 2.1" - only allows valid JPA 2.1 JPQL.
     * <li>"None" - no JPQL validation is done.
     * </ul>
     * 
     * @see ParserValidationType
     */
    public static final String JPQL_VALIDATION = "eclipselink.jpql.validation";
    
    /**
     * The <code>"wait"</code> property.
     * This can be append to any connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.default.wait"</code>
     * which specifies the timeout time in milliseconds (ms) that will be waited
     * for an available connection before an exception is thrown. Ignored in
     * case external connection pools are used.
     * <p>
     * Default: 180000 ms (3 minutes).
     * <p>
     * The value specified should be a string containing a positive integer
     * value. A value of 0 means wait forever.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_WAIT = "wait";
    
    /**
     * The <code>"max"</code> property.
     * This can be append to any connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.default.max"</code>
     * Specifies the maximum number of read connection in the internal connection pool. If
     * the maximum size is reached, threads requiring a connection will wait
     * until one is released back to the pool. By default a single shared
     * (exclusive) read/write pool is used with min/max 32 connections and 1
     * initial. Ignored in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_MAX = "max";

    /**
     * The <code>"min"</code> property.
     * This can be append to any connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.default.min"</code>
     * Specifies the minimum number of connections in EclipseLink connection pool.
     * <p>
     * Ignored in case external connection pools are used. Connections beyond
     * the minimum will be disconnected when returned to the pool, so this
     * should normally be equal to the number of active threads, or server's
     * thread pool size. By default a single shared (exclusive) read/write pool
     * is used with min/max 32 connections and 1 initial.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_MIN = "min";

    /**
     * The <code>"initial"</code> property.
     * This can be append to any connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.default.initial"</code>
     * EclipseLink JDBC (internal) connection pools properties. Initial number
     * of connections in EclipseLink connection pool. This is the number of
     * connections connected at startup. By default a single shared (exclusive)
     * read/write pool is used with min/max 32 connections and 1 initial. Ignored
     * in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_INITIAL = "initial";
    
    /**
     * The <code>"shared"</code> property.
     * This can be append to the read connection pool,
     * i.e. <code>"eclipselink.jdbc.connection_pool.read.shared"</code>
     * Configures whether connections in EclipseLink read connection pool should
     * be shared (not exclusive). Connection sharing means the same JDBC
     * connection will be used concurrently for multiple reading threads.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"false" (DEFAULT): indicates read connections will not be shared
     * <li>"true": indicates read connections can be shared
     * </ul>
     * @see #CONNECTION_POOL_READ
     */
    public static final String CONNECTION_POOL_SHARED = "shared";
    
    /**
     * The <code>"url"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.url"</code>
     * Configures the JDBC url to use for the connection pool.
     * Only required if different than the default.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_URL = "url";
    
    /**
     * The <code>"jtaDataSource"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.jtaDataSource"</code>
     * Configures the JTA DataSource name to use for the connection pool.
     * Only required if different than the default.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_JTA_DATA_SOURCE = "jtaDataSource";
    
    /**
     * The <code>"nonJtaDataSource"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.nonJtaDataSource"</code>
     * Configures the non JTA DataSource name to use for the connection pool.
     * Only required if different than the default.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_NON_JTA_DATA_SOURCE = "nonJtaDataSource";
    
    /**
     * The <code>"user"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.user"</code>
     * Configures the user name to use for the connection pool.
     * Only required if different than the default.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_USER = "user";
    
    /**
     * The <code>"password"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.password"</code>
     * Configures the password to use for the connection pool.
     * Only required if different than the default.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_PASSWORD = "password";

    /**
     * The <code>"failover"</code> property.
     * This can be append to a connection pool property,
     * i.e. <code>"eclipselink.jdbc.connection_pool.node1.failover"</code>
     * Configures the connection pool(s) to fail-over to if this connection pool fails.
     * A comma separate list is allowed if multiple failover pools are required.
     * @see #CONNECTION_POOL
     */
    public static final String CONNECTION_POOL_FAILOVER = "failover";
    
    /**
     * Allow configuring a <code>"eclipselink.connection-pool."</code> properties.
     * The name of the connection pool must be appended to configure the pool,
     * if no name is appended the default (write) pool is configured.
     * The name of the property to configure must also be appended.
     * <p>
     * A user defined connection pool can be configured or one of the following system pools:
     * <ul>
     * <li> "read" - pool used for non-transactional read queries, (defaults to default pool if not specified).
     * <li> "default", "write", "" - default pool used for writing and reads if no read pool configured.
     * <li> "sequence" - pool used for sequencing, (default pool/write connection used if not specified).
     * </ul>
     * A user defined pool is only used if specified in the EntityManager properties or ClientSession ConnectionPolicy,
     * or if partitioning is used.     * 
     * <p>
     * The following connection pool properties can be configured:
     * <ul>
     * <li> "initial" - number of initial connections.
     * <li> "min" - minimum number of connections.
     * <li> "max" - maximum number of connections.
     * <li> "wait" - amount of time to wait for a connection from the pool.
     * <li> "url" - JDBC URL for the connection.
     * <li> "shared" - only for the read connection pool, shares read connections across threads.
     * <li> "jtaDataSource" - JTA DataSource name to use for the connection, if different than the default.
     * <li> "nonJtaDataSource" - non JTA DataSource name to use for the connection, if different than the default.
     * <li> "user" - user to use for the connection, if different than the default.
     * <li> "password" - password to use for the connection, if different than the default.
     * </ul>
     * <p>
     * Example:
     * <pre>
     * &lt;property name="eclipselink.connection-pool.node2.min" value="16"/&gt;
     * &lt;property name="eclipselink.connection-pool.node2.max" value="16"/&gt;
     * &lt;property name="eclipselink.connection-pool.node2.url" value="jdbc:oracle:thin:@node2:1521:orcl"/&gt;
     * </pre>
     * @see CONNECTION_POOL_READ
     * @see CONNECTION_POOL_SEQUENCE
     * @see #CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_WAIT
     * @see #CONNECTION_POOL_USER
     * @see #CONNECTION_POOL_PASSWORD
     * @see #CONNECTION_POOL_URL
     * @see #CONNECTION_POOL_JTA_DATA_SOURCE
     * @see #CONNECTION_POOL_NON_JTA_DATA_SOURCE
     * @see #CONNECTION_POOL_SHARED
     * @see org.eclipse.persistence.sessions.server.ConnectionPool
     */
    public static final String CONNECTION_POOL = "eclipselink.connection-pool.";

    /**
     * Allow configuring the <code>"eclipselink.connection-pool.read."</code> properties.
     * The read connection pool is used for non-transaction read queries.
     * By default a separate read connection pool is not used,
     * and the default pool is used for read queries.
     * <p>
     * One of the following connection pool properties must be appended.
     * @see #CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_WAIT
     * @see #CONNECTION_POOL_USER
     * @see #CONNECTION_POOL_PASSWORD
     * @see #CONNECTION_POOL_URL
     * @see #CONNECTION_POOL_JTA_DATA_SOURCE
     * @see #CONNECTION_POOL_NON_JTA_DATA_SOURCE
     * @see org.eclipse.persistence.sessions.server.ReadConnectionPool
     */
    public static final String CONNECTION_POOL_READ = "eclipselink.connection-pool.read.";

    /**
     * Allow configuring the <code>"eclipselink.connection-pool.sequence."</code> properties.
     * The sequence connection pool is used to allocate generated Ids.
     * This is only required for TABLE sequencing.
     * By default a separate sequence connection pool is not used,
     * and the default pool is used for sequencing.
     * <p>
     * One of the following connection pool properties must be appended.
     * @see #CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_WAIT
     * @see #CONNECTION_POOL_USER
     * @see #CONNECTION_POOL_PASSWORD
     * @see #CONNECTION_POOL_URL
     * @see #CONNECTION_POOL_JTA_DATA_SOURCE
     * @see #CONNECTION_POOL_NON_JTA_DATA_SOURCE
     * @see org.eclipse.persistence.sessions.server.ReadConnectionPool
     */
    public static final String CONNECTION_POOL_SEQUENCE = "eclipselink.connection-pool.sequence.";
    
    /**
     * Tell EclipseLink to use it's internal connection pool to pool connections from a datasource.
     * 
     * This property is useful when using EclipseLink with Gemini JPA because it internally wraps local
     * database information in a datasource.
     * 
     * Default: false
     */
    public static final String CONNECTION_POOL_INTERNALLY_POOL_DATASOURCE = "eclipselink.connection-pool.force-internal-pool";
    
    
    /**
     * The <code>"eclipselink.jdbc.connections.wait-timeout"</code> property
     * which specifies the timeout time in milliseconds (ms) that will be waited
     * for an available connection before an exception is thrown. Ignored in
     * case external connection pools are used.
     * <p>
     * Default: 180000 ms (3 minutes).
     * <p>
     * The value specified should be a string containing a positive integer
     * value. A value of 0 means wait forever.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_WAIT
     * @see #CONNECTION_POOL_WAIT
     */
    @Deprecated
    public static final String JDBC_CONNECTIONS_WAIT = "eclipselink.jdbc.connections.wait-timeout";

    /**
     * The <code>"eclipselink.jdbc.connections.max"</code> property specifies
     * the maximum number of read connection in the internal connection pool. If
     * the maximum size is reached, threads requiring a connection will wait
     * until one is released back to the pool. By default a single shared
     * (exclusive) read/write pool is used with min/max 32 connections and 1
     * initial. Ignored in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_MAX
     */
    @Deprecated
    public static final String JDBC_CONNECTIONS_MAX = "eclipselink.jdbc.connections.max";

    /**
     * The <code>"eclipselink.jdbc.connections.min"</code> property specifies
     * the minimum number of connections in EclipseLink connection pool.
     * <p>
     * Ignored in case external connection pools are used. Connections beyond
     * the minimum will be disconnected when returned to the pool, so this
     * should normally be equal to the number of active threads, or server's
     * thread pool size. By default a single shared (exclusive) read/write pool
     * is used with min/max 32 connections and 1 initial.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MIN
     */
    @Deprecated
    public static final String JDBC_CONNECTIONS_MIN = "eclipselink.jdbc.connections.min";

    /**
     * The <code>"eclipselink.jdbc.connections.initial"</code> property
     * EclipseLink JDBC (internal) connection pools properties. Initial number
     * of connections in EclipseLink connection pool. This is the number of
     * connections connected at startup. By default a single shared (exclusive)
     * read/write pool is used with min/max 32 connections and 1 initial. Ignored
     * in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_INITIAL
     */
    @Deprecated
    public static final String JDBC_CONNECTIONS_INITIAL = "eclipselink.jdbc.connections.initial";

    /**
     * The <code>"eclipselink.jdbc.write-connections.max"</code> property
     * specifies the maximum number of connections supported in the internal
     * write connection pool. Maximum number of connections in EclipseLink write
     * connection pool. If the maximum size is reached, threads requiring a
     * connection will wait until one is released back to the pool. By default a
     * single shared (exclusive) read/write pool is used with min/max 32
     * connections and 1 initial. Ignored in case external connection pools are
     * used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_MAX
     */
    @Deprecated
    public static final String JDBC_WRITE_CONNECTIONS_MAX = "eclipselink.jdbc.write-connections.max";

    /**
     * The <code>"eclipselink.jdbc.write-connections.min"</code> property
     * specifies the minimum number of connections in the internal write
     * connection pool. Connections beyond the minimum will be disconnected when
     * returned to the pool, so this should normally be equal to the number of
     * active threads, or server's thread pool size. By default a single shared
     * (exclusive) read/write pool is used with min/max 32 connections and 1
     * initial. Ignored in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a positive integer
     * value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MIN
     */
    @Deprecated
    public static final String JDBC_WRITE_CONNECTIONS_MIN = "eclipselink.jdbc.write-connections.min";

    /**
     * The <code>"eclipselink.jdbc.write-connections.initial"</code> property
     * configures the number of connections connected at created at startup in
     * the write connection pool. By default a single shared (exclusive)
     * read/write pool is used with min/max 32 connections and 1 initial.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value must be a string containing a zero or greater integer value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_INITIAL
     */
    @Deprecated
    public static final String JDBC_WRITE_CONNECTIONS_INITIAL = "eclipselink.jdbc.write-connections.initial";

    /**
     * The <code>"eclipselink.jdbc.read-connections.max"</code> property
     * configures the maximum number of connections in the read connection pool.
     * If the maximum size is reached, threads requiring a connection will wait
     * until one is released back to the pool (unless shared). By default a
     * separate read connection pool is not used. By default a single shared
     * (exclusive) read/write pool is used with min/max 32 connections and 1
     * initial.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a zero or greater
     * integer value.
     * 
     * @see #JDBC_CONNECTIONS_WAIT to configure the timeout waiting on a
     *      connection.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_MAX
     */
    @Deprecated
    public static final String JDBC_READ_CONNECTIONS_MAX = "eclipselink.jdbc.read-connections.max";

    /**
     * The <code>"eclipselink.jdbc.read-connections.min"</code> property
     * configures the minimum number of connections in read connection pool.
     * Connections beyond the minimum will be disconnected when returned to the
     * pool, so this should normally be equal to the number of active threads,
     * or server's thread pool size. By default a separate read connection pool
     * is not used. By default a single shared (exclusive) read/write pool is
     * used with min/max 32 connections and 1 initial.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value specified should be a string containing a zero or greater
     * integer value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MIN
     */
    @Deprecated
    public static final String JDBC_READ_CONNECTIONS_MIN = "eclipselink.jdbc.read-connections.min";

    /**
     * The <code>"eclipselink.jdbc.read-connections.initial"</code> property
     * configures the number of connections connected at created at startup in
     * the read connection pool. By default a single shared (exclusive)
     * read/write pool is used with min/max 32 connections and 1 initial.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value must be a string containing a zero or greater integer value.
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_INITIAL
     */
    @Deprecated
    public static final String JDBC_READ_CONNECTIONS_INITIAL = "eclipselink.jdbc.read-connections.initial";

    /**
     * The <code>"eclipselink.jdbc.read-connections.shared"</code> property
     * configures whether connections in EclipseLink read connection pool should
     * be shared (not exclusive). Connection sharing means the same JDBC
     * connection will be used concurrently for multiple reading threads.
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"false" (DEFAULT): indicates read connections will not be shared
     * <li>"true": indicates read connections can be shared
     * </ul>
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_SHARED
     * @see #CONNECTION_POOL_SHARED
     */
    @Deprecated
    public static final String JDBC_READ_CONNECTIONS_SHARED = "eclipselink.jdbc.read-connections.shared";

    /**
     * The <code>"eclipselink.jdbc.sequence-connection-pool.max"</code> property
     * configures the maximum number of connections in the sequence connection
     * pool. If the maximum size is reached, threads requiring a connection will
     * wait until one is released back to the pool.
     * <p>
     * By default a separate sequence connection pool is not used (the sequence
     * is allocated on the write connection).
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value must be a string containing a zero or greater integer value.
     * The default value is two (2).
     * 
     * @see #JDBC_SEQUENCE_CONNECTION_POOL Required to configure the use of a
     *      sequence pool/data-source
     * @see #JDBC_CONNECTIONS_WAIT to configure the timeout
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MAX
     * @see #CONNECTION_POOL_MAX
     */
    @Deprecated
    public static final String JDBC_SEQUENCE_CONNECTION_POOL_MAX = "eclipselink.jdbc.sequence-connection-pool.max";

    /**
     * The <code>"eclipselink.jdbc.sequence-connection-pool.min"</code> property
     * configures the minimum number of connections in sequence connection pool.
     * Connections beyond the minimum will be disconnected when returned to the
     * pool, so this should normally be equal to the maximum to avoid
     * connecting/disconnecting.
     * <p>
     * By default a separate sequence connection pool is not used (the sequence
     * is allocated on the write connection).
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value must be a string containing a zero or greater integer value.
     * The default value is two (2).
     * 
     * @see #JDBC_SEQUENCE_CONNECTION_POOL Required to configure the use of a
     *      sequence pool/data-source
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_MIN
     * @see #CONNECTION_POOL_MIN
     */
    @Deprecated
    public static final String JDBC_SEQUENCE_CONNECTION_POOL_MIN = "eclipselink.jdbc.sequence-connection-pool.min";

    /**
     * The <code>"eclipselink.jdbc.sequence-connection-pool.initial</code> property configures the initial number of connections in
     * sequence connection pool. This is the number of connections connected at
     * startup.
     * <p>
     * By default a separate sequence connection pool is not used (the sequence
     * is allocated on the write connection).
     * <p>
     * This property is ignored in case external connection pools are used.
     * <p>
     * The value must be a string containing a zero or greater integer value.
     * The default value is two (2).
     * 
     * @see #JDBC_SEQUENCE_CONNECTION_POOL Required to configure the use of a
     *      sequence pool/data-source
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_INITIAL
     * @see #CONNECTION_POOL_INITIAL
     */
    @Deprecated
    public static final String JDBC_SEQUENCE_CONNECTION_POOL_INITIAL = "eclipselink.jdbc.sequence-connection-pool.initial";

    /**
     * The <code>"eclipselink.jdbc.sequence-connection-pool"</code> property
     * configures a separate connection pool should used for sequencing to
     * retrieve new value(s). This improves sequence allocation by allocating
     * sequencing outside the current transaction. This can be used with
     * internal or external (DataSource) connection pooling, external must
     * provide a non-jta-datasource resource name using
     * {@link #JDBC_SEQUENCE_CONNECTION_POOL_DATASOURCE}. A sequence connection
     * pool is generally only used with using TABLE sequencing to minimize
     * contention on the sequence table(s).
     * <p>
     * Values (case-insensitive):
     * <ul>
     * <li>"false" (DEFAULT):
     * <li>"true":
     * </ul>
     * 
     * @see #JDBC_SEQUENCE_CONNECTION_POOL_DATASOURCE to configure the use of a
     *      non-JTA data source for sequence allocation call.
     * @see #JDBC_SEQUENCE_CONNECTION_POOL_INITIAL to configure the initial
     *      connections size for internal connection pooling
     * @see #JDBC_SEQUENCE_CONNECTION_POOL_MIN to configure the minimum
     *      connections size for internal connection pooling
     * @see #JDBC_SEQUENCE_CONNECTION_POOL_MAX to configure the maximum
     *      connections size for internal connection pooling
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_SEQUENCE
     * @see #CONNECTION_POOL_SEQUENCE
     */
    @Deprecated
    public static final String JDBC_SEQUENCE_CONNECTION_POOL = "eclipselink.jdbc.sequence-connection-pool";

    /**
     * The <code>"eclipselink.jdbc.sequence-connection-pool.non-jta-data-source</code> property configures the name of the non-JTA data source that
     * will be used for sequencing calls.
     * 
     * @see #JDBC_SEQUENCE_CONNECTION_POOL
     * @deprecated as of EclipseLink 2.2 replaced by CONNECTION_POOL_NON_JTA_DATA_SOURCE
     * @see #CONNECTION_POOL_NON_JTA_DATA_SOURCE
     */
    @Deprecated
    public static final String JDBC_SEQUENCE_CONNECTION_POOL_DATASOURCE = "eclipselink.jdbc.sequence-connection-pool.non-jta-data-source";

    /**
     * "eclipselink.partitioning"
     * <p>Used to set the default PartitioningPolicy for a persistence unit.
     * A PartitioningPolicy is used to partition the data for a class across multiple difference databases
     * or across a database cluster such as Oracle RAC.
     * Partitioning can provide improved scalability by allowing multiple database machines to service requests.
     * <p>
     * If multiple partitions are used to process a single transaction, JTA should be used for proper XA transaction support.
     * <p>
     * The value must be set to the name of an existing defined PartitioningPolicy.
     * 
     * @see org.eclipse.persistence.annotations.Partitioning
     * @see org.eclipse.persistence.descriptors.partitioning.PartitioningPolicy
     */
    public static final String PARTITIONING = "eclipselink.partitioning";
    
    /**
     * "eclipselink.partitioning.callback"
     * <p>Used to integrate with an external DataSource's data affinity support, such as UCP.
     * <p>
     * The value must be set to the full class name of the implementor of the DataPartitioningCallback interface.
     * <p>i.e. "org.eclipse.persistence.platform.database.oracle.ucp.UCPDataPartitioningCallback".
     * 
     * @see org.eclipse.persistence.platform.database.partitioning.DataPartitioningCallback
     * @see org.eclipse.persistence.annotations.Partitioning
     * @see org.eclipse.persistence.descriptors.partitioning.PartitioningPolicy
     */
    public static final String PARTITIONING_CALLBACK = "eclipselink.partitioning.callback";
    
    /**
     * Property <code>"eclipselink.jdbc.bind-parameters</code> configures whether parameter binding will be used in the
     * creation of JDBC prepared statements. Usage of parameter binding is
     * generally a performance optimization allowing for SQL and prepared
     * statement caching as well as usage of batch writing.
     * <p>
     * Values:
     * <ul>
     * <li>"true" (DEFAULT): binding will be used
     * <li>"false": values will be written literally into the generated SQL
     * </ul>
     */
    public static final String JDBC_BIND_PARAMETERS = "eclipselink.jdbc.bind-parameters";

    /**
     * The <code>"eclipselink.jdbc.exclusive-connection.mode"</code> property
     * specifies when reads are performed through the write connection. You can
     * set this property while creating either an EntityManagerFactory (either
     * in the map passed to the createEntityManagerFactory method, or in the
     * persistence.xml file), or an EntityManager (in the map passed to the
     * createEntityManager method). Note that the latter overrides the former.
     * <p>
     * Values:
     * <ul>
     * <li>"Transactional" (DEFAULT):
     * {@link ExclusiveConnectionMode#Transactional}
     * <li>"Isolated" - {@link ExclusiveConnectionMode#Isolated}
     * <li>"Always" - {@link ExclusiveConnectionMode#Always}
     * </ul>
     * 
     * @see ExclusiveConnectionMode
     */
    public static final String EXCLUSIVE_CONNECTION_MODE = "eclipselink.jdbc.exclusive-connection.mode";

    /**
     * The <code>"eclipselink.jdbc.exclusive-connection.is-lazy"</code> property
     * specifies when write connection is acquired lazily.
     * <p>
     * Values:
     * <ul>
     * <li>"false"
     * <li>"true" (DEFAULT)
     * </ul>
     */
    public static final String EXCLUSIVE_CONNECTION_IS_LAZY = "eclipselink.jdbc.exclusive-connection.is-lazy";

    /**
     * The <code>"eclipselink.jdbc.cache-statements.size"</code> property
     * specifies the number of statements held when using internal statement
     * caching. The value must be a string value containing a positive integer
     * or zero.
     * <p>
     * Default: "50".
     */
    public static final String CACHE_STATEMENTS_SIZE = "eclipselink.jdbc.cache-statements.size";

    /**
     * The <code>"eclipselink.jdbc.cache-statements"</code> property specifies
     * whether JDBC statements should be cached. This is recommended when using
     * EclipseLink's internal connection pooling.
     * <p>
     * Valid values:
     * <ul>
     * <li>true - enable internal statement caching.
     * <li>false - disable internal statement caching. (DEFAULT)
     * </ul>
     * <p>
     * Example: persistence.xml file <code>
     * <property name="eclipselink.jdbc.cache-statements" value="false"/>
     * </code> Example: property Map <code>
     * propertiesMap.put(PersistenceUnitProperties.CACHE_STATEMENTS, "false");
     * </code>
     */
    public static final String CACHE_STATEMENTS = "eclipselink.jdbc.cache-statements";

    // Bean Validation properties

    /**
     * The <code>"javax.persistence.validation.factory"</code> property
     * specifies an instance of <a href =
     * http://download.oracle.com/javaee/6/docs/api/javax/validation/ValidatorFactory.html>javax.validation.ValidatorFactory</a> used by
     * EclipseLink to perform Automatic Validation upon Lifecycle Events. If the
     * property is not specified, and if Bean Validation API is visible to
     * Eclipselink, it will try to instantiate an instance of
     * <code>javax.validation.ValidationFactory</code> by calling
     * <code>Validation.buildDefaultValidatorFactory()</code>
     */
    public static final String VALIDATOR_FACTORY = "javax.persistence.validation.factory";

    /**
     * The <code>"javax.persistence.validation.mode"</code> property specifies
     * whether the automatic lifecycle event validation is in effect.
     * <p>
     * Valid values for this property are "AUTO", "CALLBACK" or "NONE".
     */
    public static final String VALIDATION_MODE = "javax.persistence.validation.mode";

    /**
     * The <code>"javax.persistence.validation.group.pre-persist"</code>
     * property specifies the name of the validator groups to execute for
     * preUpdate event. The value should be a string with fully qualified
     * classnames separated by a comma (','). If this value is not specified in
     * both persistence.xml or using this property, the default Bean Validation
     * group (the group Default) will be validated
     */
    public static final String VALIDATION_GROUP_PRE_PERSIST = "javax.persistence.validation.group.pre-persist";

    /**
     * The <code>"javax.persistence.validation.group.pre-update"</code> property
     * specifies the name of the validator groups to execute for preUpdate
     * event. The value should be a string with fully qualified classnames
     * separated by a comma (','). If this value is not specified in both
     * persistence.xml or using this property, the default Bean Validation group
     * (the group Default) will be validated
     */
    public static final String VALIDATION_GROUP_PRE_UPDATE = "javax.persistence.validation.group.pre-update";

    /**
     * The <code>"javax.persistence.validation.group.pre-remove"</code> property
     * specifies the name of the validator groups to execute for preRemove
     * event. The value should be a string with fully qualified classnames
     * separated by a comma (','). If this value is not specified in both
     * persistence.xml or using this property, no validation will occur on
     * remove.
     */
    public static final String VALIDATION_GROUP_PRE_REMOVE = "javax.persistence.validation.group.pre-remove";

    // Caching Properties

    /**
     * Default Suffix could be appended to some prefixes to form a property name
     * setting the default for the persistence unit.
     * 
     * @see #CACHE_SIZE_
     * @see #CACHE_TYPE_
     * @see #CACHE_SHARED_
     */
    public static final String DEFAULT = "default";

    /**
     * Property prefix <code>"eclipselink.cache.size.</code> used to specify the cache size for a specific
     * entity type. The prefix must be followed by a valid entity type name.
     * <p>
     * Property names formed out of these prefixes by appending either entity
     * name, or class name (indicating that the property values applies only to
     * a particular entity) or DEFAULT suffix (indicating that the property
     * value applies to all entities). For most cache types, the size is only
     * the initial size, not a fixed or maximum size. For CacheType.SoftCache
     * and CacheType.HardCache the size is the sub-cache size. The default cache
     * size is 100.
     * 
     * @see #CACHE_SIZE_DEFAULT
     */
    public static final String CACHE_SIZE_ = "eclipselink.cache.size.";

    /**
     * All valid values for CACHE_TYPE_ properties are declared in CacheType
     * class. The default cache type is SoftWeak. This sets the type of cache,
     * if you do not wish to cache entities at all, then set CACHE_SHARED_.
     * 
     * @see #CACHE_SHARED_
     * @see CacheType
     * @see #CACHE_TYPE_DEFAULT
     */
    public static final String CACHE_TYPE_ = "eclipselink.cache.type.";

    /**
     * Indicates whether entity's cache should be shared (non-isolated). Valid
     * values are case-insensitive "false" and "true"; "true" is default. If you
     * do not wish to cache your entities, set this to "false".
     * 
     * @see #CACHE_SHARED_DEFAULT
     */
    public static final String CACHE_SHARED_ = "eclipselink.cache.shared.";

    /**
     * Default caching properties - apply to all entities. May be overridden by
     * individual entity property with the same prefix. For most cache types,
     * the size is only the initial size, not a fixed or maximum size. For
     * CacheType.SoftCache and CacheType.HardCache the size is the sub-cache
     * size. The default cache size is 100.
     */
    public static final String CACHE_SIZE_DEFAULT = CACHE_SIZE_ + DEFAULT;

    /**
     * Default caching properties - apply to all entities. May be overridden by
     * individual entity property with the same prefix. The default cache type
     * is SoftWeak. This sets the type of cache, if you do not wish to cache
     * entities at all, then set CACHE_SHARED_DEFAULT.
     * 
     * @see #CACHE_SHARED_DEFAULT
     */
    public static final String CACHE_TYPE_DEFAULT = CACHE_TYPE_ + DEFAULT;

    /** 
     * NOTE: The Canonical Model properties should be kept in sync with those
     * in org.eclipse.persistence.internal.jpa.modelgen.CanonicalModelProperties. 
     */
    
    /**
     * This optional property specifies the prefix that will be added to the 
     * start of the class name of any canonical model class generated. 
     * By default the prefix is not used.
     */    
    public static final String CANONICAL_MODEL_PREFIX = "eclipselink.canonicalmodel.prefix";
    public static String CANONICAL_MODEL_PREFIX_DEFAULT = "";
    
    /**
     * This optional property specifies the suffix that will be added to the 
     * end of the class name of any canonical model class generated. The suffix
     * defaults to "_" unless a prefix is specified. If this property is
     * specified, the value must be a non-empty string that contains valid
     * characters for use in a Java class name.
     */
    public static final String CANONICAL_MODEL_SUFFIX = "eclipselink.canonicalmodel.suffix";
    public static String CANONICAL_MODEL_SUFFIX_DEFAULT = "_";
    
    /**
     * This optional property specifies a sub-package name that can be used to 
     * have the canonical model generator generate its classes in a sub-package 
     * of the package where the corresponding entity class is located. By 
     * default the canonical model classes are generated into the same package 
     * as the entity classes. 
     */
    public static final String CANONICAL_MODEL_SUB_PACKAGE = "eclipselink.canonicalmodel.subpackage";
    public static String CANONICAL_MODEL_SUB_PACKAGE_DEFAULT = "";
    
    /**
     * This optional property can be used a performance enhancement between
     * compile rounds. It is used to avoid reloading XML metadata on each
     * compile which may only contain a single class etc. The default value
     * is true and should be left as such for the initial generation to capture
     * the XML metadata. Afterwards users may choose to set this flag if no
     * changes to XML are expected thereafter.
     */
    public static final String CANONICAL_MODEL_LOAD_XML = "eclipselink.canonicalmodel.load_xml";
    public static final String CANONICAL_MODEL_LOAD_XML_DEFAULT = "true";
    
    /**
     * This optional property can be used a performance enhancement between
     * compile rounds within an IDE. It is used to avoid using a static metadata 
     * factory between 'cache' metadata from incremental builds. Turning this 
     * off in some use cases (IDE) could result in a loss of functionality. 
     * The default value is true and should be left as such for full feature 
     * support.
     */
    public static final String CANONICAL_MODEL_USE_STATIC_FACTORY = "eclipselink.canonicalmodel.use_static_factory";
    public static final String CANONICAL_MODEL_USE_STATIC_FACTORY_DEFAULT = "true";
    
    /**
     * Default caching properties - apply to all entities. May be overridden by
     * individual entity property with the same prefix. If you do not wish to
     * cache your entities, set this to "false".
     */
    public static final String CACHE_SHARED_DEFAULT = CACHE_SHARED_ + DEFAULT;

    /**
     * Property prefix <code>"eclipselink.cache.query-results</code> used to
     * configure the default option for query results caching.
     * <p>
     * The query results cache is separate from the object cache.
     * It caches the results of named query execution.
     * The query results cache is not enabled by default, and
     * can be enabled per query.
     * This option allows it to be enabled for all named queries.
     * Valid values are "true" or "false" (default).
     */
    public static final String QUERY_CACHE = "eclipselink.cache.query-results";
    
    /**
     * Allows integration with a database event notification service.
     * This allows the EclipseLink cache to be invalidated by database change events.
     * This is used to support Oracle QCN/DCN (Database Change event Notification),
     * but could also be used by triggers or other services, or other types of events.
     * Must be set to the name of a class that implements DatabaseEventListener,
     * such as the OracleChangeNotificationListener (org.eclipse.persistence.platform.database.oracle.dcn.OracleChangeNotificationListener).
     * The values of "DCN" and "QCN" may also be used for Oracle.
     * 
     * @see DatabaseEventListener
     * @see org.eclipse.persistence.platform.database.oracle.dcn.OracleChangeNotificationListener
     */
    public static final String DATABASE_EVENT_LISTENER = "eclipselink.cache.database-event-listener";
    
    // Customizations properties

    /**
     * The type of logger. By default DefaultSessionLog is used. Valid values
     * are the logger class name which implements
     * org.eclipse.persistence.logging.SessionLog or one of values defined in
     * LoggerType.
     * 
     * @see LoggerType
     */
    public static final String LOGGING_LOGGER = "eclipselink.logging.logger";

    /**
     * Property <code>"eclipselink.logging.level</code> allows the default logging levels to be specified.
     * <p>
     * <b>Java example:</b> <code>
     * props.put(PersistenceUnitProperties.LOGGING_LEVEL, SessionLog.FINE_LABEL);</br>
     * <p>
     * <b>XML example:</b>
     * <code>
     * <property name="eclipselink.logging.level" value="FINE" />;</br>
     * </code>
     * <p>
     * <b>Logging Levels:</b>
     * 
     * @see SessionLog#OFF_LABEL = "OFF"
     * @see SessionLog#SEVERE_LABEL = "SEVERE"
     * @see SessionLog#WARNING_LABEL = "WARNING"
     * @see SessionLog#CONFIG_LABEL = "CONFIG"
     * @see SessionLog#INFO_LABEL = "INFO" (DEFAULT)
     * @see SessionLog#FINE_LABEL = "FINE"
     * @see SessionLog#FINER_LABEL = "FINER"
     * @see SessionLog#FINEST_LABEL = "FINEST"
     * @see SessionLog#ALL_LABEL = "ALL"
     * 
     * @see #CATEGORY_LOGGING_LEVEL_ for category specific level configuration
     */
    public static final String LOGGING_LEVEL = "eclipselink.logging.level";

    /**
     * Property prefix <code>"eclipselink.logging.level.</code> allows the category specific logging levels to be
     * specified.
     * <p>
     * <b>Java example:</b> <code>
     * props.put(PersistenceUnitProperties.CATEGORY_LOGGING_LEVEL_ + SessionLog.EJB_OR_METADATA, SessionLog.WARNING_LABEL);</br>
     * <p>
     * <b>XML example:</b>
     * <code>
     * <property name="eclipselink.logging.level.ejb_or_metadata" value="WARNING" />;</br>
     * </code> specific Valid values are names of levels defined in
     * java.util.logging.Level, default value is INFO.
     * <p>
     * <b>Categories:</b>
     * 
     * @see SessionLog#SQL
     * @see SessionLog#TRANSACTION
     * @see SessionLog#EVENT
     * @see SessionLog#CONNECTION
     * @see SessionLog#QUERY
     * @see SessionLog#CACHE
     * @see SessionLog#PROPAGATION
     * @see SessionLog#SEQUENCING
     * @see SessionLog#METADATA
     * @see SessionLog#METAMODEL
     * @see SessionLog#WEAVER
     * @see SessionLog#PROPERTIES
     * @see SessionLog#SERVER
     */
    public static final String CATEGORY_LOGGING_LEVEL_ = LOGGING_LEVEL + ".";
    
    /**
     * By default sql bind paramters are displayed in exceptions and logs
     * when the log level is FINE or greater. To override this behavior you
     * may set this property to specify that the data should or should not be
     * visible. Note: this property applies only to bind parameters. When not
     * using binding, the parameters are always displayed.
     * 
     * @see JDBC_BIND_PARAMETERS 
     */
    public static final String LOGGING_PARAMETERS = "eclipselink.logging.parameters";

    /**
     * The <code>"eclipselink.logging.timestamp"</code> property configures if
     * the current timestamp should be included in each log message.
     * <p>
     * Values:
     * <ul>
     * <li>"true" (Default)
     * <li>"false"
     * </ul>
     */
    public static final String LOGGING_TIMESTAMP = "eclipselink.logging.timestamp";

    /**
     * The <code>"eclipselink.tenant-id"</code> property specifies the 
     * default context property used to populate multitenant entities.
     * 
     * NOTE: This is merely a default multitenant property than can be used on 
     * its own or with other properties defined by the user. Users are not 
     * obligated to use this property and are free to specify their own.
     * 
     * @see org.eclipse.persistence.annotations.Multitenant
     * @see org.eclipse.persistence.annotations.TenantDiscriminatorColumn
     * 
     * Example: persistence.xml file <code>
     * <property name="eclipselink.tenant-id" value="Oracle"/>
     * </code> Example: property Map <code>
     * propertiesMap.put(PersistenceUnitProperties.MULTITENANT_PROPERTY_DEFAULT, "Oracle");
     * </code>
     */
    public static final String MULTITENANT_PROPERTY_DEFAULT = "eclipselink.tenant-id";
    
    /**
     * Property <code>"eclipselink.multitenant.tenants-share-cache</code> 
     * specifies that multitenant entities will share the L2 cache. By default 
     * this property is false meaning multitenant entities will have an ISOLATED 
     * setting. When setting it to true a PROTECTED cache setting will be used.
     * 
     * WARNING: Queries that use the cache may return data from other tenants 
     * when using the PROTECTED setting.
     * 
     * @see eclipselink.multitenant.tenants-share-emf
     * 
     * <p>
     * <b>Java example:</b> <code>
     * props.put(PersistenceUnitProperties.MULTITENANT_SHARED_CACHE, true);</br>
     * <p>
     * <b>XML example:</b>
     * <code>
     * <property name="eclipselink.multitenant.tenants-share-cache" value="true" />;</br>
     * </code>
     */
    public static final String MULTITENANT_SHARED_CACHE = "eclipselink.multitenant.tenants-share-cache";
    
    /**
     * Property <code>"eclipselink.multitenant.shared-emf</code> is used to 
     * indicate that multitenant entities will be used within a shared entity
     * manager factory. This property defaults to true (and applies to
     * multitenant entities only). When setting it to false, users are required 
     * to provide a unique session name.
     * 
     * @see eclipselink.session-name
     * @see eclipselink.multitenant.tenants-share-cache
     * 
     * <p>
     * <b>Java example:</b> <code>
     * props.put(PersistenceUnitProperties.MULTITENANT_SHARED_EMF, true);</br>
     * <p>
     * <b>XML example:</b>
     * <code>
     * <property name="eclipselink.multitenant.tenants-share-emf" value="true" />;</br>
     * </code>
     */
    public static final String MULTITENANT_SHARED_EMF = "eclipselink.multitenant.tenants-share-emf";
    
    /**
     * Property <code>"eclipselink.logging.thread"</code> indicating if current
     * thread should have its identity included in each log message.
     * <p>
     * By default ("true") the thread is logged at FINE or less level. This can
     * be turned off ("false") or on ("true"). Values:
     * <ul>
     * <li>"true" (Default)
     * <li>"false"
     * </ul>
     */
    public static final String LOGGING_THREAD = "eclipselink.logging.thread";

    /**
     * Property <code>"eclipselink.logging.session"</code> indicating if the
     * session in use should have its identity included in each log message.
     * <p>
     * Values:
     * <ul>
     * <li>"true" (Default)
     * <li>"false"
     * </ul>
     */
    public static final String LOGGING_SESSION = "eclipselink.logging.session";

    /**
     * Property: <code>"eclipselink.logging.connection"</code>
     * <p>
     * Values:
     * <ul>
     * <li>"true" (Default)
     * <li>"false"
     * </ul>
     */
    public static final String LOGGING_CONNECTION = "eclipselink.logging.connection";

    /**
     * Values:
     * <ul>
     * <li>"true" (Default)
     * <li>"false"
     * </ul>
     */
    public static final String LOGGING_EXCEPTIONS = "eclipselink.logging.exceptions";

    /**
     * The <code>"eclipselink.logging.file"</code> property configures a file
     * location where the log will be output to instead of standard out.
     */
    public static final String LOGGING_FILE = "eclipselink.logging.file";

    // Platforms & Customization
    
    /**
     * The <code>"eclipselink.ddl.table-creation-suffix"</code> property is used in 
     * conjunction with DDL generation options to append a string to the end of 
     * generated CREATE Table statements
     * 
     * This value is applied to all Table creation statements through the DDL generation feature
     * ie <property name="eclipselink.ddl.table-creation-suffix" value="engine=InnoDB"/>
     */
    public static final String TABLE_CREATION_SUFFIX = "eclipselink.ddl-generation.table-creation-suffix";

    /**
     * The <code>"eclipselink.target-database"</code> property configures the
     * database that will be used controlling custom operations and SQL
     * generation for the specified database.
     * <p>
     * Values: Either a short string values as defined in {@link TargetDatabase}
     * or a fully qualified class name for a class that extends
     * {@link DatabasePlatform}. The default value is TargetDatabase.Auto which
     * means EclipseLink will try to automatically determine the correct
     * database platform type.
     * </p>
     * Note: <code>"eclipselink.target-database"</code> must be specified with a
     * non-"Auto" class name or short name when <code>"eclipselink.validation-only"</code>
     * is set to <code>"True"</code>.
     * 
     * @see TargetDatabase
     * @see DatabasePlatform
     */
    public static final String TARGET_DATABASE = "eclipselink.target-database";

    /**
     * The <code>"eclipselink.exclude-eclipselink-orm"</code> property
     * configures the exclusion of an EclipseLink ORM mapping file for a
     * specific persistence unit. By default the first file found at the
     * resource name: "META-INF/eclipselink-orm.xml" is processed and overrides
     * configurations specified in annotations, and standard mapping files.
     */
    public static final String EXCLUDE_ECLIPSELINK_ORM_FILE = "eclipselink.exclude-eclipselink-orm";

    /**
     * The <code>"eclipselink.session-name"</code> property configures a
     * specific name to use when storing the singleton server session within the
     * {@link SessionManager}.
     * <p>
     * By default a unique session name is generated by EclipseLink, but the
     * user can provide a customary session name - and make sure it's unique. If
     * a sessions-xml file is used this must be the name of the session in the
     * sessions-xml file.
     */
    public static final String SESSION_NAME = "eclipselink.session-name";

    // Weaving Properties

    /**
     * The <code>"eclipselink.weaving"</code> property configures whether
     * weaving should be performed. Weaving is requires for lazy OneToOne,
     * ManyToOne, Basic, attribute change tracking, fetch groups, and other
     * optimizations.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>Not Set - defaults to "true" in Java SE using javaagent and within
     * EJB 3+ compliant containers
     * <li>"true" - requires that weaving be done. Will throw an exception if
     * entities are not woven
     * <li>"false" - forces weaving not to be done
     * <li>"static" - requires that the static weaving utility was used to weave
     * the entities
     * </ul>
     * <i>Note: Any value specified that is not in the above list is treated as
     * "static".</i>
     */
    public static final String WEAVING = "eclipselink.weaving";

    /**
     * The <code>"eclipselink.weaving.internal"</code> property indicates
     * whether internal optimizations should be enabled through weaving.
     * 
     * Internal optimizations include caching of primary key and session, 
     * addition of a serialVersionUID if none exists, optimization of EclipseLink's
     * cloning strategy and optimization of the way EclipseLink gets and sets values from
     * fields mapped as Basic.
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     * 
     * @see #WEAVING
     */
    public static final String WEAVING_INTERNAL = "eclipselink.weaving.internal";

    /**
     * The <code>"eclipselink.weaving.lazy"</code> property configures whether
     * LAZY OneToOne and ManyToOne mappings should be enabled through weaving.
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     * 
     * @see #WEAVING
     */
    public static final String WEAVING_LAZY = "eclipselink.weaving.lazy";

    /**
     * The <code>"eclipselink.weaving.eager"</code> property configures whether
     * EAGER mapping's attributes should be woven to use indirection.
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true"
     * <li>"false" (DEFAULT)
     * </ul>
     * 
     * @see #WEAVING
     */
    public static final String WEAVING_EAGER = "eclipselink.weaving.eager";

    /**
     * The <code>"eclipselink.weaving.changetracking"</code> property configures
     * whether AttributeLevelChangeTracking should be enabled through weaving.
     * When this is enabled, only classes with all mappings allowing change
     * tracking will have change tracking enabled. Mutable basic attributes will
     * prevent this.
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     * 
     * @see #WEAVING
     */
    public static final String WEAVING_CHANGE_TRACKING = "eclipselink.weaving.changetracking";

    /**
     * The <code>"eclipselink.weaving.fetchgroups"</code> property configures
     * whether FetchGroup support should be enabled through weaving. When this
     * is enabled, lazy direct mappings will be supported as well as descriptor
     * and query level FetchGroups. FetchGroups allow partial objects to be read
     * and written, access to un-fetched attributes will cause the object to be
     * refreshed/fully-fetched.
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     * 
     * @see #WEAVING
     * @see org.eclipse.persistence.descriptors.FetchGroupManager
     * @see org.eclipse.persistence.queries.FetchGroup
     */
    public static final String WEAVING_FETCHGROUPS = "eclipselink.weaving.fetchgroups";

    /**
     * The <code>"eclipselink.target-server"</code> property configures the
     * {@link ServerPlatform} that will be used to enable integration with a
     * host container.
     * <p>
     * Valid values are defined in TargetServer class - they correspond to
     * server platforms currently supported. Also a custom server platform may
     * be specified by supplying a full class name. Specifying a name of the
     * class implementing ExternalTransactionController sets
     * CustomServerPlatform with this controller. Default is TargetServer.None.
     * 
     * @see TargetServer
     */
    public static final String TARGET_SERVER = "eclipselink.target-server";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.database.action"</code> 
     * property specifies the action to be taken by the persistence provider with 
     * regard to the database artifacts.</p>
     *  
     * <p>The values for this property are <code>"none"</code>, <code>"create"</code>, 
     * <code>"drop-and-create"</code>, <code>"drop"</code>.</p> 
     * 
     * <p>If the <code>"javax.persistence.schema-generation.database.action"</code> 
     * property is not specified, no schema generation actions must be taken on 
     * the database.</p>
     */
    public static final String SCHEMA_GENERATION_DATABASE_ACTION = "javax.persistence.schema-generation.database.action";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.scripts.action"</code> 
     * property specifies which scripts are to be generated by the persistence 
     * provider.</p>
     * 
     * <p>The values for this property are <code>"none"</code>, <code>"create"</code>, 
     * <code>"drop-and-create"</code>, <code>"drop"</code>.</p> 
     * 
     * <p>Scripts will only be generated if script targets are specified. If 
     * this property is not specified, no scripts will be generated.</p>
     */
    public static final String SCHEMA_GENERATION_SCRIPTS_ACTION = "javax.persistence.schema-generation.scripts.action";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.create-source"</code> 
     * property specifies whether the creation of database artifacts is to occur 
     * on the basis of the object/relational mapping metadata, DDL script, or a 
     * combination of the two.</p>
     * 
     * <p>The values for this property are <code>"metadata"</code>, <code>"script"</code>, 
     * <code>"metadata-then-script"</code>, <code>"script-then-metadata"</code>.</p>
     * 
     * <p>If this property is not specified, and a script is specified by the 
     * <code>"javax.persistence.schema-generation.create-script-source property"</code>, 
     * the script (only) will be used for schema generation; otherwise if this 
     * property is not specified, schema generation will occur on the basis of 
     * the object/relational mapping metadata (only).</p>
     * 
     * <p>The <code>"metadata-then-script"</code> and <code>"script-then-metadata"</code> 
     * values specify that a combination of metadata and script is to be used 
     * and the order in which this use is to occur. If either of these values is 
     * specified and the resulting database actions are not disjoint, the 
     * results are undefined and schema generation may fail.</p>
     */
    public static final String SCHEMA_GENERATION_CREATE_SOURCE = "javax.persistence.schema-generation.create-source";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.drop-source"</code> property 
     * specifies whether the dropping of database artifacts is to occur on the 
     * basis of the object/relational mapping metadata, DDL script, or a 
     * combination of the two.</p> 
     * 
     * <p>The values for this property are <code>"metadata"</code>, <code>"script"</code>, 
     * <code>"metadata-then-script"</code>, <code>"script-then-metadata"</code>.</p>
     * 
     * <p>If this property is not specified, and a script is specified by the 
     * <code>"javax.persistence.schema-generation.drop-script-source"</code> property, 
     * the script (only) will be used for the dropping of database artifacts; 
     * otherwise if this property is not specified, the dropping of database 
     * artifacts will occur on the basis of the object/relational mapping 
     * metadata (only).</p>
     * 
     * <p>The <code>"metadata-then-script"</code> and <code>"script-then-metadata"</code> 
     * values specify that a combination of metadata and script is to be used 
     * and the order in which this use is to occur. If either of these values is 
     * specified and the resulting database actions are not disjoint, the 
     * results are undefined and the dropping of database artifacts may fail.</p>
     */
    public static final String SCHEMA_GENERATION_DROP_SOURCE = "javax.persistence.schema-generation.drop-source";
    
    /**
     * <p>In Java EE environments, it is anticipated that the Java EE platform 
     * provider may wish to control the creation of database schemas rather than 
     * delegate this task to the persistence provider.</p> 
     * 
     * <p>The <code>"javax.persistence.schema-generation.create-database-schemas"</code> 
     * property specifies whether the persistence provider is to create the 
     * database schema(s) in addition to creating database objects such as 
     * tables, sequences, constraints, etc.</p>
     * 
     * <p>The value of this boolean property should be set to true if the 
     * persistence provider is to create schemas in the database or to generate 
     * DDL that contains <code>"CREATE SCHEMA"</code> commands. If this property 
     * is not supplied, the provider should not attempt to create database 
     * schemas. This property may also be specified in Java SE environments.</p>
     */
    public static final String SCHEMA_GENERATION_CREATE_DATABASE_SCHEMAS = "javax.persistence.schema-generation.create-database-schemas";
    
    /**
     * <p>If scripts are to be generated, the target locations for the writing 
     * of these scripts must be specified.</p>
     * 
     * <p>The <code>"javax.persistence.schema-generation.scripts.create-target"</code> 
     * property specifies a java.IO.Writer configured for use by the persistence 
     * provider for output of the DDL script or a string specifying the file URL 
     * for the DDL script. This property should only be specified if scripts are 
     * to be generated.</p>
     */
    public static final String SCHEMA_GENERATION_SCRIPTS_CREATE_TARGET = "javax.persistence.schema-generation.scripts.create-target";
    
    /**
     * <p>If scripts are to be generated, the target locations for the writing 
     * of these scripts must be specified.</p>
     * 
     * <p>The <code>"javax.persistence.schema-generation.scripts.drop-target"</code> 
     * property specifies a java.IO.Writer configured for use by the persistence 
     * provider for output of the DDL script or a string specifying the file URL 
     * for the DDL script. This property should only be specified if scripts are 
     * to be generated.</p>
     */
    public static final String SCHEMA_GENERATION_SCRIPTS_DROP_TARGET = "javax.persistence.schema-generation.scripts.drop-target";
    
    /**
     * <p>If scripts are to be generated by the persistence provider and a 
     * connection to the target database is not supplied, the 
     * <code>"javax.persistence.database-product-name"</code> property must be 
     * specified.</p> 
     * 
     * <p>The value of this property should be the value returned for the target 
     * database by the JDBC DatabaseMetaData method getDatabaseProductName.</p> 
     * 
     * <p>If sufficient database version information is not included in the 
     * result of this method, the <code>"javax.persistence.database-major-version"</code> 
     * and <code>"javax.persistence.database-minor-version"</code> properties 
     * should be specified as needed. These should contain the values returned 
     * by the JDBC getDatabaseMajorVersion and getDatabaseMinor-Version methods 
     * respectively.</p>
     */
    public static final String SCHEMA_DATABASE_PRODUCT_NAME = "javax.persistence.database-product-name";
    
    /**
     * <p>If sufficient database version information is not included from the
     * JDBC DatabaseMetaData method getDatabaseProductName, the 
     * <code>"javax.persistence.database-major-version"</code> property should 
     * be specified as needed. This should contain the value returned by the 
     * JDBC getDatabaseMajor-Version method.</p>
     */
    public static final String SCHEMA_DATABASE_MAJOR_VERSION = "javax.persistence.database-major-version";
    
    /**
     * <p>If sufficient database version information is not included from the 
     * JDBC DatabaseMetaData method getDatabaseProductName, the 
     * <code>"javax.persistence.database-minor-version"</code> property should 
     * be specified as needed. This should contain the value returned by the 
     * JDBC getDatabaseMinor-Version method.</p>
     */
    public static final String SCHEMA_DATABASE_MINOR_VERSION = "javax.persistence.database-minor-version";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.create-script-source"</code> 
     * is used for script execution.</p>
     * 
     * <p>In Java EE container environments, it is generally expected that the 
     * container will be responsible for executing DDL scripts, although the 
     * container is permitted to delegate this task to  the persistence provider.</p> 
     * 
     * <p>If DDL scripts are to be used in Java SE environments or if the Java 
     * EE container delegates the execution of scripts to the persistence 
     * provider, this property must be specified.</p>
     * 
     * <p>The <code>"javax.persistence.schema-generation.create-script-source"</code> 
     * property specifies a java.IO.Reader configured for reading of the DDL 
     * script or a string designating a file URL for the DDL script.</p>
     */
    public static final String SCHEMA_GENERATION_CREATE_SCRIPT_SOURCE = "javax.persistence.schema-generation.create-script-source";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.drop-script-source"</code> 
     * is used for script execution.</p> 
     * 
     * <p>In Java EE container environments, it is generally expected that the 
     * container will be responsible for executing DDL scripts, although the 
     * container is permitted to delegate this task to  the persistence provider.</p> 
     * 
     * <p>If DDL scripts are to be used in Java SE environments or if the Java 
     * EE container delegates the execution of scripts to the persistence 
     * provider, this property must be specified.</p>
     * 
     * <p>The <code>"javax.persistence.schema-generation.drop-script-source"</code> 
     * property specifies a java.IO.Reader configured for reading of the DDL 
     * script or a string designating a file URL for the DDL script.</p>
     */
    public static final String SCHEMA_GENERATION_DROP_SCRIPT_SOURCE = "javax.persistence.schema-generation.drop-script-source";
    
    /**
     * <p>The <code>"javax.persistence.schema-generation.connection"</code> property 
     * specifies the JDBC connection to be used for schema generation. This is 
     * intended for use in Java EE environments, where the platform provider may 
     * want to control the database privileges that are available to the 
     * persistence provider.</p>
     * 
     * <p>This connection is provided by the container, and should be closed by 
     * the container when the schema generation request or entity manager 
     * factory creation completes.</p> 
     * 
     * <p>The connection provided must have credentials sufficient for the 
     * persistence provider to carry out the requested actions.</p> 
     * 
     * <p>If this property is not specified, the persistence provider should use 
     * the DataSource that has otherwise been provided.</p>
     */
    public static final String SCHEMA_GENERATION_CONNECTION = "javax.persistence.schema-generation.connection";
    
    /**
     * <p>In Java EE container environments, it is generally expected that the 
     * container will be responsible for executing data load scripts, although 
     * the container is permitted to delegate this task to the persistence 
     * provider. If a load script is to be used in Java SE environments or if 
     * the Java EE container delegates the execution of the load script to the 
     * persistence provider, this property must be specified.</p>
     * 
     * <p>The <code>"javax.persistence.sql-load-script-source"</code> property 
     * specifies a java.IO.Reader configured for reading of the SQL load script 
     * for database initialization or a string designating a file URL for the 
     * script.</p>
     */
    public static final String SCHEMA_GENERATION_SQL_LOAD_SCRIPT_SOURCE = "javax.persistence.sql-load-script-source";
    
    /**
     * The parameter value <code>"create"</code>
     * <p>For use with the <code>"javax.persistence.schema-generation.database.action"</code> 
     * and <code>"javax.persistence.schema-generation.scripts.action"</code> properties.</p>
     * <p>Specifies that database tables should be created.</p>
     */
    public static final String SCHEMA_GENERATION_CREATE_ACTION = "create";
    
    /**
     * The parameter value <code>"drop-and-create"</code>
     * <p>For use with the <code>"javax.persistence.schema-generation.database.action"</code> 
     * and <code>"javax.persistence.schema-generation.scripts.action"</code> properties.</p>
     * <p>Specifies that database tables should be dropped, then created.</p>
     */
    public static final String SCHEMA_GENERATION_DROP_AND_CREATE_ACTION = "drop-and-create";
    
    /**
     * The parameter value <code>"drop"</code>
     * <p>For use with the <code>"javax.persistence.schema-generation.database.action"</code> 
     * and <code>"javax.persistence.schema-generation.scripts.action"</code> properties.</p>
     * <p>Specifies that database tables should be dropped.</p>
     */
    public static final String SCHEMA_GENERATION_DROP_ACTION = "drop";
    
    /**
     * The parameter value <code>"none"</code> 
     * <p>For use with the <code>"javax.persistence.schema-generation.database.action"</code> 
     * and <code>"javax.persistence.schema-generation.scripts.action"</code> properties.</p>
     * <p>Specifies that database tables should not be created or dropped.</p>
     */
    public static final String SCHEMA_GENERATION_NONE_ACTION = "none";

    /**
     * The parameter value <code>"metadata"</code> 
     * <p>For use with the <code>"javax.persistence.schema-generation.create-source"</code> 
     * and <code>"javax.persistence.schema-generation.drop-source"</code> properties.</p>
     * <p>Specifies that DDL generation source will come from the metadata only.</p>
     */
    public static final String SCHEMA_GENERATION_METADATA_SOURCE = "metadata";
    
    /**
     * The parameter value <code>"script"</code> 
     * <p>For use with the <code>"javax.persistence.schema-generation.create-source"</code> 
     * and <code>"javax.persistence.schema-generation.drop-source"</code> properties.</p>
     * <p>Specifies that DDL generation source will come from scripts only.</p>
     */
    public static final String SCHEMA_GENERATION_SCRIPT_SOURCE = "script";
    
    /**
     * The parameter value <code>"metadata-then-script"</code> 
     * <p>For use with the <code>"javax.persistence.schema-generation.create-source"</code> 
     * and <code>"javax.persistence.schema-generation.drop-source"</code> properties.</p>
     * <p>Specifies that DDL generation source will come from the metadata first
     * followed with the scripts.</p>
     */
    public static final String SCHEMA_GENERATION_METADATA_THEN_SCRIPT_SOURCE = "metadata-then-script";
    
    /**
     * The parameter value <code>"script-then-metadata"</code> 
     * <p>For use with the <code>"javax.persistence.schema-generation.create-source"</code> 
     * and <code>"javax.persistence.schema-generation.drop-source"</code> properties.</p>
     * <p>Specifies that DDL generation source will come from the scripts first
     * followed with the metadata.</p>
     */
    public static final String SCHEMA_GENERATION_SCRIPT_THEN_METADATA_SOURCE = "script-then-metadata";
    
    /**
     * The <code>"eclipselink.sequencing.default-sequence-to-table"</code> property
     * determines the default behavior when a GeneratedValue of type SEQUENCE is used
     * on a database platform that does not support SEQUENCE generation.
     * By default IDENTITY generation is used if supported.
     * If this property is set to true, then TABLE sequencing will be used instead.
     */
    public static final String SEQUENCING_SEQUENCE_DEFAULT = "eclipselink.sequencing.default-sequence-to-table";
    
    /**
     * The <code>"eclipselink.session.customizer"</code> property configures a
     * {@link SessionCustomizer} used to alter the runtime configuration through
     * API.
     * <p>
     * The value is a full name for a class which implements SessionCustomizer.
     * Session customizer called after all other properties have been processed.
     * 
     * @see SessionCustomizer
     */
    public static final String SESSION_CUSTOMIZER = "eclipselink.session.customizer";

    // Under review public static final String RELATIONSHIPS_FETCH_DEFAULT =
    // "eclipselink.relationships-fetch-default";

    /**
     * The <code>"eclipselink.descriptor.customizer."</code> is a prefix for a
     * property used to configure a {@link DescriptorCustomizer}. Customization
     * Prefix Property names formed out of this prefix by appending either
     * entity name, or class name (indicating that the property values applies
     * only to a particular entity) Allows descriptor customization.
     * <p>
     * The value is a full name for a class which implements
     * DescriptorCustomizer. Only session customizer is called after processing
     * these properties.
     * 
     * @see DescriptorCustomizer
     */
    public static final String DESCRIPTOR_CUSTOMIZER_ = "eclipselink.descriptor.customizer.";

    /**
     * The <code>"eclipselink.jdbc.uppercase-columns"</code> property configures
     * native SQL queries are used, the JDBC meta-data may return column names
     * in lower case on some platforms. If the column names are upper-case in
     * the mappings (default) then they will not match. This setting allows for
     * forcing the column names from the meta-data to upper-case.
     * <p>
     * This setting has been replaced by UPPERCASE_COLUMN_NAMES, which should be used instead,
     * as it ensure both sides use upper case for comparisons.
     * @see #UPPERCASE_COLUMN_NAMES
     */
    public static final String NATIVE_QUERY_UPPERCASE_COLUMNS = "eclipselink.jdbc.uppercase-columns";

    /**
     * The <code>"eclipselink.jpa.uppercase-column-names"</code> property configures JPA processing
     * to uppercase all column name definitions.  A value of true also sets the 
     * <code>"eclipselink.jdbc.uppercase-columns"</code> property to true, so that JDBC meta-data
     * returned from the database is also returned in uppercase, ensuring fields are the same case.  This
     * gets around situations where user defined fields do not match the case returned by the database for
     * native queries, simulating case insensitivity.  
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false" 
     * </ul>
     */
    public static final String UPPERCASE_COLUMN_NAMES = "eclipselink.jpa.uppercase-column-names";

    /**
     * The <code>"eclipselink.jdbc.batch-writing"</code> property configures the
     * use of batch writing to optimize transactions with multiple writes.
     * <p>Batch writing allows multiple heterogeneous dynamic SQL statements to be sent to the database as a single
     * execution, or multiple homogeneous parameterized SQL statements to be executed as a single batch execution.
     * <p>Note that not all JDBC drivers, or databases support batch writing.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"JDBC": use JDBC batch writing.
     * <li>"Buffered": do not use either JDBC batch writing nor native platform
     * batch writing.
     * <li>"Oracle-JDBC": use Oracle's native batch writing. This requires the
     * use of an Oracle JDBC driver.
     * <li>&ltcustom-class&gt - A custom class that extends the BatchWritingMechansim class.
     * <li>"None" (DEFAULT): do not use batch writing (turn it off).
     * </ul>
     * 
     * @see BatchWriting
     * @see BatchWritingMechanism
     */
    public static final String BATCH_WRITING = "eclipselink.jdbc.batch-writing";

    /**
     * The <code>"eclipselink.jdbc.batch-writing.size"</code> property
     * configures the batch size used for batch writing. For parameterized batch
     * writing this is the number of statements to batch, default 100. For
     * dynamic batch writing, this is the size of the batched SQL buffer,
     * default 32k.
     * 
     * @see #BATCH_WRITING
     */
    public static final String BATCH_WRITING_SIZE = "eclipselink.jdbc.batch-writing.size";
    
    /**
     * The <code>"javax.persistence.bean.manager"</code> property is used to set
     * CDI BeanManager when available
     */
    public static final String CDI_BEANMANAGER = "javax.persistence.bean.manager";

    /**
     * The <code>"eclipselink.persistencexml"</code> property specifies the full
     * resource name to look for the persistence XML files in. If not specified
     * the default value defined by {@link #ECLIPSELINK_PERSISTENCE_XML_DEFAULT}
     * will be used.
     * <p>
     * IMPORTANT: For now this property is used for the canonical model
     * generator but it can later be used as a system property for customizing
     * weaving and application bootstrap usage.
     * <p>
     * This property is only used by EclipseLink when it is locating the
     * configuration file. When used within an EJB/Spring container in container
     * managed mode the locating and reading of this file is done by the
     * container and will not use this configuration.
     */
    public static final String ECLIPSELINK_PERSISTENCE_XML = "eclipselink.persistencexml";

    /**
     * The default resource location used to locate the persistence.xml
     * configuration files. Default: "META-INF/persistence.xml"
     */
    public static final String ECLIPSELINK_PERSISTENCE_XML_DEFAULT = "META-INF/persistence.xml";

    /**
     * This <code>"eclipselink.persistenceunits"</code> property specifies the
     * set of persistence unit names that will be processed when generating the
     * canonical model. By default all persistence units available in all
     * persistence XML files will be used. The value of this property is a comma
     * separated list. When specifying multiple persistence units it is not
     * possible to have persistence units with a comma in their name.
     * <p>
     * Note: In the future this property can also be used to limit the
     * persistence units that will be processed by the static or dynamic
     * weaving.
     */
    public static final String ECLIPSELINK_PERSISTENCE_UNITS = "eclipselink.persistenceunits";

    /**
     * The <code>"eclipselink.exception-handler"</code> property allows an
     * {@link ExceptionHandler} to be specified. An ExceptionHandler handles
     * exceptions when they are thrown so that an application might address
     * address expected failures and continue.
     * 
     * @see ExceptionHandler
     */
    public static final String EXCEPTION_HANDLER_CLASS = "eclipselink.exception-handler";

    /**
     * The <code>"eclipselink.session.include.descriptor.queries"</code>
     * property configures whether to enable the copying of all descriptor named
     * queries to the session to be usable from the entity manager.
     * <p>
     * Default: "false".
     */
    public static final String INCLUDE_DESCRIPTOR_QUERIES = "eclipselink.session.include.descriptor.queries";

    /**
     * The <code>"eclipselink.session-event-listener"</code> property configures
     * a session event listener class.
     * 
     * @see SessionEventListener
     * @see #SESSION_CUSTOMIZER as a means to configure multiple listeners using
     *      API
     */
    public static final String SESSION_EVENT_LISTENER_CLASS = "eclipselink.session-event-listener";

    /**
     * The <code>"eclipselink.sessions-xml"</code> property configures the use
     * of the specified native sessions.xml configuration file. When specified
     * this file will load all of the session configuration and mapping
     * information from the native XML. No JPA annotations or XML will be used.
     */
    public static final String SESSIONS_XML = "eclipselink.sessions-xml";

    /**
     * The <code>"eclipselink.project-cache"</code>property configures the type of
     * ProjectCacheAccessor implementation to use to retrieve and store projects
     * representing the metadata for the project
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"java-serialization": Use {@link FileBasedProjectCache}
     * <li>Custom ProjectCacheAccessor - Specify a custom class name which
     * implements {@link ProjectCacheAccessor}
     * </ul>
     * 
     * @see ProjectCacheAccessor
     */
    public static final String PROJECT_CACHE = "eclipselink.project-cache"; 
    
    /**
     * The property <code>"eclipselink.project-cache.java-serialization.file"</code>
     * 
     * <p>Specifies the name of the file to read/write a serialized project representing the application's
     * metadata</p>* 
     * 
     * 
     * <p>Specifies the name of the metadata repository xml file to read from using classloader to find the resource</p>
     * 
     * <p>This property should be used in conjunction with 
     * <code>"eclipselink.project-cache"</code> when a project is serialized to a file for caching.</p>
     * 
     * @see #PROJECT_CACHE
     */
    public static final String PROJECT_CACHE_FILE = "eclipselink.project-cache.java-serialization.file-location";

    /**
     * The <code>"eclipselink.temporal.mutable"</code> property configures the
     * default for detecting changes to temporal field (Date, Calendar). Default
     * "false" (changes to date object itself are not detected). By default it
     * is assumed that temporal fields are replaced, and the temporal object not
     * changed directly. Enabling mutable temporal fields will cause weaving of
     * attribute change tracking to be disabled.
     */
    public static final String TEMPORAL_MUTABLE = "eclipselink.temporal.mutable";

    /**
     * The <code>"eclipselink.jdbc.allow-native-sql-queries"</code> property 
     * specifies whether any user defined SQL is allowed within a persistence 
     * unit. This is of particular importance within a multitenant to minimize 
     * the potential impact of revealing multi tenant information. By default
     * any persistence unit containing at least one multitenant entity will
     * cause this flag to be set to 'false'. 
     * <p>
     * Allowed Values (String):
     * <ul>
     * <li>"true" - (DEFAULT) allow native SQL
     * <li>"false" - do not allow native SQL.
     * </ul>
     *
     * @see Project#setAllowNativeSQLQueries(boolean)
     */
    public static final String ALLOW_NATIVE_SQL_QUERIES = "eclipselink.jdbc.allow-native-sql-queries";
    
    /**
     * The <code>"eclipselink.allow-zero-id"</code> property configures if zero
     * is considered a valid id on a new entity. If the id is not considered
     * valid and sequencing is enabled for the entity a new value will be
     * assigned when it is persisted to the database (INSERT)By default an id
     * value of 0 is assumed to be null/unassigned. This allows 0 to be a valid
     * id value. This can also be set per class using the @PrimaryKey annotation
     * and IdValidation.
     * <p>
     * Caution: This property configures the static singleton on
     * {@link Helper#isZeroValidPrimaryKey} which will be shared by all
     * concurrent uses of EclipseLink.
     * 
     * @see org.eclipse.persistence.annotations.PrimaryKey
     * @see org.eclipse.persistence.annotations.IdValidation
     * 
     * @deprecated replaced by ID_VALIDATION property with value "NULL".
     * @see #ID_VALIDATION
     */
    public static final String ALLOW_ZERO_ID = "eclipselink.allow-zero-id";

    /**
     * The <code>"eclipselink.id-validation"</code> property defines
     * which primary key components values are considered invalid.
     * These values will be also overridden by sequencing.
     * Note that Identity always overrides any existing id value
     * and so does any sequence with shouldAlwaysOverrideExistingValue flag set to true.
     * 
     * @see org.eclipse.persistence.annotations.PrimaryKey
     * @see org.eclipse.persistence.annotations.IdValidation
     */
    public static final String ID_VALIDATION = "eclipselink.id-validation";

    /**
     * Defines EntityManager cache behavior after a call to flush method
     * followed by a call to clear method. This property could be specified
     * while creating either EntityManagerFactory (either in the map passed to
     * createEntityManagerFactory method or in persistence.xml) or EntityManager
     * (in the map passed to createEntityManager method); the latter overrides
     * the former.
     * 
     * @see FlushClearCache
     */
    public static final String FLUSH_CLEAR_CACHE = "eclipselink.flush-clear.cache";

    /**
     * Specify the classloader to use to create an EntityManagerFactory in the
     * property map passed to Persistence.createEntityManagerFactory.
     */
    public static final String CLASSLOADER = "eclipselink.classloader";

    /**
     * Configures if the first exception that occurs during deployment should be
     * thrown, or if all exceptions should be caught and summary thrown at end
     * of deployment attempt. "true" by default.
     */
    public static final String THROW_EXCEPTIONS = "eclipselink.orm.throw.exceptions";

    /**
     * This property set on the session is used to override orm.xml schema
     * validation from its default of false.
     */
    public static final String ORM_SCHEMA_VALIDATION = "eclipselink.orm.validate.schema";

    /**
     * The <code>"eclipselink.deploy-on-startup"</code> property controls whether
     * EclipseLink creates the persistence unit when the application starts up, or
     * when the persistence unit is first actually accessed by the application.
     *
     * Setting this to true causes the persistence unit to be created when the
     * EntityManagerFactory is created, usually during deployment to a Java EE
     * 7 container or servlet container.  Enabling this option may increase
     * startup time of the container/server, but will prevent the first request
     * to the application from pausing while the persistence unit is deployed.
     *
     * When this property is set to false the persistence unit is not
     * initialized until the first EntityManager is created or until metadata
     * is requested from the EntityManagerFactory. 
     * 
     * When set to False, there is a known issue with Fields of static metamodel 
     * classes ("Entity_" classes) being null until the persistence unit is
     * initialized. This behaviour won't affect applications unless they use 
     * the static metamodel feature.  (See bug 383199)
     * <p>
     * Values: A boolean value of "True" or (default "False").
     */
    public static final String DEPLOY_ON_STARTUP = "eclipselink.deploy-on-startup";
    
    /**
     * The <code>"eclipselink.validation-only"</code> property validates deployment
     * which includes initializing descriptors but does not connect (no login to the database).
     * <p>
     * Values: A boolean value of "True" or (default "False").
     * </p>
     * Note: <code>"eclipselink.target-database"</code> must be specified with a
     * non-"Auto" class name or short name when <code>"eclipselink.validation-only"</code>
     * is set to <code>"True"</code>.
     * 
     * @see TargetDatabase
     */    
    // See 324213
    public static final String VALIDATION_ONLY_PROPERTY = "eclipselink.validation-only";

    /**
     * Allows the database schema to be generated on deployment. Valid values,
     * CREATE_ONLY, DROP_AND_CREATE, CREATE_OR_EXTEND, NONE ("create-tables",
     * "drop-and-create-tables", "create-or-extend-tables", "none"). Default is NONE.
     */
    public static final String DDL_GENERATION = "eclipselink.ddl-generation";

    /**
     * The parameter value <code>"create-tables"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation"</code> property.</p>
     * <p>Specifies that database tables should be created.</p>
     *
     * @see #DDL_GENERATION
     */
    public static final String CREATE_ONLY = "create-tables";
    
    /**
     * The parameter value <code>"drop-tables"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation"</code> property.</p>
     * <p>Specifies that database tables should be dropped only.</p>
     * 
     * @see #DDL_GENERATION
     */
    public static final String DROP_ONLY = "drop-tables";
    
    /**
     * The parameter value <code>"drop-and-create-tables"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation"</code> property.</p>
     * <p>Specifies that database tables should be dropped, then created.</p>
     * 
     * @see #DDL_GENERATION
     */
    public static final String DROP_AND_CREATE = "drop-and-create-tables";
    
    /**
     * The parameter value <code>"create-or-extend-tables"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation"</code> property.</p>
     * <p>Specifies that database tables should be created and if existing, missing columns will be added.</p>
     * <p>This can only be used with eclipselink.ddl-generation.output-mode with value of "database".</p>
     * 
     * @see #DDL_GENERATION
     */
    public static final String CREATE_OR_EXTEND = "create-or-extend-tables";
    
    /**
     * The parameter value <code>"none"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation"</code> property,
     * and is the default parameter value.</p>
     * <p>Specifies that database tables should not be created or dropped.</p>
     * 
     * @see #DDL_GENERATION
     */
    public static final String NONE = "none";
    
    /**
     * The <code>"eclipselink.metadata-source"</code>property configures the type of
     * MetadataSource implementation to use to read Metadata
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"XML": Use {@link XMLMetadataSource}
     * <li>Custom MetadataSource - Specify a custom class name which
     * implements {@link MetadataSource}
     * </ul>
     * 
     * @see MetadataSource
     */
    public static final String METADATA_SOURCE = "eclipselink.metadata-source";
    
    /**
     * the <code>"eclipselink.metadata-source.send-refresh-command"</code> property
     * works with cache coordination for a clustered environment to. If cache coordination
     * is configured and the session is deployed on startup, this property controls the sending
     * of RCM refresh metadata commands to the cluster.  These commands will cause the remote
     * instances to refresh their metadata.
     * 
     * Defaults to true
     * 
     * @see #COORDINATION_PROTOCOL
     * @see #DEPLOY_ON_STARTUP 
     */
    public static final String METADATA_SOURCE_RCM_COMMAND = "eclipselink.metadata-source.send-refresh-command";
    
    /**
     * The property <code>"eclipselink.metadata-source.xml.file"</code>
     * 
     * <p>Specifies the name of the metadata repository xml file to read from using classloader to find the resource</p>
     * 
     * <p>This property should be used in conjunction with the 
     * <code>"eclipselink.metadata-repository"</code> when an XML repository is being used.</p>
     * 
     * @see #METADATA_SOURCE
     */
    public static final String METADATA_SOURCE_XML_FILE = "eclipselink.metadata-source.xml.file";
    
    /**
     * The property <code>"eclipselink.metadata-source.xml.URL"</code>
     * 
     * <p>Specifies the name of the metadata repository xml URL to read from.</p>
     * 
     * <p>This property should be used in conjunction with the 
     * <code>"eclipselink.metadata-repository"</code> when an XML repository is being used.</p>
     * 
     * @see #METADATA_SOURCE
     */
    public static final String METADATA_SOURCE_XML_URL = "eclipselink.metadata-source.xml.url";

    /**
     * The property <code>"eclipselink.metadata-source.properties.file"</code>
     * 
     * <p>Specifies the name of the metadata repository properties file to read from using classloader to find the resource</p>
     * 
     * @see #METADATA_SOURCE
     */
    public static final String METADATA_SOURCE_PROPERTIES_FILE = "eclipselink.metadata-source.properties.file";
    
    /**
     * The property <code>"eclipselink.application-location"</code>
     * 
     * <p>Specifies the file system directory location where 
     * DDL files are written (output) to.</p>
     * 
     * <p>This property should be used in conjunction with the 
     * <code>"eclipselink.ddl-generation.output-mode"</code> property, with 
     * a setting of <code>"sql-script"</code> (or <code>"both"</code>) for 
     * DDL file(s) to be written.</p>
     * 
     * @see #DEFAULT_APP_LOCATION
     * @see #DDL_GENERATION_MODE
     * @see #DDL_SQL_SCRIPT_GENERATION
     * @see #DDL_BOTH_GENERATION
     */
    public static final String APP_LOCATION = "eclipselink.application-location";
    
    /**
     * The property <code>"eclipselink.create-ddl-jdbc-file-name"</code>
     * 
     * <p>Specifies the name of the DDL file which is used to create 
     * database tables.</p>
     * 
     * <p>This property should be used in conjunction with the 
     * <code>"eclipselink.application-location"</code> property to specify a 
     * location on the file system for DDL file(s) to be written.</p>
     * 
     * @see #APP_LOCATION
     * @see #DEFAULT_CREATE_JDBC_FILE_NAME
     */
    public static final String CREATE_JDBC_DDL_FILE = "eclipselink.create-ddl-jdbc-file-name";
    
    /**
     * The property <code>"eclipselink.drop-ddl-jdbc-file-name"</code>
     * 
     * <p>Specifies the name of the DDL file which is used to drop 
     * database tables.</p>
     * 
     * <p>This property should be used in conjunction with the 
     * <code>"eclipselink.application-location"</code> property to specify a 
     * location on the file system for DDL file(s) to be written.</p>
     * 
     * @see #APP_LOCATION
     * @see #DEFAULT_DROP_JDBC_FILE_NAME
     */
    public static final String DROP_JDBC_DDL_FILE = "eclipselink.drop-ddl-jdbc-file-name";

    /**
     * The default location in the file system to output DDL files.
     * Defaults to: the working directory.
     * 
     * @see #APP_LOCATION
     */
    public static final String DEFAULT_APP_LOCATION = "." + File.separator;
    
    /**
     * The default name of the DDL file which is used to create database tables.
     * Defaults to: <code>createDDL.jdbc</code>
     * 
     * @see #CREATE_JDBC_DDL_FILE
     */
    public static final String DEFAULT_CREATE_JDBC_FILE_NAME = "createDDL.jdbc";
    
    /**
     * The default name of the DDL file which is used to drop database tables.
     * Defaults to: <code>dropDDL.jdbc</code>
     * 
     * @see #DROP_JDBC_DDL_FILE
     */
    public static final String DEFAULT_DROP_JDBC_FILE_NAME = "dropDDL.jdbc";
    
    /**
     * The system property <code>INTERACT_WITH_DB</code>
     * 
     * <p>Specified to enable or disable the execution of DDL (configured with 
     * the <code>eclipselink.ddl-generation<code> property) against a database.</p>
     * 
     * <p>e.g. a command line setting of <code>-DINTERACT_WITH_DB=false</code> 
     * will not output DDL to the database.</p>
     * 
     * <p>Valid values:</p>
     * <code>true</code> - output DDL to the database<br> 
     * <code>false</code> - do not output DDL to the database
     * 
     * @see #DDL_GENERATION
     */
    public static final String JAVASE_DB_INTERACTION = "INTERACT_WITH_DB";

    /**
     * Configures if database schema should be generated on the database, to a
     * file, or both. Valid values, DDL_SQL_SCRIPT_GENERATION,
     * DDL_DATABASE_GENERATION, DDL_BOTH_GENERATION ("sql-script", "database",
     * "both") DDL_GENERATION must also be set, for this to have an effect.
     * Default is DDL_DATABASE_GENERATION.
     * 
     * @see #DEFAULT_DDL_GENERATION_MODE
     * @see #DDL_DATABASE_GENERATION
     * @see #DDL_SQL_SCRIPT_GENERATION
     * @see #DDL_BOTH_GENERATION
     */
    public static final String DDL_GENERATION_MODE = "eclipselink.ddl-generation.output-mode";

    /**
     * The <code>"eclipselink.ddl-generation.index-foreign-keys"</code> property.
     * Configures if an index should be automatically generated for foreign key constraints.
     * It is normally recommended to have an index for a foreign key.
     * By default indexes are not generated, most database also do not auto generate indexes, although some do.
     * Values: "true" or "false" (default).
     * 
     * @see #DDL_GENERATION
     */
    public static final String DDL_GENERATION_INDEX_FOREIGN_KEYS = "eclipselink.ddl-generation.index-foreign-keys";
    
    /**
     * The parameter value <code>"sql-script"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation.output-mode"</code> property.</p>
     * 
     * <p>Specifies that DDL will be written to file(s).</p>
     * 
     * @see #DDL_GENERATION_MODE
     * @see #CREATE_JDBC_DDL_FILE
     * @see #DROP_JDBC_DDL_FILE
     */
    public static final String DDL_SQL_SCRIPT_GENERATION = "sql-script";
    
    /**
     * The parameter value <code>"database"</code>
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation.output-mode"</code> property, 
     * and is the default parameter value</p>
     * 
     * <p>Specifies that DDL will be written to the database.</p>
     * 
     * @see #DDL_GENERATION_MODE
     * @see #CREATE_JDBC_DDL_FILE
     * @see #DROP_JDBC_DDL_FILE
     */
    public static final String DDL_DATABASE_GENERATION = "database";
    
    /**
     * The parameter value <code>"both"</code> 
     * 
     * <p>For use with the <code>"eclipselink.ddl-generation.output-mode"</code> property.</p>
     * 
     * <p>Specifies that DDL will be written to file(s) and the database.</p>
     * 
     * @see #DDL_GENERATION_MODE
     * @see #CREATE_JDBC_DDL_FILE
     * @see #DROP_JDBC_DDL_FILE
     */
    public static final String DDL_BOTH_GENERATION = "both";
    
    /**
     * The <code>eclipselink.ddl-generation.output-mode</code> parameter is configured
     * to the default value of <code>database</code>.
     * 
     * @see #DDL_GENERATION_MODE
     * @see #DDL_DATABASE_GENERATION
     */
    public static final String DEFAULT_DDL_GENERATION_MODE = DDL_DATABASE_GENERATION;

    /**
     * The <code>"eclipselink.validate-existence"</code> property configures if
     * the existence of an object should be verified on persist(), otherwise it
     * will assume to be new if not in the persistence context. If checked and
     * existing and not in the persistence context and error will be thrown.
     * "false" by default.
     */
    public static final String VALIDATE_EXISTENCE = "eclipselink.validate-existence";

    /**
     * Configures if updates should be ordered by primary key.
     * This can be used to avoid possible database deadlocks from concurrent 
     * threads updating the same objects in a different order.
     * If not set to true, the order of updates is not guaranteed.
     * "true" by default.
     */    
    public static final String ORDER_UPDATES = "eclipselink.order-updates";
    
    /**
     * The <code>"eclipselink.profiler"</code>property configures the type of
     * profiler used to capture runtime statistics.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"NoProfiler" (DEFAULT)
     * <li>"PerformanceMonitor": Use {@link PerformanceMonitor}
     * <li>"PerformanceProfiler": Use {@link PerformanceProfiler}
     * <li>"QueryMonitor": Use {@link QueryMonitor}
     * <li>"DMSProfiler": Use {@link DMSPerformanceProfiler}
     * <li>Custom profiler - Specify a custom profiler class name which
     * implements {@link SessionProfiler}
     * </ul>
     * 
     * @see ProfilerType
     */
    public static final String PROFILER = "eclipselink.profiler";
    
    /**
     * The <code>"eclipselink.tuning"</code>property configures the type of
     * tuner to use to configure the persistence unit.
     * A SessionTuner can be used to define a template for a persistence unit configuration.
     * It allows a set of configuration values to be configured as a single tuning option.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"Standard" (DEFAULT)
     * <li>"Safe": See {@link SafeModeTuner}
     * <li>Custom tuner - Specify a full class name of an implementation of {@link SessionTuner}
     * </ul>
     * 
     * @see TunerType
     */
    public static final String TUNING = "eclipselink.tuning";

    /**
     * The <code>"eclipselink.memory.free-metadata"</code>property configures the JPA
     * internal deployment metadata to be released after deployment.
     * This conserves memory, as the metadata is no longer required, but make
     * future deployments of any other application take longer, as the metadata must be re-allocated.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true"
     * <li>"false" (DEFAULT)
     * </ul>
     */
    public static final String FREE_METADATA = "eclipselink.memory.free-metadata";
    
    /**
     * The <code>"eclipselink.transaction.join-existing"</code> property Set to
     * "true" this property forces persistence context to read through
     * JTA-managed ("write") connection in case there is an active
     * transaction.The property set in persistence.xml or passed to
     * createEntityManagerFactory affects all EntityManagers created by the
     * factory. Note that if the property set to "true" then objects read during
     * transaction won't be placed into the shared cache unless they have been
     * updated. Alternatively, to apply the property only to some
     * EntityManagers pass it to createEntityManager method.
     * <p>
     * Values (caseinsensitive):
     * <ul>
     * <li>"false" (DEFAULT):
     * <li>"true":
     * </ul>
     */
    public static final String JOIN_EXISTING_TRANSACTION = "eclipselink.transaction.join-existing";

    /**
     * The <code>"eclipselink.persistence-context.reference-mode"</code>
     * property configures whether there should be hard or soft references used
     * within the Persistence Context. Default is "HARD". With soft references
     * entities no longer referenced by the application may be garbage collected
     * freeing resources. Any changes that have not been flushed in these
     * entities will be lost. The property set in persistence.xml or passed to
     * createEntityManagerFactory affects all EntityManagers created by the
     * factory. Alternatively, to apply the property only to some
     * SessionManagers pass it to createEntityManager method.
     * <p>
     * Values:<ul>
     * <li>"HARD" (DEFAULT) - {@link ReferenceMode#HARD
     * <li>"WEAK"  - {@link ReferenceMode#WEAK
     * <li>"FORCE_WEAK" - {@link ReferenceMode#FORCE_WEAK
     * </ul>
     * 
     * @see ReferenceMode
     */
    public static final String PERSISTENCE_CONTEXT_REFERENCE_MODE = "eclipselink.persistence-context.reference-mode";

    /**
     * The <code>"javax.persistence.lock.timeout"</code> property configures the
     * WAIT timeout used in pessimistic locking, if the database query exceeds
     * the timeout the database will terminate the query and return an
     * exception.
     * <p>
     * Valid values are Strings containing integers zero or greater.
     */
    public static final String PESSIMISTIC_LOCK_TIMEOUT = QueryHints.PESSIMISTIC_LOCK_TIMEOUT;

    /**
     * The <code>"javax.persistence.query.timeout"</code> property configures
     * the default query timeout value.
     * <p>
     * Valid values are strings containing integers zero or greater.
     */
    public static final String QUERY_TIMEOUT = "javax.persistence.query.timeout";

    /**
     * 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
     * for a container managed EntityManager, and common for application
     * managed. This can be used to avoid additional performance overhead of
     * resuming the persistence context after a commit(). The property set in
     * persistence.xml or passed to createEntityManagerFactory affects all
     * EntityManagers created by the factory. Alternatively, to apply the
     * property only to some EntityManagers pass it to createEntityManager
     * method.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"false" (DEFAULT)
     * <li>"true"
     * </ul>
     */
    public static final String PERSISTENCE_CONTEXT_CLOSE_ON_COMMIT = "eclipselink.persistence-context.close-on-commit";

    /**
     * The <code>"eclipselink.persistence-context.persist-on-commit"</code>
     * property specifies that the EntityManager will search all managed objects
     * and persist any related non-managed new objects that are cascade persist.
     * This can be used to avoid the cost of performing this search if persist
     * is always used for new objects. The property set in persistence.xml or
     * passed to createEntityManagerFactory affects all EntityManagers created
     * by the factory. Alternatively, to apply the property only to some
     * EntityManagers pass it to createEntityManager method.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     */
    public static final String PERSISTENCE_CONTEXT_PERSIST_ON_COMMIT = "eclipselink.persistence-context.persist-on-commit";

    /**
     * The
     * <code>"eclipselink.persistence-context.commit-without-persist-rules"</code>
     * property specifies that the EntityManager will search all managed objects
     * and persist any related non-managed new objects that are found ignoring
     * any absence of CascadeType.PERSIST settings. Also the Entity life-cycle
     * Persist operation will not be cascaded to related entities. This setting
     * replicates the traditional EclipseLink native functionality.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"false" (DEFAULT)
     * <li>"true"
     * </ul>
     */
    public static final String PERSISTENCE_CONTEXT_COMMIT_WITHOUT_PERSIST_RULES = "eclipselink.persistence-context.commit-without-persist-rules";

    /**
     * The <code>"eclipselink.persistence-context.flush-mode</code> property configures the EntityManager FlushMode to be set as a
     * persistence property. This can be set to either "AUTO" or "COMMIT". By
     * default the flush mode is AUTO, which requires an automatic flush before
     * all query execution. This can be used to avoid any flushing until commit.
     * The property set in persistence.xml or passed to
     * createEntityManagerFactory affects all EntityManagers created by the
     * factory. Alternatively, to apply the property only to some EntityManagers
     * pass it to createEntityManager method.
     * 
     * @see EntityManager#setFlushMode(javax.persistence.FlushModeType)
     * @see FlushModeType
     */
    public static final String PERSISTENCE_CONTEXT_FLUSH_MODE = "eclipselink.persistence-context.flush-mode";

    /**
     * The <code>"eclipselink.oracle.proxy-type"</code> property is used to
     * specify proxy type that should be passed to
     * OracleConnection.openProxySession method. Requires Oracle JDBC version
     * 10.1.0.2 or later. Requires Oracle9Platform or later as a database
     * platform (TARGET_DATABASE property value should be TargetDatabase.Oracle9
     * or later).
     * <p>
     * Values:
     * <ul>
     * <li>oracle.jdbc.OracleConnection.PROXYTYPE_USER_NAME,
     * <li>oracle.jdbc.OracleConnection.PROXYTYPE_DISTINGUISHED_NAME,
     * <li>oracle.jdbc.OracleConnection.PROXYTYPE_CERTIFICATE.
     * </ul>
     * <p>
     * Property values corresponding to the specified type should be also
     * provided:
     * <ul>
     * <li>oracle.jdbc.OracleConnection.PROXY_USER_NAME,
     * <li>oracle.jdbc.OracleConnection.PROXY_DISTINGUISHED_NAME,
     * <li>oracle.jdbc.OracleConnection.PROXY_CERTIFICATE.
     * <p>
     * Typically these properties should be set into EntityManager (either
     * through createEntityManager method or using proprietary setProperties
     * method on EntityManagerImpl) - that causes EntityManager to use proxy
     * connection for writing and reading inside transaction. If proxy-type and
     * the corresponding proxy property set into EntityManagerFactory then all
     * connections created by the factory will be proxy connections.
     */
    public static final String ORACLE_PROXY_TYPE = "eclipselink.oracle.proxy-type";

    /**
     * The <code>"eclipselink.cache.coordination.protocol"</code> property
     * configures cache coordination for a clustered environment. This needs to
     * be set on every persistence unit/session in the cluster. Depending on the
     * cache configuration for each descriptor, this will broadcast cache
     * updates or inserts to the cluster to update or invalidate each session's
     * cache.
     * <p>
     * Values:
     * <ul>
     * <li>"jms"
     * <li>"jms-publishing"
     * <li>"rmi"
     * <li>"rmi-iiop"
     * <li>a <package.class> name of a subclass implementation of the TransportManager abstract class.
     * </ul>
     * by default the cache is not coordinated.
     * 
     * @see CacheCoordinationProtocol
     * @see Cache#coordinationType()
     * @see RemoteCommandManager#setTransportManager(TransportManager)
     */
    public static final String COORDINATION_PROTOCOL = "eclipselink.cache.coordination.protocol";

    /**
     * The <code>"eclipselink.cache.coordination.jms.host"</code> property
     * configures cache coordination for a clustered environment. Only used for
     * JMS coordination. Sets the URL for the JMS server hosting the topic.
     * This is not required in the topic is distributed across the cluster (can be looked up in local JNDI).
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.jms.JMSTopicTransportManager#setTopicHostUrl(String)
     */
    public static final String COORDINATION_JMS_HOST = "eclipselink.cache.coordination.jms.host";

    /**
     * The <code>"eclipselink.cache.coordination.jms.topic"</code> property
     * configures cache coordination for a clustered environment. Only used for
     * JMS coordination. Sets the JMS topic name.
     * The default topic JNDI name is "jms/EclipseLinkTopic".
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.broadcast.BroadcastTransportManager#setTopicName(String)
     */
    public static final String COORDINATION_JMS_TOPIC = "eclipselink.cache.coordination.jms.topic";

    /**
     * The <code>"eclipselink.cache.coordination.jms.factory"</code> property
     * configures cache coordination for a clustered environment. Only used for
     * JMS coordination. Sets the JMS topic connection factory name.
     * The default topic connection factory JNDI name is "jms/EclipseLinkTopicConnectionFactory".
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.broadcast.BroadcastTransportManager#setTopicConnectionFactoryName(String)
     */
    public static final String COORDINATION_JMS_FACTORY = "eclipselink.cache.coordination.jms.factory";
    
    /**
     * The <code>"eclipselink.cache.coordination.jms.reuse-topic-publisher"</code> property
     * configures cache coordination for a clustered environment. Only used for
     * JMS coordination. Sets the JSM transport manager to cache a TopicPubliser 
     * and reuse it for all cache coordination publishing. Default value if unset is false.
     *
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.jms.JMSPublishingTransportManager#setShouldReuseJMSTopicPublisher(boolean)
     */
    public static final String COORDINATION_JMS_REUSE_PUBLISHER = "eclipselink.cache.coordination.jms.reuse-topic-publisher";

    /**
     * The <code>"eclipselink.cache.coordination.rmi.announcement-delay"</code>
     * property configures cache coordination for a clustered environment. Only
     * used for RMI coordination. Sets the number of milliseconds to wait for
     * announcements from other cluster members on startup.
     * Default is 1000 milliseconds.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.DiscoveryManager#setAnnouncementDelay(int)
     */
    public static final String COORDINATION_RMI_ANNOUNCEMENT_DELAY = "eclipselink.cache.coordination.rmi.announcement-delay";

    /**
     * The <code>"eclipselink.cache.coordination.rmi.multicast-group"</code>
     * property configures cache coordination for a clustered environment. Only
     * used for RMI coordination. Sets the multicast socket group address. The
     * multicast group is used to find other members of the cluster.
     * The default address is 239.192.0.0.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.DiscoveryManager#setMulticastGroupAddress(String)
     */
    public static final String COORDINATION_RMI_MULTICAST_GROUP = "eclipselink.cache.coordination.rmi.multicast-group";

    /**
     * The
     * <code>"eclipselink.cache.coordination.rmi.multicast-group.port"</code>
     * property configures cache coordination for a clustered environment. Only
     * used for RMI coordination. Sets the multicast socket group port. The
     * multicast group port is used to find other members of the cluster.
     * The default port is 3121.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.DiscoveryManager#setMulticastPort(int)
     */
    public static final String COORDINATION_RMI_MULTICAST_GROUP_PORT = "eclipselink.cache.coordination.rmi.multicast-group.port";

    /**
     * The <code>"eclipselink.cache.coordination.rmi.packet-time-to-live"</code>
     * property configures cache coordination for a clustered environment. Only
     * used for RMI coordination. Sets the multicast socket packet time to live.
     * The multicast group is used to find other members of the cluster. Set the
     * number of hops the data packets of the session announcement will take
     * before expiring. The default is 2, a hub and an interface card to prevent
     * the data packets from leaving the local network.
     * 
     * Note that if sessions are hosted on different LANs that are part of WAN,
     * the announcement sending by one session may not reach other sessions. In
     * this case, consult your network administrator for the right time-to-live
     * value or test your network by increase the value until sessions receive
     * announcement sent by others.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.DiscoveryManager#setPacketTimeToLive(int)
     */
    public static final String COORDINATION_RMI_PACKET_TIME_TO_LIVE = "eclipselink.cache.coordination.rmi.packet-time-to-live";

    /**
     * The <code>"eclipselink.cache.coordination.rmi.url"</code> property
     * configures cache coordination for a clustered environment. Only used for
     * RMI coordination. Sets the URL of the host server. This is the URL that
     * other cluster member should use to connect to this host.
     * This may not be required in a clustered environment where JNDI is replicated.
     * This can also be set as a System property or using a SessionCustomizer to avoid
     * a separate persistence.xml per server.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.RemoteCommandManager#setUrl(String)
     */
    public static final String COORDINATION_RMI_URL = "eclipselink.cache.coordination.rmi.url";

    /**
     * The <code>"eclipselink.cache.coordination.naming-service"</code> property
     * configures cache coordination for a clustered environment. Set the naming
     * service to use, either "jndi" or "rmi".
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.TransportManager#setNamingServiceType(int)
     */
    public static final String COORDINATION_NAMING_SERVICE = "eclipselink.cache.coordination.naming-service";

    /**
     * the <code>"eclipselink.cache.coordination.jndi.user"</code> property
     * configures cache coordination for a clustered environment. Set the JNDI
     * naming service user name.
     * This is not normally require if connecting to the local server.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.TransportManager#setUserName(String)
     */
    public static final String COORDINATION_JNDI_USER = "eclipselink.cache.coordination.jndi.user";

    /**
     * The <code>"eclipselink.cache.coordination.jndi.password"</code> property
     * configures cache coordination for a clustered environment. Set the JNDI
     * naming service user name.
     * This is not normally require if connecting to the local server.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.TransportManager#setPassword(String)
     */
    public static final String COORDINATION_JNDI_PASSWORD = "eclipselink.cache.coordination.jndi.password";

    /**
     * The
     * <code>"eclipselink.cache.coordination.jndi.initial-context-factory"</code>
     * property configures cache coordination for a clustered environment. Set
     * the JNDI InitialContext factory.
     * This is not normally require if connecting to the local server.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.TransportManager#setInitialContextFactoryName(String)
     */
    public static final String COORDINATION_JNDI_CONTEXT = "eclipselink.cache.coordination.jndi.initial-context-factory";

    /**
     * The
     * <code>"eclipselink.cache.coordination.remove-connection-on-error"</code>
     * property configures cache coordination for a clustered environment. Set
     * if the connection should be removed if a communication error occurs when
     * coordinating with it. This is normally used for RMI coordination in case
     * a server goes down (it will reconnect when it comes back up).
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.TransportManager#setShouldRemoveConnectionOnError(boolean)
     */
    public static final String COORDINATION_REMOVE_CONNECTION = "eclipselink.cache.coordination.remove-connection-on-error";

    /**
     * the
     * <code>"eclipselink.cache.coordination.propagate-asynchronously"</code>
     * property configures cache coordination for a clustered environment. Set
     * if the coordination broadcast should occur asynchronously with the
     * committing thread. This means the coordination will be complete before
     * the thread returns from the commit of the transaction. Note that JMS is
     * always asynchronous. By default RMI is asynchronous.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.RemoteCommandManager#setShouldPropagateAsynchronously(boolean)
     */
    public static final String COORDINATION_ASYNCH = "eclipselink.cache.coordination.propagate-asynchronously";

    /**
     * the
     * <code>"eclipselink.cache.coordination.thread.pool.size"</code>
     * property configures thread pool size for cache coordination threads.
     * RMI cache coordination will spawn one thread per node to send change notifications.
     * RMI also spawns a thread to listen for new node notifications.
     * JMS cache coordination will spawn one thread to receive JMS change notification messages (unless MDB is used).
     * JMS also spawns a thread to process the change notificaiton (unless MDB is used).
     * The default size is 32 threads.
     * A size of 0 indicates no thread pool should be used, and threads will be spawned when required.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.platform.server.ServerPlatformBase#setThreadPoolSize(int)
     */
    public static final String COORDINATION_THREAD_POOL_SIZE = "eclipselink.cache.coordination.thread.pool.size";
    
    /**
     * the <code>"eclipselink.cache.coordination.serializer"</code> property
     * configures how cache coordination serializes message sent between nodes.
     * By default Java serialization is used.  Other serializer can be used for improved performance
     * or integration with other systems.
     * The full class name of the serializer class should be provided.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see Serializer
     * @see org.eclipse.persistence.sessions.coordination.RemoteCommandManager#setSerializer(Serializer)
     */
    public static final String COORDINATION_SERIALIZER = "eclipselink.cache.coordination.serializer";
    
    /**
     * the <code>"eclipselink.cache.coordination.channel"</code> property
     * configures cache coordination for a clustered environment. Set the
     * channel for this cluster. All server's in the same channel will be
     * coordinated.  The default channel name is "EclipseLinkCommandChannel".
     * If multiple EclipseLink deployment reside on the same network, they should use different channels.
     * 
     * @see #COORDINATION_PROTOCOL
     * @see org.eclipse.persistence.sessions.coordination.RemoteCommandManager#setChannel(String)
     */
    public static final String COORDINATION_CHANNEL = "eclipselink.cache.coordination.channel";

    /**
     * Indicates if it's a composite persistence unit ("true").
     * The property must be specified in persistence.xml of a composite persistence unit.
     * The property passed to createEntityManagerFactory method or in system properties is ignored.
     * Composite persistence unit would contain all persistence units found in jar files specified by <jar-file> elements in persistence.xml. 
     *    <jar-file>member1.jar</jar-file>
     *    <jar-file>member2.jar</jar-file>
     *    <properties>
     *        <property name="eclipselink.composite-unit" value="true"/>
     *    </properties>
     * @see #COMPOSITE_UNIT_MEMBER
     * @see #COMPOSITE_UNIT_PROPERTIES
     */
    public static final String COMPOSITE_UNIT = "eclipselink.composite-unit";
    
    /**
     * Indicates if the persistence unit must be a member of a composite persistence unit ("true"),
     * can't be used as an independent persistence unit.
     * That happens if persistence unit has dependencies on other persistence unit(s).
     * The property may be specified in persistence.xml.
     * The property passed to createEntityManagerFactory method or in system properties is ignored.
     * If this property is set to true, EntityManagerFactory still could be created,
     * but it can't be connected: an attempt to create entity manager would cause an exception.
     * @see #COMPOSITE_UNIT
     * @see #COMPOSITE_UNIT_PROPERTIES
     */
    public static final String COMPOSITE_UNIT_MEMBER = "eclipselink.composite-unit.member";
    
    /**
     * The property may be passed to createEntityManagerFactory method of a composite persistence unit
     * to pass properties to member persistence units.
     * The value is a map: 
     * the key is a member persistence unit's name,
     * the value is a map of properties to be passed to this persistence unit. 
     * "eclipselink.composite-unit.properties" -> (
     *   ("memberPu1" -> (   "javax.persistence.jdbc.user" -> "user1", 
     *                       "javax.persistence.jdbc.password" -> "password1",
     *                       "javax.persistence.jdbc.driver" -> "oracle.jdbc.OracleDriver",
     *                       "javax.persistence.jdbc.url" -> "jdbc:oracle:thin:@oracle_db_url:1521:db",
     *                    ) , 
     *   ("memberPu2" -> (   "javax.persistence.jdbc.user" -> "user2",
     *                       "javax.persistence.jdbc.password" -> "password2"
     *                       "javax.persistence.jdbc.driver" -> "com.mysql.jdbc.Driver",
     *                       "javax.persistence.jdbc.url" -> "jdbc:mysql://my_sql_db_url:3306/user2",
     *                    )
     * )
     * @see #COMPOSITE_UNIT
     */
    public static final String COMPOSITE_UNIT_PROPERTIES = "eclipselink.composite-unit.properties";

    /**
     * The <code>"eclipselink.remote.protocol"</code> property
     * configures remote JPA for a client or server.
     * This allows JPA to be access over RMI or other protocol from a remote Java client.
     * <p>
     * Values:
     * <ul>
     * <li>"rmi"
     * <li>a <package.class> name of a subclass implementation of the RemoteConnection abstract class.
     * </ul>
     * 
     * @see RemoteProtocol
     * @see org.eclipse.persistence.internal.sessions.remote.RemoteConnection
     * @see RemoteSession
     */
    public static final String REMOTE_PROTOCOL = "eclipselink.remote.protocol";
    
    /**
     * The <code>"eclipselink.remote.client.url"</code> property
     * configures remote JPA for a client.
     * This allows JPA to be access over RMI or other protocol from a remote Java client.
     * The URL is the complete URL used to access the RMI server.
     * 
     * @see REMOTE_PROTOCOL
     */
    public static final String REMOTE_URL = "eclipselink.remote.client.url";
    
    /**
     * The <code>"eclipselink.remote.server.name"</code> property
     * configures remote JPA for a server.
     * This allows JPA to be access over RMI or other protocol from a remote Java client.
     * The name is the name the server will be registered under in the RMI registry.
     * 
     * @see REMOTE_PROTOCOL
     */
    public static final String REMOTE_SERVER_NAME = "eclipselink.remote.server.name";
    
    /**
     * The <code>"eclipselink.nosql.connection-spec"</code> property.<br>
     * Allows the connection information for an NoSQL or EIS datasource to be specified.
     * An NoSQL datasource is a non-relational datasource such as a legacy database, NoSQL database,
     * XML database, transactional and messaging systems, or ERP systems.
     * @see org.eclipse.persistence.eis.EISConnectionSpec
     * @see org.eclipse.persistence.annotations.NoSQL
     */
    public static final String NOSQL_CONNECTION_SPEC = "eclipselink.nosql.connection-spec";
    
    /**
     * The <code>"eclipselink.nosql.connection-factory"</code> property.<br>
     * Allows the JCA ConnectionFactory to be specified for a NoSQL or EIS adapter.
     * An NoSQL datasource is a non-relational datasource such as a legacy database, NoSQL database,
     * XML database, transactional and messaging systems, or ERP systems.
     * @see javax.resource.cci.ConnectionFactory
     */
    public static final String NOSQL_CONNECTION_FACTORY = "eclipselink.nosql.connection-factory";
    
    /**
     * The <code>"eclipselink.jdbc.connector"</code> property.<br>
     * Allows a custom connector to be used to define how to connect to the database.
     * This is not required if a DataSource or JDBC DriverManager is used.
     * It can be used to connect to a non standard connection pool,
     * or provide additional customization in how a connection is obtained.
     * @see org.eclipse.persistence.sessions.JNDIConnector
     * @see org.eclipse.persistence.sessions.DefaultConnector
     */
    public static final String JDBC_CONNECTOR = "eclipselink.jdbc.connector";
    
    /**
     * Allows setting of NoSQL connection properties.
     * The NoSQL specific property name should be appended to this prefix.
     * <p>
     * i.e.<br>
     * "eclipselink.nosql.property.nosql.host"="localhost:5000"
     * 
     * @see org.eclipse.persistence.eis.EISConnectionSpec
     * @see org.eclipse.persistence.annotations.NoSQL
     */
    public static final String NOSQL_PROPERTY = "eclipselink.nosql.property.";
    
    /**
     * Allows setting of NoSQL user property.
     * Note that "javax.persistence.jdbc.user" is also supported.
     * 
     * @see org.eclipse.persistence.eis.EISConnectionSpec
     * @see org.eclipse.persistence.annotations.NoSQL
     */
    public static final String NOSQL_USER = "eclipselink.nosql.property.user";
    
    /**
     * Allows setting of NoSQL password property.
     * Note that "javax.persistence.jdbc.password" is also supported.
     * 
     * @see org.eclipse.persistence.eis.EISConnectionSpec
     * @see org.eclipse.persistence.annotations.NoSQL
     */
    public static final String NOSQL_PASSWORD = "eclipselink.nosql.property.password";
    
    /**
     * Allows passing of JDBC driver specific connection properties.
     * This allows for properties to be set on the JDBC connection.
     * The JDBC driver specific property name should be appended to this prefix.
     * <p>
     * i.e.<br>
     * "eclipselink.jdbc.property.defaultRowPrefetch"="25"
     * 
     * @see org.eclipse.persistence.sessions.DatasourceLogin#setProperty(String, Object)
     */
    public static final String JDBC_PROPERTY = "eclipselink.jdbc.property.";
    
    /**
     * Allows to set whether a query should by default use ResultSet Access optimization.
     * The optimization allows to avoid getting objects from ResultSet if the cached object used.
     * For instance, SELECT id, blob FROM .. with optimization would extract only "id" from ResultSet,
     * and if there is a corresponding cached object and it's not a refresh query, "blob" would never be extracted.
     * The draw back is keeping ResultSet and connection longer: until objects are built
     * (or extracted from cache) for all rows and all eager references (direct and nested) for each row.
     * Note that the optimization would not be used if it contradicts other query settings.
     * <p>
     * Allowed Values (String):
     * <ul>
     * <li>"true" - use optimization
     * <li>"false" don't use optimization
     * </ul>
     * Default value is 
     * ObjectLevelReadQuery.isResultSetAccessOptimizedQueryDefault = false;
     * 
     * @see org.eclipse.persistence.internal.sessions.AbstractSession#setShouldOptimizeResultSetAccess(boolean)
	 * @see org.eclipse.persistence.queries.ObjectLevelReadQuery#setIsResultSetAccessOptimizedQuery(boolean)
     */
    public static final String JDBC_RESULT_SET_ACCESS_OPTIMIZATION = "eclipselink.jdbc.result-set-access-optimization";
    
    /**
     * Specifies class name for session serializer (must implement org.eclipse.persistence.sessions.serializers.Serializer)
     * <p>
     * Default value is "org.eclipse.persistence.sessions.serializers.JavaSerializer" 
     * 
     * @see org.eclipse.persistence.internal.sessions.AbstractSession#setSerializer(Serializer)
     */
    public static final String SERIALIZER = "eclipselink.serializer";
    
    /**
     * INTERNAL: The following properties will not be displayed through logging
     * but instead have an alternate value shown in the log.
     */
    public static final Map<String, String> PROPERTY_LOG_OVERRIDES = new HashMap<String, String>(1);

    static {
        PROPERTY_LOG_OVERRIDES.put(JDBC_PASSWORD, "xxxxxx");
    }


    /**
     * The <code>"eclipselink.weaving.rest"</code> property configures
     * whether classes will be weaved to support our JPA_RS functionality
     * <p>
     * This property will only be considered if weaving is enabled.
     * <p>
     * Values (case insensitive):
     * <ul>
     * <li>"true" (DEFAULT)
     * <li>"false"
     * </ul>
     */
    public static final String WEAVING_REST = "eclipselink.weaving.rest";
    
    public static final String JPQL_TOLERATE = "eclipselink.tolerate-invalid-jpql";

    /**
     * INTERNAL: Return the overridden log string.
     */
    public static String getOverriddenLogStringForProperty(String propertyName) {
        return PROPERTY_LOG_OVERRIDES.get(propertyName);
    }

    /**
     * INTERNAL: The following properties passed to
     * {@link Persistence#createEntityManagerFactory(String, Map)} cached and
     * processed on the {@link EntityManagerFactory} directly. None of these
     * properties processed during pre-deploy or deploy.
     **/
    private static final Set<String> supportedNonServerSessionProperties = new HashSet<String>() {
        {
            add(JOIN_EXISTING_TRANSACTION);
            add(PERSISTENCE_CONTEXT_REFERENCE_MODE);
            add(PERSISTENCE_CONTEXT_FLUSH_MODE);
            add(PERSISTENCE_CONTEXT_CLOSE_ON_COMMIT);
            add(PERSISTENCE_CONTEXT_PERSIST_ON_COMMIT);
            add(PERSISTENCE_CONTEXT_COMMIT_WITHOUT_PERSIST_RULES);
            add(VALIDATE_EXISTENCE);
            add(ORDER_UPDATES);
            add(FLUSH_CLEAR_CACHE);
        }
    };

    public static Set<String> getSupportedNonServerSessionProperties() {
        return Collections.unmodifiableSet(supportedNonServerSessionProperties);
    }

}