OpenText Analytics Database 26.2.x – Creating and configuring a connection

Connecting-To: JDBC connection properties

Mon, 01 Jan 0001 00:00:00 +0000

You use connection properties to configure the connection between your JDBC client application and your OpenText™ Analytics Database. The properties provide the basic information about the connections, such as the server name and port number to use to connect to your database. They also let you tune the performance of your connection and enable logging.

You can set a connection property in one of the following ways:

Include the property name and value as part of the connection string you pass to the method DriverManager.getConnection().
Set the properties in a Properties object, and then pass it to the method DriverManager.getConnection().
Use the method VerticaConnection.setProperty(). With this approach, you can change only those connection properties that remain changeable after the connection has been established.

Also, some standard JDBC connection properties have getters and setters on the Connection interface, such as Connection.setAutoCommit().

Connection properties

The properties in the following table can only be set before you open the connection to the database. Two of them are required for every connection.

Property	Description
BinaryTransfer	Boolean value that determines which mode the database uses when connecting to a JDBC client: true: binary transfer (default) false: text transfer Binary transfer is generally more efficient at reading data from a server to a JDBC client and typically requires less bandwidth than text transfer. However, when transferring a large number of small values, binary transfer may use more bandwidth. The data output by both modes is identical with the following exceptions for certain data types: FLOAT: Binary transfer has slightly better precision. TIMESTAMPTZ: Binary transfer can fail to get the session time zone and default to the local time zone, while text transfer reliably uses the session time zone. NUMERIC: Binary transfer is forcibly disabled for NUMERIC data by the server for OpenText™ Analytics Database 11.0.2+.
ConnSettings	A string containing SQL statements that the JDBC driver automatically runs after it connects to the database. You can use this property to set the locale or schema search path, or perform other configuration that the connection requires.
Label	Sets a label for the connection on the server. This value appears in the client_label column of the SESSIONS system table. Default: `jdbc-``driver-version``-``random_number`
SSL	When set to true, use SSL to encrypt the connection to the server. The database must be configured to handle SSL connections before you can establish an SSL-encrypted connection to it. See TLS protocol. This property has been deprecated in favor of the TLSmode property. Default: false
TLSmode	TLSmode identifies the security level that OpenText™ Analytics Database applies to the JDBC connection. The database must be configured to handle TLS connections before you can establish an encrypted connection to it. For more information, see TLS protocol. Valid values are: `disable`: JDBC connects using plain text and implements no security measures. `prefer`: JDBC connects using TLS. If the server does not support TLS, JDBC connects with a channel that is not encrypted. This is the default mode. `require`: JDBC connects using TLS without verifying the CA certificate. `verify-ca`: JDBC connects using TLS and confirms that the server certificate has been signed by the certificate authority. This setting is equivalent to the deprecated `ssl=true` property. `verify-full`: JDBC connects using TLS, confirms that the server certificate has been signed by the certificate authority, and verifies that the host name matches the name provided in the server certificate. If this property and the SSL property are set, this property takes precedence. Default: prefer
Totp	Specify the current Time-based One-time Password (Totp) value. The Totp is sent to the server in the connection string for validation. If MFA is enforced and you do not provide a Totp, a dialog is displayed. You need to enter the Totp before proceeding with authentication. Totp values are generated at 30-second intervals. A Totp code remains valid for up to 90 seconds.
HostnameVerifier	If TLSmode is set to `verify-full`, this property specifies the fully qualified domain name of the verifier that you want to confirm the host name.
AuthMethod	The type of authentication to use if more than one authentication type is requested in the connection string. The options are `OAuth`, `Browser`, `Kerberos`, and `Password`. This property communicates the authentication type to be used to connect to the server. You must be granted an authentication method to use it. The different AuthMethod values and the connection parameters are: OAuth: Requires the OAuthAccessToken connection property. Browser: Triggers the browser flow to prompt for authentication in a browser window. No additional connection properties are required. Kerberos: Requires you to set the Kerberos connection parameters. These connection parameters are listed in the Kerberos table. Password: Requires you to specify the Username. The password is required depending on the type of password authentication configured for the user.
Password	Required (for non-OAuth connections), the password to use to log into the database.
User	Required (for non-OAuth connections), the database user name to use to connect to the database.
ConnectionLoadBalance	A Boolean value indicating whether the client is willing to have its connection redirected to another host in the database. This setting has an effect only if the server has also enabled connection load balancing. See About native connection load balancing for more information about native connection load balancing. Default: false
BackupServerNode	A string containing the host name or IP address of one or more hosts in the database. If the connection to the host specified in the connection string times out, the client attempts to connect to any host named in this string.The host name or IP address can also include a colon followed by the port number for the database. If no port number is specified, the client uses the standard port number ( 5433) . Separate multiple host name or IP address entries with commas.
PreferredAddressFamily	The IP version to use if the client and server have both IPv4 and IPv6 addresses and you have provided a host name, one of the following: `ipv4`: Connect to the server using IPv4. `ipv6`: Connect to the server using IPv6. `none`: Use the IP address provided by the DNS server. Default: none
KeyStorePath	The path to a `.JKS` file containing your private keys and their corresponding certificate chains. For information on creating a keystore, refer to documentation for your development environment. For information on creating a keystore, refer the Java documentation.
KeyStorePassword	The password protecting the keystore file. If individual keys are also encrypted, the keystore file password must match the password for a key within the keystore.
TrustStorePath	The path to a `.JKS` truststore file containing certificates from authorities you trust.
TrustStorePassword	The password protecting the truststore file.
workload	The name of the workload for the session. For details, see Workload routing.

