快捷導(dǎo)航

Java JSqlParser解析,修改和生成SQL語句的實用技巧

更新時間：2025年04月09日 08:48:56 作者：m0_74825360

JSQLParser 是一個強大的開源 Java 庫,用于解析 SQL 并提供語法樹操作功能,本文將詳細(xì)介紹如何使用 JSQLParser,并提供常見使用場景的代碼示例,希望對大家有所幫助

SQL解析器

Java SQL 解析器通常用于處理 SQL 查詢語句的解析和分析。以下是一些常見情況，你可能需要使用 Java SQL 解析器：

構(gòu)建數(shù)據(jù)庫管理工具：如果你正在開發(fā)一個數(shù)據(jù)庫管理工具，如數(shù)據(jù)庫客戶端或管理界面，你可能需要使用 Java SQL 解析器來解析用戶輸入的 SQL 查詢，并執(zhí)行相應(yīng)的操作，如執(zhí)行查詢、更新數(shù)據(jù)庫結(jié)構(gòu)等。

自定義 SQL 解析和執(zhí)行邏輯：有時候，標(biāo)準(zhǔn)的數(shù)據(jù)庫接口（如 JDBC）可能無法完全滿足你的需求。在這種情況下，你可以使用 Java SQL 解析器來解析 SQL 查詢，并編寫自定義的執(zhí)行邏輯，以實現(xiàn)更復(fù)雜的功能或?qū)崿F(xiàn)特定的需求。

實現(xiàn)數(shù)據(jù)庫查詢優(yōu)化器：如果你對數(shù)據(jù)庫查詢優(yōu)化感興趣，并希望深入了解查詢優(yōu)化器的工作原理，你可以使用 Java SQL 解析器來解析 SQL 查詢，并基于解析結(jié)果實現(xiàn)自己的查詢優(yōu)化器。

實現(xiàn)自定義的 SQL 分析工具：有時候，你可能需要對大量的 SQL 查詢進(jìn)行分析，以了解查詢的模式、性能瓶頸等。在這種情況下，你可以使用 Java SQL 解析器來解析 SQL 查詢，并編寫自定義的分析邏輯，以實現(xiàn)你的分析需求。

實現(xiàn) SQL 注入檢測工具：SQL 注入是常見的安全漏洞之一，為了防止 SQL 注入攻擊，你可以使用 Java SQL 解析器來解析用戶輸入的 SQL 查詢，并檢測其中是否包含潛在的注入漏洞。

總的來說，Java SQL 解析器在需要對 SQL 查詢進(jìn)行解析、分析和定制化處理的場景下非常有用，它可以幫助你實現(xiàn)各種數(shù)據(jù)庫相關(guān)的功能和工具。

常用的解析器

Java 中有一些庫和框架可以用于 SQL 解析，其中一些主要的包括：

1.JSqlParser：這是一個流行的 Java 庫，用于解析和操作 SQL 語句。它可以將 SQL 語句解析為 Java 對象表示形式，使得可以輕松地對 SQL 進(jìn)行分析、修改和生成。JSqlParser 支持多種 SQL 方言，包括 ANSI SQL、MySQL、Oracle 等。

2.ANTLR：ANTLR（Another Tool for Language Recognition）是一個強大的語言識別器生成器，可以用于構(gòu)建解析器和編譯器。通過編寫相應(yīng)的語法規(guī)則，可以使用 ANTLR 生成用于解析 SQL 的 Java 代碼。ANTLR 支持多種語言和平臺，并且具有廣泛的應(yīng)用領(lǐng)域。

3.Apache Calcite：Apache Calcite 是一個開源的 SQL 解析、優(yōu)化和查詢引擎。它提供了一組用于解析 SQL 的 Java 類庫，并且可以將 SQL 轉(zhuǎn)換為抽象語法樹（AST），從而進(jìn)行進(jìn)一步的查詢優(yōu)化和執(zhí)行計劃生成。

4.SQLJocky：SQLJocky 是一個用于解析和執(zhí)行 SQL 查詢的 Java 庫，主要用于與 MySQL 數(shù)據(jù)庫進(jìn)行交互。它提供了一組 API，可以直接在 Java 代碼中構(gòu)建和執(zhí)行 SQL 查詢，從而簡化了與數(shù)據(jù)庫的交互過程。

