sql select 语句 转 Json

已于 2022-09-27 09:41:34 修改
阅读量2k 收藏
点赞数
分类专栏： 个人BUG集 文章标签： sql elasticsearch java
于 2022-05-10 16:22:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40310480/article/details/124690574
版权

最近有个Es查询的需求，用户在前端输入sql语句直接拼条件，然后后台去查询。

因为es本身带有类sql查询，刚开始打算用sql查的，但是分页的limit只有一个查询条数，没有from和size，比如es可以通过类sql 的 limit 1000 一次查出来1000条数据，但是没法通过limit 900,100查出来第900到1000的数据，想实现就得先limit 1000再去截取后100条，没办法了，只能解析sql再去拼接条件了。这块的解析实现需要感谢以下两篇贴子，

灵感来源

灵感来源

https://elasticsearch.cn/article/114

用二叉树简直是神设计，当时为了最终结构困扰了我半天
在这里插入图片描述

https://blog.csdn.net/qzshiyongjie123/article/details/54341472

这篇关于具体代码实现讲的挺详细的，唯一的缺点是代码不全，我也是在这篇的基础上修改来的

代码实现

实体结构

这块本质上还是二叉树，但是新加了几个属性，以如下语句举例说明

 a = 1 or (b = 2 and not c != 3)
 
 left:     英文字段名 // a、b、c
 right:   字段对应值 // 1、2、3
 inRelat： 字段和值的关系 // = 、!=
 outRelat  （字段-值）之间的连接关系  // and、or
 hasNot    当前（字段-值）是否包含not  
 sqlSon   括号圈起来的算一个整体

实体属性如下：

@Data
public class SqlNode {

    // 字段名
    private String left;

    // 值
    private String right;

    // 内关系符 > < =
    private String inRelat;

    // 外关系符 and or
    private String outRelat;

    // 是否not
    private boolean hasNot;

    // 子关系式
    private List<SqlNode> sqlSon;

    public SqlNode() {
    }

    public SqlNode(String left, String right, String inRelat, boolean hasNot) {
        this.left = left;
        this.right = right;
        this.inRelat = inRelat;
        this.hasNot = hasNot;
    }
}

1.将sql语句分解成数组

public static String[] handSpace(String sql) {
        sql = sql.trim();
        String tempStr = "";
        boolean hasFirstSpace = false;
        boolean hasDoublePoint = false;

        List<String> list = new ArrayList<>();
        for (int i = 0; i < sql.length(); i++) {
            char curChar = sql.charAt(i);
            String charStr = Convert.toStr(curChar);

            switch (curChar) {
                case '"':
                    hasDoublePoint = hasDoublePoint == false ? true : false;
                    if (i == sql.length() - 1) {
                        list.add(tempStr);
                    }
                    break;
                case '(':
                    if (hasDoublePoint == false) {
                        // 不在字符串内直接 添加 (
                        list.add(charStr);
                    } else {
                        // 字符串内继续拼接
                        tempStr += charStr;
                    }
                    break;
                case ')':
                    // 不在字符串内
                    if (hasDoublePoint == false) {
                        if (StringUtils.isNotBlank(tempStr)) {
                            // 前面有字符串
                            list.add(tempStr);
                            tempStr = "";
                        }
                        // 遍历到最后一位 -> 直接添加
                        if (i == sql.length() - 1) {
                            list.add(")");
                        } else {
                            list.add(")");
                        }
                    } else {
                        // 字符串内继续拼接
                        tempStr += charStr;
                    }
                    break;
                case ' ':
                    // 不在字符串内
                    if (hasDoublePoint == false) {
                        // 第一个空格 -> 添加前一个词组
                        if (hasFirstSpace == false) {
                            if (StringUtils.isNotBlank(tempStr)) {
                                list.add(tempStr);
                                tempStr = "";
                                hasFirstSpace = true;
                            }
                        }
                    } else {
                        // 字符串内继续拼接
                        tempStr += curChar;
                    }
                    break;
                default:
                    // 普通字符继续拼接
                    tempStr += curChar;
                    hasFirstSpace = false;
                    // 遍历到最后一位 -> 直接添加
                    if (i == sql.length() - 1) {
                        list.add(tempStr);
                    }
                    break;
            }
        }
        String[] array = new String[list.size()];

        return list.toArray(array);
    }

这步主要是为了拆分数据，便于下一步更好进行条件转换，写个sql看下实际效果在这里插入图片描述

2.对数组完成树结构的转换

