feat: parse INSERT OR ABORT, FAIL, IGNORE and ROLLBACK (SQLite) (#2853)

* feat: parse INSERT OR ABORT, FAIL, IGNORE and ROLLBACK (SQLite)

UpsertType and the deparsers already had these values, but the grammar
only accepted INSERT OR REPLACE.

Part of #2852

* 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.

* fix: keep CCJSqlParser under the class size limit for JaCoCo

The extra INSERT OR alternatives pushed the constant pool of CCJSqlParser
past 65535 entries once JaCoCo instrumented it, so the class was silently
left without coverage data and the coverage check failed. Parse the
algorithm with RelObjectName and decide in AbstractJSqlParser instead.

Author: ItsDeadlyProgrammer

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

@@ -11,6 +11,7 @@
 
 import net.sf.jsqlparser.parser.feature.Feature;
 import net.sf.jsqlparser.parser.feature.FeatureConfiguration;
+import net.sf.jsqlparser.statement.upsert.UpsertType;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -48,7 +49,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;
@@ -259,6 +260,30 @@ public Integer getAsInteger(Feature f) {
         return getConfiguration().getAsInteger(f);
     }
 
+    /**
+     * The INSERT OR conflict algorithms other than REPLACE are SQLite syntax.
+     */
+    protected UpsertType insertOrType(String algorithm) throws ParseException {
+        if ("REPLACE".equalsIgnoreCase(algorithm)) {
+            return UpsertType.INSERT_OR_REPLACE;
+        }
+        if (!Dialect.SQLITE.name().equals(getAsString(Feature.dialect))) {
+            throw new ParseException("INSERT OR " + algorithm + " needs Dialect.SQLITE");
+        }
+        switch (algorithm.toUpperCase()) {
+            case "IGNORE":
+                return UpsertType.INSERT_OR_IGNORE;
+            case "ROLLBACK":
+                return UpsertType.INSERT_OR_ROLLBACK;
+            case "ABORT":
+                return UpsertType.INSERT_OR_ABORT;
+            case "FAIL":
+                return UpsertType.INSERT_OR_FAIL;
+            default:
+                throw new ParseException("Expected ABORT, FAIL, IGNORE, REPLACE or ROLLBACK");
+        }
+    }
+
     public String getAsString(Feature f) {
         return getConfiguration().getAsString(f);
     }

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

@@ -8098,6 +8098,7 @@ OutputClause OutputClause():
 Upsert Upsert():
 {
     Upsert upsert = new Upsert();
+    String algorithm;
     Table table = null;
     ExpressionList<Column> columns;
     List<UpdateSet> updateSets;
@@ -8114,7 +8115,10 @@ Upsert Upsert():
         <K_REPLACE> { upsert.setUpsertType(UpsertType.REPLACE); }
         |
         (
-            <K_INSERT> <K_OR> <K_REPLACE> { upsert.setUpsertType(UpsertType.INSERT_OR_REPLACE); }
+            <K_INSERT> <K_OR>
+            // ABORT and FAIL are not keywords of the parser
+            algorithm=RelObjectName()
+            { upsert.setUpsertType(insertOrType(algorithm)); }
         )
     )
     [ LOOKAHEAD(2) <K_INTO> { upsert.setUsingInto(true); } ]

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,13 +10,46 @@
 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;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.Locale;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 public class SQLiteTest {
     @Test
     void testInsertOrReplaceUpsert() throws JSQLParserException {
         String sqlString = "INSERT OR REPLACE INTO kjobLocks VALUES (?, ?, ?)";
         TestUtils.assertSqlCanBeParsedAndDeparsed(sqlString, true);
     }
+
+    @ParameterizedTest
+    @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,
+                parser -> parser.withDialect(Dialect.SQLITE));
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "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)",
+                        parser -> parser.withDialect(Dialect.SQLITE)));
+    }
 }