Package com.google.cloud.spanner.jdbc

# Interface CloudSpannerJdbcConnection

All Superinterfaces:
  `AutoCloseable`, `Connection`, `Wrapper`

public interface CloudSpannerJdbcConnection extends Connection
JDBC connection with a number of additional Cloud Spanner specific methods. JDBC connections that are returned by the Cloud Spanner `JdbcDriver` will implement this interface.

Calling `Wrapper.unwrap(Class)` with `CloudSpannerJdbcConnection` class as input on a `Connection` returned by the Cloud Spanner JDBC Driver will return a `CloudSpannerJdbcConnection` instance.

## Field Summary

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

`TRANSACTION_NONE, TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE`

## Method Summary

Modifier and Type
Method
Description
`void`
`addTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener listener)`
`void`
`addTransactionRetryListener(TransactionRetryListener listener)`
Deprecated.
`void`
`bufferedWrite(com.google.cloud.spanner.Mutation mutation)`
Buffers the given mutation locally on the current transaction of this `Connection`.
`void`
`bufferedWrite(Iterable<com.google.cloud.spanner.Mutation> mutations)`
Buffers the given mutations locally on the current transaction of this `Connection`.
`default long`
`getAutoBatchDmlUpdateCount()`
Returns the update count that is returned for DML statements that are buffered during an automatic DML batch.
`com.google.cloud.spanner.connection.AutocommitDmlMode`
`getAutocommitDmlMode()`
`com.google.cloud.spanner.CommitResponse`
`getCommitResponse()`
`Timestamp`
`getCommitTimestamp()`
`String`
`getConnectionUrl()`
`default com.google.cloud.spanner.Dialect`
`getDialect()`
`default int`
`getMaxPartitionedParallelism()`
Returns the maximum degree of parallelism that is used for partitioned queries.
`default int`
`getMaxPartitions()`
Gets the maximum number of partitions that should be included as a hint to Cloud Spanner when partitioning a query on this connection.
`String`
`getOptimizerVersion()`
Gets the current query optimizer version of this connection.
`default byte[]`
`getProtoDescriptors()`
`com.google.cloud.spanner.TimestampBound`
`getReadOnlyStaleness()`
`Timestamp`
`getReadTimestamp()`
`com.google.cloud.spanner.connection.SavepointSupport`
`getSavepointSupport()`
Returns the current savepoint support for this connection.
`default String`
`getStatementTag()`
`com.google.cloud.spanner.connection.TransactionMode`
`getTransactionMode()`
`Iterator<TransactionRetryListener>`
`getTransactionRetryListeners()`
Deprecated.
`Iterator<com.google.cloud.spanner.connection.TransactionRetryListener>`
`getTransactionRetryListenersFromConnection()`
`default String`
`getTransactionTag()`
`default boolean`
`isAutoBatchDml()`
Returns whether automatic DML batching is enabled on this connection.
`default boolean`
`isAutoBatchDmlUpdateCountVerification()`
Indicates whether the update counts of automatic DML batches should be verified.
`default boolean`
`isAutoPartitionMode()`
Returns whether this connection will execute all queries as partitioned queries.
`default boolean`
`isDataBoostEnabled()`
Returns whether data boost is enabled for partitioned queries.
`boolean`
`isInTransaction()`
`boolean`
`isRetryAbortsInternally()`
`boolean`
`isReturnCommitStats()`
`boolean`
`isTransactionStarted()`
`boolean`
`removeTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener listener)`
`boolean`
`removeTransactionRetryListener(TransactionRetryListener listener)`
Deprecated.
`default void`
`setAutoBatchDml(boolean autoBatchDml)`
Enables or disables automatic batching of DML statements.
`default void`
`setAutoBatchDmlUpdateCount(long updateCount)`
Sets the update count that is returned for DML statements that are buffered during an automatic DML batch.
`default void`
`setAutoBatchDmlUpdateCountVerification(boolean verification)`
Sets whether the update count that is returned by Spanner after executing an automatic DML batch should be verified against the update counts that were returned during the buffering of those statements.
`void`
`setAutocommitDmlMode(com.google.cloud.spanner.connection.AutocommitDmlMode mode)`
Sets the mode for executing DML statements in autocommit mode for this connection.
`default void`
`setAutoPartitionMode(boolean alwaysUsePartitionedQueries)`
Sets whether this connection should always use partitioned queries when a query is executed on this connection.
`default void`
`setDataBoostEnabled(boolean dataBoostEnabled)`
Enable data boost for partitioned queries.
`default void`
`setMaxPartitionedParallelism(int maxThreads)`
Sets the maximum degree of parallelism that is used when executing a partitioned query.
`default void`
`setMaxPartitions(int maxPartitions)`
Sets the maximum number of partitions that should be included as a hint to Cloud Spanner when partitioning a query on this connection.
`void`
`setOptimizerVersion(String optimizerVersion)`
Sets the query optimizer version to use for this connection.
`default void`
`setProtoDescriptors(byte[] protoDescriptors)`
Sets the proto descriptors to use for the next DDL statement (single or batch) that will be executed.
`default void`
`setProtoDescriptors(InputStream protoDescriptors)`
Sets the proto descriptors to use for the next DDL statement (single or batch) that will be executed.
`void`
`setReadOnlyStaleness(com.google.cloud.spanner.TimestampBound staleness)`
Sets the staleness to use for the current read-only transaction.
`void`
`setRetryAbortsInternally(boolean retryAbortsInternally)`
Sets whether this connection will internally retry read/write transactions that abort.
`void`
`setReturnCommitStats(boolean returnCommitStats)`
Sets whether this connection should request commit statistics from Cloud Spanner for read/write transactions and for DML statements in autocommit mode.
`void`
`setSavepointSupport(com.google.cloud.spanner.connection.SavepointSupport savepointSupport)`
Sets how savepoints should be supported on this connection.
`default void`
`setStatementTag(String tag)`
Sets the statement tag to use for the next statement that will be executed.
`void`
`setTransactionMode(com.google.cloud.spanner.connection.TransactionMode transactionMode)`
Sets the transaction mode to use for current transaction.
`default void`
`setTransactionTag(String tag)`
Sets the transaction tag to use for the current transaction.
`void`
`write(com.google.cloud.spanner.Mutation mutation)`
Writes the specified mutation directly to the database and commits the change.
`void`
`write(Iterable<com.google.cloud.spanner.Mutation> mutations)`
Writes the specified mutations directly to the database and commits the changes.

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

