You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by zs...@apache.org on 2023/10/17 05:51:29 UTC

[ignite-3] branch main updated: IGNITE-20444 Sql. Add restrictions for execution tx related statements with single statement mode (#2683)

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

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


The following commit(s) were added to refs/heads/main by this push:
     new e443b6f862 IGNITE-20444 Sql. Add restrictions for execution tx related statements with single statement mode (#2683)
e443b6f862 is described below

commit e443b6f8627f3b17c8b20b3f4b42b96036a827be
Author: Max Zhuravkov <sh...@gmail.com>
AuthorDate: Tue Oct 17 08:51:23 2023 +0300

    IGNITE-20444 Sql. Add restrictions for execution tx related statements with single statement mode (#2683)
---
 .../client/handler/JdbcQueryEventHandlerImpl.java  |   2 +-
 .../benchmark/AbstractOneNodeBenchmark.java        |   2 +-
 .../internal/sql/engine/ItMultistatementTest.java  | 120 +++++++++++++++++++++
 .../ignite/internal/sql/api/SessionImpl.java       |   2 +-
 .../internal/sql/engine/SqlQueryProcessor.java     |   6 ++
 .../ignite/internal/sql/engine/SqlQueryType.java   |  11 +-
 .../ignite/internal/sql/engine/util/Commons.java   |   8 ++
 .../internal/sql/engine/util/QueryCheckerImpl.java |   2 +-
 8 files changed, 148 insertions(+), 5 deletions(-)

diff --git a/modules/client-handler/src/main/java/org/apache/ignite/client/handler/JdbcQueryEventHandlerImpl.java b/modules/client-handler/src/main/java/org/apache/ignite/client/handler/JdbcQueryEventHandlerImpl.java
index fabcb33355..24dbdd0e40 100644
--- a/modules/client-handler/src/main/java/org/apache/ignite/client/handler/JdbcQueryEventHandlerImpl.java
+++ b/modules/client-handler/src/main/java/org/apache/ignite/client/handler/JdbcQueryEventHandlerImpl.java
@@ -180,7 +180,7 @@ public class JdbcQueryEventHandlerImpl implements JdbcQueryEventHandler {
     private QueryContext createQueryContext(JdbcStatementType stmtType, @Nullable Transaction tx) {
         switch (stmtType) {
             case ANY_STATEMENT_TYPE:
-                return QueryContext.create(SqlQueryType.ALL, tx);
+                return QueryContext.create(SqlQueryType.SINGLE_STMT_TYPES, tx);
             case SELECT_STATEMENT_TYPE:
                 return QueryContext.create(SELECT_STATEMENT_QUERIES, tx);
             case UPDATE_STATEMENT_TYPE:
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/AbstractOneNodeBenchmark.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/AbstractOneNodeBenchmark.java
index 3de017059b..e2dbacc0aa 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/AbstractOneNodeBenchmark.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/benchmark/AbstractOneNodeBenchmark.java
@@ -111,7 +111,7 @@ public class AbstractOneNodeBenchmark {
                 + ");";
 
         try {
-            var context = QueryContext.create(SqlQueryType.ALL);
+            var context = QueryContext.create(SqlQueryType.SINGLE_STMT_TYPES);
 
             getAllFromCursor(
                     await(queryEngine.querySingleAsync(sessionId, context, clusterNode.transactions(), sql))
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItMultistatementTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItMultistatementTest.java
new file mode 100644
index 0000000000..fadefebd9e
--- /dev/null
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/sql/engine/ItMultistatementTest.java
@@ -0,0 +1,120 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.sql.engine;
+
+import static org.apache.ignite.lang.ErrorGroups.Sql.STMT_VALIDATION_ERR;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.Arrays;
+import java.util.concurrent.CompletionException;
+import java.util.stream.Stream;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.sql.IgniteSql;
+import org.apache.ignite.sql.Session;
+import org.apache.ignite.sql.SqlException;
+import org.apache.ignite.sql.Statement;
+import org.apache.ignite.tx.Transaction;
+import org.jetbrains.annotations.Nullable;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests for multi-statements.
+ */
+public class ItMultistatementTest extends ClusterPerClassIntegrationTest {
+
+    /**
+     * Transaction control statements can not be used in single statement methods.
+     */
+    @ParameterizedTest
+    @MethodSource("txControlCalls")
+    public void testTxControlStatementsAreNotAllowedWithSingleStatementMethods(String stmtSql, ExecMethod execMethod) {
+        Ignite ignite = CLUSTER_NODES.get(0);
+        IgniteSql igniteSql = ignite.sql();
+
+        try (Session session = igniteSql.createSession()) {
+            RuntimeException t = assertThrows(RuntimeException.class, () -> execMethod.execute(igniteSql, session, stmtSql, null));
+
+            String message = "Transaction control statement can not be executed as an independent statement";
+            checkError(message, t);
+        }
+    }
+
+    /** Sql session method to use. */
+    public enum ExecMethod {
+        ASYNC,
+        SYNC,
+
+        STMT_ASYNC,
+        STMT_SYNC,
+        ;
+
+        void execute(IgniteSql sql, Session session, String stmtSql, @Nullable Transaction tx) {
+            switch (this) {
+                case ASYNC:
+                    session.executeAsync(tx, stmtSql).join();
+                    break;
+                case SYNC:
+                    session.execute(tx, stmtSql).next();
+                    break;
+                case STMT_ASYNC: {
+                    Statement s = sql.createStatement(stmtSql);
+                    session.executeAsync(tx, s).join();
+                }
+                    break;
+                case STMT_SYNC: {
+                    Statement s = sql.createStatement(stmtSql);
+                    session.execute(tx, s).next();
+                }
+                    break;
+                default:
+                    throw new IllegalStateException("Unexpected value: " + this);
+            }
+        }
+    }
+
+    private static Stream<Arguments> txControlCalls() {
+        return txControlStatements().flatMap(s -> Arrays.stream(ExecMethod.values()).map(m -> Arguments.of(s, m)));
+    }
+
+    private static Stream<String> txControlStatements() {
+        return Stream.of(
+                "START TRANSACTION",
+                "START TRANSACTION READ WRITE",
+                "START TRANSACTION READ ONLY",
+                "COMMIT"
+        );
+    }
+
+    private static void checkError(String message, RuntimeException err) {
+        SqlException sqlException;
+        if (err instanceof CompletionException) {
+            sqlException = assertInstanceOf(SqlException.class, err.getCause());
+        } else {
+            sqlException = assertInstanceOf(SqlException.class, err);
+        }
+
+        assertEquals(STMT_VALIDATION_ERR, sqlException.code());
+        assertThat(sqlException.getMessage(), containsString(message));
+    }
+}
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/SessionImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/SessionImpl.java
index f947e6a7af..3c48b78900 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/SessionImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/SessionImpl.java
@@ -178,7 +178,7 @@ public class SessionImpl implements AbstractSession {
         CompletableFuture<AsyncResultSet<SqlRow>> result;
 
         try {
-            QueryContext ctx = QueryContext.create(SqlQueryType.ALL, transaction);
+            QueryContext ctx = QueryContext.create(SqlQueryType.SINGLE_STMT_TYPES, transaction);
 
             result = qryProc.querySingleAsync(sessionId, ctx, transactions, query, arguments)
                     .thenCompose(cur -> cur.requestNextAsync(pageSize)
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
index f37ca76be3..56bbc80d2b 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
@@ -571,6 +571,12 @@ public class SqlQueryProcessor implements QueryProcessor {
         Set<SqlQueryType> allowedTypes = context.allowedQueryTypes();
         SqlQueryType queryType = parsedResult.queryType();
 
+        if (parsedResult.queryType() == SqlQueryType.TX_CONTROL) {
+            String message = "Transaction control statement can not be executed as an independent statement";
+
+            throw new SqlException(STMT_VALIDATION_ERR, message);
+        }
+
         if (!allowedTypes.contains(queryType)) {
             String message = format("Invalid SQL statement type. Expected {} but got {}", allowedTypes, queryType);
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryType.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryType.java
index 92e718a7d0..be08e9dc97 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryType.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryType.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.sql.engine;
 
+import java.util.EnumSet;
 import java.util.Set;
 
 /**
@@ -33,7 +34,15 @@ public enum SqlQueryType {
     DDL,
 
     /** Explain. */
-    EXPLAIN;
+    EXPLAIN,
+
+    /** Transaction control statements such as {@code START TRANSACTION}, {@code COMMIT},  etc. */
+    TX_CONTROL,
+
+    ;
+
+    /** A set of statement types that can run only in single statement mode. **/
+    public static final Set<SqlQueryType> SINGLE_STMT_TYPES = EnumSet.complementOf(EnumSet.of(TX_CONTROL));
 
     /** A set of all query types. **/
     public static final Set<SqlQueryType> ALL = Set.of(values());
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/Commons.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/Commons.java
index 871707f6e3..3791bcb681 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/Commons.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/util/Commons.java
@@ -88,8 +88,10 @@ import org.apache.ignite.internal.sql.engine.metadata.cost.IgniteCostFactory;
 import org.apache.ignite.internal.sql.engine.prepare.IgniteConvertletTable;
 import org.apache.ignite.internal.sql.engine.prepare.IgniteTypeCoercion;
 import org.apache.ignite.internal.sql.engine.prepare.PlanningContext;
+import org.apache.ignite.internal.sql.engine.sql.IgniteSqlCommitTransaction;
 import org.apache.ignite.internal.sql.engine.sql.IgniteSqlConformance;
 import org.apache.ignite.internal.sql.engine.sql.IgniteSqlParser;
+import org.apache.ignite.internal.sql.engine.sql.IgniteSqlStartTransaction;
 import org.apache.ignite.internal.sql.engine.sql.fun.IgniteSqlOperatorTable;
 import org.apache.ignite.internal.sql.engine.trait.DistributionTraitDef;
 import org.apache.ignite.internal.sql.engine.type.IgniteTypeFactory;
@@ -794,6 +796,12 @@ public final class Commons {
     @Nullable
     public static SqlQueryType getQueryType(SqlNode sqlNode) {
         SqlKind sqlKind = sqlNode.getKind();
+
+        // Check for tx control types earlier, because COMMIT, ROLLBACK belongs to SqlKind.DDL
+        if (sqlNode instanceof IgniteSqlStartTransaction || sqlNode instanceof IgniteSqlCommitTransaction) {
+            return SqlQueryType.TX_CONTROL;
+        }
+
         if (SqlKind.DDL.contains(sqlKind)) {
             return SqlQueryType.DDL;
         }
diff --git a/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/QueryCheckerImpl.java b/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/QueryCheckerImpl.java
index eb11526fda..ea49ce9f1e 100644
--- a/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/QueryCheckerImpl.java
+++ b/modules/sql-engine/src/testFixtures/java/org/apache/ignite/internal/sql/engine/util/QueryCheckerImpl.java
@@ -248,7 +248,7 @@ abstract class QueryCheckerImpl implements QueryChecker {
 
         SessionId sessionId = qryProc.createSession(PropertiesHelper.emptyHolder());
 
-        QueryContext context = QueryContext.create(SqlQueryType.ALL, tx);
+        QueryContext context = QueryContext.create(SqlQueryType.SINGLE_STMT_TYPES, tx);
 
         String qry = queryTemplate.createQuery();