JSqlParse解析动态Sql

最新推荐文章于 2024-08-09 09:36:17 发布
最新推荐文章于 2024-08-09 09:36:17 发布
阅读量1.5k 收藏
点赞数
文章标签： sql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mhl8519/article/details/132102290
版权

想要实现一个插件功能，得到请求与表字段之间的映射关系，比如：

    功能A
        表1
            字段a
            字段b
    功能B
        表1
            字段c
        表2
            字段d
            字段e

    ...

    思路主要类似分布式日志一样，各服务请求透传一个唯一标识，比如请求路径，然后再通过拦截器获取具体执行的Sql语句，通过解析sql来获取表及字段，从而构建映射关系。
    刚开始用以为自己去遍历递归，后来查到神器JSqlParse，看到Visitor设计模式实现效果，感觉真心强。
    JDK1.8
    Maven版本
    <dependency>
        <groupId>com.github.jsqlparser</groupId>
        <artifactId>jsqlparser</artifactId>
        <version>4.6</version>
    </dependency>
    对于复杂的Sql处理，各种嵌套、函数、子查询，都可解析，只要自己去实现各个具体的方法。
    以下是仅是解析Sql简单的例子，有的地方还需要根据自己实际需求去调整，仅供参考。

package test;

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

import net.sf.jsqlparser.expression.AllValue;
import net.sf.jsqlparser.expression.AnalyticExpression;
import net.sf.jsqlparser.expression.AnyComparisonExpression;
import net.sf.jsqlparser.expression.ArrayConstructor;
import net.sf.jsqlparser.expression.ArrayExpression;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.CaseExpression;
import net.sf.jsqlparser.expression.CastExpression;
import net.sf.jsqlparser.expression.CollateExpression;
import net.sf.jsqlparser.expression.ConnectByRootOperator;
import net.sf.jsqlparser.expression.DateTimeLiteralExpression;
import net.sf.jsqlparser.expression.DateValue;
import net.sf.jsqlparser.expression.DoubleValue;
import net.sf.jsqlparser.expression.ExpressionVisitor;
import net.sf.jsqlparser.expression.ExtractExpression;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.expression.HexValue;
import net.sf.jsqlparser.expression.IntervalExpression;
import net.sf.jsqlparser.expression.JdbcNamedParameter;
import net.sf.jsqlparser.expression.JdbcParameter;
import net.sf.jsqlparser.expression.JsonAggregateFunction;
import net.sf.jsqlparser.expression.JsonExpression;
import net.sf.jsqlparser.expression.JsonFunction;
import net.sf.jsqlparser.expression.KeepExpression;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.MySQLGroupConcat;
import net.sf.jsqlparser.expression.NextValExpression;
import net.sf.jsqlparser.expression.NotExpression;
import net.sf.jsqlparser.expression.NullValue;
import net.sf.jsqlparser.expression.NumericBind;
import net.sf.jsqlparser.expression.OracleHierarchicalExpression;
import net.sf.jsqlparser.expression.OracleHint;
import net.sf.jsqlparser.expression.OracleNamedFunctionParameter;
import net.sf.jsqlparser.expression.OverlapsCondition;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.RowConstructor;
import net.sf.jsqlparser.expression.RowGetExpression;
import net.sf.jsqlparser.expression.SafeCastExpression;
import net.sf.jsqlparser.expression.SignedExpression;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.TimeKeyExpression;
import net.sf.jsqlparser.expression.TimeValue;
import net.sf.jsqlparser.expression.TimestampValue;
import net.sf.jsqlparser.expression.TimezoneExpression;
import net.sf.jsqlparser.expression.TryCastExpression;
import net.sf.jsqlparser.expression.UserVariable;
import net.sf.jsqlparser.expression.ValueListExpression;
import net.sf.jsqlparser.expression.VariableAssignment;
import net.sf.jsqlparser.expression.WhenClause;
import net.sf.jsqlparser.expression.XMLSerializeExpr;
import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseOr;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseRightShift;
import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor;
import net.sf.jsqlparser.expression.operators.arithmetic.Concat;
import net.sf.jsqlparser.expression.operators.arithmetic.Division;
import net.sf.jsqlparser.expression.operators.arithmetic.IntegerDivision;
import net.sf.jsqlparser.expression.operators.arithmetic.Modulo;
import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication;
import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.conditional.XorExpression;
import net.sf.jsqlparser.expression.operators.relational.Between;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExistsExpression;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.FullTextSearch;
import net.sf.jsqlparser.expression.operators.relational.GeometryDistance;
import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.expression.operators.relational.IsBooleanExpression;
import net.sf.jsqlparser.expression.operators.relational.IsDistinctExpression;
import net.sf.jsqlparser.expression.operators.relational.IsNullExpression;
import net.sf.jsqlparser.expression.operators.relational.ItemsListVisitor;
import net.sf.jsqlparser.expression.operators.relational.JsonOperator;
import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
import net.sf.jsqlparser.expression.operators.relational.Matches;
import net.sf.jsqlparser.expression.operators.relational.MinorThan;
import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
import net.sf.jsqlparser.expression.operators.relational.MultiExpressionList;
import net.sf.jsqlparser.expression.operators.relational.NamedExpressionList;
import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
import net.sf.jsqlparser.expression.operators.relational.RegExpMatchOperator;
import net.sf.jsqlparser.expression.operators.relational.RegExpMySQLOperator;
import net.sf.jsqlparser.expression.operators.relational.SimilarToExpression;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.AllColumns;
import net.sf.jsqlparser.statement.select.AllTableColumns;
import net.sf.jsqlparser.statement.select.FromItemVisitor;
import net.sf.jsqlparser.statement.select.LateralSubSelect;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.OrderByVisitor;
import net.sf.jsqlparser.statement.select.ParenthesisFromItem;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectExpressionItem;
import net.sf.jsqlparser.statement.select.SelectItemVisitor;
import net.sf.jsqlparser.statement.select.SelectVisitor;
import net.sf.jsqlparser.statement.select.SetOperationList;
import net.sf.jsqlparser.statement.select.SubJoin;
import net.sf.jsqlparser.statement.select.SubSelect;
import net.sf.jsqlparser.statement.select.TableFunction;
import net.sf.jsqlparser.statement.select.ValuesList;
import net.sf.jsqlparser.statement.select.WithItem;
import net.sf.jsqlparser.statement.values.ValuesStatement;

