jsqlparser學習和測試代碼

一，jsqlparser簡介
jsqlparser是sql語法解析器，可以生成java類層次結構（是用java開發的解析器）。
主頁地址：http://jsqlparser.sourceforge.net
使用過程中的bug
1.tablenamefinder只能得到所有不重復的表名tablename，如果發生重復只能得到一個，不能重復獲取
2.left join 獲取查詢條件的時候，沒有left關鍵字

-----------join連接查詢----------
[INNER JOIN table_name2 ON table_name1.column_name = table_name2.column_name]
[JOIN table_name2 ON table_name1.column_name = table_name2.column_name]
[RIGHT JOIN table_name2 ON table_name1.column_name = table_name2.column_name]

3.查詢的過程中如果字段是* ,得到的結果也是*，目前沒有發現輸入* 直接返回該表格的所有字段

二，jsqlparser功能

總結來說jsqlparser有以下主要功能：
1.解析sql語句
2.加法和乘法的簡單的表達式求值器
3.構建sql

三，jsqlparser使用

解析sql語句塊
1.導入maven依賴 

<!-- https://mvnrepository.com/artifact/net.sf.jsqlparser/jsqlparser -->
<dependency>
  <groupId>net.sf.jsqlparser</groupId>
  <artifactId>jsqlparser</artifactId>
  <version>0.8.0</version>
</dependency>

2.參考代碼

package com.jsqlparser;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.util.TablesNamesFinder;
import net.sf.jsqlparser.util.deparser.ExpressionDeParser;

import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @describer:
 * @author:fanzhihui
 * @Date:2019/6/13
 * @Time:11:50
 */
