com.amazon.redshift.jdbc

## Class RedshiftConnectionImpl

- java.lang.Object
- - com.amazon.redshift.jdbc.RedshiftConnectionImpl

All Implemented Interfaces:
  BaseConnection, RedshiftConnection, AutoCloseable, Connection, Wrapper

    public class RedshiftConnectionImpl
    extends Object
    implements BaseConnection

### Nested Class Summary

Nested Classes
`class` `RedshiftConnectionImpl.AbortCommand`

### Field Summary

Fields
`protected int` `defaultFetchSize` Default fetch size for statement.
`protected boolean` `enableGeneratedName`
`protected boolean` `forcebinary`
`protected DatabaseMetaData` `metadata`
`static String` `NON_VALIDATING_SSL_FACTORY`
`protected int` `prepareThreshold`
`protected Map<String,Class<?>>` `typemap` The current type mappings.

### Fields inherited from interface java.sql.Connection

`TRANSACTION_NONE, TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE`

### Constructor Summary

Constructors
Constructor and Description
`RedshiftConnectionImpl(HostSpec[] hostSpecs, String user, String database, RedshiftProperties info, String url, RedshiftLogger logger)`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`protected void` `abort()`
`void` `abort(Executor executor)`
`void` `addDataType(String type, Class<? extends RedshiftObject> klass)` This allows client code to add a handler for one of com.amazon.redshift's more unique data types.
`void` `addDataType(String type, String name)` This allows client code to add a handler for one of com.amazon.redshift's more unique data types.
`void` `addTimerTask(TimerTask timerTask, long milliSeconds)` Schedule a TimerTask for later execution.
`void` `addWarning(SQLWarning warn)` This adds a warning to the warning chain.
`boolean` `binaryTransferSend(int oid)` Returns true if value for the given oid should be sent using binary transfer.
`void` `cancelQuery()` Cancel the current query executing on this connection.
`protected void` `checkClosed()`
`void` `clearWarnings()`
`void` `close()` Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.
`void` `commit()`
`Array` `createArrayOf(String typeName, Object elements)` Creates an `Array` wrapping elements.
`Array` `createArrayOf(String typeName, Object[] elements)`
`Blob` `createBlob()`
`Clob` `createClob()`
`NClob` `createNClob()`
`CachedQuery` `createQuery(String sql, boolean escapeProcessing, boolean isParameterized, String... columnNames)`
`<T> T` `createQueryObject(Class<T> ifc)`
`SQLXML` `createSQLXML()`
`Statement` `createStatement()`
`Statement` `createStatement(int resultSetType, int resultSetConcurrency)`
`Statement` `createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`Struct` `createStruct(String typeName, Object[] attributes)`
`protected TypeInfo` `createTypeInfo(BaseConnection conn, int unknownLength)`
`byte[]` `encodeString(String str)` Encode a string using the database's client_encoding (usually UTF8, but can vary on older server versions).
`String` `escapeIdentifier(String identifier)` Return the given string suitably quoted to be used as an identifier in an SQL statement string.
`String` `escapeLiteral(String literal)` Return the given string suitably quoted to be used as a string literal in an SQL statement string.
`String` `escapeOnlyQuotesString(String str)` Escapes only quotes in string for catalog name.
`String` `escapeString(String str)` Escapes a string for use as string-literal within an SQL command.
`ResultSet` `execSQLQuery(String s)` Execute a SQL query that returns a single resultset.
`ResultSet` `execSQLQuery(String s, int resultSetType, int resultSetConcurrency)`
`void` `execSQLUpdate(String s)` Execute a SQL query that does not return results.
`protected void` `finalize()` Overrides finalize().
`boolean` `getAutoCommit()`
`AutoSave` `getAutosave()` Connection configuration regarding automatic per-query savepoints.
`int` `getBackendPID()` Return the process ID (PID) of the backend server process handling this connection.
`String` `getCatalog()`
`Properties` `getClientInfo()`
`String` `getClientInfo(String name)`
`CopyManager` `getCopyAPI()` This returns the COPY API for the current connection.
`String` `getCursorName()` getCursorName gets the cursor name.
`String` `getDBVersionNumber()` Get server version number.
`int` `getDefaultFetchSize()` Get the default fetch size for statements created from this connection.
`Encoding` `getEncoding()`
`Fastpath` `getFastpathAPI()` This returns the Fastpath API for the current connection.
`LruCache<FieldMetadata.Key,FieldMetadata>` `getFieldMetadataCache()` Return metadata cache for given connection.
`boolean` `getForceBinary()`
`boolean` `getGeneratedName()`
`boolean` `getHideUnprivilegedObjects()`
`int` `getHoldability()`
`protected String` `getIsolationLevelName(int level)`
`LargeObjectManager` `getLargeObjectAPI()` This returns the LargeObject API for the current connection.
`RedshiftLogger` `getLogger()`
`DatabaseMetaData` `getMetaData()`
`int` `getNetworkTimeout()`
`RedshiftNotification[]` `getNotifications()` This method returns any notifications that have been received since the last call to this method.
`RedshiftNotification[]` `getNotifications(int timeoutMillis)` This method returns any notifications that have been received since the last call to this method.
`Object` `getObject(String type, String value, byte[] byteValue)` Construct and return an appropriate object for the given type and value.
`static String` `getOptionalConnSetting(String key, Properties info)`
`static String` `getOptionalSetting(String key, Properties info)` Get the optional setting.
`Integer` `getOverrideSchemaPatternType()`
`String` `getParameterStatus(String parameterName)` Shorthand for getParameterStatuses().get(...) .
`Map<String,String>` `getParameterStatuses()` Returns the current values of all parameters reported by the server.
`PreferQueryMode` `getPreferQueryMode()` Returns the query mode for this connection.
`int` `getPrepareThreshold()` Get the default server-side prepare reuse threshold for statements created from this connection.
`int` `getProtocolVersion()`
`QueryExecutor` `getQueryExecutor()` Get the QueryExecutor implementation for this connection.
`RedshiftReplicationConnection` `getReplicationAPI()`
`ReplicationProtocol` `getReplicationProtocol()` Internal protocol for work with physical and logical replication.
`static String` `getRequiredConnSetting(String key, Properties info)`
`static String` `getRequiredSetting(String key, Properties info)` Get the required setting, and throw an exception if it isn't present.
`int` `getReWriteBatchedInsertsSize()`
`String` `getSchema()`
`int` `getServerMajorVersion()` Get server major version.
`int` `getServerMinorVersion()` Get server minor version.
`boolean` `getStandardConformingStrings()` Returns whether the server treats string-literals according to the SQL standard or if it uses traditional Redshift escaping rules.
`boolean` `getStringVarcharFlag()`
`TimestampUtils` `getTimestampUtils()`
`int` `getTransactionIsolation()`
`TransactionState` `getTransactionState()` Get the current transaction state of this connection.
`TypeInfo` `getTypeInfo()`
`Map<String,Class<?>>` `getTypeMap()`
`String` `getURL()` We are required to bring back certain information by the DatabaseMetaData class.
`String` `getUserName()` Method getUserName() brings back the User Name (again, we saved it).
`SQLWarning` `getWarnings()`
`boolean` `haveMinimumServerVersion(int ver)` Check if we have at least a particular server version.
`boolean` `haveMinimumServerVersion(Version ver)` Check if we have at least a particular server version.
`boolean` `hintReadOnly()` Indicates if statements to backend should be hinted as read only.
`boolean` `isClosed()`
`boolean` `isColumnSanitiserDisabled()` Return whether to disable column name sanitation.
`boolean` `isDatabaseMetadataCurrentDbOnly()`
`boolean` `isReadOnly()`
`boolean` `isValid(int timeout)`
`boolean` `isWrapperFor(Class<?> iface)`
`protected Array` `makeArray(int oid, String fieldString)`
`protected Blob` `makeBlob(long oid)`
`protected Clob` `makeClob(long oid)`
`protected SQLXML` `makeSQLXML()`
`String` `nativeSQL(String sql)`
`CallableStatement` `prepareCall(String sql)`
`CallableStatement` `prepareCall(String sql, int resultSetType, int resultSetConcurrency)`
`CallableStatement` `prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`PreparedStatement` `prepareStatement(String sql)`
`PreparedStatement` `prepareStatement(String sql, int autoGeneratedKeys)`
`PreparedStatement` `prepareStatement(String sql, int[] columnIndexes)`
`PreparedStatement` `prepareStatement(String sql, int resultSetType, int resultSetConcurrency)`
`PreparedStatement` `prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)`
`PreparedStatement` `prepareStatement(String sql, String[] columnNames)`
`void` `purgeTimerTasks()` Invoke purge() on the underlying shared Timer so that internal resources will be released.
`void` `releaseSavepoint(Savepoint savepoint)`
`void` `rollback()`
`void` `rollback(Savepoint savepoint)`
`void` `setAutoCommit(boolean autoCommit)`
`void` `setAutosave(AutoSave autoSave)` Configures if connection should use automatic savepoints.
`void` `setCatalog(String catalog)`
`void` `setClientInfo(Properties properties)`
`void` `setClientInfo(String name, String value)`
`void` `setCursorName(String cursor)` In SQL, a result table can be retrieved through a cursor that is named.
`void` `setDatabaseMetadataCurrentDbOnly(boolean databaseMetadataCurrentDbOnly)`
`void` `setDefaultFetchSize(int fetchSize)` Set the default fetch size for statements created from this connection.
`void` `setDisableColumnSanitiser(boolean disableColumnSanitiser)`
`void` `setFlushCacheOnDeallocate(boolean flushCacheOnDeallocate)` By default, the connection resets statement cache in case deallocate all/discard all message is observed.
`void` `setForceBinary(boolean newValue)`
`void` `setGeneratedName(boolean enable)`
`void` `setHoldability(int holdability)`
`void` `setNetworkTimeout(Executor executor, int milliseconds)`
`void` `setPrepareThreshold(int newThreshold)` Set the default statement reuse threshold before enabling server-side prepare.
`void` `setReadOnly(boolean readOnly)`
`Savepoint` `setSavepoint()`
`Savepoint` `setSavepoint(String name)`
`void` `setSchema(String schema)`
`void` `setTransactionIsolation(int level)`
`void` `setTypeMap(Map<String,Class<?>> map)`
`void` `setTypeMapImpl(Map<String,Class<?>> map)`
`<T> T` `unwrap(Class<T> iface)`