public class SelectTablesColumns implements SelectVisitor,SelectItemVisitor,FromItemVisitor,ExpressionVisitor,ItemsListVisitor,OrderByVisitor{
	public SelectTablesColumns(String id){
		this.id = id;
	}
	private String id;

	private List<String> tables;

	public List<String> getTableList(Select select) {
		tables = new ArrayList<String>();
		select.getSelectBody().accept(this);
		return tables;
	}

	public void visit(Table tableName) {
		String tableWholeName = tableName.getDBLinkName();
		tables.add(tableWholeName+" "+tableName.getAlias());
	}
	
	public void visit(SubSelect subSelect) {
		subSelect.getSelectBody().accept(this);
	}

	@Override
	public void visit(PlainSelect plainSelect) {
		if(null!=plainSelect.getSelectItems()){
			plainSelect.getSelectItems().stream().forEach(o->o.accept(this));
		}
		if(null!=plainSelect.getFromItem()){
			plainSelect.getFromItem().accept(this);
		}
		if(null!=plainSelect.getJoins()){
			plainSelect.getJoins().stream().forEach(o->o.getRightItem().accept(this));
		}
		if(null!=plainSelect.getWhere()){
			plainSelect.getWhere().accept(this);
		}
		
		if(null!=plainSelect.getOrderByElements()){
			plainSelect.getOrderByElements().stream().forEach(o->o.accept(this));
		}
	}

	@Override
	public void visit(SetOperationList setOpList) {
		System.out.println("SetOperationList");
	}

	@Override
	public void visit(WithItem withItem) {
		System.out.println("WithItem");
	}

	@Override
	public void visit(ValuesStatement aThis) {
		System.out.println("ValuesStatement");
	}

