Reject contradictory MySQL transaction access modes

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

Author: minleejae

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -19052,6 +19052,10 @@ StartTransaction StartTransaction():
     {
         requireDdlSyntax(!isMySqlDialect() || statement.getCommand() != StartTransaction.Command.BEGIN
                 || statement.getModes().isEmpty(), "MySQL BEGIN does not accept transaction characteristics");
+        requireDdlSyntax(!Dialect.MYSQL.name().equals(getAsString(Feature.dialect))
+                || !statement.getModes().contains(StartTransaction.Mode.READ_ONLY)
+                || !statement.getModes().contains(StartTransaction.Mode.READ_WRITE),
+                "MySQL transactions cannot specify both READ ONLY and READ WRITE");
         return statement;
     }
 }

src/site/sphinx/usage.rst

@@ -1426,6 +1426,8 @@ Transaction statements
 transaction modes. PostgreSQL isolation levels, ``READ ONLY`` / ``READ WRITE``, and
 ``[NOT] DEFERRABLE`` are supported, as is MySQL ``WITH CONSISTENT SNAPSHOT``.
 PostgreSQL accepts mode lists with or without commas; output uses commas.
+The explicit MySQL dialect rejects a transaction containing both ``READ ONLY`` and
+``READ WRITE``, while retaining repeated occurrences of the same mode.
 
 Choose the dialect explicitly to parse ``BEGIN`` as a transaction command:
 

src/test/java/net/sf/jsqlparser/statement/TransactionStatementTest.java

@@ -79,6 +79,42 @@ void mysqlStartsAreStructured(String sql) throws Exception {
         assertInstanceOf(StartTransaction.class, roundTrip(sql, Dialect.MYSQL));
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {"START TRANSACTION READ ONLY, READ WRITE",
+            "START TRANSACTION READ WRITE, READ ONLY"})
+    void contradictoryAccessModesAreRejectedOnlyForMysql(String sql) throws Exception {
+        JSQLParserException error = assertThrows(JSQLParserException.class,
+                () -> parse(sql, Dialect.MYSQL));
+        assertTrue(error.getCause().getMessage()
+                .contains("cannot specify both READ ONLY and READ WRITE"));
+        assertThrows(JSQLParserException.class,
+                () -> parse(sql.replace(", ", ", WITH CONSISTENT SNAPSHOT, "), Dialect.MYSQL));
+        StartTransaction postgres = assertInstanceOf(StartTransaction.class,
+                roundTrip(sql, Dialect.POSTGRESQL));
+        List<StartTransaction.Mode> expected = sql.endsWith("READ WRITE")
+                ? List.of(StartTransaction.Mode.READ_ONLY, StartTransaction.Mode.READ_WRITE)
+                : List.of(StartTransaction.Mode.READ_WRITE, StartTransaction.Mode.READ_ONLY);
+        assertEquals(expected, postgres.getModes());
+        assertEquals(sql, postgres.toString());
+        StartTransaction permissive = assertInstanceOf(StartTransaction.class,
+                CCJSqlParserUtil.parse(sql));
+        assertEquals(expected, permissive.getModes());
+        assertEquals(sql, permissive.toString());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"START TRANSACTION READ ONLY, READ ONLY",
+            "START TRANSACTION READ WRITE, READ WRITE"})
+    void mysqlRepeatedAccessModesArePreserved(String sql) throws Exception {
+        StartTransaction statement = assertInstanceOf(StartTransaction.class,
+                roundTrip(sql, Dialect.MYSQL));
+        StartTransaction.Mode mode = sql.endsWith("READ ONLY")
+                ? StartTransaction.Mode.READ_ONLY
+                : StartTransaction.Mode.READ_WRITE;
+        assertEquals(List.of(mode, mode), statement.getModes());
+        assertEquals(sql, statement.toString());
+    }
+
     @ParameterizedTest
     @ValueSource(strings = {"COMMIT", "COMMIT WORK", "COMMIT TRANSACTION", "COMMIT AND CHAIN",
             "COMMIT WORK AND NO CHAIN", "COMMIT TRANSACTION AND CHAIN", "ROLLBACK",