feat: parse SET TRANSACTION, SET CONSTRAINTS, COMMIT RELEASE and PostgreSQL END and ABORT

MySQL SET [scope] TRANSACTION, PostgreSQL SET [scope] TRANSACTION,
SET TRANSACTION SNAPSHOT, SET SESSION CHARACTERISTICS AS TRANSACTION,
SET CONSTRAINTS, MySQL COMMIT/ROLLBACK ... [NO] RELEASE and PostgreSQL
END and ABORT failed to parse; SET CONSTRAINTS c1, c2 IMMEDIATE was
read as two variable assignments.

Move the transaction characteristics to a top-level TransactionMode
enum, parsed by one TransactionModeList production whose context
(BEGIN, START TRANSACTION, SET TRANSACTION) selects the dialect rules.
Add SetTransactionStatement and SetConstraintsStatement, dispatched
before the generic SET, which keeps variable assignments. They reuse
TransactionMode, a new SetScope enum that also types the scope of
SetStatement, and ConstraintAttributes.Initially. SET TRANSACTION takes
the scopes of each server's grammar: GLOBAL, SESSION, LOCAL, PERSIST
and PERSIST_ONLY in MySQL, the first three in MariaDB, and SESSION and
LOCAL in PostgreSQL, where they also precede SNAPSHOT and SESSION
CHARACTERISTICS.

Commit and RollbackStatement share TransactionCompletionStatement for
the keyword, chain and the new TransactionRelease, and record the END
and ABORT spellings in Command enums. END is a statement only with
the PostgreSQL dialect and outside BEGIN ... END blocks.

The new statements and TransactionCompletionStatement extend
ASTNodeAccessImpl, so each parsed statement keeps the node spanning
its source.

Wire the statements into the deparser, visitors, table finder,
feature analysis and validation, with new features in the MySQL and
PostgreSQL capabilities.

Signed-off-by: minleejae <mmj9808@gmail.com>

Author: minleejae

src/main/java/net/sf/jsqlparser/parser/feature/Feature.java

@@ -23,7 +23,9 @@
 import net.sf.jsqlparser.statement.DescribeStatement;
 import net.sf.jsqlparser.statement.ExplainStatement;
 import net.sf.jsqlparser.statement.ResetStatement;
+import net.sf.jsqlparser.statement.SetConstraintsStatement;
 import net.sf.jsqlparser.statement.SetStatement;
+import net.sf.jsqlparser.statement.SetTransactionStatement;
 import net.sf.jsqlparser.statement.ShowColumnsStatement;
 import net.sf.jsqlparser.statement.ShowStatement;
 import net.sf.jsqlparser.statement.TableMaintenanceStatement;