public class SqlParser {
    /**
     * 查詢字段
     * @param sql
     * @return
     * @throws JSQLParserException
     */
    private static List<String> test_select_items(String sql)
            throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select select = (Select) parserManager.parse(new StringReader(sql));
        PlainSelect plain = (PlainSelect) select.getSelectBody();
        List<SelectItem> selectitems = plain.getSelectItems();
        List<String> str_items = new ArrayList<String>();
        if (selectitems != null) {
            for (SelectItem selectitem : selectitems) {
                str_items.add(selectitem.toString());
            }
        }
        return str_items;
    }

    /**
     * 查詢表名 table
     * @param sql
     * @return
     * @throws JSQLParserException
     */
    private static List<String> test_select_table(String sql)
            throws JSQLParserException {
        Statement statement = CCJSqlParserUtil.parse(sql);
        //  System.out.println(statement.toString());
        Select selectStatement = (Select) statement;
        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
        return tablesNamesFinder
                .getTableList(selectStatement);
    }

    /**
     * 查詢 join
     * @param sql
     * @return
     * @throws JSQLParserException
     */
    private static List<String> test_select_join(String sql)
            throws JSQLParserException {
        Statement statement = CCJSqlParserUtil.parse(sql);
        Select selectStatement = (Select) statement;

        PlainSelect plain = (PlainSelect) selectStatement.getSelectBody();
        //System.out.println(plain.toString());
        List<Join> joinList = plain.getJoins();
        List<String> tablewithjoin = new ArrayList<String>();
        if (joinList != null) {
            for (Join join : joinList) {
                join.setLeft(false);
                tablewithjoin.add(join.toString());
                //注意 ， leftjoin rightjoin 等等的to string()區別
            }
        }
        return tablewithjoin;
    }
    /**
     * 查詢where
     */
    private static String test_select_where(String sql)
            throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select select = (Select) parserManager.parse(new StringReader(sql));
        PlainSelect plain = (PlainSelect) select.getSelectBody();
        Expression where_expression = plain.getWhere();
        return where_expression.toString();
    }
    /**
     * 對where的結果進行解析
     */
    private static void testParseWhere1(String sql){
        try {
            Select select = (Select) CCJSqlParserUtil.parse(sql);
            SelectBody selectBody = select.getSelectBody();
            PlainSelect plainSelect = (PlainSelect)selectBody;

            Expression where = plainSelect.getWhere();
            ExpressionDeParser expressionDeParser = new ExpressionDeParser();
            plainSelect.getWhere().accept(expressionDeParser);

            // 此處根據where實際情況強轉 最外層
            EqualsTo equalsTo = (EqualsTo)where;
            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());

        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }

    /**
     * where兩個條件or連接
     * 代碼中有兩個條件or連接，可回憶轉成OrExpression,里面還是兩個EqualsTo。
     */
    private static void testParseWhere2(String sql){
        try {
            Select select = (Select)CCJSqlParserUtil.parse(sql);
            SelectBody selectBody = select.getSelectBody();
            PlainSelect plainSelect = (PlainSelect)selectBody;

            Expression where = plainSelect.getWhere();
            ExpressionDeParser expressionDeParser = new ExpressionDeParser();
            plainSelect.getWhere().accept(expressionDeParser);

            // 此處根據where實際情況強轉 最外層
            OrExpression orExpression = (OrExpression)where;
            EqualsTo equalsTo = (EqualsTo)orExpression.getLeftExpression();

            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());
            System.out.println("--------");
            equalsTo = (EqualsTo)orExpression.getRightExpression();

            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());

        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }
    /**
     * where三個條件or連接
     *得到的第一層的leftExpression還是一個orExpression,rightExpression是一個EqualsTo
     */
    private static void testParseWhere3(String sql){
        try {
            Select select = (Select)CCJSqlParserUtil.parse(sql);
            SelectBody selectBody = select.getSelectBody();
            PlainSelect plainSelect = (PlainSelect)selectBody;

            Expression where = plainSelect.getWhere();
            ExpressionDeParser expressionDeParser = new ExpressionDeParser();
            plainSelect.getWhere().accept(expressionDeParser);

            // 此處根據where實際情況強轉 最外層
            OrExpression orExpression = (OrExpression)where;

            OrExpression leftOrExpression = (OrExpression)orExpression.getLeftExpression();

            EqualsTo equalsTo = (EqualsTo)leftOrExpression.getLeftExpression();

            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());
            System.out.println("--------");
            equalsTo = (EqualsTo)leftOrExpression.getRightExpression();

            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());
            System.out.println("--------");
            equalsTo = (EqualsTo)orExpression.getRightExpression();

            System.out.println("Table:"+((Column)equalsTo.getLeftExpression()).getTable());
            System.out.println("Field:"+((Column)equalsTo.getLeftExpression()).getColumnName());
            System.out.println("equal:"+equalsTo.getRightExpression());

        } catch (JSQLParserException e) {
            e.printStackTrace();
        }
    }

    /**
     * 查詢 group by
     * @param sql
     * @return
     * @throws JSQLParserException
     */
    private static List<String> test_select_groupby(String sql)
            throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select select = (Select) parserManager.parse(new StringReader(sql));
        PlainSelect plain = (PlainSelect) select.getSelectBody();
        List<Expression> GroupByColumnReferences = plain
                .getGroupByColumnReferences();
        List<String> str_groupby = new ArrayList<String>();
        if (GroupByColumnReferences != null) {
            for (Expression groupByColumnReference : GroupByColumnReferences) {
                str_groupby.add(groupByColumnReference.toString());
            }
        }
        return str_groupby;
    }
    /**
     * 查詢order by
     */
    private static List<String> test_select_orderby(String sql)
            throws JSQLParserException {
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select select = (Select) parserManager.parse(new StringReader(sql));
        PlainSelect plain = (PlainSelect) select.getSelectBody();
        List<OrderByElement> OrderByElements = plain.getOrderByElements();
        List<String> str_orderby = new ArrayList<String>();
        if (OrderByElements != null) {
            for (OrderByElement orderByElement : OrderByElements) {
                str_orderby.add(orderByElement.toString());
            }
        }
        return str_orderby;
    }
    /**
     * 子查詢
     */
    private static Map test_select_subselect(SelectBody selectBody) throws JSQLParserException {
        Map<String, String> map = new HashMap<String, String>();

        if (selectBody instanceof PlainSelect) {
            List<SelectItem> selectItems = ((PlainSelect) selectBody).getSelectItems();
            for (SelectItem selectItem : selectItems) {
                if (selectItem.toString().contains("(") && selectItem.toString().contains(")")) {
                    map.put("selectItemsSubselect", selectItem.toString());
                }
            }
            Expression where = ((PlainSelect) selectBody).getWhere();
            String whereStr = where.toString();
            if (whereStr.contains("(") && whereStr.contains(")")) {
                int firstIndex = whereStr.indexOf("(");
                int lastIndex = whereStr.lastIndexOf(")");
                CharSequence charSequence = whereStr.subSequence(firstIndex, lastIndex + 1);
                map.put("whereSubselect", charSequence.toString());
            }

            FromItem fromItem = ((PlainSelect) selectBody).getFromItem();
//            System.out.println("111----"+((PlainSelect) selectBody).getFromItem());
//            System.out.println(fromItem);
            if (fromItem instanceof SubSelect) {
                map.put("fromItemSubselect", fromItem.toString());
            }

        } else if (selectBody instanceof WithItem) {
            SqlParser.test_select_subselect(((WithItem) selectBody).getSelectBody());
        }
        return map;
    }
    /**
     * 單表操作測試
     * @throws Exception
     */
    @org.junit.Test
    public void jsqlparser2() throws Exception{
        /**
         * 查詢字段
         */
        System.out.println("-----------查詢字段----------");
        String sql = "SELECT id,name,age FROM TABLE1";
        List<String> list = test_select_items(sql);
        System.out.println(list);
        /**
         * 查詢表名
         */
        System.out.println("-----------查詢表名----------");
        List<String> list1 = test_select_table(sql);
        System.out.println(list1);
        /**
         * join
         */
        System.out.println("-----------join連接查詢表名----------");
        String sql2 = "select id,name,age from table1 t1 left join table2 t2 on t1.id=t2.id left join table3 t3 on t3.id=t2.id";
        List<String> list2 = test_select_table(sql2);
        System.out.println(list2);
        //inner join
        System.out.println("-----------join連接查詢----------");
        String sql7 = "SELECT column_name(s)\n" +
                "FROM table_name1\n" +
                "INNER JOIN table_name2 \n" +
                "ON table_name1.column_name=table_name2.column_name;";
        List<String> selectJoin1 = test_select_join(sql7);
        System.out.println(selectJoin1);
        //left join
        String sql8 = "SELECT column_name(s)\n" +
                "FROM table_name1\n" +
                "LEFT JOIN table_name2 \n" +
                "ON table_name1.column_name=table_name2.column_name;";
        List<String> selectJoin2 = test_select_join(sql8);
        System.out.println(selectJoin2);
        //right join
        String sql9 = "SELECT column_name(s)\n" +
                "FROM table_name1\n" +
                "right join table_name2 \n" +
                "ON table_name1.column_name=table_name2.column_name;";
        List<String> selectJoin3 = test_select_join(sql9);
        System.out.println(selectJoin3);
        /**
         * where
         */
        System.out.println("-----------where查詢所有的條件----------");
        String sql3="select * from table1 where id=1 and id=2";
        String selectWhere = test_select_where(sql3);
        System.out.println(selectWhere);
        /**
         * where or條件查詢
         */
        System.out.println("-----------where單個條件or連接----------");
        String sqlw1 = "select *from A as a left join B on a.bid = B.id left join C on A.cid = C.id left join D on B.did = D.id where a.id = 23";
        testParseWhere1(sqlw1);
        System.out.println("-----------where兩個條件or連接--------");
        String sqlw2 = "select *from A as a left join B on a.bid = B.id left join C on A.cid = C.id left join D on B.did = D.id where a.id = 23 or b.id = 34";
        testParseWhere2(sqlw2);
        System.out.println("-----------where三個條件or連接--------");
        String sqlw3 = "select *from A as a left join B on a.bid = B.id left join C on A.cid = C.id left join D on B.did = D.id where a.id = 23 or b.id = 34 or c.id = 54";
        testParseWhere3(sqlw3);
        /**
         * 查詢group by
         */
        System.out.println("-----------group by--------");
        String sql4="select id,name,age from core_user group by id";
        List<String> select_groupby = test_select_groupby(sql4);
        System.out.println(select_groupby);
        /**
         * 查詢order by
         */
        System.out.println("-----------order by--------");
        String sql5="select id,name,age from core_user order by id";
        List<String> select_orderby = test_select_orderby(sql5);
        System.out.println(select_orderby);
        /**
         * 子查詢
         */
        System.out.println("-----------子查詢--------");
        String sql6 = "select age,sex,(select dno from employee where salary >=5000) from (select dno from employee5 where salary >=5000) a where did in(select dno from employee3 where salary >=5000);";
        CCJSqlParserManager parserManager = new CCJSqlParserManager();
        Select selectStatement = (Select) parserManager.parse(new StringReader(sql6));
        Map map = test_select_subselect(selectStatement.getSelectBody());
        System.out.println(map.toString());
        //查詢結果
        /*{whereSubselect=(SELECT dno FROM employee3 WHERE salary >= 5000),
         fromItemSubselect=(SELECT dno FROM employee5 WHERE salary >= 5000) a,
         selectItemsSubselect=(SELECT dno FROM employee WHERE salary >= 5000)
         }
         說明： whereSubselect 條件
                fromItemSubselect 表格
                selectItemsSubselect字段
         */


    }
}