public static void paraseSql(String[] arr, List<SqlNode> nodes) throws Exception {
        Queue<String> queue = new ArrayDeque<String>();
        int bracketsStart = 0;
        int bracketsEnd = 0;
        for (int i = 0; i < arr.length; i++) {
            String left;
            String right = null;
            String outRelat;
            String inRelat;
            boolean hasNot;

            String curStr = arr[i];
            if (curStr.equals("(")) {
                if (queue.size() == 0) {
                    // 只记录首次下标
                    bracketsStart = i;
                }
                queue.add("(");
            } else if (curStr.equals(")")) {
                queue.poll();
                if (queue.size() == 0) {
                    // 括号闭环了 才能处理
                    // 判断and not / or not
                    hasNot = bracketsStart - 1 > 0 ? (arr[bracketsStart - 1].matches(NOT)) : false;
                    int andOrIndex;
                    // 前面是否有 and / or
                    if (bracketsStart - 1 > 0) {
                        andOrIndex = hasNot ? bracketsStart - 2 : bracketsStart - 1;
                        outRelat = arr[andOrIndex].matches(AND) ? AND : OR;
                    } else {
                        // 后面 and / or
                        outRelat = i + 1 < arr.length ? (arr[i + 1].matches(AND) ? AND : OR) : AND;
                    }
                    bracketsEnd = i;

                    SqlNode sqlNode = new SqlNode();
                    List<SqlNode> sonNodes = new ArrayList<>();
                    String[] noBracketsArr = Arrays.copyOfRange(arr, bracketsStart + 1, bracketsEnd);
                    // 接着递归处理
                    paraseSql(noBracketsArr, sonNodes);
                    sqlNode.setSqlSon(sonNodes);
                    sqlNode.setOutRelat(outRelat);
                    sqlNode.setHasNot(hasNot);
                    nodes.add(sqlNode);
                }
            } else if (curStr.matches("(" + AND + ")|(" + OR + ")")) {
                // 括号遍历完了才能加
                if (queue.size() == 0) {
                    if (!arr[i - 1].equals(")")) {
                        boolean hasExist = (arr[i - 1].equals(EXIST) || arr[i - 1].equals(NOT_EXIST)) ? true : false;
                        if (hasExist) {
                            hasNot = i - 3 >= 0 ? (arr[i - 3].equals(NOT) ? true : false) : false;
                            // 第一个条件以当前and / or 为准，语句中间的以前面的条件为准
                            outRelat = i - 3 > 0 ? (arr[i - 3].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 3] : arr[i - 4]) : curStr;
                            left = arr[i - 2];
                            inRelat = arr[i - 1];
                        } else {
                            hasNot = i - 4 >= 0 ? (arr[i - 4].equals(NOT) ? true : false) : false;
                            outRelat = i - 4 > 0 ? (arr[i - 4].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 4] : arr[i - 5]) : curStr;
                            left = arr[i - 3];
                            inRelat = arr[i - 2];
                            right = arr[i - 1];
                        }
                        SqlNode sqlNode = new SqlNode();
                        sqlNode.setLeft(left);
                        sqlNode.setHasNot(hasNot);
                        sqlNode.setRight(right);
                        sqlNode.setInRelat(inRelat);
                        sqlNode.setOutRelat(outRelat);
                        nodes.add(sqlNode);
                    }
                }
            } else if (i == arr.length - 1) {
                // 最后一个了
                // 判断是不是 exist
                boolean hasExist = (arr[i].equals(EXIST) || arr[i].equals(NOT_EXIST)) ? true : false;
                if (hasExist) {
                    hasNot = i - 2 > 0 ? (arr[i - 2].equals(NOT) ? true : false) : false;
                    outRelat = i - 2 > 0 ? (arr[i - 2].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 2] : arr[i - 3]) : AND;
                    left = arr[i - 1];
                    inRelat = arr[i];
                } else {
                    // 有 and / or
                    hasNot = i - 3 > 0 ? (arr[i - 3].equals(NOT) ? true : false) : false;
                    outRelat = i - 3 > 0 ? (arr[i - 3].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 3] : arr[i - 4]) : AND;
                    left = arr[i - 2];
                    right = arr[i];
                    inRelat = arr[i - 1];
                }
                if (!outRelat.matches("(" + AND + ")|(" + OR + ")")) {
                    throw new Exception("sql语法有误，请修改后重试！");
                }
                SqlNode sqlNode = new SqlNode();
                sqlNode.setLeft(left);
                sqlNode.setRight(right);
                sqlNode.setInRelat(inRelat);
                sqlNode.setOutRelat(outRelat);
                sqlNode.setHasNot(hasNot);
                nodes.add(sqlNode);
            }
        }
    }