### Methods inherited from class java.lang.Object

`clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### prepareThreshold

    protected int prepareThreshold

#### enableGeneratedName

    protected boolean enableGeneratedName

#### defaultFetchSize

    protected int defaultFetchSize

Default fetch size for statement.

See Also:
  `RedshiftProperty.DEFAULT_ROW_FETCH_SIZE`

#### forcebinary

    protected boolean forcebinary

#### NON_VALIDATING_SSL_FACTORY

    public static String NON_VALIDATING_SSL_FACTORY

#### typemap

    protected Map<String,Class<?>> typemap

The current type mappings.

#### metadata

    protected DatabaseMetaData metadata

### Constructor Detail

#### RedshiftConnectionImpl

    public RedshiftConnectionImpl(HostSpec[] hostSpecs,
                                  String user,
                                  String database,
                                  RedshiftProperties info,
                                  String url,
                                  RedshiftLogger logger)
                           throws SQLException

Throws:
  `SQLException`

### Method Detail

#### createQuery

    public CachedQuery createQuery(String sql,
                                   boolean escapeProcessing,
                                   boolean isParameterized,
                                   String... columnNames)
                            throws SQLException

Specified by:
  `createQuery` in interface `BaseConnection`
Throws:
  `SQLException`

#### setFlushCacheOnDeallocate

    public void setFlushCacheOnDeallocate(boolean flushCacheOnDeallocate)

Description copied from interface: `BaseConnection`
By default, the connection resets statement cache in case deallocate all/discard all message is observed. This API allows to disable that feature for testing purposes.

Specified by:
  `setFlushCacheOnDeallocate` in interface `BaseConnection`
Parameters:
  `flushCacheOnDeallocate` - true if statement cache should be reset when "deallocate/discard" message observed

#### getTimestampUtils

    public TimestampUtils getTimestampUtils()

Specified by:
  `getTimestampUtils` in interface `BaseConnection`

#### createStatement

    public Statement createStatement()
                              throws SQLException

Specified by:
  `createStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareCall

    public CallableStatement prepareCall(String sql)
                                  throws SQLException

