You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by pp...@apache.org on 2025/06/06 13:59:07 UTC

(ignite-3) 03/03: IGNITE-25297 Throw exception on start transaction.

This is an automated email from the ASF dual-hosted git repository.

ppa pushed a commit to branch ignite-25297
in repository https://gitbox.apache.org/repos/asf/ignite-3.git

commit 84dabbd661a8edff3654cb53dbd76e2054f24933
Author: Pavel Pereslegin <xx...@gmail.com>
AuthorDate: Fri Jun 6 16:49:45 2025 +0300

    IGNITE-25297 Throw exception on start transaction.
---
 .../sql/engine/ItSqlMultiStatementTxTest.java      | 32 +++++++-------
 .../sql/engine/exec/fsm/MultiStatementHandler.java | 51 +++++++++++++---------
 .../internal/sql/engine/sql/ParserServiceImpl.java |  2 +-
 .../sql/engine/tx/ScriptTransactionContext.java    |  7 ---
 .../engine/tx/ScriptTransactionWrapperImpl.java    | 23 ++--------
 5 files changed, 50 insertions(+), 65 deletions(-)

diff --git a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItSqlMultiStatementTxTest.java b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItSqlMultiStatementTxTest.java
index c3974fc6e9c..4290d7c0c1a 100644
--- a/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItSqlMultiStatementTxTest.java
+++ b/modules/sql-engine/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItSqlMultiStatementTxTest.java
@@ -157,33 +157,34 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
 
     @ParameterizedTest
     @ValueSource(strings = {"READ ONLY", "READ WRITE"})
