第三部分：精通篇 - 高级应用与技巧 (Expert)

模块五：使用 Visitor 模式遍历和修改 SQL

到目前为止，我们主要通过直接调用 JSqlParser 解析后对象（如 PlainSelect, Column, Function 等）的 get 方法来访问 SQL 语句的各个部分。当 SQL 结构变得复杂，或者我们需要对 AST (抽象语法树) 进行系统性的遍历或修改时，这种直接访问的方式会变得非常繁琐且容易出错。

Visitor 设计模式 提供了一种更优雅、更灵活的方式来处理复杂的对象结构（如 JSqlParser 的 AST）。

1. Visitor 设计模式简介

1.1 为什么需要 Visitor 模式？

想象一下，你需要对一个复杂的 SQL AST 执行多种不同的操作：

• 操作1： 收集所有用到的表名。
• 操作2： 收集所有用到的列名。
• 操作3： 找到所有类型为 VARCHAR 的列定义。
• 操作4： 将所有表名转换为大写。
• 操作5： 在所有 SELECT 语句的 WHERE 条件中添加一个 tenant_id = 'xxx' 的过滤。

如果我们将这些操作逻辑直接写在 AST 节点类（如 Table, Column, Select）中，会导致这些类变得非常臃肿，并且每次增加新的操作都需要修改这些核心类，违反了“开闭原则”（对扩展开放，对修改关闭）。

Visitor 模式通过以下方式解决了这个问题：

• 将操作与对象结构分离： 它允许你在不修改对象结构（AST 节点类）的前提下，定义新的操作。
• 双重分发 (Double Dispatch)： Visitor 模式的核心机制。当一个 Visitor 访问一个元素时：
  1. 元素调用 Visitor 的特定方法，并将自身 (element) 作为参数传递过去 (element.accept(visitor))。
  2. 在 Visitor 的方法内部，通常会回调元素的一个特定方法，并将 Visitor 自身作为参数 (visitor.visit(this_specific_element_type))。这样，Visitor 就知道当前正在访问的具体元素类型，从而执行相应的操作。

1.2 Visitor 模式的核心思想

• Visitor (访问者) 接口/抽象类： 定义了一系列 visit() 方法，每个方法对应 AST 中一种具体类型的节点 (Element)。例如，visit(Table table), visit(Column column), visit(Select select)。
• ConcreteVisitor (具体访问者) 类： 实现 Visitor 接口，为每个 visit() 方法提供具体的业务逻辑。不同的 ConcreteVisitor 可以实现不同的操作（如收集表名、修改列名等）。
• Element (元素) 接口/抽象类： 定义了一个 accept(Visitor visitor) 方法，接收一个 Visitor 对象作为参数。
• ConcreteElement (具体元素) 类： 实现 Element 接口。其 accept() 方法通常会调用 Visitor 对应当前元素类型的 visit() 方法，例如 visitor.visit(this)。

在 JSqlParser 中，Statement, Expression, FromItem 等接口和它们的实现类扮演了 Element 的角色，而 JSqlParser 提供了一系列 Visitor 接口供我们实现。

2. JSqlParser 中的 Visitor 接口

JSqlParser 为其 AST 的不同部分提供了专门的 Visitor 接口。通常，每个主要的 AST 节点接口都有一个对应的 Visitor 接口。为了方便使用，JSqlParser 还为每个 Visitor 接口提供了一个默认的适配器类 (Adapter)，该适配器类为 Visitor 接口中的所有方法提供了空实现。这样，我们在创建自定义 Visitor 时，只需要继承适配器类并覆盖我们感兴趣的节点类型的 visit() 方法即可，而无需实现所有方法。

以下是一些核心的 Visitor 接口及其对应的适配器：

• StatementVisitor / StatementVisitorAdapter:
  用于访问各种类型的 SQL 语句 (Statement 的实现类)。
  • visit(Select select)
  • visit(Insert insert)
  • visit(Update update)
  • visit(Delete delete)
  • visit(CreateTable createTable)
  • visit(Drop drop)
  • visit(Alter alter)
  • visit(Truncate truncate)
  • ... 等等