Specified by:
  `prepareCall` in interface `Connection`
Throws:
  `SQLException`

#### getTypeMap

    public Map<String,Class<?>> getTypeMap()
                                    throws SQLException

Specified by:
  `getTypeMap` in interface `Connection`
Throws:
  `SQLException`

#### getQueryExecutor

    public QueryExecutor getQueryExecutor()

Description copied from interface: `BaseConnection`
Get the QueryExecutor implementation for this connection.

Specified by:
  `getQueryExecutor` in interface `BaseConnection`
Returns:
  the (non-null) executor

#### getReplicationProtocol

    public ReplicationProtocol getReplicationProtocol()

Description copied from interface: `BaseConnection`
Internal protocol for work with physical and logical replication. Unsupported in Redshift.

Specified by:
  `getReplicationProtocol` in interface `BaseConnection`
Returns:
  not null replication protocol

#### addWarning

    public void addWarning(SQLWarning warn)

This adds a warning to the warning chain.

Parameters:
  `warn` - warning to add

#### execSQLQuery

    public ResultSet execSQLQuery(String s)
                           throws SQLException

Description copied from interface: `BaseConnection`
Execute a SQL query that returns a single resultset. Never causes a new transaction to be started regardless of the autocommit setting.

Specified by:
  `execSQLQuery` in interface `BaseConnection`
Parameters:
  `s` - the query to execute
Returns:
  the (non-null) returned resultset
Throws:
  `SQLException` - if something goes wrong.

#### execSQLQuery

    public ResultSet execSQLQuery(String s,
                                  int resultSetType,
                                  int resultSetConcurrency)
                           throws SQLException

Specified by:
  `execSQLQuery` in interface `BaseConnection`
Throws:
  `SQLException`

#### execSQLUpdate

    public void execSQLUpdate(String s)
                       throws SQLException

Description copied from interface: `BaseConnection`
Execute a SQL query that does not return results. Never causes a new transaction to be started regardless of the autocommit setting.

Specified by:
  `execSQLUpdate` in interface `BaseConnection`
Parameters:
  `s` - the query to execute
Throws:
  `SQLException` - if something goes wrong.

#### setCursorName

    public void setCursorName(String cursor)
                       throws SQLException

In SQL, a result table can be retrieved through a cursor that is named. The current row of a result can be updated or deleted using a positioned update/delete statement that references the cursor name.

We do not support positioned update/delete, so this is a no-op.

Parameters:
  `cursor` - the cursor name
Throws:
  `SQLException` - if a database access error occurs

#### getCursorName

    public String getCursorName()
                         throws SQLException

getCursorName gets the cursor name.

Returns:
  the current cursor name
Throws:
  `SQLException` - if a database access error occurs

#### getURL

    public String getURL()
                  throws SQLException

We are required to bring back certain information by the DatabaseMetaData class. These functions do that.

Method getURL() brings back the URL (good job we saved it)

Returns:
  the url
Throws:
  `SQLException` - just in case...

#### getUserName

    public String getUserName()
                       throws SQLException

Method getUserName() brings back the User Name (again, we saved it).

Returns:
  the user name
Throws:
  `SQLException` - just in case...

#### getFastpathAPI

    public Fastpath getFastpathAPI()
                            throws SQLException

Description copied from interface: `RedshiftConnection`
This returns the Fastpath API for the current connection.

Specified by:
  `getFastpathAPI` in interface `RedshiftConnection`
Returns:
  Fastpath API for the current connection
Throws:
  `SQLException` - if something wrong happens

#### getLargeObjectAPI

    public LargeObjectManager getLargeObjectAPI()
                                         throws SQLException

Description copied from interface: `RedshiftConnection`
This returns the LargeObject API for the current connection.

Specified by:
  `getLargeObjectAPI` in interface `RedshiftConnection`
Returns:
  LargeObject API for the current connection
Throws:
  `SQLException` - if something wrong happens

#### getObject

    public Object getObject(String type,
                            String value,
                            byte[] byteValue)
                     throws SQLException

Description copied from interface: `BaseConnection`

Construct and return an appropriate object for the given type and value. This only considers the types registered via `RedshiftConnection.addDataType(String, Class)` and `RedshiftConnection.addDataType(String, String)`.

If no class is registered as handling the given type, then a generic `RedshiftObject` instance is returned.

Specified by:
  `getObject` in interface `BaseConnection`
Parameters:
  `type` - the backend typename
  `value` - the type-specific string representation of the value
  `byteValue` - the type-specific binary representation of the value
Returns:
  an appropriate object; never null.
