feat: guard INSERT OR conflict clauses by the SQLITE dialect

Add Dialect.SQLITE. INSERT OR ABORT, FAIL, IGNORE and ROLLBACK need it.
INSERT OR REPLACE keeps parsing in every dialect.

Author: ItsDeadlyProgrammer

src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java

@@ -48,7 +48,7 @@ public enum Dialect {
                                                         AdjacentStringLiterals.WHITESPACE,
                                                         Feature.allowDoubleQuotedStrings,
                                                         Feature.allowBackslashEscapeCharacter), SNOWFLAKE(
-                                                                Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS, COCKROACHDB, TERADATA;
+                                                                Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS, COCKROACHDB, TERADATA, SQLITE;
 
         private final Set<Feature> lexerFeatures;
         private final AdjacentStringLiterals adjacentStringLiterals;

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

@@ -3139,6 +3139,11 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         }
     }
 
+    private void requireSqliteSyntax(String syntax) throws ParseException {
+        requireDdlSyntax(Dialect.SQLITE.name().equals(getAsString(Feature.dialect)),
+                syntax + " needs Dialect.SQLITE");
+    }
+
     private void requireDdlSyntax(boolean valid, String message) throws ParseException {
         if (!valid) {
             throw new ParseException(message);
@@ -8119,12 +8124,20 @@ Upsert Upsert():
             (
                 <K_REPLACE> { upsert.setUpsertType(UpsertType.INSERT_OR_REPLACE); }
                 |
-                <K_IGNORE> { upsert.setUpsertType(UpsertType.INSERT_OR_IGNORE); }
+                // the other conflict resolution algorithms are SQLite syntax
+                <K_IGNORE> {
+                    requireSqliteSyntax("INSERT OR IGNORE");
+                    upsert.setUpsertType(UpsertType.INSERT_OR_IGNORE);
+                }
                 |
-                <K_ROLLBACK> { upsert.setUpsertType(UpsertType.INSERT_OR_ROLLBACK); }
+                <K_ROLLBACK> {
+                    requireSqliteSyntax("INSERT OR ROLLBACK");
+                    upsert.setUpsertType(UpsertType.INSERT_OR_ROLLBACK);
+                }
                 |
-                // SQLite conflict resolution algorithms that are not keywords of the parser
+                // ABORT and FAIL are not keywords of the parser
                 tk=<S_IDENTIFIER> {
+                    requireSqliteSyntax("INSERT OR " + tk.image);
                     requireDdlSyntax("ABORT".equalsIgnoreCase(tk.image) || "FAIL".equalsIgnoreCase(tk.image),
                             "Expected ABORT, FAIL, IGNORE, REPLACE or ROLLBACK");
                     upsert.setUpsertType("ABORT".equalsIgnoreCase(tk.image)

src/site/sphinx/usage.rst

@@ -1604,6 +1604,8 @@ One grammar covers every supported RDBMS, but a few pieces of syntax mean differ
       - ``ALTER TABLE ... ALTER PRIMARY KEY USING COLUMNS (...)`` with optional hash sharding and storage parameters
     * - ``TERADATA``
       - ``UPDATE target FROM sources SET ...`` with the FROM clause before SET
+    * - ``SQLITE``
+      - ``INSERT OR ABORT``, ``INSERT OR FAIL``, ``INSERT OR IGNORE`` and ``INSERT OR ROLLBACK`` conflict clauses
 
 Features set explicitly *after* the preset win over it.
 

src/test/java/net/sf/jsqlparser/statement/select/SQLiteTest.java

@@ -10,6 +10,7 @@
 package net.sf.jsqlparser.statement.select;
 
 import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.test.TestUtils;
 import org.junit.jupiter.api.Test;
@@ -31,14 +32,24 @@ void testInsertOrReplaceUpsert() throws JSQLParserException {
     @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "REPLACE", "ROLLBACK"})
     void testInsertOrConflictAlgorithm(String algorithm) throws JSQLParserException {
         TestUtils.assertSqlCanBeParsedAndDeparsed(
-                "INSERT OR " + algorithm + " INTO t (a, b) VALUES (1, 2)", true);
+                "INSERT OR " + algorithm + " INTO t (a, b) VALUES (1, 2)", true,
+                parser -> parser.withDialect(Dialect.SQLITE));
         TestUtils.assertSqlCanBeParsedAndDeparsed(
-                "insert or " + algorithm.toLowerCase(Locale.ROOT) + " into t select * from s", true);
+                "insert or " + algorithm.toLowerCase(Locale.ROOT) + " into t select * from s", true,
+                parser -> parser.withDialect(Dialect.SQLITE));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"ABORT", "FAIL", "IGNORE", "ROLLBACK"})
+    void testInsertOrConflictAlgorithmNeedsSqliteDialect(String algorithm) {
+        assertThrows(JSQLParserException.class,
+                () -> CCJSqlParserUtil.parse("INSERT OR " + algorithm + " INTO t VALUES (1)"));
     }
 
     @Test
     void testInsertOrUnknownAlgorithm() {
         assertThrows(JSQLParserException.class,
-                () -> CCJSqlParserUtil.parse("INSERT OR NOTHING INTO t VALUES (1)"));
+                () -> CCJSqlParserUtil.parse("INSERT OR NOTHING INTO t VALUES (1)",
+                        parser -> parser.withDialect(Dialect.SQLITE)));
     }
 }