`abort, clearWarnings, close, commit, createArrayOf, createBlob, createClob, createNClob, createSQLXML, createStatement, createStatement, createStatement, createStruct, getAutoCommit, getCatalog, getClientInfo, getClientInfo, getHoldability, getMetaData, getNetworkTimeout, getSchema, getTransactionIsolation, getTypeMap, getWarnings, isClosed, isReadOnly, isValid, nativeSQL, prepareCall, prepareCall, prepareCall, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, releaseSavepoint, rollback, rollback, setAutoCommit, setCatalog, setClientInfo, setClientInfo, setHoldability, setNetworkTimeout, setReadOnly, setSavepoint, setSavepoint, setSchema, setTransactionIsolation, setTypeMap`

### Methods inherited from interface java.sql.Wrapper

`isWrapperFor, unwrap`

## Method Details

### setTransactionTag

default void setTransactionTag(String tag) throws SQLException
Sets the transaction tag to use for the current transaction. This method may only be called when in a transaction, and before the transaction is actually started, i.e. before any statements have been executed in the transaction.

The tag will be set as the transaction tag of all statements during the transaction, and as the transaction tag of the commit.

The transaction tag will automatically be cleared after the transaction has ended.

Parameters:
  `tag` - The tag to use.
Throws:
  `SQLException`

### getTransactionTag

default String getTransactionTag() throws SQLException

Returns:
  The transaction tag of the current transaction.
Throws:
  `SQLException`

### setStatementTag

default void setStatementTag(String tag) throws SQLException
Sets the statement tag to use for the next statement that will be executed. The tag is automatically cleared after the statement is executed. Statement tags can be used both with autocommit=true and autocommit=false, and can be used for partitioned DML.

Parameters:
  `tag` - The statement tag to use with the next statement that will be executed on this connection.
Throws:
  `SQLException`

### getStatementTag

default String getStatementTag() throws SQLException

Returns:
  The statement tag that will be used with the next statement that is executed on this connection.
Throws:
  `SQLException`

### setTransactionMode

void setTransactionMode(com.google.cloud.spanner.connection.TransactionMode transactionMode) throws SQLException
Sets the transaction mode to use for current transaction. This method may only be called when in a transaction, and before the transaction is actually started, i.e. before any statements have been executed in the transaction.