	@Override
	public void visit(SelectExpressionItem selectExpressionItem) {
		System.out.println("SelectExpressionItem");
		selectExpressionItem.getExpression().accept(this);
	}
	
	@Override
	public void visit(SubJoin subjoin) {
		System.out.println("SubJoin:");
	}

	@Override
	public void visit(LateralSubSelect lateralSubSelect) {
		System.out.println("LateralSubSelect");
	}

	@Override
	public void visit(ValuesList valuesList) {
		System.out.println("ValuesList");
	}

	@Override
	public void visit(TableFunction tableFunction) {
		System.out.println("TableFunction");
	}

	@Override
	public void visit(ParenthesisFromItem aThis) {
		System.out.println("ParenthesisFromItem");
	}

	@Override
	public void visit(BitwiseRightShift aThis) {
		System.out.println("BitwiseRightShift");
	}

	@Override
	public void visit(BitwiseLeftShift aThis) {
		System.out.println("BitwiseLeftShift");
	}

	@Override
	public void visit(NullValue nullValue) {
		System.out.println("NullValue");
	}

	@Override
	public void visit(Function function) {
		System.out.println("Function");
		
		//SUB_STR(ID2,1,6)
		System.out.println(function.getMultipartName());//[SUB_STR]
//		System.out.println(function.getParameters());// ID2,1,6
//		
//		System.out.println(function.getAttribute());//null
//		System.out.println(function.getName());//SUB_STR
//		System.out.println(function.getKeep());//null
//		System.out.println(function.getNamedParameters());//null
//		System.out.println();//null
		if(null!=function.getParameters()){
			function.getParameters().getExpressions().stream().forEach(o->o.accept(this));
		}
	}

	@Override
	public void visit(SignedExpression signedExpression) {
		System.out.println("SignedExpression");
	}

	@Override
	public void visit(JdbcParameter jdbcParameter) {
		System.out.println("JdbcParameter");
	}

	@Override
	public void visit(JdbcNamedParameter jdbcNamedParameter) {
		System.out.println("JdbcNamedParameter");
	}

	@Override
	public void visit(DoubleValue doubleValue) {
		System.out.println("DoubleValue");
		System.out.println("DoubleValue="+doubleValue);
	}

	@Override
	public void visit(LongValue longValue) {
		System.out.println("LongValue");
		System.out.println("LongValue="+longValue);
	}

	@Override
	public void visit(HexValue hexValue) {
		System.out.println("HexValue");
		System.out.println("HexValue="+hexValue);
	}

	@Override
	public void visit(DateValue dateValue) {
		System.out.println("DateValue");
		System.out.println("DateValue="+dateValue);
	}

	@Override
	public void visit(TimeValue timeValue) {
		System.out.println("TimeValue");
		System.out.println("TimeValue="+timeValue);
	}

	@Override
	public void visit(TimestampValue timestampValue) {
		System.out.println("TimestampValue");
		System.out.println("TimestampValue="+timestampValue);
	}

	@Override
	public void visit(Parenthesis parenthesis) {
		System.out.println("Parenthesis");
		System.out.println("Parenthesis="+parenthesis);
	}

	@Override
	public void visit(StringValue stringValue) {
		System.out.println("StringValue");
		System.out.println("StringValue="+stringValue);
	}

	@Override
	public void visit(Addition addition) {
		System.out.println("Addition");
		visitBinaryExpression(addition);
	}

	@Override
	public void visit(Division division) {
		System.out.println("Division");
		visitBinaryExpression(division);
	}

	@Override
	public void visit(IntegerDivision division) {
		System.out.println("IntegerDivision");
		visitBinaryExpression(division);
	}

	@Override
	public void visit(Multiplication multiplication) {
		System.out.println("Multiplication");
		visitBinaryExpression(multiplication);
	}

	@Override
	public void visit(Subtraction subtraction) {
		System.out.println("Subtraction");
		visitBinaryExpression(subtraction);
	}

	@Override
	public void visit(AndExpression andExpression) {
		System.out.println("AndExpression");
		visitBinaryExpression(andExpression);
	}
	