• SelectVisitor / SelectVisitorAdapter:
  用于访问 SelectBody 的不同实现。
  • visit(PlainSelect plainSelect)
  • visit(SetOperationList setOpList) (用于 UNION, INTERSECT 等)
  • visit(ValuesStatement valuesStatement)
• ExpressionVisitor / ExpressionVisitorAdapter:
  这是最常用和最复杂的 Visitor 之一，用于访问各种类型的表达式 (Expression 的实现类)。
  • visit(Column tableColumn)
  • visit(StringValue value)
  • visit(LongValue value)
  • visit(DoubleValue value)
  • visit(DateValue value)
  • visit(TimestampValue value)
  • visit(NullValue value)
  • visit(Function function)
  • visit(SubSelect subSelect)
  • visit(AndExpression andExpression)
  • visit(OrExpression orExpression)
  • visit(EqualsTo equalsTo)
  • visit(GreaterThan greaterThan)
  • visit(LikeExpression likeExpression)
  • visit(InExpression inExpression)
  • visit(Between between)
  • visit(CaseExpression caseExpression)
  • visit(WhenClause whenClause)
  • ... 等等，几乎每种表达式都有对应的 visit 方法。
• FromItemVisitor / FromItemVisitorAdapter:
  用于访问 FROM 子句中的项 (FromItem 的实现类)。
  • visit(Table tableName)
  • visit(SubSelect subSelect)
  • visit(SubJoin subjoin)
  • visit(LateralSubSelect lateralSubSelect)
• ItemsListVisitor / ItemsListVisitorAdapter:
  用于访问 INSERT 语句中的值列表或 IN 表达式中的列表 (ItemsList 的实现类)。
  • visit(ExpressionList expressionList) (用于 VALUES (...) 或 IN (...))
  • visit(SubSelect subSelect) (用于 INSERT INTO ... SELECT ... 或 IN (SELECT ...) )
  • visit(MultiExpressionList multiExprList) (用于多行 VALUES 的旧版处理)
  • visit(RowConstructor rowConstructor) (JSqlParser 4.7+ 用于 VALUES (r1c1, r1c2), (r2c1, r2c2))
• 其他辅助 Visitor 接口:
  • SelectBodyVisitor (与 SelectVisitor 类似，但可能是旧版或特定用途)
  • OrderByVisitor / OrderByVisitorAdapter
  • GroupByVisitor / GroupByVisitorAdapter
  • PivotVisitor / PivotVisitorAdapter (用于 PIVOT 子句)

如何触发 Visitor 的访问：

每个 JSqlParser AST 节点（如 Statement, PlainSelect, Column, Table 等）都实现了 accept(Visitor visitor) 方法。当你调用一个节点的 accept() 方法并传入你的 Visitor 实例时，遍历就开始了。

// 假设 statement 是一个已解析的 Statement 对象
// tablesNamesCollector 是一个自定义的 Visitor，用于收集表名

TablesNamesCollector tablesNamesCollector = new TablesNamesCollector();
statement.accept(tablesNamesCollector); // 开始遍历整个 Statement AST

// 遍历完成后，可以从 tablesNamesCollector 中获取结果
List<String> tableNames = tablesNamesCollector.getTableNames();

在 accept() 方法内部，该节点会调用 Visitor 对应其自身类型的 visit() 方法。例如，如果 statement 是一个 Select 对象，statement.accept(tablesNamesCollector) 内部会执行类似 tablesNamesCollector.visit(this) 的调用，其中 this 指向该 Select 对象。

3. 实现自定义 Visitor：遍历 AST

遍历 AST 的主要目的是收集信息或对节点执行某些只读操作。

步骤：

1. 创建一个类并继承相应的 VisitorAdapter (例如 StatementVisitorAdapter, ExpressionVisitorAdapter)。
2. 覆盖你感兴趣的节点的 visit() 方法。
3. 在 visit() 方法中实现你的逻辑。 例如，将收集到的信息存储在 Visitor 类的成员变量中。
4. 确保递归访问子节点（如果需要）。 这是关键！如果一个节点包含其他也需要被访问的子节点，你需要在当前节点的 visit() 方法中显式调用子节点的 accept(this) 方法，将当前 Visitor 传递下去。

