      
  /** 
   * This is applicable only for the thin driver. Pass "true" to retain the V9 bind
   * behavior for Long and potential long binds. "false" is the default behavior which
   * would emulate the same behavior as in OCI driver. 
   **/
  public static final String CONNECTION_PROPERTY_RETAIN_V9_BIND_BEHAVIOR = "oracle.jdbc.RetainV9LongBindBehavior";
  public static final String CONNECTION_PROPERTY_RETAIN_V9_BIND_BEHAVIOR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_RETAIN_V9_BIND_BEHAVIOR_ACCESSMODE = 15; 
  /** 
   * 
   * The value of this property is used as the user name when connecting to the database. Note that there are other
   * ways to set the username: in the URL or in a wallet but the value of this property overwrites any other
   * value.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_USER_NAME = "user";
  public static final String CONNECTION_PROPERTY_USER_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_USER_NAME_ACCESSMODE = 15; 
  /** 
   * 
   * This property enables users to set a new password during connection creation if user's password got expired.
   * User can also change the password using this property even if their password is not expired.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_NEW_PASSWORD = "oracle.jdbc.newPassword";
  public static final String CONNECTION_PROPERTY_NEW_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_NEW_PASSWORD_ACCESSMODE = 1; 
  /** 
   * 
   *   This property sets the application context before the connection is
   *   established. The expected format is a semi-colon separated list of:
   *   <namespace>.<attribute>=<values>.
   *   @since 23ai
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_APPLICATION_CONTEXT = "oracle.jdbc.applicationContext";
  public static final String CONNECTION_PROPERTY_APPLICATION_CONTEXT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_APPLICATION_CONTEXT_ACCESSMODE = 15; 
  /** 
   * 
   * This property identifies the database that Oracle JDBC connects to. The 
   * value of this property may be any string that can appear after the '@'
   * symbol in a "jdbc:oracle:driver_type:@" URL. This value is 
   * referred to as a "database specifier". See section 
   * 
   * 8.2 Database URLs and Database Specifiers
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/21/jjdbc/data-sources-and-URLs.html#GUID-C4F2CA86-0F68-400C-95DA-30171C9FB8F0)
   * of the Oracle JDBC Developer's Guide for more information about database
   * specifiers.
   * 

   * If this property is set, the value takes precedence over any database
   * specifier that appears in a
   *  jdbc:oracle:driver_type:@database_specifier URL.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_DATABASE = "database";
  public static final String CONNECTION_PROPERTY_DATABASE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DATABASE_ACCESSMODE = 15; 
  /** 
   * This property is used to enable/disable auto-commit mode. By default, 
   * the value is set to "true", which enables auto commit. Setting this 
   * property to any value other than "true" disables auto commit. 
   **/
  public static final String CONNECTION_PROPERTY_AUTOCOMMIT = "autoCommit";
  public static final String CONNECTION_PROPERTY_AUTOCOMMIT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_AUTOCOMMIT_ACCESSMODE = 15;  
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_PROTOCOL = "protocol";
  public static final String CONNECTION_PROPERTY_PROTOCOL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROTOCOL_ACCESSMODE = 15; 
  /** 
   * Stream chunk size for input streams. This property is deprecated since 12.1 and is no longer used internally.
   * @deprecated 
   **/
  public static final String CONNECTION_PROPERTY_STREAM_CHUNK_SIZE = "oracle.jdbc.StreamChunkSize";
  public static final String CONNECTION_PROPERTY_STREAM_CHUNK_SIZE_DEFAULT = "32767";
  public static final byte CONNECTION_PROPERTY_STREAM_CHUNK_SIZE_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", the JDBC PreparedStatement
   * setFloat and setDouble API's convert float and 
   * double values to the internal binary format for BINARY_FLOAT or
   * BINARY_DOUBLE before sending to the database.
   * If the property is not set or set to other than "true", the
   * setFloat and setDouble API's convert float and 
   * double values to the internal format for NUMBER.
   * See the JavaDoc for setBinaryFloat in oracle.jdbc.PreparedStatement.
   * Use only for 10g or later databases. 
   **/
  public static final String CONNECTION_PROPERTY_SET_FLOAT_AND_DOUBLE_USE_BINARY = "SetFloatAndDoubleUseBinary";
  public static final String CONNECTION_PROPERTY_SET_FLOAT_AND_DOUBLE_USE_BINARY_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_SET_FLOAT_AND_DOUBLE_USE_BINARY_ACCESSMODE = 15; 
  /** 
   * Use this connection property to change the value that will show up in the "terminal"
   * column of the "v$session" table
   * for this connection. Note that this setting only applies to the thin driver. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_TERMINAL = "v$session.terminal";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_TERMINAL_DEFAULT = "unknown";
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_TERMINAL_ACCESSMODE = 15; 
  /** 
   * Use this connection property to change the value that will show up in the "machine"
   * column of the "v$session" table for this connection. Note that this setting only
   * applies to the thin driver.
   * 
   * If you don't specify a value, by default, the driver will attempt to retrieve your host
   * name. If the attempt fails, it will use "jdbcclient". 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_MACHINE = "v$session.machine";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_MACHINE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_MACHINE_ACCESSMODE = 15; 
  /** 
   * By default, the driver retrieves the OS username from the "user.name" system property which
   * is set by the JVM. You can however override this value by using this connection property (thin driver only).
   * 
   * The OS username will show up in the "osuser" column of the "v$session" table for this connection.
   * 
   * If you don't specify any value and if the JVM's "user.name" system property is null, the value will be set to "jdbcuser".
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_OSUSER = "v$session.osuser";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_OSUSER_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_OSUSER_ACCESSMODE = 15; 
  /** 
   * Use this connection property to change the value that will show up in the "program"
   * column of the "v$session" table for this connection. Note that this setting only applies
   * to the thin driver. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_PROGRAM = "v$session.program";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_PROGRAM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_PROGRAM_ACCESSMODE = 15; 
  /** 
   * Use this connection property to change the value that will show up in the "process"
   * column of the "v$session" table for this connection. Note that this setting only applies
   * to the thin driver. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_PROCESS = "v$session.process";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_PROCESS_DEFAULT = "1234";
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_PROCESS_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_INAME = "v$session.iname";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_INAME_DEFAULT = "jdbc_ttc_impl";
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_INAME_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_ENAME = "v$session.ename";
  public static final String CONNECTION_PROPERTY_THIN_VSESSION_ENAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_VSESSION_ENAME_ACCESSMODE = 15; 
  /** 
  * This property no longer has any effect.
  * @deprecated
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_PROFILE = "oracle.net.profile";
  public static final String CONNECTION_PROPERTY_THIN_NET_PROFILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_PROFILE_ACCESSMODE = 15; 
  /** 
   * Use this connection property to enable external authentication mechanism such as Kerberos, RADIUS or TCPS 
   * for the JDBC-OCI driver. The default value is false.
   * This property must be set to true while using external authentication along with DRCP.
   * While DRCP is not used, setting this property is optional and native driver implementation will try 
   * to resolve authentication type automatically.
   * @since 22c
   * @see #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_EXTERNAL_AUTHENTICATION = "oracle.net.external_authentication";
  public static final String CONNECTION_PROPERTY_OCI_EXTERNAL_AUTHENTICATION_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_OCI_EXTERNAL_AUTHENTICATION_ACCESSMODE = 7; 
  /** 
   * Use this connection property to turn on the authentication adaptors. The adaptors
   * are "RADIUS", "KERBEROS5", "BEQ" or "TCPS" which is SSL authentication.
   * 
   * For example, to turn on KERBEROS authentication:
   * 
   * 
   * Properties prop = new Properties();
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES,
   *                  "( KERBEROS5 )");  
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_MUTUAL,
   *                  "true");
   * // Specify where my krb5 configuration file is because JSSE can't find it:
   * System.setProperty("java.security.krb5.conf","C:\\WINDOWS\\krb5.ini");
   * 
   * 
   * Since 23ai, KERBEROS principal and password can be configured via the user and password
   * properties. JDBC Thin will initialize the KERBEROS context using these values when 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication} is set to KERBEROS5.
   * 

   * Or to turn on RADIUS: 
   * 
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES,
   *                  "( RADIUS)");
   * 
   * Or to turn on RADIUS, KERBEROS and SSL authentication adaptors: 
   * 
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES,
   *                  "( RADIUS, KERBEROS5, TCPS)");
   * 

   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES = "oracle.net.authentication_services";
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES_ACCESSMODE = 7; 
  /** 
   * This property is used to configure fully qualified name of the class that will be used during
   * the Challenge/Response phase of RADIUS authentication. The implementation must provide 
   * a public no argument constructor which the Thin driver calls to instansiate the handler. 
   * The handler must implement the functional interface java.util.function.Function. 
   * 
The byte[] input is the challenge hint text that is used
   * while prompting the user for a response. The text is UTF-8 encoded.
   * The handler is expected to return the response for the challenge as byte[].
   * 
This can also be configured via {@link oracle.jdbc.OracleConnectionBuilder#radiusChallengeResponseHandler(Function)}.
   * The value configured via {@link oracle.jdbc.OracleConnectionBuilder} has higher priority 
   * than the value configured through connection properties.
   * 
Example:
   * 
   *   OracleDataSource ods  = new OracleDataSource();
   *   ods.setURL(url);
   *   ods.setUser("myRadiusUser");
   *   ods.setPassword("myRadiusPassword");
   *   ods.setConnectionProperty(
   *   OracleConnection.CONNECTION_PROPERTY_THIN_NET_RADIUS_CHALLENGE_RESPONSE_HANDLER,
   *         "com.mycompany.RadiusChallengeResponseHandler");
   *   OracleConnection conn  = (OracleConnection)ods.getConnection();
   * 
   *
   * Example implementation that handles the RADIUS Challenge/Response:
   * 
   *   package com.mycompany;
   *   import java.util.function.Function;
   *   import java.nio.charset.StandardCharsets;
   *
   *   public class RadiusChallengeResponseHandler
   *      implements Function<byte[], byte[]> {
   *
   *   public byte[] apply(final byte[] hint) {
   *     // do some processing to calculate the challenge response
   *     final String response = getChallengeResponse(hint);
   *     return response.getBytes(StandardCharsets.UTF_8);
   *   }
   * }
   * 
   * @since 23ai
   * @see #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_RADIUS_CHALLENGE_RESPONSE_HANDLER = "oracle.net.radius_challenge_response_handler";
  public static final String CONNECTION_PROPERTY_THIN_NET_RADIUS_CHALLENGE_RESPONSE_HANDLER_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_RADIUS_CHALLENGE_RESPONSE_HANDLER_ACCESSMODE = 7; 
  /** 
   * To turn on Kerberos mutual authentication, set this property to "true". 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_MUTUAL = "oracle.net.kerberos5_mutual_authentication";
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_MUTUAL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_MUTUAL_ACCESSMODE = 7; 
  /** 
 * Use this connection property to specify the location of the Kerberos credential cache. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_CC_NAME = "oracle.net.kerberos5_cc_name";
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_CC_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_CC_NAME_ACCESSMODE = 7; 
  /** 
 * Use this connection property to specify the realm used for Kerberos authentication. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_REALM = "oracle.net.KerberosRealm";
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_REALM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_REALM_ACCESSMODE = 7; 
  /** 
 * Use this connection property to specify the name of the JAAS login module which will be used for 
 * initializing javax.security.auth.login.LoginContext. This property works in conjunction with 
 * the JAAS configuration. Please refer JDK documentation to know about configuring the JAAS config file. 
 * By default the Thin driver uses com.sun.security.auth.module.Krb5LoginModule as LoginModule and  
 * the Kerberos Credential Cache configured via {@link #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_CC_NAME}  
 * is used for retreiving the TGT. The default value is null. The JAAS configuration is used only if 
 * this property is configured with login module name.
 * @since 23ai
 * @see #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB5_CC_NAME
 * @see #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_JAAS_LOGIN_MODULE = "oracle.net.KerberosJaasLoginModule";
  public static final String CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_JAAS_LOGIN_MODULE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_KRB_JAAS_LOGIN_MODULE_ACCESSMODE = 7; 
  /** 
 * Use this connection property to enable FIPS140-2 mode for native network encryption.
 * The default key pair generation mechanism is not FIPS140-2 compliant and fails to generate 
 * a Diffie-Hellman key pair while negotiating the network encryption. Set the value to true
 * to enable FIPS-140-2 mode. The default value is false and FIPS140-2
 * mode is disabled.
 * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_SET_FIPS_MODE = "oracle.net.setFIPSMode";
  public static final String CONNECTION_PROPERTY_THIN_NET_SET_FIPS_MODE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_SET_FIPS_MODE_ACCESSMODE = 15; 
  /** 
 * Use this connection property to enable debugging of PL/SQL stored procedures and 
 * Java stored procedures over Java Debug Wire Protocol (JDWP).
 * The value must contain hostname and portnumber of the JDWP debugger in the following format 
 * host=HOST_NAME;port=PORT_NUMBER. Following are some valid examples : 
 * 
 *   
- host=127.0.0.1;port=8880
 *   
- host=myjdwpserver;port=8002
 * 
 * The default value is null and JDWP debugging is disabled by default.
 * @since 23ai
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_DEBUG_JDWP = "oracle.jdbc.debugJDWP";
  public static final String CONNECTION_PROPERTY_THIN_DEBUG_JDWP_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_DEBUG_JDWP_ACCESSMODE = 15; 
  /** 
   * 
Starting in release 23ai, the driver can be configured to use strong session keys 
   * when Native Network Encryption is used. But this breaks compatibility with  
   * older versions of the server which may not have the same capability. An exception 
   * with error code 12268 is thrown when the server does not have this 
   * capabilty. By default, in order to allow compatibility with 
   * such servers, and at the cost of security, this property is set to "true". 
   * When this property is configured to "false" then strong session keys are used.
   * 
Since 23ai, the following algorithms are not supported. 
   * De-supported encryption algorithms : RC4_40, DES40, DES, RC4_56, RC4_128,   
   * 3DES112, 3DES168 and RC4_256. De-supported checksum algorithms : MD5.
   * 
This property can also be configured through URL. The value configured through URL 
   * has higher priority than the value configured through connection properties. 
   * Please see the below examples to know how to configure this property through URL.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@//host:port/servicename?allow_weak_crypto=false
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(Security=(ALLOW_WEAK_CRYPTO=false)))
   * @since 23ai
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_ALLOW_WEAK_CRYPTO = "oracle.net.allow_weak_crypto";
  public static final String CONNECTION_PROPERTY_THIN_NET_ALLOW_WEAK_CRYPTO_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_THIN_NET_ALLOW_WEAK_CRYPTO_ACCESSMODE = 15; 
  /** 
   * Use this property to specify the level of security for the encryption service.
   * In order of increasing security the parameter can be (note that the default is "ACCEPTED"):<bt>
   * 
- "REJECTED": Select this value if you do not elect to enable the encryption
   * service, even if required by the other side. In this scenario, this side of
   * the connection specifies that the encryption service is not permitted. If the
   * other side is set to REQUIRED, the connection terminates with error message ORA-12650.
   * If the other side is set to REQUESTED, ACCEPTED, or REJECTED, the connection
   * continues without error and without the encryption service enabled.
   * 
- "ACCEPTED": Select this value to enable the encryption service if required
   * or requested by the other side. In this scenario, this side of the connection
   * does not require the encryption service, but it is enabled if the other side is
   * set to REQUIRED or REQUESTED. If the other side is set to REQUIRED or REQUESTED,
   * and an encryption algorithm match is found, the connection continues without error
   * and with the encryption service enabled. If the other side is set to REQUIRED and
   * no algorithm match is found, the connection terminates with error message ORA-12650.
   * If the other side is set to REQUESTED and no algorithm match is found, or if the other
   * side is set to ACCEPTED or REJECTED, the connection continues without error and
   * without the security service enabled.
   * 
- "REQUESTED": Select this value to enable the encryption service if the other
   * side permits it. In this scenario, this side of the connection specifies that the
   * security service is desired but not required. The security service is enabled if
   * the other side specifies ACCEPTED, REQUESTED, or REQUIRED. There must be a matching
   * algorithm available on the other side--otherwise the service is not enabled.
   * If the other side specifies REQUIRED and there is no matching algorithm,
   * the connection fails.
   * 
- "REQUIRED": Select this value to enable the encryption service or preclude
   * the connection. In this scenario, this side of the connection specifies that
   * the encryption service must be enabled. The connection fails if the other side
   * specifies REJECTED or if there is no compatible algorithm on the other side.
   * 
   * This property can also be configured through URL. The value configured through URL 
   * has higher priority than the value configured through connection properties. 
   * Please see the below examples to know how to configure this property through URL.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@//host:port/servicename?encryption_client=REQUIRED
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(Security=(ENCRYPTION_CLIENT=REQUESTED)))
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL = "oracle.net.encryption_client";
  public static final String CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL_ACCESSMODE = 15; 
  /** 
   * Use this connection property to specify the list of encryption algorithms that
   * you want to activate.
   * 
The supported algorithms are:
   * 
- "AES256": AES 256-bit key
   * 
- "AES192": AES 192-bit key
   * 
- "AES128": AES 128-bit key
   * 
   * 
   * For example, if you require the connection to be encrypted with either AES256 or AES192,
   * you would set the following properties: 
   * 
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES,
   *                  "( AES256, AES192 )");
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL,
   *                  "REQUIRED");
   * 
   * This property can also be configured through URL. The value configured through URL 
   * has higher priority than the value configured through connection properties. 
   * Please see the below examples to know how to configure this property through URL.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@//host:port/servicename?encryption_client=required&encryption_types_client=AES128,AES192
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(Security=(ENCRYPTION_CLIENT=REQUESTED)(ENCRYPTION_TYPES_CLIENT=AES128, AES192)))
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL
   * @see #CONNECTION_PROPERTY_THIN_NET_ALLOW_WEAK_CRYPTO
   *  
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES = "oracle.net.encryption_types_client";
  public static final String CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES_ACCESSMODE = 15; 
  /** 
   * Use this property to specify the level of security for the integrity service. Please refer
   * {@link #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL} to know more about the accepted values
   * and information on each of the values as both of these properties support same set of values.
   * This property can also be configured through URL. The value configured through URL 
   * has higher priority than the value configured through the connection properties. 
   * Please see the below examples to know how to configure this property through URL.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@//host:port/servicename?crypto_checksum_client=required
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(Security=(CRYPTO_CHECKSUM_CLIENT=REQUESTED)))
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES
   *  
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL = "oracle.net.crypto_checksum_client";
  public static final String CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL_ACCESSMODE = 15; 
  /** 
   * Use this connection property to specify the list of integrity algorithms that
   * you want to activate.
   * 
The supported algorithms are:
   * 
- "SHA1"
   * 
- "SHA256"
   * 
- "SHA384"
   * 
- "SHA512"
   * 
   * 
   * For example, if you require checksumming to be turned on and you
   * want either SHA1, SHA256, SHA384 or SHA512:
   * 
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES,
   *                  "( SHA1, SHA256, SHA384 or SHA512 )");
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL,
   *                  "REQUIRED");
   * 
   * This property can also be configured through URL. The value configured through URL 
   * has higher priority than the value configured through the connection properties. 
   * Please see the below examples to know how to configure this property through URL.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@//host:port/servicename?crypto_checksum_client=required&crypto_checksum_types_client=sha256,sha1
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcp)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(Security=(CRYPTO_CHECKSUM_CLIENT=REQUESTED)(CRYPTO_CHECKSUM_TYPES_CLIENT=SHA256,SHA1)))
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL
   * @see #CONNECTION_PROPERTY_THIN_NET_ALLOW_WEAK_CRYPTO
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES = "oracle.net.crypto_checksum_types_client";
  public static final String CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES_ACCESSMODE = 15; 
  /** 
   * Use this connection property to specify the encryption seed (between 10 and 70 random
   * characters). The encryption seed for the client should not be the same as that for the server.
   * Note that you don't have to specify a seed on the client. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_CRYPTO_SEED = "oracle.net.crypto_seed";
  public static final String CONNECTION_PROPERTY_THIN_NET_CRYPTO_SEED_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_CRYPTO_SEED_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true" and Data Encryption service is enabled, then 
   * JDK Crypto(JCE) APIs are used for encryption and decryption of the data between the
   * JDBC client and the Oracle Server, otherwise the built-in crypto implementation is used. 
   * Since 19.1, the default value is true for the Thin driver. If the JVM version is older than
   * 1.8.0_u151, then you need to change the JVM security policy to allow unlimited key
   * sizes. This is done by downloading and replacing the files found in $JAVA_HOME/lib/security
   * (local_policy.jar and US_export_policy.jar). Java Cryptography Extension 
   * (JCE) Unlimited Strength Jurisdiction Policy Files can be downloaded from Oracle website.
   * When this property value is set to "true" and the Unlimited Crypto Strength is not available 
   * then the Thin driver will automatically change this property value to "false" and will use
   * the built-in crypto implementation.
   * Since 23ai, this property has no effect and built-in crypto implementation is not available.
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_TYPES
   * @see #CONNECTION_PROPERTY_THIN_NET_ENCRYPTION_LEVEL
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_TYPES
   * @see #CONNECTION_PROPERTY_THIN_NET_CHECKSUM_LEVEL
   * @deprecated
    
   **/
  public static final String CONNECTION_PROPERTY_THIN_USE_JCE_API = "oracle.net.useJCEAPI";
  public static final String CONNECTION_PROPERTY_THIN_USE_JCE_API_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_THIN_USE_JCE_API_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", the TCP_NODELAY property is set on
   * the socket when using the Thin driver. See java.net.SocketOptions.TCP_NODELAY.
   * Can be either a system property or a connection property 
   **/
  public static final String CONNECTION_PROPERTY_THIN_TCP_NO_DELAY = "oracle.jdbc.TcpNoDelay";
  public static final String CONNECTION_PROPERTY_THIN_TCP_NO_DELAY_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_THIN_TCP_NO_DELAY_ACCESSMODE = 15; 
  /** 
   * 
   * Configures the socket read timeout (in milliseconds) for the JDBC thin
   * driver.
   * 
   * 
   * Starting in 12.2, this timeout value is set right after the socket 
   * establishment and is applicable to all socket read calls including
   * those that happen during the initial NS Protocol negotiation.
   * 
   * 
   * When connecting to ADB-S a value higher than 239000ms has no effect because 
   * every 4 minutes ADB-S sends a probe packet for DCD (Dead Connection 
   * Detection).
   * 
   * 
   * Since 18.1 this value can be followed by 'ms', 'sec' or 'min' (case not 
   * sensitive) to indicate 'milliseconds', 'seconds' or 'minutes'.
   * 
    
   **/
  public static final String CONNECTION_PROPERTY_THIN_READ_TIMEOUT = "oracle.jdbc.ReadTimeout";
  public static final String CONNECTION_PROPERTY_THIN_READ_TIMEOUT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_READ_TIMEOUT_ACCESSMODE = 15; 
  /** 
   * The outbound connect timeout controls the time allowed to connect the socket,
   * let the server accept the connection to the desired service, negotiate the NS
   * protocol as well as complete the ASO negotiation. It doesn't include the 
   * user authentication.
   * The timeout is applicable for each ADDRESS in an ADDRESS_LIST, and each IP address to which a host name is mapped.
   * This value is assumed in seconds if no explicit unit is indicated (both in the URL and in the connection's properties).
   * Default value is "0" (no timeout).
   * This affects only the thin driver.
   * This property can also be set through connection URL. The outbound timeout value
   * set in the connection URL overrides the value set using connection properties.
   * Since 18.1 this value can be followed by 'ms', 'sec' or 'min' (case not sensitive) to indicate 'milliseconds', 'seconds' or 'minutes'.
   * Here is an example of how to set the outbound connect timeout to 10 seconds through the URL: 
   *  jdbc:oracle:thin:@(DESCRIPTION=(CONNECT_TIMEOUT=10)  
   *    (ADDRESS_LIST=(ADDRESS=(HOST=myhost)(PORT=5521)(PROTOCOL=tcp)))(CONNECT_DATA=(SERVICE_NAME=myService))) 
   * @see #CONNECTION_PROPERTY_THIN_NET_CONNECT_TIMEOUT
   * @since 12.2 
    
   **/
  public static final String CONNECTION_PROPERTY_THIN_OUTBOUND_CONNECT_TIMEOUT = "oracle.net.OUTBOUND_CONNECT_TIMEOUT";
  public static final String CONNECTION_PROPERTY_THIN_OUTBOUND_CONNECT_TIMEOUT_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_THIN_OUTBOUND_CONNECT_TIMEOUT_ACCESSMODE = 15; 
  /** 
   * The connect timeout controls how much time is allowed to connect the socket to 
   * the database. Successfully connecting the socket doesn't necessarily mean that
   * the database service is up but it means that the listener is accepting
   * connections.
   * This value is assumed in seconds if set in the URL with no explicit units and in milliseconds if set in the connection's properties.
   * Starting in 23.6, the default value was changed from 
   * "0" (no timeout) to "20000" (20 seconds).
   * This affects only the thin driver. The connect timeout can also be set
   * through the connection URL using TRANSPORT_CONNECT_TIMEOUT like in the example
   * below. The value set in the URL overrides the value set in this property.
   * Since 18.1 this value can be followed by 'ms', 'sec' or 'min' (case not sensitive) to indicate 'milliseconds', 'seconds' or 'minutes'.
   * Here is an example of how to set the connect timeout to 5 seconds through the URL: 
   *  jdbc:oracle:thin:@(DESCRIPTION=(TRANSPORT_CONNECT_TIMEOUT=5)  
   *    (ADDRESS_LIST=(ADDRESS=(HOST=myhost)(PORT=5521)(PROTOCOL=tcp)))(CONNECT_DATA=(SERVICE_NAME=myService))) 
   * @see #CONNECTION_PROPERTY_THIN_OUTBOUND_CONNECT_TIMEOUT
    
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_CONNECT_TIMEOUT = "oracle.net.CONNECT_TIMEOUT";
  public static final String CONNECTION_PROPERTY_THIN_NET_CONNECT_TIMEOUT_DEFAULT = "20000";
  public static final byte CONNECTION_PROPERTY_THIN_NET_CONNECT_TIMEOUT_ACCESSMODE = 15; 
  /** 
   * Thin uses out of band breaks by default from 11g onwards.   If the user prefers
   * to use Inband breaks instead of Out of Band ones then this property could be set 
   * to true. 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_DISABLE_OUT_OF_BAND_BREAK = "oracle.net.disableOob";
  public static final String CONNECTION_PROPERTY_THIN_NET_DISABLE_OUT_OF_BAND_BREAK_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_THIN_NET_DISABLE_OUT_OF_BAND_BREAK_ACCESSMODE = 15; 
  /** 
   * The thin driver uses the zero-copy IO codepath for SecureFile Lobs by default from 11gR2 onwards.
   * To use the regular codepath, set this property to "false". 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_USE_ZERO_COPY_IO = "oracle.net.useZeroCopyIO";
  public static final String CONNECTION_PROPERTY_THIN_NET_USE_ZERO_COPY_IO_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_THIN_NET_USE_ZERO_COPY_IO_ACCESSMODE = 15; 
  /** 
   * setTime used to set the date component to 01 Jan, 1900 by default in earlier
   * versions (version < 10g).   However, this changed after 10.1 where the time
   * date component in the time was also honored by Jdbc.
   * This flag is introduced to retain the old behavior (as in 9.2)
   *  
   **/
  public static final String CONNECTION_PROPERTY_USE_1900_AS_YEAR_FOR_TIME = "oracle.jdbc.use1900AsYearForTime";
  public static final String CONNECTION_PROPERTY_USE_1900_AS_YEAR_FOR_TIME_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_1900_AS_YEAR_FOR_TIME_ACCESSMODE = 15; 
  /** 
   * Obtain TIMESTAMP WITH TIME ZONE value in GMT than adjusting the same to local
   * time zone. default is true. 
   **/
  public static final String CONNECTION_PROPERTY_TIMESTAMPTZ_IN_GMT = "oracle.jdbc.timestampTzInGmt";
  public static final String CONNECTION_PROPERTY_TIMESTAMPTZ_IN_GMT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_TIMESTAMPTZ_IN_GMT_ACCESSMODE = 15; 
  /** 
   * Use JVM default timezone as specified rather than convert to a GMT offset.
   * Default is true. 
   **/
  public static final String CONNECTION_PROPERTY_TIMEZONE_AS_REGION = "oracle.jdbc.timezoneAsRegion";
  public static final String CONNECTION_PROPERTY_TIMEZONE_AS_REGION_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_TIMEZONE_AS_REGION_ACCESSMODE = 15; 
  /** 
   * When a keystore (either wallet or jks file) contains multiple certificates, this
   * property can be used to specify the alias name of the certificate to be used by
   * the driver during the client authentication part of the SSL handshake.
   * Starting in 23ai, this can also be configured via the connection URL using the
   * SECURITY parameter SSL_CERTIFICATE_ALIAS.
   * The value set using the URL has higher precedence over the value
   * set using connection property.
   * This property can also be set using EZConnectPlus alias ssl_certificate_alias.
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_ALIAS = "oracle.net.ssl_certificate_alias";
  public static final String CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_ALIAS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_ALIAS_ACCESSMODE = 15; 
  /** 
   * When a keystore (either wallet or jks file) contains multiple certificates, this
   * property can be used to specify the thumbprint of the certificate to be used by
   * the driver during the client authentication part of the SSL handshake.
   * This can also be configured via the connection URL using the
   * SECURITY parameter SSL_CERTIFICATE_THUMBPRINT.
   * The value set using the URL has higher precedence over the value
   * set using connection property.
   * This property can also be set using EZConnectPlus alias ssl_certificate_thumbprint.
   * Hashing algorithm can be prepended to thumbprint. If no algorithm configured then 
   * SHA-1 is used by default.
   * 
   * Examples :
   *      SHA1:CD:C6:8B:0D:36:FE:20:0E:7F:86:5F:94:0B:4D:EC:EE:1B:C0:D1:09
   *      CD:C6:8B:0D:36:FE:20:0E:7F:86:5F:94:0B:4D:EC:EE:1B:C0:D1:09
   *      SHA1:CDC68B0D36FE200E7F865F940B4DECEE1BC0D109
   *      CDC68B0D36FE200E7F865F940B4DECEE1BC0D109
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_THUMBPRINT = "oracle.net.ssl_certificate_thumbprint";
  public static final String CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_THUMBPRINT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_CERTIFICATE_THUMBPRINT_ACCESSMODE = 15; 
  /** 
   * Use this connection property to enable or disable the authentication of the server 
   * during the SSL handshake. Authenticating the server means that the driver will verify 
   * that the Distinguished Name (DN) of the server's certificate matches the one that's
   * specified either in the connection string using "ssl_server_cert_dn" or through
   * the connection property "oracle.net.ssl_server_cert_dn". Starting in 18.0, the driver 
   * will automatically authenticate the server if its DN is specified. You can use this 
   * property to disable authentication by setting the value to "false".
   * Starting in 23ai, this can also be configured via the connection URL using the
   * SECURITY parameter SSL_SERVER_DN_MATCH.
   * The value set using the URL has higher precedence over the value
   * set using connection property.
   * This property can also be set using EZConnectPlus alias ssl_server_dn_match.
   * @see #CONNECTION_PROPERTY_THIN_SSL_SERVER_CERT_DN
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_SERVER_DN_MATCH = "oracle.net.ssl_server_dn_match";
  public static final String CONNECTION_PROPERTY_THIN_SSL_SERVER_DN_MATCH_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_SERVER_DN_MATCH_ACCESSMODE = 15; 
  /** 
   * Use this connection property to specify the distinguished name (DN) of the
   * server used during the SSL handshake to authenticate the server. This value can also   
   * be configured in the URL using the parameter "ssl_server_cert_dn".
   * The value set in the URL overrides the value set in this property.
   * @see #CONNECTION_PROPERTY_THIN_SSL_SERVER_DN_MATCH
   * @since 18.0
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_SERVER_CERT_DN = "oracle.net.ssl_server_cert_dn";
  public static final String CONNECTION_PROPERTY_THIN_SSL_SERVER_CERT_DN_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_SERVER_CERT_DN_ACCESSMODE = 15; 
  /** 
    * Use this connection property to enable or disable the authentication of the server
    * during the SSL handshake using the service name specified in the connection string.
    * Also when this property is set to true the DN is verified only    
    * after establishing NS Session, otherwise the DN is verified after every SSL handshake. 
    * This can also be configured via the connection URL using the
    * SECURITY parameter SSL_ALLOW_WEAK_DN_MATCH.
    * By default, weak dn match is disabled. Set the value to true to enable it.
    * The value set using the URL has higher precedence over the value
    * set using connection property.
    * This property can also be set using EZConnectPlus alias ssl_allow_weak_dn_match.
    * @see #CONNECTION_PROPERTY_THIN_SSL_SERVER_DN_MATCH
    * @see #CONNECTION_PROPERTY_THIN_SSL_SERVER_CERT_DN
    * @since 23ai
  
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_ALLOW_WEAK_DN_MATCH = "oracle.net.ssl_allow_weak_dn_match";
  public static final String CONNECTION_PROPERTY_THIN_SSL_ALLOW_WEAK_DN_MATCH_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_ALLOW_WEAK_DN_MATCH_ACCESSMODE = 15; 
  /** 
  * 
Specifies the TLS version to be used for negotiating the TLS protocol  
  * with the Oracle Database. This property is optional. By default, the 
  * database server and client negotiate the strongest security protocol  
  * available. Oracle advises against setting this parameter unless there are  
  * specific security requirements that necessitate the use of certain TLS  
  * protocol versions. When this property is not set, the JDBC thin driver uses  
  * all protocols supported by the JVM during the TLS handshake.
  * 
The TLS version can be configured by specifying the protocol version 
  * number, such as 1.2, or by using the TLSv 
  * prefix, like TLSv1.2. To specify multiple protocol versions, 
  * use a comma-separated string of values enclosed in parentheses, 
  * for example, (1.2, 1.3) or (TLSv1.2, TLSv1.3).
  * 
The specified value can indicate the minimum TLS 
  * version to be used by adding a '+' character at the end. For example, using 
  * values like 1.2+ or TLSv1.2+. In this case, the 
  * JDBC Thin driver will employ the TLS version TLSv1.2 and above 
  * (TLSv1.2 and TLSv1.3) to negotiate the protocol version with 
  * the Oracle Database during the TLS handshake.
  * 
Example:
  *   (DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=mydbhost)(PORT=3484))
  *   (SECURITY=(SSL_VERSION=(TLSv1.2, TLSv1.3)))
  *   (CONNECT_DATA=(SERVICE_NAME=mydbservice)))
  * 
  * 
The value can also be specified by using the EZConnect parameter 
  * called ssl_version.
  * 
Example:
  *    tcps://mydbhost:3484/mydbservice?ssl_version=1.2&wallet_location=walletpath
  * 
  * 
'SECURITY' parameter 'TLS_DISABLE_VERSION' can be used to disable one or more 
  * TLS versions from the list of supported versions.
  * 
Example:
  *   (DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=mydbhost)(PORT=3484))
  *   (SECURITY=(TLS_VERSION=TLSv1.1+)(TLS_DISABLE_VERSION=TLSv1.2))
  *   (CONNECT_DATA=(SERVICE_NAME=mydbservice)))
  * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_VERSION = "oracle.net.ssl_version";
  public static final String CONNECTION_PROPERTY_THIN_SSL_VERSION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_VERSION_ACCESSMODE = 15; 
  /** 
   * 
   * Specify a comma separated list of cipher suites to enable for TLS
   * communications with a database. The list must include at least one cipher
   * suite that is also enabled for the database. If the driver and the
   * database do not share a common cipher, then connection establishment
   * will result in a TLS handshake failure.
   * 

   * Note that the standard list of cipher suite names may be found in the JSSE
   * Cipher Suite Names section of the Java Cryptography Architecture Standard
   * Algorithm Name Documentation. Providers may support cipher suite names not
   * found in this list or might not use the recommended name for a certain
   * cipher suite.
   * 

   * If no value is set for this property, the driver will use the set of
   * cipher suites which your JSSE Security Provider has enabled by default.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * This property can also be configured through the EZConnect Plus URL format 
   * using the parameter SSL_CIPHERS. Since 26.1, this property can 
   * also be configured through TNS URL format using SSL_CIPHER_SUITES 
   * parameter under SECURITY section. 
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_CIPHER_SUITES = "oracle.net.ssl_cipher_suites";
  public static final String CONNECTION_PROPERTY_THIN_SSL_CIPHER_SUITES_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_CIPHER_SUITES_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the file system path of a key store file which contains private 
   * keys and certificates used for TLS (ie: TCPS) authentication with a database.
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORETYPE
   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTOREPASSWORD
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE = "javax.net.ssl.keyStore";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the format of a key store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE}. Examples of
   * commonly used formats are "SSO", "PKCS12", and "JKS".
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * If this property is not set, the JDBC driver will attempt to automatically
   * recognize the key store type based on the file extension of the key store.
   * 
   *   
Automatic Type Recognition
   *   
   *      Recognized Type
   *      File Extension(s)
   *   
   *   
   *      SSO
   *      .sso
   *   
   *   
   *      PKCS12
   *      .p12 or .pfx
   *   
   *   
   *      JKS
   *      .jks
   *   
   * 
   * For example, if the key store file is named "MyKeyStore.jks", and a type
   * is not specified using this property, then the type is automatically
   * recognized as JKS.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORETYPE = "javax.net.ssl.keyStoreType";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORETYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORETYPE_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the password of a key store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE}.
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * If this property is not set, the JDBC driver will attempt to access the 
   * key store without using a password.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTOREPASSWORD = "javax.net.ssl.keyStorePassword";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTOREPASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTOREPASSWORD_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the file system path of a trust store file which contains
   * certificate authorities that can be trusted when authenticating a
   * database's certificate.
   * 

   * If no value is set for this property, the driver will use the
   * {@code cacerts} file included with your JDK installation.
   * 

   * If a database's certificate can not be authenticated, then connection
   * establishment will result in a TLS handshake failure. The failure message
   * may describe a problem with building or finding a verification
   * path.
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORETYPE
   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTOREPASSWORD
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE = "javax.net.ssl.trustStore";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the format of a trust store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE}. Examples of
   * commonly used formats are "SSO", "PKCS12", and "JKS".
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * If this property is not set, the JDBC driver will attempt to automatically
   * recognize the trust store type based on the file extension of the trust
   * store.
   * 
   *   
Automatic Type Recognition
   *   
   *      Recognized Type
   *      File Extension(s)
   *   
   *   
   *      SSO
   *      .sso
   *   
   *   
   *      PKCS12
   *      .p12 or .pfx
   *   
   *   
   *      JKS
   *      .jks
   *   
   * 
   * For example, if the trust store file is named "MyTrustStore.jks", and a
   * type is not specified using this property, then the type is automatically
   * recognized as JKS.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORETYPE = "javax.net.ssl.trustStoreType";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORETYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORETYPE_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the password of a trust store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE}.
   * 

   * This property has no effect if
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * has also been set.
   * 

   * If this property is not set, the JDBC driver will attempt to access the 
   * trust store without using a password.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTOREPASSWORD = "javax.net.ssl.trustStorePassword";
  public static final String CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTOREPASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTOREPASSWORD_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the algorithm to use when managing the key meterial of the key
   * store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE}.
   * 

   * If this property is not set, the JDBC driver will use your JDK's default
   * algorithm, as returned by 
   * {@link javax.net.ssl.KeyManagerFactory#getDefaultAlgorithm()}.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_KEYMANAGERFACTORY_ALGORITHM = "ssl.keyManagerFactory.algorithm";
  public static final String CONNECTION_PROPERTY_THIN_SSL_KEYMANAGERFACTORY_ALGORITHM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_KEYMANAGERFACTORY_ALGORITHM_ACCESSMODE = 15; 
  /** 
   * 
   * Specify the algorithm to use when managing the meterial of the trust
   * store file specified by
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE}.
   * 

   * If this property is not set, the JDBC driver will use your JDK's default
   * algorithm, as returned by 
   * {@link javax.net.ssl.TrustManagerFactory#getDefaultAlgorithm()}.
   * 

   * This property is only supported by the jdbc:oracle:thin driver.
   * 

   * @see #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_TRUSTMANAGERFACTORY_ALGORITHM = "ssl.trustManagerFactory.algorithm";
  public static final String CONNECTION_PROPERTY_THIN_SSL_TRUSTMANAGERFACTORY_ALGORITHM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_SSL_TRUSTMANAGERFACTORY_ALGORITHM_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_OLDSYNTAX = "oracle.net.oldSyntax";
  public static final String CONNECTION_PROPERTY_THIN_NET_OLDSYNTAX_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_OLDSYNTAX_ACCESSMODE = 15; 
  /** 
   * Specify a timeout, in milliseconds, to apply when establishing a connection
   * to an LDAP server.
   * @see #CONNECTION_PROPERTY_THIN_JNDI_LDAP_READ_TIMEOUT
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JNDI_LDAP_CONNECT_TIMEOUT = "com.sun.jndi.ldap.connect.timeout";
  public static final String CONNECTION_PROPERTY_THIN_JNDI_LDAP_CONNECT_TIMEOUT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JNDI_LDAP_CONNECT_TIMEOUT_ACCESSMODE = 7; 
  /** 
   * Specify a timeout, in milliseconds, to apply when reading a response from
   * an LDAP server.
   * @see #CONNECTION_PROPERTY_THIN_JNDI_LDAP_CONNECT_TIMEOUT
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_JNDI_LDAP_READ_TIMEOUT = "com.sun.jndi.ldap.read.timeout";
  public static final String CONNECTION_PROPERTY_THIN_JNDI_LDAP_READ_TIMEOUT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_JNDI_LDAP_READ_TIMEOUT_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the wallet location. The driver will use this wallet to:
   * 
-    * Retrieve the username and password which can be stored in a wallet. The driver
   * attempts to retrieve the username and password from the wallet unless they are specified
   * in the JDBC URL or in the properties (in order, it will look in the properties
   * first, then in the URL and then in the wallet). The "mkstore" utility can be used to store
   * the username and password in an existing wallet. For example,
   * if the wallet is in the "client_wallet" directory: mkstore -wrl ./client_wallet
   * -createCredential \(DESCRIPTION=\(ADDRESS=\(PROTOCOL=tcp\)\(HOST=servername\)\(
   * PORT=5560\)\)\(CONNECT_DATA=\(SERVICE_NAME=service_name\)\)\) scott ****
   * 
A default username and password can also be added to an existing wallet using the 
   * below commands. When URL specific username and password are not found then the default 
   * values are used. Example:
   * 
   * mkstore -wrl .\walletpath -createEntry oracle.security.client.default_username scott
   * 
mkstore -wrl .\walletpath -createEntry oracle.security.client.default_password ****
   * 
   * 
Since 26.1, the username and password can be stored in a separate wallet. 
   * Please refer to
   * {@linkplain #CONNECTION_PROPERTY_SEPS_WALLET_LOCATION oracle.net.seps_wallet_location} 
   * for more information.
   * 
   * 
- Create an SSL connection if the TCPS protocol is enabled. The wallet is used for both
   * the truststore and the keystore and overwrites the JSSE properties.
   * 
   * 
   * 
   * The wallet location can be set in three formats:
   * 
- "file:/path/ewallet.sso" or "file:/path/cwallet.p12" or "file:/path/to/directory/"
   * 
- (SOURCE=(METHOD=FILE)(METHOD_DATA=(DIRECTORY=/path/to/directory)))
   * 
- "data:;base64,<Base64 representation of the bytes in cwallet.sso>"
   * 
   * 

   * This property can also be configured through EZConnectPlus alias wallet_location
   * and TNS URL parameters WALLET_LOCATION or MY_WALLET_DIRECTORY.
   * The value configured in the URL has higher priority over the value configured over 
   * connection properties.
   * 
Please see the below examples.
   * 
EzConnectPlus Format:
   * jdbc:oracle:thin:@tcps://host:port/servicename?wallet_location=/mywallets/cwallet.sso
   * 
For setting base64 value of cwallet.sso:
   * jdbc:oracle:thin:@tcps://host:port/servicename?wallet_location=data:;base64,bGlnaHQgd29yaw==
   * 
TNS Long URL Format:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcps)(HOST=host)(PORT=5521))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(SECURITY=(WALLET_LOCATION=/mywallets/cwallet.sso)))
   * 
Incase of One-Way TLS, to use the default truststore the wallet location
   * can be configured to a special value SYSTEM in the URL and the wallet location value specified  
   * via connection properties can be used to retrieve username and password for authenticating
   * to the Oracle Database. 
   * 

   * Note that if you don't use SSO wallets but PKCS12 wallets, you must provide the wallet password through
   * the {@linkplain #CONNECTION_PROPERTY_WALLET_PASSWORD oracle.net.wallet_password} property.
   * 

   * A wallet located by this property may store credentials for an Azure 
   * service principal. When 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} 
   * is set to AZURE_SERVICE_PRINCIPAL, a username is interpreted as a 
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_ID client id}, and a password is
   * interpreted as a 
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET client secret}.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_WALLET_LOCATION = "oracle.net.wallet_location";
  public static final String CONNECTION_PROPERTY_WALLET_LOCATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_WALLET_LOCATION_ACCESSMODE = 15; 
  /** 
   * Use this property to set the wallet password which is only required if you don't enable
   * enable auto-login in the wallet. In this case "ewallet.p12" will be used instead of "cwallet.sso".
 
   **/
  public static final String CONNECTION_PROPERTY_WALLET_PASSWORD = "oracle.net.wallet_password";
  public static final String CONNECTION_PROPERTY_WALLET_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_WALLET_PASSWORD_ACCESSMODE = 15; 
  /** 
   * Use this property to specify which private key to use in a PEM file.
   * By default, the driver will use the first private key it finds, unless a different index is specified in 
   * this connection property.
 
   **/
  public static final String CONNECTION_PROPERTY_PEM_PRIVATE_KEY_INDEX = "oracle.net.ssl_pem_private_key_index";
  public static final String CONNECTION_PROPERTY_PEM_PRIVATE_KEY_INDEX_DEFAULT = "1";
  public static final byte CONNECTION_PROPERTY_PEM_PRIVATE_KEY_INDEX_ACCESSMODE = 15; 
  /** 
   * Use this property to configure the maximum number of SSLContext instances 
   * that can be cached in SSLContextCache. An SSLContext is cached to improve 
   * performance and to achieve the TLS session resumption. The SSLContextCache
   *  is a singleton instance and is used across all the connection instances. 
   * When a connection requires an SSLContext for establishing a TLS session 
   * with the Oracle Database, it queries the SSLContextCache. If an SSLContext 
   * exists for an identical TLS configuration, then it is used. Otherwise a 
   * new SSLContext instance is created, cached and returned. A cached 
   * SSLContext instance is invalidated if its keystore / truststore file is 
   * modified or its provider is removed. When the SSLContextCache becomes 
   * full, the least recently used SSLContext instance is removed before adding
   *  a new SSLContext instance to the cache. The default maximum cache size is
   *  15 and can be tuned using this property. If this property 
   * is set to 0 then SSLContextCache is disabled.
   * 
Each SSLContext instance caches the SSLSessions created using it. The 
   * cached sessions are used during TLS session resumption. By default JDK 
   * implementation does not have any limit on the maximum number of sessions 
   * that can be cached. But this can be optimised using the system property 
   * javax.net.ssl.sessionCacheSize.
   * @since 26.1
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_SSL_CONTEXT_CACHE_SIZE = "oracle.net.sslContextCacheSize";
  public static final String CONNECTION_PROPERTY_THIN_SSL_CONTEXT_CACHE_SIZE_DEFAULT = "15";
  public static final byte CONNECTION_PROPERTY_THIN_SSL_CONTEXT_CACHE_SIZE_ACCESSMODE = 2; 
  /** 
   * Use this property to specify the set of cipher suites to be used while SSL negotiation with LDAP server.
   * Multiple cipher suite names can be separated by comma. This is an optional property and by default 
   * the JDBC Thin driver uses all the cipher suites supported by the JVM.   
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_CIPHER_SUITES = "oracle.net.ldap.ssl.supportedCiphers";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_CIPHER_SUITES_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_CIPHER_SUITES_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the valid SSL protocol version(s) used while SSL negotiation with LDAP Server.
   * Multiple protocol versions can be separated by comma. The default value is null.
   * The valid protocol versions are 
   * TLSv1.2
   * TLSv1.1
   * TLSv1
   * SSLv3
   * SSLv2Hello
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_VERSIONS = "oracle.net.ldap.ssl.supportedVersions";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_VERSIONS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_VERSIONS_ACCESSMODE = 7; 
  /** 
   * This property is used to specify the path to the KeyStore file which will be used while 
   * SSL negotiation with LDAP server. The default value is null. When no value is specified, 
   * the default keystore of the JVM is used.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_PASSWORD
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_TYPE
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE = "oracle.net.ldap.ssl.keyStore";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_ACCESSMODE = 7; 
  /** 
   * Use this property to specify type of the configured KeyStore file to be used while SSL 
   * negotiation with LDAP Server. This is an optional property and the JDBC Thin driver will try to resolve 
   * the key store type automatically using the file extension. JVM's default KeyStoreType is 
   * used if the type is not configured and the driver is not able to resolve the type automatically.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_TYPE = "oracle.net.ldap.ssl.keyStoreType";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_TYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_TYPE_ACCESSMODE = 7; 
  /** 
   * This property is used to specify the password for the KeyStore file which will be used while SSL negotiation
   * with LDAP server. The default value is null.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_PASSWORD = "oracle.net.ldap.ssl.keyStorePassword";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE_PASSWORD_ACCESSMODE = 7; 
  /** 
   * Use this property to override the default algorithm used by KeyManagerFactory.
   * The default value is null.
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYMANAGER_FACTORY_ALGORITHM = "oracle.net.ldap.ssl.keyManagerFactory.algorithm";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYMANAGER_FACTORY_ALGORITHM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYMANAGER_FACTORY_ALGORITHM_ACCESSMODE = 7; 
  /** 
   * This property is used to specify the path to the TrustStore file which will be used while 
   * SSL negotiation with LDAP server. The default value is null. When no value is specified, 
   * the default truststore of the JVM is used.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_TYPE
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_PASSWORD
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_KEYSTORE 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE = "oracle.net.ldap.ssl.trustStore";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_ACCESSMODE = 7; 
  /** 
   * Use this property to specify type of the configured TrustStore file to be used while SSL 
   * negotiation with LDAP Server. This is an optional property and the JDBC Thin driver will try to resolve 
   * the trust store type automatically using the file extension. JVM's default KeyStoreType is 
   * used if the type is not configured and the driver is not able to resolve the type automatically.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_TYPE = "oracle.net.ldap.ssl.trustStoreType";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_TYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_TYPE_ACCESSMODE = 7; 
  /** 
   * This property is used to specify the password for the TrustStore file which will be used while SSL negotiation
   * with LDAP server. The default value is null.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_PASSWORD = "oracle.net.ldap.ssl.trustStorePassword";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTSTORE_PASSWORD_ACCESSMODE = 7; 
  /** 
   * Use this property to override the default algorithm used by TrustManagerFactory.
   * The default value is null.
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTMANAGER_FACTORY_ALGORITHM = "oracle.net.ldap.ssl.trustManagerFactory.algorithm";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTMANAGER_FACTORY_ALGORITHM_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_TRUSTMANAGER_FACTORY_ALGORITHM_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the wallet location. The driver will use this wallet while SSL negotiation
   * with LDAP server. The default value is null. Username(DN) and password to be used for 
   * authenticating with the LDAP server can be added to the wallet secret store using the
   * key names oracle.ldap.client.dn and oracle.ldap.client.password respectively.
   * The above authentication credentials can also be configured through connection properties.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_PASSWORD
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_LOCATION = "oracle.net.ldap.ssl.walletLocation";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_LOCATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_LOCATION_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the password of the wallet file which will be used while SSL negotiation
   * with LDAP server. The default value is null and no password is required for accessing the wallet.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_LOCATION
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_PASSWORD = "oracle.net.ldap.ssl.walletPassword";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_WALLET_PASSWORD_ACCESSMODE = 7; 
  /** 
   * Specifies the authentication mechanism to be used by the LDAP service provider in the JDK. 
   * 
This can be one of the following strings: none or simple.
   * The default value is none and LDAP authentication is disabled. If it is configured
   * with the value simple then the LDAP Server authentication details must to be set through either
   * wallet secret store or connection properties.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION = "oracle.net.ldap.security.authentication";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the value of the username(DN) which will be used while authenticating with the LDAP server.
   * 
The default value is null. This property can also be configured via wallet secret store entry
   * oracle.ldap.client.dn. The value configured in connection property has higher priority over the 
   * value configured in the wallet secret store. This property is used only when the LDAP authentication is set to
   * simple.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS
   * @since 21c  
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL = "oracle.net.ldap.security.principal";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL_ACCESSMODE = 7; 
  /** 
   * Use this property to configure the password which will be used while authenticating with the LDAP server.
   * 
The default value is null. This property can also be configured via wallet secret store entry
   * oracle.ldap.client.password. The value configured in connection property has higher priority over the 
   * value configured in the wallet secret store. This property is used only when the LDAP authentication is set to
   * simple.
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_AUTHENTICATION
   * @see #CONNECTION_PROPERTY_THIN_LDAP_SECURITY_PRINCIPAL
   * @since 21c  
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS = "oracle.net.ldap.security.credentials";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SECURITY_CREDENTIALS_ACCESSMODE = 7; 
  /** 
   * 
   * Specifies a {@code protocol} name for the driver to use when
   * obtaining an instance of {@link javax.net.ssl.SSLContext} from
   * {@link javax.net.ssl.SSLContext#getInstance(String)} for a TLS enabled
   * LDAP connection.
   * 
   * 
   * 
   * This property has no effect on which versions of SSL or TLS will be
   * accepted during handshakes with the LDAP server.
   * 
   * To configure the set of protocol versions accepted during handshakes, use
   * {@link #CONNECTION_PROPERTY_THIN_LDAP_SSL_VERSIONS}.
   * 
   * 
   * If this property is not specified, the driver will use "TLS" by default.
   * 
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   * 
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_CONTEXT_PROTOCOL = "oracle.net.ldap.ssl.ssl_context_protocol";
  public static final String CONNECTION_PROPERTY_THIN_LDAP_SSL_CONTEXT_PROTOCOL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_LDAP_SSL_CONTEXT_PROTOCOL_ACCESSMODE = 7; 
  /** 
   * The value of this property is used to specify the name of the proxy client
   * during proxy authentication.
   * 
   * For example if a database user "proxyclient" is setup to connect through another
   * user called "proxy", then you would set the value of this property to "proxyclient".
   * 
   * Note that this connection property can be used to obtain a proxy client connection from 
   * scratch and in this model there is only one database session involved instead of two when
   * you first create a regular connection as "proxy" and then call openProxySession(...)
   * to obtain a proxy client session. This is called the single-session proxy model.
   * This property is only supported for connections to database versions of 10.2 and higher.
   * There is no support for the single-session proxy model in earlier database versions.
 
   **/
  public static final String CONNECTION_PROPERTY_PROXY_CLIENT_NAME = "oracle.jdbc.proxyClientName";
  public static final String CONNECTION_PROPERTY_PROXY_CLIENT_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROXY_CLIENT_NAME_ACCESSMODE = 15; 
  /** 
   * In case of Jdbc-OCI drivers the data is copied from C layer to Java using
   * Jni array copy api.   Alternatively by setting this property to "true"
   * the user can instruct the driver to copy data using NIO.
   * Note that the feature would enabled if the underlying JVM supports
   * NIO in JNI layer.
   * The flag is turned off by default (set to false).
 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULT_USE_NIO = "oracle.jdbc.useNio";
  public static final String CONNECTION_PROPERTY_DEFAULT_USE_NIO_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DEFAULT_USE_NIO_ACCESSMODE = 15; 
  /** 
   * Use this property to set the hostname or address of the https proxy server. This can also be set via the URL.
   * The value set through the URL has higher priority than the value set using this property.
   * Here is an example of how to set the proxy host name through the URL: 
   *  jdbc:oracle:thin:@(DESCRIPTION=  
   *    (ADDRESS_LIST=
   *  (ADDRESS=(HTTPS_PROXY=myproxyserver)(HTTPS_PROXY_PORT=8080)(HOST=myhost)(PORT=5521)(PROTOCOL=tcp)))
   *  (CONNECT_DATA=(SERVICE_NAME=myService))) 
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT
   * @since 19.3 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST = "oracle.net.httpsProxyHost";
  public static final String CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST_ACCESSMODE = 15; 
  /** 
   * Use this property to set the port of the https proxy server. This can also be set via the URL.
   * The value set through the URL has higher priority than the value set using this property.
   * Here is an example of how to set the proxy port through the URL: 
   *  jdbc:oracle:thin:@(DESCRIPTION=  
   *    (ADDRESS_LIST=
   *  (ADDRESS=(HTTPS_PROXY=myproxyserver)(HTTPS_PROXY_PORT=8080)(HOST=myhost)(PORT=5521)(PROTOCOL=tcp)))
   *  (CONNECT_DATA=(SERVICE_NAME=myService))) 
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST
   * @since 19.3 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT = "oracle.net.httpsProxyPort";
  public static final String CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT_ACCESSMODE = 15; 
  /** 
   * The property is used to set the value of the local host name.
   * The default value is InetAddress.getLocalHost().getHostName(). If this does not exists, then the
   * value is set to "__jdbc__".
   * This value shows up in the connect data of the connect packet in the listener logs.
 
   **/
  public static final String CONNECTION_PROPERTY_LOCAL_HOST_NAME = "oracle.jdbc.localhostName";
  public static final String CONNECTION_PROPERTY_LOCAL_HOST_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_LOCAL_HOST_NAME_ACCESSMODE = 15; 
  /** 
   * This property oracle.net.connectionIdPrefix can be used to
   * customize the first 8 characters of the Net connection id that's sent to the
   * listener during connection establishment for tracing purposes. Its value is a 8
   * character long string (can contain only alphabets, numbers 
   * and _).
   * For example the value can be set to App_231 (which contains only 
   * supported characters) to identify connections coming from a 
   * particular application.
   * Starting in 23ai, this can also be configured via the connection URL using the
   * CONNECT_DATA parameter CONNECTION_ID_PREFIX.
   * The value set using the connection property has higher precedence over the value
   * set using URL.
   * This property can also be set using EZConnectPlus alias connection_id_prefix.
   * @since 21c 
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_NET_CONNECTIONID_PREFIX = "oracle.net.connectionIdPrefix";
  public static final String CONNECTION_PROPERTY_THIN_NET_CONNECTIONID_PREFIX_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_THIN_NET_CONNECTIONID_PREFIX_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_DRIVER_CHARSET = "JDBCDriverCharSetId";
  public static final String CONNECTION_PROPERTY_OCI_DRIVER_CHARSET_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_DRIVER_CHARSET_ACCESSMODE = 15; 
  /** 
   * This connection property can be used to specify a name for the "session edition".
   * The value is sent to the server at connection time.
   *
   * 
 The following SQL query:
   * 
SELECT sys_context('USERENV', 'CURRENT_EDITION_NAME') 
   * FROM dual
   * will return the same value.
   *
   * 
   * Note that this property can also be set as a system property.
   * 
   * 
   * 
By default, if you don't set this property, the "session edition" will be set to the
   * database default edition (for example "ORA$BASE").
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_EDITION_NAME = "oracle.jdbc.editionName";
  public static final String CONNECTION_PROPERTY_EDITION_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_EDITION_NAME_ACCESSMODE = 15;  
  /** 
   * 
The driver can be configured to verify the legitimacy of the connected   
   * server on authentication failure. But this breaks compatibility with  
   * older versions of the server which may not have the same capability. An exception 
   * with error code 28481 is thrown when the server does not have this 
   * capabilty. By default, in order to allow compatibility with 
   * such servers, and at the cost of security, this property is set to "false". 
   * When this property is configured to "true" then the server's legitimacy is verified
   * on authentication failure.
 
   **/
  public static final String CONNECTION_PROPERTY_THIN_CHECK_AUTH_RESPONSE_ON_ERROR = "oracle.jdbc.checkAuthResponseOnError";
  public static final String CONNECTION_PROPERTY_THIN_CHECK_AUTH_RESPONSE_ON_ERROR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_THIN_CHECK_AUTH_RESPONSE_ON_ERROR_ACCESSMODE = 15;  
  /** 
 * The value of this property is used as the user name when performing an
 * internal logon. Usually this will be "SYS" or "SYSDBA".
 * 
 * As of 12.1 server and driver, "SYSBACKUP", "SYSDG" and "SYSKM" are also supported.
 * 
   **/
  public static final String CONNECTION_PROPERTY_INTERNAL_LOGON = "internal_logon";
  public static final String CONNECTION_PROPERTY_INTERNAL_LOGON_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_INTERNAL_LOGON_ACCESSMODE = 15; 
  /** 
  * The user has to provide fully qualified ADT name ([username].[adt name])
  * for all ADT operations.  However, if the user does not provide fully
  * qualified name, the user name provided during login is appended to the
  * ADT name to obtain fully qualified name.  This is also the behavior when
  * this flag is set to false.
  * 
The user also has an option to append the CURRENT_USER value to the
  * ADT name to obtain fully qualified name by setting this property to
  * true.   Note that it takes a network round trip to fetch
  * the CURRENT_SCHEMA value.
  * 
The default value of this flag is false which means
  * that the driver appends the user name used to login as the user name to
  * append to the ADT name.
   **/
  public static final String CONNECTION_PROPERTY_CREATE_DESCRIPTOR_USE_CURRENT_SCHEMA_FOR_SCHEMA_NAME = "oracle.jdbc.createDescriptorUseCurrentSchemaForSchemaName";
  public static final String CONNECTION_PROPERTY_CREATE_DESCRIPTOR_USE_CURRENT_SCHEMA_FOR_SCHEMA_NAME_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_CREATE_DESCRIPTOR_USE_CURRENT_SCHEMA_FOR_SCHEMA_NAME_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_SVC_CTX_HANDLE = "OCISvcCtxHandle";
  public static final String CONNECTION_PROPERTY_OCI_SVC_CTX_HANDLE_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_OCI_SVC_CTX_HANDLE_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_ENV_HANDLE = "OCIEnvHandle";
  public static final String CONNECTION_PROPERTY_OCI_ENV_HANDLE_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_OCI_ENV_HANDLE_ACCESSMODE = 15; 
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_ERR_HANDLE = "OCIErrHandle";
  public static final String CONNECTION_PROPERTY_OCI_ERR_HANDLE_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_OCI_ERR_HANDLE_ACCESSMODE = 15; 
  /** 
  * If this property is set to "true", JDBC drivers connect in PRELIM_AUTH
  * mode, which is the only mode that is permitted when the database is down. 
   **/
  public static final String CONNECTION_PROPERTY_PRELIM_AUTH = "prelim_auth";
  public static final String CONNECTION_PROPERTY_PRELIM_AUTH_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_PRELIM_AUTH_ACCESSMODE = 15;   
  /** 
   * The value of this property is ignored since the 20c release. Prior to 20c,
   * the value of this property would configure the default batch size when
   * using Oracle-Style batching.
   * 
   * @deprecated Oracle-Style batching is desupported. Standard JDBC batch execution is recommended instead. 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULT_EXECUTE_BATCH = "defaultExecuteBatch";
  public static final String CONNECTION_PROPERTY_DEFAULT_EXECUTE_BATCH_DEFAULT = "1";
  public static final byte CONNECTION_PROPERTY_DEFAULT_EXECUTE_BATCH_ACCESSMODE = 15; 
  /** 
   * The value of this property is used as the default number of rows to prefetch. 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULT_ROW_PREFETCH = "defaultRowPrefetch";
  public static final String CONNECTION_PROPERTY_DEFAULT_ROW_PREFETCH_DEFAULT = "10";
  public static final byte CONNECTION_PROPERTY_DEFAULT_ROW_PREFETCH_ACCESSMODE = 15; 
  /** 
   * The value of this property is used as the default LOB prefetch size for this connection.
   * 
   * The LOB prefetch size can be overriden at the statement level through the setLobPrefetchSize(int)
   * which is defined in oracle.jdbc.OracleStatement. The statement level LOB
   * prefetch size can be overriden at the column level through the defineColumnType method.
   * 
   * The value can be "-1" to disable LOB prefetch for this connection,
   * "0" to enable LOB prefetch for meta-data only or any value greater than 0 which represents a number
   * of bytes for BLOBs and chars for CLOBs to be prefetched along with the locator during fetch operations.
   * The default value for this property is "32768".
   * 
   * @see OracleStatement#setLobPrefetchSize OracleStatement.setLobPrefetchSize
   * @since 11.2 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULT_LOB_PREFETCH_SIZE = "oracle.jdbc.defaultLobPrefetchSize";
  public static final String CONNECTION_PROPERTY_DEFAULT_LOB_PREFETCH_SIZE_DEFAULT = "32768";
  public static final byte CONNECTION_PROPERTY_DEFAULT_LOB_PREFETCH_SIZE_ACCESSMODE = 15; 
  /** 
   * The value of this property is used to control the use of the Data in Locator feature of the server.
   * 
   * Data in Locator is a server side feature introduced in 10.2. For small lobs the actual data in included in the
   * locator bytes shipped to the client. These may be shipped back and forth several times as the 
   * client accesses the lob using the lob APIs. For fast networks this actually increases performance
   * because it greatly reduces server CPU consumption.
   * 
   * For slower networks there is a net slow down. Setting this property to false will disable this
   * feature. 
   * 
   * This property is currently only effective for the thin driver.
   * 
   * Data in Locator is automatically disabled when Lob Prefetch is enabled. 
   * Thus this property will most
   * likely be used for 10.2 servers where lob prefetch is not available. 
   * @since 11.2 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_DATA_IN_LOCATOR = "oracle.jdbc.enableDataInLocator";
  public static final String CONNECTION_PROPERTY_ENABLE_DATA_IN_LOCATOR_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_DATA_IN_LOCATOR_ACCESSMODE = 15; 
  /** 
   * The value of this property is used to control the use of the Data in Locator feature by the client.
   * 
   * Data in Locator is a server side feature introduced in 10.2. The JDBC driver is enhanced
   * to use this data directly. This saves a number of round trips which previously occurred
   * when lob APIs were used to read the data.
   * 
   * This feature is only enabled for 10.2 servers. For earlier servers the Data in Locator feature
   * did not exist and for later ones the lob prefetch functionality make this uunnecessary and
   * the new lob storage types complicate the locator structure.  
   * @since 11.2 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_READ_DATA_IN_LOCATOR = "oracle.jdbc.enableReadDataInLocator";
  public static final String CONNECTION_PROPERTY_ENABLE_READ_DATA_IN_LOCATOR_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_READ_DATA_IN_LOCATOR_ACCESSMODE = 15;  
  /** 
   * If the value of this property is "true", OracleDatabaseMetaData will include remarks
   * in the meta data. This can result in a substantial reduction in performance. 
   **/
  public static final String CONNECTION_PROPERTY_REPORT_REMARKS = "remarksReporting";
  public static final String CONNECTION_PROPERTY_REPORT_REMARKS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_REPORT_REMARKS_ACCESSMODE = 15; 
  /** 
  * If the value of this property is "true", JDBC will include synonyms when getting
   * information about a column. 
   **/
  public static final String CONNECTION_PROPERTY_INCLUDE_SYNONYMS = "includeSynonyms";
  public static final String CONNECTION_PROPERTY_INCLUDE_SYNONYMS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_INCLUDE_SYNONYMS_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", JDBC will return a more refined value for
   * DatabaseMeta.getTables. By default JDBC will return things that are not accessible
   * tables. These can be non-table objects or accessible synonymns for inaccessible tables.
   * If this property is true JDBC will return only accessible tables. This has a substantial
   * performance penalty. 
   **/
  public static final String CONNECTION_PROPERTY_RESTRICT_GETTABLES = "restrictGetTables";
  public static final String CONNECTION_PROPERTY_RESTRICT_GETTABLES_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_RESTRICT_GETTABLES_ACCESSMODE = 15; 
  /** 
 * When using Oracle style batching, JDBC determines when to flush a batch to
   * the database. If this property is true, then the number of modified rows
   * accumulated across all batches flushed from a single statement. The default
   * is to count each batch separately. 
   **/
  public static final String CONNECTION_PROPERTY_ACCUMULATE_BATCH_RESULT = "AccumulateBatchResult";
  public static final String CONNECTION_PROPERTY_ACCUMULATE_BATCH_RESULT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ACCUMULATE_BATCH_RESULT_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", then JDBC will prefetch rows even
   * though there is a LONG or LONG RAW column in the result. By default JDBC fetches
   * only one row at a time if there are LONG or LONG RAW columns in the result.
   * Setting this property to "true" can improve performance but can also cause
   * SQLExceptions if the results are too big. 
   **/
  public static final String CONNECTION_PROPERTY_USE_FETCH_SIZE_WITH_LONG_COLUMN = "useFetchSizeWithLongColumn";
  public static final String CONNECTION_PROPERTY_USE_FETCH_SIZE_WITH_LONG_COLUMN_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_FETCH_SIZE_WITH_LONG_COLUMN_ACCESSMODE = 15; 
  /** 
  * If the value of this property is "false" then the default setting for
  * Statement.setEscapeProccessing is false.
  @see oracle.jdbc.OracleStatement#setEscapeProcessing(boolean) 
   **/
  public static final String CONNECTION_PROPERTY_PROCESS_ESCAPES = "processEscapes";
  public static final String CONNECTION_PROPERTY_PROCESS_ESCAPES_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_PROCESS_ESCAPES_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", JDBC will use FIXED CHAR semantic when
   * setObject is called with a String argument. By default JDBC uses VARCHAR semantics.
   * The difference is in blank padding. With the default there is no blank padding so,
   * for example, 'a' does not equal 'a ' in a CHAR(4). If true these two will be equal. 
   **/
  public static final String CONNECTION_PROPERTY_FIXED_STRING = "fixedString";
  public static final String CONNECTION_PROPERTY_FIXED_STRING_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_FIXED_STRING_ACCESSMODE = 15; 
  /** 
   * 
   * This property changes the default parameter mapping of a Java String to its
   * Oracle Type. The default mapping is to VARCHAR2 (SQLT_CHR). When this 
   * property is set to true, the String parameter will be defined as ANSI fixed
   * char, CHAR (SQLT_AFC).
   * 

   * This affects the behavior of setString(index, value) where "value" is a 
   * Java String.
   * 

   * The correct way to define a parameter against a CHAR column is to use
   * setObject(index, value, OracleTypes.FIXED_CHAR). This property may be used 
   * as a workaround for applications that can't be fixed and use setString 
   * against CHAR columns.
   **/
  public static final String CONNECTION_PROPERTY_MAP_STRING_PARAMETER_TO_CHAR = "mapStringParameterToCHAR";
  public static final String CONNECTION_PROPERTY_MAP_STRING_PARAMETER_TO_CHAR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_MAP_STRING_PARAMETER_TO_CHAR_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", the default mode for all
   * character data columns will be NCHAR. 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULTNCHAR = "defaultNChar";
  public static final String CONNECTION_PROPERTY_DEFAULTNCHAR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DEFAULTNCHAR_ACCESSMODE = 15;  
  /** 
 
   **/
  public static final String CONNECTION_PROPERTY_RESOURCE_MANAGER_ID = "RessourceManagerId";
  public static final String CONNECTION_PROPERTY_RESOURCE_MANAGER_ID_DEFAULT = "0000";
  public static final byte CONNECTION_PROPERTY_RESOURCE_MANAGER_ID_ACCESSMODE = 15; 
  /** 
   * Disable the method OracleStatement.defineColumnType when equal "true".
   * 
   * When this connection property has the value true, the method defineColumnType is
   * has no effect. This is highly recommended when using the Thin driver, especially
   * when the database character set contains four byte characters that expand to two
   * UCS2 surrogate characters, e.g. AL32UTF8. The method defineColumnType provides no
   * performance benefit (or any other benefit) when used with the 10g Thin driver.
   * This property is provided so that you do not have to remove the calls from your
   * code. This is especially valuable if you use the same code with Thin driver and
   * either the OCI or Server Internal driver. 
   **/
  public static final String CONNECTION_PROPERTY_DISABLE_DEFINECOLUMNTYPE = "disableDefineColumnType";
  public static final String CONNECTION_PROPERTY_DISABLE_DEFINECOLUMNTYPE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DISABLE_DEFINECOLUMNTYPE_ACCESSMODE = 15; 
  /** 
  * Convert NCHAR literals to Unicode literals when equal "true". The default
   * is true. 
   **/
  public static final String CONNECTION_PROPERTY_CONVERT_NCHAR_LITERALS = "oracle.jdbc.convertNcharLiterals";
  public static final String CONNECTION_PROPERTY_CONVERT_NCHAR_LITERALS_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_CONVERT_NCHAR_LITERALS_ACCESSMODE = 15; 
  /** 
   * Alters the auto-commit behavior of the driver.   By default the driver
   * complies with JDBC specification.   User can choose to alter the behavior 
   * by changing the value of this flag.
   *
   * 
Oracle JDBC 12.1 drivers comply with JDBC specification 4.1 and will:
   * 
   * 
-  throw SQLException when {@link #commit()} or {@link #rollback()} is invoked when auto-commit is true.
   * 
- issue an implicit commit of the local transaction when {@link #setAutoCommit} is called and the mode is changed from false to true.
   * 
   *
   * 
Because the standard behavior may break existing applications, this 
   * flag is provided as a convenience and can be set to false.
   * Most applications may never need to set this flag. Users are encouraged to 
   * modify their applications to support the specification instead of using 
   * this flag.
   * 
   *
   * @see  #commit()
   * @see  #rollback()
   * @see  #setAutoCommit(boolean)
   *
   * @since 12.1
   *
   * @deprecated It's recommended to use {@link oracle.jdbc.OracleConnection#CONNECTION_PROPERTY_DISABLED_BUG_FIXES}
   * system property instead. 
   * The corresponding bug number for this connection property is
   * {@link oracle.jdbc.SwitchableBugFix.BugNumber#BUG_11891661}.
 
   **/
  public static final String CONNECTION_PROPERTY_AUTO_COMMIT_SPEC_COMPLIANT = "oracle.jdbc.autoCommitSpecCompliant";
  public static final String CONNECTION_PROPERTY_AUTO_COMMIT_SPEC_COMPLIANT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_AUTO_COMMIT_SPEC_COMPLIANT_ACCESSMODE = 15; 
  /** 
   * Ensures the driver is in strict compliance with the JDBC specification.
   * When "false" (the default), previous Oracle specific non-standard 
   * deviations from the standard are maintained. 
   * When "true", this flag will override the behavior of all other 
   * compatibility flags.
   * For complete backwards compatibility with previous drivers which
   * differed from the JDBC standards, you should leave this flag set
   * to "false". If you require compliance with the JDBC standard, then
   " set to "true"; this ensures ALL non-standard behavior is removed
   * from the driver. Note that backwards compatibility and standards 
   * compliance is often contradictory and you can't have both.
   *
   *
   * @since 12.2
 
   **/
  public static final String CONNECTION_PROPERTY_JDBC_STANDARD_BEHAVIOR = "oracle.jdbc.JDBCStandardBehavior";
  public static final String CONNECTION_PROPERTY_JDBC_STANDARD_BEHAVIOR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_JDBC_STANDARD_BEHAVIOR_ACCESSMODE = 15; 
  /** 
   * If the value of this property is "true", JDBC uses strict compliance for
   * some edge cases. In general Oracle's JDBC drivers will allow some operations
   * that are not permitted in the strict interpretation of J2EE 1.3. Setting this
   * property to true will cause those cases to throw SQLExceptions. There are some
   * other edge cases where Oracle's JDBC drivers have slightly different behavior
   * than defined in J2EE 1.3. This results from Oracle having defined the behavior
   * prior to the J2EE 1.3 specification and the resultant need for compatibility
   * with existing customer code. Setting this property will result in full J2EE 1.3
   * compliance at the cost of incompatibility with some customer code. Can be either
   * a system property or a connection property.
   * 
The driver would behave differently in the following way when the property is set.
   * 
   * 
- Throws an exception when executeQuery is invoked on a DML
   * 
- Throws an exception when executeUpdate is invoked on a Query
   * 
- MetaData.getScale returns 0 for unconstrained NUMBER column
   * 
- getObject on a NUMBER column with precision 0 and scale 
   *     unconstrained returns Double
   * 
- ResultSetMetaData.getColumnType on a NUMBER column with precision 
   *     0 and scale unconstrained returns FLOAT
   * 
- ResultSetMetaData.getColumnClassName on a NUMBER column with 
   *     precision 0 and scale unconstrained returns java.lang.Double
   * 
- getObject on a TIMESTAMP column returns an object of type 
   *     java.sql.Timestamp
   * 
- ResultSetMetaData.getColumnClassName on a TIMESTAMP column returns 
   *     java.sql.Timestamp
   * 
   * 
   * 
The default value of this property is true if dms.jar
   * is present in the classpath; false otherwise.
   *
   * @deprecated This property could be removed in the future and the default 
   * will be true.   So if this property is used as workaround 
   * to turn off compliant behavior, consider changing the application.
 
   **/
  public static final String CONNECTION_PROPERTY_J2EE13_COMPLIANT = "oracle.jdbc.J2EE13Compliant";
  public static final String CONNECTION_PROPERTY_J2EE13_COMPLIANT_DEFAULT = oracle.jdbc.internal.OracleConnection.isDMSJarPresent() ? "true" : "false";
  public static final byte CONNECTION_PROPERTY_J2EE13_COMPLIANT_ACCESSMODE = 15; 
  /** 
   * Override the default DMS parent name. This property should only be set 
   * if it is absolutely necessary to do so. For most cases, the default name
   * should be used.
 
   **/
  public static final String CONNECTION_PROPERTY_DMS_PARENT_NAME = "DMSName";
  public static final String CONNECTION_PROPERTY_DMS_PARENT_NAME_DEFAULT = "Driver";
  public static final byte CONNECTION_PROPERTY_DMS_PARENT_NAME_ACCESSMODE = 1; 
  /** 
   * Override the default DMS parent type. This property should only be set 
   * if it is absolutely necessary to do so. For most cases, the default type
   * should be used.
 
   **/
  public static final String CONNECTION_PROPERTY_DMS_PARENT_TYPE = "DMSType";
  public static final String CONNECTION_PROPERTY_DMS_PARENT_TYPE_DEFAULT = "JDBC_Driver";
  public static final byte CONNECTION_PROPERTY_DMS_PARENT_TYPE_ACCESSMODE = 1; 
  /** 
  * Property which enables/disables DMS Statement metrics
 
   **/
  public static final String CONNECTION_PROPERTY_DMS_STMT_METRICS = "oracle.jdbc.DMSStatementMetrics";
  public static final String CONNECTION_PROPERTY_DMS_STMT_METRICS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DMS_STMT_METRICS_ACCESSMODE = 1; 
  /** 
  * This property no longer has any effect.
  * @deprecated
 
   **/
  public static final String CONNECTION_PROPERTY_DMS_STMT_CACHING_METRICS = "oracle.jdbc.DMSStatementCachingMetrics";
  public static final String CONNECTION_PROPERTY_DMS_STMT_CACHING_METRICS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DMS_STMT_CACHING_METRICS_ACCESSMODE = 1; 
  /** 
   * This connection property lets you define how the driver will map
   * SQL DATE values in the database to Java types. Since Oracle SQL
   * DATE includes a time component and java.sql.Date does not, mapping
   * DATE to java.sql.Date looses information. It is more appropriate to
   * map DATE to java.sql.Timestamp and that is the default behavior.
   * 
   * The 9i and 10g drivers mistakenly mapped DATE to java.sql.Date by
   * default. Setting this property to false will cause the driver to 
   * map SQL DATE to java.util.Date with the corresponding loss of time
   * information in each DATE value. This is for backwards compatibility 
   * only.  
   **/
  public static final String CONNECTION_PROPERTY_MAP_DATE_TO_TIMESTAMP = "oracle.jdbc.mapDateToTimestamp";
  public static final String CONNECTION_PROPERTY_MAP_DATE_TO_TIMESTAMP_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_MAP_DATE_TO_TIMESTAMP_ACCESSMODE = 15; 
  /** 
   * If true, the statement data buffers are cached on a per thread basis.
   * If false, the data buffers are cached on a per connection basis. These
   * buffers can be quite large. It is important that the number of them be
   * minimized.
   *
   * In most cases you should use the per connection cache. However if your app
   * has many more idle connections than active connections at any given moment
   * then using the thread local cache may reduce the total JDBC driver memory 
   * footprint. If you are not having a problem with Java heap size, leave this 
   * alone.  
   **/
  public static final String CONNECTION_PROPERTY_USE_THREADLOCAL_BUFFER_CACHE = "oracle.jdbc.useThreadLocalBufferCache";
  public static final String CONNECTION_PROPERTY_USE_THREADLOCAL_BUFFER_CACHE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_THREADLOCAL_BUFFER_CACHE_ACCESSMODE = 15; 
  /** 
   * The value passed to the server for the OCI_ATTR_DRIVER_NAME. This property
   * is supported with both the OCI and Thin drivers. The attribute aids in
   * diagnosability. In most cases you should not need to set it. The value is
   * limited to a maximum of 8 printable 7-bit ASCII characters. The default
   * value depends on which driver is used. The default value for the THIN
   * driver is "jdbcthin" and the default value for the OCI driver is "jdbcoci". 
   **/
  public static final String CONNECTION_PROPERTY_DRIVER_NAME_ATTRIBUTE = "oracle.jdbc.driverNameAttribute";
  public static final String CONNECTION_PROPERTY_DRIVER_NAME_ATTRIBUTE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DRIVER_NAME_ATTRIBUTE_ACCESSMODE = 15; 
  /** 
   * The log base 2 of the size of the largest internal char or byte data
   * buffer that the driver should cache. The default is 30 which means the
   * largest cached buffer is 1 giga(byte/char). Values greater than 30 are
   * treated as the actual buffer size. Values less than 12 will effectively
   * disable the buffer cache. Rather than setting the value less than 16, you
   * should increase the amount of heap available to your application by
   * setting -Xmx and -Xms.
   * 
   * The driver uses char and byte buffers to read BLOB, CLOB, LONG, and LONG
   * RAW data. The type 2 (OCI) driver and the server side internal driver also
   * use these buffers to store bind values.
   * 
   * These buffers can be quite large and are cached. If some operations create
   * particularly large buffers, the driver will attempt to cache those large
   * buffers. This may possibly reduce performance. This property can be set to
   * prevent these large buffers from being cached. The appropriate value 
   * depends on the heap size, number of connections open, number of statements
   * open at once, and fraction of the heap that can be allocated to JDBC. A
   * reasonable starting point for a middle-tier application server might be 21
   * (2MB).
   * 
   * 
   * Prior to the 12.1.0.1 release, these buffers had been used to retrieve 
   * query results. In the current release, this is no longer the case.
   * 
   * @see #CONNECTION_PROPERTY_USE_THREADLOCAL_BUFFER_CACHE  
   **/
  public static final String CONNECTION_PROPERTY_MAX_CACHED_BUFFER_SIZE = "oracle.jdbc.maxCachedBufferSize";
  public static final String CONNECTION_PROPERTY_MAX_CACHED_BUFFER_SIZE_DEFAULT = "30";
  public static final byte CONNECTION_PROPERTY_MAX_CACHED_BUFFER_SIZE_ACCESSMODE = 15; 
  /** 
   * The maximum number of statements that will be stored in this connection's
   * statement cache. The default is 0 which disables the statement cache.
   * If set to a value greater than 0, the implicit statement cache is 
   * enabled. Calls to setStatementCacheSize and setImplicitCachingEnabled
   * override this.  
   **/
  public static final String CONNECTION_PROPERTY_IMPLICIT_STATEMENT_CACHE_SIZE = "oracle.jdbc.implicitStatementCacheSize";
  public static final String CONNECTION_PROPERTY_IMPLICIT_STATEMENT_CACHE_SIZE_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_IMPLICIT_STATEMENT_CACHE_SIZE_ACCESSMODE = 15; 
  /** 
   * Previous releases allowed the value of 0L to be set for the
   * position parameter of Blob.setBinaryStream and
   * Clob.setAsciiStream and setCharacterStream which is not
   * correct in the specification. It had the same effect as
   * setting 1L. This was a legacy of the orginal Oracle proprietary 
   * APiS.  If this switch is set false the 
   * old incorrect behavior is retained for compatibility  
   **/
  public static final String CONNECTION_PROPERTY_LOB_STREAM_POS_STANDARD_COMPLIANT = "oracle.jdbc.LobStreamPosStandardCompliant";
  public static final String CONNECTION_PROPERTY_LOB_STREAM_POS_STANDARD_COMPLIANT_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_LOB_STREAM_POS_STANDARD_COMPLIANT_ACCESSMODE = 15; 
  /** 
   * The Oracle JDBC has been doing quick ASCII conversion (use only 
   * the low bytes) in different areas for the sake of performance.  
   * However, when the input characters are not pure ASCII,
   * they need to be converted to the corresponding ASCII 
   * replacement characters.  To accomodate this need, Oracle JDBC 
   * implements this flag.  
   * This flag is default to false, in which no characters will be 
   * converted, quick ASCII conversion is done for good performance.
   * When this flag is set to true, Oracle JDBC will check for 
   * non-ASCII characters and convert them with replacement characters.
   * This flag controls all areas where ASCII conversion is done. 
   **/
  public static final String CONNECTION_PROPERTY_STRICT_ASCII_CONVERSION = "oracle.jdbc.strictASCIIConversion";
  public static final String CONNECTION_PROPERTY_STRICT_ASCII_CONVERSION_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_STRICT_ASCII_CONVERSION_ACCESSMODE = 15;  
  /** 
   * Specify the connection class name for Database Resident Connection Pool 
   * (DRCP).   Connection class must be provided to enable DRCP.  Along with
   * the connection class the URL must be altered to include 
   * (SERVER=POOLED) in long URL form.   In thin the short URL form
   * should be modified to append :POOLED.
    
   **/
  public static final String CONNECTION_PROPERTY_CONNECTION_CLASS = "oracle.jdbc.DRCPConnectionClass";
  public static final String CONNECTION_PROPERTY_CONNECTION_CLASS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CONNECTION_CLASS_ACCESSMODE = 15; 
  /** 
   * This is the tag name that for Database Resident Connection Pool (DRCP).
   * Tag name is provided during connect time.   The server will make an attempt
   * to obtain a server process of the same tag.  If it succeeds the next
   * {@link #attachServerConnection()} will return true.
    
   **/
  public static final String CONNECTION_PROPERTY_DRCP_TAG_NAME = "oracle.jdbc.DRCPTagName";
  public static final String CONNECTION_PROPERTY_DRCP_TAG_NAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DRCP_TAG_NAME_ACCESSMODE = 1; 
  /** 
   * Specify the connection purity for a Database Resident Connection Pool 
   * (DRCP) connection.   
   * Session purity specifies whether the application wants a "brand new" 
   * session or whether the application logic is set up to reuse a "pooled" 
   * session.
   * There are two possible values, NEW or SELF.
   * The default is SELF.
    
   **/
  public static final String CONNECTION_PROPERTY_CONNECTION_PURITY = "oracle.jdbc.DRCPConnectionPurity";
  public static final String CONNECTION_PROPERTY_CONNECTION_PURITY_DEFAULT = "SELF";
  public static final byte CONNECTION_PROPERTY_CONNECTION_PURITY_ACCESSMODE = 1; 
  /** 
   * Enables multiple tagging feature in DRCP. Default value is false.
   * A valid tag has to be a key value pair separated by = character.
   * Multiple tags are separated by ; character.
   * Value of key and value can not be null or empty.   
   * This property is valid only for thin driver.
    
   **/
  public static final String CONNECTION_PROPERTY_USE_DRCP_MULTIPLE_TAG = "oracle.jdbc.UseDRCPMultipletag";
  public static final String CONNECTION_PROPERTY_USE_DRCP_MULTIPLE_TAG_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_DRCP_MULTIPLE_TAG_ACCESSMODE = 1; 
  /** 
   * This is PL/SQL "fix-up" callback name which is provided by the application, and  
   * it is used to transform a session checked out from the pool to the desired state 
   * requested by the application.
   * "fix-up" callback can provide performance improvements to applications by running 
   * the "session state fix-up" logic on the server, thereby eliminating application  
   * round-trips to the database to run the "fix-up" logic.
   * This is an optional configuration.
   * This property is valid only for thin driver.
    
   **/
  public static final String CONNECTION_PROPERTY_DRCP_PLSQL_CALLBACK = "oracle.jdbc.DRCPPLSQLCallback";
  public static final String CONNECTION_PROPERTY_DRCP_PLSQL_CALLBACK_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DRCP_PLSQL_CALLBACK_ACCESSMODE = 1; 
  /** 
   * 
Use this to configure the session parameters that will modify the connection to the desired state 
   * once it is established. Parameters are separated by a semicolon (;) character, and within each 
   * parameter, the key and value are separated by an equals sign (=) character. 
   * Additionally, ensure that only session-related parameters are specified with this option.
   * 
Example : NLS_LANGUAGE=English;NLS_DATE_FORMAT=MM-DD-YYYY
    
   **/
  public static final String CONNECTION_PROPERTY_SESSION_FIXUP_PARAMS = "oracle.jdbc.sessionFixUpParams";
  public static final String CONNECTION_PROPERTY_SESSION_FIXUP_PARAMS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SESSION_FIXUP_PARAMS_ACCESSMODE = 15;  
  /** 
   * 
When a hostname resolves to multiple addresses, the JDBC thin driver
   * retrieves an array of addresses by calling "InetAddress.getAllByName()"
   * and attempts to connect to first address in the array. If the
   * connection fails, it tries to connect to the second address and so on.
   * 
By default, because "InetAddress.getAllByName()" always returns
   * the addresses in the same order, the first connection attempt will always
   * be made to the same IP address. This defeats the goal of SCAN (Single
   * Client Access Name which is a 11.2 RAC feature). In order to force the
   * the driver to make the first connection attempt to a different IP address
   * each time, you can set this property to "true". The default value is "false".
   * 
When this connection is set to "true", the array of IP addresses that
   * a hostname resolves to, will be rotated by one for each new JDBC connection.
   * As a result, DNS load balancing will happen properly. 
   * 
This is a JDBC thin driver property only.
   **/
  public static final String CONNECTION_PROPERTY_THIN_FORCE_DNS_LOAD_BALANCING = "oracle.jdbc.thinForceDNSLoadBalancing";
  public static final String CONNECTION_PROPERTY_THIN_FORCE_DNS_LOAD_BALANCING_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_THIN_FORCE_DNS_LOAD_BALANCING_ACCESSMODE = 15; 
  /** 
   * 
By default the JDBC thin driver counts the temp LOB references and only
   * closes them on the server when this count is down to zero. For example it 
   * may happen that two instances of CLOB (or OracleClob) A and B point to the same
   * temp lob. At this point thin's temp lob ref count is 2. If you close A, no
   * roundtrip will be issued because B is still holding on the temp LOB (counts is 1). Thin will
   * send a close to the database only when B is also closed.
   * 
The JDBC Thin driver will tell the server that it's counting temp lob references so
   * that the server's temp lob ref count is always 1 as long as a close hasn't been issued.
   * 
   * 
If you're running into ORA-22922: NONEXISTENT LOB VALUE errors in your application
   * you should make sure that you haven't accidentally set this property to false.
   * 
This property applies to the JDBC Thin driver only. It's new in 11.2.0.3.
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_TEMP_LOB_REF_COUNT = "oracle.jdbc.enableTempLobRefCnt";
  public static final String CONNECTION_PROPERTY_ENABLE_TEMP_LOB_REF_COUNT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_TEMP_LOB_REF_COUNT_ACCESSMODE = 15; 
  /** 
   * Enables TCP keep alive on the network connection.
   * 
   * Valid values for this property are "true" or "false". If this property is
   * not set, the default value is "false".
   * 
   * When this property is set to "true", a TCP keep alive probe will be
   * initiated when the network connection has been idle for some period of
   * time.
   * 
   * The behavior of the keep alive probe can be configured using additional
   * connection properties:
   * 
   * 
- {@link #CONNECTION_PROPERTY_TCP_KEEPIDLE}
   * 
- {@link #CONNECTION_PROPERTY_TCP_KEEPINTERVAL}
   * 
- {@link #CONNECTION_PROPERTY_TCP_KEEPCOUNT}
   * 
   * @see java.net.StandardSocketOptions#SO_KEEPALIVE
   *  
   **/
  public static final String CONNECTION_PROPERTY_NET_KEEPALIVE = "oracle.net.keepAlive";
  public static final String CONNECTION_PROPERTY_NET_KEEPALIVE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_NET_KEEPALIVE_ACCESSMODE = 15; 
  /** 
   * 
Enables Server Name Indication (SNI) to avoid the TLS handshake with 
   * the listener. SNI information is passed as part of the ClientHello during 
   * the TLS handshake. The listener uses this information to hand-off the 
   * connection to the appropriate server process therefore avoiding the TLS 
   * handshake that would otherwise happen with the listener.
   * 
The default value is "false". To enable SNI, set this property to "true".
   * 
This property can also be configured via the connection URL using the 
   * DESCRIPTION parameter USE_SNI. The value set 
   * using the URL has higher precedence over the value set using connection 
   * property.
   * @see #CONNECTION_PROPERTY_NET_SNI_IGNORE_LIST 
 
   **/
  public static final String CONNECTION_PROPERTY_NET_USE_SNI = "oracle.net.useSNI";
  public static final String CONNECTION_PROPERTY_NET_USE_SNI_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_NET_USE_SNI_ACCESSMODE = 15; 
  /** 
   * 
The Server Name Indication (SNI) value is created using the 
   * SERVICE_NAME, SERVER, INSTANCE_NAME and COLOCATION_TAG parameters found 
   * under the CONNECT_DATA section of the connect string.
   * 
The CONNECT_DATA section may contain other parameters that could 
   * affect the selection of the server process; for example, if the sharding 
   * key is provided. Therefore, if the CONNECT_DATA section contains any 
   * other parameter than the 4 mentioned above, then SNI is disabled to avoid 
   * redirecting to the wrong handler.
   * 
Some parameters are ignored because they don't have any impact on the
   * selection of the server process, and so won't turn off SNI. By default 
   * CONNECTION_ID_PREFIX, CONNECTION_ID, POOL_PURITY, POOL_CONNECTION_CLASS, 
   * USE_TCP_FAST_OPEN and CID are ignored. More parameters of the 
   * CONNECT_DATA can be ignored using this property. The value is a 
   * comma-separated list of the CONNECT_DATA parameter names.
   * 
If SOURCE_ROUTE is ON, then SNI is always disabled.
   * @see #CONNECTION_PROPERTY_NET_USE_SNI
 
   **/
  public static final String CONNECTION_PROPERTY_NET_SNI_IGNORE_LIST = "oracle.net.SNIIgnoreList";
  public static final String CONNECTION_PROPERTY_NET_SNI_IGNORE_LIST_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_NET_SNI_IGNORE_LIST_ACCESSMODE = 15; 
  /** 
   * 
This is an ADB-S specific property for clients connecting from within 
   * OCI Cloud network. Please refer to ADB-S documentation for more information.
   * @since 23ai
 
   **/
  public static final String CONNECTION_PROPERTY_NET_USE_TCP_FAST_OPEN = "oracle.net.useTcpFastOpen";
  public static final String CONNECTION_PROPERTY_NET_USE_TCP_FAST_OPEN_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_NET_USE_TCP_FAST_OPEN_ACCESSMODE = 15; 
  /** 
   * 
The string identifier for the translation
        profile or the translator to be used. Presence of this property activates the
        support for SQL Translation and is thus mandatory if SQL Translation feature is required.
   **/
  public static final String CONNECTION_PROPERTY_SQL_TRANSLATION_PROFILE = "oracle.jdbc.sqlTranslationProfile";
  public static final String CONNECTION_PROPERTY_SQL_TRANSLATION_PROFILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SQL_TRANSLATION_PROFILE_ACCESSMODE = 3; 
  /** 
   * 
Path to an xml file which provides
      the Error code translations for those errors which occur if a connection can not be established
      to the server.
      The XML file is to be provided by the user and must conform to the following DTD. This is an
      optional property and if not provided then untranslated exceptions with oracle error codes are thrown. This property only affects the exceptions which happen when a connection to the server cannot be established. Once connection is established the translation happens on the server bypassing the local error translation file.

<!DOCTYPE LocalTranslationProfile[
<!ELEMENT LocalTranslationProfile (Exception+)>
<!ELEMENT Exception (ORAError, ErrorCode, SQLState )>
<!ELEMENT ORAError (#PCDATA)>
<!ELEMENT ErrorCode (#PCDATA)>
<!ELEMENT SQLState (#PCDATA)>
]>

      </pre>


   **/
  public static final String CONNECTION_PROPERTY_SQL_ERROR_TRANSLATION_FILE = "oracle.jdbc.sqlErrorTranslationFile";
  public static final String CONNECTION_PROPERTY_SQL_ERROR_TRANSLATION_FILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SQL_ERROR_TRANSLATION_FILE_ACCESSMODE = 3;          
  /** 
   * This property allows connection creation to a read-only instance if the value is set to true. 
   * It is applicable for sharded database only. The default value is false.
   * This property is only supported by Thin driver.
   *
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_READONLY_INSTANCE_ALLOWED = "oracle.jdbc.readOnlyInstanceAllowed";
  public static final String CONNECTION_PROPERTY_READONLY_INSTANCE_ALLOWED_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_READONLY_INSTANCE_ALLOWED_ACCESSMODE = 15;   
  /** 
   * This property is ignored in 18c.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_RESULTSET_CACHE = "oracle.jdbc.enableResultSetCache";
  public static final String CONNECTION_PROPERTY_ENABLE_RESULTSET_CACHE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_RESULTSET_CACHE_ACCESSMODE = 15; 
  /** 
   * This property is introduced in 18c.
   * If set to false, this property turns off the ResultSet Cache feature of the JDBC Thin driver.
   * To use this feature the server-side initialization parameter CLIENT_RESULT_CACHE_SIZE also has
   * to be configured to a non zero value. This value controls how much memory the Thin driver can use
   * for its cache.
   * 
   * A read-only or read-mostly table can then be annoted (RESULT_CACHE(MODE FORCE) for example)
   * for its data to be cached on the driver. You can also use a SQL hint /*+result_cache */
   * to identify queries that are worth being cached.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_QUERY_RESULT_CACHE = "oracle.jdbc.enableQueryResultCache";
  public static final String CONNECTION_PROPERTY_ENABLE_QUERY_RESULT_CACHE_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_QUERY_RESULT_CACHE_ACCESSMODE = 15; 
  /** 
   * If set to true, use the old, pre 12.1.0.2.0, updateable ResultSet behavior.
   * If false use JDBC standard compliant updateable ResultSet behavior.
 
   **/
  public static final String CONNECTION_PROPERTY_BACKWARD_COMPATIBLE_UPDATEABLE_RESULTSET = "oracle.jdbc.backwardCompatibileUpdateableResultSet";
  public static final String CONNECTION_PROPERTY_BACKWARD_COMPATIBLE_UPDATEABLE_RESULTSET_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_BACKWARD_COMPATIBLE_UPDATEABLE_RESULTSET_ACCESSMODE = 15; 
  /** 
   * 
 Minimum authentication protocol required by the client. The term VERSION in the parameter name refers to the version of the authentication protocol, not the Oracle Database release.
   *
   * If the database doesn't meet or exceed the value defined by this parameter, then JDBC throws ORA-17292 : No valid logon method found.
   * 
   * Allowed values :
   *       
   * 
   *   
-  12a
   *   
-  12 
   *   
-  11 
   *   
-  10 
   *   
-  8 
   * 
   *
   * Thus if client sets the allowedLogonVersion to be 10. Then connection would
   * fail if the database server doesn support authentication protocol 10 or above
   * ie 11, 12 and 12a. And similarly for other values. Default logon version for
   * JDBC thin is 8.
   * 
   * These values are JDBC thin counterpart of SQLNET.ALLOWED_LOGON_VERSION_CLIENT.
   * For more information on the logon values and authentication protocol, 
   * read the documenation for SQLNET.ALLOWED_LOGON_VERSION_CLIENT and
   * SQLNET.ALLOWED_LOGON_VERSION_SERVER.
    
   **/
  public static final String CONNECTION_PROPERTY_ALLOWED_LOGON_VERSION = "oracle.jdbc.allowedLogonVersion";
  public static final String CONNECTION_PROPERTY_ALLOWED_LOGON_VERSION_DEFAULT = "8";
  public static final byte CONNECTION_PROPERTY_ALLOWED_LOGON_VERSION_ACCESSMODE = 15; 
  /** 
   * This connection property lets you define a default commit option
   * that will be used when calling connection.commit();. This
   * can be useful in cases where you don't want to rewrite your application to
   * specify a commit option at the call level, such as 
   * connection.commit(myCommitOption);.
   * 
   * This property can be set at the system level (all connections will use it) or
   * at the connection level (only that particular connection will be affected).
   * A call level commit option will override the default value.
   * 
   * Note that by default, if you don't set this property, the commit option is 
   * '0', zero, and the Oracle server's defaults apply. These defaults are: 
   * IMMEDIATE and WAIT (IO operations are done immediately and the call waits
   * until the operation has completed to return).
 
   **/
  public static final String CONNECTION_PROPERTY_COMMIT_OPTION = "oracle.jdbc.commitOption";
  public static final String CONNECTION_PROPERTY_COMMIT_OPTION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_COMMIT_OPTION_ACCESSMODE = 15;      
  /** 
   * 
To specify the amount of time in seconds that information about the down state of server hosts is kept in JDBC-Thin driver's cache. This property is specific to the JDBC-Thin Driver.
   * 
The driver discovers the down state of server hosts when attempting connections. 
   * When a connection attempt fails, the information about the down state of the server host is added to the driver's cache. 
   * Subsequent connection attempts moves the down hosts to the end of the address list, thereby reducing the priority of such hosts. 
   * When the time specified by the oracle.net.DOWN_HOSTS_TIMEOUT parameter has passed, the host is purged from the driver's cache, and its priority in the address list is restored.
   * 
Default value is 600 seconds.
 
   **/
  public static final String CONNECTION_PROPERTY_DOWN_HOSTS_TIMEOUT = "oracle.net.DOWN_HOSTS_TIMEOUT";
  public static final String CONNECTION_PROPERTY_DOWN_HOSTS_TIMEOUT_DEFAULT = "600";
  public static final byte CONNECTION_PROPERTY_DOWN_HOSTS_TIMEOUT_ACCESSMODE = 15; 
  /** 
   * Specifies whether driver High Availability (HA) or FAN (Fast Application
   * Notification) is enabled.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN and JDBC-OCI drivers
   * only.
   * 
   * By default, if you don't set this property,
   * FAN/HA is enabled.
   * The primary use of this property is to disable driver HA/FAN.
   * 
   * Note that this property is automatically switched off when Bequeath protocol is used.
 
   **/
  public static final String CONNECTION_PROPERTY_FAN_ENABLED = "oracle.jdbc.fanEnabled";
  public static final String CONNECTION_PROPERTY_FAN_ENABLED_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_FAN_ENABLED_ACCESSMODE = 15; 
  /** 
   * This property is used for setting the TNS Admin path. When using 
   * TNS Names with JDBC Thin driver this property has to be set to the 
   * directory which contains the tnsnames.ora file.
   * 
   * This property can also be used to set the path of a properties file. When
   * set, the driver will look for a file named ojdbc.properties
   * in the TNS Admin directory.
   * @see #CONNECTION_PROPERTY_CONFIG_FILE
 
   **/
  public static final String CONNECTION_PROPERTY_TNS_ADMIN = "oracle.net.tns_admin";
  public static final String CONNECTION_PROPERTY_TNS_ADMIN_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_TNS_ADMIN_ACCESSMODE = 7; 
  /** 
   * 
Enables compression of the protocol data sent over network.
   * The value can be either "on" , "off" or "auto".
   * The default value is "off".
 
   **/
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION = "oracle.net.networkCompression";
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION_DEFAULT = "off";
  public static final byte CONNECTION_PROPERTY_NETWORK_COMPRESSION_ACCESSMODE = 15; 
  /** 
   * The value is a comma separated list of supported levels
   * in the user preference order surrounded by brackets. The
   * value is used at the time of negotiation to check what
   * levels can be supported by both the client and the server
   * and decide on the first  common match. Thin driver only 
   * supports ("high") compression level and it is
   * the default value, so setting this property is optional.
   * Please note that the server should be configured to support
   * high compression level. By default the server
   * supports only low compression level. 
 
   **/
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION_LEVELS = "oracle.net.networkCompressionLevels";
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION_LEVELS_DEFAULT = "(high)";
  public static final byte CONNECTION_PROPERTY_NETWORK_COMPRESSION_LEVELS_ACCESSMODE = 15; 
  /** 
   * Minimum size of data in packet required to perform compression.
   * Packet compression will not be done if size of data to be sent
   * in the packet is less than specified value. The default is "1024". 
   * The value cannot be less than "200". The value is in bytes.
 
   **/
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION_THRESHOLD = "oracle.net.networkCompressionThreshold";
  public static final String CONNECTION_PROPERTY_NETWORK_COMPRESSION_THRESHOLD_DEFAULT = "1024";
  public static final byte CONNECTION_PROPERTY_NETWORK_COMPRESSION_THRESHOLD_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the path of a connection properties file. Oracle JDBC reads 
   * connection properties from this file each time it opens a connection. File 
   * reading is disabled by setting this property to an empty string.
   * 

   * There are a small number of connection properties which may not be 
   * configured in a file. The ACCESSMODE of these 
   * properties will not include {@link #ACCESSMODE_FILEPROP}.
   * 
   * File Syntax
   * 
   * A connection properties file contains "name=value" pairs that assign a 
   * value to the name of a connection property. The values may reference system
   * properties or environment variables. This syntax is shown in the example
   * below.
   * 

   * oracle.jdbc.database=${DB_CONNECTION_STRING}
   * oracle.jdbc.user=${DB_USER}
   * oracle.jdbc.password=${DB_PASSWORD}
   * oracle.jdbc.loginTimeout=30
   * 

   * The basic "name=value" syntax is specified by 
   * {@linkplain java.util.Properties#load(java.io.Reader) java.util.Properties}.
   * Oracle JDBC extends the syntax as follows:
   * 

-    * "${name}" is evaluated as a system property or environment variable 
   * of the given name. A system property takes precedence over an
   * environment variable. A {@code SQLException} is thrown if no value is 
   * defined for the name.
   * 
-    * "?" is evaluated as the ORACLE_HOME environment variable. A 
   * {@code SQLException} is thrown if ORACLE_HOME is not defined.
   *  
-    * "${/}" is evaluated as the OS dependent file path separator. The value
   * "path${/}to${/}" is evaluated as "path/to/" on Linux, and "path\to\" on 
   * Windows.
   * 
   * 
   * Two consecutive "$" or "?" characters will escape these evaluations.
   * 
   * Default File Location
   * 
   * If this property is not configured, the default behavior is to
   * check for a file named "ojdbc.properties" in a directory defined as 
   * TNS_ADMIN. A definition for TNS_ADMIN is resolved in the
   * following order:

-    * A URL parameter, as in: "jdbc:oracle:thin:@dbname?TNS_ADMIN=..."
   * 
-    * The {@linkplain #CONNECTION_PROPERTY_TNS_ADMIN oracle.net.tns_admin} 
   * connection property
   * 
-    * A JVM system property named "TNS_ADMIN"
   * 
-    * An environment variable named "TNS_ADMIN"
   * 
   * 

   * In addition to the "ojdbc.properties" file, Oracle JDBC will also
   * recorgnize a file named ojdbc_alias.properties,
   * where alias matches the section of a JDBC URL following
   * the "@" symbol. For example, if the JDBC URL is "jdbc:oracle:thin:@dbname",
   * then a file named "ojdbc_dbname.properties" will be recognized. A property
   * defined in the ojdbc_alias.properties file will override any
   * definition of that property in the ojdbc.properties file. This mechanism
   * allows certain connection properties to be configured only when connecting
   * to a specific alias of a tnsnames.ora file.
   * 

   * Setting up a connection properties file for the default behavior is 
   * completely optional. If TNS_ADMIN is not defined, or it does not 
   * contain a connection properties file, then a connection will be opened
   * using any connection properties defined elsewhere.
   * 
   * Overriding the Default File Location
   * 
   * The default behavior is overridden by configuring this property with the
   * path of a connection properties file. The path may be expressed with OS
   * dependent separators: 
   * 

   * oracle.jdbc.config.file=/path/to/connection.properties
   * The path may also be expressed using a platform neutral file URI:
   * 
   * oracle.jdbc.config.file=file:///path/to/connection.properties
   * 

   * Multiple files may be expressed as a comma separated list of paths:
   * 
   * oracle.jdbc.config.file=file:///path/to/common.properties,file:///path/to/more.properties
   * 
   * Higher precedence is given to files appearing at later positions in the
   * list. In the example seen above, a connection property defined in "more.properties" would 
   * override a definition appearing in "common.properties". The list
   * may also contain the value "default", which will be resolved as the
   * default location.
   * 
   * Precedence
   * 
   * An order of precedence is applied when connection properties are defined 
   * by multiple sources. A property's value will always be resolved by the 
   * source which has the highest precedence. The sources of connection 
   * properties, ranked from highest to lowest precedence are:
   * 
   * 
   * 
- Properties set in the {@linkplain OracleDriver connection URL}
   * 
- Properties configured by calling a method of OracleDataSource, DriverManager, etc.
   * 
- Properties retrieved by an {@link oracle.jdbc.spi.OracleConfigurationProvider}
   * 
- The jar-internal properties file: defaultConnectionProperties.properties in the oracle.jdbc package
   * 
- Java system properties
   * 
- A default properties file, or one configured as oracle.jdbc.config.file
   * 
- The default value of a property, as specified by the CONNECTION_PROPERTY_{name}_DEFAULT constants
   * 
   * 
   * @see java.util.Properties#load(java.io.Reader)
   * @see #ACCESSMODE_FILEPROP
 
   **/
  public static final String CONNECTION_PROPERTY_CONFIG_FILE = "oracle.jdbc.config.file";
  public static final String CONNECTION_PROPERTY_CONFIG_FILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CONFIG_FILE_ACCESSMODE = 3; 
  /** 
   * This connection property is used to configure the username of the webserver, when the JDBC Thin driver 
   * is configured to connect to a webserver using the Secure Websocket protocol (WSS).
   * The webserver acts as a reverse proxy for the Oracle Database.
   * The default value of this property is null.
   *
   * @see #CONNECTION_PROPERTY_WEBSOCKET_PASSWORD
 
   **/
  public static final String CONNECTION_PROPERTY_WEBSOCKET_USER = "oracle.net.websocketUser";
  public static final String CONNECTION_PROPERTY_WEBSOCKET_USER_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_WEBSOCKET_USER_ACCESSMODE = 15; 
  /** 
   * This connection property is used to configure the password of the webserver, when the JDBC Thin driver 
   * is configured to connect to a webserver using the Secure Websocket protocol (WSS).
   * The webserver acts as a reverse proxy for the Oracle Database.
   * The default value of this property is null.
   *
   * @see #CONNECTION_PROPERTY_WEBSOCKET_USER
 
   **/
  public static final String CONNECTION_PROPERTY_WEBSOCKET_PASSWORD = "oracle.net.websocketPassword";
  public static final String CONNECTION_PROPERTY_WEBSOCKET_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_WEBSOCKET_PASSWORD_ACCESSMODE = 15; 
  /** 
   * This connection property is used to configure the host name of the SOCKS
   * proxy server. When this property is configured the connection to the 
   * Oracle Database Server is attempted via this SOCKS proxy server.
   * The default value of this property is null.
   * The HTTPS proxy configuration has higher precedence over SOCKS proxy.
   * If both are configured then HTTPS proxy is used for establishing connection 
   * to the Oracle Database Server.
   * @see #CONNECTION_PROPERTY_SOCKS_PROXY_PORT
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT
   * @since 20c
 
   **/
  public static final String CONNECTION_PROPERTY_SOCKS_PROXY_HOST = "oracle.net.socksProxyHost";
  public static final String CONNECTION_PROPERTY_SOCKS_PROXY_HOST_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SOCKS_PROXY_HOST_ACCESSMODE = 15; 
  /** 
   * This connection property is used to configure the port value of the
   * SOCKS proxy server.
   * The default value of this property is 1080.
   * @see #CONNECTION_PROPERTY_SOCKS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT
   * @since 20c
 
   **/
  public static final String CONNECTION_PROPERTY_SOCKS_PROXY_PORT = "oracle.net.socksProxyPort";
  public static final String CONNECTION_PROPERTY_SOCKS_PROXY_PORT_DEFAULT = "1080";
  public static final byte CONNECTION_PROPERTY_SOCKS_PROXY_PORT_ACCESSMODE = 15; 
  /** 
   * This connection property is used to specify whether the DNS lookup for the DB Host
   * should be performed locally or remotely when a SOCKS5 Proxy is being used.
   * @deprecated This property is deprecated since 25.1 and it is recommended to use 
   * {@link #CONNECTION_PROPERTY_PROXY_REMOTE_DNS}.
   * {@link #CONNECTION_PROPERTY_PROXY_REMOTE_DNS} has higher priority over this 
   * connection property.
   * 
Since 23.5 when a proxy is configured the DNS lookup is performed 
   * remotely by default.  
   * @see #CONNECTION_PROPERTY_PROXY_REMOTE_DNS
   * @see #CONNECTION_PROPERTY_SOCKS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT
   * @see #CONNECTION_PROPERTY_THIN_FORCE_DNS_LOAD_BALANCING
   * @since 21c
 
   **/
  public static final String CONNECTION_PROPERTY_SOCKS_REMOTE_DNS = "oracle.net.socksRemoteDNS";
  public static final String CONNECTION_PROPERTY_SOCKS_REMOTE_DNS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SOCKS_REMOTE_DNS_ACCESSMODE = 15; 
  /** 
   * This connection property is used to specify whether the DNS lookup for the DB Host
   * should be performed locally or remotely when a proxy is being used.
   * By default, when a proxy is configured the DNS lookup is performed remotely.
   * To perform the DNS lookup locally, configure this property to false.
   * Please note that when remote lookup is performed, DNS load balancing is disabled.
   * @see #CONNECTION_PROPERTY_SOCKS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_HOST
   * @see #CONNECTION_PROPERTY_THIN_HTTPS_PROXY_PORT
   * @see #CONNECTION_PROPERTY_THIN_FORCE_DNS_LOAD_BALANCING
   * @since 23.5
 
   **/
  public static final String CONNECTION_PROPERTY_PROXY_REMOTE_DNS = "oracle.net.proxyRemoteDNS";
  public static final String CONNECTION_PROPERTY_PROXY_REMOTE_DNS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROXY_REMOTE_DNS_ACCESSMODE = 15; 
  /** 
   * This connection property is used to specify how much effort to put into validating a {@link Connection}.
   * This property controls what isValid() does.
   * The possible values for this property are - "NONE", "LOCAL", "INBAND_DOWN", "SOCKET", "NETWORK", "SERVER" and "COMPLETE".
   * The behavior for each value is specified by {@link OracleConnection.ConnectionValidation}
   * The values are case-sensitive, setting any other value throws exception.
   * The default value of this property is "NETWORK".
 
   **/
  public static final String CONNECTION_PROPERTY_DEFAULT_CONNECTION_VALIDATION = "oracle.jdbc.defaultConnectionValidation";
  public static final String CONNECTION_PROPERTY_DEFAULT_CONNECTION_VALIDATION_DEFAULT = "NETWORK";
  public static final byte CONNECTION_PROPERTY_DEFAULT_CONNECTION_VALIDATION_ACCESSMODE = 15; 
  /** 
   * Specifies whether driver support for Application Continuity (AC)
   * is enabled.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN driver only.
   * 
   * By default, if you don't set this property, AC support is enabled on
   * the JDBC driver data sources. The primary use of this property is
   * to disable AC on the data sources.
   * 
   * Note that when this property is set to true, whether AC is actually
   * active depends on other factors like server AC configuration.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_AC_SUPPORT = "oracle.jdbc.enableACSupport";
  public static final String CONNECTION_PROPERTY_ENABLE_AC_SUPPORT_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_AC_SUPPORT_ACCESSMODE = 15; 
  /** 
   * Specifies whether driver support for Transaction Guard (TG)
   * is enabled.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN driver only.
   * 
   * By default, if you don't set this property, TG support is disabled on
   * the JDBC driver data sources, unless Application Continuity (AC) is
   * enabled. The primary use of this property is to enable TG on the
   * data sources, when AC is not enabled.
   * 
   * Note that when this property is set to true, whether TG is actually
   * active depends on other factors like server TG configuration.
   * One way to check if TG is actually enabled is to call
   * getLogicalTransactionId on
   * oracle.jdbc.OracleConnection and verify that the returned
   * value is not null.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_TG_SUPPORT = "oracle.jdbc.enableTGSupport";
  public static final String CONNECTION_PROPERTY_ENABLE_TG_SUPPORT_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_TG_SUPPORT_ACCESSMODE = 15; 
  /** 
   * Specifies whether to enable implicit request boundary support for
   * Application Continuity (AC).
   * 
   * Implicit request support helps to reduce application failover recovery
   * time. This AC optimization should be used with caution for applications
   * that change server session states during a request. For more details,
   * please consult the JDBC and RAC documentations on Auto-AC.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN driver only.
   * 
   * By default, the value of this property is "true", which means that
   * implicit request support is enabled.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_IMPLICIT_REQUESTS = "oracle.jdbc.enableImplicitRequests";
  public static final String CONNECTION_PROPERTY_ENABLE_IMPLICIT_REQUESTS_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_IMPLICIT_REQUESTS_ACCESSMODE = 15; 
  /** 
   * Specifies whether to enable Session-State-Stable (SSS) cursor support
   * for Transparent Application Continuity (TAC).
   * 
   * The SSS cursor support helps to increase TAC protection coverage and
   * reduces application failover recovery time. It allows applications to
   * establish implicit request boundaries more frequently. SSS cursors
   * can stay open throughout an entire explicit request, until endRequest.
   * 
   * This AC optimization should be used with caution for applications
   * that change server session states during a request. For more details,
   * please consult the JDBC and RAC documentations on TAC.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN driver only.
   * 
   * By default, the value of this property is "true", which means that
   * SSS cursor support is enabled for TAC.
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_SSS_CURSOR = "oracle.jdbc.enableSSSCursor";
  public static final String CONNECTION_PROPERTY_ENABLE_SSS_CURSOR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_SSS_CURSOR_ACCESSMODE = 15; 
  /** 
   * Specifies whether to enable DRCP-attach in beginRequest and DRCP-detach
   * in endRequest.
   * 
   * Enabling this makes DRCP transparent to connection pools that call the
   * request-APIs at pool check-out and check-in.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection).
   * 
   * By default, the value of this property is "false", which means that
   * the support is disabled.
 
   **/
  public static final String CONNECTION_PROPERTY_DRCP_MULTIPLEXING_IN_REQUEST_APIS = "oracle.jdbc.DRCPMultiplexingInRequestAPIs";
  public static final String CONNECTION_PROPERTY_DRCP_MULTIPLEXING_IN_REQUEST_APIS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_DRCP_MULTIPLEXING_IN_REQUEST_APIS_ACCESSMODE = 15; 
  /** 
   * This connection property specifies whether to continue batch execution 
   * when server encounters an erroneous row in the batch. If this property 
   * value is set to "true", server skips the erroneous row in the batch 
   * and continues processing rest of the rows.
   * BatchUpdateException.getLargeUpdateCounts() method can be used to know 
   * which row in the batch failed.
   * 
   * This property is applicable to the THIN driver only.
   * The default value of this property is "false".
 
   **/
  public static final String CONNECTION_PROPERTY_CONTINUE_BATCH_ON_ERROR = "oracle.jdbc.continueBatchOnError";
  public static final String CONNECTION_PROPERTY_CONTINUE_BATCH_ON_ERROR_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_CONTINUE_BATCH_ON_ERROR_ACCESSMODE = 15; 
  /** 
   * Specifies a number of seconds for a network connection to remain idle 
   * before initiating a keep alive probe. If this property is set to a value
   * other than -1, the property value will override any other value set by an
   * EXPIRE_TIME parameter in a connect descriptor URL.
   * 
   * This property is applicable to the THIN driver only.
   * 
   * {@link #CONNECTION_PROPERTY_NET_KEEPALIVE} must be set to "true" to enable
   * TCP keep alive.
   * 
   * The default value is system dependent. If this property is not set, or if
   * it is set to -1, the driver will use the system dependent default value.
   * @see jdk.net.ExtendedSocketOptions#TCP_KEEPIDLE
   * @since 20
 
   **/
  public static final String CONNECTION_PROPERTY_TCP_KEEPIDLE = "oracle.net.TCP_KEEPIDLE";
  public static final String CONNECTION_PROPERTY_TCP_KEEPIDLE_DEFAULT = "-1";
  public static final byte CONNECTION_PROPERTY_TCP_KEEPIDLE_ACCESSMODE = 15; 
  /** 
   * Specifies a number of seconds to wait before retransmitting a keep alive
   * probe.
   * 
   * This property is applicable to the THIN driver only.
   * 
   * {@link #CONNECTION_PROPERTY_NET_KEEPALIVE} must be set to "true" to enable
   * TCP keep alive.
   * 
   * The default value is system dependent. If this property is not set, or if
   * it is set to -1, the driver will use the system dependent default value.
   * @see jdk.net.ExtendedSocketOptions#TCP_KEEPINTERVAL
   * @since 20
 
   **/
  public static final String CONNECTION_PROPERTY_TCP_KEEPINTERVAL = "oracle.net.TCP_KEEPINTERVAL";
  public static final String CONNECTION_PROPERTY_TCP_KEEPINTERVAL_DEFAULT = "-1";
  public static final byte CONNECTION_PROPERTY_TCP_KEEPINTERVAL_ACCESSMODE = 15; 
  /** 
   * This is applicable only for the thin driver. Pass "true" to use the sharding driver connection.
   * The sharding driver connection derives a sharding key from a SQL command. "false" is the default behavior which
   * would give a Thin driver connection.
   * @since 20
 
   **/
  public static final String CONNECTION_PROPERTY_USE_SHARDING_DRIVER_CONNECTION = "oracle.jdbc.useShardingDriverConnection";
  public static final String CONNECTION_PROPERTY_USE_SHARDING_DRIVER_CONNECTION_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_SHARDING_DRIVER_CONNECTION_ACCESSMODE = 15; 
  /** 
   * Specifies a maximum number of keep alive probes to be sent before a
   * connection is considered broken.
   * 
   * This property is applicable to the THIN driver only.
   * 
   * {@link #CONNECTION_PROPERTY_NET_KEEPALIVE} must be set to "true" to enable
   * TCP keep alive.
   * 
   * The default value is system dependent. If this property is not set, or if
   * it is set to -1, the driver will use the system dependent default value.
   * @see jdk.net.ExtendedSocketOptions#TCP_KEEPCOUNT
   * @since 20
 
   **/
  public static final String CONNECTION_PROPERTY_TCP_KEEPCOUNT = "oracle.net.TCP_KEEPCOUNT";
  public static final String CONNECTION_PROPERTY_TCP_KEEPCOUNT_DEFAULT = "-1";
  public static final byte CONNECTION_PROPERTY_TCP_KEEPCOUNT_ACCESSMODE = 15; 
  /** 
   * Specifies the maximum request size, in terms of number of JDBC calls,
   * beyond which AC replay will be disabled. For example, if the property
   * value is set to 100, it means replay will be disabled for any request
   * with more than 100 JDBC calls in it.
   * 
   * We recommend that applicationss do not set this property unless
   * there is a demonstrated memory size problem caused by request size
   * and no better solution is feasible.
   * 
   * Replay disabling applies only to any request that exceeds the limit.
   * Replay will be reenabled at the next beginRequest on the same JDBC
   * physical connection.
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN driver only.
   * 
   * There is a request-size histogram in the AC statistics that users can
   * use to get an idea of the request size distribution of their application.
   * It can be obtained by calling getRequestSizeHistogram() on
   * oracle.jdbc.replay.ReplayStatistics.
   * 
   * The histogram is also dumped into the Oracle JDBC driver logs, when
   * the driver detects significant memory pressure.
   * 
   * Users can use the histogram and AC statistics to determine the
   * majority of their request sizes, and set the request-size limit to
   * be slightly above those. For small number of long requests above
   * the limit, users could consider alternatives such as more frequent
   * connection pool checkout/checkin's, deploying Transparent
   * Application Continuity (TAC) to reduce request size, or to allow
   * replay being disabled for requests with only long queries.
   * 
   * By default, the value of this property is "2147483647", which is
   * Integer.MAX_VALUE that means replay is practically enabled for
   * all requests.
   * 
   * @since 20.1
 
   **/
  public static final String CONNECTION_PROPERTY_REQUEST_SIZE_LIMIT = "oracle.jdbc.replay.protectedRequestSizeLimit";
  public static final String CONNECTION_PROPERTY_REQUEST_SIZE_LIMIT_DEFAULT = "2147483647";
  public static final byte CONNECTION_PROPERTY_REQUEST_SIZE_LIMIT_ACCESSMODE = 15; 
  /** 
   * Use this property to specify the ONS wallet file, when you need Oracle
   * Fast Application Notification (FAN).
   * 
   * The Oracle JDBC driver just passes this wallet file to the lower layer.
   * The file can be specified on a global or per-data source basis.
   * 
   * The supported wallet file specification syntax is the same as for
   * oracle.net.wallet_location
   * 
   * If the oracle.jdbc.ons.walletfile property is not specified
   * but the oracle.net.wallet_location property is, and if the
   * oracle.jdbc.ons.protocol property is set to "TCPS", the driver
   * will use oracle.net.wallet_location property's value as
   * the ONS wallet file. In that case, both the JDBC connection and
   * the ONS connection share the same Oracle wallet.
   * 
   * @see #CONNECTION_PROPERTY_WALLET_LOCATION
   * @since 20.1
 
   **/
  public static final String CONNECTION_PROPERTY_ONS_WALLET_FILE = "oracle.jdbc.ons.walletfile";
  public static final String CONNECTION_PROPERTY_ONS_WALLET_FILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_ONS_WALLET_FILE_ACCESSMODE = 7; 
  /** 
   * Use this property to specify the ONS wallet password, which is only
   * required if you don't enable auto-login in the ONS wallet. In this case
   * "ewallet.p12" will be used instead of "cwallet.sso".
   * 
   * @see #CONNECTION_PROPERTY_WALLET_PASSWORD
   * @since 20.1
 
   **/
  public static final String CONNECTION_PROPERTY_ONS_WALLET_PASSWORD = "oracle.jdbc.ons.walletpassword";
  public static final String CONNECTION_PROPERTY_ONS_WALLET_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_ONS_WALLET_PASSWORD_ACCESSMODE = 15; 
  /** 
   * Use this property to specify the ONS connection protocol, as either
   * "TCP" or "TCPS". The default is "TCP".
   * 
   * When this property is "TCPS" and oracle.jdbc.ons.walletfile
   * is not specified, any JDBC wallet configured via the connection
   * property oracle.net.wallet_location will also be used
   * as the ONS wallet for ONS connections.
   * 
   * If oracle.jdbc.ons.walletfile is specified, it will be used
   * as the ONS wallet and the ONS connection protocol is assumed to be TCPS.
   * 
   * @since 20.1
 
   **/
  public static final String CONNECTION_PROPERTY_ONS_PROTOCOL = "oracle.jdbc.ons.protocol";
  public static final String CONNECTION_PROPERTY_ONS_PROTOCOL_DEFAULT = "TCP";
  public static final byte CONNECTION_PROPERTY_ONS_PROTOCOL_ACCESSMODE = 15; 
  /** 
   * Configures a timeout for creating a new connection. The value of this
   * property is parsed as an integer number of seconds. A value of 0 
   * configures the driver to not use a timeout. The default value is 0.
   * Values which are less than 0 are invalid.
   * 
   * When specified, the timeout is applied to any method call which opens a
   * new connection, such as 
   * {@link javax.sql.DataSource#getConnection()} or
   * {@link java.sql.ConnectionBuilder#build}. If the timeout expires, these
   * method calls will throw a {@link java.sql.SQLException} with error code 
   * 18714.
   * 
   * A value specified for this property can be overriden by a value set with
   * {@link javax.sql.CommonDataSource#setLoginTimeout(int)}.
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   *
   * @since 21
 
   **/
  public static final String CONNECTION_PROPERTY_LOGIN_TIMEOUT = "oracle.jdbc.loginTimeout";
  public static final String CONNECTION_PROPERTY_LOGIN_TIMEOUT_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_LOGIN_TIMEOUT_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies whether driver in-band notification support is enabled.
   * This feature primarily helps applications to drain connections
   * gracefully during Oracle Autonomous Database (ADB) and Real
   * Application Clusters (RAC) planned maintenance.
   * 
   * 
   * This property can be set at the system level (which applies to all
   * connections), or at the connection level (which applies to a particular
   * connection). The property is applicable to THIN and JDBC-OCI drivers
   * only.
   * 
   * 
   * By default, if you don't set this property, in-band notification is
   * always enabled. The primary use of this property is to disable this
   * feature, which might be necessary in case in-band notification
   * interferes with similar features in upper-stacks (like a connection pool
   * or application container), or malfunctions.
   * Note that this property is automatically switched off when Bequeath protocol is used.
   * 
       
   **/
  public static final String CONNECTION_PROPERTY_IN_BAND_NOTIFICATION = "oracle.jdbc.inbandNotification";
  public static final String CONNECTION_PROPERTY_IN_BAND_NOTIFICATION_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_IN_BAND_NOTIFICATION_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies a {@code protocol} name for the driver to use when
   * obtaining an instance of {@link javax.net.ssl.SSLContext} from
   * {@link javax.net.ssl.SSLContext#getInstance(String)} for a TLS enabled
   * database connection.
   * 
   * 
   * 
   * This property has no effect on which versions of SSL or TLS will be
   * accepted during handshakes with the database server.
   * 
   * To configure the set of protocol versions accepted during handshakes, use
   * {@link #CONNECTION_PROPERTY_THIN_SSL_VERSION}.
   * 
   * 
   * If this property is not specified, the driver will use "TLS" by default.
   * 
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   * 
   * @since 20.3
 
   **/
  public static final String CONNECTION_PROPERTY_SSL_CONTEXT_PROTOCOL = "oracle.net.ssl_context_protocol";
  public static final String CONNECTION_PROPERTY_SSL_CONTEXT_PROTOCOL_DEFAULT = "TLS";
  public static final byte CONNECTION_PROPERTY_SSL_CONTEXT_PROTOCOL_ACCESSMODE = 15; 
  /** 
   * 
Use this property to specify the Secure External Password Store (SEPS) 
   * wallet location. The driver will then use this wallet to retrieve the 
   * username and password.
   * 
The "mkstore" utility can be used to add the username and password to 
   * an existing wallet. Example: mkstore -wrl ./walletpath -createCredential tnsalias scott tiger
   * 
The priority in which the driver locates the username and password (from high to low) is:
   * 
- Connection properties
   * 
- URL
   * 
- Resource provider
   * 
- SEPS wallet in the URL with seps_wallet_location=<location>
   * 
- SEPS wallet as connection property("oracle.net.seps_wallet_location=<location>")
   * 
- TCPS wallet in the URL with wallet_location=<location>
   * 
- TCPS wallet as connection property ("oracle.net.wallet_location=<location>")
   * 
Example URL with SEPS wallet:
   * jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=tcps)(HOST=myhost)(PORT=3484))(CONNECT_DATA=
   * (SERVICE_NAME=servicename))(SECURITY=(SEPS_WALLET_LOCATION=/seps/cwallet.sso)))
   * 
The wallet location can be set in three formats:
   * 
- "file:/path/ewallet.sso" or "file:/path/cwallet.p12" or "file:/path/to/directory/"
   * 
- (SOURCE=(METHOD=FILE)(METHOD_DATA=(DIRECTORY=/path/to/directory)))	
   * 
- "data:;base64,<Base64 representation of the bytes in cwallet.sso or ewallet.p12>"
   * 
   * 
 Please note that the SEPS wallet type must be either SSO or PKCS12.
   * @see #CONNECTION_PROPERTY_SEPS_WALLET_PASSWORD
   * @see #CONNECTION_PROPERTY_WALLET_LOCATION
 
   **/
  public static final String CONNECTION_PROPERTY_SEPS_WALLET_LOCATION = "oracle.net.seps_wallet_location";
  public static final String CONNECTION_PROPERTY_SEPS_WALLET_LOCATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SEPS_WALLET_LOCATION_ACCESSMODE = 15; 
  /** 
   * Use this property to specify the SEPS wallet's password. An SSO wallet 
   * doesn't require a password but if the SEPS wallet type is 
   * p12 then a password must be specified to retrieve the 
   * credentials from the wallet.
   * @see #CONNECTION_PROPERTY_SEPS_WALLET_LOCATION
 
   **/
  public static final String CONNECTION_PROPERTY_SEPS_WALLET_PASSWORD = "oracle.net.seps_wallet_password";
  public static final String CONNECTION_PROPERTY_SEPS_WALLET_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SEPS_WALLET_PASSWORD_ACCESSMODE = 15; 
  /** 
   * This property controls the row fetch size tuning behavior. 
   * Setting it to a larger value increases the fetch size for large results 
   * at the expense of substantially larger memory footprint and setting the 
   * value to less than 1 disables the fetch size tuning feature. 
   * The default value is 8 which means the feature is enabled by default.
   * Setting the property value to less than 1 or setting the fetch size 
   * explicitly using {@link java.sql.Statement#setFetchSize(int)} disables 
   * this feature.
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_FETCH_SIZE_TUNING = "oracle.jdbc.fetchSizeTuning";
  public static final String CONNECTION_PROPERTY_FETCH_SIZE_TUNING_DEFAULT = "8";
  public static final byte CONNECTION_PROPERTY_FETCH_SIZE_TUNING_ACCESSMODE = 15; 
  /** 
   * Setting the connection property value to "true" enables the True Cache 
   * feature. When this feature is enabled, the JDBC 
   * driver creates a logical connection that contains two physical connections 
   * one to the primary database and another to a True Cache instance. 
   * 
   * The JDBC driver executes a given SQL query either on the primary database 
   * or on a True Cache instance depending on the value returned by the API 
   * {@link java.sql.Connection#isReadOnly()}. 
   * 
   * If the API returns true, the query is executed on a True Cache instance, 
   * otherwise on the primary database.
   * 
   * Please note that a True Cache instance may be lagging behind the primary 
   * database which means that an application may not see the most recent 
   * data when a query is executed on a True Cache instance.
   * The default value of this property is "false" which means the True Cache  
   * feature is disabled by default.
   * 
   * 
Note:  When this property is set, make sure that
   * UCP jar is present in classpath.
   * 
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   * 
   * The following example illustrates the use of the True Cache feature
   * 
   * 
   * {@code
   *   OracleDataSource ods = new oracle.jdbc.pool.OracleDataSource();
   *   ods.setURL(DB_URL);
   *   ods.setUser(DB_USER);
   *   ods.setPassword(DB_PASSWORD);
   *   Properties props = new Properties();
   *   props.setProperty("oracle.jdbc.useTrueCacheDriverConnection", "true");
   *   ods.setConnectionProperties(props);
   *   // this is a True Cache driver connection and it can be used to execute 
   *   // queries on both the primary database and a True Cache instance
   *   Connection conn = ods.getConnection();
   *   Statement stmt = conn.createStatement();
   *   // Default value of connection read-only flag is false which means 
   *   // the SQL_QUERY1 is executed on the primary database 
   *   ResultSet rs = stmt.executeQuery(SQL_QUERY1);
   *   // set the read-only flag to true, in order to execute SQL_QUERY2 
   *   // on a True Cache instance
   *   conn.setReadOnly(true);
   *   ResultSet rs1 = stmt.executeQuery(SQL_QUERY2);
   * }
   * 
   * @see  #isReadOnly()
   * @see  #setReadOnly(boolean)
   * @since 23ai
 
   **/
  public static final String CONNECTION_PROPERTY_USE_TRUECACHE_DRIVER_CONNECTION = "oracle.jdbc.useTrueCacheDriverConnection";
  public static final String CONNECTION_PROPERTY_USE_TRUECACHE_DRIVER_CONNECTION_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_USE_TRUECACHE_DRIVER_CONNECTION_ACCESSMODE = 15; 
  /** 
   * Controls whether sensitive diagnostic logging is permitted. If false logging
   * sensitive data, primarily SQL parameter values, is not permitted. Attempting
   * to enable sensitive diagnostics will cause an exception. If true logging of
   * sensitive data is permitted, though not enabled. To capture sensitive data
   * in diagnostic logs, sensitive diagnostics must be enabled. 
   * 
   * 
Values known by JDBC to be passwords are never logged. This includes
   * database authentication passwords passed to {@code getConnection}. Although
   * the SQL text may include passwords, ALTER USER IDENTIFIED BY, or user data
   * when represented by literals, JDBC considers the SQL text to be public, ie
   * not sensitive. The SQL text is too valuable for diagnostics to be omitted from
   * public diagnostic logs and vanishingly few, if any, apps do ALTER USER IDENTIFIED
   * BY. Apps should not send user in SQL as literals. Use bind values instead.
   * If the app does either of these things user data or even database use passwords
   * can appear in diagnostic log files. In this case do not enable diagnostics.
   * 
   * 
This property can only be set in the java command line via the -D option.
   * Setting it any other way will have no effect.
   * 
   * @see #CONNECTION_PROPERTY_ENABLE_SENSITIVE_DIAGNOSTICS
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_PERMIT_SENSITIVE_DIAGNOSTICS = "oracle.jdbc.diagnostic.permitSensitiveDiagnostics";
  public static final String CONNECTION_PROPERTY_PERMIT_SENSITIVE_DIAGNOSTICS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_PERMIT_SENSITIVE_DIAGNOSTICS_ACCESSMODE = 2; 
  /** 
   * Controls whether sensitive diagnostic logging is enabled. If false sensitive
   * data, primarily SQL parameter values, is not captured or written. Attempting
   * to enable sensitive diagnostics will cause an exception. If true logging of
   * sensitive data is permitted, though not enabled. To capture sensitive data
   * in diagnostic logs, sensitive diagnostics must be enabled. Sensitive
   * diagnostics cannot be enabled unless it is permitted. Attempting to do so
   * will cause an error.
   * 
   * 
Although the SQL text can contain sensitive data in literals, putting 
   * sensitive data in the SQL text is poor practice for a wide variety of reasons
   * and vanishingly few apps do so. The SQL text is so valuable for diagnostics
   * that omitting it from public diagnostics logs would greatly reduce their 
   * value. Rather than requiring customers to enable sensitive diagnostics in
   * order to see the SQL text which would also expose user data, JDBC treats
   * the SQL text as not sensitive and includes it in public diagnostic logs.
   * 
   * @see #CONNECTION_PROPERTY_PERMIT_SENSITIVE_DIAGNOSTICS
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_SENSITIVE_DIAGNOSTICS = "oracle.jdbc.diagnostic.enableSensitiveDiagnostics";
  public static final String CONNECTION_PROPERTY_ENABLE_SENSITIVE_DIAGNOSTICS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_SENSITIVE_DIAGNOSTICS_ACCESSMODE = 15; 
  /** 
   * This property controls which {@link java.util.logging.Logger} is used to
   * write diagnostic log output. Setting this property is not necessary unless
   * debugging is enabled. In that case each connection which has debugging
   * enabled should have a distinct {@code Logger} name. Failure to set a 
   * distinct name results in mixing the diagnostic output for multiple
   * connections in a single log file and greatly reduces performance due to
   * contention on the {@code Logger}. If debugging is enabled on only one
   * connection (best practice) there is no need to set the {@code Logger} name.
   * 
   * 
It should be unnecessary to set this property when only Diagnose First
   * Failure is enabled. Usually failure are sufficiently infrequent that there
   * is no simultaneous access to the {@code Logger}. If failures are so frequent
   * that contention is an issue, then setting a distinct name for each connection
   * would reduce contention improving performance and might make the logs easier
   * to read.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_DIAGNOSTIC_LOGGER_NAME = "oracle.jdbc.diagnostic.loggerName";
  public static final String CONNECTION_PROPERTY_DIAGNOSTIC_LOGGER_NAME_DEFAULT = "oracle.jdbc";
  public static final byte CONNECTION_PROPERTY_DIAGNOSTIC_LOGGER_NAME_ACCESSMODE = 15; 
  /** 
   * This property controls the size of the ring buffer which holds Diagnose First
   * Failure log records in memory. The size of this buffer is the amount of history
   * that is written to the {@link java.util.logging.Logger} when a failure is 
   * detected. A larger buffer size means more history but at the expense of more
   * memory.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_DIAGNOSTIC_BUFFER_SIZE = "oracle.jdbc.diagnostic.bufferSize";
  public static final String CONNECTION_PROPERTY_DIAGNOSTIC_BUFFER_SIZE_DEFAULT = "1000";
  public static final byte CONNECTION_PROPERTY_DIAGNOSTIC_BUFFER_SIZE_ACCESSMODE = 15; 
  /** 
   * This property controls whether Diagnose First Failure is enabled. The default 
   * value is true; Diagnose First Failure is enabled by default. In a properly 
   * working app during normal operation this should result in no diagnostic output. 
   * Diagnostic output will be generated only on serious errors. Note that diagnostic 
   * output is produced regardless of whether the Exception is handled, for example by 
   * Application Continuity. If Diagnose First Failure is enabled and JDBC throws a 
   * recoverable exception, AC will attempt to recover. But Diagnose First Failure 
   * will generate the diagnostic output before AC starts recovery. Using an MBean 
   * operation {@link oracle.jdbc.diagnostics.DiagnosticsMXBean#addErrorCodeToWatchList(String)},
   * error codes can be configured to monitor their occurrence. The diagnostic output is 
   * generated when a configured error occurs. The list of preconfigured error codes 
   * can be fetched using the operation 
   * {@link oracle.jdbc.diagnostics.DiagnosticsMXBean#showErrorCodesWatchList()}. 
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_DIAGNOSE_FIRST_FAILURE = "oracle.jdbc.diagnostic.enableDiagnoseFirstFailure";
  public static final String CONNECTION_PROPERTY_ENABLE_DIAGNOSE_FIRST_FAILURE_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_DIAGNOSE_FIRST_FAILURE_ACCESSMODE = 15; 
  /** 
   * This property controls whether logging is enabled. The default is false and
   * while it can be set to true as a System property, this is discouraged. Logging
   * output can be voluminous and it reduces system performance. It is best practice
   * to enable logging only for one or perhaps a very small number of connections.
   * This will keep the log size more manageable and limit the performance reduction
   * to only one connection. It is best practice to set a distinct name for the
   * {@link java.util.logging.Logger} for each connection using the
   * {@link #CONNECTION_PROPERTY_DIAGNOSTIC_LOGGER_NAME} property. 
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_LOGGING = "oracle.jdbc.diagnostic.enableLogging";
  public static final String CONNECTION_PROPERTY_ENABLE_LOGGING_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_LOGGING_ACCESSMODE = 15; 
  /** 
   * This property controls whether observability is enabled. The default value is true.
   * Observability requires dms.jar in CLASSPATH. Observability is disabled if the value
   * of this property is false or dms.jar is not in CLASSPATH.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_OBSERVABILITY = "oracle.jdbc.diagnostic.enableObservability";
  public static final String CONNECTION_PROPERTY_ENABLE_OBSERVABILITY_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_OBSERVABILITY_ACCESSMODE = 2; 
  /** 
   * This property enables writing diagnostic logging output to Diagnose First Failure 
   * buffer. The default is false. If this property is set and logging is enabled, the 
   * complete logging output is written to Diagnose First Failure buffer. The logging 
   * output can be voluminous. Hence writing logging output to Diagnose First Failure 
   * buffer is discouraged.
   * The Diagnose First Failure diagnostic output is generated when a configured error 
   * occurs. The list of preconfigured error codes can be fetched using the opeartion
   * {@link oracle.jdbc.diagnostics.DiagnosticsMXBean#showErrorCodesWatchList()}. 
   * One or more error codes can be added to the list of errors watched for occurrence 
   * using the operation 
   * {@link oracle.jdbc.diagnostics.DiagnosticsMXBean#addErrorCodeToWatchList(String)}.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_WRITE_LOGS_TO_DIAGNOSE_FIRST_FAILURE = "oracle.jdbc.diagnostic.writeLogsToDiagnoseFirstFailure";
  public static final String CONNECTION_PROPERTY_WRITE_LOGS_TO_DIAGNOSE_FIRST_FAILURE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_WRITE_LOGS_TO_DIAGNOSE_FIRST_FAILURE_ACCESSMODE = 2; 
  /** 
   * This property specifies one or more database tenant names in a JSON array String 
   * format. If set, debugging is enabled if the connection is attached to a tenant 
   * with any of those names. It is best practice to set this for only one or a very 
   * small number of connections.
   * The default value is {@code null}. If no value is set debugging by tenant is 
   * disabled.
   *
   * For example, to enable debugging by tenant, set the tenant name(s) in a JSON array 
   * String format.
   * 
   * 
   * Properties prop = new Properties();
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_DEBUG_TENANT, 
   *                                       "[\"tenant_name_1\",\"tenant_name_2\"]");
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_DEBUG_TENANT = "oracle.jdbc.diagnostic.debugTenant";
  public static final String CONNECTION_PROPERTY_DEBUG_TENANT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DEBUG_TENANT_ACCESSMODE = 15; 
  /** 
   * This property specifies one or more SQL texts in a JSON array String format.
   * If set, debugging is enabled if the connection is doing work related to one 
   * of the specified SQL texts. The comparison by String.equals so the SQL texts 
   * in this property must match the SQL texts in the code exactly including white 
   * space. It is best practice to set this for only one or a very small number of 
   * connections. 
   * The default value is {@code null}. If no value is set debugging by SQL is disabled.
   *
   * For example, to enable debugging, set the SQL text(s) in a JSON array String format:
   * 
   * 
   * Properties prop = new Properties();
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_DEBUG_SQL, 
   *                           "[\"SELECT * FROM emp\",\"SELECT empno FROM emp\"]");
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_DEBUG_SQL = "oracle.jdbc.diagnostic.debugSQL";
  public static final String CONNECTION_PROPERTY_DEBUG_SQL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DEBUG_SQL_ACCESSMODE = 15;  
  /** 
   * Use this connection property to set one or more Database Change Notification options.
   * See the JavaDoc of {@link oracle.jdbc.OracleConnection#registerDatabaseChangeNotification(Properties)}
   * for the complete list of Database Change Notification options. The default value of this property is null.
   * The Database Change Notification connection options set using this connection property take
   * precedence over the Database Change Notification options set on DCN registration.
   *
   * 
   * Example:
   * 
   * Properties prop = new Properties();
   * properties.setProperty(OracleConnection.CONNECTION_PROPERTY_DATABASE_CHANGE_NOTIFICATION_OPTIONS,
   *     "DCN_NOTIFY_ROWIDS=true,DCN_CLIENT_INIT_CONNECTION=true,DCN_QUERY_CHANGE_NOTIFICATION=true");
   * 
   * 
   * @since 26
 
   **/
  public static final String CONNECTION_PROPERTY_DATABASE_CHANGE_NOTIFICATION_OPTIONS = "oracle.jdbc.dcnOptions";
  public static final String CONNECTION_PROPERTY_DATABASE_CHANGE_NOTIFICATION_OPTIONS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_DATABASE_CHANGE_NOTIFICATION_OPTIONS_ACCESSMODE = 15; 
  /** 
   * 
   * Enables the use of access tokens for authentication with Oracle Database.
   * 

   * The database instance that Oracle JDBC connects to must be configured to 
   * validate the token with the service that issued it. The Oracle Database 
   * Security Guide specifies how to configure the database for token based
   * authentication with 
   * 
   * Oracle Cloud
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/authenticating-and-authorizing-iam-users-oracle-dbaas-databases.html)
   * and 
   * 
   * Azure 
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/authenticating-and-authorizing-microsoft-entra-id-azure-ad-users-oracle-databases.html)
   * 

   * The value of this property determines the method used by Oracle JDBC to
   * obtain a token. Each of the possible values are listed in the table below.
   * Depending on which value is configured, additional properties may be set;
   * these are listed under the "Related Properties" column. If an
   * {@link oracle.jdbc.spi.OracleResourceProvider} is required, it is listed
   * under the "Required Provider" column.
   * 

   *       *   Property Value
   *       *   Description
   *       *   Related Properties
   *       *   Required Provider
   *   
   * 

   *       *   OAUTH
   *       *   Read a JWT from the file system.
   *       *   {@linkplain #CONNECTION_PROPERTY_TOKEN_LOCATION oracle.jdbc.tokenLocation}
   *       *   No provider required
   *   
   * 

   *       *   OCI_TOKEN
   *       *   Read a JWT and proof-of-possesion key from the file system
   *       *   {@linkplain #CONNECTION_PROPERTY_TOKEN_LOCATION oracle.jdbc.tokenLocation}
   *       *   No provider required
   *   
   * 

   *       *   OCI_API_KEY
   *       *   Request a token from OCI using an API key.
   *       *   {@linkplain #CONNECTION_PROPERTY_OCI_CONFIG_FILE oracle.jdbc.ociConfigFile}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_PROFILE oracle.jdbc.ociProfile}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   OCI_INSTANCE_PRINCIPAL
   *       *   Request a token from OCI as an instance principal.
   *       *   {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   OCI_RESOURCE_PRINCIPAL
   *       *   Request a token from OCI as a resource principal.
   *       *   {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   OCI_DELEGATION_TOKEN
   *       *   Request a token from OCI using a delegation token.
   *       *   {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   OCI_INTERACTIVE
   *       *   Request a token from OCI using interactive authentication in a web 
   *   browser.
   *       *   {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_CONFIG_FILE oracle.jdbc.ociConfigFile}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_OCI_PROFILE oracle.jdbc.ociProfile}
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   OCI_DEFAULT
   *       *   Request a token from OCI using the most appropriate method for the 
   *   current environment:
   *   

-    *   OCI_API_KEY is used if an OCI configuration file with a "DEFAULT" profile
   *   is present at $HOME/.oci/config.
   *   
-    *   OCI_DELEGATION_TOKEN is used if running in an OCI Cloud Shell.
   *   
-    *   OCI_INSTANCE_PRINCIPAL is used if running in an OCI compute instance.
   *   
   *       *   Related properties depend on which authentication method is used
   *       *   
   *   OCI Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-oci#access-token-provider)
   *   
   * 

   *       *   AZURE_SERVICE_PRINCIPAL
   *       *   Request a token from Azure as a service principal.
   *   <div>
   *   The client ID and secret may be loaded from a SEPS wallet configured with
   *   {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   *   or 
   *   {@linkplain #CONNECTION_PROPERTY_AZURE_CREDENTIALS oracle.jdbc.azureCredentials}.
   *   An ID configured by 
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_ID oracle.jdbc.clientId} and/or
   *   a secret configured by 
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET oracle.jdbc.clientSecret}
   *   will take precedence over an ID and/or secret from
   *   {@linkplain #CONNECTION_PROPERTY_AZURE_CREDENTIALS oracle.jdbc.azureCredentials}.
   *   And, an ID and/or secret from 
   *   {@linkplain #CONNECTION_PROPERTY_AZURE_CREDENTIALS oracle.jdbc.azureCredentials}
   *   will take precedence over an ID and/or secret from
   *   {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}.
   *       *   {@linkplain #CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI oracle.jdbc.azureDatabaseApplicationIdUri}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_TENANT_ID oracle.jdbc.tenantId}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_ID oracle.jdbc.clientId}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET oracle.jdbc.clientSecret}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE oracle.jdbc.clientCertificate}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE_PASSWORD oracle.jdbc.clientCertificatePassword}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_AZURE_CREDENTIALS oracle.jdbc.azureCredentials}
   *       *   
   *   Azure Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-azure#access-token-provider)
   *   
   * 

   *       *   AZURE_MANAGED_IDENTITY
   *       *   Request a token from Azure as a managed identity.
   *       *   {@linkplain #CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI oracle.jdbc.azureDatabaseApplicationIdUri}
   *       *   
   *   Azure Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-azure#access-token-provider)
   *   
   * 

   *       *   AZURE_INTERACTIVE
   *       *   Request a token from Azure using interactive authentication in a web 
   *   browser.
   *       *   {@linkplain #CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI oracle.jdbc.azureDatabaseApplicationIdUri}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_TENANT_ID oracle.jdbc.tenantId}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_ID oracle.jdbc.clientId}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET oracle.jdbc.clientSecret}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE oracle.jdbc.clientCertificate}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE_PASSWORD oracle.jdbc.clientCertificatePassword}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_REDIRECT_URI oracle.jdbc.redirectUri}
   *       *   
   *   Azure Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-azure#access-token-provider)
   *   
   * 

   *       *   AZURE_DEVICE_CODE
   *       *   Request a token from Azure by entering a device code into a web browser.
   *   The device code and browser URL are printed to the standard output 
   *   stream.
   *       *   {@linkplain #CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI oracle.jdbc.azureDatabaseApplicationIdUri}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_TENANT_ID oracle.jdbc.tenantId}
   *   <div>
   *   {@linkplain #CONNECTION_PROPERTY_CLIENT_ID oracle.jdbc.clientId}
   *       *   
   *   Azure Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-azure#access-token-provider)
   *   
   * 

   *       *   AZURE_DEFAULT
   *       *   Request a token from Azure using the most appropriate method for the 
   *   current environment:
   *   

-    *   AZURE_SERVICE_PRINCIPAL is used if a client secret or certificate is
   *   configured.
   *   
-    *   Otherwise, the username and password of an Azure account are used if the
   *   Azure SDK for Java is configured with these values.
   *   
-    *   Otherwise, AZURE_MANAGED_IDENTITY is used if running in an Azure VM.
   *   
   *       *   Related properties depend on which authentication method is used
   *       *   
   *   Azure Token Provider
   *    (https://github.com/oracle/ojdbc-extensions/tree/main/ojdbc-provider-azure#access-token-provider)
   *   
   * 

   * 

   * If an Oracle Net Descriptor style URL includes the TOKEN_AUTH parameter
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 

   * In most cases, a database username and password will take precedence 
   * over token authentication. The only exceptions to this are:
   * 

-    * A username or password read from a wallet configured by
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * will not override token authentication. However, a dedicated SEPS wallet 
   * configured by
   * {@linkplain #CONNECTION_PROPERTY_SEPS_WALLET_LOCATION oracle.net.seps_wallet_location}
   * will override token authentication.
   * 
-    * A username alone will not override token authentication if an
   * interactive authentication method is configured by this property: 
   * OCI_INTERACTIVE, AZURE_INTERACTIVE, or AZURE_DEVICE_CODE. If 
   * interactive authentication is configured, and a username is configured, and
   * no password is configured, then interactive token-based authentication will
   * be used. In this case, the username should match the OCI or Azure username
   * that is entered into the interactive prompt.
   * 
   * 

   * If a token is configured using 
   * {@linkplain #CONNECTION_PROPERTY_ACCESS_TOKEN oracle.jdbc.accessToken},
   * {@link oracle.jdbc.datasource.OracleDataSource#setTokenSupplier(Supplier)},
   * or {@link OracleConnectionBuilder#accessToken(AccessToken)} then Oracle 
   * JDBC will use that token to authenticate with the database, and any setting 
   * configured by this property will be ignored.
   * 

   * 
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_TOKEN_AUTHENTICATION = "oracle.jdbc.tokenAuthentication";
  public static final String CONNECTION_PROPERTY_TOKEN_AUTHENTICATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_TOKEN_AUTHENTICATION_ACCESSMODE = 15; 
  /** 
   * 
   * When {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is set to
   * OCI_TOKEN or OAUTH, this property specifies the file system path to 
   * obtain access tokens from. The path specified by this property must be a 
   * directory containing a file named "token", and the token file must contain 
   * a JSON Web Token (JWT) on a single line of UTF-8 encoded text. The JWT 
   * format is specified by 
   * RFC 7519 (https://datatracker.ietf.org/doc/html/rfc7519).
   * 

   * 
- 
   * If the value of {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is 
   * OCI_TOKEN then the path given by this property must be a directory 
   * containing a both a token file, and a file named oci_db_key.pem that
   * stores the proof-of-possession key for the JWT token.
   * The private key file must use the PEM format and must contain the base64 
   * encoding of an RSA private key in the PKCS#8 format. The private key 
   * encoding must appear between the tags "-----BEGIN PRIVATE KEY---" and
   * "-----END PRIVATE KEY-----". Oracle JDBC uses the private key to 
   * demonstrate proof of possession. Proof of possession is specified by
   * RFC 7800 (https://datatracker.ietf.org/doc/html/rfc7800).
   * 

   * Note that the OCI CLI tool may be used to generate both the token and
   * private key files. By default, the OCI CLI tool will write these files
   * to the location of {@code $HOME/.oci/db-token/}. If the value of 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is OCI_TOKEN, and
   * no location is configured by this property, then Oracle JDBC will read
   * the token and private key files from the default location of 
   * {@code $HOME/.oci/db-token/}.
   * 

   * 
- 
   * If the value of {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is
   * OAUTH, then only the token file is required, and the path given by this
   * property may locate either a file or directory. If a file is located,
   * then the JWT is read from it. Otherwise, if a directory is located, then
   * the JWT is read from a file named "token" in that directory.
   * 

   * 

   * If an Oracle Net Descriptor style URL includes the TOKEN_LOCATION parameter
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_TOKEN_LOCATION = "oracle.jdbc.tokenLocation";
  public static final String CONNECTION_PROPERTY_TOKEN_LOCATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_TOKEN_LOCATION_ACCESSMODE = 15; 
  /** 
   * 
   * Configures how Oracle JDBC performs authentication with a username and 
   * password. Possible values for this property are:
   * 

-    * PASSWORD_VERIFIER : The username and password are used to 
   * authenticate with Oracle Database. This is the default value of this 
   * property.
   * 
-    * OCI_TOKEN : The username and password are used to authenticate 
   * with Oracle Cloud's Identity and Access Management (IAM) service. The
   * {@link #CONNECTION_PROPERTY_OCI_IAM_URL} and
   * {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy} connection properties must also
   * be configured. Additional information can be found in the JavaDocs of these
   * connection properties.
   * 
-    * AZURE_TOKEN : The username and password are used to authenticate  
   * with Azure's Active Directory service. The 
   * {@link #CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI},
   * {@link #CONNECTION_PROPERTY_TENANT_ID}, and
   * {@link #CONNECTION_PROPERTY_CLIENT_ID} connection properties must also
   * be configured. Additional information can be found in the JavaDocs of these
   * connection properties.
   * 
-    * KERBEROS5 : The username and password are used to intialize the  
   * KERBEROS authentication context. Along with this, KERBEROS 
   * authentication must be enabled using 
   * {@link #CONNECTION_PROPERTY_THIN_NET_AUTHENTICATION_SERVICES}.
   * 
   * 

   * If an Oracle Net Descriptor style URL includes the PASSWORD_AUTH parameter
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION = "oracle.jdbc.passwordAuthentication";
  public static final String CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION_DEFAULT = "PASSWORD_VERIFIER";
  public static final byte CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION_ACCESSMODE = 15; 
  /** 
   * 
   * When 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to OCI_TOKEN, this property must specify the full path of the 
   * Identity and Access Management (IAM) endpoint that Oracle JDBC requests an
   * access token from.
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_IAM_URL parameter,
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 

   * The value of this property is typically a URL of the following form:
   * 

   * https://auth.{region}.oraclecloud.com/v1/actions/generateScopedAccessBearerToken
   * 

   * For a list of region-specific endpoints, see
   * 
   * Identity and Access Management Data Plane API
   *  (https://docs.oracle.com/en-us/iaas/api/#/en/identity-dp/v1/). The servers located at these HTTPS endpoints should have a 
   * certificate which is signed by an authority included in the JDK's built-in
   * cacerts trust store. If a server presents a certificate which is not signed
   * by an authority included in cacerts, then Oracle JDBC will close the 
   * connection without sending a request, and a {@link SQLException} is thrown.
   * If necessary, {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location} or
   * {@link #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE} may be used to
   * configure trusted certificates, in addition to those already included by
   * cacerts.
   * 

   * The request for an access token is authenticated by the database username
   * and password of an IAM user. These credentials may be configured
   * through any existing method of configuring a database username and
   * password, such as the "user" and "password" properties passed to
   * {@link java.sql.Driver#connect(String, Properties)}. For information 
   * about enabling authentication as an IAM user, including how to create a
   * database username and password, see
   * 
   * Authenticating and Authorizing IAM Users for Oracle DBaaS Databases 
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/authenticating-and-authorizing-iam-users-oracle-dbaas-databases.html).
   * 

   * An access token requested from IAM will authorize logins to a scope of
   * one or more databases. The scope must only include databases that an IAM
   * policy has allowed a user to use, otherwise the request will fail. The 
   * scope may be configured as follows:
   * 

-    * If the OCID of a compartment is set as 
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment},
   * and the OCID of a database within that compartment is set as
   * {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase},
   * then the scope only includes that database.
   * 
-    * If a compartment OCID is set as 
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment},
   * and 
   * {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase} is 
   * not set, then the scope includes all databases within that compartment.
   * 
-    * If neither 
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   * nor {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}
   * are set, then the scope includes all databases within all compartments of 
   * the tenancy identified by 
   * {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy}.
   * 
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_IAM_URL = "oracle.jdbc.ociIamUrl";
  public static final String CONNECTION_PROPERTY_OCI_IAM_URL_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_IAM_URL_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the Oracle Cloud ID (OCID) of a tenancy that Oracle JDBC 
   * authenticates with when requesting access tokens.
   * 

   * This property is required when
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to OCI_TOKEN.
   * 

   * This property is optional when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to OCI_API_KEY or OCI_INTERACTIVE. If this property is not set, 
   * then the tenancy OCID is read from a 
   * {@linkplain #CONNECTION_PROPERTY_OCI_PROFILE profile} of an
   * {@linkplain #CONNECTION_PROPERTY_OCI_CONFIG_FILE OCI configuration file}.
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_TENANCY parameter,
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_TENANCY = "oracle.jdbc.ociTenancy";
  public static final String CONNECTION_PROPERTY_OCI_TENANCY_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_TENANCY_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the Oracle Cloud ID (OCID) of a compartment as the scope for
   * access tokens requested by Oracle JDBC.
   * 

   * It is recommended to constrain the scope by configuring both this property
   * and
   * {@linkplain #CONNECTION_PROPERTY_OCI_DATABASE oracle.jdbc.ociDatabase}.
   * 

   * If this property is not set, then access to all databases within the
   * tenancy identified by 
   * {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy} or an
   * OCI config file is requested.
   * 

   * This property is optional when 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to OCI_TOKEN, or when
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to OCI_API_KEY, OCI_INSTANCE_PRINCIPAL, OCI_RESOURCE_PRINCIPAL,
   * OCI_DELEGATION_TOKEN, or OCI_INTERACTIVE.
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_COMPARTMENT 
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_COMPARTMENT = "oracle.jdbc.ociCompartment";
  public static final String CONNECTION_PROPERTY_OCI_COMPARTMENT_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_COMPARTMENT_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the Oracle Cloud ID (OCID) of a database as the scope for
   * access tokens requested by Oracle JDBC. If this property is set, then 
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   * must also be set to the OCID of the database's compartment.
   * 

   * It is recommended to constrain the scope by configuring both this property 
   * and
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}.
   * 

   * If this property is not set, then access to all databases within a 
   * compartment identified by 
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment}
   * is requested. If neither this property nor
   * {@linkplain #CONNECTION_PROPERTY_OCI_COMPARTMENT oracle.jdbc.ociCompartment} is
   * set, then access to all databases within the tenancy identified by 
   * {@linkplain #CONNECTION_PROPERTY_OCI_TENANCY oracle.jdbc.ociTenancy} or an
   * OCI config file is requested.
   * 

   * This property is optional when
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to OCI_TOKEN, or when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to OCI_API_KEY, OCI_INSTANCE_PRINCIPAL, OCI_RESOURCE_PRINCIPAL,
   * OCI_DELEGATION_TOKEN, or OCI_INTERACTIVE.
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_DATABASE parameter,
   * then the value of that parameter takes precedence over a value defined by 
   * this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_DATABASE = "oracle.jdbc.ociDatabase";
  public static final String CONNECTION_PROPERTY_OCI_DATABASE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_DATABASE_ACCESSMODE = 15; 
  /** 
   * This property controls whether the driver will be committing all SELECT
   * statements when autocommit is enabled.
   * 
   * It is preferable to leave this property to its default value: false.
   * 
   * 
   * SELECT statements involving a DB link will open a transaction unless this property is set to true.
   * 
   * 
   * This property is only supported by the Oracle JDBC Thin driver
   * (ie: jdbc:oracle:thin).
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_COMMIT_SELECT_ON_AUTOCOMMIT = "oracle.jdbc.commitSelectOnAutocommit";
  public static final String CONNECTION_PROPERTY_COMMIT_SELECT_ON_AUTOCOMMIT_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_COMMIT_SELECT_ON_AUTOCOMMIT_ACCESSMODE = 15; 
  /** 
   * This property sets the default return type of {@code getObject()} methods when the column type is
   * JSON. Specifically, this property controls the return type of the following methods:
   * 
   * 
- {@link java.sql.ResultSet#getObject(int)}
   * 
- {@link java.sql.ResultSet#getObject(String)}
   * 
- {@link java.sql.CallableStatement#getObject(int)}
   * 
- {@link java.sql.CallableStatement#getObject(String)}
   * 
   * 
   * If this property is not set, the above mentioned methods will throw an exception when the
   * column type is JSON.
   * 
   * The return types supported are:
   * 
   * 
- java.lang.String
   * 
- java.io.Reader
   * 
- java.io.InputStream
   * 
- oracle.sql.json.OracleJsonValue
   * 
- jakarta.json.JsonValue
   * 
- oracle.sql.json.OracleJsonParser
   * 
- jakarta.json.stream.JsonParser
   * 
- oracle.sql.json.OracleJsonDatum
   * 
   * 
   * The following example sets the default type to {@code oracle.sql.json.OracleJsonValue}:
   * 
   *   OracleDataSource ods = new oracle.jdbc.pool.OracleDataSource();
   *   ods.setURL(DB_URL);
   *   ods.setUser(DB_USER);
   *   ods.setPassword(DB_PASSWORD);
   *   Properties prop = new Properties();
   *   prop.setProperty(OracleConnection.CONNECTION_PROPERTY_JSON_DEFAULT_GET_OBJECT_TYPE,
   *                    "oracle.sql.json.OracleJsonValue");
   *   ods.setConnectionProperties(props);
   *   Connection conn = ods.getConnection();
   *   Statement stmt = conn.createStatement();
   *   ResultSet rs = stmt.executeQuery(SQL_QUERY);
   *   // to get the first record.
   *   rs.next();
   *   OracleJsonValue ojv = (OracleJsonValue) rs.getObject(COLUMN_NAME);
   * 
   * Alternatively, the required object type can also be obtained using {@link java.sql.ResultSet#getObject(int,java.lang.Class)} .
   * 
   *   OracleJsonValue ojv = (OracleJsonValue) rs.getObject(COLUMN_NAME,OracleJsonValue.class);
   * 
   * 
   * @see java.sql.ResultSet#getObject(int)
   * @see java.sql.ResultSet#getObject(String)
   * @see java.sql.ResultSet#getObject(String,java.lang.Class)
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_JSON_DEFAULT_GET_OBJECT_TYPE = "oracle.jdbc.jsonDefaultGetObjectType";
  public static final String CONNECTION_PROPERTY_JSON_DEFAULT_GET_OBJECT_TYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_JSON_DEFAULT_GET_OBJECT_TYPE_ACCESSMODE = 15; 
  /** 
   * 
   * This property configures an access token that Oracle JDBC uses for
   * authentication with Oracle Database. An access token configured with this
   * property will only be used if neither a user name nor password has been 
   * provided when creating a new connection. If a user name or a password is 
   * provided, via connection properties, programmatic APIs, or by any other 
   * means, then the value of this property is ignored.
   * 

   * If a value is configured for this property, then Oracle JDBC will ignore
   * any token that is specified by 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} and
   * {@link #CONNECTION_PROPERTY_TOKEN_LOCATION}.
   * 

   * The value of this property must be a JSON Web Token (JWT). The JWT format 
   * is specified by 
   * RFC 7519 (https://datatracker.ietf.org/doc/html/rfc7519).
   * 

   * The database instance that Oracle JDBC connects to must be configured to 
   * validate the token with the service that issued it. The Oracle Database 
   * Security Guide specifies how to configure the database for token based
   * authentication with 
   * 
   * Oracle Cloud
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/authenticating-and-authorizing-iam-users-oracle-dbaas-databases.html)
   * and 
   * 
   * Azure 
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/authenticating-and-authorizing-microsoft-entra-id-azure-ad-users-oracle-databases.html)
   * 

   * On systems where access tokens are stored in environment variables, it may
   * be useful to note that an 
   * {@linkplain #CONNECTION_PROPERTY_CONFIG_FILE ojdbc.properties} file can
   * include expressions that resolve to the value of an environment variable.
   * For example, this line in ojdbc.properties would configure this property
   * as the value of an environment variable named "DATABASE_ACCESS_TOKEN":
   * 

   * oracle.jdbc.accessToken=${DATABASE_ACCESS_TOKEN}
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_ACCESS_TOKEN = "oracle.jdbc.accessToken";
  public static final String CONNECTION_PROPERTY_ACCESS_TOKEN_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_ACCESS_TOKEN_ACCESSMODE = 13; 
  /** 
   * 
   * When this property is enabled, {@code Blob}, {@code Clob}, and 
   * {@code NClob} objects retain copies of their prefetched data until freed.
   * This property is enabled by default. 
   * 

   * Disabling this property configures the driver to aggressively free memory 
   * that has been allocated for prefetched LOB data. When the value of this 
   * property is set to "false", {@link java.sql.Blob}, 
   * {@link java.sql.Clob}, and {@link java.sql.NClob} objects created by a
   * {@link java.sql.ResultSet} will release prefetched data when the cursor is
   * repositioned (by {@code next()}, {@code absolute(int)}, etc), or when the 
   * the {@code ResultSet} is closed.
   * 

   * 
   * Typically, it is best to leave this property as enabled (the default).
   * 
   * Reading data that is retained in local memory is much faster than reading 
   * it from a remote database. Disabling this property may cause unexpected 
   * performance regressions for existing code, where LOBs are read after their
   * {@code ResultSet} is repositioned or closed. However, in cases where LOBs 
   * are not read after repositioning or closing their {@code ResultSet},
   * and LOBs are not explicitly freed, retaining a copy of unused 
   * prefetched data will hinder performance.
   * 

   * Programmers are strongly encouraged to make use of 
   * {@link java.sql.Blob#free()} and {@link java.sql.Clob#free()}. These 
   * methods signal when it is safe for the driver to release the resources of 
   * a LOB. If a LOB has been freed, then no copy of its prefetched data will
   * be retained. This property should be set to {@code false} only in cases
   * where it infeasible to invoke the {@code free()} method, and it is known 
   * that LOBs are not read after repositioning or closing a {@code ResultSet}.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_RETAIN_LOB_PREFETCH_DATA = "oracle.jdbc.retainLobPrefetchData";
  public static final String CONNECTION_PROPERTY_RETAIN_LOB_PREFETCH_DATA_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_RETAIN_LOB_PREFETCH_DATA_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the file system path of a 
   * 
   * configuration file for the OCI SDK and CLI.
   *  (https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm)
   * This property is optional when
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to OCI_API_KEY or OCI_INTERACTIVE.
   * 

   * If no value is specified for this property, then configuration is read from
   * a default location of: {@code $HOME/.oci/config}
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_CONFIG_FILE 
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_CONFIG_FILE = "oracle.jdbc.ociConfigFile";
  public static final String CONNECTION_PROPERTY_OCI_CONFIG_FILE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_OCI_CONFIG_FILE_ACCESSMODE = 7; 
  /** 
   * 
   * Specifies the name of a profile in a 
   * 
   * configuration file for the OCI SDK and CLI.
   *  (https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm)
   * This property is optional when
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to OCI_API_KEY or OCI_INTERACTIVE.
   * 

   * If no value is specified for this property, then configuration is read from
   * a profile with the name DEFAULT.
   * 

   * If an Oracle Net Descriptor style URL includes the OCI_PROFILE
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_OCI_PROFILE = "oracle.jdbc.ociProfile";
  public static final String CONNECTION_PROPERTY_OCI_PROFILE_DEFAULT = "DEFAULT";
  public static final byte CONNECTION_PROPERTY_OCI_PROFILE_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the application ID URI of a database registered with Azure. This
   * property is required when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is set to
   * AZURE_SERVICE_PRINCIPAL, AZURE_MANAGED_IDENTITY, or 
   * AZURE_INTERACTIVE. This property is also required when 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication} is set to 
   * AZURE_TOKEN.
   * 

   * If an Oracle Net Descriptor style URL includes the AZURE_DB_APP_ID
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI = "oracle.jdbc.azureDatabaseApplicationIdUri";
  public static final String CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_AZURE_DB_APP_ID_URI_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the ID of an Azure tenant that Oracle JDBC authenticates with 
   * when requesting access tokens. This property is optional when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to AZURE_SERVICE_PRINCIPAL or AZURE_INTERACTIVE. This property is 
   * also optional when 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to AZURE_TOKEN.
   * 

   * If no value is specified for this property, then Oracle JDBC authenticates
   * with the tenant configured by environment variables of the 
   * 
   * Azure SDK for Java
   *  (https://azuresdkdocs.blob.core.windows.net/$web/java/azure-identity/1.5.3/index.html#environment-variables)
   * 

   * If an Oracle Net Descriptor style URL includes the TENANT_ID
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_TENANT_ID = "oracle.jdbc.tenantId";
  public static final String CONNECTION_PROPERTY_TENANT_ID_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_TENANT_ID_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the ID of an Azure client that Oracle JDBC authenticates as
   * when requesting access tokens. This property is optional when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to AZURE_SERVICE_PRINCIPAL, AZURE_MANAGED_IDENTITY, or 
   * AZURE_INTERACTIVE. This property is also optional when 
   * {@linkplain #CONNECTION_PROPERTY_PASSWORD_AUTHENTICATION oracle.jdbc.passwordAuthentication}
   * is set to AZURE_TOKEN.
   * 

   * If no value is specified for this property, then Oracle JDBC authenticates
   * as the client configured by environment variables of the 
   * 
   * Azure SDK for Java
   *  (https://azuresdkdocs.blob.core.windows.net/$web/java/azure-identity/1.5.3/index.html#environment-variables)
   * 

   * If an Oracle Net Descriptor style URL includes the CLIENT_ID
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_CLIENT_ID = "oracle.jdbc.clientId";
  public static final String CONNECTION_PROPERTY_CLIENT_ID_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CLIENT_ID_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the secret string for an Azure client that Oracle JDBC 
   * authenticates as when requesting access tokens. This property is optional
   * when {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is set to
   * AZURE_SERVICE_PRINCIPAL.
   * 

   * If no value is specified for this property, then Oracle JDBC authenticates
   * with the client secret configured by environment variables of the 
   * 
   * Azure SDK for Java
   *  (https://azuresdkdocs.blob.core.windows.net/$web/java/azure-identity/1.5.3/index.html#environment-variables)
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_CLIENT_SECRET = "oracle.jdbc.clientSecret";
  public static final String CONNECTION_PROPERTY_CLIENT_SECRET_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CLIENT_SECRET_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the file system path of a certificate for an Azure client that 
   * Oracle JDBC authenticates as when requesting access tokens. This property 
   * is optional when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to AZURE_SERVICE_PRINCIPAL.
   * 

   * If no value is specified for this property, then Oracle JDBC authenticates
   * with the client certificate configured by environment variables of the 
   * 
   * Azure SDK for Java
   *  (https://azuresdkdocs.blob.core.windows.net/$web/java/azure-identity/1.5.3/index.html#environment-variables)
   * 

   * If an Oracle Net Descriptor style URL includes the CLIENT_CERTIFICATE
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 

   * The value of this property is ignored if a
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET client secret} has been
   * configured by a connection property, descriptor parameter, or SEPS wallet.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_CLIENT_CERTIFICATE = "oracle.jdbc.clientCertificate";
  public static final String CONNECTION_PROPERTY_CLIENT_CERTIFICATE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CLIENT_CERTIFICATE_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the password of a PFX certificate configured by
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE oracle.jdbc.clientCertificate}. 
   * This property 
   * is optional when 
   * {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}
   * is set to AZURE_SERVICE_PRINCIPAL.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_CLIENT_CERTIFICATE_PASSWORD = "oracle.jdbc.clientCertificatePassword";
  public static final String CONNECTION_PROPERTY_CLIENT_CERTIFICATE_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_CLIENT_CERTIFICATE_PASSWORD_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the redirect URI for an Azure client that 
   * Oracle JDBC authenticates as when requesting access tokens. This property 
   * is required when {@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication} is set 
   * to AZURE_INTERACTIVE.
   * 
   * 

   * If an Oracle Net Descriptor style URL includes the REDIRECT_URI
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_REDIRECT_URI = "oracle.jdbc.redirectUri";
  public static final String CONNECTION_PROPERTY_REDIRECT_URI_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_REDIRECT_URI_ACCESSMODE = 15; 
  /** 
   * Use this system property to enable error url to appear in the error message.
   * The default value is true
   * @since 23ai
 
   **/
  public static final String CONNECTION_PROPERTY_ENABLE_ERROR_URL = "oracle.jdbc.enableErrorUrl";
  public static final String CONNECTION_PROPERTY_ENABLE_ERROR_URL_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_ENABLE_ERROR_URL_ACCESSMODE = 2;  
  /** 
   * 
   * This property controls whether the driver will pre-process queries for the
   * Parameter Metadata API.
   * 

   * If set to true, the driver will compress all IN clauses with multiple
   * bind variables to an IN clause with a single bind variable.
   * This addresses some performance issues when using the Parameter Metadata
   * API with SQL queries containing IN clauses with thousands of bind variables (or parameters).
   * 
   * @since 23
 
   **/
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_PREPROCESS = "oracle.jdbc.parameterMetadataPreprocess";
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_PREPROCESS_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_PARAMETER_METADATA_PREPROCESS_ACCESSMODE = 7; 
  /** 
   * 
   * The maximum number of statements that will be stored in the parameter
   * metadata cache. The default is 0 which disables the parameter metadata cache.
   * If set to a value greater than 0, the parameter metadata cache is
   * enabled.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_SIZE = "oracle.jdbc.parameterMetadataCacheSize";
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_SIZE_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_SIZE_ACCESSMODE = 2; 
  /** 
   * 
   * If we should include the parsing information with the parameter metadata cache.
   * This allows fast re-query of types in the database at the cost of a larger cache size.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_INCLUDE_PARSING = "oracle.jdbc.parameterMetadataCacheIncludeParsing";
  public static final String CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_INCLUDE_PARSING_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_PARAMETER_METADATA_CACHE_INCLUDE_PARSING_ACCESSMODE = 2; 
  /** 
   * 
   * The property is used to disable the whitelist filtering of properties that can be set by a remote provider.
   * The default value of the property is "true" which means that filtering is enabled and in that case
   * only the whitelisted properties can be set by the remote provider.
   * If the property is set to "false", the remote provider can set all the properties.
   * 

   * If an application is multi-tenant and if the tenants can configure their
   * JDBC URL then it's highly recommended to not disable the filtering.
   * Filtering can be disabled in a single-tenant application server.
   * 

   * Not all the properties are whitelisted due to security reasons. Only the properties
   * that do not access the FileSystem or configure classes on the ClassPath are whitelisted.
   * The list of properties whitelisted for remote configuration can be retrieved by using
   * connection.getProviderAllowedProperties().
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_REMOTE_CONFIGURATION_FILTERING = "oracle.jdbc.remoteConfigurationFiltering";
  public static final String CONNECTION_PROPERTY_REMOTE_CONFIGURATION_FILTERING_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_REMOTE_CONFIGURATION_FILTERING_ACCESSMODE = 3;     
  /** 
   * 
   * The property is used to enable prefetching of full lob data for Value Based Lobs (VBLs).
   * If the property value is set to "true", the server sends full lob data for value lobs 
   * irrespective of the lob prefetch size set by the application. 
   * The default value of this property is "false".
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_SEND_ALL_DATA_FOR_VALUE_LOBS = "oracle.jdbc.sendAllDataForValueLobs";
  public static final String CONNECTION_PROPERTY_SEND_ALL_DATA_FOR_VALUE_LOBS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_SEND_ALL_DATA_FOR_VALUE_LOBS_ACCESSMODE = 7; 
  /** 
  * This property should no longer be used, oracle.jdbc.sendBooleanAsNativeBoolean should be used instead.
  * @deprecated
 
   **/
  public static final String CONNECTION_PROPERTY_SEND_BOOLEAN_IN_PLSQL = "oracle.jdbc.sendBooleanInPLSQL";
  public static final String CONNECTION_PROPERTY_SEND_BOOLEAN_IN_PLSQL_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_SEND_BOOLEAN_IN_PLSQL_ACCESSMODE = 3; 
  /** 
   * 
   * This property controls how the driver sends a Boolean parameter. 
   * By default, it sends it as a BOOLEAN type (new type in 23ai), but if this property is set to 
   * "false" then the value will be sent as a VARNUM which was the default behavior until 23ai. 
   * This is useful when a PLSQL procedure with a NUMBER parameter is used and it 
   * is set by calling the setBoolean JDBC API or setBoolean is used to insert a value in 
   * a table with a VARCHAR2(1) type column.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_SEND_BOOLEAN_AS_NATIVE_BOOLEAN = "oracle.jdbc.sendBooleanAsNativeBoolean";
  public static final String CONNECTION_PROPERTY_SEND_BOOLEAN_AS_NATIVE_BOOLEAN_DEFAULT = "true";
  public static final byte CONNECTION_PROPERTY_SEND_BOOLEAN_AS_NATIVE_BOOLEAN_ACCESSMODE = 3; 
  /** 
   * 
   * This property specifies in which state the database should be for the connection to succeed.
   * By default, the value is "NOMOUNT", but if the property is set to "MOUNT" then it means that the
   * DB is expected to be in MOUNT state.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_DATABASE_STATE_REQUIREMENT = "oracle.jdbc.databaseStateRequirement";
  public static final String CONNECTION_PROPERTY_DATABASE_STATE_REQUIREMENT_DEFAULT = "NOMOUNT";
  public static final byte CONNECTION_PROPERTY_DATABASE_STATE_REQUIREMENT_ACCESSMODE = 3; 
  /** 
   * 
   * This system property is used to allow the mixing of JDBC bind notation (?) and named
   * bind notation (:bind) in the same statement.
   * The default value of the property is "false" which means the driver will error out
   * when encountering JDBC binds and named binds in the same statement.
   * If the property is set to "true", the driver will allow mixing bind parameter types.
   * 

   * It is strongly recommended to leave this property to its default value: "false".
   * 

   * Mixing JDBC bind parameters and named binds in the same statement is not supported
   * and such statement should be fixed.
   * Because the driver used to accept these statements, this property can be set to true
   * for backward compatibility.
   * 
 
   **/
  public static final String CONNECTION_PROPERTY_ALLOW_MIXING_JDBC_AND_NAMED_BINDS = "oracle.jdbc.allowMixingJdbcAndNamedBinds";
  public static final String CONNECTION_PROPERTY_ALLOW_MIXING_JDBC_AND_NAMED_BINDS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ALLOW_MIXING_JDBC_AND_NAMED_BINDS_ACCESSMODE = 2; 
  /** 
   * 
   * This property is used to allow single shard transaction support when using sharding datasource.
   * When the property value is set to "true", transactions can be started on direct shard, while 
   * setting the property value to "false" indicates that the transactions will always be started 
   * on the catalog database.
   * The default value of the property is "false".
   * 

   * This feature can be enabled in following ways:
   * 

-    * 
   * Properties prop = new Properties();
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_USE_SHARDING_DRIVER_CONNECTION,"true");  
   * prop.setProperty(OracleConnection.CONNECTION_PROPERTY_ALLOW_SINGLE_SHARD_TRANSACTION_SUPPORT,"true");
   * 
   * 
   * 
-    * 
   * -Doracle.jdbc.useShardingDriverConnection=true
   * -Doracle.jdbc.allowSingleShardTransactionSupport=true
   * 
   * 
   * 
-    * 
   * "jdbc:oracle:thin:@//host:port/service?oracle.jdbc.useShardingDriverConnection=true&oracle.jdbc.allowSingleShardTransactionSupport=true"
   * 
   * 
   * 
   * 
   * @see #CONNECTION_PROPERTY_USE_SHARDING_DRIVER_CONNECTION
 
   **/
  public static final String CONNECTION_PROPERTY_ALLOW_SINGLE_SHARD_TRANSACTION_SUPPORT = "oracle.jdbc.allowSingleShardTransactionSupport";
  public static final String CONNECTION_PROPERTY_ALLOW_SINGLE_SHARD_TRANSACTION_SUPPORT_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ALLOW_SINGLE_SHARD_TRANSACTION_SUPPORT_ACCESSMODE = 3; 
  /** 
   * 
   * This property configures the maximum amount of memory allocated
   * by {@link PreparedStatement#executeBatch()} and
   * {@link PreparedStatement#executeLargeBatch()} when converting Java bind
   * values to SQL data types. The value of this property is an amount of bytes.
   * The default value is 0, which configures no maximum.
   * 

   * If this property is configured as a non-zero value, then 
   * executeBatch and executeLargeBatch may execute
   * multiple database calls to complete a batch DML operation. Each 
   * database call will include no more than M bytes of bind values, where M is
   * the value configured by this property. For example, if this property is set
   * to "2000000", then a batch DML operation with 4,000,000 bytes of bind 
   * values will be executed as two database calls: Each call will include
   * 2,000,000 bytes of bind values.
   * 

   * A single set of bind values added by {@link PreparedStatement#addBatch()}
   * may require more memory than the maximum configued by this property. The
   * configured maximum is ignored in this case, and the batch DML operation 
   * will execute a database call that includes just this single set of bind
   * values.
   * 

   * Executing multiple database calls can significantly increase the amount
   * of time required to complete a batch DML operation when compared to
   * a single database call. The trade-off between memory usage and response 
   * time must be considered when configuring this property.
   * 

   * Prior to the 23.4 release, the maximum amount of memory was fixed at
   * 2,097,152 bytes. If consistent behavior is required, this fixed limit may
   * be restored by setting this property as:
   * 

   * oracle.jdbc.maxBatchMemory=2097152 
   * 
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_MAX_BATCH_MEMORY = "oracle.jdbc.maxBatchMemory";
  public static final String CONNECTION_PROPERTY_MAX_BATCH_MEMORY_DEFAULT = "0";
  public static final byte CONNECTION_PROPERTY_MAX_BATCH_MEMORY_ACCESSMODE = 15; 
  /** 
   * 
   * This property sets the default return type of getObject()
   * methods when the column type is VECTOR. Specifically, this property 
   * controls the return type of the following methods:
   * 

   * 
- {@link java.sql.ResultSet#getObject(int)}
   * 
- {@link java.sql.ResultSet#getObject(String)}
   * 
- {@link java.sql.CallableStatement#getObject(int)}
   * 
- {@link java.sql.CallableStatement#getObject(String)}
   * 

   * If this property is not set, the above mentioned methods will throw an 
   * exception when the column type is VECTOR.
   * 

   * The return types supported are:
   * 

-    * double[]
   * 
-    * float[]
   * 
-    * long[]
   * 
-    * int[]
   * 
-    * short[]
   * 
-    * byte[]
   * 
-    * boolean[]
   * 
-    * String
   * 
-    * Clob
   * 
-    * {@link oracle.sql.VECTOR}
   * 

   * More details about these conversions are specified in the JavaDocs of 
   * {@link OracleType#VECTOR}, {@link OracleType#VECTOR_INT8},
   * {@link OracleType#VECTOR_FLOAT32}, and {@link OracleType#VECTOR_FLOAT64}.
   * 

   * In addition to the type names listed above, this property may also be set
   * to the value of: "preferred-array-class". When set to this value, 
   * getObject methods return an instance of the 
   * {@link VectorMetaData#arrayClass() preferred array class} for each VECTOR
   * type:
   * 

-    * {@linkplain OracleType#VECTOR Untyped VECTOR} -> double[]
   * 
-    * {@linkplain OracleType#VECTOR_FLOAT64 FLOAT64 VECTOR} -> double[]
   * 
-    * {@linkplain OracleType#VECTOR_FLOAT32 FLOAT32 VECTOR} -> float[]
   * 
-    * {@linkplain OracleType#VECTOR_INT8 INT8 VECTOR} -> byte[]
   * 

   * The following example sets the default type to double[]
   * 
{@code
   *   double[] queryVector() throws SQLException {
   *     Properties connectionProperties = new Properties();
   *     connectionProperties.setProperty(
   *       "oracle.jdbc.vectorDefaultGetObjectType",
   *       "double[]");
   *     ... set other properties like username and password, if needed ...
   *     try (
   *       Connection connection =
   *         DriverManager.getConnection("jdbc:oracle:thin:@example", connectionProperties);
   *       Statement statement = connection.createStatement();
   *       ResultSet resultSet = statement.executeQuery(
   *         "SELECT vectorColumn FROM example");) {
   *
   *       resultSet.next();
   *       return (double[])resultSet.getObject(1);
   *     }
   *   }
   * }
   * Alternatively, the required object type can also be obtained using
   * {@link java.sql.ResultSet#getObject(int,java.lang.Class)} .
   * 
   *   double[] vector = resultSet.getObject(1, double[].class);
   * 
   * 
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_VECTOR_DEFAULT_GET_OBJECT_TYPE = "oracle.jdbc.vectorDefaultGetObjectType";
  public static final String CONNECTION_PROPERTY_VECTOR_DEFAULT_GET_OBJECT_TYPE_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_VECTOR_DEFAULT_GET_OBJECT_TYPE_ACCESSMODE = 15; 
  /** 
   * 
This system property can be used to disable bug fixes when these fixes create a
   * backward compatibility issue for existing applications that may rely on the
   * bogus behavior. The value can be set to a comma-separated list of bug numbers
   * which fixes need to be disabled.
   * 
By default, this property is empty and, therefore, all the bug fixes are
   * enabled.
   * 
For example, to disable bug fixes 123123123 and 324324324 you can set this
   * system property to:
   * 
 {@code java -Doracle.jdbc.disabledBugFixes=123123123,324324324 ...} 
   * 
   * 
Note:  Bug numbers can have the BUG_ prefix
   * which is optional and case-insensitive, meaning that BUG_123123123
   * and bug_123123123 are also valid inputs.
   * 
   * 
The list of bug fixes that can be turned off can be found in the {@link
   * oracle.jdbc.SwitchableBugFix.BugNumber} enum.
   *
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_DISABLED_BUG_FIXES = "oracle.jdbc.disabledBugFixes";
  public static final String CONNECTION_PROPERTY_DISABLED_BUG_FIXES_DEFAULT = "";
  public static final byte CONNECTION_PROPERTY_DISABLED_BUG_FIXES_ACCESSMODE = 2; 
  /** 
   * 
This system property can be used to configure the maximum size in bytes of the client's query ResultSet cache.
   * 
The default value is -1.
   * 
Specifying a size less than 32768 disables client result cache for this JVM.
   * 
For example, to configure the max cache size on the client, you can set this
   * property to:
   * 
 {@code java -Doracle.jdbc.queryResultCacheMaxSize=65536 ...} 
   * 
   * 
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_SIZE = "oracle.jdbc.queryResultCacheMaxSize";
  public static final String CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_SIZE_DEFAULT = "-1";
  public static final byte CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_SIZE_ACCESSMODE = 2; 
  /** 
   * 
This system property can be used to configure the maximum time (in milliseconds) of the client's query ResultSet cache lag.
   * 
The default value is -1.
   * 
For example, to configure the max cache lag on the client, you can set this
   * property to:
   * 
 {@code java -Doracle.jdbc.queryResultCacheMaxLag=6000 ...} 
   * 
   *
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_LAG = "oracle.jdbc.queryResultCacheMaxLag";
  public static final String CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_LAG_DEFAULT = "-1";
  public static final byte CONNECTION_PROPERTY_QUERY_RESULT_CACHE_MAX_LAG_ACCESSMODE = 2; 
  /** 
   * 
This system property can be used to indicate which configuration providers can be
   * used by the driver. This value can be "(ALL)" (all providers are enabled) or "(NONE)" (all providers are 
   * disabled) or a comma-separated names of allowed providers (case sensitive) between parenthesis.
   * 
By default, all providers are enabled. The value is set to "(ALL)".
   * 
The value is correlated to the type of the {@link oracle.jdbc.spi.OracleConfigurationProvider}. If the
   * provider is present in the classpath but its type is not in this list (or the value is different than '(ALL)')
   * then the provider will not be loaded and an error will be raised if an URL with its type is defined.
   * 
For more information, please read the documentation in {@link oracle.jdbc.spi.OracleConfigurationProvider}.
   *
   * @since 23.4
 
   **/
  public static final String CONNECTION_PROPERTY_CONFIGURATION_PROVIDERS = "oracle.jdbc.configurationProviders";
  public static final String CONNECTION_PROPERTY_CONFIGURATION_PROVIDERS_DEFAULT = "(ALL)";
  public static final byte CONNECTION_PROPERTY_CONFIGURATION_PROVIDERS_ACCESSMODE = 2; 
  /** 
   * 
Set this property to "true" to process XA transactions as sessionless
   * transactions.
   * The benefit is performance, as sessionless transaction operations can be
   * piggybacked.
   * But there are limitations: sessionless transactions are not truly global
   * and can't have more than one branch.
   * 
The default value of the property is "false".
   *
   * @since 23.6
 
   **/
  public static final String CONNECTION_PROPERTY_XA_THROUGH_SESSIONLESS_TRANSACTIONS = "oracle.jdbc.XAThroughSessionlessTransactions";
  public static final String CONNECTION_PROPERTY_XA_THROUGH_SESSIONLESS_TRANSACTIONS_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_XA_THROUGH_SESSIONLESS_TRANSACTIONS_ACCESSMODE = 15; 
  /** 
   * 
   * Specifies the location of an Oracle wallet containing a client secret
   * for authentication with Azure. Where "{CLIENT_ID}" is an Azure client ID,
   * Oracle JDBC will search the wallet for a secret named:
   * 

   * oracle.security.azure.credential.{CLIENT_ID}
   * 

   * The {CLIENT_ID} can be configured as a 
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_ID connection property or descriptor parameter}
   * 

   * This property is ignored if a client secret or client certificate are 
   * configured with
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_SECRET oracle.jdbc.clientSecret}
   * or
   * {@linkplain #CONNECTION_PROPERTY_CLIENT_CERTIFICATE oracle.jdbc.clientCertificate}
   * 

   * If an Oracle Net Descriptor style URL includes the AZURE_CREDENTIALS
   * parameter, then the value of that parameter takes precedence over a value 
   * defined by this property.
   * 
   * @since 23.6
 
   **/
  public static final String CONNECTION_PROPERTY_AZURE_CREDENTIALS = "oracle.jdbc.azureCredentials";
  public static final String CONNECTION_PROPERTY_AZURE_CREDENTIALS_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_AZURE_CREDENTIALS_ACCESSMODE = 15; 
  /** 
   * 
   * Controls whether the {@link oracle.jdbc.spi.OracleConfigurationProvider}
   * overrides connection properties set with other methods.
   * 

   * This is a system property that determines the precedence of connection
   * properties.
   * If set to true, the provider takes precedence and overrides existing 
   * connection properties.
   * If set to false (default), the driver's predefined properties take 
   * precedence, and only missing properties will be filled in by the provider.
   * 

   * For more details on the configuration precedence, refer to the
   * "Precedence" section in {@link #CONNECTION_PROPERTY_CONFIG_FILE}.
   * 
   *
   * @since 23.9

   **/
  public static final String CONNECTION_PROPERTY_ENABLE_PROVIDER_OVERRIDE = "oracle.jdbc.enableProviderOverride";
  public static final String CONNECTION_PROPERTY_ENABLE_PROVIDER_OVERRIDE_DEFAULT = "false";
  public static final byte CONNECTION_PROPERTY_ENABLE_PROVIDER_OVERRIDE_ACCESSMODE = 2; //;
  // ------------------ END ------------------------------------------------------

  /**
   * The value of this property is used as the password when connecting to the
   * database.
   */
  public static final String CONNECTION_PROPERTY_PASSWORD = "password";
  public static final String CONNECTION_PROPERTY_PASSWORD_DEFAULT = null;
  // Password should not have SYSTEMPROP because that would allow it to be set 
  // plain text on the command line.
  public static final byte CONNECTION_PROPERTY_PASSWORD_ACCESSMODE = 
    ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP;
  public static final String CONNECTION_PROPERTY_SERVER = "server";
  public static final String CONNECTION_PROPERTY_SERVER_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_SERVER_ACCESSMODE = ACCESSMODE_JAVAPROP;

  /** 
   * 
   * Identifies the name of a {@link oracle.jdbc.spi.ConnectionStringProvider} that
   * provides a
   * 
   * connection string
   *  (https://docs.oracle.com/en/database/oracle/oracle-database/21/jjdbc/data-sources-and-URLs.html#GUID-C4F2CA86-0F68-400C-95DA-30171C9FB8F0) for establishing a network connection to Oracle Database.
   * 

   * The provider is not used if a database specifier has been configured in
   * any other way:
   * 

-    * A JDBC URL having any character other than a single "@" symbol between
   * the prefix of {@code jdbc:oracle:{thin|oci|kprb}} and an optional query
   * section beginning with a "?" symbol.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_DATABASE oracle.jdbc.database}"
   * connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_SERVER server}" connection  property.
   * 
-    * Any proprietary API that exposes methods to configure a connection string,
   * such as a connection pool {@code DataSource}.
   * 
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_CONNECTION_STRING = "oracle.jdbc.provider.connectionString";
  public static final String CONNECTION_PROPERTY_PROVIDER_CONNECTION_STRING_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROVIDER_CONNECTION_STRING_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP;

  /** 
   * 
   * Identifies the name of a {@link oracle.jdbc.spi.UsernameProvider} that
   * provides a user name for database authentication.
   * 

   * The provider is not used if a user name has been configured in any 
   * other way:
   * 

-    * The {@link javax.sql.DataSource#getConnection(String, String)} method.
   * 
-    * The "user/password@" element of a JDBC URL.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_USER_NAME user}" connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_USER_NAME oracle.jdbc.user}" connection
   * property.
   * 
-    * Any proprietary API that exposes methods to configure a username, such as a
   * connection pool {@code DataSource}.
   * 
   * 
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_USERNAME = "oracle.jdbc.provider.username";
  public static final String CONNECTION_PROPERTY_PROVIDER_USERNAME_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROVIDER_USERNAME_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP; 

  /** 
   * 
   * Identifies the name of a {@link oracle.jdbc.spi.PasswordProvider} that 
   * provides a password for database authentication.
   * 

   * The provider is not used if a password has been configured in any 
   * other way:
   * 

-    * The {@link javax.sql.DataSource#getConnection(String, String)} method.
   * 
-    * The "user/password@" element of a JDBC URL.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PASSWORD password}" connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PASSWORD oracle.jdbc.password}" connection
   * property.
   * 
-    * Any proprietary API that exposes methods to configure a username or
   * password, such as a connection pool {@code DataSource}.
   * 
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_PASSWORD = "oracle.jdbc.provider.password";
  public static final String CONNECTION_PROPERTY_PROVIDER_PASSWORD_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROVIDER_PASSWORD_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP; 

  /** 
   * 
   * Identifies the name of an {@link oracle.jdbc.spi.AccessTokenProvider} that
   * provide an OAUTH access token for database authentication.
   * 

   * The provider is not used if an access token has been configured in any 
   * other way:
   * 
   * 
-    * The {@link oracle.jdbc.datasource.OracleDataSource#setTokenSupplier(Supplier)}
   * method, or UCP's equivalent {@code PoolDataSource} method.
   * 
-    * The {@link OracleConnectionBuilder#accessToken(AccessToken)} method.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_ACCESS_TOKEN oracle.jdbc.accessToken}"
   * connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_TOKEN_AUTHENTICATION oracle.jdbc.tokenAuthentication}"
   * connection property.
   * 
   * 

   * The provider is not used if an username or password has been configured in
   * any other way:
   * 

-    * The {@link javax.sql.DataSource#getConnection(String, String)} method.
   * 
-    * The {@link OracleConnectionBuilder#user(String)} method.
   * 
-    * The {@link OracleConnectionBuilder#password(String)} method.
   * 
-    * The "user/password@" element of a JDBC URL.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_USER_NAME user}" connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PASSWORD password}" connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_USER_NAME oracle.jdbc.user}" connection
   * property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PASSWORD oracle.jdbc.password}" connection
   * property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PROVIDER_USERNAME oracle.jdbc.provider.username}"
   * connection property.
   * 
-    * The "{@linkplain #CONNECTION_PROPERTY_PROVIDER_PASSWORD oracle.jdbc.provider.password}"
   * connection property.
   * 
-    * Any proprietary API that exposes methods to configure a username or
   * password, such as a connection pool {@code DataSource}.
   * 
   * 
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_ACCESS_TOKEN = "oracle.jdbc.provider.accessToken";
  public static final String CONNECTION_PROPERTY_PROVIDER_ACCESS_TOKEN_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROVIDER_ACCESS_TOKEN_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP; 

  /** 
   * 
   * Identifies the name of a {@link oracle.jdbc.spi.TlsConfigurationProvider}
   * that provides keys and/or certificates for TLS communications with a
   * database.
   * 

   * The provider is not used if keys and/or certificates for TLS communications
   * have been configured in any other way:
   * 

-    * The
   * {@link oracle.jdbc.datasource.OracleDataSource#setSSLContext(SSLContext)}
   * method.
   * 
-    * The {@link OracleConnectionBuilder#sslContext(SSLContext)} method.
   * 
-    * The
   * {@linkplain #CONNECTION_PROPERTY_WALLET_LOCATION oracle.net.wallet_location}
   * connection property.
   * 
-    * The
   * {@linkplain #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_KEYSTORE javax.net.ssl.keyStore}
   * connection property.
   * 
-    * The
   * {@linkplain #CONNECTION_PROPERTY_THIN_JAVAX_NET_SSL_TRUSTSTORE javax.net.ssl.trustStore}
   * connection property.
   * 
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_TLS_CONFIGURATION = "oracle.jdbc.provider.tlsConfiguration";
  public static final String CONNECTION_PROPERTY_PROVIDER_TLS_CONFIGURATION_DEFAULT = null;
  public static final byte CONNECTION_PROPERTY_PROVIDER_TLS_CONFIGURATION_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP;

  /** 
   * 
   * Identifies the name of a {@link oracle.jdbc.spi.TraceEventListenerProvider}
   * that provides a listener for application and system tracing events.
   * 

   * The default provider uses DMS if dms.jar is in the classpath. Otherwise, it
   * does nothing.
   * 

   * The provider is not used if a listener has been configured using 
   * {@link oracle.jdbc.OracleConnectionBuilder#traceEventListener(TraceEventListener)}.
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_TRACE_EVENT_LISTENER = "oracle.jdbc.provider.traceEventListener";
  public static final String CONNECTION_PROPERTY_PROVIDER_TRACE_EVENT_LISTENER_DEFAULT = "ojdbc-default-trace-event-listener-provider";
  public static final byte CONNECTION_PROPERTY_PROVIDER_TRACE_EVENT_LISTENER_ACCESSMODE = ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP; 

  /** 
   * 
   * Identifies the provider name of a {@link oracle.jdbc.spi.JsonProvider}
   * that provides a converter for serialization and deserialization of java
   * objects to OSON bytes by implementing {@link oracle.jdbc.spi.JsonProvider}.
   * 

   * The default provider uses "jackson-json-provider" if jackson-json.jar is
   * in the classpath. Otherwise, it does nothing.
   * 

   * The default provider is not used if a provider has been configured using 
   * this property.
   * 
   */
  public static final String CONNECTION_PROPERTY_PROVIDER_JSON = "oracle.jdbc.provider.json";
  public static final String CONNECTION_PROPERTY_PROVIDER_JSON_DEFAULT = "ojdbc-default-json-provider";
  public static final byte CONNECTION_PROPERTY_PROVIDER_JSON_ACCESSMODE = ACCESSMODE_SYSTEMPROP | ACCESSMODE_JAVAPROP | ACCESSMODE_FILEPROP;
