Author: porcelli Date: 2009-04-17 16:48:26 -0400 (Fri, 17 Apr 2009) New Revision: 16357 Added: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/ core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/EntityNameTree.java core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContext.java core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContextDefaultImpl.java Modified: core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQL.g core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQLTreeWalker.g Log: updates for new antlr3 parser version. Modified: core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQL.g =================================================================== --- core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQL.g 2009-04-17 16:47:24 UTC (rev 16356) +++ core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQL.g 2009-04-17 20:48:26 UTC (rev 16357) @@ -6,159 +6,145 @@ tokens { //VIRTUAL TOKENS - FILTER; - ALIAS_NAME; - - IS_NOT_NULL; - IS_NULL; - IS_NOT_EMPTY; - NOT_IN; - NOT_BETWEEN; - NOT_LIKE; - + ALIAS_REF; BETWEEN_LIST; - SIMPLE_CASE; - SEARCHED_CASE; - UNARY_MINUS; - UNARY_PLUS; - IN_LIST; - + COLLATE; + COLLECTION_EXPRESSION; DOT_CLASS; - COLLECTION_EXPRESSION; + DYNAMIC_INSTANTIATION_ARG; + DYNAMIC_INSTANTIATION; + ENTITY_NAME; + ENTITY_PERSISTER_REF; + FILTER; GENERAL_FUNCTION_CALL; + GENERIC_ELEMENT; + GROUPING_VALUE; + IN_LIST; + INSERTABILITY_SPEC; + IS_NOT_EMPTY; + IS_NOT_NULL; + IS_NULL; JAVA_CONSTANT; - GENERIC_ELEMENT; + JPA_PARAM; NAMED_PARAM; - JPA_PARAM; - - COLLATE; - - VECTOR_EXPR; - + NOT_BETWEEN; + NOT_IN; + NOT_LIKE; + PERSISTER_JOIN; + PERSISTER_SPACE; + PROP_FETCH; + PROPERTY_JOIN; + PROPERTY_REFERENCE; + QUALIFIED_JOIN; + QUERY_SPEC; QUERY; - QUERY_SPEC; - GROUPING_VALUE; + SEARCHED_CASE; SELECT_FROM; + SELECT_ITEM; SELECT_LIST; - PERSISTER_SPACE; - - PERSISTER_JOIN; - DYNAMIC_INSTANTIATION_ARG; - SELECT_ITEM; - DYNAMIC_INSTANTIATION; - ENTITY_PERSISTER_REF; - PROPERTY_JOIN; - PROP_FETCH; + SIMPLE_CASE; SORT_SPEC; - - ASSIGNMENT_FIELD; + UNARY_MINUS; + UNARY_PLUS; + VECTOR_EXPR; - INSERTABILITY_SPEC; - INSERTABLE_PROPERTY; - - QUALIFIED_JOIN; - ENTITY_NAME; - PROPERTY_REFERENCE; - ALIAS_REF; - //SOFT KEYWORDS - ELSE; + ABS; + ALL; + AND; + ANY; + AS; + ASC; + AVG; + BETWEEN; + BIT_LENGTH; + BOTH; + CAST; + CHARACTER_LENGTH; CLASS; - NEW; - OBJECT; - WHERE; - ASC; + COALESCE; + CONCAT; + COUNT; + CROSS; + CURRENT_DATE; + CURRENT_TIME; + CURRENT_TIMESTAMP; + DAY; + DELETE; DESC; - UNION; - INTERSECT; - ALL; + DISTINCT; + ELEMENTS; + ELSE; + END; + ESCAPE; EXCEPT; - DISTINCT; - SELECT; - AS; - IN; - PROPERTIES; + EXISTS; + EXTRACT; FETCH; - ELEMENTS; - INDICES; - CROSS; - JOIN; - INNER; - OUTER; - LEFT; - RIGHT; + FROM; FULL; - WITH; - ON; GROUP_BY; HAVING; + HOUR; + IN; + INDEX; + INDICES; + INNER; INSERT; + INTERSECT; INTO; - DELETE; - SET; - VERSIONED; - UPDATE; - OR; - AND; - NOT; IS_EMPTY; IS; - ESCAPE; - BETWEEN; + JOIN; + LEADING; + LEFT; + LENGTH; LIKE; + LOCATE; + LOWER; + MAX; + MAXELEMENT; + MAXINDEX; MEMBER_OF; - THEN; - END; - WHEN; + MIN; + MINELEMENT; + MININDEX; + MINUTE; + MOD; + MONTH; + NEW; + NOT; NULLIF; - COALESCE; - EXISTS; + OCTET_LENGTH; + ON; + OR; + ORDER_BY; + OUTER; + POSITION; + PROPERTIES; + RIGHT; + SECOND; + SELECT; + SET; + SIZE; SOME; - ANY; + SQRT; SUBSTRING; - CONCAT; - CAST; - LEADING; + SUM; + THEN; + TIMEZONE_HOUR; + TIMEZONE_MINUTE; TRAILING; - BOTH; TRIM; + UNION; + UPDATE; UPPER; - LOWER; - LENGTH; - LOCATE; - ABS; - SQRT; - MOD; - SIZE; - INDEX; - CURRENT_DATE; - CURRENT_TIME; - CURRENT_TIMESTAMP; - EXTRACT; - SECOND; + VERSIONED; + WHEN; + WHERE; + WITH; YEAR; - MONTH; - DAY; - HOUR; - MINUTE; - TIMEZONE_HOUR; - TIMEZONE_MINUTE; - POSITION; - CHARACTER_LENGTH; - OCTET_LENGTH; - BIT_LENGTH; - SUM; - AVG; - MAX; - MIN; - COUNT; - MAXELEMENT; - MAXINDEX; - MINELEMENT; - MININDEX; - ORDER_BY; - FROM; } @parser::header { @@ -194,6 +180,8 @@ package org.hibernate.sql.ast.phase.hql.parse; import java.util.LinkedList; +import java.util.HashSet; +import java.util.Set; } @lexer::header { @@ -249,8 +237,11 @@ } @parser::members { - private List<String> errorMessages = new LinkedList<String>(); + Stack entitySplitStack = new Stack(); + ParserContext context = new ParserContextDefaultImpl(); + private List errorMessages = new LinkedList(); + private boolean validateIdentifierKey(String text) { return validateLT(1, text); } @@ -278,17 +269,16 @@ return false; } - public List<String> getErrorMessages(){ + public List getErrorMessages(){ return errorMessages; } - @Override public void reportError( RecognitionException e ) { errorMessages.add(generateError(getRuleInvocationStack(e, this.getClass().getName()), this.getTokenNames(), e)); super.reportError(e); } - private String generateError( List<Object> invocationStack, + private String generateError( List invocationStack, String[] tokenNames, RecognitionException e ) { String localization = invocationStack + ": line " + e.line + ":" + e.charPositionInLine + " "; @@ -340,7 +330,14 @@ return message; } - + + private List extractEntityNames(String entityName) throws RecognitionException { + List implementors = context.getEntityImplementors(entityName); + if (implementors == null){ + throw new RecognitionException( ); + } + return implementors; + } } filterStatement[String collectionRole] @@ -358,7 +355,10 @@ ; updateStatement - : udpate_key^ versioned_key? from_key!? entityName aliasClause setClause whereClause? +@init { if (state.backtracking == 0) entitySplitStack.push(Boolean.FALSE); } +@after { entitySplitStack.pop(); } + : udpate_key^ + versioned_key? from_key!? entityName aliasClause setClause whereClause? ; setClause @@ -370,17 +370,23 @@ ; assignmentField - : dotIdentifierPath -> ^(ASSIGNMENT_FIELD dotIdentifierPath) + : dotIdentifierPath -> ^(PROPERTY_REFERENCE dotIdentifierPath) ; deleteStatement +@init { if (state.backtracking == 0) entitySplitStack.push(Boolean.FALSE); } +@after { entitySplitStack.pop(); } : delete_key^ from_key!? entityName aliasClause whereClause? ; insertStatement - : insert_key^ intoClause selectStatement +@init { if (state.backtracking == 0) entitySplitStack.push(Boolean.FALSE); } +@after { entitySplitStack.pop(); } + : insert_key^ + intoClause selectStatement ; +//TODO: Generate an exception when try to use a polimorfic entity at INTO clause intoClause : into_key^ entityName insertabilitySpecification ; @@ -391,7 +397,7 @@ ; insertablePropertySpecification - : dotIdentifierPath -> ^(INSERTABLE_PROPERTY dotIdentifierPath) + : dotIdentifierPath -> ^(PROPERTY_REFERENCE dotIdentifierPath) ; selectStatement @@ -399,7 +405,10 @@ -> ^(QUERY queryExpression orderByClause?) ; +//Think about the exception generation where Polimorfic queris are used inside a Mix of results (union, intersect and except) queryExpression +@init { if (state.backtracking == 0) entitySplitStack.push(Boolean.FALSE); } +@after { entitySplitStack.pop(); } : querySpec ( ( union_key^ | intersect_key^ | except_key^ ) all_key? querySpec )* ; @@ -440,11 +449,13 @@ ; fromClause - : from_key^ persisterSpaces + : from_key^ + persisterSpaces ; persisterSpaces : persisterSpace ( COMMA persisterSpace )* +//TODO: Should handle here if the persisterSpace first element is a join.. it it is.. should be inside the last one. -> ^(PERSISTER_SPACE persisterSpace)+ ; @@ -458,12 +469,16 @@ ; qualifiedJoin -@init {boolean isEntityReference = false;} +@init { boolean isEntityReference = false; List entityNames = null; } : nonCrossJoinType join_key fetch_key? path aliasClause - ( on_key {isEntityReference = true;} logicalExpression + ( on_key + { isEntityReference = true; + entityNames = extractEntityNames($path.text); + if (entityNames.size() > 1 && entitySplitStack.peek().equals(Boolean.FALSE)) { entitySplitStack.pop(); entitySplitStack.push(Boolean.TRUE); } } + logicalExpression | propertyFetch? withClause? ) - -> {isEntityReference}? ^(PERSISTER_JOIN[$join_key.start,"persister-join"] nonCrossJoinType ^(ENTITY_PERSISTER_REF ENTITY_NAME[$path.start, $path.text] aliasClause?) ^(on_key logicalExpression)) + -> {isEntityReference}? ^(PERSISTER_JOIN[$join_key.start,"persister-join"] nonCrossJoinType ^(ENTITY_PERSISTER_REF ENTITY_NAME<EntityNameTree>[$path.start, $path.text, entityNames] aliasClause?) ^(on_key logicalExpression)) -> ^(PROPERTY_JOIN[$join_key.start, "property-join"] nonCrossJoinType fetch_key? aliasClause? propertyFetch? ^(PROPERTY_REFERENCE path) withClause?) ; @@ -501,10 +516,11 @@ -> PROP_FETCH[$fetch_key.start, "property-fetch"] ; -hibernateLegacySyntax - : aliasValue in_key - ( class_key entityName -> ^(ENTITY_PERSISTER_REF entityName aliasValue) - | collectionExpression -> ^(PROPERTY_JOIN INNER[$in_key.start, "inner"] aliasValue collectionExpression) +hibernateLegacySyntax returns [boolean isPropertyJoin] +@init {$isPropertyJoin = false;} + : aliasDeclaration in_key + ( class_key entityName -> ^(ENTITY_PERSISTER_REF entityName aliasDeclaration) + | collectionExpression {$isPropertyJoin = true;} -> ^(PROPERTY_JOIN INNER[$in_key.start, "inner legacy"] aliasDeclaration collectionExpression) ) ; @@ -533,21 +549,27 @@ ; selectExpression +//TODO: PARAMETERS CAN'T BE USED -> This verification should be scoped : expression aliasClause + -> ^(SELECT_ITEM expression aliasClause?) ; aliasClause options{ k=2; } : - | aliasValue - | as_key! aliasValue + | aliasDeclaration + | as_key! aliasDeclaration ; -aliasValue +aliasDeclaration : IDENTIFIER -> ALIAS_NAME[$IDENTIFIER] ; +aliasReference + : IDENTIFIER -> ALIAS_REF[$IDENTIFIER] + ; + rootDynamicInstantiation : new_key dynamicInstantiationTarget LEFT_PAREN dynamicInstantiationArgs RIGHT_PAREN -> ^(SELECT_ITEM ^(DYNAMIC_INSTANTIATION[$dynamicInstantiationTarget.start, $dynamicInstantiationTarget.text] dynamicInstantiationArgs)) @@ -568,7 +590,7 @@ jpaSelectObjectSyntax : object_key LEFT_PAREN aliasReference RIGHT_PAREN - -> ^(SELECT_ITEM ^(object_key aliasReference)) + -> ^(SELECT_ITEM aliasReference) ; orderByClause @@ -576,11 +598,14 @@ ; sortSpecification - : sortKey collationSpecification? orderingSpecification? +@init{boolean generateOmmitedElement = true;} + : sortKey collationSpecification? (orderingSpecification {generateOmmitedElement = false;})? + -> {generateOmmitedElement}? ^(SORT_SPEC sortKey collationSpecification? ASC) -> ^(SORT_SPEC sortKey collationSpecification? orderingSpecification?) ; sortKey +//TODO: PARAMETERS CAN'T BE USED -> This verification should be scoped : concatenation ; @@ -649,9 +674,9 @@ | like_key concatenation likeEscape? -> {isNegated}? ^(NOT_LIKE[$not_key.start, "not like"] $relationalExpression concatenation likeEscape?) -> ^(like_key $relationalExpression concatenation likeEscape?) - | member_of_key propertyReference - -> {isNegated}? ^(NOT_IN[$not_key.start, "not in"] $relationalExpression ^(IN_LIST ^(QUERY ^(QUERY_SPEC ^(SELECT_FROM ^(FROM propertyReference)))))) - -> ^(IN[$member_of_key.start, "in"] $relationalExpression ^(IN_LIST ^(QUERY ^(QUERY_SPEC ^(SELECT_FROM ^(FROM propertyReference)))))) + | member_of_key path + -> {isNegated}? ^(NOT_IN[$not_key.start, "not in"] $relationalExpression ^(IN_LIST ^(QUERY ^(QUERY_SPEC ^(SELECT_FROM ^(FROM ^(GENERIC_ELEMENT path))))))) + -> ^(IN[$member_of_key.start, "in"] $relationalExpression ^(IN_LIST ^(QUERY ^(QUERY_SPEC ^(SELECT_FROM ^(FROM ^(GENERIC_ELEMENT path))))))) ) )? ; @@ -737,7 +762,7 @@ quantifiedExpression : ( some_key^ | exists_key^ | all_key^ | any_key^ ) - ( aliasValue + ( aliasReference | collectionExpression | LEFT_PAREN! subQuery RIGHT_PAREN! ) @@ -895,16 +920,18 @@ ; setFunction +@init{boolean generateOmmitedElement = true;} : ( sum_key^ | avg_key^ | max_key^ | min_key^ ) LEFT_PAREN! additiveExpression RIGHT_PAREN! - | count_key LEFT_PAREN ( ASTERISK | ( ( distinct_key | all_key )? countFunctionArguments ) ) RIGHT_PAREN + | count_key LEFT_PAREN ( ASTERISK {generateOmmitedElement = false;} | ( ( (distinct_key | all_key) {generateOmmitedElement = false;} )? countFunctionArguments ) ) RIGHT_PAREN + -> {generateOmmitedElement}? ^(count_key ASTERISK? ALL countFunctionArguments?) -> ^(count_key ASTERISK? distinct_key? all_key? countFunctionArguments?) ; countFunctionArguments @init { int type = -1;} : path - -> {type == 1}? ^(ELEMENTS path) - -> {type == 2}? ^(INDICES path) + -> {type == 1}? ^(ELEMENTS ^(PROPERTY_REFERENCE path)) + -> {type == 2}? ^(INDICES ^(PROPERTY_REFERENCE path)) -> ^(PROPERTY_REFERENCE path) //TODO if ends with: // .elements or .indices -> it is a collectionExpression @@ -936,10 +963,10 @@ // if it is constantReference (using context) // otherwise it will be a generic element to be resolved on the next phase (1st tree walker) -> {type == 0}? ^(DOT_CLASS identPrimary) - -> {type == 1}? ^(ELEMENTS identPrimary) - -> {type == 2}? ^(INDICES identPrimary) + -> {type == 1}? ^(ELEMENTS ^(PROPERTY_REFERENCE identPrimary)) + -> {type == 2}? ^(INDICES ^(PROPERTY_REFERENCE identPrimary)) -> {type == 3}? ^(GENERAL_FUNCTION_CALL identPrimary) - -> {type == 4}? ^(JAVA_CONSTANT identPrimary) + -> {type == 4}? ^(JAVA_CONSTANT identPrimary) //-> here will have 2 strutctures element and the constant -> ^(GENERIC_ELEMENT identPrimary) | constant | parameterSpecification @@ -1000,13 +1027,15 @@ | FLOATING_POINT_LITERAL ; -aliasReference - : IDENTIFIER -> ALIAS_REF[$IDENTIFIER] - ; - entityName - : dotIdentifierPath -> ENTITY_NAME[$dotIdentifierPath.start, $dotIdentifierPath.text] - //TODO: semantic validation +@init { List entityNames = null; } +@after { if (entityNames.size() > 1 && entitySplitStack.peek().equals(Boolean.FALSE)) { entitySplitStack.pop(); entitySplitStack.push(Boolean.TRUE); } } + : dotIdentifierPath + { entityNames = extractEntityNames($dotIdentifierPath.text); } + //here the polimorfic entities should be resolved... to: + // 1. to place inside the ENTITY_NAME Token all its possible values, otherwise it would be much difficult to return to the place that should explit the sentence + // 2. enable exception geration when not supported (union, insert) + -> ENTITY_NAME<EntityNameTree>[$dotIdentifierPath.start, $dotIdentifierPath.text, entityNames] ; propertyReference @@ -1048,7 +1077,6 @@ object_key : {(validateIdentifierKey("object"))}?=> id=IDENTIFIER - -> OBJECT[$id] ; case_key Modified: core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQLTreeWalker.g =================================================================== --- core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQLTreeWalker.g 2009-04-17 16:47:24 UTC (rev 16356) +++ core/branches/antlr3/src/main/antlr3/org/hibernate/sql/ast/phase/hql/parse/HQLTreeWalker.g 2009-04-17 20:48:26 UTC (rev 16357) @@ -1,11 +1,17 @@ tree grammar HQLTreeWalker; options{ + output=AST; + rewrite=true; tokenVocab=HQL; ASTLabelType=CommonTree; TokenLabelType=CommonToken; } +tokens { + VERSIONED_VALUE; +} + @header { /* * Hibernate, Relational Persistence for Idiomatic Java @@ -47,34 +53,47 @@ ; statement - : updateStatement - | deleteStatement + : updateStatementSet + | deleteStatementSet | insertStatement - | queryStatement + | queryStatementSet ; +updateStatementSet + : updateStatement+ + ; + updateStatement - : ^(UPDATE VERSIONED? ENTITY_NAME ALIAS_NAME? ^(SET assignment+) whereClause?) +@init {boolean hasVersioned = false; Object versionedPropertyDaya = null;} + : ^(UPDATE (VERSIONED {hasVersioned = true;})? entityName ^(SET assignment+) whereClause?) + -> {hasVersioned}? ^(UPDATE entityName ^(SET assignment+ + ^(EQUALS ^(PROPERTY_REFERENCE IDENTIFIER["name"]) VERSIONED_VALUE)) whereClause?) + -> ^(UPDATE entityName ^(SET assignment+) whereClause?) ; assignment - : ^(EQUALS ^(ASSIGNMENT_FIELD dotIdentifierPath) valueExpression) + : ^(EQUALS propertyReference valueExpression) ; +deleteStatementSet + : deleteStatement+ + ; + deleteStatement - : ^(DELETE ENTITY_NAME ALIAS_NAME? whereClause?) + : ^(DELETE entityName whereClause?) ; + insertStatement - : ^(INSERT intoClause queryStatement) + : ^(INSERT intoClause queryStatementSet) ; intoClause - : ^(INTO ENTITY_NAME ^(INSERTABILITY_SPEC insertablePropertySpecification+ ) ) + : ^(INTO entityName ^(INSERTABILITY_SPEC propertyReference+ ) ) ; -insertablePropertySpecification - : ^(INSERTABLE_PROPERTY dotIdentifierPath) +queryStatementSet + : queryStatement+ ; queryStatement @@ -82,7 +101,7 @@ ; queryExpression - : ^(UNION queryExpression queryExpression) + : ^(UNION ALL? queryExpression queryExpression) | ^(INTERSECT ALL? queryExpression queryExpression) | ^(EXCEPT ALL? queryExpression queryExpression) | querySpec @@ -117,9 +136,8 @@ ; persisterSpaces - : propertyReference + : ^(PERSISTER_SPACE persisterSpace) | ^(GENERIC_ELEMENT identPrimary) - | ^(PERSISTER_SPACE persisterSpace) ; persisterSpace @@ -146,8 +164,8 @@ ; persisterSpaceRoot - : ^(ENTITY_PERSISTER_REF ENTITY_NAME ALIAS_NAME? PROP_FETCH?) - | joins + : ^(ENTITY_PERSISTER_REF entityName PROP_FETCH?) + //| joins // this is created based on legacy syntax... check if we can move this from here ; selectClause @@ -155,22 +173,19 @@ ; rootSelectExpression - : ^(SELECT_ITEM ^(DYNAMIC_INSTANTIATION dynamicInstantiationArg+)) - | ^(SELECT_ITEM ^(OBJECT ALIAS_REF)) - | ^(SELECT_LIST rootSelectExpression+) + : ^(SELECT_LIST rootSelectExpression+) + | ^(SELECT_ITEM rootSelectExpression) + | ^(DYNAMIC_INSTANTIATION rootSelectExpression+) + | ^(DYNAMIC_INSTANTIATION_ARG rootSelectExpression) | valueExpression ALIAS_NAME? ; -dynamicInstantiationArg - : ^(DYNAMIC_INSTANTIATION_ARG rootSelectExpression) - ; - orderByClause : ^(ORDER_BY sortSpecification+) ; sortSpecification - : ^(SORT_SPEC valueExpression COLLATE? (ASC|DESC)?) + : ^(SORT_SPEC valueExpression COLLATE? (ASC|DESC)) ; searchCondition @@ -195,7 +210,6 @@ | ^( NOT_BETWEEN rowValueConstructor betweenList ) | ^( IN rowValueConstructor inPredicateValue ) | ^( NOT_IN rowValueConstructor inPredicateValue ) - | ^( EXISTS (rowValueConstructor|ALIAS_NAME)) | rowValueConstructor ; @@ -239,64 +253,52 @@ | ^( MINUS valueExpression valueExpression ) | ^( ASTERISK numericValueExpression numericValueExpression ) | ^( SOLIDUS numericValueExpression numericValueExpression ) - | ^( VECTOR_EXPR valueExpression+) - | ^( SOME (valueExpression|ALIAS_NAME) ) - | ^( ALL (valueExpression|ALIAS_NAME) ) - | ^( ANY (valueExpression|ALIAS_NAME) ) + | ^( EXISTS rowValueConstructor) + | ^( SOME valueExpression ) + | ^( ALL valueExpression ) + | ^( ANY valueExpression ) + | ^( VECTOR_EXPR valueExpression+) // or a tuples or ^(AND or IN statement | valueExpressionPrimary ; valueExpressionPrimary - : ALIAS_REF - | caseExpression + : caseExpression | function | collectionFunction | collectionExpression | constant | parameter | propertyReference + | queryStatementSet + | ALIAS_REF //ID COLUMN, full property column list + | ^(DOT_CLASS identPrimary) // crazy + | ^(GENERAL_FUNCTION_CALL identPrimary) + | ^(JAVA_CONSTANT identPrimary) //It will generate at SQL a parameter element (?) -> 'cos we do not need to care about char escaping | ^(GENERIC_ELEMENT identPrimary) - | queryStatement ; caseExpression - : caseAbbreviation - | caseSpecification - ; - - -caseAbbreviation : ^(NULLIF valueExpression valueExpression) | ^(COALESCE valueExpression valueExpression*) + | ^(SIMPLE_CASE valueExpression simpleCaseWhenClause+ elseClause?) + | ^(SEARCHED_CASE searchedWhenClause+ elseClause?) ; -caseSpecification - : simpleCase - | searchedCase - ; - -simpleCase - : ^(SIMPLE_CASE valueExpression simpleCaseWhenClause+ elseClause?) - ; - simpleCaseWhenClause : ^(WHEN valueExpression valueExpression) ; -elseClause - : ^(ELSE valueExpression) - ; - -searchedCase - : ^(SEARCHED_CASE searchedWhenClause+ elseClause?) - ; - searchedWhenClause : ^(WHEN searchCondition valueExpression) ; +elseClause + : ^(ELSE valueExpression) + ; + function - : ( standardFunction | setFunction ) + : standardFunction + | setFunction ; standardFunction @@ -435,7 +437,7 @@ | ^(AVG numericValueExpression) | ^(MAX numericValueExpression) | ^(MIN numericValueExpression) - | ^(COUNT (ASTERISK | (DISTINCT|ALL)? countFunctionArguments)) + | ^(COUNT (ASTERISK | (DISTINCT|ALL) countFunctionArguments)) ; countFunctionArguments @@ -446,6 +448,7 @@ collectionFunction : ^((MAXELEMENT|MAXINDEX|MINELEMENT|MININDEX) collectionPropertyReference) + //it will generate a SELECT MAX (m.column) form Table xxx -> it is realted to Hibernate mappings to Table->Map ; collectionPropertyReference @@ -453,14 +456,14 @@ ; collectionExpression - : ^(ELEMENTS propertyReference) + : ^(ELEMENTS propertyReference) //it will generate a SELECT m.column form Table xxx -> it is realted to Hibernate mappings to Table->Map | ^(INDICES propertyReference) ; parameter : NAMED_PARAM | JPA_PARAM - | PARAM + | PARAM ; constant @@ -484,8 +487,12 @@ | FLOATING_POINT_LITERAL ; +entityName + : ENTITY_NAME ALIAS_NAME? + ; + propertyReference - : ^(PROPERTY_REFERENCE path) + : ^(PROPERTY_REFERENCE identPrimary) ; identPrimary @@ -494,14 +501,3 @@ | ^(LEFT_SQUARE identPrimary valueExpression* ) | ^(LEFT_PAREN identPrimary valueExpression* ) ; - -dotIdentifierPath - : IDENTIFIER - | ^(DOT dotIdentifierPath dotIdentifierPath) - ; - -path - : IDENTIFIER - | ^( DOT path path ) - | ^(LEFT_SQUARE path valueExpression* ) - ; Added: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/EntityNameTree.java =================================================================== --- core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/EntityNameTree.java (rev 0) +++ core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/EntityNameTree.java 2009-04-17 20:48:26 UTC (rev 16357) @@ -0,0 +1,38 @@ +package org.hibernate.sql.ast.phase.hql.parse; + +import java.util.List; + +import org.antlr.runtime.CommonToken; +import org.antlr.runtime.Token; +import org.antlr.runtime.tree.CommonTree; + +public class EntityNameTree extends CommonTree { + + private List entityNames = null; + private String outputText = null; + + public EntityNameTree(EntityNameTree entityNameTree, String outputText) { + this.token = entityNameTree.getToken(); + this.outputText = outputText; + } + + public EntityNameTree(int tokenType, Token token, String tokenText, + List entityNames) { + Token newToken = createToken(token); + newToken.setType(tokenType); + newToken.setText(tokenText); + this.token = newToken; + this.entityNames = entityNames; + } + + private Token createToken(Token fromToken) { + return new CommonToken(fromToken); + } + + public String toString() { + if (outputText == null) { + outputText = entityNames.get(0).toString(); + } + return outputText; + } +} \ No newline at end of file Property changes on: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/EntityNameTree.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContext.java =================================================================== --- core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContext.java (rev 0) +++ core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContext.java 2009-04-17 20:48:26 UTC (rev 16357) @@ -0,0 +1,12 @@ +package org.hibernate.sql.ast.phase.hql.parse; + +import java.util.List; + +public interface ParserContext { + + public boolean isJavaConstant(String text); + + public boolean isEntityName(String text); + + public List getEntityImplementors(String text); +} Property changes on: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContext.java ___________________________________________________________________ Name: svn:eol-style + native Added: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContextDefaultImpl.java =================================================================== --- core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContextDefaultImpl.java (rev 0) +++ core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContextDefaultImpl.java 2009-04-17 20:48:26 UTC (rev 16357) @@ -0,0 +1,22 @@ +package org.hibernate.sql.ast.phase.hql.parse; + +import java.util.ArrayList; +import java.util.List; + +public class ParserContextDefaultImpl implements ParserContext { + + public List getEntityImplementors(String text) { + List implementors = new ArrayList(); + implementors.add(text); + return implementors; + } + + public boolean isEntityName(String text) { + return true; + } + + public boolean isJavaConstant(String text) { + return false; + } + +} Property changes on: core/branches/antlr3/src/main/java/org/hibernate/sql/ast/phase/hql/parse/ParserContextDefaultImpl.java ___________________________________________________________________ Name: svn:eol-style + native