示例1：收集 SQL 语句中所有用到的表名

我们需要访问 FROM 子句中的表 (Table) 和 JOIN 子句中的表。

import com.github.jsqlparser.schema.Table;
import com.github.jsqlparser.statement.select.*;
import com.github.jsqlparser.statement.Statement;
import com.github.jsqlparser.statement.insert.Insert;
import com.github.jsqlparser.statement.update.Update;
import com.github.jsqlparser.statement.delete.Delete;
import com.github.jsqlparser.util.deparser.StatementDeParser; // For simple toString
import com.github.jsqlparser.parser.CCJSqlParserUtil;
import com.github.jsqlparser.JSQLParserException;

import java.util.ArrayList;

import java.util.HashSet;  
import java.util.List;  
import java.util.Set;

class TablesNamesCollector extends SelectVisitorAdapter implements FromItemVisitor {  
    private Set<String> tableNames = new HashSet<>();

    public Set<String> getTableNames() {  
        return tableNames;  
    }

    // --- FromItemVisitor Implementation ---  
    @Override  
    public void visit(Table tableName) { // 当访问到一个 Table 对象时被调用  
        tableNames.add(tableName.getFullyQualifiedName());  
    }

    @Override  
    public void visit(SubSelect subSelect) { // 如果 FROM item 是子查询  
        // 需要递归访问子查询的 SelectBody  
        if (subSelect.getSelectBody() != null) {  
            subSelect.getSelectBody().accept(this); // `this` 就是当前的 TablesNamesCollector  
        }  
    }

    @Override  
    public void visit(SubJoin subjoin) { // 如果 FROM item 是一个 SubJoin  
        if (subjoin.getLeft() != null) {  
            subjoin.getLeft().accept(this);  
        }  
        if (subjoin.getJoinList() != null) {  
            for (Join join : subjoin.getJoinList()) {  
                if (join.getRightItem() != null) {  
                    join.getRightItem().accept(this);  
                }  
            }  
        }  
    }

    @Override  
    public void visit(LateralSubSelect lateralSubSelect) {  
        if (lateralSubSelect.getSubSelect() != null && lateralSubSelect.getSubSelect().getSelectBody() != null) {  
            lateralSubSelect.getSubSelect().getSelectBody().accept(this);  
        }  
    }

    // --- SelectVisitorAdapter Overrides ---  
    @Override  
    public void visit(PlainSelect plainSelect) {  
        // 访问 FROM item  
        if (plainSelect.getFromItem() != null) {  
            plainSelect.getFromItem().accept(this); // `this` is TablesNamesCollector which implements FromItemVisitor  
        }

        // 访问 JOINs  
        if (plainSelect.getJoins() != null) {  
            for (Join join : plainSelect.getJoins()) {  
                if (join.getRightItem() != null) {  
                    join.getRightItem().accept(this); // `this` is TablesNamesCollector  
                }  
            }  
        }

        // 如果 WHERE 条件中可能包含子查询，也需要访问  
        if (plainSelect.getWhere() != null) {  
            // 为了访问表达式中的子查询，我们需要一个 ExpressionVisitor  
            // 这里简化处理，实际应用中可能需要一个组合的 Visitor 或在 ExpressionVisitor 中处理  
            // plainSelect.getWhere().accept(anExpressionVisitor);  
        }  
        // 同样，SelectItems, GroupBy, Having, OrderBy 中的表达式也可能包含子查询  
    }

    @Override  
    public void visit(SetOperationList setOpList) { // 处理 UNION, INTERSECT 等  
        if (setOpList.getSelects() != null) {  
            for (SelectBody selectBody : setOpList.getSelects()) {  
                selectBody.accept(this);  
            }  
        }  
    }

