Package com.google.cloud.spanner.jdbc

Interface CloudSpannerJdbcConnection

    • Method Detail

      • 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 ResultSets 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 AbortedExceptions.
        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 Mutations 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 Mutations 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.

      • 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)

      • 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)

      • getTransactionRetryListenersFromConnection

        Iterator<com.google.cloud.spanner.connection.TransactionRetryListener> getTransactionRetryListenersFromConnection()
                                                                                                           throws SQLException
        Throws:
        SQLException - if the Connection is closed.
        See Also:
        Connection.getTransactionRetryListeners()