	@Override
	public void visit(OrExpression orExpression) {
		System.out.println("OrExpression");
		visitBinaryExpression(orExpression);
	}

	public void visitBinaryExpression(BinaryExpression binaryExpression) {
		binaryExpression.getLeftExpression().accept(this);
		binaryExpression.getRightExpression().accept(this);
	}
	
	@Override
	public void visit(XorExpression orExpression) {
		System.out.println("XorExpression");
		visitBinaryExpression(orExpression);
	}

	@Override
	public void visit(Between between) {
		System.out.println("Between");
		between.getBetweenExpressionStart().accept(this);
		between.getBetweenExpressionEnd().accept(this);
	}

	@Override
	public void visit(OverlapsCondition overlapsCondition) {
		System.out.println("OverlapsCondition");
		overlapsCondition.getLeft().getExpressions().stream().forEach(o->o.accept(this));
		overlapsCondition.getRight().getExpressions().stream().forEach(o->o.accept(this));
	}

	@Override
	public void visit(EqualsTo equalsTo) {
		System.out.println("EqualsTo");
		visitBinaryExpression(equalsTo);
	}

	@Override
	public void visit(GreaterThan greaterThan) {
		System.out.println("GreaterThan");
		visitBinaryExpression(greaterThan);
	}

	@Override
	public void visit(GreaterThanEquals greaterThanEquals) {
		System.out.println("GreaterThanEquals");
		visitBinaryExpression(greaterThanEquals);
	}

	@Override
	public void visit(InExpression inExpression) {
		System.out.println("InExpression");
		inExpression.getLeftExpression().accept(this);
		inExpression.getRightExpression().accept(this);
	}

	@Override
	public void visit(FullTextSearch fullTextSearch) {
		System.out.println("FullTextSearch");
		
	}

	@Override
	public void visit(IsNullExpression isNullExpression) {
		System.out.println("IsNullExpression");
		
	}

	@Override
	public void visit(IsBooleanExpression isBooleanExpression) {
		System.out.println("IsBooleanExpression");
		
	}

	@Override
	public void visit(LikeExpression likeExpression) {
		System.out.println("LikeExpression");
		visitBinaryExpression(likeExpression);
	}

	@Override
	public void visit(MinorThan minorThan) {
		System.out.println("MinorThan");
		visitBinaryExpression(minorThan);
	}

	@Override
	public void visit(MinorThanEquals minorThanEquals) {
		System.out.println("MinorThanEquals");
		visitBinaryExpression(minorThanEquals);
	}

	@Override
	public void visit(NotEqualsTo notEqualsTo) {
		System.out.println("NotEqualsTo");
		visitBinaryExpression(notEqualsTo);
	}

	@Override
	public void visit(Column tableColumn) {
		System.out.println("Column");
		System.out.println(tableColumn.toString());
	}

	@Override
	public void visit(CaseExpression caseExpression) {
		System.out.println("CaseExpression");
		
	}

	@Override
	public void visit(WhenClause whenClause) {
		System.out.println("WhenClause");
		
	}

	@Override
	public void visit(ExistsExpression existsExpression) {
		System.out.println("ExistsExpression");
		
	}

	@Override
	public void visit(AnyComparisonExpression anyComparisonExpression) {
		System.out.println("AnyComparisonExpression");
		
	}

	@Override
	public void visit(Concat concat) {
		System.out.println("Concat");
		visitBinaryExpression(concat);
	}

	@Override
	public void visit(Matches matches) {
		System.out.println("Matches");
		visitBinaryExpression(matches);
	}

	@Override
	public void visit(BitwiseAnd bitwiseAnd) {
		System.out.println("BitwiseAnd");
		visitBinaryExpression(bitwiseAnd);
	}

	@Override
	public void visit(BitwiseOr bitwiseOr) {
		System.out.println("BitwiseOr");
		visitBinaryExpression(bitwiseOr);
	}

	@Override
	public void visit(BitwiseXor bitwiseXor) {
		System.out.println("BitwiseXor");
		visitBinaryExpression(bitwiseXor);
	}