    // 如果还需要从 INSERT, UPDATE, DELETE 中提取表名，  
    // 则需要让 TablesNamesCollector 实现 StatementVisitor  
    // 并在 visit(Insert insert), visit(Update update), visit(Delete delete) 中提取表名  
    // 例如:  
    // public void visit(Insert insert) {  
    //     if (insert.getTable() != null) {  
    //         tableNames.add(insert.getTable().getFullyQualifiedName());  
    //     }  
    //     if (insert.getSelect() != null) { // For INSERT INTO ... SELECT  
    //         insert.getSelect().getSelectBody().accept(this);  
    //     }  
    // }  
}

public class VisitorTraversalDemo {  
    public static void main(String[] args) throws JSQLParserException {  
        String sql = "SELECT e.name, d.dept_name " +  
                     "FROM employees e " +  
                     "JOIN departments d ON e.dept_id = d.id " +  
                     "LEFT JOIN (SELECT manager_id, COUNT(*) AS managed_count FROM employees GROUP BY manager_id) AS m_counts ON e.emp_id = m_counts.manager_id " +  
                     "WHERE e.salary > (SELECT AVG(salary) FROM employees WHERE dept_id = e.dept_id) " +  
                     "UNION " +  
                     "SELECT 'N/A', dept_name FROM departments WHERE location = 'Remote'";

        Statement statement = CCJSqlParserUtil.parse(sql);

        TablesNamesCollector collector = new TablesNamesCollector();

        // 如果只想处理 SELECT 语句的表名  
        if (statement instanceof Select) {  
            ((Select) statement).getSelectBody().accept(collector);  
        }  
        // 如果想处理所有类型的语句 (需要 TablesNamesCollector 实现 StatementVisitor)  
        // statement.accept(collector);

        System.out.println("Collected Table Names: " + collector.getTableNames());  
        // 输出可能包含: [employees, departments] (子查询中的 employees 也会被收集)  
        // 注意：这个简单的 collector 没有处理 WHERE 子查询中的表名。  
        // 要处理表达式中的子查询，通常需要一个 ExpressionVisitor。  
    }  
}

要点：

• TablesNamesCollector 同时实现了 SelectVisitor (通过继承 SelectVisitorAdapter) 和 FromItemVisitor。
• 在 visit(PlainSelect plainSelect) 中，我们调用 plainSelect.getFromItem().accept(this) 和 join.getRightItem().accept(this)。由于 this (即 TablesNamesCollector 实例) 实现了 FromItemVisitor，这将触发 FromItemVisitor 中相应的 visit(Table table) 或 visit(SubSelect subSelect) 方法。
• 对于 SubSelect，我们递归调用 subSelect.getSelectBody().accept(this) 来处理子查询。
• 局限性： 上述示例没有处理表达式（如 WHERE 条件、SELECT 列中的子查询）中可能出现的表名。要做到这一点，你需要一个 ExpressionVisitor，并在其中处理 SubSelect 表达式。

示例2：收集所有列引用 (需要 ExpressionVisitor)

import com.github.jsqlparser.expression.ExpressionVisitorAdapter;  
import com.github.jsqlparser.schema.Column;  
// ... other imports from previous example

class ColumnNamesCollector extends ExpressionVisitorAdapter {  
    private Set<String> columnNames = new HashSet<>();

    public Set<String> getColumnNames() {  
        return columnNames;  
    }

    @Override  
    public void visit(Column column) { // 当访问到一个 Column 对象时被调用  
        columnNames.add(column.getFullyQualifiedName());  
    }

    // 为了遍历整个语句，通常将 ExpressionVisitor 与 StatementVisitor/SelectVisitor 结合使用  
    // 例如，在 SelectVisitorAdapter 的 visit(PlainSelect) 中:  
    // if (plainSelect.getWhere() != null) {  
    //     plainSelect.getWhere().accept(this); // `this` 也是 ColumnNamesCollector  
    // }  
    // for (SelectItem item : plainSelect.getSelectItems()) {  
    //     item.accept(this); // SelectItem 也需要一个 Visitor 或直接访问其 Expression  
    // }  
}