Throws:
  `SQLException` - if something goes wrong

#### createTypeInfo

    protected TypeInfo createTypeInfo(BaseConnection conn,
                                      int unknownLength)

#### getTypeInfo

    public TypeInfo getTypeInfo()

Specified by:
  `getTypeInfo` in interface `BaseConnection`

#### addDataType

    public void addDataType(String type,
                            String name)

Description copied from interface: `RedshiftConnection`
This allows client code to add a handler for one of com.amazon.redshift's more unique data types. It is approximately equivalent to `addDataType(type, Class.forName(name))`.

Specified by:
  `addDataType` in interface `RedshiftConnection`
Parameters:
  `type` - JDBC type name
  `name` - class name

#### addDataType

    public void addDataType(String type,
                            Class<? extends RedshiftObject> klass)
                     throws SQLException

Description copied from interface: `RedshiftConnection`

This allows client code to add a handler for one of com.amazon.redshift's more unique data types.

NOTE: This is not part of JDBC, but an extension.

The best way to use this is as follows:

     ...
     ((com.amazon.redshift.RedshiftConnection)myconn).addDataType("mytype", my.class.name.class);
     ...

where myconn is an open Connection to com.amazon.redshift.

The handling class must extend com.amazon.redshift.util.RedshiftObject

Specified by:
  `addDataType` in interface `RedshiftConnection`
Parameters:
  `type` - the Redshift type to register
  `klass` - the class implementing the Java representation of the type; this class must implement `RedshiftObject`).
Throws:
  `SQLException` - if `klass` does not implement `RedshiftObject`).
See Also:
  `RedshiftObject`

#### close

    public void close()
               throws SQLException

Note: even though `Statement` is automatically closed when it is garbage collected, it is better to close it explicitly to lower resource consumption.

Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in interface `Connection`
Throws:
  `SQLException`

#### nativeSQL

    public String nativeSQL(String sql)
                     throws SQLException

Specified by:
  `nativeSQL` in interface `Connection`
Throws:
  `SQLException`

#### getWarnings

    public SQLWarning getWarnings()
                           throws SQLException

Specified by:
  `getWarnings` in interface `Connection`
Throws:
  `SQLException`

#### clearWarnings

    public void clearWarnings()
                       throws SQLException

Specified by:
  `clearWarnings` in interface `Connection`
Throws:
  `SQLException`

#### setDatabaseMetadataCurrentDbOnly

    public void setDatabaseMetadataCurrentDbOnly(boolean databaseMetadataCurrentDbOnly)
                                          throws SQLException

Throws:
  `SQLException`

#### isDatabaseMetadataCurrentDbOnly

    public boolean isDatabaseMetadataCurrentDbOnly()

#### setReadOnly

    public void setReadOnly(boolean readOnly)
                     throws SQLException

Specified by:
  `setReadOnly` in interface `Connection`
Throws:
  `SQLException`

#### isReadOnly

    public boolean isReadOnly()
                       throws SQLException

Specified by:
  `isReadOnly` in interface `Connection`
Throws:
  `SQLException`

#### hintReadOnly

    public boolean hintReadOnly()

Description copied from interface: `BaseConnection`
Indicates if statements to backend should be hinted as read only.

Specified by:
  `hintReadOnly` in interface `BaseConnection`
Returns:
  Indication if hints to backend (such as when transaction begins) should be read only.
See Also:
  `RedshiftProperty.READ_ONLY_MODE`

#### setAutoCommit

    public void setAutoCommit(boolean autoCommit)
                       throws SQLException

Specified by:
  `setAutoCommit` in interface `Connection`
Throws:
  `SQLException`

#### getAutoCommit

    public boolean getAutoCommit()
                          throws SQLException

Specified by:
  `getAutoCommit` in interface `Connection`
Throws:
  `SQLException`

#### commit

    public void commit()
                throws SQLException

Specified by:
  `commit` in interface `Connection`
Throws:
  `SQLException`

#### checkClosed

    protected void checkClosed()
                        throws SQLException

Throws:
  `SQLException`

#### rollback

    public void rollback()
                  throws SQLException

Specified by:
  `rollback` in interface `Connection`
Throws:
  `SQLException`

#### getTransactionState

    public TransactionState getTransactionState()

Description copied from interface: `BaseConnection`
Get the current transaction state of this connection.

Specified by:
  `getTransactionState` in interface `BaseConnection`
Returns:
  current transaction state of this connection

#### getTransactionIsolation

    public int getTransactionIsolation()
                                throws SQLException

Specified by:
  `getTransactionIsolation` in interface `Connection`
Throws:
  `SQLException`

#### setTransactionIsolation

    public void setTransactionIsolation(int level)
                                 throws SQLException

Specified by:
  `setTransactionIsolation` in interface `Connection`
Throws:
  `SQLException`

#### getIsolationLevelName

    protected String getIsolationLevelName(int level)

#### setCatalog

    public void setCatalog(String catalog)
                    throws SQLException

Specified by:
  `setCatalog` in interface `Connection`
Throws:
  `SQLException`

#### getCatalog

    public String getCatalog()
                      throws SQLException

Specified by:
  `getCatalog` in interface `Connection`
Throws:
  `SQLException`

#### getHideUnprivilegedObjects

    public boolean getHideUnprivilegedObjects()

#### finalize

    protected void finalize()
                     throws Throwable

Overrides finalize(). If called, it closes the connection.

This was done at the request of Rachel Greenham who hit a problem where multiple clients didn't close the connection, and once a fortnight enough clients were open to kill the postgres server.

Overrides:
  `finalize` in class `Object`
Throws:
  `Throwable`

#### getDBVersionNumber

    public String getDBVersionNumber()

Get server version number.

Returns:
  server version number