	@Override
	public void visit(CastExpression cast) {
		System.out.println("CastExpression");
		
	}

	@Override
	public void visit(TryCastExpression cast) {
		System.out.println("TryCastExpression");
		
	}

	@Override
	public void visit(SafeCastExpression cast) {
		System.out.println("SafeCastExpression");
		
	}

	@Override
	public void visit(Modulo modulo) {
		System.out.println("Modulo");
		visitBinaryExpression(modulo);
	}

	@Override
	public void visit(AnalyticExpression aexpr) {
		System.out.println("AnalyticExpression");
		
	}

	@Override
	public void visit(ExtractExpression eexpr) {
		System.out.println("ExtractExpression");
		
	}

	@Override
	public void visit(IntervalExpression iexpr) {
		System.out.println("IntervalExpression");
		
	}

	@Override
	public void visit(OracleHierarchicalExpression oexpr) {
		System.out.println("OracleHierarchicalExpression");
		
	}

	@Override
	public void visit(RegExpMatchOperator rexpr) {
		System.out.println("RegExpMatchOperator");
		visitBinaryExpression(rexpr);
	}

	@Override
	public void visit(JsonExpression jsonExpr) {
		System.out.println("JsonExpression");
		
	}

	@Override
	public void visit(JsonOperator jsonExpr) {
		System.out.println("JsonOperator");
		visitBinaryExpression(jsonExpr);
	}

	@Override
	public void visit(RegExpMySQLOperator regExpMySQLOperator) {
		System.out.println("RegExpMySQLOperator");
		visitBinaryExpression(regExpMySQLOperator);
	}

	@Override
	public void visit(UserVariable var) {
		System.out.println("UserVariable");
		
	}

	@Override
	public void visit(NumericBind bind) {
		System.out.println("NumericBind");
		
	}

	@Override
	public void visit(KeepExpression aexpr) {
		System.out.println("KeepExpression");
		
	}

	@Override
	public void visit(MySQLGroupConcat groupConcat) {
		System.out.println("MySQLGroupConcat");
		
	}

	@Override
	public void visit(ValueListExpression valueList) {
		System.out.println("ValueListExpression");
		
	}

	@Override
	public void visit(RowConstructor rowConstructor) {
		System.out.println("RowConstructor");
		
	}

	@Override
	public void visit(RowGetExpression rowGetExpression) {
		System.out.println("RowGetExpression");
		
	}

	@Override
	public void visit(OracleHint hint) {
		System.out.println("OracleHint");
		
	}

	@Override
	public void visit(TimeKeyExpression timeKeyExpression) {
		System.out.println("TimeKeyExpression");
		
	}

	@Override
	public void visit(DateTimeLiteralExpression literal) {
		System.out.println("DateTimeLiteralExpression");
		
	}

	@Override
	public void visit(NotExpression aThis) {
		System.out.println("NotExpression");
		
	}

	@Override
	public void visit(NextValExpression aThis) {
		System.out.println("NextValExpression");
		
	}

	@Override
	public void visit(CollateExpression aThis) {
		System.out.println("CollateExpression");
		
	}

	@Override
	public void visit(SimilarToExpression aThis) {
		System.out.println("SimilarToExpression");
		visitBinaryExpression(aThis);
	}

	@Override
	public void visit(ArrayExpression aThis) {
		System.out.println("ArrayExpression");
		
	}

	@Override
	public void visit(ArrayConstructor aThis) {
		System.out.println("ArrayConstructor");
		
	}

	@Override
	public void visit(VariableAssignment aThis) {
		System.out.println("VariableAssignment");
		
	}

	@Override
	public void visit(XMLSerializeExpr aThis) {
		System.out.println("XMLSerializeExpr");
	}

	@Override
	public void visit(TimezoneExpression aThis) {
		System.out.println("TimezoneExpression");
		
	}

	@Override
	public void visit(JsonAggregateFunction aThis) {
		System.out.println("JsonAggregateFunction");
		
	}

	@Override
	public void visit(JsonFunction aThis) {
		System.out.println("JsonFunction");
		
	}

