2. 程式人生 > >hibernate中antlr對於hql生成抽象語法樹原始碼解析

hibernate中antlr對於hql生成抽象語法樹原始碼解析

阿新 • • 發佈：2018-12-10

Hibernate版本5.1.11FInal

以一句update語句作為例子。

update com.tydhot.eninty.User set userName=:userName where userId=:userId

上面這句hql經過antlr的語法解析之後，得到的語法樹如下。

\-[50] Node: 'update'
    +-[22] Node: 'FROM'
    |  \-[90] Node: 'RANGE'
    |     \-[15] Node: '.'
    |        +-[15] Node: '.'
    |        |  +-[15] Node: '.'
    |        |  |  +-[108] Node: 'com'
    |        |  |  \-[108] Node: 'tydhot'
    |        |  \-[108] Node: 'eninty'
    |        \-[108] Node: 'User'
    +-[46] Node: 'set'
    |  \-[105] Node: '='
    |     +-[108] Node: 'userName'
    |     \-[127] Node: ':'
    |        \-[108] Node: 'userName'
    \-[52] Node: 'where'
       \-[105] Node: '='
          +-[108] Node: 'userId'
          \-[127] Node: ':'
             \-[108] Node: 'userId'

在antlr的語法樹中，使用BaseAST作為一個語法樹節點的抽象，在BaseAST儲存中，其資料結構更加類似一個連結串列。

protected BaseAST down;
protected BaseAST right;

BaseAST中down代表其在樹結構中的子節點，而right則代表跟他從屬一個父節點的兄弟節點。在語法樹中，父節點的down只指向邏輯順序的第一個子節點。

承接上文，當QueryTranslatorImpl中呼叫parse()方法中，當語法解析器parser呼叫statement正式開始語法解析。

從語法檔案hql.g中可以看到，所有hql解析的起點是statement規則。

statement
   : ( updateStatement | deleteStatement | selectStatement | insertStatement ) (EOF!)
   ;

從這裡可以看到，語法解析器會依次從下面四個規則一次嘗試去選擇匹配，四個規則也正好對應了資料庫操作的增刪改查。

這裡再次放上等待作為例子等待解析的hql語句。

update com.tydhot.eninty.User set userName=:userName where userId=:userId

我們可以看到，首先會嘗試去選擇匹配updateStatement規則，如程式碼所示。

try {      // for error handling
   {
   switch ( LA(1)) {
   case UPDATE:
   {
      updateStatement();
      astFactory.addASTChild(currentAST, returnAST);
      break;
   }
   case DELETE:
   {
      deleteStatement();
      astFactory.addASTChild(currentAST, returnAST);
      break;
   }
   case EOF:
   case FROM:
   case GROUP:
   case ORDER:
   case SELECT:
   case WHERE:
   {
      selectStatement();
      astFactory.addASTChild(currentAST, returnAST);
      break;
   }
   case INSERT:
   {
      insertStatement();
      astFactory.addASTChild(currentAST, returnAST);
      break;
   }
   default:
   {
      throw new NoViableAltException(LT(1), getFilename());
   }
   }

在上方的程式碼中，會從上一篇文章所提到的詞法解析器去提取所等到解析的hql語句的第一個詞，在這裡，如果是update關鍵字開頭，自然會開始進入updateStatement規則的匹配。

updateStatement
   : UPDATE^ (optionalVersioned)?
      optionalFromTokenFromClause
      setClause
      (whereClause)?
   ;

從語法檔案的配置還是可以看出，只有在第一個在字元匹配到了update才會繼續進行下面的匹配。接下來是根據這個語法規則antlr編譯的程式碼。

match(UPDATE);
{
switch ( LA(1)) {
case VERSIONED:
{
   AST tmp2_AST = null;
   tmp2_AST = astFactory.create(LT(1));
   astFactory.addASTChild(currentAST, tmp2_AST);
   match(VERSIONED);
   break;
}
case FROM:
case IDENT:
{
   break;
}
default:
{
   throw new NoViableAltException(LT(1), getFilename());
}
}
}
optionalFromTokenFromClause();
astFactory.addASTChild(currentAST, returnAST);
setClause();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case WHERE:
{
   whereClause();
   astFactory.addASTChild(currentAST, returnAST);
   break;
}
case EOF:
{
   break;
}
default:
{
   throw new NoViableAltException(LT(1), getFilename());
}
}
}
updateStatement_AST = (AST)currentAST.root;