#### getServerMajorVersion

    public int getServerMajorVersion()

Get server major version.

Returns:
  server major version

#### getServerMinorVersion

    public int getServerMinorVersion()

Get server minor version.

Returns:
  server minor version

#### haveMinimumServerVersion

    public boolean haveMinimumServerVersion(int ver)

Description copied from interface: `BaseConnection`

Check if we have at least a particular server version.

The input version is of the form xxyyzz, matching a Redshift version like xx.yy.zz. So 08.00.02 is 080002.

Specified by:
  `haveMinimumServerVersion` in interface `BaseConnection`
Parameters:
  `ver` - the server version to check, of the form xxyyzz eg 90401
Returns:
  true if the server version is at least "ver".

#### haveMinimumServerVersion

    public boolean haveMinimumServerVersion(Version ver)

Description copied from interface: `BaseConnection`

Check if we have at least a particular server version.

The input version is of the form xxyyzz, matching a Redshift version like xx.yy.zz. So 8.0.2 is 80002.

Specified by:
  `haveMinimumServerVersion` in interface `BaseConnection`
Parameters:
  `ver` - the server version to check
Returns:
  true if the server version is at least "ver".

#### getEncoding

    public Encoding getEncoding()

Specified by:
  `getEncoding` in interface `BaseConnection`

#### encodeString

    public byte[] encodeString(String str)
                        throws SQLException

Description copied from interface: `BaseConnection`
Encode a string using the database's client_encoding (usually UTF8, but can vary on older server versions). This is used when constructing synthetic resultsets (for example, in metadata methods).

Specified by:
  `encodeString` in interface `BaseConnection`
Parameters:
  `str` - the string to encode
Returns:
  an encoded representation of the string
Throws:
  `SQLException` - if something goes wrong.

#### escapeString

    public String escapeString(String str)
                        throws SQLException

Description copied from interface: `BaseConnection`
Escapes a string for use as string-literal within an SQL command. The method chooses the applicable escaping rules based on the value of `BaseConnection.getStandardConformingStrings()`.

Specified by:
  `escapeString` in interface `BaseConnection`
Parameters:
  `str` - a string value
Returns:
  the escaped representation of the string
Throws:
  `SQLException` - if the string contains a `\0` character

#### escapeOnlyQuotesString

    public String escapeOnlyQuotesString(String str)
                                  throws SQLException

Description copied from interface: `BaseConnection`
Escapes only quotes in string for catalog name. The method chooses the applicable escaping rules based on the value of `BaseConnection.getStandardConformingStrings()`.

Specified by:
  `escapeOnlyQuotesString` in interface `BaseConnection`
Parameters:
  `str` - a string value
Returns:
  the escaped representation of the string
Throws:
  `SQLException` - if the string contains a `\0` character

#### getStandardConformingStrings

    public boolean getStandardConformingStrings()

Description copied from interface: `BaseConnection`
Returns whether the server treats string-literals according to the SQL standard or if it uses traditional Redshift escaping rules. Versions up to 8.1 always treated backslashes as escape characters in string-literals. Since 8.2, this depends on the value of the `standard_conforming_strings` server variable.

Specified by:
  `getStandardConformingStrings` in interface `BaseConnection`
Returns:
  true if the server treats string literals according to the SQL standard
See Also:
  `QueryExecutor.getStandardConformingStrings()`

#### isClosed

    public boolean isClosed()
                     throws SQLException

Specified by:
  `isClosed` in interface `Connection`
Throws:
  `SQLException`

#### cancelQuery

    public void cancelQuery()
                     throws SQLException

Description copied from interface: `BaseConnection`
Cancel the current query executing on this connection.

Specified by:
  `cancelQuery` in interface `BaseConnection`
Specified by:
  `cancelQuery` in interface `RedshiftConnection`
Throws:
  `SQLException` - if something goes wrong.

#### getNotifications

    public RedshiftNotification[] getNotifications()
                                            throws SQLException

Description copied from interface: `RedshiftConnection`
This method returns any notifications that have been received since the last call to this method. Returns null if there have been no notifications.

Specified by:
  `getNotifications` in interface `RedshiftConnection`
Returns:
  notifications that have been received
Throws:
  `SQLException` - if something wrong happens

#### getNotifications

    public RedshiftNotification[] getNotifications(int timeoutMillis)
                                            throws SQLException

Description copied from interface: `RedshiftConnection`
This method returns any notifications that have been received since the last call to this method. Returns null if there have been no notifications. A timeout can be specified so the driver waits for notifications.

Specified by:
  `getNotifications` in interface `RedshiftConnection`
Parameters:
  `timeoutMillis` - when 0, blocks forever. when > 0, blocks up to the specified number of millies or until at least one notification has been received. If more than one notification is about to be received, these will be returned in one batch.
Returns:
  notifications that have been received
Throws:
  `SQLException` - if something wrong happens

#### getPrepareThreshold

    public int getPrepareThreshold()

Description copied from interface: `RedshiftConnection`
Get the default server-side prepare reuse threshold for statements created from this connection.

Specified by:
  `getPrepareThreshold` in interface `RedshiftConnection`
Returns:
  the current threshold

#### setDefaultFetchSize

    public void setDefaultFetchSize(int fetchSize)
                             throws SQLException

Description copied from interface: `RedshiftConnection`
Set the default fetch size for statements created from this connection.

Specified by:
  `setDefaultFetchSize` in interface `RedshiftConnection`
Parameters:
  `fetchSize` - new default fetch size
Throws:
  `SQLException` - if specified negative `fetchSize` parameter
See Also:
  `Statement.setFetchSize(int)`

#### getDefaultFetchSize

    public int getDefaultFetchSize()