本文我們選取最具代表性的 JSqlParser 來看看 SQL 解析器的使用。

JSqlParser

官網(wǎng)文檔：How to use it - JSQLParser 4.9 documentation

JSqlParser 是一個流行的 Java SQL 解析器庫，它提供了強大的功能來解析、分析和操作 SQL 查詢語句。以下是關(guān)于 JSqlParser 的一些重要特性和用法：

支持多種 SQL 方言：JSqlParser 支持多種常見的 SQL 方言，包括標(biāo)準(zhǔn)的 SQL92、SQL99，以及一些特定數(shù)據(jù)庫的方言，如MySQL、Oracle、PostgreSQL等。
解析 SQL 查詢：JSqlParser 可以解析各種類型的 SQL 查詢語句，包括 SELECT、INSERT、UPDATE、DELETE 等，以及相應(yīng)的子句和表達(dá)式。
構(gòu)建查詢語法樹：JSqlParser 可以將解析后的 SQL 查詢語句轉(zhuǎn)換為語法樹形式，這使得開發(fā)人員可以輕松地遍歷和操作查詢的各個部分。
修改查詢語句：通過操作查詢語法樹，開發(fā)人員可以對查詢語句進(jìn)行修改，如添加新的條件、修改表名、更改列名等。
生成 SQL 查詢：除了解析和修改現(xiàn)有的 SQL 查詢語句外，JSqlParser 還提供了生成 SQL 查詢語句的功能。開發(fā)人員可以使用 JSqlParser 來構(gòu)建和生成復(fù)雜的 SQL 查詢語句，以滿足特定的需求。
支持 SQL 注入檢測：JSqlParser 可以幫助開發(fā)人員識別和檢測潛在的 SQL 注入漏洞，通過解析用戶輸入的 SQL 查詢并驗證其中的參數(shù)，從而確保查詢的安全性。
廣泛應(yīng)用于數(shù)據(jù)庫工具和框架：由于其強大的功能和易用性，JSqlParser 被廣泛應(yīng)用于各種數(shù)據(jù)庫工具和框架中，如數(shù)據(jù)庫客戶端、ORM 框架、數(shù)據(jù)遷移工具等。

引入依賴

<dependency>
    <groupId>com.github.jsqlparser</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>4.9</version>
</dependency>

測試程序

查詢語句解析

package world.xuewei.sql;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.select.*;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * JSqlParser 測試類
 *
 * @author 薛偉
 */
public class JSqlParserSelectTest {

    public static final String SQL = "SELECT DISTINCT u.id, r.role_name, u.user_name, u.sex, u.email " +
            "FROM t_user u " +
            "LEFT JOIN t_role r ON u.role_id = r.id " +
            "WHERE r.role_name = '管理員' " +
            "ORDER BY u.age DESC " +
            "LIMIT 0,10";

