feat: add support for Oracle INSERT ALL/FIRST with WHEN branches

src/main/java/net/sf/jsqlparser/statement/insert/Insert.java

@@ -9,6 +9,11 @@
  */
 package net.sf.jsqlparser.statement.insert;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
 import net.sf.jsqlparser.expression.Alias;
 import net.sf.jsqlparser.expression.OracleHint;
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
@@ -26,12 +31,6 @@
 import net.sf.jsqlparser.statement.select.WithItem;
 import net.sf.jsqlparser.statement.update.UpdateSet;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-
 @SuppressWarnings({"PMD.CyclomaticComplexity"})
 public class Insert implements Statement {
 
@@ -55,6 +54,9 @@ public class Insert implements Statement {
     private InsertConflictAction conflictAction;
     private InsertDuplicateAction duplicateAction;
     private Alias rowAlias;
+    private boolean oracleMultiInsert = false;
+    private boolean oracleMultiInsertFirst = false;
+    private List<OracleMultiInsertBranch> oracleMultiInsertBranches;
 
     public List<UpdateSet> getDuplicateUpdateSets() {
         if (duplicateAction != null) {
@@ -97,6 +99,12 @@ public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
     }
 
     public Table getTable() {
+        if (table == null && oracleMultiInsertBranches != null
+                && !oracleMultiInsertBranches.isEmpty()
+                && oracleMultiInsertBranches.get(0).getClauses() != null
+                && !oracleMultiInsertBranches.get(0).getClauses().isEmpty()) {
+            return oracleMultiInsertBranches.get(0).getClauses().get(0).getTable();
+        }
         return table;
     }
 
@@ -270,10 +278,46 @@ public Insert withConflictAction(InsertConflictAction conflictAction) {
         return this;
     }
 
+    public boolean isOracleMultiInsert() {
+        return oracleMultiInsert;
+    }
+
+    public void setOracleMultiInsert(boolean oracleMultiInsert) {
+        this.oracleMultiInsert = oracleMultiInsert;
+    }
+
+    public boolean isOracleMultiInsertFirst() {
+        return oracleMultiInsertFirst;
+    }
+
+    public void setOracleMultiInsertFirst(boolean oracleMultiInsertFirst) {
+        this.oracleMultiInsertFirst = oracleMultiInsertFirst;
+    }
+
+    public List<OracleMultiInsertBranch> getOracleMultiInsertBranches() {
+        return oracleMultiInsertBranches;
+    }
+
+    public void setOracleMultiInsertBranches(
+            List<OracleMultiInsertBranch> oracleMultiInsertBranches) {
+        this.oracleMultiInsertBranches = oracleMultiInsertBranches;
+    }
+
     @Override
     @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"})
     public String toString() {
         StringBuilder sql = new StringBuilder();
+        appendWithItems(sql);
+        appendInsertPrefix(sql);
+        if (appendOracleMultiInsert(sql)) {
+            return sql.toString();
+        }
+        appendInsertTargetAndValues(sql);
+        appendInsertActions(sql);
+        return sql.toString();
+    }
+
+    private void appendWithItems(StringBuilder sql) {
         if (withItemsList != null && !withItemsList.isEmpty()) {
             sql.append("WITH ");
             for (Iterator<WithItem<?>> iter = withItemsList.iterator(); iter.hasNext();) {
@@ -285,6 +329,9 @@ public String toString() {
                 sql.append(" ");
             }
         }
+    }
+
+    private void appendInsertPrefix(StringBuilder sql) {
         sql.append("INSERT ");
         if (oracleHint != null) {
             sql.append(oracleHint).append(" ");
@@ -295,6 +342,26 @@ public String toString() {
         if (modifierIgnore) {
             sql.append("IGNORE ");
         }
+    }
+
+    private boolean appendOracleMultiInsert(StringBuilder sql) {
+        if (!oracleMultiInsert) {
+            return false;
+        }
+
+        sql.append(oracleMultiInsertFirst ? "FIRST" : "ALL");
+        if (oracleMultiInsertBranches != null && !oracleMultiInsertBranches.isEmpty()) {
+            for (OracleMultiInsertBranch branch : oracleMultiInsertBranches) {
+                appendOracleMultiInsertBranch(sql, branch);
+            }
+        }
+        if (select != null) {
+            sql.append(" ").append(select);
+        }
+        return true;
+    }
+
+    private void appendInsertTargetAndValues(StringBuilder sql) {
         if (overwrite) {
             sql.append("OVERWRITE ");
         } else {
@@ -338,10 +405,12 @@ public String toString() {
         if (select != null) {
             sql.append(select);
         }
+    }
 
+    private void appendInsertActions(StringBuilder sql) {
         if (setUpdateSets != null && !setUpdateSets.isEmpty()) {
             sql.append("SET ");
-            sql = UpdateSet.appendUpdateSetsTo(sql, setUpdateSets);
+            UpdateSet.appendUpdateSetsTo(sql, setUpdateSets);
             if (rowAlias != null) {
                 sql.append(" ").append(rowAlias);
             }
@@ -364,8 +433,6 @@ public String toString() {
         if (returningClause != null) {
             returningClause.appendTo(sql);
         }
-
-        return sql.toString();
     }
 
     public Insert withWithItemsList(List<WithItem<?>> withList) {
@@ -424,4 +491,37 @@ public Alias getRowAlias() {
     public void setRowAlias(Alias rowAlias) {
         this.rowAlias = rowAlias;
     }
+
+    public Insert withOracleMultiInsert(boolean oracleMultiInsert) {
+        this.setOracleMultiInsert(oracleMultiInsert);
+        return this;
+    }
+
+    public Insert withOracleMultiInsertFirst(boolean oracleMultiInsertFirst) {
+        this.setOracleMultiInsertFirst(oracleMultiInsertFirst);
+        return this;
+    }
+
+    public Insert withOracleMultiInsertBranches(
+            List<OracleMultiInsertBranch> oracleMultiInsertBranches) {
+        this.setOracleMultiInsertBranches(oracleMultiInsertBranches);
+        return this;
+    }
+
+    private void appendOracleMultiInsertBranch(StringBuilder sql,
+            OracleMultiInsertBranch branch) {
+        if (branch == null || branch.getClauses() == null || branch.getClauses().isEmpty()) {
+            return;
+        }
+
+        if (branch.getWhenExpression() != null) {
+            sql.append(" WHEN ").append(branch.getWhenExpression()).append(" THEN");
+        } else if (branch.isElseClause()) {
+            sql.append(" ELSE");
+        }
+
+        for (OracleMultiInsertClause clause : branch.getClauses()) {
+            sql.append(" ").append(clause);
+        }
+    }
 }

src/main/java/net/sf/jsqlparser/statement/insert/OracleMultiInsertBranch.java

@@ -0,0 +1,74 @@
+/*-
+ * #%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.insert;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import net.sf.jsqlparser.expression.Expression;
+
+public class OracleMultiInsertBranch implements Serializable {
+
+    private Expression whenExpression;
+    private boolean elseClause;
+    private List<OracleMultiInsertClause> clauses = new ArrayList<>();
+
+    public Expression getWhenExpression() {
+        return whenExpression;
+    }
+
+    public void setWhenExpression(Expression whenExpression) {
+        this.whenExpression = whenExpression;
+        if (whenExpression != null) {
+            this.elseClause = false;
+        }
+    }
+
+    public boolean isElseClause() {
+        return elseClause;
+    }
+
+    public void setElseClause(boolean elseClause) {
+        this.elseClause = elseClause;
+        if (elseClause) {
+            this.whenExpression = null;
+        }
+    }
+
+    public List<OracleMultiInsertClause> getClauses() {
+        return clauses;
+    }
+
+    public void setClauses(List<OracleMultiInsertClause> clauses) {
+        this.clauses = clauses == null ? new ArrayList<>() : clauses;
+    }
+
+    public void addClause(OracleMultiInsertClause clause) {
+        if (clause == null) {
+            return;
+        }
+        clauses.add(clause);
+    }
+
+    public OracleMultiInsertBranch withWhenExpression(Expression whenExpression) {
+        this.setWhenExpression(whenExpression);
+        return this;
+    }
+
+    public OracleMultiInsertBranch withElseClause(boolean elseClause) {
+        this.setElseClause(elseClause);
+        return this;
+    }
+
+    public OracleMultiInsertBranch withClauses(List<OracleMultiInsertClause> clauses) {
+        this.setClauses(clauses);
+        return this;
+    }
+}

src/main/java/net/sf/jsqlparser/statement/insert/OracleMultiInsertClause.java

@@ -0,0 +1,87 @@
+/*-
+ * #%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.insert;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.select.Select;
+
+public class OracleMultiInsertClause implements Serializable {
+
+    private Table table;
+    private ExpressionList<Column> columns;
+    private Select select;
+
+    public Table getTable() {
+        return table;
+    }
+
+    public void setTable(Table table) {
+        this.table = table;
+    }
+
+    public ExpressionList<Column> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(ExpressionList<Column> columns) {
+        this.columns = columns;
+    }
+
+    public Select getSelect() {
+        return select;
+    }
+
+    public void setSelect(Select select) {
+        this.select = select;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sql = new StringBuilder("INTO ");
+        sql.append(table);
+
+        if (columns != null && !columns.isEmpty()) {
+            sql.append(" (");
+            for (Iterator<Column> iter = columns.iterator(); iter.hasNext();) {
+                Column column = iter.next();
+                sql.append(column.getColumnName());
+                if (iter.hasNext()) {
+                    sql.append(", ");
+                }
+            }
+            sql.append(")");
+        }
+
+        if (select != null) {
+            sql.append(" ").append(select);
+        }
+
+        return sql.toString();
+    }
+
+    public OracleMultiInsertClause withTable(Table table) {
+        this.setTable(table);
+        return this;
+    }
+
+    public OracleMultiInsertClause withColumns(ExpressionList<Column> columns) {
+        this.setColumns(columns);
+        return this;
+    }
+
+    public OracleMultiInsertClause withSelect(Select select) {
+        this.setSelect(select);
+        return this;
+    }
+}