JSQLParser 解析复杂SQL 2.0

置顶 已于 2024-03-12 09:53:38 修改
阅读量4.1k 收藏 23
点赞数 14
分类专栏： Ashの代码之路 文章标签： sql mybatis 数据库 java
于 2023-03-17 11:37:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54892309/article/details/129615905
版权

前言

这段时间，为了开发数据中台项目，我去研究学习了JSQLParser（Java中解析SQL语句的工具），并且结合网上资料，写了一个初步的SQL解析工具类...

正文

时隔三天，我又回来了， 因为之前JSQLParser的使用方式果然不太正确😅 。基本上正常的SQL通过JSQLParser都可以完美解析出它的结构。

主要错误如下：

  1. 表别名的解析是包含from和join两部分的，之前只解析了from，所以无法获得所有的表。

  1. SQL是可以不断嵌套的，解析的时候必须判断是否含有子查询，然后将子查询的SQL语句递归解析。

  1. 没有对union的情况做判断 2023/5/12.

关于字段类型的解析，可以用jdbc查询返回的map，然后判断instanceof的字段类型，非常简单。

这里就贴下最新的代码吧，目前已经支持了嵌套SQL的解析~~

  1. 实体类：

NormalSqlStructureDto.class


   /**
     * SQL语句
     */
    private String sql;
    /**
     * 表名
     */
    private List<String> tableNames;
    /**
     * 检索项
     */
    private List<String> selectItems;
    /**
     * 字段和表的映射关系
     */
    private List<ColMappingDto> colMappings;
    /**
     * 表别名映射
     */
    private Map<String, Object> tableAliasMapping;

ColMappingDto.class


 /** 字段名 */
    private String name;
    /** 字段别名 */
    private String alias;
    /** 关联表 */
    private Object table;
    /** 表别名 */
    private Object tableAlias;
    /** 字段类型 */
    private String type;

  1. 主要实现类：


import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.parser.SimpleNode;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.util.TablesNamesFinder;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import java.io.StringReader;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * SQL解析通用工具
 *
 * @author xurenyi
 * @since 2023/3/17 11:19
 **/
public class JsqlParserUtil {
    /**
     * 表名列表
     */
    private final static ThreadLocal<List<String>> TABLE_NAME_LIST = new ThreadLocal<>();
    /**
     * 查询字段名列表
     */
    private final static ThreadLocal<List<String>> COLUMN_NAME_LIST = new ThreadLocal<>();
    /**
     * 表别名映射关系
     */
    private final static ThreadLocal<Map<String, Object>> TABLE_AND_ALIAS_MAPPING = new ThreadLocal<>();
    /**
     * 字段映射关系列表
     */
    private final static ThreadLocal<List<ColMappingDto>> COL_MAPPING_LIST = new ThreadLocal<>();

    private static Logger logger = LoggerFactory.getLogger("JsqlParserUtil");