可以看到，在取出第一個詞之後會通過match()確認關鍵字update的確認無誤，並生成第一個update節點作為當前樹的根節點，之後判斷下一個詞是否匹配版本關鍵字，對應語法檔案的optionalVersion，當然根據語法檔案中的正則顯示該語句塊可加可不加，那麼自然程式碼中對於沒有匹配到這一關鍵字，也沒有什麼別的操作。

而對於我們的例子語句

update com.tydhot.eninty.User set userName=:userName where userId=:userId

自然也沒有影響，會繼續往下匹配下一個語法規則，下一步則會匹配optionalFromTokenClause規則，程式碼中也會進入optionalFromTokenClause()程式碼段。

optionalFromTokenFromClause!
	: (FROM!)? f:path (a:asAlias)? {
		AST #range = #([RANGE, "RANGE"], #f, #a);
		#optionalFromTokenFromClause = #([FROM, "FROM"], #range);
	}
	;

optionalFromTokenClause的語法規則就顯得稍微複雜。編譯後的程式碼如下。

switch ( LA(1)) {
case FROM:
{
   match(FROM);
   break;
}
case IDENT:
{
   break;
}
default:
{
   throw new NoViableAltException(LT(1), getFilename());
}
}
}
path();
f_AST = (AST)returnAST;
{
switch ( LA(1)) {
case AS:
case IDENT:
{
   asAlias();
   a_AST = (AST)returnAST;
   break;
}
case EOF:
case SET:
case WHERE:
{
   break;
}
default:
{
   throw new NoViableAltException(LT(1), getFilename());
}
}
}
optionalFromTokenFromClause_AST = (AST)currentAST.root;

      AST range = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(RANGE,"RANGE")).add(f_AST).add(a_AST));
      optionalFromTokenFromClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FROM,"FROM")).add(range));
   
currentAST.root = optionalFromTokenFromClause_AST;
currentAST.child = optionalFromTokenFromClause_AST!=null &&optionalFromTokenFromClause_AST.getFirstChild()!=null ?
   optionalFromTokenFromClause_AST.getFirstChild() : optionalFromTokenFromClause_AST;
currentAST.advanceChildToEnd();

程式碼比較長，根據語法規則，首先會嘗試匹配from關鍵字，當然無論有沒有匹配到都不會影響下面的操作。

接下來會對下一個部分強制進行path規則的匹配，也會進入程式碼的path()方法。

path
	: identifier ( DOT^ { weakKeywords(); } identifier )*
;

Path的規則就顯得很簡單，首先強制要求必須存在一個常量，也就是說update語句的操作表物件至少要存在一個，但是在hql語句中可能存在以一個類名作為物件，就像下面這個例子。

update com.tydhot.eninty.User set userName=:userName where userId=:userId

那麼根據語法規則可以匹配若干個點‘ .’起頭的關鍵字進行匹配，下面是path()的程式碼。

identifier();
astFactory.addASTChild(currentAST, returnAST);
{
_loop315:
do {
   if ((LA(1)==DOT)) {
      AST tmp10_AST = null;
      tmp10_AST = astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp10_AST);
      match(DOT);
      weakKeywords();
      identifier();
      astFactory.addASTChild(currentAST, returnAST);
   }
   else {
      break _loop315;
   }
   
} while (true);
}
path_AST = (AST)currentAST.root;

在path()中，會強制第一個匹配一個常量，匹配到則會生成一個語法樹節點，之後會嘗試在迴圈中不斷去匹配點‘ .’，如果匹配到點，也會生成一個相應的語法樹節點，並將這個節點作為當前樹的根節點，其down則會指向剛才生成的常量節點，之後會繼續匹配下一個常量，並作為第一個常量節點right所指向的節點。再下一次迴圈中，如果繼續匹配到了點，則生成一個相應的新節點作為當前樹的根節點，其down指向第一個迴圈所產生的點對應的樹節點（也就是根節點），以此不斷迴圈產生節點，達到一次中序遍歷可以換元整個結果的目的，之前例子該部分生成的語法樹如下。