传一个空list看下实际效果
在这里插入图片描述
成功分离出来了，现在只要遍历SqlNode集合就能按照关系组装出想要的数据了。

下面贴上全部代码

package com.event.entity.param;

import com.common.util.text.Convert;
import com.event.util.SqlNode;
import lombok.Builder;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * @author fjl
 * @date 2022/9/26
 */
@Data
@Builder
public class util {
    private static final String AND = "and";
    private static final String OR = "or";
    private static final String NOT = "not";
    private static final String EXIST = "exist";

    private static final String NOT_EXIST = "not_exist";

    public static void main(String[] args) throws Exception {

        String str = "a = 1 and ( b = 3 or c = 4 )";
        String[] fieldsArr = handSpace(str);
        List<SqlNode> nodes = new ArrayList<>();
        paraseSql(fieldsArr, nodes);
    }

    public static void paraseSql(String[] arr, List<SqlNode> nodes) throws Exception {
        Queue<String> queue = new ArrayDeque<String>();
        int bracketsStart = 0;
        int bracketsEnd = 0;
        for (int i = 0; i < arr.length; i++) {
            String left;
            String right = null;
            String outRelat;
            String inRelat;
            boolean hasNot;

            String curStr = arr[i];
            if (curStr.equals("(")) {
                if (queue.size() == 0) {
                    // 只记录首次下标
                    bracketsStart = i;
                }
                queue.add("(");
            } else if (curStr.equals(")")) {
                queue.poll();
                if (queue.size() == 0) {
                    // 括号闭环了 才能处理
                    // 判断and not / or not
                    hasNot = bracketsStart - 1 > 0 ? (arr[bracketsStart - 1].matches(NOT)) : false;
                    int andOrIndex;
                    // 前面是否有 and / or
                    if (bracketsStart - 1 > 0) {
                        andOrIndex = hasNot ? bracketsStart - 2 : bracketsStart - 1;
                        outRelat = arr[andOrIndex].matches(AND) ? AND : OR;
                    } else {
                        // 后面 and / or
                        outRelat = i + 1 < arr.length ? (arr[i + 1].matches(AND) ? AND : OR) : AND;
                    }
                    bracketsEnd = i;

                    SqlNode sqlNode = new SqlNode();
                    List<SqlNode> sonNodes = new ArrayList<>();
                    String[] noBracketsArr = Arrays.copyOfRange(arr, bracketsStart + 1, bracketsEnd);
                    // 接着递归处理
                    paraseSql(noBracketsArr, sonNodes);
                    sqlNode.setSqlSon(sonNodes);
                    sqlNode.setOutRelat(outRelat);
                    sqlNode.setHasNot(hasNot);
                    nodes.add(sqlNode);
                }
            } else if (curStr.matches("(" + AND + ")|(" + OR + ")")) {
                // 括号遍历完了才能加
                if (queue.size() == 0) {
                    if (!arr[i - 1].equals(")")) {
                        boolean hasExist = (arr[i - 1].equals(EXIST) || arr[i - 1].equals(NOT_EXIST)) ? true : false;
                        if (hasExist) {
                            hasNot = i - 3 >= 0 ? (arr[i - 3].equals(NOT) ? true : false) : false;
                            // 第一个条件以当前and / or 为准，语句中间的以前面的条件为准
                            outRelat = i - 3 > 0 ? (arr[i - 3].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 3] : arr[i - 4]) : curStr;
                            left = arr[i - 2];
                            inRelat = arr[i - 1];
                        } else {
                            hasNot = i - 4 >= 0 ? (arr[i - 4].equals(NOT) ? true : false) : false;
                            outRelat = i - 4 > 0 ? (arr[i - 4].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 4] : arr[i - 5]) : curStr;
                            left = arr[i - 3];
                            inRelat = arr[i - 2];
                            right = arr[i - 1];
                        }
                        SqlNode sqlNode = new SqlNode();
                        sqlNode.setLeft(left);
                        sqlNode.setHasNot(hasNot);
                        sqlNode.setRight(right);
                        sqlNode.setInRelat(inRelat);
                        sqlNode.setOutRelat(outRelat);
                        nodes.add(sqlNode);
                    }
                }
            } else if (i == arr.length - 1) {
                // 最后一个了
                // 判断是不是 exist
                boolean hasExist = (arr[i].equals(EXIST) || arr[i].equals(NOT_EXIST)) ? true : false;
                if (hasExist) {
                    hasNot = i - 2 > 0 ? (arr[i - 2].equals(NOT) ? true : false) : false;
                    outRelat = i - 2 > 0 ? (arr[i - 2].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 2] : arr[i - 3]) : AND;
                    left = arr[i - 1];
                    inRelat = arr[i];
                } else {
                    // 有 and / or
                    hasNot = i - 3 > 0 ? (arr[i - 3].equals(NOT) ? true : false) : false;
                    outRelat = i - 3 > 0 ? (arr[i - 3].matches("(" + AND + ")|(" + OR + ")") ? arr[i - 3] : arr[i - 4]) : AND;
                    left = arr[i - 2];
                    right = arr[i];
                    inRelat = arr[i - 1];
                }
                if (!outRelat.matches("(" + AND + ")|(" + OR + ")")) {
                    throw new Exception("sql语法有误，请修改后重试！");
                }
                SqlNode sqlNode = new SqlNode();
                sqlNode.setLeft(left);
                sqlNode.setRight(right);
                sqlNode.setInRelat(inRelat);
                sqlNode.setOutRelat(outRelat);
                sqlNode.setHasNot(hasNot);
                nodes.add(sqlNode);
            }
        }
    }

    public static String[] handSpace(String sql) {
        sql = sql.trim();
        String tempStr = "";
        boolean hasFirstSpace = false;
        boolean hasDoublePoint = false;

        List<String> list = new ArrayList<>();
        for (int i = 0; i < sql.length(); i++) {
            char curChar = sql.charAt(i);
            String charStr = Convert.toStr(curChar);

            switch (curChar) {
                case '"':
                    hasDoublePoint = hasDoublePoint == false ? true : false;
                    if (i == sql.length() - 1) {
                        list.add(tempStr);
                    }
                    break;
                case '(':
                    if (hasDoublePoint == false) {
                        // 不在字符串内直接 添加 (
                        list.add(charStr);
                    } else {
                        // 字符串内继续拼接
                        tempStr += charStr;
                    }
                    break;
                case ')':
                    // 不在字符串内
                    if (hasDoublePoint == false) {
                        if (StringUtils.isNotBlank(tempStr)) {
                            // 前面有字符串
                            list.add(tempStr);
                            tempStr = "";
                        }
                        // 遍历到最后一位 -> 直接添加
                        if (i == sql.length() - 1) {
                            list.add(")");
                        } else {
                            list.add(")");
                        }
                    } else {
                        // 字符串内继续拼接
                        tempStr += charStr;
                    }
                    break;
                case ' ':
                    // 不在字符串内
                    if (hasDoublePoint == false) {
                        // 第一个空格 -> 添加前一个词组
                        if (hasFirstSpace == false) {
                            if (StringUtils.isNotBlank(tempStr)) {
                                list.add(tempStr);
                                tempStr = "";
                                hasFirstSpace = true;
                            }
                        }
                    } else {
                        // 字符串内继续拼接
                        tempStr += curChar;
                    }
                    break;
                default:
                    // 普通字符继续拼接
                    tempStr += curChar;
                    hasFirstSpace = false;
                    // 遍历到最后一位 -> 直接添加
                    if (i == sql.length() - 1) {
                        list.add(tempStr);
                    }
                    break;
            }
        }
        String[] array = new String[list.size()];
        return list.toArray(array);
    }
 }
