Add Delete / Update modifiers for MySQL #1254

src/main/java/net/sf/jsqlparser/statement/delete/Delete.java

@@ -40,6 +40,10 @@ public class Delete implements Statement {
     private Limit limit;
     private List<OrderByElement> orderByElements;
     private boolean hasFrom = true;
+    private DeleteModifierPriority modifierPriority;
+    private boolean modifierIgnore;
+    private boolean modifierQuick;
+
     public List<WithItem> getWithItemsList() {
         return withItemsList;
     }
@@ -160,10 +164,20 @@ public String toString() {
 
         b.append("DELETE");
 
+        if (modifierPriority != null) {
+            b.append(" ").append(modifierPriority.name());
+        }
+        if (modifierQuick) {
+            b.append(" QUICK");
+        }
+        if (modifierIgnore) {
+            b.append(" IGNORE");
+        }
+
         if (tables != null && tables.size() > 0) {
             b.append(" ");
             b.append(tables.stream()
-                    .map(t -> t.toString())
+                    .map(Table::toString)
                     .collect(joining(", ")));
         }
 
@@ -243,6 +257,45 @@ public Delete withHasFrom(boolean hasFrom) {
         return this;
     }
 
+    public Delete withModifierPriority(DeleteModifierPriority modifierPriority){
+        this.setModifierPriority(modifierPriority);
+        return this;
+    }
+
+    public Delete withModifierIgnore(boolean modifierIgnore){
+        this.setModifierIgnore(modifierIgnore);
+        return this;
+    }
+
+    public Delete withModifierQuick(boolean modifierQuick){
+        this.setModifierQuick(modifierQuick);
+        return this;
+    }
+
+    public void setModifierPriority(DeleteModifierPriority modifierPriority) {
+        this.modifierPriority = modifierPriority;
+    }
+
+    public DeleteModifierPriority getModifierPriority() {
+        return modifierPriority;
+    }
+
+    public void setModifierIgnore(boolean modifierIgnore) {
+        this.modifierIgnore = modifierIgnore;
+    }
+
+    public void setModifierQuick(boolean modifierQuick) {
+        this.modifierQuick = modifierQuick;
+    }
+
+    public boolean isModifierIgnore() {
+        return modifierIgnore;
+    }
+
+    public boolean isModifierQuick() {
+        return modifierQuick;
+    }
+
     public Delete addTables(Table... tables) {
         List<Table> collection = Optional.ofNullable(getTables()).orElseGet(ArrayList::new);
         Collections.addAll(collection, tables);

src/main/java/net/sf/jsqlparser/statement/delete/DeleteModifierPriority.java

@@ -0,0 +1,14 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2019 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement.delete;
+
+public enum DeleteModifierPriority {
+    LOW_PRIORITY
+}

src/main/java/net/sf/jsqlparser/statement/update/Update.java

@@ -38,6 +38,8 @@ public class Update implements Statement {
     private Limit limit;
     private boolean returningAllColumns = false;
     private List<SelectExpressionItem> returningExpressionList = null;
+    private UpdateModifierPriority modifierPriority;
+    private boolean modifierIgnore;
 
     public ArrayList<UpdateSet> getUpdateSets() {
         return updateSets;
@@ -233,6 +235,23 @@ public void setReturningExpressionList(List<SelectExpressionItem> returningExpre
         this.returningExpressionList = returningExpressionList;
     }
 
+    public UpdateModifierPriority getModifierPriority() {
+        return modifierPriority;
+    }
+
+    public void setModifierPriority(UpdateModifierPriority modifierPriority) {
+        this.modifierPriority = modifierPriority;
+    }
+
+    public boolean isModifierIgnore() {
+        return modifierIgnore;
+    }
+
+    public void setModifierIgnore(boolean modifierIgnore) {
+        this.modifierIgnore = modifierIgnore;
+    }
+
+
     @Override
     @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity", "PMD.ExcessiveMethodLength"})
     public String toString() {
@@ -250,6 +269,12 @@ public String toString() {
             }
         }
         b.append("UPDATE ");
+        if (modifierPriority != null) {
+            b.append(modifierPriority.name()).append(" ");
+        }
+        if (modifierIgnore) {
+            b.append("IGNORE ");
+        }
         b.append(table);
         if (startJoins != null) {
             for (Join join : startJoins) {
@@ -405,6 +430,16 @@ public Update withExpressions(List<Expression> expressions) {
         return this;
     }
 
+    public Update withModifierPriority(UpdateModifierPriority modifierPriority){
+        this.setModifierPriority(modifierPriority);
+        return this;
+    }
+
+    public Update withModifierIgnore(boolean modifierIgnore){
+        this.setModifierIgnore(modifierIgnore);
+        return this;
+    }
+
     public Update addColumns(Column... columns) {
         List<Column> collection = Optional.ofNullable(getColumns()).orElseGet(ArrayList::new);
         Collections.addAll(collection, columns);

src/main/java/net/sf/jsqlparser/statement/update/UpdateModifierPriority.java

@@ -0,0 +1,14 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2019 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement.update;
+
+public enum UpdateModifierPriority {
+    LOW_PRIORITY
+}

src/main/java/net/sf/jsqlparser/util/deparser/DeleteDeParser.java

@@ -47,6 +47,15 @@ public void deParse(Delete delete) {
       }
     }
         buffer.append("DELETE");
+        if (delete.getModifierPriority() != null) {
+            buffer.append(" ").append(delete.getModifierPriority());
+        }
+        if (delete.isModifierQuick()) {
+            buffer.append(" QUICK");
+        }
+        if (delete.isModifierIgnore()) {
+            buffer.append(" IGNORE");
+        }
         if (delete.getTables() != null && !delete.getTables().isEmpty()) {
             buffer.append(
                     delete.getTables().stream().map(Table::getFullyQualifiedName).collect(joining(", ", " ", "")));

src/main/java/net/sf/jsqlparser/util/deparser/UpdateDeParser.java

@@ -48,7 +48,14 @@ public void deParse(Update update) {
                 buffer.append(" ");
             }
         }
-        buffer.append("UPDATE ").append(update.getTable());
+        buffer.append("UPDATE ");
+        if (update.getModifierPriority() != null) {
+            buffer.append(update.getModifierPriority()).append(" ");
+        }
+        if (update.isModifierIgnore()) {
+            buffer.append("IGNORE ");
+        }
+        buffer.append(update.getTable());
         if (update.getStartJoins() != null) {
             for (Join join : update.getStartJoins()) {
                 if (join.isSimple()) {

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

@@ -326,6 +326,7 @@ TOKEN: /* SQL Keywords. prefixed with K_ to avoid name clashes */
 |   <K_PUBLIC:"PUBLIC">
 |   <K_PURGE:"PURGE">
 |   <K_QUERY:"QUERY">
+|   <K_QUICK : "QUICK">
 |   <K_QUIESCE: "QUIESCE">
 |   <K_RANGE: "RANGE">
 |   <K_READ: "READ" >
@@ -1124,11 +1125,15 @@ Update Update( List<WithItem> with ):
     List<OrderByElement> orderByElements;
     boolean useColumnsBrackets = false;
     List<SelectExpressionItem> returning = null;
+    Token tk = null;
+    UpdateModifierPriority modifierPriority = null;
+    boolean modifierIgnore = false;
 }
 {
-   <K_UPDATE> { update.setOracleHint(getOracleHint()); } table=TableWithAlias()  
-        startJoins=JoinsList()
-
+   <K_UPDATE> { update.setOracleHint(getOracleHint()); }
+    [<K_LOW_PRIORITY> { modifierPriority = UpdateModifierPriority.LOW_PRIORITY; }]
+    [<K_IGNORE> { modifierIgnore = true; }]
+    table=TableWithAlias() startJoins=JoinsList()
     <K_SET>
     (
         LOOKAHEAD(3) tableColumn=Column() "=" valueExpression=SimpleExpression() { update.addUpdateSet(tableColumn, valueExpression); }
@@ -1193,6 +1198,8 @@ Update Update( List<WithItem> with ):
               .withStartJoins(startJoins)
               .withFromItem(fromItem)
               .withJoins(joins)
+              .withModifierPriority(modifierPriority)
+              .withModifierIgnore(modifierIgnore)
               .withReturningExpressionList(returning);
    }
 }
@@ -1480,9 +1487,17 @@ Delete Delete( List<WithItem> with ):
     Limit limit = null;
     List<OrderByElement> orderByElements;
     boolean hasFrom = false;
+    Token tk = null;
+    DeleteModifierPriority modifierPriority = null;
+    boolean modifierIgnore = false;
+    boolean modifierQuick = false;
 }
 {
-    <K_DELETE> { delete.setOracleHint(getOracleHint()); } [LOOKAHEAD(4) (table=TableWithAlias() { tables.add(table); }
+    <K_DELETE> { delete.setOracleHint(getOracleHint()); }
+    [<K_LOW_PRIORITY> { modifierPriority = DeleteModifierPriority.LOW_PRIORITY; }]
+    [<K_QUICK> { modifierQuick = true; }]
+    [<K_IGNORE> { modifierIgnore = true; }]
+    [LOOKAHEAD(4) (table=TableWithAlias() { tables.add(table); }
           ("," table=TableWithAlias() { tables.add(table); } )*
     <K_FROM> | <K_FROM>) { hasFrom = true; }]
 
@@ -1497,7 +1512,13 @@ Delete Delete( List<WithItem> with ):
             delete.setJoins(joins);
         }
         return delete.withWithItemsList(with)
-              .withTables(tables).withTable(table).withHasFrom(hasFrom).withUsingList(usingList);
+              .withTables(tables)
+              .withTable(table)
+              .withHasFrom(hasFrom)
+              .withUsingList(usingList)
+              .withModifierPriority(modifierPriority)
+              .withModifierIgnore(modifierIgnore)
+              .withModifierQuick(modifierQuick);
     }
 }
 

src/test/java/net/sf/jsqlparser/statement/delete/DeleteTest.java

@@ -12,6 +12,8 @@
 import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
 import static net.sf.jsqlparser.test.TestUtils.assertOracleHintExists;
 import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.StringReader;
 
@@ -137,4 +139,45 @@ public void testUsing() throws JSQLParserException {
         String statement = "DELETE A USING B.C D WHERE D.Z = 1";
         assertSqlCanBeParsedAndDeparsed(statement);
     }
+
+    @Test
+    public void testDeleteLowPriority() throws JSQLParserException {
+        String stmt = "DELETE LOW_PRIORITY FROM tablename";
+        Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed(stmt);
+        assertEquals(delete.getModifierPriority(), DeleteModifierPriority.LOW_PRIORITY);
+    }
+
+    @Test
+    public void testDeleteQuickModifier() throws JSQLParserException {
+        String stmt = "DELETE QUICK FROM tablename";
+        Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed(stmt);
+        assertTrue(delete.isModifierQuick());
+        String stmt2 = "DELETE FROM tablename";
+        Delete delete2 = (Delete) assertSqlCanBeParsedAndDeparsed(stmt2);
+        assertFalse(delete2.isModifierQuick());
+    }
+
+    @Test
+    public void testDeleteIgnoreModifier() throws JSQLParserException {
+        String stmt = "DELETE IGNORE FROM tablename";
+        Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed(stmt);
+        assertTrue(delete.isModifierIgnore());
+        String stmt2 = "DELETE FROM tablename";
+        Delete delete2 = (Delete) assertSqlCanBeParsedAndDeparsed(stmt2);
+        assertFalse(delete2.isModifierIgnore());
+    }
+
+    @Test
+    public void testDeleteMultipleModifiers() throws JSQLParserException {
+        String stmt = "DELETE LOW_PRIORITY QUICK FROM tablename";
+        Delete delete = (Delete) assertSqlCanBeParsedAndDeparsed(stmt);
+        assertEquals(delete.getModifierPriority(), DeleteModifierPriority.LOW_PRIORITY);
+        assertTrue(delete.isModifierQuick());
+
+        String stmt2 = "DELETE LOW_PRIORITY QUICK IGNORE FROM tablename";
+        Delete delete2 = (Delete) assertSqlCanBeParsedAndDeparsed(stmt2);
+        assertEquals(delete2.getModifierPriority(), DeleteModifierPriority.LOW_PRIORITY);
+        assertTrue(delete2.isModifierIgnore());
+        assertTrue(delete2.isModifierQuick());
+    }
 }

src/test/java/net/sf/jsqlparser/statement/update/UpdateTest.java

@@ -18,8 +18,8 @@
 import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
 import net.sf.jsqlparser.parser.CCJSqlParserManager;
 import static net.sf.jsqlparser.test.TestUtils.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
 
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import org.junit.Assert;
@@ -248,4 +248,29 @@ public void testUpdateSetsIssue1316() throws JSQLParserException {
         Assert.assertEquals(1, update.getUpdateSets().get(2).getColumns().size());
         Assert.assertEquals(1, update.getUpdateSets().get(2).getExpressions().size());
     }
+
+    @Test
+    public void testUpdateLowPriority() throws JSQLParserException {
+        String stmt = "UPDATE LOW_PRIORITY table1 A SET A.columna = 'XXX'";
+        Update update = (Update)assertSqlCanBeParsedAndDeparsed(stmt);
+        assertEquals(update.getModifierPriority(), UpdateModifierPriority.LOW_PRIORITY);
+    }
+
+    @Test
+    public void testUpdateIgnoreModifier() throws JSQLParserException {
+        String stmt = "UPDATE IGNORE table1 A SET A.columna = 'XXX'";
+        Update update = (Update)assertSqlCanBeParsedAndDeparsed(stmt);
+        assertTrue(update.isModifierIgnore());
+        String stmt2 = "UPDATE table1 A SET A.columna = 'XXX'";
+        Update update2 = (Update)assertSqlCanBeParsedAndDeparsed(stmt2);
+        assertFalse(update2.isModifierIgnore());
+    }
+
+    @Test
+    public void testUpdateMultipleModifiers() throws JSQLParserException {
+        String stmt = "UPDATE LOW_PRIORITY IGNORE table1 A SET A.columna = 'XXX'";
+        Update update = (Update)assertSqlCanBeParsedAndDeparsed(stmt);
+        assertEquals(update.getModifierPriority(), UpdateModifierPriority.LOW_PRIORITY);
+        assertTrue(update.isModifierIgnore());
+    }
 }