Parameters:
  `transactionMode` - The transaction mode to use for the current transaction.
  - `TransactionMode.READ_ONLY_TRANSACTION` will create a read-only transaction and prevent any changes to written to the database through this transaction. The read timestamp to be used will be determined based on the current readOnlyStaleness setting of this connection. It is recommended to use `TransactionMode.READ_ONLY_TRANSACTION` instead of `TransactionMode.READ_WRITE_TRANSACTION` when possible, as read-only transactions do not acquire locks on Cloud Spanner, and read-only transactions never abort.
  - `TransactionMode.READ_WRITE_TRANSACTION` this value is only allowed when the connection is not in read-only mode and will create a read-write transaction. If `isRetryAbortsInternally()` is `true`, each read/write transaction will keep track of a running SHA256 checksum for each `ResultSet` that is returned in order to be able to retry the transaction in case the transaction is aborted by Spanner.
Throws:
  `SQLException`

### getTransactionMode

com.google.cloud.spanner.connection.TransactionMode getTransactionMode() throws SQLException

Returns:
  the transaction mode of the current transaction. This method may only be called when the connection is in a transaction.
Throws:
  `SQLException`

### setAutocommitDmlMode

void setAutocommitDmlMode(com.google.cloud.spanner.connection.AutocommitDmlMode mode) throws SQLException
Sets the mode for executing DML statements in autocommit mode for this connection. This setting is only used when the connection is in autocommit mode, and may only be set while the transaction is in autocommit mode and not in a temporary transaction. The autocommit transaction mode is reset to its default value of `AutocommitDmlMode.TRANSACTIONAL` when autocommit mode is changed on the connection.

Parameters:
  `mode` - The DML autocommit mode to use
  - `AutocommitDmlMode.TRANSACTIONAL` DML statements are executed as single read-write transaction. After successful execution, the DML statement is guaranteed to have been applied exactly once to the database
  - `AutocommitDmlMode.PARTITIONED_NON_ATOMIC` DML statements are executed as partitioned DML transactions. If an error occurs during the execution of the DML statement, it is possible that the statement has been applied to some but not all of the rows specified in the statement.
Throws:
  `SQLException`

### getAutocommitDmlMode

com.google.cloud.spanner.connection.AutocommitDmlMode getAutocommitDmlMode() throws SQLException

Returns:
  the current `AutocommitDmlMode` setting for this connection. This method may only be called on a connection that is in autocommit mode and not while in a temporary transaction.
Throws:
  `SQLException`

### setReadOnlyStaleness

void setReadOnlyStaleness(com.google.cloud.spanner.TimestampBound staleness) throws SQLException
Sets the staleness to use for the current read-only transaction. This method may only be called when the transaction mode of the current transaction is `TransactionMode.READ_ONLY_TRANSACTION` and there is no transaction that has started, or when the connection is in read-only and autocommit mode.

Parameters:
  `staleness` - The staleness to use for the current but not yet started read-only transaction
Throws:
  `SQLException`

### getReadOnlyStaleness

com.google.cloud.spanner.TimestampBound getReadOnlyStaleness() throws SQLException

Returns:
  the read-only staleness setting for the current read-only transaction. This method may only be called when the current transaction is a read-only transaction, or when the connection is in read-only and autocommit mode.
Throws:
  `SQLException`

### setOptimizerVersion

void setOptimizerVersion(String optimizerVersion) throws SQLException
Sets the query optimizer version to use for this connection.

Parameters:
  `optimizerVersion` - The query optimizer version to use. Must be a valid optimizer version number, the string `LATEST` or an empty string. The empty string will instruct the connection to use the optimizer version that is defined in the environment variable `SPANNER_OPTIMIZER_VERSION`. If no value is specified in the environment variable, the default query optimizer of Cloud Spanner is used.
Throws:
  `SQLException`

### getOptimizerVersion

String getOptimizerVersion() throws SQLException
Gets the current query optimizer version of this connection.

Returns:
  The query optimizer version that is currently used by this connection.
Throws:
  `SQLException`

### isInTransaction

boolean isInTransaction() throws SQLException

Returns:
  `true` if this connection has a transaction (that has not necessarily started). This method will only return false when the `Connection` is in autocommit mode and no explicit transaction has been started by executing `BEGIN TRANSACTION`. If the `Connection` is not in autocommit mode, there will always be a transaction.
Throws:
  `SQLException`

### isTransactionStarted

boolean isTransactionStarted() throws SQLException

Returns:
  `true` if this connection has a transaction that has started. A transaction is automatically started by the first statement that is executed in the transaction.
Throws:
  `SQLException`