OAuth connection properties

The following connection properties pertain to OAuth in JDBC.

Property	Description
oauthaccesstoken	Required if oauthrefreshtoken is unspecified, an OAuth token that authorizes a user to the database.
oauthrefreshtoken	Deprecated Use oauthaccesstoken instead. Token refresh should be handled by the client application separately. Required if oauthaccesstoken is unspecified, a token used to obtain a new access token when their old one expires. Either OAuthAccessToken or OAuthRefreshToken must be set (programmatically or manually) to authenticate to OpenText™ Analytics Database with OAuth authentication. You can omit both OAuthAccessToken and OAuthRefreshToken only if you authenticate to your identity provider directly with single sign-on through the client driver, which requires the machine running the ODBC driver to have access to a web browser. For details on the different methods for retrieving access tokens, see Retrieving access tokens. If you set this parameter, you must also set the OAuthClientSecret connection property. In cases where introspection fails (e.g. when the access token expires), OpenText™ Analytics Database responds to the request with an error. If introspection fails and OAuthRefreshToken is specified, the driver attempts to refresh and silently retrieve a new access token. Otherwise, the driver passes error to the client application.
oauthclientsecret	Deprecated Use oauthaccesstoken instead. Token refresh should be handled by the client application separately. The secret provided by your identity provider for your client.
oauthtruststorepath	Deprecated This property is deprecated, but will still be necessary if your environment requires custom CA certificates for the driver to connect to your identity provider. Versions with this property removed will not require the driver to connect to the identity provider. The path to a custom truststore. If unspecified, JDBC uses the default system truststore.
oauthtruststorepassword	Deprecated This property is deprecated, but will still be necessary if your environment requires custom CA certificates for the driver to connect to your identity provider. Versions with this property removed will not require the driver to connect to the identity provider. The password to the truststore.

Timeout properties

With the following parameters, you can specify various timeouts for each step and the overall connection of JDBC to your database.

Property	Description
LoginTimeout	The number of seconds the database waits for the client to log in to the database before throwing a `SQLException`. Default: 0 (no timeout)
LoginNodeTimeout	The number of seconds the JDBC client waits before attempting to connect to the next node if the database process is running, but does not respond. The "next" node is determined either by the BackupServerNode connection property or DNS resolution. If you only provide a single IP address, the JDBC client returns an error. A timeout value of 0 instructs JDBC to wait indefinitely for an error or a successful connection rather than attempt to connect to another node. Default: 0 (no timeout)
LoginNetworkTimeout	The number of seconds the JDBC client needs to establish a TCP connection to a database node. A typical use case for this property is to let JDBC connect to another node if the system is down for maintenance and modifying the JDBC application's connection string is not feasible. Default: 0 (no timeout)
NetworkTimeout	The number of milliseconds for the server to reply to a request after the client has established a connection with the database. Default: 0

The relationship between these properties and the role they play when JDBC attempts to connect to an OpenText™ Analytics Database is illustrated in the following diagram:

General properties

The following properties can be set after the connection is established. None of these properties are required.

Property	Description
AutoCommit	Controls whether the connection automatically commits transactions. Set this parameter to false to prevent the connection from automatically committing its transactions. Consider using AutoCommit if you are bulk loading multiple batches of data and need the ability to roll back all the loads if an error occurs. Set After Connection: `Connection.setAutoCommit()` Default: true
DirectBatchInsert	Deprecated, always set to true.
DisableCopyLocal	When set to true, disables file-based COPY LOCAL operations, including copying data from local files and using local files to store data and exceptions. You can use this property to prevent users from writing to and copying from files on the database host, including an MC host. Default: false
MultipleActiveResultSets	Allows more than one active result set on a single connection via MultipleActiveResultSets (MARS). If both MultipleActiveResultSets and ResultBufferSize are turned on, MultipleActiveResultSets takes precedence. The connection does not provide an error, however ResultBufferSize is ignored. Set After Connection: `VerticaConnection.setProperty()` Default: false
ReadOnly	When set to true, makes the data connection read-only. Any queries attempting to update the database using a read-only connection cause a `SQLException`. Set After Connection: `Connection.setReadOnly()` Default: false
ResultBufferSize	Sets the size of the buffer the database JDBC driver uses to temporarily store result sets. A value of 0 means ResultBufferSize is turned off. Note: This property was named maxLRSMemory in previous versions of the database JDBC driver. Set After Connection: `VerticaConnection.setProperty()` Default: 8912 (8KB)
SearchPath	Sets the schema search path for the connection. This value is a string containing a comma-separated list of schema names. See Setting Search Paths for more information on the schema search path. Set After Connection: `VerticaConnection.setProperty()` Default: "$user", public, v_catalog, v_monitor, v_internal
ThreePartNaming	A Boolean value that controls how DatabaseMetaData reports the catalog name. When set to true, the database name is returned as the catalog name in the database metadata. When set to false, NULL is returned as the catalog name. Enable this option if your client software is set up to get the catalog name from the database metadata for use in a three-part name reference. Set After Connection: `VerticaConnection.setProperty()` Default: true
TransactionIsolation	Sets the isolation level of the transactions that use the connection. See Changing the transaction isolation level for details. Note: In previous versions of the database JDBC driver, this property was only available using a getter and setter on the `PGConnection` object. You can now set it in the same way as other connection properties. Set After Connection: `Connection.setTransactionIsolation()` Default: TRANSACTION_READ_COMMITTED

Logging properties