在主程序中，你需要确保 ColumnNamesCollector 被传递到所有包含表达式的地方。这通常意味着你的主 Visitor (如 SelectVisitor) 需要持有 ExpressionVisitor 的实例，或者让主 Visitor 同时实现 ExpressionVisitor。

简化演示 (实际应用需要更完整的遍历逻辑):

public static void main(String[] args) throws JSQLParserException {  
    String sql = "SELECT name, age FROM users WHERE id = 1 AND status = 'active'";  
    Select select = (Select) CCJSqlParserUtil.parse(sql);  
    PlainSelect plainSelect = (PlainSelect) select.getSelectBody();  
 
    ColumnNamesCollector columnCollector = new ColumnNamesCollector();  
 
    // 访问 WHERE 条件中的列  
    if (plainSelect.getWhere() != null) {  
        plainSelect.getWhere().accept(columnCollector);  
    }  
 
    // 访问 SELECT items 中的列  
    for (SelectItem item : plainSelect.getSelectItems()) {  
        if (item instanceof SelectExpressionItem) {  
            ((SelectExpressionItem) item).getExpression().accept(columnCollector);  
        }  
    }  
    System.out.println("Collected Column Names: " + columnCollector.getColumnNames());  
}

组合 Visitor：
通常，一个复杂的操作可能需要访问 AST 的多个不同部分（语句、表达式、From项等）。你有几种方式来组织：

1. 一个 Visitor 实现多个 Visitor 接口： 如 TablesNamesCollector 实现了 SelectVisitor 和 FromItemVisitor。
2. 在一个 Visitor 内部实例化并使用另一个 Visitor： 例如，你的 SelectVisitor 在 visit(PlainSelect) 时，可以创建一个 ExpressionVisitor 的实例来专门处理 WHERE 条件中的表达式。
3. Visitor 链： 第一个 Visitor 处理一部分，然后将其结果或修改后的 AST 传递给下一个 Visitor。

4. 实现自定义 Visitor：修改 AST

使用 Visitor 修改 AST 比遍历更复杂，因为你需要小心处理对象的引用和可变性。JSqlParser 的 AST 节点通常是可变的。

修改步骤：

1. 与遍历类似，创建 Visitor 并覆盖 visit() 方法。
2. 在 visit() 方法中，直接修改 AST 节点的属性。 例如，table.setName("NEW_" + table.getName())。
3. 注意副作用： 修改是直接在原始 AST 对象上进行的。
4. 替换节点： 有时你可能需要用一个全新的节点替换掉 AST 中的某个现有节点。这比较棘手，因为 JSqlParser 的 AST 节点通常没有提供 setParent() 或类似的方法来轻易替换自己。你通常需要在父节点的 visit() 方法中，当子节点被访问和修改（或创建新节点）后，用新的子节点去更新父节点对该子节点的引用（例如，调用父节点的 setWhere(newWhereExpression)）。

示例：给所有 SELECT 语句的 WHERE 条件中自动添加一个过滤条件

假设我们要为所有 SELECT 语句添加 AND tenant_id = 'XYZ'。

import com.github.jsqlparser.expression.Expression;
import com.github.jsqlparser.expression.LongValue;
import com.github.jsqlparser.expression.Parenthesis;
import com.github.jsqlparser.expression.StringValue;
import com.github.jsqlparser.expression.operators.conditional.AndExpression;
import com.github.jsqlparser.expression.operators.relational.EqualsTo;
import com.github.jsqlparser.schema.Column;
import com.github.jsqlparser.statement.select.PlainSelect;
import com.github.jsqlparser.statement.select.Select;
import com.github.jsqlparser.statement.select.SelectVisitorAdapter;
import com.github.jsqlparser.statement.select.SetOperationList;
import com.github.jsqlparser.util.deparser.StatementDeParser;
// ... other imports