    public static void main(String[] args) throws JSQLParserException {
        //1、获取原始sql输入
//        String sql = "select t1.s_id as id," +
//                "t1.s_name," +
//                "t1.join_date, \n" +
//                "t2.score, \n" +
//                "t2.* \n" +
//                "from schema1.edu_college_student t1\n" +
//                "join schema2.edu_college_test_score t2\n" +
//                "on t2.s_id = t1.s_id \n" +
//                "where 1=1 \n";

//        String sql = "select t11.*,t1.* \n" +
//                "from original_data.edu_college_student As t1\n" +
//                "JOIN original_data.edu_college_test_score t11\n" +
//                "on t1.s_id = t11.s_id \n" +
//                "where 1=1 \n";

//        String sql = "select t1.*,t1.*,t2.*\n" +
//                "from edu_college_student t1\n" +
//                "join edu_college_test_score t2 on t2.s_id = t1.s_id";

//        String sql = "select '1' from meta_dict_type";

//        String sql = "select\n" +
//                "  t1.s_id,\n" +
//                "  t1.s_name,\n" +
//                "  max(t2.score) as maxscore,\n" +
//                "  t2.course\n" +
//                "from\n" +
//                "  original_data.edu_college_student t1\n" +
//                "  join original_data.edu_college_test_score t2 on t2.s_id = t1.s_id\n" +
//                "group by\n" +
//                "  t2.course,\n" +
//                "  t1.s_id,\n" +
//                "  t1.s_name";

//        String sql = "select t2.id from (select t1.id from (select id from original_data.edu_college_student) t1) t2";

//        String sql = "select t1.stime,t1.sscore from (select o.create_time as stime,t.score as sscore from original_data.edu_college_student o join original_data.edu_college_test_score t on t.s_id = o.s_id ) t1";

//        String sql = "select t1.s_id as sid, t1.t1.s_name from original_data.edu_college_student t1";

//        String sql = "select\n" +
//                "  v1.id as t_id,\n" +
//                "  v1.s_name as t_s_name,\n" +
//                "  v1.join_date as t_date,\n" +
//                "  v1.score As t_score,\n" +
//                "  t3.course AS t_course\n" +
//                "from\n" +
//                "  (\n" +
//                "    select\n" +
//                "      t1.s_id as id,\n" +
//                "      t1.s_name,\n" +
//                "      t1.join_date,\n" +
//                "      t2.score\n" +
//                "    from\n" +
//                "      original_data.edu_college_student t1\n" +
//                "      join original_data.edu_college_test_score t2 on t2.s_id = t1.s_id\n" +
//                "    where\n" +
//                "      1 = 1\n" +
//                "  ) v1\n" +
//                "  join original_data.edu_college_sign_in_situation t3 on t3.s_id = v1.id\n" +
//                "  limit 10";

        String sql = "select '正常签到' as '签到情况',sum(1) as '次数' from `original_data`.hr_attendance_summary_day where is_early = 0 and is_later = 0 \n" +
                "union all \n" +
                "SELECT '迟到' AS '签到情况',if(SUM(is_later)is null,0,SUM(is_later)) AS '次数' FROM `original_data`.hr_attendance_summary_day WHERE is_later = 1\n" +
                "union all \n" +
                "SELECT '早退' AS '签到情况',if(SUM(is_early)is null,0,SUM(is_early)) AS '次数' FROM `original_data`.hr_attendance_summary_day WHERE is_early = 1";

        try {
            getStructure(sql.replaceAll("[\r\n]", " "), true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取SQL结构
     *
     * @param sql SQL语句
     * @throws JSQLParserException 解析异常
     */
    public static NormalSqlStructureDto getStructure(String sql, boolean isAlias) throws JSQLParserException {
        //logger.info("【START】");
        TABLE_NAME_LIST.set(new ArrayList<>());
        COLUMN_NAME_LIST.set(new ArrayList<>());
        TABLE_AND_ALIAS_MAPPING.set(new HashMap<>());
        COL_MAPPING_LIST.set(new ArrayList<>());
        NormalSqlStructureDto normalSqlStructureDto = new NormalSqlStructureDto();
        if (StringUtils.isEmpty(sql)) {
            throw new ServiceException("请先输入SQL语句");
        }
        normalSqlStructureDto.setSql(sql);
        sql = sql.replaceAll("(\\$\\{\\w*\\})|(\\{\\{\\w+\\}\\})", "''");
        analysisSql(sql, isAlias, false);
        normalSqlStructureDto.setSelectItems(COLUMN_NAME_LIST.get());
        normalSqlStructureDto.setTableNames(TABLE_NAME_LIST.get());
        normalSqlStructureDto.setTableAliasMapping(TABLE_AND_ALIAS_MAPPING.get());
        List<ColMappingDto> colMappingDtoList = COL_MAPPING_LIST.get();
        for (ColMappingDto mapping : colMappingDtoList) {
            if (Objects.isNull(mapping.getTable()) && Objects.nonNull(mapping.getTableAlias())) {
                mapping.setTable(TABLE_AND_ALIAS_MAPPING.get().get(mapping.getTableAlias()));
            }
        }
        normalSqlStructureDto.setColMappings(colMappingDtoList);

        //logger.info("【END】");
        return normalSqlStructureDto;
    }

    /**
     * 解析SQL
     *
     * @param sql         SQL语句
     * @param isAlias     true|false 是否使用别称<br> eg. 【s_id as id】 => 【id】<br>
     * @param isSubSelect 是否是子查询
     * @throws JSQLParserException 解析异常
     */
    private static void analysisSql(String sql, boolean isAlias, boolean isSubSelect) throws JSQLParserException {
        //logger.info("是否是子查询: " + isSubSelect);
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        // 解析SQL为Statement对象
        Statement statement = parserManager.parse(new StringReader(sql));
        Select select = (Select) CCJSqlParserUtil.parse(sql);
        SelectBody selectBody = select.getSelectBody();
        // 判断是否是union查询
        if(selectBody instanceof SetOperationList){
            SetOperationList operationList = (SetOperationList) select.getSelectBody();
            List<SelectBody> plainSelects = operationList.getSelects();
            for (SelectBody plainSelect : plainSelects) {
                analysisSql(plainSelect.toString(), isAlias, isSubSelect);
            }
        } else if(selectBody instanceof PlainSelect){
            analysisSelectBody(isAlias, isSubSelect, statement, select);
        }
    }

    /**
     * 解析SelectBody
     *
     * @param isAlias true|false 是否使用别称<br> eg. 【s_id as id】 => 【id】<br>
     * @param isSubSelect 是否是子查询
     * @param statement Statement对象
     * @param select Select对象
     * @throws JSQLParserException 解析异常
     */
    private static void analysisSelectBody(boolean isAlias, boolean isSubSelect, Statement statement, Select select) throws JSQLParserException {
        PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
        // 1.解析表名
        List<String> tableNameList = getTable(statement);
        // 表别名映射
        Map<String, Object> tableMapping = new HashMap<>();
        tableNameList.forEach(i -> tableMapping.put(i, i));
        if (CollectionUtils.isEmpty(TABLE_AND_ALIAS_MAPPING.get())) {
            TABLE_AND_ALIAS_MAPPING.get().putAll(tableMapping);
        }
        if (CollectionUtils.isEmpty(TABLE_NAME_LIST.get())) {
            TABLE_NAME_LIST.get().addAll(tableNameList);
        }
        // 字段和表的映射
        List<ColMappingDto> colMappingList = new ArrayList<>();

        // 2.解析查询元素 列，函数等
        getSelectItems(plainSelect, tableNameList, tableMapping, colMappingList, isAlias, isSubSelect);

        // 3.解析from（可能含有子查询）
        FromItem fromItem = plainSelect.getFromItem();
        String fromTable = getFromItem(fromItem, isAlias);
        //logger.info("from 表名：" + fromTable);

        // 4.解析join
        List<Join> tablewithjoin = getJoinItem(plainSelect);
        if (!CollectionUtils.isEmpty(tablewithjoin)) {
            tablewithjoin.forEach(i -> System.out.println("连接方式为：" + i));
        }
    }

    /**
     * 获取join的项目
     *
     * @param plainSelect
     * @return
     */
    private static List<Join> getJoinItem(PlainSelect plainSelect) {
        // 如果关联后面是子查询，可以通过遍历join集合，获取FromItem rightItem = join.getRightItem();
        List<Join> joinList = plainSelect.getJoins();
        if (joinList != null) {
            for (int i = 0; i < joinList.size(); i++) {
                //注意 ， leftjoin rightjoin 等等的to string()区别
                Join join = joinList.get(i);
                String alias = join.getRightItem().getAlias().toString().trim();
                String tableName = join.getRightItem().toString().replaceAll("(?i)\\s+as\\s+", " ").replace(alias, "").trim();
                //logger.info("join 表名：" + join.getRightItem().toString());
                //logger.info("物理名：" + tableName);
                //logger.info("别名：" + alias);
                TABLE_AND_ALIAS_MAPPING.get().put(alias, tableName);
            }
        }
        return joinList;
    }

    /**
     * 获取from的项目
     *
     * @param fromItem
     * @return
     * @throws JSQLParserException 解析异常
     */
    private static String getFromItem(FromItem fromItem, boolean isAlias) throws JSQLParserException {
        // 判断fromItem属于哪种类型，如果是subSelect类型就是子查询
        if (fromItem instanceof SubSelect) {
            //logger.info("-----------------子查询开始-----------------");
            SelectBody selectBody = ((SubSelect) fromItem).getSelectBody();
            //logger.info("子查询" + selectBody.toString());
            analysisSql(selectBody.toString(), true, true);
            //logger.info("-----------------子查询结束-----------------");
        }
        String alias = "";
        try {
            alias = fromItem.getAlias().toString().trim();
            Table table = ((Table) fromItem);
            String tableName = table.getName();
            String schemaName = table.getSchemaName();
            schemaName = StringUtils.isEmpty(schemaName) ? "" : schemaName;
            String name = schemaName + "." + tableName;
            //logger.info("物理名：" + name);
            //logger.info("别名：" + alias);

            TABLE_AND_ALIAS_MAPPING.get().put(alias, name);
        } catch (Exception e) {
            if (StringUtils.isNotEmpty(alias)) {
                TABLE_AND_ALIAS_MAPPING.get().put(alias, fromItem.toString());
            }
        } finally {
            return fromItem.toString();
        }

    }

    /**
     * 获取当前查询字段
     *
     * @param plainSelect
     * @param tableNameList
     * @param tableMapping
     * @param colMappingList
     */
    private static void getSelectItems(PlainSelect plainSelect, List<String> tableNameList, Map<String, Object> tableMapping, List<ColMappingDto> colMappingList, boolean isAlias, boolean isSubSelect) {
        // 目前不解析子查询
        if (isSubSelect) {
            return;
        }
        List<SelectItem> selectItems = plainSelect.getSelectItems();
        List<String> columnList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(selectItems)) {
            for (SelectItem selectItem : selectItems) {
                ColMappingDto colMapping = new ColMappingDto();
                // 字段名称
                String columnName = "";
                // 表别名
                String tblAlias = "";
                try {
                    if (selectItem instanceof SelectExpressionItem) {
                        SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
                        Alias alias = selectExpressionItem.getAlias();
                        Expression expression = selectExpressionItem.getExpression();
                        Column col = ((Column) expression);
                        Table colTbl = col.getTable();
                        if (Objects.nonNull(colTbl)) {
                            tblAlias = colTbl.getName();
                        }
                        if (!isAlias) {
                            columnName = selectItem.toString();
                        } else if (expression instanceof CaseExpression) {
                            // case表达式
                            columnName = alias.getName();
                        } else if (expression instanceof LongValue || expression instanceof StringValue || expression instanceof DateValue || expression instanceof DoubleValue) {
                            // 值表达式
                            columnName = Objects.nonNull(alias.getName()) ? alias.getName() : expression.getASTNode().jjtGetValue().toString();
                        } else if (expression instanceof TimeKeyExpression) {
                            // 日期
                            columnName = alias.getName();
                        } else {
                            if (alias != null) {
                                columnName = alias.getName();
                            } else {
                                SimpleNode node = expression.getASTNode();
                                Object value = node.jjtGetValue();
                                if (value instanceof Column) {
                                    columnName = ((Column) value).getColumnName();
                                } else if (value instanceof Function) {
                                    columnName = value.toString();
                                } else {
                                    // 增加对select 'aaa' from table; 的支持
                                    columnName = String.valueOf(value);
                                    columnName = getString(columnName);
                                }
                            }
                        }

                        columnName = getString(columnName);

                        colMapping.setName(col.getColumnName());
                        if (Objects.nonNull(alias) && StringUtils.isNotEmpty(alias.getName())) {
                            colMapping.setAlias(alias.getName());
                        }
//                        colMapping.setTable(tableMapping.get(tblAlias));
                        colMapping.setTableAlias(tblAlias);

                    } else if (selectItem instanceof AllTableColumns) {
                        AllTableColumns allTableColumns = (AllTableColumns) selectItem;
                        columnName = allTableColumns.toString();
                        if (columnName.indexOf(".") > -1) {
                            tblAlias = columnName.substring(0, columnName.indexOf(".")).trim();
//                            buildTblMapping(tableMapping, sql, tblAlias);
//                            colMapping.setTable(tableMapping.get(tblAlias));
                            colMapping.setTableAlias(tblAlias);
                        } else {
                            colMapping.setTable(tableNameList);
                        }
                        colMapping.setName(columnName);
                    } else if (selectItem.toString().equals("*")) {
                        columnName = selectItem.toString();
                        colMapping.setName(columnName);
                        colMapping.setTable(tableNameList);
                    } else {
                        columnName = selectItem.toString();
                        colMapping.setName(columnName);
                    }
                } catch (Exception e) {
                    columnName = selectItem.toString();
                    colMapping.setName(columnName);
                    colMapping.setTable(null);
                    if (columnName.matches("(?i).+\\s+as\\s+.+")) {
                        colMapping.setAlias(columnName.replaceAll("(?i).+\\s+as\\s+", "").trim());
                    }
                }

                columnList.add(columnName);
                colMappingList.add(colMapping);
                if (!isSubSelect) {
                    COL_MAPPING_LIST.get().add(colMapping);
                    COLUMN_NAME_LIST.set(columnList);
                }
            }
            //logger.info("查询字段名：" + columnList.toString());
        }
    }

    private static String getString(String columnName) {
        columnName = columnName.replace("'", "");
        columnName = columnName.replace("\"", "");
        columnName = columnName.replace("`", "");
        return columnName;
    }

    /**
     * 获取SQL中所有出现的表
     *
     * @param statement
     * @return
     */
    private static List<String> getTable(Statement statement) {
        // 创建表名发现者对象
        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
        // 获取到表名列表
        List<String> tableNameList = tablesNamesFinder.getTableList(statement);
        //logger.info("查询表名：" + tableNameList.toString());

        return tableNameList;
    }

    /**
     * 构建表名和表别名的对应关系
     *
     * @param tableMapping
     * @param sql
     * @param tblAlias
     */
    private static void buildTblMapping(Map<String, Object> tableMapping, String sql, String tblAlias) {
        if (StringUtils.isNotEmpty(tblAlias)) {
            if (CollectionUtils.isEmpty(tableMapping) || Objects.isNull(tableMapping.get(tblAlias))) {
                sql = sql.replaceAll("(?i)\\s+as\\s+", " ");
                String regex = "(from|join)\\s+(\\w+\\.)?\\w+\\s+".concat(tblAlias).concat("\\s?");
                Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
                Matcher m = p.matcher(sql.replaceAll("[\n\r]", " "));
                String replaceReg = "(?i)(from|join|" + tblAlias + ")";
                while (m.find()) {
                    tableMapping.put(tblAlias, m.group(0).replaceAll(replaceReg, "").trim());
                }
            }
        }
    }
}

  1. 解析结果展示

结论

JSQLParser是Java里用来解析SQL结构的一个非常好用的工具，有且不仅限于上面的功能。

醒盼梦惜忆甚悠
关注
  • 14
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
java sqlparser_使用Jsqlparser从复杂SQL语句中提取表名
weixin_35849560的博客
02-16 3325
如果从简单的SQL语句中获取表名，那么可以通过不严谨的关键字匹配的方式获取或者正则表达式的方式获取表名。但是这种做法不具有通用性，遇到复杂的SQL语句就会存在BUG。严谨的做法当然是通过SQL分析工具分析SQL结构并获取SQL信息，Jsqlparser就是这样的工具，为我们的SQL分析提供了便利。下面通过一个简单的例子可以了解到Jsqlparser的实现机制，举一反三，更多的应用都是可以做到的。/...
jsqlparser-2.0.jar
07-02
SQL解析器， 项目地址：https://github.com/JSQLParser/JSqlParser
JSqlParser：JSqlParser解析一条SQL语句并将其转换为Java类的层次结构。 可以使用“访问者模式”浏览生成的层次结构
01-30
JSqlParser 在此处查找更多信息和示例： : 。 执照 JSqlParser具有LGPL V2.1或Apache软件许可2.0版的双重许可。 讨论区 请提供有关以下方面的反馈： API更改：使用返回值扩展访问者（ ） 新闻 发布了JSqlParser 4.0版本 发布了JSqlParser的3.2版 发布了JSqlParser的3.1版 发布了JSqlParser 3.0版 数组解析是默认行为。 必须使用解析器标志（ CCJSqlParser.withSquareBracketQuotation ）启用方括号引用。 由于API更改，版本将为3.0 现在，JSqlParser至少使用Java 8 更多新闻可以在这里找到： : 。 JSqlParser的替代品？ 看起来很不错，具有扩展SQL语法（例如PL / SQL和T-SQL）和Java + .NET API。 该工具是商业工具（可在线获得许可证），并提供免费下载选项。 JSqlParser JSqlParser是一个SQL语句解析器。 它将SQL转换为Java类的可遍历层次结构。 JSqlParser不
jsqlparser解析复杂sql
04-24
jsqlparser解析复杂sql 获取where条件字段 select字段 表名table 查询join 查询 group by 查询order by 子查询 判断是否为多级子查询
JSqlParser的使用
qq_39203337的博客
03-22 1898
JSqlParse是一款很精简的sql解析工具，它可以将常用的sql文本解析成具有层级结构的语法树，我们可以针对解析后的节点进行处理(增加、移除、修改等操作),从而生成符合我们业务要求的sql，比如添加过滤条件等等JSqlParse采用访问者模式项目结构非常简单，从截图上看就5个包。如果对源码感兴趣的可以直接从github上下载源码包调试。其中expression包包含了所有的sql表达式的抽象对象：statement包含了所有sql语句的类型，比如：增删改查，ddl语句,rollback语句等等。
List-SetOperation
06-06
名称 List::SetOperation - 简单的设置操作 概要 use Test::More; use List::SetOperation qw/intersection union difference/; my @intersection = intersection( [1, 2, 3, 4, 5], [1, 2, 3], [1, 3] ); is_deeply \@intersection, [1, 3]; my @union = union( [1, 2, 3, 4, 5], [1, 2], [3, 4, 5], ); is_deeply \@union, [1, 2, 3, 4, 5]; my @difference = difference( [1, 2, 3, 4, 5], [3, 4, 5], );
使用java sql parser插件Jsqlparser 实例(一)
热门推荐
cuixuange的博客
11-21 5万+
JsqlParser插件用来对于SQL语句进行解析和组装，将SQL语句关键词之间的内容用List进行保存，同时可以进行更改List的内容后重新组装成一个新的SQL语句。项目中的需求多用于更改SQL中table name。(其实感觉用正则会更好一点) JsqlParser其实就是将sql语句各个关键词用Java类的形式进行了对应解析，包括很多函数可以让我们得到各个部分的内容。我目前只是简单的测试使用
Sql解析转换之JSqlParse完整介绍
Interest1_wyt的博客
03-26 2万+
1、 jsqlparse介绍 JSqlParse是一款很精简的sql解析工具，它可以将常用的sql文本解析成具有层级结构的“语法树”，我们可以针对解析后的“树节点（也即官网里说的有层次结构的java类）”进行处理进而生成符合我们要求的sql形式。 官网给的介绍很简洁：JSqlParser 解析 SQL 语句并将其转换为 Java 类的层次结构。生成的层次结构可以使用访问者模式进行访问（官网地址：JSqlParser - Home）。 官网的介绍即是该中间件的全部，虽然介绍很短，但是其功能着实强悍。
JSqlParser
OWMBL的博客
05-15 7257
1.定义：JSqlParser是一个SQL语句解析器。它将SQL转换为Java类的可遍历层次结构。2.工具地址：目前在github上开源。3.支持的数据库类型：支持Oracle，SqlServer，MySQL，PostgreSQL等常用数据库。但各种数据库系统的SQL语法都在动态变化，可以解析大部分（不是全部）。Github 官网截图：4.支持的语法类型：目前，JSqlParser最新版本为4.6（2023-2-24），支持的语法已在官网上做了全部列举（部分截图展示：）
JSQLParser 解析 复杂sql （表别名、字段与表对应关系）
m0_54892309的博客
03-13 9800
个人代码分享- 使用Java的JSqlParser工具来解析复杂SQL（SQL的基本结构、表|别名、字段|别名|关联表）
JSqlParser-解析SQL工具类
zuihongyan518的博客
04-14 5644
JSqlParse是一款很精简的sql解析工具，本文封装JSqlParse解析SQL处理工具。
JSqlParser-SQL解析处理
喝醉的咕咕鸟
07-07 6938
JSqlParse是一款很精简的sql解析工具，将sql语句转成Java对象，同时也可以根据Java对象进行构建数据库sql。
JSqlParser:JSqlParser解析一条SQL语句并将其转换为Java类的层次结构。 可以使用“访问者模式”浏览生成的层次结构
05-10
的JSqlParser 在此处查找更多信息和示例： : 。 执照 JSqlParser具有LGPL V2.1或Apache软件许可2.0版的双重许可。 讨论 请提供有关以下方面的反馈： API更改：使用返回值扩展访问者（ ） 消息 发布了JSqlParser的版本4.0 发布了JSqlParser的3.2版 发布了JSqlParser的3.1版 发布了JSqlParser 3.0版 数组解析是默认行为。 必须使用解析器标志（ CCJSqlParser.withSquareBracketQuotation ）启用方括号引用。 由于API的更改，该版本将为3.0 现在，JSqlParser至少使用Java 8 更多新闻可以在这里找到： : 。 JSqlParser的替代品？ 看起来很不错，具有扩展SQL语法（如PL / SQL和T-SQL）和Java + .NET AP
jsqlparser sql解析
04-07
jsqlparser sql解析
jsqlparser0.7解决中文问题
09-23
解决jsqlparser中文问题，修改JSqlParserCC.jj使用jcc重新编译，打包。
java的sql解析器jsqlparser
07-14
支持解析sql的正确性，可以解析出sql 的列名，表名，别名，条件等，非常好用
JSqlParser开源SQL解析库jar
最新发布
04-04
JSqlParser是一个用Java编写的开源SQL解析库，它可以解析SQL语句并生成抽象语法树(AST)，也可以根据AST生成SQL语句。这意味着你可以利用它来分析、修改甚至生成SQL查询。 以下是一些JSqlParser的主要应用场景： ...
JSqlParser入门系列(1)-JSqlParser简介及入门案例
记录知识、锤炼自我
03-18 1万+
简介 JSqlParser是一个SQL语句解析器。它将SQL转换为Java类的可遍历层次结构。 支持Oracle，SqlServer，MySQL，PostgreSQL等常用数据库。但各种数据库系统的SQL语法都在动态变化，可以解析某些（不是全部）。 JSqlParser就是一个把SQL转换为JAVA对象操作的工具包，但是发现此类文章较少，文档也不太详细，所以写个系列博客供参考。 GitHub地址 入门案例 添加pom <dependency> <
SQL 语法解释器jsqlparser
serv
03-20 480
SQL 语法解释器jsqlparser   是用java 开发的解析器, 可以生成java类层次结构.   主页地址: http://jsqlparser.sourceforge.net   可以完美解析 表的 增删查改等操作.   展开它的源码你会发现.基本不用看api就可以使用,因为它是如此的类似sql   只要你会java 只要你会写sql 那么你就会使用...
jsqlparser解析子查询sql
12-06
以下是使用jsqlparser解析子查询sql的示例代码： ```java import java.io.StringReader; import java.util.List; import net.sf.jsqlparser.JSQLParserException; import net.sf.jsqlparser.expression.Expression; import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.Statement; import net.sf.jsqlparser.statement.select.PlainSelect; import net.sf.jsqlparser.statement.select.Select; import net.sf.jsqlparser.statement.select.SubSelect; public class JSqlParserDemo { public static void main(String[] args) throws JSQLParserException { String sql = "SELECT * FROM (SELECT * FROM table1 WHERE id IN (SELECT id FROM table2)) AS subquery"; Statement statement = CCJSqlParserUtil.parse(sql); Select selectStatement = (Select) statement; PlainSelect plainSelect = (PlainSelect) selectStatement.getSelectBody(); SubSelect subSelect = (SubSelect) plainSelect.getFromItem(); Select subquery = (Select) subSelect.getSelectBody(); PlainSelect subqueryPlainSelect = (PlainSelect) subquery.getSelectBody(); List<Expression> expressions = subqueryPlainSelect.getSelectItems(); for (Expression expression : expressions) { System.out.println(expression.toString()); } } } ``` 上述代码中，我们首先将子查询sql语句作为字符串传入JSqlParser进行解析。然后，我们通过获取Select对象和PlainSelect对象来获取子查询的Select对象和PlainSelect对象。最后，我们可以通过获取子查询的PlainSelect对象来获取子查询中的Select字段。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值