The properties that control client logging must be set before the connection is opened. None of these properties are required, and none can be changed after the Connection object has been instantiated.

Property Description

LogLevel

Property	Description
LogLevel	Sets the type of information logged by the JDBC driver. The value is set to one of the following values: `"DEBUG"` `"ERROR"` `"TRACE"` `"WARNING"` `"INFO"` `"OFF"` Default: `"OFF"`
LogNameSpace	Restricts logging to just messages generated by a specific packages. Valid values are: `com.vertica` — All messages generated by the JDBC driver `com.vertica.jdbc` — All messages generated by the top-level JDBC API `com.vertica.jdbc.kv` — A ll messages generated by the JDBC KV API) `com.vertica.jdbc.core` — Connection and statement settings `com.vertica.jdbc.io` — Client/server protocol messages `com.vertica.jdbc.util` — Miscellaneous utilities `com.vertica.jdbc.dataengine` — Query execution and result set iteration `com.vertica.dataengine` — Query execution and result set iteration
LogPath	The path for the log file. Default: The current working directory

Sets the type of information logged by the JDBC driver. The value is set to one of the following values:

"DEBUG"
"ERROR"
"TRACE"
"WARNING"
"INFO"
"OFF"

Default: "OFF"

LogNameSpace

Restricts logging to just messages generated by a specific packages. Valid values are:

com.vertica — All messages generated by the JDBC driver
com.vertica.jdbc — All messages generated by the top-level JDBC API
com.vertica.jdbc.kv — A ll messages generated by the JDBC KV API)
com.vertica.jdbc.core — Connection and statement settings
com.vertica.jdbc.io — Client/server protocol messages
com.vertica.jdbc.util — Miscellaneous utilities
com.vertica.jdbc.dataengine — Query execution and result set iteration
com.vertica.dataengine — Query execution and result set iteration

LogPath

The path for the log file.

Default: The current working directory

Kerberos connection parameters

Use the following parameters to set the service and host name principals for client authentication using Kerberos.

Parameters Description

JAASConfigName

Parameters	Description
JAASConfigName	Provides the name of the JAAS configuration that contains the JAAS Krb5LoginModule and its settings Default: verticajdbc
KerberosServiceName	Provides the service name portion of the database Kerberos principal, for example: `vertichost@EXAMPLE.COM` Default: vertica
KerberosHostname	Provides the instance or host name portion of the database Kerberos principal, for example: `verticaosEXAMPLE.COM` Default: Value specified in the servername connection string property

Provides the name of the JAAS configuration that contains the JAAS Krb5LoginModule and its settings

Default: verticajdbc

KerberosServiceName

Provides the service name portion of the database Kerberos principal, for example: vertichost@EXAMPLE.COM

Default: vertica

KerberosHostname

Provides the instance or host name portion of the database Kerberos principal, for example: verticaosEXAMPLE.COM

Default: Value specified in the servername connection string property

Routable connection API connection parameters

Use the following parameters to set properties to enable and configure the connection for Routable Connection lookups.

Parameters	Description
EnableRoutableQueries	Enables Routable Connection lookup. See Routing JDBC queries directly to a single node Default: false
FailOnMultiNodePlans	If the query plan requires more than one node, then the query fails. Only applicable when EnableRoutableQueries = true. Default: true
MetadataCacheLifetime	The time in seconds to keep projection metadata. Only applicable when EnableRoutableQueries = true. Default:
MaxPooledConnections	Cluster-wide maximum number of connections to keep in the VerticaRoutableConnection’s internal pool. Only applicable when EnableRoutableQueries = true. Default: 20
MaxPooledConnections PerNode	Per-node maximum number of connections to keep in the VerticaRoutableConnection’s internal pool. Only applicable when EnableRoutableQueries = true. Default: 5

Note

You can also use VerticaConnection.setProperty() method to set properties that have standard JDBC Connection setters, such as AutoCommit.

For information about manipulating these attributes, see Setting and getting connection property values.

Connecting-To: Setting and getting connection property values

Mon, 01 Jan 0001 00:00:00 +0000

You can set a connection property in one of the following ways:

Include the property name and value as part of the connection string you pass to the method DriverManager.getConnection().
Set the properties in a Properties object, and then pass it to the method DriverManager.getConnection().
Use the method VerticaConnection.setProperty(). With this approach, you can change only those connection properties that remain changeable after the connection has been established.

Also, some standard JDBC connection properties have getters and setters on the Connection interface, such as Connection.setAutoCommit().

Setting properties when connecting

When creating a connection to OpenText™ Analytics Database, you can set connection properties by:

Specifying them in the connection string.
Modifying the Properties object passed to getConnection().

Connection string properties

You can specify connection properties in the connection string with the same URL parameter format used for usernames and passwords. For example, the following string enables a TLS connection:

"jdbc:vertica://VerticaHost:5433/db?user=UserName&password=Password&TLSmode=require"

Setting a host name using the setProperty() method overrides the host name set in a connection string. If this occurs, the database might not be able to connect to a host. For example, using the connection string above, the following overrides the VerticaHost name:

Properties props = new Properties();
props.setProperty("dataSource", dataSourceURL);
props.setProperty("database", database);
props.setProperty("user", user);
props.setProperty("password", password);
ps.setProperty("jdbcDriver", jdbcDriver);
props.setProperty("hostName", "NonVertica_host");

However, if a new connection or override connection is needed, you can enter a valid host name in the hostname properties object.

The NonVertica_host hostname overrides VerticaHost name in the connection string. To avoid this issue, comment out the props.setProperty("hostName", "NonVertica_host");line:

//props.setProperty("hostName", "NonVertica_host");

Properties object

To set connection properties with the Properties object passed to the getConnection() call:

Import the java.util.Properties class to instantiate a Properties object.
Use the put() method to add name-value pairs to the object.

Properties myProp = new Properties();
myProp.put("user", "ExampleUser");
myProp.put("password", "password123");
myProp.put("LoginTimeout", "35");
Connection conn;
try {
    conn = DriverManager.getConnection(
        "jdbc:vertica://VerticaHost:/ExampleDB", myProp);
} catch (SQLException e) {
    e.printStackTrace();
}

Note

The data type of all of the values you set in the Properties object are strings, regardless of the property value's data type.

Getting and setting properties after connecting

After you establish a connection with the database, you can use the VerticaConnection methods getProperty() and setProperty() to set the values of some connection properties, respectively.

The VerticaConnection.getProperty() method lets you get the value of some connection properties. Use this method to change the value for properties that can be set after you establish a connection with the database.

Because these methods are database-specific, you must cast your Connection object to the VerticaConnection interface with one of the following methods:

Import the Connection object into your client application.
Use a fully-qualified reference: com.vertica.jdbc.VerticaConnection.

The following example demonstrates getting and setting the value of the ReadOnly property.

import java.sql.*;
import java.util.Properties;
import com.vertica.jdbc.*;

