Add rules to avoid commit and rollback

esql-checks/src/main/java/com/exxeta/iss/sonar/esql/check/CheckList.java

@@ -53,6 +53,7 @@ public static List<Class<?>> getChecks() {
             CommentRegularExpressionCheck.class,
             CommentedCodeCheck.class,
             CommentsCheck.class,
+            CommitCheck.class,
             ConditionParenthesisCheck.class,
             CyclomaticComplexityCheck.class,
             DeclareCombineCheck.class,
@@ -91,6 +92,7 @@ public static List<Class<?>> getChecks() {
             PropagateConsistencyCheck.class,
             PropagateToLabelCheck.class,
             RecursionCheck.class,
+            RollbackCheck.class,
             RoutineCommentsCheck.class,
             RoutineWithExcessiveReturnsCheck.class,
             SelectAllCheck.class,

esql-checks/src/main/java/com/exxeta/iss/sonar/esql/check/CommitCheck.java

@@ -0,0 +1,33 @@
+/*
+ * Sonar ESQL Plugin
+ * Copyright (C) 2013-2023 Thomas Pohl and EXXETA AG
+ * http://www.exxeta.com
+ *
+ * Licensed 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 com.exxeta.iss.sonar.esql.check;
+
+import com.exxeta.iss.sonar.esql.api.visitors.DoubleDispatchVisitorCheck;
+import com.exxeta.iss.sonar.esql.tree.impl.statement.CommitStatementTreeImpl;
+import org.sonar.check.Rule;
+
+@Rule(key="Commit")
+public class CommitCheck extends DoubleDispatchVisitorCheck {
+
+	public static final String MESSAGE = "COMMIT should not be called explicitly. Otherwise the messageflow can't handle the transaction.";
+	@Override
+	public void visitCommitStatement(CommitStatementTreeImpl tree) {
+		addIssue(tree.commitKeyword(), MESSAGE);
+		super.visitCommitStatement(tree);
+	}
+}

esql-checks/src/main/java/com/exxeta/iss/sonar/esql/check/RollbackCheck.java

@@ -0,0 +1,33 @@
+/*
+ * Sonar ESQL Plugin
+ * Copyright (C) 2013-2023 Thomas Pohl and EXXETA AG
+ * http://www.exxeta.com
+ *
+ * Licensed 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 com.exxeta.iss.sonar.esql.check;
+
+import com.exxeta.iss.sonar.esql.api.visitors.DoubleDispatchVisitorCheck;
+import com.exxeta.iss.sonar.esql.tree.impl.statement.RollbackStatementTreeImpl;
+import org.sonar.check.Rule;
+
+@Rule(key="Rollback")
+public class RollbackCheck extends DoubleDispatchVisitorCheck {
+
+	public static final String MESSAGE = "ROLLBACK should not be called explicitly. Otherwise the messageflow can't handle the transaction.";
+	@Override
+	public void visitRollbackStatement(RollbackStatementTreeImpl tree) {
+		addIssue(tree.rollbackKeyword(), MESSAGE);
+		super.visitRollbackStatement(tree);
+	}
+}

esql-checks/src/main/resources/org/sonar/l10n/esql/rules/esql/Commit.html

@@ -0,0 +1,6 @@
+<p>Avoid using the COMMIT statement in ESQL code, as it can undermine the transaction
+    handling mechanism of the message flow.  Instead, consider restructuring the flow
+    to handle smaller transactions or committing all changes at once. This approach
+    helps ensure that the transaction handling mechanism operates correctly and reliably,
+    without risking unexpected behavior or data loss. By avoiding the use of COMMIT statements,
+    you can help maintain the integrity and consistency of the message flow's data.</p>

esql-checks/src/main/resources/org/sonar/l10n/esql/rules/esql/Commit.json

@@ -0,0 +1,13 @@
+{
+  "title": "COMMIT should not be used.",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "20min"
+  },
+  "tags": [
+    "bad-practice"
+  ],
+  "defaultSeverity": "Major"
+}

esql-checks/src/main/resources/org/sonar/l10n/esql/rules/esql/Rollback.html

@@ -0,0 +1,5 @@
+<p>Avoid using the ROLLBACK statement in ESQL code, as it can undermine the transaction
+    handling mechanism of the message flow. Instead, consider using the THROW statement to
+    raise an exception and trigger a rollback of the entire message flow. This approach helps
+    ensure that the transaction handling mechanism operates correctly and reliably, without
+    risking unexpected behavior or data loss.</p>

esql-checks/src/main/resources/org/sonar/l10n/esql/rules/esql/Rollback.json

@@ -0,0 +1,13 @@
+{
+  "title": "ROLLBACK should not be used.",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "20min"
+  },
+  "tags": [
+    "bad-practice"
+  ],
+  "defaultSeverity": "Major"
+}

esql-checks/src/main/resources/org/sonar/l10n/esql/rules/esql/Sonar_way_profile.json

@@ -10,6 +10,7 @@
     "CaseWithoutElse",
     "CommentedCode",
     "Comments",
+    "Commit",
     "CyclomaticComplexity",
     "DeleteFromWithoutWhere",
     "DeprecatedMethod",
@@ -40,6 +41,7 @@
     "OneStatementPerLine",
     "ParameterWithDirection",
     "PassThruStatement",
+    "Rollback",
     "PropagateConsistency",
     "PropagateToLabel",
     "RoutineWithExcessiveReturns",

esql-checks/src/test/java/com/exxeta/iss/sonar/esql/check/CommitCheckTest.java

@@ -0,0 +1,16 @@
+package com.exxeta.iss.sonar.esql.check;
+
+import com.exxeta.iss.sonar.esql.checks.verifier.EsqlCheckVerifier;
+import java.io.File;
+import org.junit.jupiter.api.Test;
+
+class CommitCheckTest {
+
+    @Test
+    void test() {
+
+        EsqlCheckVerifier.issues(new RollbackCheck(), new File("src/test/resources/commitRollback.esql"))
+            .next().atLine(5).withMessage("ROLLBACK should not be called explicitly. Otherwise the messageflow can't handle the transaction.")
+            .noMore();
+    }
+}

esql-checks/src/test/java/com/exxeta/iss/sonar/esql/check/RollbackCheckTest.java

@@ -0,0 +1,16 @@
+package com.exxeta.iss.sonar.esql.check;
+
+import com.exxeta.iss.sonar.esql.checks.verifier.EsqlCheckVerifier;
+import java.io.File;
+import org.junit.jupiter.api.Test;
+
+class RollbackCheckTest {
+
+    @Test
+    void test() {
+
+        EsqlCheckVerifier.issues(new CommitCheck(), new File("src/test/resources/commitRollback.esql"))
+            .next().atLine(6).withMessage("COMMIT should not be called explicitly. Otherwise the messageflow can't handle the transaction.")
+            .noMore();
+    }
+}

esql-checks/src/test/resources/commitRollback.esql

@@ -0,0 +1,9 @@
+CREATE COMPUTE MODULE CommitRollback
+
+	CREATE FUNCTION Main() RETURNS BOOLEAN
+	BEGIN
+		ROLLBACK;
+		COMMIT;
+	END;
+
+END MODULE;

esql-frontend/src/test/java/com/exxeta/iss/sonar/esql/lexer/EsqlKeywordTest.java

@@ -36,7 +36,7 @@ void esqlReservedKeyword() {
 
 	  @Test
 	  void esqlNonReservedKeyword() {
-	    assertThat(EsqlNonReservedKeyword.values().length).isEqualTo(214);
+	    assertThat(EsqlNonReservedKeyword.values().length).isEqualTo(216);
 	    assertThat(EsqlNonReservedKeyword.keywordValues().length).isEqualTo(EsqlNonReservedKeyword.values().length);
 
 	    for (EsqlNonReservedKeyword keyword : EsqlNonReservedKeyword.values()) {