木子芳兮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何将sql转化为json数据
chunxinchang7827的博客
12-03 967
//将sql代码转化为json格式的数据public String getJsonStr(String sql,String jsonName){ String jsonStr = ""; String tjson = ""; Connection con = null; ResultSet ...
Sql语句生成Json
Greyscarf的博客
02-24 433
SELECT * FROM 表名 WHERE 1=1 FOR JSON AUTO;
sql 行转列列传行 字符串转json array
最新发布
qq_43185226的博客
04-15 129
sql 行转列列传行 字符串转json array
sqlserver中将sql查询结果转换成Json（互转）
DHZYKN
12-12 7414
将表中的数据转换成Json SELECT TOp 1 * FROM table FOR JSON AUTO , INCLUDE_NULL_VALUES,WITHOUT_ARRAY_WRAPPER 将指定的数值拼成Json select 'hahah' as "A", 'hdhdhdh' as "B" FOR JSON PATH , INCLUDE_NULL_VALUES,WITHO...
将SQL数据转换成json格式
独揽日月星辰的博客
11-28 3288
将SQL数据转换成json格式
在线SQL转JSON工具
Linux,Java,SpringBoot,Python,Lua略知一点
07-14 1681
在线SQL转JSON工具https://toolgg.com/sql-to-json.html
json语句转换为sql写入数据库操作
弄潮大数据的博客
12-03 2023
个人博客: jin522.github.io –待操作语句 [{"website":"www.baidu.cn","name":"tomjerry"},{"website":"cloud.baidu.com","name":"carbondata 中文文档"}] –完整hql表达式 select json_tuple(baidu.json, 'website', 'name') from (S...
如何用SQL取出字段内是json体的数据
hnfangh的博客
07-04 2785
数据库中会遇到字段里面存的JSON结果的数据，那么如果我们想直接取到JSON里的值该怎么办呢？SQL自带的函数就可解决
MS SQL Table与JSON转换
sen_shan的专栏
12-06 1589
案例1 运行效果：{"User_id":"ADMIN","PWS":"12345"},{"User_id":"INPUTUSER","PWS":"YTETS"}[{"User_id":"ADMIN","PWS":"12345"},{"User_id":"INPUTUSER","PWS":"YTETS"}]若要删除默认括住 FOR JSON 子句的 JSON 输出的方括号，请指定 WITHOUT_ARRAY_WRAPPER 选项。 将此选项用于单行结果，生成单个 JSON 对象作为输出，而不是生成具有单个
JsonSQL:用SQL语句解析JSON文件
06-19
**JsonSQL: SQL语句解析JSON文件** 在大数据处理和Web应用中，JSON（JavaScript Object Notation）格式已经成为数据交换的常见格式。然而，对于习惯使用SQL查询关系型数据库的人来说，处理JSON数据可能会觉得不太...
pb json 生成、解析，dw导入导出json，select-sql转json(20231120更新)
11-20
增加函数of_get_sqls_json、of_get_sqls_json1，利用sqlserver snc多查询语句执行接口，一次性执行多条select语句转入到json对象，调用方法参阅demo相关调用示例；增加of_getdwblob、of_setdwblob、of_getdsblob、of...
SQL Server中将查询结果转换为Json格式脚本分享
09-10
SELECT * FROM YourTable FOR JSON AUTO ``` 这条语句会自动将`YourTable`的结果转换为JSON格式。 总结来说，SQL Server提供了多种方式将查询结果转换为JSON，包括使用XML功能和内置的`FOR JSON`子句。选择哪种方法...
pb json 生成、解析，dw导入导出json，select_sql转json(20220511更新)
05-12
采用pb11.5 + pbni + vs2015 + ...3.增加跟PB程序现有数据库连结的绑定（sqlca或者自建的transobject对象）(目前只支持SNC sqlserver 2008接口)，直接sql语句生成json的功能，会比dw浏览完数据再生成json要快很多。
SQL SERVER 将XML变量转为JSON文本
09-10
函数的核心部分使用了嵌套的`SELECT`语句和`XML PATH`方法。外层`SELECT`用于构建JSON对象的数组结构，内层`SELECT`则用来解析XML数据并构造JSON键值对。`STUFF`函数用于插入和删除特定字符，例如在此案例中，用于在...
把省份（json数据）显示到select中
weixin_50751685的博客
07-25 663
把josn数据中全国的省份都显示到select里面
MySQL如何获取JSON串的值
u013851294的博客
11-14 2511
我们使用JSON_EXTRACT()、JSON_UNQUOTE() 这两个函数来操作。
sqlserver通过OPENJSON转换 json数据
slilx的博客
11-15 3631
行集函数可将 JSON 文本转换为一组行和列。使用 OPENJSON 将 JSON 集合转换为行集后，可以在返回的数据上运行任意 SQL 查询或将其插入到 SQL Server 表中。函数采用单个 JSON 对象或 JSON 对象的集合，并将其转换为一行或多行。可以添加可选的 WITH 子句来提供显式定义输出结构的架构。
Select下拉框json获取国家区号
oybn5201314的博客
04-04 993
应客户需求,填写电话区号时,要求下拉选择国家来获取该国家的电话区号.国家区码: country.json。
把SQL查询结果转为Json
qq_33246702的博客
02-24 4274
1. 普通查询 select * from test_table 2. 转为Json 方法：添加 FOR JSON PATH语句 select * from test_table for json path [{ "iid": 1, "value": 2 }, { "iid": 2, "value": 0 }, { "iid": 1, "value": 2 }, { "...
json转sql语句
10-25
3. 使用提取的值生成 SQL 查询语句。 例如，如果你有一个 JSON 字符串，其中包含一个名为 "users" 的数组，该数组包含多个用户对象，每个对象都有一个名为 "age" 的属性，你可以使用以下代码将其转换为 SQL 查询： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值