diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/ConnectionImpl.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/ConnectionImpl.java index cadd63757398..8e375ee2bfa9 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/ConnectionImpl.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/ConnectionImpl.java @@ -1780,16 +1780,6 @@ private ResultSet parseAndExecuteQuery( return internalExecuteQuery(callType, parsedStatement, analyzeMode, options); case UPDATE: if (parsedStatement.hasReturningClause()) { - // Cannot execute DML statement with returning clause in read-only mode or in - // READ_ONLY_TRANSACTION transaction mode. - if (this.isReadOnly() - || (this.isInTransaction() - && this.getTransactionMode() == TransactionMode.READ_ONLY_TRANSACTION)) { - throw SpannerExceptionFactory.newSpannerException( - ErrorCode.FAILED_PRECONDITION, - "DML statement with returning clause cannot be executed in read-only mode: " - + parsedStatement.getSql()); - } return internalExecuteQuery(callType, parsedStatement, analyzeMode, options); } case DDL: @@ -1821,16 +1811,6 @@ private AsyncResultSet parseAndExecuteQueryAsync(Statement query, QueryOption... CallType.ASYNC, parsedStatement, AnalyzeMode.NONE, options); case UPDATE: if (parsedStatement.hasReturningClause()) { - // Cannot execute DML statement with returning clause in read-only mode or in - // READ_ONLY_TRANSACTION transaction mode. - if (this.isReadOnly() - || (this.isInTransaction() - && this.getTransactionMode() == TransactionMode.READ_ONLY_TRANSACTION)) { - throw SpannerExceptionFactory.newSpannerException( - ErrorCode.FAILED_PRECONDITION, - "DML statement with returning clause cannot be executed in read-only mode: " - + parsedStatement.getSql()); - } return internalExecuteQueryAsync( CallType.ASYNC, parsedStatement, AnalyzeMode.NONE, options); } @@ -2099,6 +2079,24 @@ private UpdateOption[] mergeUpdateRequestOptions(UpdateOption... options) { return options; } + /** + * Throws a {@link SpannerException} with {@link ErrorCode#FAILED_PRECONDITION} if this connection + * is in read-only mode or in a {@link TransactionMode#READ_ONLY_TRANSACTION}, since DML + * statements mutate data and require a read/write transaction. + */ + private void checkDmlReturningAllowed(ParsedStatement parsedStatement) { + if (this.isReadOnly() + || (this.isInTransaction() + && this.getTransactionMode() == TransactionMode.READ_ONLY_TRANSACTION)) { + throw SpannerExceptionFactory.newSpannerException( + ErrorCode.FAILED_PRECONDITION, + parsedStatement.hasReturningClause() + ? "DML statement with returning clause cannot be executed in read-only mode: " + + parsedStatement.getSql() + : "Update statements are not allowed in read-only mode"); + } + } + private ResultSet internalExecuteQuery( final CallType callType, final ParsedStatement statement, @@ -2110,6 +2108,10 @@ private ResultSet internalExecuteQuery( && (analyzeMode != AnalyzeMode.NONE || statement.hasReturningClause())), "Statement must either be a query or a DML mode with analyzeMode!=NONE or returning" + " clause"); + // Enforce read-only restrictions before allocating a UnitOfWork or consuming statementTag. + if (statement.isUpdate()) { + checkDmlReturningAllowed(statement); + } boolean isInternalMetadataQuery = isInternalMetadataQuery(options); QueryOption[] combinedOptions = concat(statement.getOptionsFromHints(), options); UnitOfWork transaction = @@ -2137,6 +2139,10 @@ private AsyncResultSet internalExecuteQueryAsync( (statement.getType() == StatementType.QUERY) || (statement.getType() == StatementType.UPDATE && statement.hasReturningClause()), "Statement must be a query or DML with returning clause."); + // Enforce read-only restrictions before allocating a UnitOfWork or consuming statementTag. + if (statement.isUpdate()) { + checkDmlReturningAllowed(statement); + } ConnectionPreconditions.checkState( !(isAutoPartitionMode() && statement.getType() == StatementType.QUERY), "Partitioned queries cannot be executed asynchronously"); diff --git a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SingleUseTransaction.java b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SingleUseTransaction.java index cfb13cef966b..54107f12d3c8 100644 --- a/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SingleUseTransaction.java +++ b/java-spanner/google-cloud-spanner/src/main/java/com/google/cloud/spanner/connection/SingleUseTransaction.java @@ -222,6 +222,16 @@ public ApiFuture executeQueryAsync( && (analyzeMode != AnalyzeMode.NONE || statement.hasReturningClause())), "The statement must be a query, or the statement must be DML and AnalyzeMode must be PLAN" + " or PROFILE"); + // Enforce read-only mode before checkAndMarkUsed() so a rejected DML statement leaves this + // single-use transaction unused in STARTED state without opening a write transaction. + if (statement.isUpdate() && isReadOnly()) { + throw SpannerExceptionFactory.newSpannerException( + ErrorCode.FAILED_PRECONDITION, + statement.hasReturningClause() + ? "DML statement with returning clause cannot be executed in read-only mode: " + + statement.getSql() + : "Update statements are not allowed in read-only mode"); + } try (Scope ignore = span.makeCurrent()) { checkAndMarkUsed(); diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplAutocommitReadOnlyTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplAutocommitReadOnlyTest.java index 58e2c6f3e77e..2ec0e7971be4 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplAutocommitReadOnlyTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplAutocommitReadOnlyTest.java @@ -16,14 +16,48 @@ package com.google.cloud.spanner.connection; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.api.gax.core.ExecutorProvider; +import com.google.api.gax.core.InstantiatingExecutorProvider; import com.google.cloud.NoCredentials; +import com.google.cloud.Timestamp; +import com.google.cloud.spanner.BatchClient; +import com.google.cloud.spanner.CommitResponse; +import com.google.cloud.spanner.DatabaseClient; +import com.google.cloud.spanner.Dialect; +import com.google.cloud.spanner.ErrorCode; +import com.google.cloud.spanner.ReadContext.QueryAnalyzeMode; +import com.google.cloud.spanner.ResultSet; +import com.google.cloud.spanner.Spanner; +import com.google.cloud.spanner.SpannerException; +import com.google.cloud.spanner.SpannerExceptionFactory; import com.google.cloud.spanner.Statement; import com.google.cloud.spanner.TimestampBound; import com.google.cloud.spanner.TimestampBound.Mode; +import com.google.cloud.spanner.TransactionContext; +import com.google.cloud.spanner.TransactionRunner; import com.google.cloud.spanner.connection.AbstractStatementParser.StatementType; +import com.google.cloud.spanner.connection.StatementResult.ResultType; +import com.google.common.util.concurrent.ThreadFactoryBuilder; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import java.util.concurrent.TimeUnit; +import org.junit.Test; import org.junit.experimental.runners.Enclosed; import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; /** * The tests in this class do not need to be implemented for client libraries in other programming @@ -935,4 +969,182 @@ boolean isAbortBatchAllowed() { return false; } } + + /** + * Verifies that autocommit read-only connections reject DML statements with GoogleSQL {@code THEN + * RETURN} and PostgreSQL {@code RETURNING} clauses across all synchronous and asynchronous + * execution entrypoints without issuing write RPCs or mutating transient connection state. + */ + @RunWith(Parameterized.class) + public static class ConnectionImplAutocommitReadOnlyDmlReturningTest { + private static final ExecutorProvider ASYNC_EXECUTOR_PROVIDER = + InstantiatingExecutorProvider.newBuilder() + .setExecutorThreadCount(1) + .setThreadFactory( + new ThreadFactoryBuilder() + .setDaemon(true) + .setNameFormat("autocommit-readonly-dml-returning-test-%d") + .build()) + .build(); + + @Parameter public Dialect dialect; + + @Parameters(name = "dialect = {0}") + public static Object[] data() { + return Dialect.values(); + } + + private List dmlReturningStatements() { + if (dialect == Dialect.POSTGRESQL) { + return Arrays.asList( + "INSERT INTO foo (id, name) VALUES (1, 'bar') RETURNING id", + "UPDATE foo SET bar=1 WHERE id=1 RETURNING bar", + "DELETE FROM foo WHERE id=1 RETURNING id"); + } + return Arrays.asList( + "INSERT INTO foo (id, name) VALUES (1, 'bar') THEN RETURN id", + "UPDATE foo SET bar=1 WHERE id=1 THEN RETURN bar", + "DELETE FROM foo WHERE id=1 THEN RETURN id"); + } + + /** + * Creates an autocommit read-only {@link ConnectionImpl} backed by {@code dbClient} with a + * stubbed {@code readWriteTransaction()} so any unguarded write execution succeeds rather than + * failing with an unrelated mock null-pointer error. + */ + private ConnectionImpl createAutocommitReadOnlyConnection(DatabaseClient dbClient) { + Spanner spanner = mock(Spanner.class); + when(spanner.getAsyncExecutorProvider()).thenReturn(ASYNC_EXECUTOR_PROVIDER); + SpannerPool spannerPool = mock(SpannerPool.class); + when(spannerPool.getSpanner(any(ConnectionOptions.class), any(ConnectionImpl.class))) + .thenReturn(spanner); + when(dbClient.getDialect()).thenReturn(dialect); + when(dbClient.readWriteTransaction()) + .thenAnswer( + invocation -> + new TransactionRunner() { + private CommitResponse commitResponse; + + @Override + public T run(TransactionCallable callable) { + TransactionContext txContext = mock(TransactionContext.class); + ResultSet returningRs = mock(ResultSet.class); + when(returningRs.next()).thenReturn(true, false); + when(returningRs.getLong(0)).thenReturn(1L); + when(txContext.executeQuery(any(Statement.class), any())) + .thenReturn(returningRs); + try { + T result = callable.run(txContext); + commitResponse = new CommitResponse(Timestamp.ofTimeSecondsAndNanos(1, 1)); + return result; + } catch (Exception e) { + throw SpannerExceptionFactory.newSpannerException(e); + } + } + + @Override + public Timestamp getCommitTimestamp() { + return commitResponse.getCommitTimestamp(); + } + + @Override + public CommitResponse getCommitResponse() { + return commitResponse; + } + + @Override + public TransactionRunner allowNestedTransaction() { + return this; + } + }); + + ConnectionOptions options = + ConnectionOptions.newBuilder() + .setCredentials(NoCredentials.getInstance()) + .setUri(ConnectionImplTest.URI) + .build(); + ConnectionImpl connection = + new ConnectionImpl( + options, spannerPool, mock(DdlClient.class), dbClient, mock(BatchClient.class)); + connection.setAutocommit(true); + connection.setReadOnly(true); + assertTrue(connection.isAutocommit()); + assertTrue(connection.isReadOnly()); + return connection; + } + + @Test + public void testExecuteDmlReturningRejectedInAutocommitReadOnly() { + for (String sql : dmlReturningStatements()) { + Statement stmt = Statement.of(sql); + String expectedMessage = + "DML statement with returning clause cannot be executed in read-only mode: " + sql; + DatabaseClient dbClient = mock(DatabaseClient.class); + try (ConnectionImpl connection = createAutocommitReadOnlyConnection(dbClient)) { + connection.setStatementTag("autocommit-tag"); + + SpannerException execEx = + assertThrows(SpannerException.class, () -> connection.execute(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, execEx.getErrorCode()); + assertTrue(execEx.getMessage().contains(expectedMessage)); + assertEquals("autocommit-tag", connection.getStatementTag()); + + SpannerException execAllowedTypesEx = + assertThrows( + SpannerException.class, + () -> connection.execute(stmt, Collections.singleton(ResultType.RESULT_SET))); + assertEquals(ErrorCode.FAILED_PRECONDITION, execAllowedTypesEx.getErrorCode()); + assertTrue(execAllowedTypesEx.getMessage().contains(expectedMessage)); + assertEquals("autocommit-tag", connection.getStatementTag()); + + SpannerException execAsyncEx = + assertThrows(SpannerException.class, () -> connection.executeAsync(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, execAsyncEx.getErrorCode()); + assertTrue(execAsyncEx.getMessage().contains(expectedMessage)); + assertEquals("autocommit-tag", connection.getStatementTag()); + assertFalse(connection.isTransactionStarted()); + + verify(dbClient, never()).readWriteTransaction(); + verify(dbClient, never()).readWriteTransaction(any()); + } + } + } + + @Test + public void testExecuteQueryAndAnalyzeQueryDmlReturningRejectedInAutocommitReadOnly() { + for (String sql : dmlReturningStatements()) { + Statement stmt = Statement.of(sql); + String expectedMessage = + "DML statement with returning clause cannot be executed in read-only mode: " + sql; + DatabaseClient dbClient = mock(DatabaseClient.class); + try (ConnectionImpl connection = createAutocommitReadOnlyConnection(dbClient)) { + connection.setStatementTag("query-tag"); + + SpannerException queryEx = + assertThrows(SpannerException.class, () -> connection.executeQuery(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, queryEx.getErrorCode()); + assertTrue(queryEx.getMessage().contains(expectedMessage)); + assertEquals("query-tag", connection.getStatementTag()); + + SpannerException queryAsyncEx = + assertThrows(SpannerException.class, () -> connection.executeQueryAsync(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, queryAsyncEx.getErrorCode()); + assertTrue(queryAsyncEx.getMessage().contains(expectedMessage)); + assertEquals("query-tag", connection.getStatementTag()); + + for (QueryAnalyzeMode analyzeMode : QueryAnalyzeMode.values()) { + SpannerException analyzeEx = + assertThrows( + SpannerException.class, () -> connection.analyzeQuery(stmt, analyzeMode)); + assertEquals(ErrorCode.FAILED_PRECONDITION, analyzeEx.getErrorCode()); + assertTrue(analyzeEx.getMessage().contains(expectedMessage)); + assertEquals("query-tag", connection.getStatementTag()); + } + + verify(dbClient, never()).readWriteTransaction(); + verify(dbClient, never()).readWriteTransaction(any()); + } + } + } + } } diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplTransactionalReadOnlyTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplTransactionalReadOnlyTest.java index 627fadd79eb9..6cd176b06186 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplTransactionalReadOnlyTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/ConnectionImplTransactionalReadOnlyTest.java @@ -16,14 +16,48 @@ package com.google.cloud.spanner.connection; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.api.gax.core.ExecutorProvider; +import com.google.api.gax.core.InstantiatingExecutorProvider; import com.google.cloud.NoCredentials; +import com.google.cloud.Timestamp; +import com.google.cloud.spanner.BatchClient; +import com.google.cloud.spanner.DatabaseClient; +import com.google.cloud.spanner.Dialect; +import com.google.cloud.spanner.ErrorCode; +import com.google.cloud.spanner.Options.QueryOption; +import com.google.cloud.spanner.ReadContext.QueryAnalyzeMode; +import com.google.cloud.spanner.ReadOnlyTransaction; +import com.google.cloud.spanner.ResultSet; +import com.google.cloud.spanner.Spanner; +import com.google.cloud.spanner.SpannerException; import com.google.cloud.spanner.Statement; import com.google.cloud.spanner.TimestampBound; import com.google.cloud.spanner.TimestampBound.Mode; +import com.google.cloud.spanner.Type; import com.google.cloud.spanner.connection.AbstractStatementParser.StatementType; +import com.google.cloud.spanner.connection.StatementResult.ResultType; +import com.google.common.util.concurrent.ThreadFactoryBuilder; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import java.util.concurrent.TimeUnit; +import org.junit.Test; import org.junit.experimental.runners.Enclosed; import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; /** * The tests in this class do not need to be implemented for client libraries in other programming @@ -1233,4 +1267,230 @@ boolean isAbortBatchAllowed() { return false; } } + + /** + * Verifies that transactional read-only connections (both {@code readOnly=true} and writable + * connections in {@link TransactionMode#READ_ONLY_TRANSACTION}) reject DML statements with + * GoogleSQL {@code THEN RETURN} and PostgreSQL {@code RETURNING} clauses with {@link + * ErrorCode#FAILED_PRECONDITION} without starting an idle transaction or corrupting an active + * {@link com.google.cloud.spanner.connection.ReadOnlyTransaction}. + */ + @RunWith(Parameterized.class) + public static class ConnectionImplTransactionalReadOnlyDmlReturningTest { + private static final String SELECT_SQL = "SELECT 1 AS TEST"; + private static final Timestamp FIXED_READ_TIMESTAMP = + Timestamp.ofTimeSecondsAndNanos(12345L, 0); + private static final ExecutorProvider ASYNC_EXECUTOR_PROVIDER = + InstantiatingExecutorProvider.newBuilder() + .setExecutorThreadCount(1) + .setThreadFactory( + new ThreadFactoryBuilder() + .setDaemon(true) + .setNameFormat("transactional-readonly-dml-returning-test-%d") + .build()) + .build(); + + @Parameter public Dialect dialect; + + @Parameters(name = "dialect = {0}") + public static Object[] data() { + return Dialect.values(); + } + + private List dmlReturningStatements() { + if (dialect == Dialect.POSTGRESQL) { + return Arrays.asList( + "INSERT INTO foo (id, name) VALUES (1, 'bar') RETURNING id", + "UPDATE foo SET bar=1 WHERE id=1 RETURNING bar", + "DELETE FROM foo WHERE id=1 RETURNING id"); + } + return Arrays.asList( + "INSERT INTO foo (id, name) VALUES (1, 'bar') THEN RETURN id", + "UPDATE foo SET bar=1 WHERE id=1 THEN RETURN bar", + "DELETE FROM foo WHERE id=1 THEN RETURN id"); + } + + private static ResultSet createSelectOneResultSet() { + ResultSet rs = mock(ResultSet.class); + when(rs.next()).thenReturn(true, false); + when(rs.getLong(0)).thenReturn(1L); + when(rs.getType()).thenReturn(Type.struct()); + when(rs.getColumnType(0)).thenReturn(Type.int64()); + return rs; + } + + /** + * Creates a transactional {@link ConnectionImpl} configured either via connection-level {@code + * readOnly=true} or via explicit {@link TransactionMode#READ_ONLY_TRANSACTION} on a writable + * connection. + */ + private ConnectionImpl createTransactionalReadOnlyConnection( + DatabaseClient dbClient, boolean connectionReadOnly, boolean autocommitExplicitBegin) { + Spanner spanner = mock(Spanner.class); + when(spanner.getAsyncExecutorProvider()).thenReturn(ASYNC_EXECUTOR_PROVIDER); + SpannerPool spannerPool = mock(SpannerPool.class); + when(spannerPool.getSpanner(any(ConnectionOptions.class), any(ConnectionImpl.class))) + .thenReturn(spanner); + when(dbClient.getDialect()).thenReturn(dialect); + when(dbClient.readOnlyTransaction(any(TimestampBound.class))) + .thenAnswer( + invocation -> { + ReadOnlyTransaction readOnlyTx = mock(ReadOnlyTransaction.class); + when(readOnlyTx.executeQuery(Statement.of(SELECT_SQL))) + .thenAnswer(ignored -> createSelectOneResultSet()); + when(readOnlyTx.executeQuery(eq(Statement.of(SELECT_SQL)), any(QueryOption.class))) + .thenAnswer(ignored -> createSelectOneResultSet()); + when(readOnlyTx.getReadTimestamp()).thenReturn(FIXED_READ_TIMESTAMP); + return readOnlyTx; + }); + + ConnectionOptions options = + ConnectionOptions.newBuilder() + .setCredentials(NoCredentials.getInstance()) + .setUri(ConnectionImplTest.URI) + .build(); + ConnectionImpl connection = + new ConnectionImpl( + options, spannerPool, mock(DdlClient.class), dbClient, mock(BatchClient.class)); + if (autocommitExplicitBegin) { + connection.setAutocommit(true); + connection.setReadOnly(connectionReadOnly); + connection.beginTransaction(); + if (!connectionReadOnly) { + connection.setTransactionMode(TransactionMode.READ_ONLY_TRANSACTION); + } + } else { + connection.setAutocommit(false); + connection.setReadOnly(connectionReadOnly); + if (!connectionReadOnly) { + connection.setTransactionMode(TransactionMode.READ_ONLY_TRANSACTION); + } + } + assertTrue(connection.isInTransaction()); + assertEquals(TransactionMode.READ_ONLY_TRANSACTION, connection.getTransactionMode()); + return connection; + } + + private void assertAllQueryEntrypointsRejectWithFailedPrecondition( + Connection connection, Statement stmt, String expectedMessage) { + SpannerException execEx = + assertThrows(SpannerException.class, () -> connection.execute(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, execEx.getErrorCode()); + assertTrue(execEx.getMessage().contains(expectedMessage)); + + SpannerException execAllowedEx = + assertThrows( + SpannerException.class, + () -> connection.execute(stmt, Collections.singleton(ResultType.RESULT_SET))); + assertEquals(ErrorCode.FAILED_PRECONDITION, execAllowedEx.getErrorCode()); + assertTrue(execAllowedEx.getMessage().contains(expectedMessage)); + + SpannerException execAsyncEx = + assertThrows(SpannerException.class, () -> connection.executeAsync(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, execAsyncEx.getErrorCode()); + assertTrue(execAsyncEx.getMessage().contains(expectedMessage)); + + SpannerException queryEx = + assertThrows(SpannerException.class, () -> connection.executeQuery(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, queryEx.getErrorCode()); + assertTrue(queryEx.getMessage().contains(expectedMessage)); + + SpannerException queryAsyncEx = + assertThrows(SpannerException.class, () -> connection.executeQueryAsync(stmt)); + assertEquals(ErrorCode.FAILED_PRECONDITION, queryAsyncEx.getErrorCode()); + assertTrue(queryAsyncEx.getMessage().contains(expectedMessage)); + + for (QueryAnalyzeMode analyzeMode : QueryAnalyzeMode.values()) { + SpannerException analyzeEx = + assertThrows(SpannerException.class, () -> connection.analyzeQuery(stmt, analyzeMode)); + assertEquals(ErrorCode.FAILED_PRECONDITION, analyzeEx.getErrorCode()); + assertTrue(analyzeEx.getMessage().contains(expectedMessage)); + } + } + + @Test + public void testTransactionalReadOnlyRejectsDmlReturning() { + boolean[][] modes = + new boolean[][] { + {/* connectionReadOnly= */ true, /* autocommitExplicitBegin= */ false}, + {/* connectionReadOnly= */ false, /* autocommitExplicitBegin= */ false}, + {/* connectionReadOnly= */ false, /* autocommitExplicitBegin= */ true} + }; + for (boolean[] mode : modes) { + for (String sql : dmlReturningStatements()) { + Statement stmt = Statement.of(sql); + String expectedMessage = + "DML statement with returning clause cannot be executed in read-only mode: " + sql; + DatabaseClient dbClient = mock(DatabaseClient.class); + try (ConnectionImpl connection = + createTransactionalReadOnlyConnection(dbClient, mode[0], mode[1])) { + assertAllQueryEntrypointsRejectWithFailedPrecondition( + connection, stmt, expectedMessage); + verify(dbClient, never()).readWriteTransaction(); + verify(dbClient, never()).readWriteTransaction(any()); + verify(dbClient, never()).transactionManager(); + verify(dbClient, never()).transactionManager(any()); + } + } + } + } + + @Test + public void testTransactionalReadOnlyPreservesTransactionStateOnRejectedDmlReturning() { + Statement dmlReturning = Statement.of(dmlReturningStatements().get(0)); + String expectedMessage = + "DML statement with returning clause cannot be executed in read-only mode: " + + dmlReturning.getSql(); + + for (boolean connectionReadOnly : new boolean[] {true, false}) { + // 1. Idle transactional read-only connection: rejection must not start the transaction or + // consume the statement tag. + DatabaseClient idleDbClient = mock(DatabaseClient.class); + try (ConnectionImpl idleConn = + createTransactionalReadOnlyConnection( + idleDbClient, connectionReadOnly, /* autocommitExplicitBegin= */ false)) { + assertFalse(idleConn.isTransactionStarted()); + idleConn.setStatementTag("idle-tag"); + + assertAllQueryEntrypointsRejectWithFailedPrecondition( + idleConn, dmlReturning, expectedMessage); + + assertFalse(idleConn.isTransactionStarted()); + assertEquals("idle-tag", idleConn.getStatementTag()); + verify(idleDbClient, never()).readOnlyTransaction(any(TimestampBound.class)); + // Updating read-only staleness requires !isTransactionStarted(). + idleConn.setReadOnlyStaleness(TimestampBound.ofExactStaleness(5L, TimeUnit.SECONDS)); + } + + // 2. Active ReadOnlyTransaction: rejection must preserve the active read-only transaction + // for subsequent queries and commit(). + DatabaseClient activeDbClient = mock(DatabaseClient.class); + try (ConnectionImpl activeConn = + createTransactionalReadOnlyConnection( + activeDbClient, connectionReadOnly, /* autocommitExplicitBegin= */ false)) { + try (ResultSet firstSelect = activeConn.executeQuery(Statement.of(SELECT_SQL))) { + assertTrue(firstSelect.next()); + assertEquals(1L, firstSelect.getLong(0)); + } + assertTrue(activeConn.isTransactionStarted()); + Timestamp initialReadTs = activeConn.getReadTimestamp(); + activeConn.setStatementTag("active-tag"); + + assertAllQueryEntrypointsRejectWithFailedPrecondition( + activeConn, dmlReturning, expectedMessage); + + assertTrue(activeConn.isTransactionStarted()); + assertEquals("active-tag", activeConn.getStatementTag()); + assertEquals(initialReadTs, activeConn.getReadTimestamp()); + + try (ResultSet secondSelect = activeConn.executeQuery(Statement.of(SELECT_SQL))) { + assertTrue(secondSelect.next()); + assertEquals(1L, secondSelect.getLong(0)); + } + activeConn.commit(); + assertFalse(activeConn.isTransactionStarted()); + } + } + } + } } diff --git a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SingleUseTransactionTest.java b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SingleUseTransactionTest.java index cdbf13ea06ea..b8bb53d5744b 100644 --- a/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SingleUseTransactionTest.java +++ b/java-spanner/google-cloud-spanner/src/test/java/com/google/cloud/spanner/connection/SingleUseTransactionTest.java @@ -24,12 +24,14 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; import static org.junit.Assert.fail; import static org.mockito.Mockito.any; import static org.mockito.Mockito.anyList; import static org.mockito.Mockito.anyString; import static org.mockito.Mockito.doCallRealMethod; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; @@ -64,6 +66,7 @@ import com.google.cloud.spanner.connection.ConnectionProperty.Context; import com.google.cloud.spanner.connection.StatementExecutor.StatementTimeout; import com.google.cloud.spanner.connection.UnitOfWork.CallType; +import com.google.cloud.spanner.connection.UnitOfWork.UnitOfWorkState; import com.google.common.base.Preconditions; import com.google.common.io.ByteStreams; import com.google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata; @@ -894,4 +897,221 @@ public void testGetCommitResponseAfterDdl() { } assertNull(transaction.getCommitResponseOrNull()); } + + /** + * Creates a {@link SingleUseTransaction} backed by {@code dbClient} configured for {@code + * dialect} and {@code readOnly} mode so tests can verify write-transaction invocations and state + * transitions directly. + */ + private SingleUseTransaction createDmlReturningSubject( + DatabaseClient dbClient, Dialect dialect, boolean readOnly) { + when(dbClient.getDialect()).thenReturn(dialect); + when(dbClient.singleUseReadOnlyTransaction(TimestampBound.strong())) + .thenReturn(new SimpleReadOnlyTransaction(TimestampBound.strong())); + when(dbClient.readWriteTransaction()) + .thenAnswer( + invocation -> + new TransactionRunner() { + private CommitResponse commitResponse; + + @Override + public T run(TransactionCallable callable) { + TransactionContext txContext = mock(TransactionContext.class); + ResultSet returningRs = mock(ResultSet.class); + when(returningRs.next()).thenReturn(true, false); + when(returningRs.getLong(0)).thenReturn(1L); + when(txContext.executeQuery(any(Statement.class), any())) + .thenReturn(returningRs); + ResultSet analyzeRs = mock(ResultSet.class); + when(analyzeRs.next()).thenReturn(false); + when(analyzeRs.getStats()).thenReturn(ResultSetStats.getDefaultInstance()); + when(txContext.analyzeQuery(any(Statement.class), any())).thenReturn(analyzeRs); + try { + T result = callable.run(txContext); + commitResponse = new CommitResponse(Timestamp.ofTimeSecondsAndNanos(1, 1)); + return result; + } catch (Exception e) { + throw SpannerExceptionFactory.newSpannerException(e); + } + } + + @Override + public Timestamp getCommitTimestamp() { + return commitResponse.getCommitTimestamp(); + } + + @Override + public CommitResponse getCommitResponse() { + return commitResponse; + } + + @Override + public TransactionRunner allowNestedTransaction() { + return this; + } + }); + + ConnectionState connectionState = new ConnectionState(new HashMap<>()); + connectionState.setValue( + AUTOCOMMIT_DML_MODE, AutocommitDmlMode.TRANSACTIONAL, Context.STARTUP, false); + connectionState.setValue(READONLY, readOnly, Context.STARTUP, false); + connectionState.setValue(READ_ONLY_STALENESS, TimestampBound.strong(), Context.STARTUP, false); + + return SingleUseTransaction.newBuilder() + .setDatabaseClient(dbClient) + .setBatchClient(mock(BatchClient.class)) + .setDdlClient(createDefaultMockDdlClient()) + .setConnectionState(connectionState) + .setStatementTimeout(nullTimeout()) + .withStatementExecutor(executor) + .setSpan(Span.getInvalid()) + .build(); + } + + /** + * Verifies that a read-only {@link SingleUseTransaction} synchronously rejects GoogleSQL {@code + * THEN RETURN} and PostgreSQL {@code RETURNING} DML statements with {@link + * ErrorCode#FAILED_PRECONDITION} before marking the transaction used or opening a read-write + * transaction. + */ + @Test + public void testExecuteQueryAsyncDmlReturningReadOnly() { + for (Dialect dialect : Dialect.values()) { + List statements = + dialect == Dialect.POSTGRESQL + ? Arrays.asList( + "INSERT INTO foo (id, name) VALUES (1, 'bar') RETURNING id", + "UPDATE foo SET bar=1 WHERE id=1 RETURNING bar", + "DELETE FROM foo WHERE id=1 RETURNING id") + : Arrays.asList( + "INSERT INTO FOO (ID, NAME) VALUES (1, 'bar') THEN RETURN ID", + "UPDATE FOO SET BAR=1 WHERE ID=1 THEN RETURN BAR", + "DELETE FROM FOO WHERE ID=1 THEN RETURN ID"); + AbstractStatementParser parser = AbstractStatementParser.getInstance(dialect); + for (String sql : statements) { + ParsedStatement parsed = parser.parse(Statement.of(sql)); + assertThat(parsed.isUpdate()).isTrue(); + assertThat(parsed.hasReturningClause()).isTrue(); + for (CallType callType : CallType.values()) { + DatabaseClient dbClient = mock(DatabaseClient.class); + SingleUseTransaction subject = + createDmlReturningSubject(dbClient, dialect, /* readOnly= */ true); + + SpannerException ex = + assertThrows( + SpannerException.class, + () -> subject.executeQueryAsync(callType, parsed, AnalyzeMode.NONE)); + assertThat(ex.getErrorCode()).isEqualTo(ErrorCode.FAILED_PRECONDITION); + assertThat(ex.getMessage()) + .contains( + "DML statement with returning clause cannot be executed in read-only mode: " + + sql); + verify(dbClient, never()).readWriteTransaction(); + verify(dbClient, never()).readWriteTransaction(any()); + assertThat(subject.getState()).isEqualTo(UnitOfWorkState.STARTED); + + // Because the read-only guard precedes checkAndMarkUsed(), the single-use transaction + // remains unused and can still execute a valid read query. + assertThat( + get( + subject.executeQueryAsync( + CallType.SYNC, createParsedQuery(VALID_QUERY), AnalyzeMode.NONE))) + .isNotNull(); + assertThat(subject.getState()).isEqualTo(UnitOfWorkState.COMMITTED); + } + } + } + } + + /** + * Verifies that a read-only {@link SingleUseTransaction} synchronously rejects update statements + * under {@link AnalyzeMode#PLAN} and {@link AnalyzeMode#PROFILE} (both with and without returning + * clauses) with {@link ErrorCode#FAILED_PRECONDITION} before {@code checkAndMarkUsed()}. + */ + @Test + public void testExecuteQueryAsyncAnalyzeUpdateReadOnly() { + for (Dialect dialect : Dialect.values()) { + AbstractStatementParser parser = AbstractStatementParser.getInstance(dialect); + String plainDml = + dialect == Dialect.POSTGRESQL ? "UPDATE foo SET bar=1" : "UPDATE FOO SET BAR=1"; + String returningDml = + dialect == Dialect.POSTGRESQL + ? "UPDATE foo SET bar=1 RETURNING bar" + : "UPDATE FOO SET BAR=1 THEN RETURN BAR"; + ParsedStatement parsedPlain = parser.parse(Statement.of(plainDml)); + ParsedStatement parsedReturning = parser.parse(Statement.of(returningDml)); + + for (AnalyzeMode analyzeMode : new AnalyzeMode[] {AnalyzeMode.PLAN, AnalyzeMode.PROFILE}) { + for (CallType callType : CallType.values()) { + DatabaseClient plainDbClient = mock(DatabaseClient.class); + SingleUseTransaction plainSubject = + createDmlReturningSubject(plainDbClient, dialect, /* readOnly= */ true); + SpannerException plainEx = + assertThrows( + SpannerException.class, + () -> plainSubject.executeQueryAsync(callType, parsedPlain, analyzeMode)); + assertThat(plainEx.getErrorCode()).isEqualTo(ErrorCode.FAILED_PRECONDITION); + assertThat(plainEx.getMessage()) + .contains("Update statements are not allowed in read-only mode"); + verify(plainDbClient, never()).readWriteTransaction(); + assertThat(plainSubject.getState()).isEqualTo(UnitOfWorkState.STARTED); + assertThat( + get( + plainSubject.executeQueryAsync( + CallType.SYNC, createParsedQuery(VALID_QUERY), AnalyzeMode.NONE))) + .isNotNull(); + + DatabaseClient returningDbClient = mock(DatabaseClient.class); + SingleUseTransaction returningSubject = + createDmlReturningSubject(returningDbClient, dialect, /* readOnly= */ true); + SpannerException returningEx = + assertThrows( + SpannerException.class, + () -> returningSubject.executeQueryAsync(callType, parsedReturning, analyzeMode)); + assertThat(returningEx.getErrorCode()).isEqualTo(ErrorCode.FAILED_PRECONDITION); + assertThat(returningEx.getMessage()) + .contains( + "DML statement with returning clause cannot be executed in read-only mode: " + + returningDml); + verify(returningDbClient, never()).readWriteTransaction(); + assertThat(returningSubject.getState()).isEqualTo(UnitOfWorkState.STARTED); + assertThat( + get( + returningSubject.executeQueryAsync( + CallType.SYNC, createParsedQuery(VALID_QUERY), AnalyzeMode.NONE))) + .isNotNull(); + } + } + } + } + + /** + * Verifies that a writable {@link SingleUseTransaction} executes GoogleSQL {@code THEN RETURN} + * and PostgreSQL {@code RETURNING} DML statements via {@code readWriteTransaction()}, returns the + * resulting {@link ResultSet}, and transitions to {@link UnitOfWorkState#COMMITTED}. + */ + @Test + public void testExecuteQueryAsyncDmlReturningReadWrite() { + for (Dialect dialect : Dialect.values()) { + String sql = + dialect == Dialect.POSTGRESQL + ? "INSERT INTO foo (id, name) VALUES (1, 'bar') RETURNING id" + : "INSERT INTO FOO (ID, NAME) VALUES (1, 'bar') THEN RETURN ID"; + ParsedStatement parsed = + AbstractStatementParser.getInstance(dialect).parse(Statement.of(sql)); + for (CallType callType : CallType.values()) { + DatabaseClient dbClient = mock(DatabaseClient.class); + SingleUseTransaction subject = + createDmlReturningSubject(dbClient, dialect, /* readOnly= */ false); + + ResultSet rs = get(subject.executeQueryAsync(callType, parsed, AnalyzeMode.NONE)); + verify(dbClient).readWriteTransaction(); + assertThat(rs.next()).isTrue(); + assertThat(rs.getLong(0)).isEqualTo(1L); + assertThat(rs.next()).isFalse(); + assertThat(subject.getState()).isEqualTo(UnitOfWorkState.COMMITTED); + assertThat(subject.getCommitTimestamp()).isNotNull(); + } + } + } }