\-[15] Node: '.'
    |        +-[15] Node: '.'
    |        |  +-[15] Node: '.'
    |        |  |  +-[108] Node: 'com'
    |        |  |  \-[108] Node: 'tydhot'
    |        |  \-[108] Node: 'eninty'
    |        \-[108] Node: 'User'

從最左邊的com節點開始進行一次先序遍歷就可以還原整個結果。

在path()部分得到的這部分結果將會回到optionalFromTokenClause規則當中繼續作為語法樹的成員操作。

之後如果匹配到了AS關鍵字或者空格一個常量，那麼會繼續進入asAlias的規則匹配，但是根據語法規則，此處也是可有可無的部分，給出的例子即使沒有匹配到，也不會出現語法錯誤。

ST range = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(RANGE,"RANGE")).add(f_AST).add(a_AST));
optionalFromTokenFromClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FROM,"FROM")).add(range));

根據語法規則，產生的物件和其別名將會作為RANGE節點的子節點存放在語法樹中，而會繼續產生一個FROM節點繼續作為RANGE的父節點，最後在optionalFromTokenClause規則中產生的樹如下。

 +-[22] Node: 'FROM'
    |  \-[90] Node: 'RANGE'
    |     \-[15] Node: '.'
    |        +-[15] Node: '.'
    |        |  +-[15] Node: '.'
    |        |  |  +-[108] Node: 'com'
    |        |  |  \-[108] Node: 'tydhot'
    |        |  \-[108] Node: 'eninty'
|        \-[108] Node: 'User'

在完成了optionalFromTokenClause規則後，將得到的樹的根節點作為update的子節點，也是update的第一個子節點，被down所指向，而update的其他子節點將會被from節點所指向。

optionalFromTokenFromClause();
astFactory.addASTChild(currentAST, returnAST);
setClause();
astFactory.addASTChild(currentAST, returnAST);

回到update規則，接下來會強制進入setClause部分的語法匹配。接下來經過語法規則編譯的程式碼部分與上文類似，重點解析語法規則。

setClause
	: (SET^ assignment (COMMA! assignment)*)
	;
assignment
	: stateField EQ^ newValue
	;
stateField
	: path
	;
newValue
	: concatenation
	;

在setClause的語法規則中，根據正則，則會強制從set關鍵字進行匹配，接下來也強制至少存在一個等號表示式，複數的表示式可以通過逗號之間隔開，而在等號左邊，則支援path規則，也就是上文中通過.隔開常量的java物件形式的表達，而右邊則是一個concatenation規則，也就是被賦值的值。