### getCommitTimestamp

Timestamp getCommitTimestamp() throws SQLException

Returns:
  the commit `Timestamp` of the last read/write transaction. If the last transaction was not a read/write transaction, or a read/write transaction that did not return a commit timestamp because the transaction was not committed, the method will throw a `SQLException`.
Throws:
  `SQLException`

### getCommitResponse

com.google.cloud.spanner.CommitResponse getCommitResponse() throws SQLException

Returns:
  the `CommitResponse` of the last read/write transaction. If the last transaction was not a read/write transaction, or a read/write transaction that did not return a `CommitResponse` because the transaction was not committed, the method will throw a `SQLException`. The `CommitResponse` will include `CommitStats` if `isReturnCommitStats()` returns true.
Throws:
  `SQLException`

### setReturnCommitStats

void setReturnCommitStats(boolean returnCommitStats) throws SQLException
Sets whether this connection should request commit statistics from Cloud Spanner for read/write transactions and for DML statements in autocommit mode.

Throws:
  `SQLException`

### isReturnCommitStats

boolean isReturnCommitStats() throws SQLException

Returns:
  true if this connection requests commit statistics from Cloud Spanner.
Throws:
  `SQLException`

### getReadTimestamp

Timestamp getReadTimestamp() throws SQLException

Returns:
  the read `Timestamp` of the last read-only transaction. If the last transaction was not a read-only transaction, or a read-only transaction that did not return a read timestamp because no data was read, the method will throw a `SQLException`.
Throws:
  `SQLException`

### isRetryAbortsInternally

boolean isRetryAbortsInternally() throws SQLException

Returns:
  `true` if this connection will automatically retry read/write transactions that abort. This method may only be called when the connection is in read/write transactional mode and no transaction has been started yet.
Throws:
  `SQLException`

### setRetryAbortsInternally

void setRetryAbortsInternally(boolean retryAbortsInternally) throws SQLException
Sets whether this connection will internally retry read/write transactions that abort. The default is `true`. When internal retry is enabled, the `Connection` will keep track of a running SHA256 checksum of all `ResultSet`s that have been returned from Cloud Spanner. If the checksum that is calculated during an internal retry differs from the original checksum, the transaction will abort with an `AbortedDueToConcurrentModificationException`.

Note that retries of a read/write transaction that calls a non-deterministic function on Cloud Spanner, such as CURRENT_TIMESTAMP(), will never be successful, as the data returned during the retry will always be different from the original transaction.

It is also highly recommended that all queries in a read/write transaction have an ORDER BY clause that guarantees that the data is returned in the same order as in the original transaction if the transaction is internally retried. The most efficient way to achieve this is to always include the primary key columns at the end of the ORDER BY clause.

This method may only be called when the connection is in read/write transactional mode and no transaction has been started yet.

Parameters:
  `retryAbortsInternally` - Set to `true` to internally retry transactions that are aborted by Spanner. When set to `false`, any database call on a transaction that has been aborted by Cloud Spanner will throw an `AbortedException` instead of being retried. Set this to false if your application already uses retry loops to handle `AbortedException`s.
Throws:
  `SQLException`

### getSavepointSupport

com.google.cloud.spanner.connection.SavepointSupport getSavepointSupport() throws SQLException
Returns the current savepoint support for this connection.

Throws:
  `SQLException`

### setSavepointSupport

void setSavepointSupport(com.google.cloud.spanner.connection.SavepointSupport savepointSupport) throws SQLException
Sets how savepoints should be supported on this connection.

Throws:
  `SQLException`

### write

void write(com.google.cloud.spanner.Mutation mutation) throws SQLException
Writes the specified mutation directly to the database and commits the change. The value is readable after the successful completion of this method. Writing multiple mutations to a database by calling this method multiple times mode is inefficient, as each call will need a round trip to the database. Instead, you should consider writing the mutations together by calling `write(Iterable)`.

Calling this method is only allowed in autocommit mode. See `bufferedWrite(Iterable)` for writing mutations in transactions.

Parameters:
  `mutation` - The `Mutation` to write to the database.
Throws:
  `SQLException` - if the `Connection` is not in autocommit mode or if the `Connection` is closed.

### write

void write(Iterable<com.google.cloud.spanner.Mutation> mutations) throws SQLException
Writes the specified mutations directly to the database and commits the changes. The values are readable after the successful completion of this method.

Calling this method is only allowed in autocommit mode. See `bufferedWrite(Iterable)` for writing mutations in transactions.

