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();