feat: preserve DROP INDEX owner tables in the AST (#2640)

* feat: preserve DROP INDEX owner tables in the AST

* refactor: split DROP target and parameter rendering

Author: minleejae

src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java

@@ -331,10 +331,7 @@ public <S> T visit(ParenthesedInsert insert, S context) {
 
     @Override
     public <S> T visit(Drop drop, S context) {
-        if (drop.getType().equalsIgnoreCase("table")) {
-            drop.getNames().forEach(name -> fromItemVisitor.visitFromItem(name, context));
-        }
-        // @todo: handle schemas
+        drop.visitTables(table -> fromItemVisitor.visitFromItem(table, context));
 
         return null;
     }

src/main/java/net/sf/jsqlparser/statement/drop/Drop.java

@@ -16,8 +16,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
+import java.util.function.Consumer;
 
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.Statement;
@@ -34,6 +33,8 @@ public enum ObjectType {
     private ObjectType objectType = ObjectType.OTHER;
     private final List<Table> names = new ArrayList<>();
     private List<String> parameters;
+    private Table table;
+    private int tablePosition;
     private Map<String, List<String>> typeToParameters = new HashMap<>();
     private boolean ifExists = false;
     private boolean materialized = false;
@@ -74,12 +75,55 @@ public void setNames(Collection<? extends Table> names) {
         }
     }
 
+    /** Returns legacy tokens, including ON and its owner. Structured owners produce a snapshot. */
     public List<String> getParameters() {
-        return parameters;
+        if (table == null) {
+            return parameters;
+        }
+        List<String> tokens = parameters == null ? new ArrayList<>() : new ArrayList<>(parameters);
+        tokens.add(tablePosition, "ON");
+        tokens.add(tablePosition + 1, table.toString());
+        return tokens;
+    }
+
+    /** The table explicitly named by DROP INDEX ... ON, or null when SQL does not name one. */
+    public Table getTable() {
+        return table;
+    }
+
+    public void setTable(Table table) {
+        setTable(table, this.table == null ? 0 : tablePosition);
+    }
+
+    /** Places ON among the remaining parameter tokens, preserving their source order. */
+    public void setTable(Table table, int parameterPosition) {
+        int size = parameters == null ? 0 : parameters.size();
+        if (parameterPosition < 0 || parameterPosition > size) {
+            throw new IllegalArgumentException("Invalid ON table position: " + parameterPosition);
+        }
+        this.table = table;
+        tablePosition = table == null ? 0 : parameterPosition;
+    }
+
+    public Drop withTable(Table table) {
+        setTable(table);
+        return this;
     }
 
+    /** Visits table/view targets and explicit index owners without resolving catalog objects. */
+    public void visitTables(Consumer<Table> visitor) {
+        if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW) {
+            names.forEach(visitor);
+        } else if (objectType == ObjectType.INDEX && table != null) {
+            visitor.accept(table);
+        }
+    }
+
+    /** Replaces all legacy parameters and clears the structured ON table. */
     public void setParameters(List<String> list) {
         parameters = list;
+        table = null;
+        tablePosition = 0;
     }
 
     public String getType() {
@@ -145,22 +189,51 @@ public void setTypeToParameters(Map<String, List<String>> typeToParameters) {
 
     @Override
     public String toString() {
-        String sql = "DROP "
-                + (isUsingTemporary ? "TEMPORARY " : "")
-                + (materialized ? "MATERIALIZED " : "")
-                + type + " "
-                + (ifExists ? "IF EXISTS " : "") + names.stream().map(Table::toString)
-                        .collect(Collectors.joining(", "));
-
-        if (type.equals("FUNCTION")) {
-            sql += formatFuncParams(getParamsByType("FUNCTION"));
-        }
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, builder::append).toString();
+    }
 
-        if (parameters != null && !parameters.isEmpty()) {
-            sql += " " + PlainSelect.getStringList(parameters, false, false);
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Table> tablePrinter) {
+        builder.append("DROP ");
+        if (isUsingTemporary) {
+            builder.append("TEMPORARY ");
+        }
+        if (materialized) {
+            builder.append("MATERIALIZED ");
+        }
+        builder.append(type).append(ifExists ? " IF EXISTS " : " ");
+        appendNames(builder, tablePrinter);
+        if ("FUNCTION".equals(type)) {
+            builder.append(formatFuncParams(getParamsByType("FUNCTION")));
         }
+        appendParameters(builder, tablePrinter);
+        return builder;
+    }
+
+    private void appendNames(StringBuilder builder, Consumer<Table> tablePrinter) {
+        for (int i = 0; i < names.size(); i++) {
+            if (i > 0) {
+                builder.append(", ");
+            }
+            if (objectType == ObjectType.TABLE || objectType == ObjectType.VIEW) {
+                tablePrinter.accept(names.get(i));
+            } else {
+                builder.append(names.get(i));
+            }
+        }
+    }
 
-        return sql;
+    private void appendParameters(StringBuilder builder, Consumer<Table> tablePrinter) {
+        int size = parameters == null ? 0 : parameters.size();
+        for (int i = 0; i <= size; i++) {
+            if (table != null && i == tablePosition) {
+                builder.append(" ON ");
+                tablePrinter.accept(table);
+            }
+            if (i < size) {
+                builder.append(' ').append(parameters.get(i));
+            }
+        }
     }
 
     public List<String> getParamsByType(String type) {
@@ -208,14 +281,15 @@ public Drop withParameters(List<String> parameters) {
     }
 
     public Drop addParameters(String... parameters) {
-        List<String> collection = Optional.ofNullable(getParameters()).orElseGet(ArrayList::new);
-        Collections.addAll(collection, parameters);
-        return this.withParameters(collection);
+        return addParameters(java.util.Arrays.asList(parameters));
     }
 
+    /** Appends trailing tokens without discarding a structured ON table. */
     public Drop addParameters(Collection<String> parameters) {
-        List<String> collection = Optional.ofNullable(getParameters()).orElseGet(ArrayList::new);
-        collection.addAll(parameters);
-        return this.withParameters(collection);
+        if (this.parameters == null) {
+            this.parameters = new ArrayList<>();
+        }
+        this.parameters.addAll(parameters);
+        return this;
     }
 }

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

@@ -1553,7 +1553,7 @@ public void visit(Analyze analyze) {
 
     @Override
     public <S> Void visit(Drop drop, S context) {
-        drop.getNames().forEach(name -> visit(name, context));
+        drop.visitTables(table -> visit(table, context));
         return null;
     }
 

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

@@ -9,41 +9,24 @@
  */
 package net.sf.jsqlparser.util.deparser;
 
-import java.util.stream.Collectors;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.drop.Drop;
-import net.sf.jsqlparser.statement.select.PlainSelect;
 
 public class DropDeParser extends AbstractDeParser<Drop> {
+    private final Consumer<Table> tablePrinter;
 
     public DropDeParser(StringBuilder buffer) {
+        this(buffer, buffer::append);
+    }
+
+    public DropDeParser(StringBuilder buffer, Consumer<Table> tablePrinter) {
         super(buffer);
+        this.tablePrinter = tablePrinter;
     }
 
     @Override
     public void deParse(Drop drop) {
-        builder.append("DROP ");
-        if (drop.isUsingTemporary()) {
-            builder.append("TEMPORARY ");
-        }
-        if (drop.isMaterialized()) {
-            builder.append("MATERIALIZED ");
-        }
-        builder.append(drop.getType());
-        if (drop.isIfExists()) {
-            builder.append(" IF EXISTS");
-        }
-
-        builder.append(" ").append(drop.getNames().stream().map(Object::toString)
-                .collect(Collectors.joining(", ")));
-
-        if (drop.getType().equals("FUNCTION")) {
-            builder.append(Drop.formatFuncParams(drop.getParamsByType("FUNCTION")));
-        }
-
-        if (drop.getParameters() != null && !drop.getParameters().isEmpty()) {
-            builder.append(" ")
-                    .append(PlainSelect.getStringList(drop.getParameters(), false, false));
-        }
+        drop.appendTo(builder, tablePrinter);
     }
-
 }

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

@@ -210,7 +210,8 @@ public <S> StringBuilder visit(Delete delete, S context) {
 
     @Override
     public <S> StringBuilder visit(Drop drop, S context) {
-        DropDeParser dropDeParser = new DropDeParser(builder);
+        DropDeParser dropDeParser =
+                new DropDeParser(builder, table -> table.accept(selectDeParser, context));
         dropDeParser.deParse(drop);
         return builder;
     }

src/main/java/net/sf/jsqlparser/util/validation/validator/DropValidator.java

@@ -45,6 +45,9 @@ public void validate(Drop drop) {
                     Feature.dropSequenceIfExists);
         }
 
+        if (drop.getTable() != null) {
+            validateName(NamedObject.table, drop.getTable().getFullyQualifiedName());
+        }
         NamedObject named = NamedObject.forName(type);
         if (Arrays.asList(NamedObject.table, NamedObject.view).contains(named)) {
             drop.getNames().forEach(name -> validateName(named, name.getFullyQualifiedName()));

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

@@ -1632,6 +1632,12 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         }
     }
 
+    private void requireNoDropIndexOwner(Table owner) throws ParseException {
+        if (owner != null) {
+            throw new ParseException("Duplicate DROP INDEX ON clause");
+        }
+    }
+
     private static boolean hasStructuredColumnOption(List<ColumnOption> options) {
         for (ColumnOption option : options) {
             if (option.getKind() != ColumnOption.Kind.OTHER) {
@@ -14857,11 +14863,32 @@ List<String> FuncArgsList():
     }
 }
 
+/** DROP names are lexer-separated identifiers, not strings to split again on dots. */
+Table DropObjectName() #TableName:
+{
+    ObjectNames names;
+    Token literal;
+    Table table;
+    String timeTravel = null;
+}
+{
+    (
+        names=RelObjectNames() [ LOOKAHEAD(2) timeTravel=TimeTravelBeforeAlias() ]
+        { table = names.getNames().size() == 1 ? new Table(names.getNames().get(0), false)
+                : new Table(names.getNames()); table.setTimeTravel(timeTravel); }
+        |
+        literal=<S_CHAR_LITERAL> { table = new Table(literal.image, false); }
+    )
+    { linkAST(table, jjtThis); return table; }
+}
+
 Drop Drop():
 {
     Drop drop = new Drop();
     Token tk = null;
     Table name;
+    Table indexTable = null;
+    int indexTablePosition = 0;
     List<String> dropArgs = new ArrayList<String>();
     List<String> funcArgs = null;
     List<String> indexOption;
@@ -14897,8 +14924,8 @@ Drop Drop():
 
     [ LOOKAHEAD(2) <K_IF> <K_EXISTS> {drop.setIfExists(true);} ]
 
-    name = Table() { drop.setName(name); }
-    ( "," name = Table() { drop.addNames(name); } )*
+    name = DropObjectName() { drop.setName(name); }
+    ( "," name = DropObjectName() { drop.addNames(name); } )*
     [ LOOKAHEAD(2)  funcArgs = FuncArgsList() ]
     (
         LOOKAHEAD({ getToken(1).kind == K_ALGORITHM
@@ -14913,7 +14940,15 @@ Drop Drop():
         ) { dropArgs.add(tk.image); }
         |
         (
-            <K_ON> name = Table() { dropArgs.add("ON"); dropArgs.add(name.toString()); }
+            <K_ON> name = DropObjectName() {
+                if (drop.getObjectType() == Drop.ObjectType.INDEX) {
+                    requireNoDropIndexOwner(indexTable);
+                    indexTable = name;
+                    indexTablePosition = dropArgs.size();
+                } else {
+                    dropArgs.add("ON"); dropArgs.add(name.toString());
+                }
+            }
         )
         |
         // The lock_option of DROP INDEX. LOCK also starts a LOCK TABLE statement, so it is only
@@ -14925,6 +14960,9 @@ Drop Drop():
         if (dropArgs.size() > 0) {
             drop.setParameters(dropArgs);
         }
+        if (indexTable != null) {
+            drop.setTable(indexTable, indexTablePosition);
+        }
         if (drop.getType().equals("FUNCTION")) {
             drop.getTypeToParameters().put("FUNCTION", funcArgs);
         }

src/site/sphinx/usage.rst

@@ -231,6 +231,27 @@ The fastest way to learn the object model is to look at it. Paste your SQL into
 Read that as a map: each line is a getter away. ``select.getSelectItems()``, ``select.getFromItem()``, ``select.getWhere()``. Once the tree gets deeper than a couple of levels, stop casting by hand and use :ref:`Use the Visitor Patterns`.
 
 
+DROP INDEX owners
+-----------------
+
+``DROP INDEX ix ON app.t`` exposes ``app.t`` through ``Drop.getTable()``;
+``getName()`` continues to identify the index. The owner is populated for the
+single-index ON form used by MySQL and SQL Server. A DROP INDEX without ON,
+as in PostgreSQL, has a null owner: resolving the index's table requires a catalog.
+SQL Server's multi-owner list and WITH options are outside this extension.
+
+``getParameters()`` includes ON and the rendered table as a legacy token snapshot
+when a structured owner exists. Mutate ``getTable()`` or use ``setTable()`` to
+update the owner; ``addParameters()`` appends options without losing it.
+``setTable(null)`` removes ON, while ``setParameters()`` replaces the entire
+parameter clause with raw tokens and clears the structured owner. Raw parameter
+setters do not parse SQL or infer a table.
+
+Table discovery and statement visitors traverse DROP TABLE/VIEW targets and
+explicit index owners, without reporting catalog-only object names as tables.
+The statement deparser delegates real tables to its configured select deparser.
+MySQL ALGORITHM/LOCK tokens retain their order and optional equals signs.
+
 Inspect PostgreSQL schema statements
 ------------------------------------