devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JSqlParser实战指南：解析、修改和生成SQL语句的实用技巧

作者：Guff_9hys | 2024-07-21 08:31:39

赞

踩

jsqlparser

SQL解析器

Java SQL 解析器通常用于处理 SQL 查询语句的解析和分析。以下是一些常见情况，你可能需要使用 Java SQL 解析器：

  1. 构建数据库管理工具：如果你正在开发一个数据库管理工具，如数据库客户端或管理界面，你可能需要使用 Java SQL 解析器来解析用户输入的 SQL 查询，并执行相应的操作，如执行查询、更新数据库结构等。
  2. 自定义 SQL 解析和执行逻辑：有时候，标准的数据库接口（如 JDBC）可能无法完全满足你的需求。在这种情况下，你可以使用 Java SQL 解析器来解析 SQL 查询，并编写自定义的执行逻辑，以实现更复杂的功能或实现特定的需求。
  3. 实现数据库查询优化器：如果你对数据库查询优化感兴趣，并希望深入了解查询优化器的工作原理，你可以使用 Java SQL 解析器来解析 SQL 查询，并基于解析结果实现自己的查询优化器。
  4. 实现自定义的 SQL 分析工具：有时候，你可能需要对大量的 SQL 查询进行分析，以了解查询的模式、性能瓶颈等。在这种情况下，你可以使用 Java SQL 解析器来解析 SQL 查询，并编写自定义的分析逻辑，以实现你的分析需求。
  5. 实现 SQL 注入检测工具：SQL 注入是常见的安全漏洞之一，为了防止 SQL 注入攻击，你可以使用 Java SQL 解析器来解析用户输入的 SQL 查询，并检测其中是否包含潜在的注入漏洞。

总的来说，Java SQL 解析器在需要对 SQL 查询进行解析、分析和定制化处理的场景下非常有用，它可以帮助你实现各种数据库相关的功能和工具。

常用的解析器

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

  1. JSqlParser：这是一个流行的 Java 库，用于解析和操作 SQL 语句。它可以将 SQL 语句解析为 Java 对象表示形式，使得可以轻松地对 SQL 进行分析、修改和生成。JSqlParser 支持多种 SQL 方言，包括 ANSI SQL、MySQL、Oracle 等。
  2. ANTLR：ANTLR（Another Tool for Language Recognition）是一个强大的语言识别器生成器，可以用于构建解析器和编译器。通过编写相应的语法规则，可以使用 ANTLR 生成用于解析 SQL 的 Java 代码。ANTLR 支持多种语言和平台，并且具有广泛的应用领域。
  3. Apache Calcite：Apache Calcite 是一个开源的 SQL 解析、优化和查询引擎。它提供了一组用于解析 SQL 的 Java 类库，并且可以将 SQL 转换为抽象语法树（AST），从而进行进一步的查询优化和执行计划生成。
  4. SQLJocky：SQLJocky 是一个用于解析和执行 SQL 查询的 Java 库，主要用于与 MySQL 数据库进行交互。它提供了一组 API，可以直接在 Java 代码中构建和执行 SQL 查询，从而简化了与数据库的交互过程。

本文我们选取最具代表性的 JSqlParser 来看看 SQL 解析器的使用。

JSqlParser

官网文档：How to use it - JSQLParser 4.9 documentation

JSqlParser 是一个流行的 Java SQL 解析器库，它提供了强大的功能来解析、分析和操作 SQL 查询语句。以下是关于 JSqlParser 的一些重要特性和用法：

  1. 支持多种 SQL 方言：JSqlParser 支持多种常见的 SQL 方言，包括标准的 SQL92、SQL99，以及一些特定数据库的方言，如MySQL、Oracle、PostgreSQL等。
  2. 解析 SQL 查询：JSqlParser 可以解析各种类型的 SQL 查询语句，包括 SELECT、INSERT、UPDATE、DELETE 等，以及相应的子句和表达式。
  3. 构建查询语法树：JSqlParser 可以将解析后的 SQL 查询语句转换为语法树形式，这使得开发人员可以轻松地遍历和操作查询的各个部分。
  4. 修改查询语句：通过操作查询语法树，开发人员可以对查询语句进行修改，如添加新的条件、修改表名、更改列名等。
  5. 生成 SQL 查询：除了解析和修改现有的 SQL 查询语句外，JSqlParser 还提供了生成 SQL 查询语句的功能。开发人员可以使用 JSqlParser 来构建和生成复杂的 SQL 查询语句，以满足特定的需求。
  6. 支持 SQL 注入检测：JSqlParser 可以帮助开发人员识别和检测潜在的 SQL 注入漏洞，通过解析用户输入的 SQL 查询并验证其中的参数，从而确保查询的安全性。
  7. 广泛应用于数据库工具和框架：由于其强大的功能和易用性，JSqlParser 被广泛应用于各种数据库工具和框架中，如数据库客户端、ORM 框架、数据迁移工具等。

引入依赖

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

  • 1
  • 2
  • 3
  • 4
  • 5

测试程序

查询语句解析
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("【WHERE 子句】：" + 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();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72

插入语句解析
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 )\n" +
            "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("【插入目标表】：" + 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();
            // 字段和值是一一对应的，把性别删除掉
            columns.remove(4);
            values.remove(4);
            // 新增一列状态，默认为 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();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

更新语句解析
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("【更新目标表】：" + 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();
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/860213?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号