class AddTenantFilterVisitor extends SelectVisitorAdapter {
private String tenantId;
private String tenantColumnName;

public AddTenantFilterVisitor(String tenantColumnName, String tenantId) {  
    this.tenantColumnName \= tenantColumnName;  
    this.tenantId \= tenantId;  
}

@Override  
public void visit(PlainSelect plainSelect) {  
    Expression existingWhere \= plainSelect.getWhere();  
      
    // 创建新的条件: tenant\_column \= 'tenant\_value'  
    EqualsTo tenantCondition \= new EqualsTo();  
    tenantCondition.setLeftExpression(new Column(tenantColumnName)); // tenant\_id  
    tenantCondition.setRightExpression(new StringValue(tenantId)); // 'XYZ' (如果是数字用 LongValue)

    if (existingWhere \== null) {  
        // 如果没有 WHERE 条件，直接设置为新条件  
        plainSelect.setWhere(tenantCondition);  
    } else {  
        // 如果已有 WHERE 条件，用 AND 连接  
        // 为了确保优先级正确，最好将原有条件用括号括起来 (如果它不是一个简单的 AndExpression)  
        Expression newWhere;  
        if (existingWhere instanceof AndExpression || existingWhere instanceof Parenthesis) {  
             newWhere \= new AndExpression(existingWhere, tenantCondition);  
        } else {  
             newWhere \= new AndExpression(new Parenthesis(existingWhere), tenantCondition);  
        }  
        plainSelect.setWhere(newWhere);  
    }

    // 如果 PlainSelect 包含子查询 (例如在 FROM, WHERE, SELECT list 中)，  
    // 你需要确保这些子查询的 SelectBody 也被这个 Visitor 访问。  
    // 这通常意味着在访问这些子查询的表达式时，也调用 accept(this)。  
    // 例如，如果 FromItem 是 SubSelect:  
    // if (plainSelect.getFromItem() instanceof SubSelect) {  
    //     ((SubSelect) plainSelect.getFromItem()).getSelectBody().accept(this);  
    // }  
    // 同样，也需要处理 WHERE 条件中的子查询 (通过 ExpressionVisitor)  
    // 和 SELECT items 中的子查询。  
}

@Override  
public void visit(SetOperationList setOpList) {  
    // 对 UNION/INTERSECT 等操作的每个 SelectBody 都应用此逻辑  
    if (setOpList.getSelects() \!= null) {  
        for (SelectBody selectBody : setOpList.getSelects()) {  
            selectBody.accept(this);  
        }  
    }  
}  

}

public class VisitorModificationDemo {
public static void main(String[] args) throws JSQLParserException {
String sql1 = "SELECT name, salary FROM employees WHERE department = 'Sales'";
String sql2 = "SELECT product_name FROM products";
String sql3 = "SELECT c.name, o.order_date FROM customers c JOIN orders o ON c.id = o.customer_id WHERE o.amount > 1000";
String sqlUnion = "SELECT name FROM tableA WHERE id > 10 UNION SELECT name FROM tableB WHERE category = 'X'";

    AddTenantFilterVisitor tenantVisitor \= new AddTenantFilterVisitor("tenant\_id", "XYZ\_TENANT");

    Statement stmt1 \= CCJSqlParserUtil.parse(sql1);  
    if (stmt1 instanceof Select) {  
        ((Select) stmt1).getSelectBody().accept(tenantVisitor);  
    }  
    System.out.println("Modified SQL 1: " \+ stmt1);  
    // Expected: SELECT name, salary FROM employees WHERE (department \= 'Sales') AND tenant\_id \= 'XYZ\_TENANT'

    Statement stmt2 \= CCJSqlParserUtil.parse(sql2);  
    if (stmt2 instanceof Select) {  
        ((Select) stmt2).getSelectBody().accept(tenantVisitor);  
    }  
    System.out.println("Modified SQL 2: " \+ stmt2);  
    // Expected: SELECT product\_name FROM products WHERE tenant\_id \= 'XYZ\_TENANT'

    Statement stmt3 \= CCJSqlParserUtil.parse(sql3);  
    if (stmt3 instanceof Select) {  
        ((Select) stmt3).getSelectBody().accept(tenantVisitor);  
    }  
    System.out.println("Modified SQL 3: " \+ stmt3);  
    // Expected: SELECT c.name, o.order\_date FROM customers c JOIN orders o ON c.id \= o.customer\_id WHERE (o.amount \> 1000\) AND tenant\_id \= 'XYZ\_TENANT'

    Statement stmtUnion \= CCJSqlParserUtil.parse(sqlUnion);  
    if (stmtUnion instanceof Select) {  
        ((Select) stmtUnion).getSelectBody().accept(tenantVisitor);  
    }  
    System.out.println("Modified SQL Union: " \+ stmtUnion);  
    // Expected: (SELECT name FROM tableA WHERE (id \> 10\) AND tenant\_id \= 'XYZ\_TENANT') UNION (SELECT name FROM tableB WHERE (category \= 'X') AND tenant\_id \= 'XYZ\_TENANT')  
}  

}