    /**
     * 測試 SQL 解析
     */
    @Test
    public void sqlParseTest() {
        try {
            Select select = (Select) CCJSqlParserUtil.parse(SQL);
            PlainSelect plainSelect = select.getPlainSelect();
            System.out.println("【DISTINCT 子句】：" + plainSelect.getDistinct());
            System.out.println("【查詢字段】：" + plainSelect.getSelectItems());
            System.out.println("【FROM 表】：" + plainSelect.getFromItem());
            System.out.println("【W(wǎng)HERE 子句】：" + plainSelect.getWhere());
            System.out.println("【JOIN 子句】：" + plainSelect.getJoins());
            System.out.println("【LIMIT 子句】：" + plainSelect.getLimit());
            System.out.println("【OFFSET 子句】：" + plainSelect.getOffset());
            System.out.println("【ORDER BY 子句】：" + plainSelect.getOrderByElements());
            System.out.println("--------------------------------------------------------");
            // 取消去重
            plainSelect.setDistinct(null);
            // 修改查詢字段為 *
            List<SelectItem<?>> selectItems = new ArrayList<>();
            selectItems.add(new SelectItem<>(new AllColumns()));
            plainSelect.setSelectItems(selectItems);
            // 修改 WHERE 子句
            EqualsTo equalsTo = new EqualsTo();
            equalsTo.setLeftExpression(new Column("u.id"));
            equalsTo.setRightExpression(new LongValue(1));
            plainSelect.setWhere(equalsTo);
            // 修改 LIMIT 子句
            Limit limit = new Limit();
            limit.setRowCount(new LongValue(5));
            limit.setOffset(new LongValue(0));
            plainSelect.setLimit(limit);
            // 修改排序為 u.age ASC
            OrderByElement orderByElement = new OrderByElement();
            orderByElement.setExpression(new Column("u.age"));
            orderByElement.setAsc(true); // 升序
            plainSelect.setOrderByElements(Collections.singletonList(orderByElement));
            System.out.println("【處理后 SQL】" + plainSelect);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
}

插入語句解析

package world.xuewei.sql;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.insert.Insert;
import org.junit.Test;

/**
 * JSqlParser 測試類
 *
 * @author 薛偉
 */
public class JSqlParserInsertTest {

    public static final String SQL = "INSERT INTO t_user (role_id, user_name, email, age, sex, register_time )
" +
            "VALUES ( 1, 'xw', 'isxuwei@qq.com', 25, '男', '2024-04-12 17:37:18' );";

    /**
     * 測試 SQL 解析
     */
    @Test
    public void sqlParseTest() {
        try {
            Insert insert = (Insert) CCJSqlParserUtil.parse(SQL);
            System.out.println("【插入目標(biāo)表】：" + insert.getTable());
            System.out.println("【插入字段】：" + insert.getColumns());
            System.out.println("【插入值】：" + insert.getValues());
            System.out.println("--------------------------------------------------------");
            ExpressionList<Column> columns = insert.getColumns();
            ExpressionList<Expression> values = (ExpressionList<Expression>) insert.getValues().getExpressions();
            // 字段和值是一一對應(yīng)的，把性別刪除掉
            columns.remove(4);
            values.remove(4);
            // 新增一列狀態(tài)，默認(rèn)為 create
            columns.add(new Column("status"));
            values.add(new StringValue("create"));
            // 更新年齡字段 +1
            Expression expression = values.get(3);
            LongValue longValue = (LongValue) expression;
            longValue.setValue(longValue.getValue() + 1);
            System.out.println("【處理后 SQL】" + insert);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
}

更新語句解析

package world.xuewei.sql;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.statement.update.UpdateSet;
import org.junit.Test;

import java.util.List;

/**
 * JSqlParser 測試類
 *
 * @author 薛偉
 */
public class JSqlParserUpdateTest {

    public static final String SQL = "UPDATE t_user SET email = '373675032@qq.com', phone = '10086' WHERE id = 1";

    /**
     * 測試 SQL 解析
     */
    @Test
    public void sqlParseTest() {
        try {
            Update update = (Update) CCJSqlParserUtil.parse(SQL);
            System.out.println("【更新目標(biāo)表】：" + update.getTable());
            List<UpdateSet> updateSets = update.getUpdateSets();
            for (UpdateSet updateSet : updateSets) {
                System.out.println("【更新字段】：" + updateSet.getColumns());
                System.out.println("【更新字】：" + updateSet.getValues());
            }
            System.out.println("【更新條件】：" + update.getWhere());
            System.out.println("--------------------------------------------------------");
            // 去掉更新手機號
            updateSets.remove(1);
            // 添加更新字段
            UpdateSet updateSet = new UpdateSet();
            updateSet.add(new Column("update_time"), new LongValue(System.currentTimeMillis()));
            updateSets.add(updateSet);
            // 更新 Where 條件
            AndExpression expression = new AndExpression();
            expression.withLeftExpression(update.getWhere());
            EqualsTo equalsTo = new EqualsTo();
            equalsTo.setLeftExpression(new Column("deleted"));
            equalsTo.setRightExpression(new LongValue(0));
            expression.withRightExpression(equalsTo);
            update.setWhere(expression);
            System.out.println("【處理后 SQL】" + update);
        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
}