Parameters:
  `mutations` - The `Mutation`s to write to the database.
Throws:
  `SQLException` - if the `Connection` is not in autocommit mode or if the `Connection` is closed.

### bufferedWrite

void bufferedWrite(com.google.cloud.spanner.Mutation mutation) throws SQLException
Buffers the given mutation locally on the current transaction of this `Connection`. The mutation will be written to the database at the next call to `Connection.commit()`. The value will not be readable on this `Connection` before the transaction is committed.

Calling this method is only allowed when not in autocommit mode. See `write(Mutation)` for writing mutations in autocommit mode.

Parameters:
  `mutation` - the `Mutation` to buffer for writing to the database on the next commit.
Throws:
  `SQLException` - if the `Connection` is in autocommit mode or the `Connection` is closed.

### bufferedWrite

void bufferedWrite(Iterable<com.google.cloud.spanner.Mutation> mutations) throws SQLException
Buffers the given mutations locally on the current transaction of this `Connection`. The mutations will be written to the database at the next call to `Connection.commit()`. The values will not be readable on this `Connection` before the transaction is committed.

Calling this method is only allowed when not in autocommit mode. See `write(Iterable)` for writing mutations in autocommit mode.

Parameters:
  `mutations` - the `Mutation`s to buffer for writing to the database on the next commit.
Throws:
  `SQLException` - if the `Connection` is in autocommit mode or the `Connection` is closed.

### getConnectionUrl

String getConnectionUrl()

Returns:
  a connection URL that can be used to create a new `Connection` that is equal to the initial state of this connection. If this connection was initially opened in read-only mode, and later changed to read-write, this will not be reflected in the connection URL that is returned.

### getDialect

default com.google.cloud.spanner.Dialect getDialect()

Returns:
  The `Dialect` that is used by this connection.

### setDataBoostEnabled

default void setDataBoostEnabled(boolean dataBoostEnabled) throws SQLException
Enable data boost for partitioned queries. See also `CloudSpannerJdbcStatement.partitionQuery(String, PartitionOptions, QueryOption...)` and `CloudSpannerJdbcPreparedStatement.partitionQuery(PartitionOptions, QueryOption...)`.

Throws:
  `SQLException`

### isDataBoostEnabled

default boolean isDataBoostEnabled() throws SQLException
Returns whether data boost is enabled for partitioned queries. See also `CloudSpannerJdbcStatement.partitionQuery(String, PartitionOptions, QueryOption...)` and `CloudSpannerJdbcPreparedStatement.partitionQuery(PartitionOptions, QueryOption...)`.

Throws:
  `SQLException`

### setAutoPartitionMode

default void setAutoPartitionMode(boolean alwaysUsePartitionedQueries) throws SQLException
Sets whether this connection should always use partitioned queries when a query is executed on this connection. Setting this flag to `true` and then executing a query that cannot be partitioned, or executing a query in a read/write transaction, will cause an error. Use this flag in combination with `setDataBoostEnabled(boolean)` to force all queries on this connection to use data boost.

Throws:
  `SQLException`

### isAutoPartitionMode

default boolean isAutoPartitionMode() throws SQLException
Returns whether this connection will execute all queries as partitioned queries.

Throws:
  `SQLException`

### setMaxPartitions

default void setMaxPartitions(int maxPartitions) throws SQLException
Sets the maximum number of partitions that should be included as a hint to Cloud Spanner when partitioning a query on this connection. Note that this is only a hint and Cloud Spanner might choose to ignore the hint.

Throws:
  `SQLException`

### getMaxPartitions

default int getMaxPartitions() throws SQLException
Gets the maximum number of partitions that should be included as a hint to Cloud Spanner when partitioning a query on this connection. Note that this is only a hint and Cloud Spanner might choose to ignore the hint.

Throws:
  `SQLException`

### setMaxPartitionedParallelism

default void setMaxPartitionedParallelism(int maxThreads) throws SQLException
Sets the maximum degree of parallelism that is used when executing a partitioned query. A partitioned query will use up to `maxThreads` to execute and retrieve the results from Cloud Spanner. Set this value to `0`> to use the number of available processors as returned by `Runtime.availableProcessors()`.

Throws:
  `SQLException`

### getMaxPartitionedParallelism

default int getMaxPartitionedParallelism() throws SQLException
Returns the maximum degree of parallelism that is used for partitioned queries.

Throws:
  `SQLException`

### setAutoBatchDml