	@Override
	public void visit(ConnectByRootOperator aThis) {
		System.out.println("ConnectByRootOperator");
		
	}

	@Override
	public void visit(OracleNamedFunctionParameter aThis) {
		System.out.println("OracleNamedFunctionParameter");
	}

	@Override
	public void visit(AllColumns allColumns) {
		System.out.println("AllColumns");
		System.out.println(allColumns);
	}

	@Override
	public void visit(AllTableColumns allTableColumns) {
		System.out.println("AllTableColumns");
		
	}

	@Override
	public void visit(AllValue allValue) {
		System.out.println("AllValue");
		
	}

	@Override
	public void visit(IsDistinctExpression isDistinctExpression) {
		System.out.println("IsDistinctExpression");
		visitBinaryExpression(isDistinctExpression);
	}

	@Override
	public void visit(GeometryDistance geometryDistance) {
		System.out.println("GeometryDistance");
		visitBinaryExpression(geometryDistance);
	}

	@Override
	public void visit(ExpressionList expressionList) {
		System.out.println("ExpressionList");
		
	}

	@Override
	public void visit(NamedExpressionList namedExpressionList) {
		System.out.println("NamedExpressionList");
		
	}

	@Override
	public void visit(MultiExpressionList multiExprList) {
		System.out.println("MultiExpressionList");
		
	}

	@Override
	public void visit(OrderByElement orderBy) {
		System.out.println("OrderByElement");
		orderBy.getExpression().accept(this);
		if(orderBy.isAsc()){
			System.out.println("ASC");
		}else{
			System.out.println("DESC");
		}
	}
}

测试样例：

package test;

import java.io.StringReader;
import java.util.List;

import cold.light.level.util.ClDateUtil;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.parser.CCJSqlParserManager;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.update.Update;

public class TestSql {
	public static void main(String[] args) throws JSQLParserException {
		CCJSqlParserManager pm = new CCJSqlParserManager();
		
		String id = ClDateUtil.getDateTimeMS();
		String initSql = "SELECT * FROM MY_TABLE1 a, MY_TABLE2 b, (SELECT * FROM MY_TABLE3) c LEFT OUTER JOIN MY_TABLE4 d"+
				" WHERE ID = (SELECT MAX(ID) FROM MY_TABLE5) OR ID2 IN (SELECT * FROM MY_TABLE6 WHERE NAME='AA') AND MAX(ID1,ID2,ID3) > 4 ORDER BY ID1 ASC,SUB_STR(IFNULL(ID2,'123456'),1,6) DESC" ;
		
		System.out.println(initSql);
		Statement statement = pm.parse(new StringReader(initSql));
		
		if (statement instanceof Select) {
			Select selectStatement = (Select) statement;
			SelectTablesColumns tablesNamesFinder = new SelectTablesColumns(id);
			List tableList = tablesNamesFinder.getTableList(selectStatement);
//			for (Iterator iter = tableList.iterator(); iter.hasNext();) {
//				System.out.println(iter.next());
//			}
		}
	}
}

输出结果：
SELECT * FROM MY_TABLE1 a, MY_TABLE2 b, (SELECT * FROM MY_TABLE3) c LEFT OUTER JOIN MY_TABLE4 d WHERE ID = (SELECT MAX(ID) FROM MY_TABLE5) OR ID2 IN (SELECT * FROM MY_TABLE6 WHERE NAME='AA') AND MAX(ID1,ID2,ID3) > 4 ORDER BY ID1 ASC,SUB_STR(IFNULL(ID2,'123456'),1,6) DESC
AllColumns
*
AllColumns
*
OrExpression
EqualsTo
Column
ID
SelectExpressionItem
Function
[MAX]
Column
ID
AndExpression
InExpression
Column
ID2
AllColumns
*
EqualsTo
Column
NAME
StringValue
StringValue='AA'
GreaterThan
Function
[MAX]
Column
ID1
Column
ID2
Column
ID3
LongValue
LongValue=4
OrderByElement
Column
ID1
ASC
OrderByElement
Function
[SUB_STR]
Function
[IFNULL]
Column
ID2
StringValue
StringValue='123456'
LongValue
LongValue=1
LongValue
LongValue=6
DESC