Description copied from interface: `RedshiftConnection`
Get the default fetch size for statements created from this connection.

Specified by:
  `getDefaultFetchSize` in interface `RedshiftConnection`
Returns:
  current state for default fetch size
See Also:
  `RedshiftProperty.DEFAULT_ROW_FETCH_SIZE`, `Statement.getFetchSize()`

#### getReWriteBatchedInsertsSize

    public int getReWriteBatchedInsertsSize()

#### getOverrideSchemaPatternType

    public Integer getOverrideSchemaPatternType()

#### setPrepareThreshold

    public void setPrepareThreshold(int newThreshold)

Description copied from interface: `RedshiftConnection`
Set the default statement reuse threshold before enabling server-side prepare. See `RedshiftStatement.setPrepareThreshold(int)` for details.

Specified by:
  `setPrepareThreshold` in interface `RedshiftConnection`
Parameters:
  `newThreshold` - the new threshold

#### setGeneratedName

    public void setGeneratedName(boolean enable)

#### getGeneratedName

    public boolean getGeneratedName()

#### getForceBinary

    public boolean getForceBinary()

#### setForceBinary

    public void setForceBinary(boolean newValue)

#### setTypeMapImpl

    public void setTypeMapImpl(Map<String,Class<?>> map)
                        throws SQLException

Throws:
  `SQLException`

#### getLogger

    public RedshiftLogger getLogger()

Specified by:
  `getLogger` in interface `BaseConnection`

#### getProtocolVersion

    public int getProtocolVersion()

#### getStringVarcharFlag

    public boolean getStringVarcharFlag()

Specified by:
  `getStringVarcharFlag` in interface `BaseConnection`

#### getCopyAPI

    public CopyManager getCopyAPI()
                           throws SQLException

Description copied from interface: `RedshiftConnection`
This returns the COPY API for the current connection.

Specified by:
  `getCopyAPI` in interface `RedshiftConnection`
Returns:
  COPY API for the current connection
Throws:
  `SQLException` - if something wrong happens

#### binaryTransferSend

    public boolean binaryTransferSend(int oid)

Description copied from interface: `BaseConnection`
Returns true if value for the given oid should be sent using binary transfer. False if value should be sent using text transfer.

Specified by:
  `binaryTransferSend` in interface `BaseConnection`
Parameters:
  `oid` - The oid to check.
Returns:
  True for binary transfer, false for text transfer.

#### getBackendPID

    public int getBackendPID()

Description copied from interface: `RedshiftConnection`
Return the process ID (PID) of the backend server process handling this connection.

Specified by:
  `getBackendPID` in interface `RedshiftConnection`
Returns:
  PID of backend server process.

#### isColumnSanitiserDisabled

    public boolean isColumnSanitiserDisabled()

Description copied from interface: `BaseConnection`
Return whether to disable column name sanitation.

Specified by:
  `isColumnSanitiserDisabled` in interface `BaseConnection`
Returns:
  true column sanitizer is disabled

#### setDisableColumnSanitiser

    public void setDisableColumnSanitiser(boolean disableColumnSanitiser)

#### getPreferQueryMode

    public PreferQueryMode getPreferQueryMode()

Description copied from interface: `RedshiftConnection`

Returns the query mode for this connection.

When running in simple query mode, certain features are not available: callable statements, partial result set fetch, bytea type, etc.

The list of supported features is subject to change.

Specified by:
  `getPreferQueryMode` in interface `RedshiftConnection`
Returns:
  the preferred query mode
See Also:
  `PreferQueryMode`

#### getAutosave

    public AutoSave getAutosave()

Description copied from interface: `RedshiftConnection`
Connection configuration regarding automatic per-query savepoints.

Specified by:
  `getAutosave` in interface `RedshiftConnection`
Returns:
  connection configuration regarding automatic per-query savepoints
See Also:
  `RedshiftProperty.AUTOSAVE`

#### setAutosave

    public void setAutosave(AutoSave autoSave)

Description copied from interface: `RedshiftConnection`
Configures if connection should use automatic savepoints.

Specified by:
  `setAutosave` in interface `RedshiftConnection`
Parameters:
  `autoSave` - connection configuration regarding automatic per-query savepoints
See Also:
  `RedshiftProperty.AUTOSAVE`

#### abort

    protected void abort()

#### addTimerTask

    public void addTimerTask(TimerTask timerTask,
                             long milliSeconds)

Description copied from interface: `BaseConnection`
Schedule a TimerTask for later execution. The task will be scheduled with the shared Timer for this connection.

Specified by:
  `addTimerTask` in interface `BaseConnection`
Parameters:
  `timerTask` - timer task to schedule
  `milliSeconds` - delay in milliseconds

#### purgeTimerTasks

    public void purgeTimerTasks()

Description copied from interface: `BaseConnection`
Invoke purge() on the underlying shared Timer so that internal resources will be released.

Specified by:
  `purgeTimerTasks` in interface `BaseConnection`

#### escapeIdentifier

    public String escapeIdentifier(String identifier)
                            throws SQLException

Description copied from interface: `RedshiftConnection`
Return the given string suitably quoted to be used as an identifier in an SQL statement string. Quotes are added only if necessary (i.e., if the string contains non-identifier characters or would be case-folded). Embedded quotes are properly doubled.

Specified by:
  `escapeIdentifier` in interface `RedshiftConnection`
Parameters:
  `identifier` - input identifier
Returns:
  the escaped identifier
Throws:
  `SQLException` - if something goes wrong

#### escapeLiteral

    public String escapeLiteral(String literal)
                         throws SQLException

Description copied from interface: `RedshiftConnection`
Return the given string suitably quoted to be used as a string literal in an SQL statement string. Embedded single-quotes and backslashes are properly doubled. Note that quote_literal returns null on null input.