public class SetConnectionProperties {
    public static void main(String[] args) {
        // Note: If your application needs to run under Java 5, you need to
        // load the JDBC driver using Class.forName() here.
        Properties myProp = new Properties();
        myProp.put("user", "ExampleUser");
        myProp.put("password", "password123");
        // Set ReadOnly to true initially
        myProp.put("ReadOnly", "true");
        Connection conn;
        try {
            conn = DriverManager.getConnection(
                            "jdbc:vertica://VerticaHost:5433/ExampleDB",
                            myProp);
            // Show state of the ReadOnly property. This was set at the
            // time the connection was created.
            System.out.println("ReadOnly state: "
                            + ((VerticaConnection) conn).getProperty(
                                            "ReadOnly"));

            // Change it and show it again
            ((VerticaConnection) conn).setProperty("ReadOnly", false);
            System.out.println("ReadOnly state is now: " +
                             ((VerticaConnection) conn).getProperty(
                                             "ReadOnly"));
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

When run, the example prints the following on the standard output:

ReadOnly state: true
ReadOnly state is now: false

Connecting-To: Configuring TLS for JDBC clients

Mon, 01 Jan 0001 00:00:00 +0000

To configure TLS for JDBC clients:

Configure OpenText™ Analytics Database for client-server TLS.
Set the keystore and truststore properties.
Set the TLSmode parameter.
(Optional) Run the SSL debug utility to test your configuration.

Setting keystore/truststore properties

You can set the keystore and truststore properties in the following ways, each with their own pros and cons:

At the driver level.
At the JVM level.

Driver-level configuration

If you use tools like DbVizualizer with many connections, configure the keystore and truststore with the JDBC connection properties. This does, however, expose these values in the connection string:

KeyStorePath
KeyStorePassword
TrustStorePath
TrustStorePassword

For example:

Properties props = new Properties();
props.setProperty("KeyStorePath", keystorepath);
props.setProperty("KeyStorePassword", keystorepassword);
props.setProperty("TrustStorePath", truststorepath);
props.setProperty("TrustStorePassword", truststorepassword);

JVM-level configuration

Setting keystore and truststore parameters at the JVM level excludes them from the connection string, which may be more accommodating for environments with more stringent security requirements:

javax.net.ssl.keyStore
javax.net.ssl.trustStore
javax.net.ssl.keyStorePassword
javax.net.ssl.trustStorePassword

For example:

System.setProperty("javax.net.ssl.keyStore","clientKeyStore.key");
System.setProperty("javax.net.ssl.trustStore","clientTrustStore.key");
System.setProperty("javax.net.ssl.keyStorePassword","new_keystore_password")
System.setProperty("javax.net.ssl.trustStorePassword","new_truststore_password");

Set the TLSmode connection property

You can set the TLSmode connection property to determine how certificates are handled. TLSmode is disabled by default.

TLSmode identifies the security level that OpenText™ Analytics Database applies to the JDBC connection. The database must be configured to handle TLS connections before you can establish an encrypted connection to it. For more information, see TLS protocol. Valid values are:

disable: JDBC connects using plain text and implements no security measures.
prefer: JDBC connects using TLS. If the server does not support TLS, JDBC connects with a channel that is not encrypted. This is the default mode.
require: JDBC connects using TLS without verifying the CA certificate.
verify-ca: JDBC connects using TLS and confirms that the server certificate has been signed by the certificate authority. This setting is equivalent to the deprecated ssl=true property.
verify-full: JDBC connects using TLS, confirms that the server certificate has been signed by the certificate authority, and verifies that the host name matches the name provided in the server certificate.

If this property and the SSL property are set, this property takes precedence.

For example, to configure JDBC to connect to the server with TLS without verifying the CA certificate, you can set the TLSmode property to 'require' with the method VerticaConnection.setProperty():

Properties props = new Properties();
props.setProperty("TLSmode", "verify-full");

Run the SSL debug utility

After configuring TLS, you can run the following for a debugging utility:

$ java -Djavax.net.debug=ssl

You can use several debug specifiers (options) with the debug utility. The specifiers help narrow the scope of the debugging information that is returned. For example, you could specify one of the options that prints handshake messages or session activity.

For information on the debug utility and its options, see Debugging Utilities in the Oracle document, JSSE Reference Guide.

For information on interpreting debug information, refer to the Oracle document, Debugging SSL/TLS Connections.

Connecting-To: Setting and returning a client connection label

Mon, 01 Jan 0001 00:00:00 +0000

The JDBC Client has a method to set and return the client connection label: getClientInfo() and setClientInfo(). You can use these methods with the SQL Functions GET_CLIENT_LABEL and SET_CLIENT_LABEL.

When you use these two methods, make sure you pass the string value APPLICATIONNAME to both the setter and getter methods.

Use setClientInfo() to create a client label, and use getClientInfo() to return the client label:

import java.sql.*;
import java.util.Properties;

public class ClientLabelJDBC {

    public static void main(String[] args) {
        Properties myProp = new Properties();
        myProp.put("user", "dbadmin");
        myProp.put("password", "");
        myProp.put("loginTimeout", "35");
        Connection conn;
        try {
            conn = DriverManager.getConnection(
                    "jdbc:vertica://example.com:5433/mydb", myProp);
            System.out.println("Connected!");
            conn.setClientInfo("APPLICATIONNAME", "JDBC Client - Data Load");
            System.out.println("New Conn label: " + conn.getClientInfo("APPLICATIONNAME"));
            conn.close();
        } catch (SQLTransientConnectionException connException) {
            // There was a potentially temporary network error
            // Could automatically retry a number of times here, but
            // instead just report error and exit.
            System.out.print("Network connection issue: ");
            System.out.print(connException.getMessage());
            System.out.println(" Try again later!");
            return;
        } catch (SQLInvalidAuthorizationSpecException authException) {
            // Either the username or password was wrong
            System.out.print("Could not log into database: ");
            System.out.print(authException.getMessage());
            System.out.println(" Check the login credentials and try again.");
            return;
        } catch (SQLException e) {
            // Catch-all for other exceptions
            e.printStackTrace();
        }
    }
}

When you run this method, it prints the following result to the standard output:

Connected!
New Conn Label: JDBC Client - Data Load

Connecting-To: Setting the locale for JDBC sessions

Mon, 01 Jan 0001 00:00:00 +0000

You set the locale for a connection while opening it by including a SET LOCALE statement in the ConnSettings property, or by executing a SET LOCALE statement at any time after opening the connection. Changing the locale of a Connection object affects all of the Statement objects you instantiated using it.

You can get the locale by executing a SHOW LOCALE query. The following example demonstrates setting the locale using ConnSettings and executing a statement, as well as getting the locale:

import java.sql.*;
import java.util.Properties;

public class GetAndSetLocale {
    public static void main(String[] args) {

     // If running under a Java 5 JVM, you need to load the JDBC driver
     // using Class.forname here

     Properties myProp = new Properties();
        myProp.put("user", "ExampleUser");
        myProp.put("password", "password123");

        // Set Locale to true en_GB on connection. After the connection
        // is established, the JDBC driver runs the statements in the
        // ConnSettings property.
        myProp.put("ConnSettings", "SET LOCALE TO en_GB");
        Connection conn;
        try {
            conn = DriverManager.getConnection(
                            "jdbc:vertica://VerticaHost:5433/ExampleDB",
                            myProp);

            // Execute a query to get the locale. The results should
            // show "en_GB" as the locale, since it was set by the
            // conn settings property.
            Statement stmt = conn.createStatement();
            ResultSet rs = null;
            rs = stmt.executeQuery("SHOW LOCALE");
            System.out.print("Query reports that Locale is set to: ");
            while (rs.next()) {
                System.out.println(rs.getString(2).trim());
            }

            // Now execute a query to set locale.
            stmt.execute("SET LOCALE TO en_US");

            // Run query again to get locale.
            rs = stmt.executeQuery("SHOW LOCALE");
            System.out.print("Query now reports that Locale is set to: ");
            while (rs.next()) {
                System.out.println(rs.getString(2).trim());
            }
            // Clean up
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Running the above example displays the following on the system console:

Query reports that Locale is set to: en_GB (LEN)
Query now reports that Locale is set to: en_US (LEN)

Notes:

JDBC applications use a UTF-16 character set encoding and are responsible for converting any non-UTF-16 encoded data to UTF-16. Failing to convert the data can result in errors or the data being stored incorrectly.
The JDBC driver converts UTF-16 data to UTF-8 when passing to the OpenText™ Analytics Database server and converts data sent by the database server from UTF-8 to UTF-16 .

Connecting-To: Changing the transaction isolation level

Mon, 01 Jan 0001 00:00:00 +0000

Changing the transaction isolation level lets you choose how transactions prevent interference from other transactions. By default, the JDBC driver matches the transaction isolation level of the OpenText™ Analytics Database server. The database default transaction isolation level is READ_COMMITTED, which means any changes made by a transaction cannot be read by any other transaction until after they are committed. This prevents a transaction from reading data inserted by another transaction that is later rolled back.

OpenText™ Analytics Database also supports the SERIALIZABLE transaction isolation level. This level locks tables to prevent queries from having the results of their WHERE clauses changed by other transactions. Locking tables can have a performance impact, since only one transaction is able to access the table at a time.

A transaction retains its isolation level until it completes, even if the session's isolation level changes during the transaction. OpenText™ Analytics Database internal processes (such as the Tuple Mover and refresh operations) and DDL operations always run at the SERIALIZABLE isolation level to ensure consistency.

You can change the transaction isolation level connection property after the connection has been established using the Connection object's setter (setTransactionIsolation()) and getter (getTransactionIsolation()). The value for transaction isolation property is an integer. The Connection interface defines constants to help you set the value in a more intuitive manner:

Constant	Value
`Connection.TRANSACTION_READ_COMMITTED`	2
`Connection.TRANSACTION_SERIALIZABLE`	8

Note

The Connection interface also defines several other transaction isolation constants (READ_UNCOMMITTED and REPEATABLE_READ). As the database does not support these isolation levels, they are converted to READ_COMMITTED and SERIALIZABLE, respectively.

The following example demonstrates setting the transaction isolation level to SERIALIZABLE.

import java.sql.*;
import java.util.Properties;

public class SetTransactionIsolation {
    public static void main(String[] args) {
        Properties myProp = new Properties();
        myProp.put("user", "ExampleUser");
        myProp.put("password", "password123");
        Connection conn;
        try {
            conn = DriverManager.getConnection(
                            "jdbc:vertica://VerticaHost:5433/ExampleDB",
                            myProp);
            // Get default transaction isolation
            System.out.println("Transaction Isolation Level: "
                            + conn.getTransactionIsolation());
            // Set transaction isolation to SERIALIZABLE
            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            // Get the transaction isolation again
            System.out.println("Transaction Isolation Level: "
                            + conn.getTransactionIsolation());
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Running the example results in the following being printed out to the console:

Transaction Isolation Level: 2Transaction Isolation Level: 8

Connecting-To: JDBC connection pools

Mon, 01 Jan 0001 00:00:00 +0000

A pooling data source uses a collection of persistent connections in order to reduce the overhead of repeatedly opening network connections between the client and server. Opening a new connection for each request is more costly for both the server and the client than keeping a small pool of connections open constantly, ready to be used by new requests. When a request comes in, one of the pre-existing connections in the pool is assigned to it. Only if there are no free connections in the pool is a new connection created. Once the request is complete, the connection returns to the pool and waits to service another request.

The OpenText™ Analytics Database JDBC driver supports connection pooling as defined in the JDBC 4.0 standard. If you are using a J2EE-based application server with the database, it should already have a built-in data pooling feature. All that is required is that the application server work with the PooledConnection interface implemented by the database's JDBC driver. An application server's pooling feature is usually well-tuned for the works loads that the server is designed to handle. See your application server's documentation for details on how to work with pooled connections. Normally, using pooled connections should be transparent in your code—you will just open connections and the application server will worry about the details of pooling them.

If you are not using an application server, or your application server does not offer connection pooling that is compatible with the database, you can use a third-party pooling library, such as the open-source c3p0 or DBCP libraries, to implement connection pooling.

Note

The database client driver's native connection load balancing feature works with third-party connection pooling supplied by application servers and third-party pooling libraries. See Load balancing in JDBC for more information.

Pooled Connections (Pooling=true)

The connection returns to the pool for reuse and is not physically closed. It is available for future use by other parts of the application. No new connection is created; the connection is reused, improving performance by avoiding the need to establish new connections.

Non-Pooled Connections (Pooling=false)

The connection is physically closed terminating the connection to the database. Whenever the Open() function is called, a new connection must be established. This impacts performance as the application needs to create and close the connections repeatedly.

The key difference is that the Close() function:

returns the connection to the pool for pooled connections.

closes the connection to the database for non-pooled connections.

Example

using System;
using Vertica.Data.VerticaClient; // Vertica ADO.NET driver
public class VerticaConnectionPoolExample

{
    private static string connectionString = "Host=your-vertica-server;Database=your-database;
    User ID=your-user-id;Password=your-password;Pooling=true;Max Pool Size=100;Min Pool Size=5;";

        public static void Main(string[] args)
        {
            // Open and close some pooled connections
            for (int i = 0; i < 5; i++)
            {
              using (var connection = new VerticaConnection(connectionString))
              {
                connection.Open();
                Console.WriteLine($"Connection {i + 1} opened.");
                // Simulate some database operations
              } 
              Console.WriteLine($"Connection {i + 1} closed and returned to pool.");
            }
            // Now we explicitly clear the connection pool
            // VerticaConnection.ClearPool() can be used to clear the pool of connections to the server
            // This is usually only necessary when you want to force all connections to be released

            VerticaConnection.ClearPool(new VerticaConnection(connectionString)); // Clear the connection pool

            Console.WriteLine("Vertica connection pool cleared.");

            // Exit the application
            Console.WriteLine("Application is exiting.");
        }
}

Connecting-To: Load balancing in JDBC

Mon, 01 Jan 0001 00:00:00 +0000

Native connection load balancing

Native connection load balancing helps spread the overhead caused by client connections on the hosts in the OpenText™ Analytics Database. Both the server and the client must enable native connection load balancing. If enabled by both, then when the client initially connects to a host in the database, the host picks a host to handle the client connection from a list of the currently up hosts in the database, and informs the client which host it has chosen.

If the initially-contacted host does not choose itself to handle the connection, the client disconnects, then opens a second connection to the host selected by the first host. The connection process to this second host proceeds as usual—if SSL is enabled, then SSL negotiations begin, otherwise the client begins the authentication process. See About native connection load balancing for details.

To enable native load balancing on your client, set the ConnectionLoadBalance connection parameter to true. The following example demonstrates:

Connecting to the database several times with native connection load balancing enabled.
Fetching the name of the node handling the connection from the V_MONITOR.CURRENT_SESSION system table.


import java.sql.*;
import java.util.Properties;
import java.sql.*;
import java.util.Properties;

public class JDBCLoadingBalanceExample {
    public static void main(String[] args) {
        Properties myProp = new Properties();
        myProp.put("user", "dbadmin");
        myProp.put("password", "example_password123");
        myProp.put("loginTimeout", "35");
        myProp.put("ConnectionLoadBalance", "1");
        Connection conn;

        for (int x = 1; x <= 4; x++) {
            try {
                System.out.print("Connect attempt #" + x + "...");
                conn = DriverManager.getConnection(
                    "jdbc:vertica://node01.example.com:5433/vmart", myProp);
                Statement stmt = conn.createStatement();
                // Set the load balance policy to round robin before testing the database's load balancing.
                stmt.execute("SELECT SET_LOAD_BALANCE_POLICY('ROUNDROBIN');");
                // Query system to table to see what node we are connected to. Assume a single row
                // in response set.
                ResultSet rs = stmt.executeQuery("SELECT node_name FROM v_monitor.current_session;");
                rs.next();
                System.out.println("Connected to node " + rs.getString(1).trim());
                conn.close();
            } catch (SQLTransientConnectionException connException) {
                // There was a potentially temporary network error
                // Could automatically retry a number of times here, but
                // instead just report error and exit.
                System.out.print("Network connection issue: ");
                System.out.print(connException.getMessage());
                System.out.println(" Try again later!");
                return;
            } catch (SQLInvalidAuthorizationSpecException authException) {
                // Either the username or password was wrong
                System.out.print("Could not log into database: ");
                System.out.print(authException.getMessage());
                System.out.println(" Check the login credentials and try again.");
                return;
            } catch (SQLException e) {
                // Catch-all for other exceptions
                e.printStackTrace();
            }
        }
    }
}

Running the previous example produces the following output:


Connect attempt #1...Connected to node v_vmart_node0002
Connect attempt #2...Connected to node v_vmart_node0003
Connect attempt #3...Connected to node v_vmart_node0001
Connect attempt #4...Connected to node v_vmart_node0002

Hostname-based load balancing

You can load balance workloads by resolving a single hostname to multiple IP addresses. When you specify the hostname for the DriverManager.getConnection() method, the hostname resolves to a random listed IP address from the each connection.

For example, the hostname verticahost.example.com has the following entries in etc/hosts:

192.0.2.0 verticahost.example.com
192.0.2.1 verticahost.example.com
192.0.2.2 verticahost.example.com

Specifying verticahost.example.com as the connection for DriverManager.getConnection() randomly resolves to one of the listed IP address.

Connecting-To: JDBC connection failover

Mon, 01 Jan 0001 00:00:00 +0000

If a client application attempts to connect to a host in the OpenText™ Analytics Database cluster that is down, the connection attempt fails when using the default connection configuration. This failure usually returns an error to the user. The user must either wait until the host recovers and retry the connection or manually edit the connection settings to choose another host.

Due to the database's distributed architecture, you usually do not care which database host handles a client application's connection. You can use the client driver's connection failover feature to prevent the user from getting connection errors when the host specified in the connection settings is unreachable. The JDBC driver gives you several ways to let the client driver automatically attempt to connect to a different host if the one specified in the connection parameters is unreachable:

Configure your DNS server to return multiple IP addresses for a host name. When you use this host name in the connection settings, the client attempts to connect to the first IP address from the DNS lookup. If the host at that IP address is unreachable, the client tries to connect to the second IP, and so on until it either manages to connect to a host or it runs out of IP addresses.
Supply a list of backup hosts for the client driver to try if the primary host you specify in the connection parameters is unreachable.
(JDBC only) Use driver-specific connection properties to manage timeouts before attempting to connect to the next node.

For all methods, the process of failover is transparent to the client application (other than specifying the list of backup hosts, if you choose to use the list method of failover). If the primary host is unreachable, the client driver automatically tries to connect to other hosts.

Failover only applies to the initial establishment of the client connection. If the connection breaks, the driver does not automatically try to reconnect to another host in the database.

Choosing a failover method

You usually choose to use one of the two failover methods. However, they do work together. If your DNS server returns multiple IP addresses and you supply a list of backup hosts, the client first tries all of the IPs returned by the DNS server, then the hosts in the backup list.

Note

If a host name in the backup host list resolves to multiple IP addresses, the client does not try all of them. It just tries the first IP address in the list.

The DNS method of failover centralizes the configuration client failover. As you add new nodes to your OpenText™ Analytics Database cluster, you can choose to add them to the failover list by editing the DNS server settings. All client systems that use the DNS server to connect to the database automatically use connection failover without having to change any settings. However, this method does require administrative access to the DNS server that all clients use to connect to the database cluster. This may not be possible in your organization.

Using the backup server list is easier than editing the DNS server settings. However, it decentralizes the failover feature. You may need to update the application settings on each client system if you make changes to your database cluster.

Using DNS failover

To use DNS failover, you need to change your DNS server's settings to map a single host name to multiple IP addresses of hosts in your database cluster. You then have all client applications use this host name to connect to the database.

You can choose to have your DNS server return as many IP addresses for the host name as you want. In smaller clusters, you may choose to have it return the IP addresses of all of the hosts in your cluster. However, for larger clusters, you should consider choosing a subset of the hosts to return. Otherwise there can be a long delay as the client driver tries unsuccessfully to connect to each host in a database that is down.

Using the backup host list

To enable backup list-based connection failover, your client application has to specify at least one IP address or host name of a host in the BackupServerNode parameter. The host name or IP can optionally be followed by a colon and a port number. If not supplied, the driver defaults to the standard database port number (5433). To list multiple hosts, separate them by a comma.

The following example demonstrates setting the BackupServerNode connection parameter to specify additional hosts for the connection attempt. The connection string intentionally has a non-existent node, so that the initial connection fails. The client driver has to backup the hosts to establish a connection to the database.

import java.sql.*;
import java.util.Properties;

public class ConnectionFailoverExample {
    public static void main(String[] args) {
        // Assume using JDBC 4.0 driver on JVM 6+. No driver loading needed.
        Properties myProp = new Properties();
        myProp.put("user", "dbadmin");
        myProp.put("password", "vertica");
        // Set two backup hosts to be used if connecting to the first host
        // fails. All of these hosts will be tried in order until the connection
        // succeeds or all of the connections fail.
        myProp.put("BackupServerNode", "VerticaHost02,VerticaHost03");
        Connection conn;
        try {
            // The connection string is set to try to connect to a known
            // bad host (in this case, a host that never existed).
            // The database name is optional.
            conn = DriverManager.getConnection(
                    "jdbc:vertica://BadVerticaHost:5433/vmart", myProp);
            System.out.println("Connected!");
            // Query system to table to see what node we are connected to.
            // Assume a single row in response set.
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery(
                    "SELECT node_name FROM v_monitor.current_session;");
            rs.next();
            System.out.println("Connected to node " + rs.getString(1).trim());
            // Done with connection.
            conn.close();
        } catch (SQLException e) {
            // Catch-all for other exceptions
            e.printStackTrace();
        }
    }
}

When run, the example outputs output similar to the following on the system console:

Connected!
Connected to node v_vmart_node0002

Notice that the connection was made to the first node in the backup list (node 2).

Specifying connection timeouts

LoginTimeout controls the timeout for JDBC to establish establish a TCP connection with a node and log in to OpenText™ Analytics Database.

LoginNodeTimeout controls the timeout for JDBC to log in to the database. After the specified timeout, JDBC attempts to connect to the "next" node, which is determined by either the connection property BackupServerNode or DNS resolution. This is useful if the node is up, but something is wrong with the database process.

LoginNetworkTimeout controls the timeout for JDBC to establish a TCP connection to a database node. If you do not set this connection property, if the node to which the JDBC client attempts to connect is down, the JDBC client will wait "indefinitely," but practically, the system default timeout of 70 seconds is used. A typical use case for LoginNetworkTimeout is to let JDBC connect to another node if the current database node is down for maintenance and modifying the JDBC application's connection string is not feasible.

NetworkTimeout controls the timeout for the database to respond to a request from a client after it has established a connection and logged in to the database.

To set these parameters in a connection string:

# LoginTimeout is 30 seconds, LoginNodeTimeout is 10 seconds, LoginNetworkTimeout is 2 seconds, NetworkTimeout is 0.5 seconds
Connection conn = DriverManager.getConnection("jdbc:vertica://VerticaHost:5433/verticadb?user=dbadmin&loginTimeout=30&loginNodeTimeout=10"&loginNetworkTimeout=2&networkTimeout=500");

To set these parameters as a connection property:

Properties myProp = new Properties();
myProp.put("user", "dbadmin");
myProp.put("loginTimeout", "30"); // overall connection timeout is 30 seconds to make sure it is not too small for failover
myProp.put("loginNodeTimeout", "10"); // JDBC waits 10 seconds before attempting to connect to the next node if the database process is running but does not respond
myProp.put("loginNetworkTimeout", "2"); // node connection timeout is 2 seconds
myProp.put("networkTimeout", "500"); // after the client has logged in, the database has 0.5 seconds to respond to each request
Connection conn = DriverManager.getConnection("jdbc:vertica://VerticaHost:5433/verticadb", myProp);

Interaction with load balancing

The Load balancer does not redirect to a host where the host primary address is down. However, it may still redirect to a host whose export address is not available. In such cases, when the BackupServerNode connection parameter is provided:

The clients attempt to establish a new connection using the backup hosts.
The server treats this as a new connection request.
This new connection is again subject to load balancing.
As load balancing is not preserved globally across initiator nodes, a retry through the backup host still redirects to the same export address that is not reachable.

The BackupServerNode connection parameter does not prevent failures that are caused by load-balanced targets that are not reachable.

See Load balancing in JDBC for more information.

OpenText Analytics Database 26.2.x – Creating and configuring a connection

Connecting-To: JDBC connection properties

Connection properties

OAuth connection properties

Deprecated

Deprecated

Deprecated

Deprecated

Timeout properties

General properties

Logging properties

Kerberos connection parameters

Routable connection API connection parameters

Note

Connecting-To: Setting and getting connection property values

Setting properties when connecting

Connection string properties

Properties object

Note

Getting and setting properties after connecting

Connecting-To: Configuring TLS for JDBC clients

Setting keystore/truststore properties

Driver-level configuration

JVM-level configuration

Set the TLSmode connection property

Run the SSL debug utility

Connecting-To: Setting and returning a client connection label

Connecting-To: Setting the locale for JDBC sessions

Notes:

Connecting-To: Changing the transaction isolation level

Note

Connecting-To: JDBC connection pools

Note

Pooled Connections (Pooling=true)

Non-Pooled Connections (Pooling=false)

Connecting-To: Load balancing in JDBC

Native connection load balancing

Hostname-based load balancing

Connecting-To: JDBC connection failover

Choosing a failover method

Note

Using DNS failover

Using the backup host list

Specifying connection timeouts

Interaction with load balancing