同理可实现Update、Insert、Delete等Sql的解析。

奔向阳光随风奔跑
关注
Sql解析转换之JSqlParse完整介绍
jiey0407的博客
07-31 2087
JSqlParse的总体代码量不大，结构也很简单，其项目整体结构图如下可以看到其总共只有五个大的包，各个包的功能定义也很清晰expression包含表达式相关的类和接口，可以简单看做sql解析后的组成对象之一。如果需要对sql进行一些更改变换，基本都会涉及到这个包。parseJSqlParse最核心的包，这个包里的类实现了sql的解析，进而我们才可以对解析后的sql(“java类”)做各种自定义处理。sql语句的修改是通过实现对应的访问者接口实现的//1、获取原始sql输入。...
【组件】JAVA解析SQL语句jsqlparser
我是Superman丶的博客
03-16 4311
jsqlparser 依赖maven <!-- https://mvnrepository.com/artifact/com.github.jsqlparser/jsqlparser --> <dependency> <groupId>com.github.jsqlparser</groupId> <artifactId>jsqlparser</ar..
jsqlparser sql解析器
01-15
jsqlparser sql解析器 JSqlParser is a SQL statement parser. It translates SQLs in a traversable hierarchy of Java classes. JSqlParser is not limited to one database but provides support for a lot of specials of Oracle, SqlServer, MySQL, PostgreSQL ...
net.sf.jsqlparser.statement.select.SelectItem
最新发布
Rui_bbm的博客
08-09 1530
今天一启动项目，出现了这个错误，仔细想了想，应该是昨天合并代码，导致的mybatis-plus版本冲突，以及分页PageHelper版本不兼容。可以看见这个我是最下边的 Caused by 报错信息，这个地方提示我。在我的项目中，common模块中mybatis-plus 重复导入依赖。在我的server模块中可以看见这个关于jsqlparser依赖。这个依赖是导致项目启动失败的根本原因，一定要将其注释。重新启动项目，可以看见已经可以正常启动！这里我直接将这个依赖注释掉防止重复依赖注入。
JSqlParser 解析 sql
西凉的悲伤博客
07-12 948
JSqlParser是一个 SQL 语句解析器。它将 SQL 语句转换为可遍历的 Java 类层次结构，可以方便的用代码对 SQL 语句进行解析，修改等操作。jsqlparser API 文档jsqlparser github 地址。
JSqlParser-解析SQL工具类
zuihongyan518的博客
04-14 7200
JSqlParse是一款很精简的sql解析工具，本文封装JSqlParse解析SQL处理工具。
JSqlParser-SQL解析处理
喝醉的咕咕鸟
07-07 7355
JSqlParse是一款很精简的sql解析工具，将sql语句转成Java对象，同时也可以根据Java对象进行构建数据库sql。
JSqlParser入门系列(4)-JSqlParser之SQL解析
记录知识、锤炼自我
03-20 7223
前言 JSqlParser可以解析SQL为JAVA对象，以便于获取SQL中的相关信息并进行修改。 一般使用CCJSqlParserUtil工具类直接解析SQ;，根据SQL类型转换为增删改查对象，再获取或修改对象中相关信息。 查询解析 /** * SQL 解析 * * @throws JSQLParserException */ @Test public void testSelectParser() throws JSQLParserExcep
jsqlparser解析复杂sql
04-24
jsqlparser解析复杂sql 获取where条件字段 select字段 表名table 查询join 查询 group by 查询order by 子查询 判断是否为多级子查询
java的sql解析器jsqlparser
07-14
然后，你可以创建一个`CCJSqlParserManager`实例，使用它来解析SQL字符串，得到AST。之后，遍历AST并提取所需信息。例如，以下是一个简单的代码片段： ```java import net.sf.jsqlparser.JSQLParserException; ...
SQL WHERE 条件解析器
10-31
在实际应用中，`SQL WHERE 条件解析器`通常与前端界面结合，用户可以通过界面上的控件设置查询条件，后端服务接收到这些条件后，通过解析器生成相应的SQL查询，从而返回符合用户需求的数据。 总结来说，`SQL WHERE ...
基于SQL 语法解释器JSqlParser实现的SQL解析工具
04-06
NULL 博文链接：https://lxy19791111.iteye.com/blog/1543223
利用jsqlparser解析SQL语句
热门推荐
SteelZheng
09-26 2万+
时常会遇到很多情况，我们需要对SQL语句进行替换或者拼接。以往我们可能会用StringBuild来进行拼接。StringBuilder sql = new StringBuilder(); sql.append("select * from"); sql.append(schema); sql.append(".")； sql.append(table); sql.append("where id
JSQLPARSER解析SQL知识入门
zhangjunli的博客
11-30 2823
操作的工具包，但是发现此类文章较少，文档也不太详细，所以写个博客供参考。转换为Java类的可遍历层次结构。语法都在动态变化，可以解析某些（不是全部）。Parser就是一个把。
使用JSQLParser解析SQL中涉及到的表
weixin_30713953的博客
02-12 1259
首先添加Maven依赖： <dependency> <groupId>com.github.jsqlparser</groupId> <artifactId>jsqlparser</artifactId> <version>1.2</version> </dependency...
【JSqlParser】Java使用JSqlParser解析SQL语句总结
RudolphLiu的博客
06-21 6141
熟悉JDBC的程序员一般都知道Statement，其实就是语句的意思，不过在Jsqlparser中Statement已经面向对象，被设计成了一个interface，之所以设计成interface大概都可以猜到，因为Jsqlparser既然要去解析SQL，那必然要对SQL语句做区分，到底是Select、还是Insert、还是Delete、甚至是Create，而Jsqlparser对每种语句都做了一个封装，它们都继承了Statement。
JSqlParser实战指南：解析、修改和生成SQL语句的实用技巧
学而时习之，不亦说乎？温故而知新，可以为师矣！
04-13 1万+
JSqlParser是一个强大的Java库，用于解析和操作SQL语句。本文将深入探讨JSqlParser的使用方法和功能特性，详细介绍如何利用JSqlParser解析、修改和生成SQL语句。我们将讨论JSqlParser的基本用法、支持的SQL语法和常见应用场景，以及如何结合JSqlParser实现自定义的SQL操作和查询优化。
JSqlParser系列之二代码结构（原）
weixin_30838921的博客
04-12 268
JSqlParser系列之二代码结构（原） 博客园 百味木屋原创，转载请注明出处。 上一篇文章简单介绍如何建立JSqlParser工程，本章对JSqlParser工程的代码结构作大致地介绍。 一、目录结构 JSqlParser的目录结构比较简单，主要有表达式，解析器，语句处理几个目录。下面这张图给出了一个具体的SQL语句与表达式： 接下来，简要介绍一下在J...
JAVA之sql解析工具JSqlParser介绍
11-20 966
What is it JSqlParser parses an SQL statement and translate it into a hierarchy of Java classes. The generated hierarchy can be navigated using the Visitor Pattern jsqlparser结构简单，继承也不复杂，并且setter和g...
java解析xml的动态sql
10-13
可以使用Java中的DOM或SAX解析器来解析XML文件，并使用动态SQL来生成SQL语句。DOM解析器将整个XML文档加载到内存中，而SAX解析器则逐行读取XML文档。以下是一个使用DOM解析器和动态SQL的示例： ```java DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(new File("example.xml")); XPathFactory xPathfactory = XPathFactory.newInstance(); XPath xpath = xPathfactory.newXPath(); XPathExpression expr = xpath.compile("//book[author='Neal Stephenson']/title/text()"); NodeList nl = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); for (int i = 0; i < nl.getLength(); i++) { String title = nl.item(i).getNodeValue(); String sql = "SELECT * FROM books WHERE title LIKE '%" + title + "%'"; // execute SQL statement } ``` 在此示例中，我们使用XPath表达式选择所有作者为“Neal Stephenson”的书籍的标题，并将其用作动态SQL语句的一部分。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值