3.測試結果

-----------查詢字段----------
[id, name, age]
-----------查詢表名----------
[TABLE1]
-----------join連接查詢表名----------
[table1, table2, table3]
-----------join連接查詢----------
[INNER JOIN table_name2 ON table_name1.column_name = table_name2.column_name]
[JOIN table_name2 ON table_name1.column_name = table_name2.column_name]
[RIGHT JOIN table_name2 ON table_name1.column_name = table_name2.column_name]
-----------where查詢所有的條件----------
id = 1 AND id = 2
-----------where單個條件or連接----------
Table:a
Field:id
equal:23
-----------where兩個條件or連接--------
Table:a
Field:id
equal:23
--------
Table:b
Field:id
equal:34
-----------where三個條件or連接--------
Table:a
Field:id
equal:23
--------
Table:b
Field:id
equal:34
--------
Table:c
Field:id
equal:54
-----------group by--------
[id]
-----------order by--------
[id]
-----------子查詢--------
{whereSubselect=(SELECT dno FROM employee3 WHERE salary >= 5000), fromItemSubselect=(SELECT dno FROM employee5 WHERE salary >= 5000) a, selectItemsSubselect=(SELECT dno FROM employee WHERE salary >= 5000)}

Process finished with exit code 0

 

使用JSqlParser進行加法和乘法的非常簡單的表達式求值器。ExpressionDeParser用於遍歷和解釋解析樹。