concatenation
	: additiveExpression 
	( c:CONCAT^ { #c.setType(EXPR_LIST); #c.setText("concatList"); } 
	  additiveExpression
	  ( CONCAT! additiveExpression )* 
	  { #concatenation = #([METHOD_CALL, "||"], #([IDENT, "concat"]), #c ); } )?
;

賦值語句分為五級，第4級也就是優先度最低的通過|隔開.

additiveExpression
	: multiplyExpression ( ( PLUS^ | MINUS^ ) multiplyExpression )*
;

第3級則是根據加減分隔，根據先序遍歷的性質，這裡也將會在接下來的乘除操作之後進行加減。

multiplyExpression
	: unaryExpression ( ( STAR^ | DIV^ | MOD^ ) unaryExpression )*
;

第2級也就是乘除，優先順序高於加減。

unaryExpression
	: MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression
	| PLUS^ {#PLUS.setType(UNARY_PLUS);} unaryExpression
	| caseExpression
	| quantifiedExpression
	| atom
	;

caseExpression
	// NOTE : the unaryExpression rule contains the subQuery rule
	: simpleCaseStatement
	| searchedCaseStatement
	;

simpleCaseStatement
	: CASE^ unaryExpression (simpleCaseWhenClause)+ (elseClause)? END! {
		#simpleCaseStatement.setType(CASE2);
	}
	;

simpleCaseWhenClause
	: (WHEN^ unaryExpression THEN! unaryExpression)
	;

elseClause
	: (ELSE^ unaryExpression)
	;

searchedCaseStatement
	: CASE^ (searchedCaseWhenClause)+ (elseClause)? END!
	;

searchedCaseWhenClause
	: (WHEN^ logicalExpression THEN! unaryExpression)
	;
	
quantifiedExpression
	: ( SOME^ | EXISTS^ | ALL^ | ANY^ ) 
	( identifier | collectionExpr | (OPEN! ( subQuery ) CLOSE!) )
;

第一級則是一些邏輯操作，優先度是除了常量和數字之外最高的。

atom
	: primaryExpression
		(
			DOT^ identifier
				( options { greedy=true; } :
					( op:OPEN^ {#op.setType(METHOD_CALL);} exprList CLOSE! ) )?
		|	lb:OPEN_BRACKET^ {#lb.setType(INDEX_OP);} expression CLOSE_BRACKET!
		)*
	;
// level 0 - the basic element of an expression
primaryExpression
    : { validateSoftKeyword("function") && LA(2) == OPEN && LA(3) == QUOTED_STRING }? jpaFunctionSyntax
    | { validateSoftKeyword("cast") && LA(2) == OPEN }? castFunction
	| identPrimary ( options {greedy=true;} : DOT^ "class" )?
	| constant
	| parameter
	| OPEN! (expressionOrVector | subQuery) CLOSE!
	;

第0級也就是一些常量和數字，是所有詞中，被處理優先順序最高的，這些也將在serClause規則中依次被處理成為語法樹中的節點。

我們的例子在經過set規則後，生成的樹的根節點將會被之前的from部分的right所指向，代表同為update的節點的子節點，在語句的順序上，也在其兄弟節點from節點的之後，生成的語法樹會成為如下所示。

 \-[50] Node: 'update'
    +-[22] Node: 'FROM'
    |  \-[90] Node: 'RANGE'
    |     \-[15] Node: '.'
    |        +-[15] Node: '.'
    |        |  +-[15] Node: '.'
    |        |  |  +-[108] Node: 'com'
    |        |  |  \-[108] Node: 'tydhot'
    |        |  \-[108] Node: 'eninty'
    |        \-[108] Node: 'User'
    +-[46] Node: 'set'
    |  \-[105] Node: '='
    |     +-[108] Node: 'userName'
    |     \-[127] Node: ':'
|        \-[108] Node: 'userName'

最後根據我們一開始的語法規則，where關鍵字的匹配是可有可無的，但是我們的例子給出了where 關鍵字，所以同樣的也要相應的繼續whereClause規則的匹配。

whereClause
	: WHERE^ logicalExpression
	;
ogicalExpression
	: expression
	;
// Main expression rule
expression
	: logicalOrExpression
	;
// level 7 - OR
logicalOrExpression
	: logicalAndExpression ( OR^ logicalAndExpression )*
	;
// level 6 - AND, NOT
logicalAndExpression
	: negatedExpression ( AND^ negatedExpression )*
	;
// NOT nodes aren't generated.  Instead, the operator in the sub-tree will be
// negated, if possible.   Expressions without a NOT parent are passed through.
negatedExpression!
{ weakKeywords(); } // Weak keywords can appear in an expression, so look ahead.
	: NOT^ x:negatedExpression { #negatedExpression = negateNode(#x); }
	| y:equalityExpression { #negatedExpression = #y; }
;
equalityExpression
	: x:relationalExpression (
		( EQ^
		| is:IS^	{ #is.setType(EQ); } (NOT! { #is.setType(NE); } )?
		| NE^
		| ne:SQL_NE^	{ #ne.setType(NE); }
		) y:relationalExpression)* {
			// Post process the equality expression to clean up 'is null', etc.
			#equalityExpression = processEqualityExpression(#equalityExpression);
		}
	;

Where的語法規則，在之前set的5級基礎上又添加了三級，分別是第七級的與，第六級的是非，和第五級的邏輯等式集合規則。

經過上述的語法規則後，生成的語法樹加入到最後的結果如下。

\-[50] Node: 'update'
    +-[22] Node: 'FROM'
    |  \-[90] Node: 'RANGE'
    |     \-[15] Node: '.'
    |        +-[15] Node: '.'
    |        |  +-[15] Node: '.'
    |        |  |  +-[108] Node: 'com'
    |        |  |  \-[108] Node: 'tydhot'
    |        |  \-[108] Node: 'eninty'
    |        \-[108] Node: 'User'
    +-[46] Node: 'set'
    |  \-[105] Node: '='
    |     +-[108] Node: 'userName'
    |     \-[127] Node: ':'
    |        \-[108] Node: 'userName'
    \-[52] Node: 'where'
       \-[105] Node: '='
          +-[108] Node: 'userId'
          \-[127] Node: ':'
             \-[108] Node: 'userId'

在語法樹中，關鍵字部分下的子樹通過中序遍歷，都可以得到例子中的子句，最後將得到的字句根據關鍵字的順序組合，就能得到例子中的hql語句，這個語法樹，也將被用來作為轉換sql語句的依據。

相關推薦

hibernate中antlr對於hql生成抽象語法樹原始碼解析

Hibernate版本5.1.11FInal 以一句update語句作為例子。 update com.tydhot.eninty.User set userName=:userName where userId=:userId 上面這句hql經過antlr的語法解析

新的Hibernate 4版本中，對於Hql的一個改變

在新的Hibernate 4版本中，對於Hql有一點點改變，如果你還是按照以前的方式去編寫HQL並且用了以下佔位符的方式，就會得到一個警告。 參考資料：https://hibernate.atlassian.net/browse/HHH-8012?page=com.atlassian.jira.p

hibernate中相關問題hql與sql的不同實現方式

如果我們想要的結果是某個物件的實體，這是就可以通過addEntity()方法來實現。addEntity()方法可以講結果轉換為實體。但是在轉換的過程中要注意幾個問題：           1、查詢返回的是某個資料表的全部資料列           2、該資料表有對應的持久化類對映  vo類都不行    

1 Java程式檔案中函式起始行和終止行在程式檔案位置中的判定__抽象語法樹方法

應用需求： 實現對BigCloneBench中函式體的克隆檢測，必須標註出起始行號和終止行號。 問題： 給定一個Java檔案，從中提取出每個函式的起始行和終止行。 難點： 這個問題的難點在於，對於Java的解析器而言，其在形成抽象語法樹的過程中，已經對原始碼檔案進行了劃分，然後，形成了對函式的抽象語

hibernate中的主鍵生成策略

一、在hibernate的實體對映配置檔案中配置hibernate的主鍵生成器: generator元素：表示了一個主鍵生成器，它用來為持久化類例項生成唯一的標識 。 <?xml version="1.0" encoding="UTF-8"?> &l

Hibernate中的主鍵生成方法native與assigned

在用Hibernate的時候，當有表中的主鍵是庫自動生成的時候將使用native。<generator class="native"></generator>而當是自己新增的時候

關於hibernate中createQuery執行hql報錯的小結

org.hibernate.hql.ast.QuerySyntaxException: news is not mapped [select id, type,title ,author,message,date from news where type = 1 order by date desc] or

hibernate中主鍵的生成策略

1、assigned 主鍵由外部程式負責生成，在 save() 之前必須指定一個。Hibernate不負責維護主鍵生成。與Hibernate和底層資料庫都無關，可以跨資料庫。在儲存物件前，必須要使用主鍵的setter方法給主鍵賦值，至於這個值怎麼生成，完全由自己決定，這

如何檢視SparkSQL 生成的抽象語法樹？

前言     在《Spark SQL核心剖析》書中4.3章節，談到Catalyst體系中生成的抽象語法樹的節點都是以Context來結尾，在ANLTR4以及生成的SqlBaseParser解析SQL生成，其原始碼部分就是語法解析，其生成的抽象語法樹的節點都是ParserRuleContex

PMD 編譯 語法分析 詞法分析 抽象語法樹

edit get 編譯 test if語句 final 代碼掃描 pic blog 編譯原理 163 課堂 http://mooc.study.163.com/learn/-1000002001?tid=1000003000#/learn/content?type=deta

現代編譯原理——第三章：抽象語法樹以及原始碼

　　轉自： http://www.cnblogs.com/BlackWalnut/p/4508093.html   這是flxe的檔案，檔名稱為tiger.l 　　 %{ #include <string.h> #include "util.h" #

正則表示式引擎的構建——基於編譯原理DFA（龍書第三章）——2 構造抽象語法樹

簡要介紹     構造抽象語法樹是構造基於DFA的正則表示式引擎的第一步。目前在我實現的這個正則表示式的雛形中，正則表示式的運算子有3種，表示選擇的|運算子，表示星號運算的*運算子，表示連線的運算子cat（在實際正則表示式中被省去）。 例如對於正則表示式a*b|c，在a*

AST 抽象語法樹學習

閱讀原文 Abstract Syntax Tree 抽象語法樹簡介 在使用前端許多工具外掛的時候，我們大多知道每個工具庫、每個外掛能做什麼，不過很多同學其實並不清楚背後用到的技術，如webpack、rollup、UglifyJS、Lint等很多的工具和庫

PHP7 的抽象語法樹（AST）帶來的變化

轉載自：http://0x1.im/blog/php/changes-of-php7-because-of-ast.html 本文並不會告訴你抽象語法樹是什麼，這需要你自己去了解，這裡只是描述 AST 給 PHP 帶來的一些變化。 新的執行過程 PHP7 的核心中有一個

[WebKit核心] JavaScript引擎深度解析--基礎篇（一）位元組碼生成及語法樹的構建詳情分析

      看到HorkeyChen寫的文章《[WebKit] JavaScriptCore解析--基礎篇(三)從指令碼程式碼到JIT編譯的程式碼實現》，寫的很好，深受啟發。想補充一些Horkey沒有寫到的細節比如位元組碼是如何生成的等等，為此成文。       JSC對

自制指令碼語言（10） 抽象語法樹AST與三地址線性IR

摘要：介紹了YF language程式語言的AST及IR表示     根據前面定義的語法，基本上AST就已經被決定了。因為語法每reduce一次，要麼組建一個新AST，要麼在已有的AST上新增資料。這裡照慣例採用了訪問者模式，將Code Generator設為訪問者，遍歷

C 語言 抽象語法樹AST

抽象語法樹簡介 (一)簡介 抽象語法樹（abstract syntax code，AST）是原始碼的抽象語法結構的樹狀表示，樹上的每個節點都表示原始碼中的一種結構，這所以說是抽象的，是因為抽象語法樹並不會表示出真實語法出現的每一個細節，比如說，巢狀括號被隱含在樹的

[WebKit核心] JavaScriptCore深度解析--基礎篇（一）位元組碼生成及語法樹的構建詳情分析

     看到HorkeyChen寫的文章《[WebKit] JavaScriptCore解析--基礎篇(三)從指令碼程式碼到JIT編譯的程式碼實現》，寫的很好，深受啟發。想補充一些Horkey沒有寫到的細節比如位元組碼是如何生成的等等，為此成文。       JS

從零寫一個編譯器（九）：語義分析之構造抽象語法樹(AST)

專案的完整程式碼在 C2j-Compiler 前言 在上一篇完成了符號表的構建，下一步就是輸出抽象語法樹(Abstract Syntax Tree，AST) 抽象語法樹（abstract syntax tree 或者縮寫為 AST），是原始碼的抽象語法結構的樹狀表現形式，這裡特指程式語言的原始碼。樹上的

五分鐘瞭解抽象語法樹（AST）babel是如何轉換的？

抽象語法樹 什麼是抽象語法樹？ It is a hierarchical program representation that presents source code structure according to the grammar of a programming language, each A