default void setAutoBatchDml(boolean autoBatchDml) throws SQLException
Enables or disables automatic batching of DML statements. When enabled, DML statements that are executed on this connection will be buffered in memory instead of actually being executed. The buffered DML statements are flushed to Spanner when a statement that cannot be part of a DML batch is executed on the connection. This can be a query, a DDL statement with a THEN RETURN clause, or a Commit call. The update count that is returned for DML statements that are buffered is determined by the value that has been set with `setAutoBatchDmlUpdateCount(long)`. The default is 1. The connection verifies that the update counts that were returned while buffering DML statements match the actual update counts that are returned by Spanner when the batch is executed. This verification can be disabled by calling `setAutoBatchDmlUpdateCountVerification(boolean)`.

Throws:
  `SQLException`

### isAutoBatchDml

default boolean isAutoBatchDml() throws SQLException
Returns whether automatic DML batching is enabled on this connection.

Throws:
  `SQLException`

### setAutoBatchDmlUpdateCount

default void setAutoBatchDmlUpdateCount(long updateCount) throws SQLException
Sets the update count that is returned for DML statements that are buffered during an automatic DML batch. This value is only used if `isAutoBatchDml()` is enabled.

Throws:
  `SQLException`

### getAutoBatchDmlUpdateCount

default long getAutoBatchDmlUpdateCount() throws SQLException
Returns the update count that is returned for DML statements that are buffered during an automatic DML batch.

Throws:
  `SQLException`

### setAutoBatchDmlUpdateCountVerification

default void setAutoBatchDmlUpdateCountVerification(boolean verification) throws SQLException
Sets whether the update count that is returned by Spanner after executing an automatic DML batch should be verified against the update counts that were returned during the buffering of those statements.

Throws:
  `SQLException`

### isAutoBatchDmlUpdateCountVerification

default boolean isAutoBatchDmlUpdateCountVerification() throws SQLException
Indicates whether the update counts of automatic DML batches should be verified.

Throws:
  `SQLException`

### addTransactionRetryListener

void addTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener listener) throws SQLException

Throws:
  `SQLException` - if the `Connection` is closed.
See Also:
  - `Connection.addTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener)`

### addTransactionRetryListener

@Deprecated void addTransactionRetryListener(TransactionRetryListener listener) throws SQLException
Deprecated.
Use `addTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener)` instead.

Throws:
  `SQLException`

### removeTransactionRetryListener

boolean removeTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener listener) throws SQLException

Throws:
  `SQLException` - if the `Connection` is closed.
See Also:
  - `Connection.removeTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener)`

### removeTransactionRetryListener

@Deprecated boolean removeTransactionRetryListener(TransactionRetryListener listener) throws SQLException
Deprecated.
Use `removeTransactionRetryListener(com.google.cloud.spanner.connection.TransactionRetryListener)` instead.

Throws:
  `SQLException`

### getTransactionRetryListeners

@Deprecated Iterator<TransactionRetryListener> getTransactionRetryListeners() throws SQLException
Deprecated.
Use `getTransactionRetryListenersFromConnection()` instead.

Throws:
  `SQLException`

### getTransactionRetryListenersFromConnection

Iterator<com.google.cloud.spanner.connection.TransactionRetryListener> getTransactionRetryListenersFromConnection() throws SQLException

Throws:
  `SQLException` - if the `Connection` is closed.
See Also:
  - `Connection.getTransactionRetryListeners()`

### setProtoDescriptors

default void setProtoDescriptors(@Nonnull byte[] protoDescriptors) throws SQLException
Sets the proto descriptors to use for the next DDL statement (single or batch) that will be executed. The proto descriptor is automatically cleared after the statement is executed.

Parameters:
  `protoDescriptors` - The proto descriptors to use with the next DDL statement (single or batch) that will be executed on this connection.
Throws:
  `SQLException`

### setProtoDescriptors

default void setProtoDescriptors(@Nonnull InputStream protoDescriptors) throws SQLException, IOException
Sets the proto descriptors to use for the next DDL statement (single or batch) that will be executed. The proto descriptor is automatically cleared after the statement is executed.

Parameters:
  `protoDescriptors` - The proto descriptors to use with the next DDL statement (single or batch) that will be executed on this connection.
Throws:
  `SQLException`
  `IOException`

### getProtoDescriptors

default byte[] getProtoDescriptors() throws SQLException

Returns:
  The proto descriptor that will be used with the next DDL statement (single or batch) that is executed on this connection.
Throws:
  `SQLException`