Specified by:
  `escapeLiteral` in interface `RedshiftConnection`
Parameters:
  `literal` - input literal
Returns:
  the quoted literal
Throws:
  `SQLException` - if something goes wrong

#### getFieldMetadataCache

    public LruCache<FieldMetadata.Key,FieldMetadata> getFieldMetadataCache()

Description copied from interface: `BaseConnection`
Return metadata cache for given connection.

Specified by:
  `getFieldMetadataCache` in interface `BaseConnection`
Returns:
  metadata cache

#### getReplicationAPI

    public RedshiftReplicationConnection getReplicationAPI()

Specified by:
  `getReplicationAPI` in interface `RedshiftConnection`
Returns:
  replication API for the current connection

#### createStatement

    public Statement createStatement(int resultSetType,
                                     int resultSetConcurrency,
                                     int resultSetHoldability)
                              throws SQLException

Specified by:
  `createStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql,
                                              int resultSetType,
                                              int resultSetConcurrency,
                                              int resultSetHoldability)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareCall

    public CallableStatement prepareCall(String sql,
                                         int resultSetType,
                                         int resultSetConcurrency,
                                         int resultSetHoldability)
                                  throws SQLException

Specified by:
  `prepareCall` in interface `Connection`
Throws:
  `SQLException`

#### getMetaData

    public DatabaseMetaData getMetaData()
                                 throws SQLException

Specified by:
  `getMetaData` in interface `Connection`
Throws:
  `SQLException`

#### setTypeMap

    public void setTypeMap(Map<String,Class<?>> map)
                    throws SQLException

Specified by:
  `setTypeMap` in interface `Connection`
Throws:
  `SQLException`

#### makeArray

    protected Array makeArray(int oid,
                              String fieldString)
                       throws SQLException

Throws:
  `SQLException`

#### makeBlob

    protected Blob makeBlob(long oid)
                     throws SQLException

Throws:
  `SQLException`

#### makeClob

    protected Clob makeClob(long oid)
                     throws SQLException

Throws:
  `SQLException`

#### makeSQLXML

    protected SQLXML makeSQLXML()
                         throws SQLException

Throws:
  `SQLException`

#### createClob

    public Clob createClob()
                    throws SQLException

Specified by:
  `createClob` in interface `Connection`
Throws:
  `SQLException`

#### createBlob

    public Blob createBlob()
                    throws SQLException

Specified by:
  `createBlob` in interface `Connection`
Throws:
  `SQLException`

#### createNClob

    public NClob createNClob()
                      throws SQLException

Specified by:
  `createNClob` in interface `Connection`
Throws:
  `SQLException`

#### createSQLXML

    public SQLXML createSQLXML()
                        throws SQLException

Specified by:
  `createSQLXML` in interface `Connection`
Throws:
  `SQLException`

#### createStruct

    public Struct createStruct(String typeName,
                               Object[] attributes)
                        throws SQLException

Specified by:
  `createStruct` in interface `Connection`
Throws:
  `SQLException`

#### createArrayOf

    public Array createArrayOf(String typeName,
                               Object elements)
                        throws SQLException

Description copied from interface: `RedshiftConnection`
Creates an `Array` wrapping elements. This is similar to `Connection.createArrayOf(String, Object[])`, but also provides support for primitive arrays.

Specified by:
  `createArrayOf` in interface `RedshiftConnection`
Parameters:
  `typeName` - The SQL name of the type to map the elements to. Must not be `null`.
  `elements` - The array of objects to map. A `null` value will result in an `Array` representing `null`.
Returns:
  An `Array` wrapping elements.
Throws:
  `SQLException` - If for some reason the array cannot be created.
See Also:
  `Connection.createArrayOf(String, Object[])`

#### createArrayOf

    public Array createArrayOf(String typeName,
                               Object[] elements)
                        throws SQLException

Specified by:
  `createArrayOf` in interface `Connection`
Throws:
  `SQLException`

#### isValid

    public boolean isValid(int timeout)
                    throws SQLException

Specified by:
  `isValid` in interface `Connection`
Throws:
  `SQLException`

#### setClientInfo

    public void setClientInfo(String name,
                              String value)
                       throws SQLClientInfoException

Specified by:
  `setClientInfo` in interface `Connection`
Throws:
  `SQLClientInfoException`

#### setClientInfo

    public void setClientInfo(Properties properties)
                       throws SQLClientInfoException

Specified by:
  `setClientInfo` in interface `Connection`
Throws:
  `SQLClientInfoException`

#### getClientInfo

    public String getClientInfo(String name)
                         throws SQLException

Specified by:
  `getClientInfo` in interface `Connection`
Throws:
  `SQLException`

#### getClientInfo

    public Properties getClientInfo()
                             throws SQLException

Specified by:
  `getClientInfo` in interface `Connection`
Throws:
  `SQLException`

#### createQueryObject

    public <T> T createQueryObject(Class<T> ifc)
                            throws SQLException

Throws:
  `SQLException`

#### isWrapperFor

    public boolean isWrapperFor(Class<?> iface)
                         throws SQLException

Specified by:
  `isWrapperFor` in interface `Wrapper`
Throws:
  `SQLException`

#### unwrap

    public <T> T unwrap(Class<T> iface)
                 throws SQLException

Specified by:
  `unwrap` in interface `Wrapper`
Throws:
  `SQLException`

#### getSchema

    public String getSchema()
                     throws SQLException

Specified by:
  `getSchema` in interface `Connection`
Throws:
  `SQLException`

#### setSchema

    public void setSchema(String schema)
                   throws SQLException

Specified by:
  `setSchema` in interface `Connection`
Throws:
  `SQLException`

#### abort

    public void abort(Executor executor)
               throws SQLException

Specified by:
  `abort` in interface `Connection`
Throws:
  `SQLException`

#### setNetworkTimeout

    public void setNetworkTimeout(Executor executor,
                                  int milliseconds)
                           throws SQLException

Specified by:
  `setNetworkTimeout` in interface `Connection`
Throws:
  `SQLException`

#### getNetworkTimeout

    public int getNetworkTimeout()
                          throws SQLException

Specified by:
  `getNetworkTimeout` in interface `Connection`
Throws:
  `SQLException`

#### setHoldability

    public void setHoldability(int holdability)
                        throws SQLException

Specified by:
  `setHoldability` in interface `Connection`
Throws:
  `SQLException`

#### getHoldability

    public int getHoldability()
                       throws SQLException

Specified by:
  `getHoldability` in interface `Connection`
Throws:
  `SQLException`

#### setSavepoint

    public Savepoint setSavepoint()
                           throws SQLException

Specified by:
  `setSavepoint` in interface `Connection`
Throws:
  `SQLException`

#### setSavepoint

    public Savepoint setSavepoint(String name)
                           throws SQLException

Specified by:
  `setSavepoint` in interface `Connection`
Throws:
  `SQLException`

#### rollback

    public void rollback(Savepoint savepoint)
                  throws SQLException

Specified by:
  `rollback` in interface `Connection`
Throws:
  `SQLException`

#### releaseSavepoint

    public void releaseSavepoint(Savepoint savepoint)
                          throws SQLException

Specified by:
  `releaseSavepoint` in interface `Connection`
Throws:
  `SQLException`

#### createStatement

    public Statement createStatement(int resultSetType,
                                     int resultSetConcurrency)
                              throws SQLException

Specified by:
  `createStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql,
                                              int resultSetType,
                                              int resultSetConcurrency)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareCall

    public CallableStatement prepareCall(String sql,
                                         int resultSetType,
                                         int resultSetConcurrency)
                                  throws SQLException