1.參考代碼

 package com.jsqlparser;

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.util.deparser.ExpressionDeParser;

import java.util.Stack;

/**
 * @describer:
 * @author:fanzhihui
 * @Date:2019/6/14
 * @Time:9:47
 */
public class Expression {
    static void evaluate(String expr) throws JSQLParserException {
        final Stack<Long> stack = new Stack<Long>();
        System.out.println("expr=" + expr);
        net.sf.jsqlparser.expression.Expression parseExpression= CCJSqlParserUtil.parseExpression(expr);
        ExpressionDeParser deparser = new ExpressionDeParser() {
            @Override
            public void visit(Addition addition) {
                super.visit(addition);

                long sum1 = stack.pop();
                long sum2 = stack.pop();

                stack.push(sum1 + sum2);
            }

            @Override
            public void visit(Multiplication multiplication) {
                super.visit(multiplication);

                long fac1 = stack.pop();
                long fac2 = stack.pop();

                stack.push(fac1 * fac2);
            }

            @Override
            public void visit(LongValue longValue) {
                super.visit(longValue);
                stack.push(longValue.getValue());
            }
        };
        StringBuilder b = new StringBuilder();
        deparser.setBuffer(b);
        parseExpression.accept(deparser);

        System.out.println(expr + " = " + stack.pop() );
    }
    public static void main( String[] args ) throws JSQLParserException {
        evaluate("4+5*6");
        evaluate("4*5+6");
        evaluate("4*(5+6)");
        evaluate("4*(5+6)*(2+3)");
    }

2.測試結果

expr=4+5*6
4+5*6 = 34
expr=4*5+6
4*5+6 = 26
expr=4*(5+6)
4*(5+6) = 44
expr=4*(5+6)*(2+3)
4*(5+6)*(2+3) = 220

Process finished with exit code 0

 

SQL構建

1.參考代碼（簡單的插入）

package com.jsqlparser;

import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.ItemsListVisitor;
import net.sf.jsqlparser.expression.operators.relational.MultiExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SubSelect;
import net.sf.jsqlparser.util.SelectUtils;
import org.junit.Test;

/**
 * @describer:
 * @author:fanzhihui
 * @Date:2019/6/14
 * @Time:10:34
 */
public class CreateTabel {
    /**
     * 簡單的插入
     * @throws Exception
     */
    public static void createTable() throws  Exception{
        Insert insert = (Insert) CCJSqlParserUtil.parse("insert into mytable (col1) values (1)");
        System.out.println(insert.toString());
        //adding a column
        insert.getColumns().add(new Column("col2"));
        //adding a value using a visitor
        insert.getItemsList().accept(new ItemsListVisitor() {
            @Override
            public void visit(SubSelect subSelect) {
                throw new UnsupportedOperationException("Not supported yet.");
            }
            @Override
            public void visit(ExpressionList expressionList) {
                expressionList.getExpressions().add(new LongValue(5));
            }
            @Override
            public void visit(MultiExpressionList multiExprList) {
                throw new UnsupportedOperationException("Not supported yet.");
            }
        });
        System.out.println(insert.toString());
        //adding another column
        insert.getColumns().add(new Column("col3"));
        //adding another value (the easy way)
        ((ExpressionList)insert.getItemsList()).getExpressions().add(new LongValue(10));
        System.out.println(insert.toString());
    }
    @Test
    public void add() throws  Exception{
        createTable();
    }
} 

2.測試結果

INSERT INTO mytable (col1) VALUES (1)
INSERT INTO mytable (col1, col2) VALUES (1, 5)
INSERT INTO mytable (col1, col2, col3) VALUES (1, 5, 10)

Process finished with exit code 0

 

 

原文：
https://blog.csdn.net/wocan23/article/details/82383070
https://blog.csdn.net/liu22985342/article/details/82935980
https://blog.csdn.net/qq_26458903/article/details/89924187

 

聲明：此博客為個人學習之用，如與其他作品雷同，純屬巧合，轉載請指明出處！