Support DELETE FROM T1 USING T2 WHERE ... (#1228)

Co-authored-by: Francois Secherre <[email protected]>

Author: francois-secherre

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

@@ -15,6 +15,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
+
 import static java.util.stream.Collectors.joining;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.OracleHint;
@@ -33,6 +34,7 @@ public class Delete implements Statement {
     private Table table;
     private OracleHint oracleHint = null;
     private List<Table> tables;
+    private List<Table> usingList;
     private List<Join> joins;
     private Expression where;
     private Limit limit;
@@ -116,6 +118,14 @@ public void setTables(List<Table> tables) {
         this.tables = tables;
     }
 
+    public List<Table> getUsingList() {
+        return usingList;
+    }
+
+    public void setUsingList(List<Table> usingList) {
+        this.usingList = usingList;
+    }
+
     public List<Join> getJoins() {
         return joins;
     }
@@ -162,6 +172,13 @@ public String toString() {
         }
         b.append(" ").append(table);
 
+        if (usingList != null && usingList.size()>0) {
+            b.append(" USING ");
+            b.append(usingList.stream()
+                    .map(Table::toString)
+                    .collect(joining(", ")));
+        }
+
         if (joins != null) {
             for (Join join : joins) {
                 if (join.isSimple()) {
@@ -191,6 +208,11 @@ public Delete withTables(List<Table> tables) {
         return this;
     }
 
+    public Delete withUsingList(List<Table> usingList) {
+        this.setUsingList(usingList);
+        return this;
+    }
+
     public Delete withJoins(List<Join> joins) {
         this.setJoins(joins);
         return this;
@@ -233,6 +255,18 @@ public Delete addTables(Collection<? extends Table> tables) {
         return this.withTables(collection);
     }
 
+    public Delete addUsingList(Table... usingList) {
+        List<Table> collection = Optional.ofNullable(getUsingList()).orElseGet(ArrayList::new);
+        Collections.addAll(collection, usingList);
+        return this.withUsingList(collection);
+    }
+
+    public Delete addUsingList(Collection<? extends Table> usingList) {
+        List<Table> collection = Optional.ofNullable(getUsingList()).orElseGet(ArrayList::new);
+        collection.addAll(usingList);
+        return this.withUsingList(collection);
+    }
+
     public Delete addJoins(Join... joins) {
         List<Join> collection = Optional.ofNullable(getJoins()).orElseGet(ArrayList::new);
         Collections.addAll(collection, joins);

src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java

@@ -647,6 +647,12 @@ public void visit(ValueListExpression valueList) {
     public void visit(Delete delete) {
         visit(delete.getTable());
 
+        if (delete.getUsingList() != null) {
+            for (Table using : delete.getUsingList()) {
+                visit(using);
+            }
+        }
+
         if (delete.getJoins() != null) {
             for (Join join : delete.getJoins()) {
                 join.getRightItem().accept(this);

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

@@ -56,6 +56,10 @@ public void deParse(Delete delete) {
         }
         buffer.append(" ").append(delete.getTable().toString());
 
+        if (delete.getUsingList() != null && !delete.getUsingList().isEmpty()) {
+            buffer.append(" USING").append(
+                    delete.getUsingList().stream().map(Table::toString).collect(joining(", ", " ", "")));
+        }
         if (delete.getJoins() != null) {
             for (Join join : delete.getJoins()) {
                 if (join.isSimple()) {

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

@@ -1202,6 +1202,8 @@ Delete Delete( List<WithItem> with ):
     Delete delete = new Delete();
     Table table = null;
     List<Table> tables = new ArrayList<Table>();
+    Table usingTable = null;
+    List<Table> usingList = new ArrayList<Table>();
     List<Join> joins = null;
     Expression where = null;
     Limit limit = null;
@@ -1214,6 +1216,8 @@ Delete Delete( List<WithItem> with ):
     <K_FROM> | <K_FROM>) { hasFrom = true; }]
 
     [ LOOKAHEAD(3) table=TableWithAlias()  joins=JoinsList() ]
+    [ <K_USING> usingTable=TableWithAlias() { usingList.add(usingTable); }
+          ("," usingTable=TableWithAlias() { usingList.add(usingTable); } )*]
     [where=WhereClause() { delete.setWhere(where); } ]
     [orderByElements = OrderByElements() { delete.setOrderByElements(orderByElements); } ]
     [limit=PlainLimit() {delete.setLimit(limit); } ]
@@ -1222,7 +1226,7 @@ Delete Delete( List<WithItem> with ):
             delete.setJoins(joins);
         }
         return delete.withWithItemsList(with)
-              .withTables(tables).withTable(table).withHasFrom(hasFrom);
+              .withTables(tables).withTable(table).withHasFrom(hasFrom).withUsingList(usingList);
     }
 }
 

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

@@ -131,4 +131,10 @@ public void testNoFromWithSchema() throws JSQLParserException {
         String statement = "DELETE A.B WHERE Z = 1";
         assertSqlCanBeParsedAndDeparsed(statement);
     }
+
+    @Test
+    public void testUsing() throws JSQLParserException {
+        String statement = "DELETE A USING B.C D WHERE D.Z = 1";
+        assertSqlCanBeParsedAndDeparsed(statement);
+    }
 }

src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java

@@ -37,6 +37,7 @@
 import java.io.StringReader;
 import java.util.Iterator;
 import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
@@ -664,4 +665,17 @@ public void testAtTimeZoneExpression() throws JSQLParserException {
         assertEquals(1, tableList.size());
         assertTrue(tableList.contains("mytbl"));
     }
+
+
+    @Test
+    public void testUsing() throws JSQLParserException {
+        String sql = "DELETE A USING B.C D WHERE D.Z = 1";
+        Statement stmt = CCJSqlParserUtil.parse(sql);
+        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
+        List<String> tableList = tablesNamesFinder.getTableList(stmt);
+        assertEquals(2, tableList.size());
+        assertTrue(tableList.contains("A"));
+        assertTrue(tableList.contains("B.C"));
+    }
+
 }