@@ -738,6 +740,30 @@ public enum Feature {
     transactionDeferrable,
     /** MySQL WITH CONSISTENT SNAPSHOT transaction characteristic. */
     transactionConsistentSnapshot,
+    /** MySQL [NO] RELEASE after COMMIT or ROLLBACK. */
+    transactionRelease,
+    /** PostgreSQL END and ABORT, the alternative spellings of COMMIT and ROLLBACK. */
+    transactionEndAbort,
+    /**
+     * SET TRANSACTION characteristics
+     *
+     * @see SetTransactionStatement
+     */
+    setTransaction,
+    /** MySQL SET GLOBAL TRANSACTION. */
+    setTransactionGlobal,
+    /** MySQL SET PERSIST TRANSACTION and SET PERSIST_ONLY TRANSACTION. */
+    setTransactionPersist,
+    /** PostgreSQL SET SESSION CHARACTERISTICS AS TRANSACTION. */
+    setTransactionSessionCharacteristics,
+    /** PostgreSQL SET TRANSACTION SNAPSHOT. */
+    setTransactionSnapshot,
+    /**
+     * SET CONSTRAINTS {ALL | names} {DEFERRED | IMMEDIATE}
+     *
+     * @see SetConstraintsStatement
+     */
+    setConstraints,
     /**
      * SQL "LOCK TABLE" statement is allowed
      *

src/main/java/net/sf/jsqlparser/statement/Commit.java

@@ -9,57 +9,59 @@
  */
 package net.sf.jsqlparser.statement;
 
-import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import java.util.Objects;
 
-public class Commit extends ASTNodeAccessImpl implements Statement {
-    private TransactionKeyword keyword;
-    private TransactionChain chain;
-
-    public TransactionKeyword getKeyword() {
-        return keyword;
+/** COMMIT, or its PostgreSQL spelling END. */
+public class Commit extends TransactionCompletionStatement {
+    /** The keyword that starts the statement; both commit the current transaction. */
+    public enum Command {
+        COMMIT, END
     }
 
-    public void setKeyword(TransactionKeyword keyword) {
-        this.keyword = keyword;
+    private Command command = Command.COMMIT;
+
+    public Command getCommand() {
+        return command;
     }
 
-    public Commit withKeyword(TransactionKeyword keyword) {
-        setKeyword(keyword);
-        return this;
+    public void setCommand(Command command) {
+        this.command = Objects.requireNonNull(command, "command");
     }
 
-    public TransactionChain getChain() {
-        return chain;
+    public Commit withCommand(Command command) {
+        setCommand(command);
+        return this;
     }
 
-    public void setChain(TransactionChain chain) {
-        this.chain = chain;
+    public Commit withKeyword(TransactionKeyword keyword) {
+        setKeyword(keyword);
+        return this;
     }
 
     public Commit withChain(TransactionChain chain) {
         setChain(chain);
         return this;
     }
 
+    public Commit withRelease(TransactionRelease release) {
+        setRelease(release);
+        return this;
+    }
 
     @Override
-    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
-        return statementVisitor.visit(this, context);
+    public boolean isPostgresSpelling() {
+        return command == Command.END;
     }
 
-    public StringBuilder appendTo(StringBuilder builder) {
-        builder.append("COMMIT");
-        if (keyword != null) {
-            builder.append(' ').append(keyword);
-        }
-        if (chain != null) {
-            builder.append(' ').append(chain);
-        }
-        return builder;
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
     }
 
     @Override
-    public String toString() {
-        return appendTo(new StringBuilder()).toString();
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append(command);
+        appendKeyword(builder);
+        return appendCompletion(builder);
     }
 }

src/main/java/net/sf/jsqlparser/statement/RollbackStatement.java

@@ -25,53 +25,61 @@
 
 package net.sf.jsqlparser.statement;
 
-import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import java.util.Objects;
 
 /**
+ * ROLLBACK, or its PostgreSQL spelling ABORT.
+ *
  * @author are
  */
-public class RollbackStatement extends ASTNodeAccessImpl implements Statement {
-    private TransactionKeyword keyword;
-    private TransactionChain chain;
+public class RollbackStatement extends TransactionCompletionStatement {
+    /** The keyword that starts the statement; ABORT has no savepoint or FORCE form. */
+    public enum Command {
+        ROLLBACK, ABORT
+    }
+
+    private Command command = Command.ROLLBACK;
     private boolean usingSavepointKeyword = false;
     private String savepointName = null;
     private String forceDistributedTransactionIdentifier = null;
 
-    public TransactionKeyword getKeyword() {
-        return keyword;
+    public Command getCommand() {
+        return command;
     }
 
-    public void setKeyword(TransactionKeyword keyword) {
-        this.keyword = keyword;
+    public void setCommand(Command command) {
+        this.command = Objects.requireNonNull(command, "command");
     }
 
-    public RollbackStatement withKeyword(TransactionKeyword keyword) {
-        setKeyword(keyword);
+    public RollbackStatement withCommand(Command command) {
+        setCommand(command);
         return this;
     }
 
-    public TransactionChain getChain() {
-        return chain;
-    }
-
-    public void setChain(TransactionChain chain) {
-        this.chain = chain;
+    public RollbackStatement withKeyword(TransactionKeyword keyword) {
+        setKeyword(keyword);
+        return this;
     }
 
     public RollbackStatement withChain(TransactionChain chain) {
         setChain(chain);
         return this;
     }
 
+    public RollbackStatement withRelease(TransactionRelease release) {
+        setRelease(release);
+        return this;
+    }
+
     public boolean isUsingWorkKeyword() {
-        return keyword == TransactionKeyword.WORK;
+        return getKeyword() == TransactionKeyword.WORK;
     }
 
     public void setUsingWorkKeyword(boolean usingWorkKeyword) {
         if (usingWorkKeyword) {
-            keyword = TransactionKeyword.WORK;
-        } else if (keyword == TransactionKeyword.WORK) {
-            keyword = null;
+            setKeyword(TransactionKeyword.WORK);
+        } else if (getKeyword() == TransactionKeyword.WORK) {
+            setKeyword(null);
         }
     }
 
@@ -121,27 +129,23 @@ public RollbackStatement withForceDistributedTransactionIdentifier(
         return this;
     }
 
+    @Override
+    public boolean isPostgresSpelling() {
+        return command == Command.ABORT;
+    }
+
+    @Override
     public StringBuilder appendTo(StringBuilder builder) {
-        builder.append("ROLLBACK");
-        if (keyword != null) {
-            builder.append(' ').append(keyword);
-        }
+        builder.append(command);
+        appendKeyword(builder);
         if (savepointName != null && !savepointName.trim().isEmpty()) {
             builder.append(" TO ").append(usingSavepointKeyword ? "SAVEPOINT " : "")
                     .append(savepointName);
         } else if (forceDistributedTransactionIdentifier != null
                 && !forceDistributedTransactionIdentifier.trim().isEmpty()) {
             builder.append(" FORCE ").append(forceDistributedTransactionIdentifier);
         }
-        if (chain != null) {
-            builder.append(' ').append(chain);
-        }
-        return builder;
-    }
-
-    @Override
-    public String toString() {
-        return appendTo(new StringBuilder()).toString();
+        return appendCompletion(builder);
     }
 
     @Override

src/main/java/net/sf/jsqlparser/statement/SetConstraintsStatement.java

@@ -0,0 +1,85 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import net.sf.jsqlparser.statement.create.table.ConstraintAttributes;
+
+/**
+ * {@code SET CONSTRAINTS {ALL | name [, ...]} {DEFERRED | IMMEDIATE}}, which changes when the
+ * deferrable constraints of the current transaction are checked.
+ */
+public class SetConstraintsStatement extends ASTNodeAccessImpl implements Statement {
+    private final List<String> constraintNames = new ArrayList<>();
+    private ConstraintAttributes.Initially timing;
+
+    public SetConstraintsStatement() {
+        this(ConstraintAttributes.Initially.IMMEDIATE);
+    }
+
+    public SetConstraintsStatement(ConstraintAttributes.Initially timing) {
+        setTiming(timing);
+    }
+
+    /**
+     * Mutable list of the named constraints, each possibly schema-qualified and kept as written. An
+     * empty list means ALL.
+     */
+    public List<String> getConstraintNames() {
+        return constraintNames;
+    }
+
+    public SetConstraintsStatement addConstraintName(String name) {
+        constraintNames.add(Objects.requireNonNull(name, "name"));
+        return this;
+    }
+
+    /** Whether the statement applies to all deferrable constraints. */
+    public boolean isAll() {
+        return constraintNames.isEmpty();
+    }
+
+    /** The check timing, shared with the INITIALLY clause of constraint definitions. */
+    public ConstraintAttributes.Initially getTiming() {
+        return timing;
+    }
+
+    public void setTiming(ConstraintAttributes.Initially timing) {
+        this.timing = Objects.requireNonNull(timing, "timing");
+    }
+
+    public SetConstraintsStatement withTiming(ConstraintAttributes.Initially timing) {
+        setTiming(timing);
+        return this;
+    }
+
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append("SET CONSTRAINTS ");
+        if (isAll()) {
+            builder.append("ALL");
+        } else {
+            builder.append(String.join(", ", constraintNames));
+        }
+        return builder.append(' ').append(timing);
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> visitor, S context) {
+        return visitor.visit(this, context);
+    }
+}

src/main/java/net/sf/jsqlparser/statement/SetScope.java

@@ -0,0 +1,50 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import java.util.Locale;
+
+/**
+ * The scope keyword after SET, shared by {@link SetStatement} assignments and
+ * {@link SetTransactionStatement}.
+ */
+public enum SetScope {
+    /** No scope keyword. */
+    NONE,
+    /** MySQL: the server-wide default. */
+    GLOBAL,
+    /** The current session. */
+    SESSION,
+    /** PostgreSQL: the current transaction; MySQL: a synonym of SESSION. */
+    LOCAL,
+    /** MySQL: GLOBAL, also written to the persisted configuration. */
+    PERSIST,
+    /** MySQL: only the persisted configuration. */
+    PERSIST_ONLY;
+
+    /**
+     * Resolves a scope keyword, ignoring case.
+     *
+     * @param keyword the keyword, or null or empty for {@link #NONE}
+     * @return the scope
+     * @throws IllegalArgumentException if the keyword names no scope
+     */
+    public static SetScope fromKeyword(String keyword) {
+        if (keyword == null || keyword.isEmpty()) {
+            return NONE;
+        }
+        return valueOf(keyword.toUpperCase(Locale.ROOT));
+    }
+
+    /** The keyword as written after SET, or null for {@link #NONE}. */
+    public String getKeyword() {
+        return this == NONE ? null : name();
+    }
+}