注意事项：

• 递归修改： 上述 AddTenantFilterVisitor 示例仅处理了顶层的 PlainSelect 和 SetOperationList。在一个真实的、复杂的 SQL 中，子查询可能出现在 FROM 子句、WHERE 条件、SELECT 列、JOIN ON 条件等多个地方。你需要确保你的 Visitor 能够递归地访问并修改这些嵌套的 SelectBody。这通常涉及到让你的 Visitor 也实现 ExpressionVisitor 和 FromItemVisitor，并在访问 SubSelect (作为表达式或 FromItem) 时，对其 SelectBody 调用 accept(this)。
• 深拷贝： 如果你不想修改原始 AST，而想创建一个修改后的副本，你需要自己实现深拷贝逻辑，因为 JSqlParser 本身不直接提供完整的 AST 深拷贝功能。这通常很复杂。
• 引用完整性： 当替换节点时，要确保所有指向旧节点的引用都被更新为指向新节点。

5. JSqlParser 提供的 DeParser (反向解析)

修改完 AST 后，我们通常需要将其转换回 SQL 字符串。JSqlParser 提供了 DeParser (反向解析器) 来实现这个功能。

核心的 DeParser 类有：

• com.github.jsqlparser.util.deparser.StatementDeParser
• com.github.jsqlparser.util.deparser.SelectDeParser
• com.github.jsqlparser.util.deparser.ExpressionDeParser

这些 DeParser 本身也是 Visitor！它们通过访问 AST 节点，并将每个节点转换成其对应的 SQL 字符串片段，然后将这些片段拼接起来。

基本用法：

当你调用一个 AST 节点的 toString() 方法时 (例如 statement.toString())，JSqlParser 内部实际上就是在使用一个默认的 DeParser 实例来生成 SQL 字符串。

Statement modifiedStatement = ... // 经过 Visitor 修改后的 AST
String newSql = modifiedStatement.toString();
System.out.println(newSql);

自定义 DeParser 的行为：

DeParser 类通常接受一个 StringBuilder 作为构造参数（或通过 setBuffer() 方法设置），用于构建输出的 SQL 字符串。它们还可能提供一些配置选项或方法，允许你定制输出 SQL 的格式（例如，关键字大小写、缩进等），但这方面的功能相对有限。

如果你需要高度定制化的 SQL 输出格式，你可能需要：

1. 继承 JSqlParser 提供的 DeParser 类，并覆盖某些 visit() 方法来改变特定节点的输出行为。
2. 完全实现自己的 DeParser (实现相应的 Visitor 接口)，但这工作量较大。

DeParser 如何与修改 Visitor 配合：

1. 使用你的自定义修改 Visitor (如 AddTenantFilterVisitor) 访问并修改 AST。
   Statement stmt = CCJSqlParserUtil.parse(originalSql);
   AddTenantFilterVisitor modifier = new AddTenantFilterVisitor("tenant_id", "ABC");
   stmt.accept(modifier); // 或者 selectBody.accept(modifier)

2. 直接调用修改后 AST 节点的 toString() 方法即可得到新的 SQL 字符串。
   String modifiedSql = stmt.toString();

或者，如果你想更精细地控制 DeParsing 过程：