-    void openedScriptTransactionRollsBackImplicitly(String txOptions) {
+    void startTransactionWithoutCommitThrowsException(String txOptions) {
         String expectedError = "Transaction managed by the script was not completed by the script.";
         String startTxStatement = format("START TRANSACTION {};", txOptions);
 
         {
             assertThrowsSqlException(RUNTIME_ERR, expectedError, () -> runScript(startTxStatement));
 
-            verifyFinishedTxCount(1);
+            verifyFinishedTxCount(0);
         }
 
         {
             assertThrowsSqlException(
                     RUNTIME_ERR,
                     expectedError,
-                    () -> fetchAllCursors(
-                            runScript(startTxStatement
-                                    + "SELECT * FROM TEST;"
-                                    + "SELECT * FROM TEST;"
-                            ))
+                    () -> runScript(startTxStatement
+                            + "SELECT * FROM TEST;"
+                            + "SELECT * FROM TEST;")
             );
 
-            verifyFinishedTxCount(2);
+            verifyFinishedTxCount(0);
         }
     }
 
+    /**
+     * The test verifies that changes made inside a transaction block without committing are not applied.
+     */
     @Test
-    void dmlScriptRollsBackImplicitly() throws InterruptedException {
+    void dmlInsideUnfinishedTransactionBlockAreNotApplied() throws InterruptedException {
         AsyncSqlCursor<InternalSqlRow> cur = runScript("START TRANSACTION READ WRITE;"
                 + "INSERT INTO test VALUES(0);"
                 + "INSERT INTO test VALUES(1);"
@@ -215,11 +216,10 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
         assertThrowsSqlException(
                 RUNTIME_ERR,
                 "Transaction managed by the script was not completed by the script",
-                () -> fetchAllCursors(cur0)
+                () -> await(cur0.nextResult())
         );
 
-        // 1 COMMIT + 1 ROLLBACK.
-        verifyFinishedTxCount(2);
+        verifyFinishedTxCount(1);
 
         assertTrue(waitForCondition(() -> txManager().lockManager().isEmpty(), 2_000));
 
@@ -256,7 +256,7 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
 
     @Test
     void ddlInsideExplicitTransactionFails() {
-        String ddlStatement = "CREATE TABLE foo (id INT PRIMARY KEY)";
+        String ddlStatement = "CREATE TABLE foo (id INT PRIMARY KEY);";
 
         {
             InternalTransaction tx = (InternalTransaction) igniteTx().begin();
@@ -272,7 +272,7 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
 
         {
             assertThrowsSqlException(RUNTIME_ERR, "DDL doesn't support transactions.",
-                    () -> fetchAllCursors(runScript("START TRANSACTION;" + ddlStatement)));
+                    () -> fetchAllCursors(runScript("START TRANSACTION;" + ddlStatement + "COMMIT;")));
 
             verifyFinishedTxCount(2);
         }
@@ -280,7 +280,7 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
 
     @Test
     void nestedTransactionStartFails() {
-        AsyncSqlCursor<InternalSqlRow> cursor = runScript("START TRANSACTION; SELECT 1; START TRANSACTION;");
+        AsyncSqlCursor<InternalSqlRow> cursor = runScript("START TRANSACTION; SELECT 1; START TRANSACTION; COMMIT;");
 
         AsyncSqlCursor<InternalSqlRow> startTxCur = await(cursor.nextResult());
         assertNotNull(startTxCur);
@@ -356,7 +356,7 @@ public class ItSqlMultiStatementTxTest extends BaseSqlMultiStatementTest {
         assertEquals(TxState.ABORTED, tx1.state());
 
         InternalTransaction tx2 = (InternalTransaction) igniteTx().begin();
-        assertThrowsExactly(TxControlInsideExternalTxNotSupportedException.class, () -> runScript(tx2, null, "START TRANSACTION"));
+        assertThrowsExactly(TxControlInsideExternalTxNotSupportedException.class, () -> runScript(tx2, null, "START TRANSACTION; COMMIT;"));
         assertEquals(0, txManager().pending());
         assertEquals(TxState.ABORTED, tx2.state());
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/fsm/MultiStatementHandler.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/fsm/MultiStatementHandler.java
index c616b457761..9d47e1d09e6 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/fsm/MultiStatementHandler.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/fsm/MultiStatementHandler.java
@@ -38,6 +38,7 @@ import org.apache.ignite.internal.sql.engine.SqlQueryType;
 import org.apache.ignite.internal.sql.engine.TxControlInsideExternalTxNotSupportedException;
 import org.apache.ignite.internal.sql.engine.exec.TransactionalOperationTracker;
 import org.apache.ignite.internal.sql.engine.exec.fsm.QueryExecutor.ParsedResultWithNextCursorFuture;
+import org.apache.ignite.internal.sql.engine.sql.IgniteSqlStartTransaction;
 import org.apache.ignite.internal.sql.engine.sql.ParsedResult;
 import org.apache.ignite.internal.sql.engine.tx.QueryTransactionContext;
 import org.apache.ignite.internal.sql.engine.tx.ScriptTransactionContext;
@@ -90,6 +91,8 @@ class MultiStatementHandler {
 
         ScriptStatement[] results = new ScriptStatement[parsedResults.size()];
 
+        boolean txControlStatementFound = false;
+
         // We fill parameters in reverse order, because each script statement
         // requires a reference to the future of the next statement.
         CompletableFuture<AsyncSqlCursor<InternalSqlRow>> prevCursorFuture = null;
@@ -99,7 +102,16 @@ class MultiStatementHandler {
             Object[] params0 = Arrays.copyOfRange(params, paramsCount - result.dynamicParamsCount(), paramsCount);
             paramsCount -= result.dynamicParamsCount();
 
-            results[i] = new ScriptStatement(i, result, params0, prevCursorFuture);
+            // Marks the beginning of a transaction block that does not end with a COMMIT.
+            boolean unfinishedTxBlock = false;
+
+            if (!txControlStatementFound && result.queryType() == SqlQueryType.TX_CONTROL) {
+                unfinishedTxBlock = result.parsedTree() instanceof IgniteSqlStartTransaction;
+
+                txControlStatementFound = true;
+            }
+
+            results[i] = new ScriptStatement(i, result, params0, unfinishedTxBlock, prevCursorFuture);
             prevCursorFuture = results[i].cursorFuture;
         }
 
@@ -137,14 +149,20 @@ class MultiStatementHandler {
                     inFlightSelects.clear();
                 }
 
-                // Return an empty cursor.
-                fut = scriptTxContext.handleControlStatement(parsedResult.parsedTree())
-                        .thenApply(ignored -> new AsyncSqlCursorImpl<>(
-                                parsedResult.queryType(),
-                                EMPTY_RESULT_SET_METADATA,
-                                new IteratorToDataCursorAdapter<>(Collections.emptyIterator()),
-                                nextCurFut
-                        ));
+                if (scriptStatement.unfinishedTxBlock) {
+                    // Stop script execution because the transaction block is not complete.
+                    fut = CompletableFuture.failedFuture(new SqlException(RUNTIME_ERR,
+                            "Transaction managed by the script was not completed by the script."));
+                } else {
+                    // Return an empty cursor.
+                    fut = scriptTxContext.handleControlStatement(parsedResult.parsedTree())
+                            .thenApply(ignored -> new AsyncSqlCursorImpl<>(
+                                    parsedResult.queryType(),
+                                    EMPTY_RESULT_SET_METADATA,
+                                    new IteratorToDataCursorAdapter<>(Collections.emptyIterator()),
+                                    nextCurFut
+                            ));
+                }
             } else if (parsedResult.queryType() == SqlQueryType.DDL) {
                 List<ParsedResultWithNextCursorFuture> ddlBatch = new ArrayList<>();
 
@@ -181,18 +199,6 @@ class MultiStatementHandler {
                     return;
                 }
 
-                // Check if the script does not have a commit of the active transaction at the end of the script.
-                if (lastStatement && scriptTxContext.rollbackActiveTx()) {
-                    SqlException ex0 = new SqlException(RUNTIME_ERR,
-                            "Transaction managed by the script was not completed by the script.");
-
-                    cursorFuture.completeExceptionally(ex0);
-
-                    cancelAll(ex0);
-
-                    return;
-                }
-
                 cursorFuture.complete(cursor);
 
                 if (!cursor.onClose().isDone()) {
@@ -296,17 +302,20 @@ class MultiStatementHandler {
         private final ParsedResult parsedResult;
         private final Object[] dynamicParams;
         private final int idx;
+        private final boolean unfinishedTxBlock;
 
         private ScriptStatement(
                 int idx,
                 ParsedResult parsedResult,
                 Object[] dynamicParams,
+                boolean unfinishedTxBlock,
                 @Nullable CompletableFuture<AsyncSqlCursor<InternalSqlRow>> nextStatementFuture
         ) {
             this.idx = idx;
             this.parsedResult = parsedResult;
             this.dynamicParams = dynamicParams;
             this.nextStatementFuture = nextStatementFuture;
+            this.unfinishedTxBlock = unfinishedTxBlock;
         }
 
         boolean isLastStatement() {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/ParserServiceImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/ParserServiceImpl.java
index be2750e9a36..94b808ac8b1 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/ParserServiceImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/sql/ParserServiceImpl.java
@@ -86,7 +86,7 @@ public class ParserServiceImpl implements ParserService {
                     normalizedQuery,
                     result.dynamicParamsCount(),
                     () -> {
-                        if (!used.compareAndSet(false, true)) {
+                        if (queryType != SqlQueryType.TX_CONTROL && !used.compareAndSet(false, true)) {
                             throw new IllegalStateException("Parsed result of script is not reusable.");
                         }
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionContext.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionContext.java
index 6179d4b1bb0..32f0e2c1ec9 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionContext.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionContext.java
@@ -137,13 +137,6 @@ public class ScriptTransactionContext implements QueryTransactionContext {
         }
     }
 
-    /** Returns {@code True} if the script transaction exists and its rollback has been initiated by this call. */
-    public boolean rollbackActiveTx() {
-        ScriptTransactionWrapperImpl txWrapper = wrapper;
-
-        return txWrapper != null && txWrapper.rollback();
-    }
-
     /** Rolls back the script-driven transaction. */
     public void onError(Throwable t) {
         assert t != null;
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionWrapperImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionWrapperImpl.java
index 0967b8bd46e..d14fe70b486 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionWrapperImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/tx/ScriptTransactionWrapperImpl.java
@@ -129,21 +129,6 @@ class ScriptTransactionWrapperImpl implements QueryTransactionWrapper {
         });
     }
 
-    /**
-     * Rolls back the transaction.
-     *
-     * @return {@code True} if the rollback was initiated by this call, {@code False} if the transaction completion was already initiated.
-     */
-    boolean rollback() {
-        if (changeState(State.ROLLBACK)) {
-            completeTx();
-
-            return true;
-        }
-
-        return false;
-    }
-
     /** Registers a new cursor associated with the current transaction. */
     void registerCursorFuture(CompletableFuture<AsyncSqlCursor<InternalSqlRow>> cursorFut) {
         UUID cursorId = UUID.randomUUID();
@@ -176,22 +161,20 @@ class ScriptTransactionWrapperImpl implements QueryTransactionWrapper {
         });
     }
 
-    private boolean changeState(State newState) {
+    private void changeState(State newState) {
         synchronized (mux) {
             if (txState != null) {
-                return false;
+                return;
             }
 
             txState = newState;
 
             if (!openedCursors.isEmpty()) {
-                return true;
+                return;
             }
         }
 
         completeTx();
-
-        return true;
     }
 
     private void completeTx() {