Specified by:
  `prepareCall` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql,
                                              int autoGeneratedKeys)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql,
                                              int[] columnIndexes)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### prepareStatement

    public PreparedStatement prepareStatement(String sql,
                                              String[] columnNames)
                                       throws SQLException

Specified by:
  `prepareStatement` in interface `Connection`
Throws:
  `SQLException`

#### getParameterStatuses

    public final Map<String,String> getParameterStatuses()

Description copied from interface: `RedshiftConnection`

Returns the current values of all parameters reported by the server.

Redshift reports values for a subset of parameters (GUCs) to the client at connect-time, then sends update messages whenever the values change during a session. PgJDBC records the latest values and exposes it to client applications via `getParameterStatuses()`.

PgJDBC exposes individual accessors for some of these parameters as listed below. They are more backwarrds-compatible and should be preferred where possible.

Not all parameters are reported, only those marked `GUC_REPORT` in the source code. The `pg_settings` view does not expose information about which parameters are reportable. PgJDBC's map will only contain the parameters the server reports values for, so you cannot use this method as a substitute for running a `SHOW paramname;` or `SELECT current_setting('paramname');` query for arbitrary parameters.

Parameter names are case-insensitive and case-preserving in this map, like in Redshift itself. So `DateStyle` and `datestyle` are the same key.

As of PostgreSQL 11 the reportable parameter list, and related PgJDBC interfaces or accesors, are:

- `application_name` - `Connection.getClientInfo()`, `Connection.setClientInfo(java.util.Properties)` and `ApplicationName` connection property.
- `client_encoding` - PgJDBC always sets this to `UTF8`. See `allowEncodingChanges` connection property.
- `DateStyle` - PgJDBC requires this to always be set to `ISO`
- `standard_conforming_strings` - indirectly via `RedshiftConnection.escapeLiteral(String)`
- `TimeZone` - set from JDK timezone see `TimeZone.getDefault()` and `TimeZone.setDefault(TimeZone)`
- `integer_datetimes`
- `IntervalStyle`
- `server_encoding`
- `server_version`
- `is_superuser`
- `session_authorization`

Note that some PgJDBC operations will change server parameters automatically.

Specified by:
  `getParameterStatuses` in interface `RedshiftConnection`
Returns:
  unmodifiable map of case-insensitive parameter names to parameter values

#### getParameterStatus

    public final String getParameterStatus(String parameterName)

Description copied from interface: `RedshiftConnection`
Shorthand for getParameterStatuses().get(...) .

Specified by:
  `getParameterStatus` in interface `RedshiftConnection`
Parameters:
  `parameterName` - case-insensitive parameter name
Returns:
  parameter value if defined, or null if no parameter known
See Also:
  `RedshiftConnection.getParameterStatuses()`

#### getOptionalSetting

    public static String getOptionalSetting(String key,
                                            Properties info)

Get the optional setting.

Parameters:
  `key` - The name of the setting to retrieve.
  `info` - The connection settings generated by a call to UpdateConnectionSettings().
Returns:
  The String representing the specified setting, or null if the setting isn't present.

#### getOptionalConnSetting

    public static String getOptionalConnSetting(String key,
                                                Properties info)

#### getRequiredSetting

    public static String getRequiredSetting(String key,
                                            Properties info)
                                     throws RedshiftException

Get the required setting, and throw an exception if it isn't present.

Parameters:
  `key` - The name of the setting to retrieve.
  `info` - The connection settings generated by a call to UpdateConnectionSettings().
Returns:
  The Variant representing the specified setting.
Throws:
  `RedshiftException` - If the required setting isn't present.

#### getRequiredConnSetting

    public static String getRequiredConnSetting(String key,
                                                Properties info)
                                         throws RedshiftException

Throws:
  `RedshiftException`