Statement stmt = CCJSqlParserUtil.parse(originalSql);
// ... (修改 stmt 的逻辑) ...

StringBuilder buffer = new StringBuilder();
// StatementDeParser 需要一个 ExpressionDeParser 和一个 SelectDeParser 作为参数
// 通常可以创建默认的实例
ExpressionDeParser expressionDeParser = new ExpressionDeParser();
SelectDeParser selectDeParser = new SelectDeParser(expressionDeParser, buffer);
expressionDeParser.setSelectVisitor(selectDeParser); // 解决循环依赖
expressionDeParser.setBuffer(buffer);

StatementDeParser deParser = new StatementDeParser(expressionDeParser, selectDeParser, buffer);
stmt.accept(deParser);

String newSqlString = buffer.toString();

对于大多数场景，直接调用 statement.toString() 已经足够。

动手实验 5：

1. 遍历任务 - 统计函数调用：
   • 编写一个 Visitor (例如，继承 ExpressionVisitorAdapter)，用于收集 SQL 语句中所有被调用的函数名称及其参数数量。
   • 例如，对于 SELECT COUNT(*), SUBSTRING(name, 1, 3), NOW() FROM users，应能收集到：
     • COUNT (1 个参数，* 算一个)
     • SUBSTRING (3 个参数)
     • NOW (0 个参数)
   • 你需要一个主 Visitor (如 SelectVisitorAdapter) 来遍历 SELECT 语句的各个部分 (select items, where, having 等)，并在遇到表达式时，调用你的函数收集 Visitor。
2. 修改任务 - 表名统一添加前缀：
   • 编写一个 Visitor (例如，继承 StatementVisitorAdapter 并实现 FromItemVisitor)，将 SQL 语句中所有引用的表名（包括 FROM 子句和 JOIN 子句中的表）统一添加一个前缀，例如 DEV_。
   • 例如，SELECT * FROM users JOIN orders ON users.id = orders.user_id 应修改为 SELECT * FROM DEV_users JOIN DEV_orders ON DEV_users.id = DEV_orders.user_id。
   • 注意： 你还需要修改 Column 对象中的表名引用 (例如 users.id -> DEV_users.id)。这需要你的 Visitor 也处理 Column 表达式。
   • 使用 DeParser 将修改后的 AST 转换回 SQL 字符串并打印。
3. (挑战) 修改任务 - 参数化敏感字面量：
   • 编写一个 Visitor，查找 WHERE 条件中的字符串字面量或数字字面量（例如，name = 'Alice' 或 age = 30），并将它们替换为 JDBC 参数占位符 ?。
   • 收集被替换掉的原始值，按顺序存储。
   • 例如，SELECT * FROM users WHERE name = 'Bob' AND city = 'London'
     修改为 SELECT * FROM users WHERE name = ? AND city = ?
     收集到的值为 ['Bob', 'London']。
   • 这需要一个 ExpressionVisitor，并且在修改时要小心处理父节点对子节点的引用。

模块五小结：

在本模块中，我们深入探讨了 Visitor 设计模式及其在 JSqlParser 中的应用：

• 理解了 Visitor 模式如何将操作与对象结构分离，方便对 AST 进行扩展操作。
• 熟悉了 JSqlParser 提供的核心 Visitor 接口 (StatementVisitor, SelectVisitor, ExpressionVisitor, FromItemVisitor 等) 及其适配器类。
• 掌握了如何通过继承 VisitorAdapter 并覆盖 visit() 方法来实现自定义的 AST 遍历逻辑，以收集信息。
• 学习了如何通过在 visit() 方法中直接修改 AST 节点属性来实现对 SQL 结构的修改，并了解了其中的注意事项（递归修改、节点替换的复杂性）。
• 了解了 JSqlParser 的 DeParser 如何将 AST 反向解析为 SQL 字符串，以及如何与修改 Visitor 配合使用。

Visitor 模式是使用 JSqlParser 进行高级 SQL 分析和操作的基石。熟练掌握它将使你能够处理非常复杂的 SQL 处理任务。