[hibernate-commits] Hibernate SVN: r16322 - core/branches/antlr3/src/main/antlr.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Tue Apr 14 12:41:30 EDT 2009
Author: steve.ebersole at jboss.com
Date: 2009-04-14 12:41:30 -0400 (Tue, 14 Apr 2009)
New Revision: 16322
Removed:
core/branches/antlr3/src/main/antlr/sql-gen.g
Log:
creating antlr3 branch
Deleted: core/branches/antlr3/src/main/antlr/sql-gen.g
===================================================================
--- core/branches/antlr3/src/main/antlr/sql-gen.g 2009-04-14 16:41:16 UTC (rev 16321)
+++ core/branches/antlr3/src/main/antlr/sql-gen.g 2009-04-14 16:41:30 UTC (rev 16322)
@@ -1,427 +0,0 @@
-header
-{
-// $Id: sql-gen.g 10001 2006-06-08 21:08:04Z steve.ebersole at jboss.com $
-package org.hibernate.hql.antlr;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-}
-/**
- * SQL Generator Tree Parser, providing SQL rendering of SQL ASTs produced by the previous phase, HqlSqlWalker. All
- * syntax decoration such as extra spaces, lack of spaces, extra parens, etc. should be added by this class.
- * <br>
- * This grammar processes the HQL/SQL AST and produces an SQL string. The intent is to move dialect-specific
- * code into a sub-class that will override some of the methods, just like the other two grammars in this system.
- * @author Joshua Davis (joshua at hibernate.org)
- */
-class SqlGeneratorBase extends TreeParser;
-
-options {
- // Note: importVocab and exportVocab cause ANTLR to share the token type numbers between the
- // two grammars. This means that the token type constants from the source tree are the same
- // as those in the target tree. If this is not the case, tree translation can result in
- // token types from the *source* tree being present in the target tree.
- importVocab=HqlSql; // import definitions from "HqlSql"
- exportVocab=Sql; // Call the resulting definitions "Sql"
- buildAST=false; // Don't build an AST.
-}
-
-{
- private static Logger log = LoggerFactory.getLogger(SqlGeneratorBase.class);
-
- /** the buffer resulting SQL statement is written to */
- private StringBuffer buf = new StringBuffer();
-
- protected void out(String s) {
- buf.append(s);
- }
-
- /**
- * Returns the last character written to the output, or -1 if there isn't one.
- */
- protected int getLastChar() {
- int len = buf.length();
- if ( len == 0 )
- return -1;
- else
- return buf.charAt( len - 1 );
- }
-
- /**
- * Add a aspace if the previous token was not a space or a parenthesis.
- */
- protected void optionalSpace() {
- // Implemented in the sub-class.
- }
-
- protected void out(AST n) {
- out(n.getText());
- }
-
- protected void separator(AST n, String sep) {
- if (n.getNextSibling() != null)
- out(sep);
- }
-
- protected boolean hasText(AST a) {
- String t = a.getText();
- return t != null && t.length() > 0;
- }
-
- protected void fromFragmentSeparator(AST a) {
- // moved this impl into the subclass...
- }
-
- protected void nestedFromFragment(AST d,AST parent) {
- // moved this impl into the subclass...
- }
-
- protected StringBuffer getStringBuffer() {
- return buf;
- }
-
- protected void nyi(AST n) {
- throw new UnsupportedOperationException("Unsupported node: " + n);
- }
-
- protected void beginFunctionTemplate(AST m,AST i) {
- // if template is null we just write the function out as it appears in the hql statement
- out(i);
- out("(");
- }
-
- protected void endFunctionTemplate(AST m) {
- out(")");
- }
-
- protected void commaBetweenParameters(String comma) {
- out(comma);
- }
-}
-
-statement
- : selectStatement
- | updateStatement
- | deleteStatement
- | insertStatement
- ;
-
-selectStatement
- : #(SELECT { out("select "); }
- selectClause
- from
- ( #(WHERE { out(" where "); } whereExpr ) )?
- ( #(GROUP { out(" group by "); } groupExprs ( #(HAVING { out(" having "); } booleanExpr[false]) )? ) )?
- ( #(ORDER { out(" order by "); } orderExprs ) )?
- )
- ;
-
-// Note: eats the FROM token node, as it is not valid in an update statement.
-// It's outlived its usefulness after analysis phase :)
-// TODO : needed to use conditionList directly here and deleteStatement, as whereExprs no longer works for this stuff
-updateStatement
- : #(UPDATE { out("update "); }
- #( FROM fromTable )
- setClause
- (whereClause)?
- )
- ;
-
-deleteStatement
- // Note: not space needed at end of "delete" because the from rule included one before the "from" it outputs
- : #(DELETE { out("delete"); }
- from
- (whereClause)?
- )
- ;
-
-insertStatement
- : #(INSERT { out( "insert " ); }
- i:INTO { out( i ); out( " " ); }
- selectStatement
- )
- ;
-
-setClause
- // Simply re-use comparisionExpr, because it already correctly defines the EQ rule the
- // way it is needed here; not the most aptly named, but ah
- : #( SET { out(" set "); } comparisonExpr[false] ( { out(", "); } comparisonExpr[false] )* )
- ;
-
-whereClause
- : #(WHERE { out(" where "); } whereClauseExpr )
- ;
-
-whereClauseExpr
- : (SQL_TOKEN) => conditionList
- | booleanExpr[ false ]
- ;
-
-orderExprs
- // TODO: remove goofy space before the comma when we don't have to regression test anymore.
- : ( expr ) (dir:orderDirection { out(" "); out(dir); })? ( {out(", "); } orderExprs)?
- ;
-
-groupExprs
- // TODO: remove goofy space before the comma when we don't have to regression test anymore.
- : expr ( {out(" , "); } groupExprs)?
- ;
-
-orderDirection
- : ASCENDING
- | DESCENDING
- ;
-
-whereExpr
- // Expect the filter subtree, followed by the theta join subtree, followed by the HQL condition subtree.
- // Might need parens around the HQL condition if there is more than one subtree.
- // Put 'and' between each subtree.
- : filters
- ( { out(" and "); } thetaJoins )?
- ( { out(" and "); } booleanExpr [ true ] )?
- | thetaJoins
- ( { out(" and "); } booleanExpr [ true ] )?
- | booleanExpr[false]
- ;
-
-filters
- : #(FILTERS conditionList )
- ;
-
-thetaJoins
- : #(THETA_JOINS conditionList )
- ;
-
-conditionList
- : sqlToken ( { out(" and "); } conditionList )?
- ;
-
-selectClause
- : #(SELECT_CLAUSE (distinctOrAll)? ( selectColumn )+ )
- ;
-
-selectColumn
- : p:selectExpr (sc:SELECT_COLUMNS { out(sc); } )? { separator( (sc != null) ? sc : p,", "); }
- ;
-
-selectExpr
- : e:selectAtom { out(e); }
- | count
- | #(CONSTRUCTOR (DOT | IDENT) ( selectColumn )+ )
- | methodCall
- | aggregate
- | c:constant { out(c); }
- | arithmeticExpr
- | param:PARAM { out(param); }
- | sn:SQL_NODE { out(sn); }
- | { out("("); } selectStatement { out(")"); }
- ;
-
-count
- : #(COUNT { out("count("); } ( distinctOrAll ) ? countExpr { out(")"); } )
- ;
-
-distinctOrAll
- : DISTINCT { out("distinct "); }
- | ALL { out("all "); }
- ;
-
-countExpr
- // Syntacitic predicate resolves star all by itself, avoiding a conflict with STAR in expr.
- : ROW_STAR { out("*"); }
- | simpleExpr
- ;
-
-selectAtom
- : DOT
- | SQL_TOKEN
- | ALIAS_REF
- | SELECT_EXPR
- ;
-
-// The from-clause piece is all goofed up. Currently, nodes of type FROM_FRAGMENT
-// and JOIN_FRAGMENT can occur at any level in the FromClause sub-tree. We really
-// should come back and clean this up at some point; which I think will require
-// a post-HqlSqlWalker phase to "re-align" the FromElements in a more sensible
-// manner.
-from
- : #(f:FROM { out(" from "); }
- (fromTable)* )
- ;
-
-fromTable
- // Write the table node (from fragment) and all the join fragments associated with it.
- : #( a:FROM_FRAGMENT { out(a); } (tableJoin [ a ])* { fromFragmentSeparator(a); } )
- | #( b:JOIN_FRAGMENT { out(b); } (tableJoin [ b ])* { fromFragmentSeparator(b); } )
- ;
-
-tableJoin [ AST parent ]
- : #( c:JOIN_FRAGMENT { out(" "); out(c); } (tableJoin [ c ] )* )
- | #( d:FROM_FRAGMENT { nestedFromFragment(d,parent); } (tableJoin [ d ] )* )
- ;
-
-booleanOp[ boolean parens ]
- : #(AND booleanExpr[true] { out(" and "); } booleanExpr[true])
- | #(OR { if (parens) out("("); } booleanExpr[false] { out(" or "); } booleanExpr[false] { if (parens) out(")"); })
- | #(NOT { out(" not ("); } booleanExpr[false] { out(")"); } )
- ;
-
-booleanExpr[ boolean parens ]
- : booleanOp [ parens ]
- | comparisonExpr [ parens ]
- | st:SQL_TOKEN { out(st); } // solely for the purpose of mapping-defined where-fragments
- ;
-
-comparisonExpr[ boolean parens ]
- : binaryComparisonExpression
- | { if (parens) out("("); } exoticComparisonExpression { if (parens) out(")"); }
- ;
-
-binaryComparisonExpression
- : #(EQ expr { out("="); } expr)
- | #(NE expr { out("<>"); } expr)
- | #(GT expr { out(">"); } expr)
- | #(GE expr { out(">="); } expr)
- | #(LT expr { out("<"); } expr)
- | #(LE expr { out("<="); } expr)
- ;
-
-exoticComparisonExpression
- : #(LIKE expr { out(" like "); } expr likeEscape )
- | #(NOT_LIKE expr { out(" not like "); } expr likeEscape)
- | #(BETWEEN expr { out(" between "); } expr { out(" and "); } expr)
- | #(NOT_BETWEEN expr { out(" not between "); } expr { out(" and "); } expr)
- | #(IN expr { out(" in"); } inList )
- | #(NOT_IN expr { out(" not in "); } inList )
- | #(EXISTS { optionalSpace(); out("exists "); } quantified )
- | #(IS_NULL expr) { out(" is null"); }
- | #(IS_NOT_NULL expr) { out(" is not null"); }
- ;
-
-likeEscape
- : ( #(ESCAPE { out(" escape "); } expr) )?
- ;
-
-inList
- : #(IN_LIST { out(" "); } ( parenSelect | simpleExprList ) )
- ;
-
-simpleExprList
- : { out("("); } (e:simpleExpr { separator(e," , "); } )* { out(")"); }
- ;
-
-// A simple expression, or a sub-select with parens around it.
-expr
- : simpleExpr
- | #( VECTOR_EXPR { out("("); } (e:expr { separator(e," , "); } )* { out(")"); } )
- | parenSelect
- | #(ANY { out("any "); } quantified )
- | #(ALL { out("all "); } quantified )
- | #(SOME { out("some "); } quantified )
- ;
-
-quantified
- : { out("("); } ( sqlToken | selectStatement ) { out(")"); }
- ;
-
-parenSelect
- : { out("("); } selectStatement { out(")"); }
- ;
-
-simpleExpr
- : c:constant { out(c); }
- | NULL { out("null"); }
- | addrExpr
- | sqlToken
- | aggregate
- | methodCall
- | count
- | parameter
- | arithmeticExpr
- ;
-
-constant
- : NUM_DOUBLE
- | NUM_FLOAT
- | NUM_INT
- | NUM_LONG
- | QUOTED_STRING
- | CONSTANT
- | JAVA_CONSTANT
- | TRUE
- | FALSE
- | IDENT
- ;
-
-arithmeticExpr
- : additiveExpr
- | multiplicativeExpr
-// | #(CONCAT { out("("); } expr ( { out("||"); } expr )+ { out(")"); } )
- | #(UNARY_MINUS { out("-"); } expr)
- | caseExpr
- ;
-
-additiveExpr
- : #(PLUS expr { out("+"); } expr)
- | #(MINUS expr { out("-"); } nestedExprAfterMinusDiv)
- ;
-
-multiplicativeExpr
- : #(STAR nestedExpr { out("*"); } nestedExpr)
- | #(DIV nestedExpr { out("/"); } nestedExprAfterMinusDiv)
- ;
-
-nestedExpr
- // Generate parens around nested additive expressions, use a syntactic predicate to avoid conflicts with 'expr'.
- : (additiveExpr) => { out("("); } additiveExpr { out(")"); }
- | expr
- ;
-
-nestedExprAfterMinusDiv
- // Generate parens around nested arithmetic expressions, use a syntactic predicate to avoid conflicts with 'expr'.
- : (arithmeticExpr) => { out("("); } arithmeticExpr { out(")"); }
- | expr
- ;
-
-caseExpr
- : #(CASE { out("case"); }
- ( #(WHEN { out( " when "); } booleanExpr[false] { out(" then "); } expr) )+
- ( #(ELSE { out(" else "); } expr) )?
- { out(" end"); } )
- | #(CASE2 { out("case "); } expr
- ( #(WHEN { out( " when "); } expr { out(" then "); } expr) )+
- ( #(ELSE { out(" else "); } expr) )?
- { out(" end"); } )
- ;
-
-aggregate
- : #(a:AGGREGATE { out(a); out("("); } expr { out(")"); } )
- ;
-
-
-methodCall
- : #(m:METHOD_CALL i:METHOD_NAME { beginFunctionTemplate(m,i); }
- ( #(EXPR_LIST (arguments)? ) )?
- { endFunctionTemplate(m); } )
- ;
-
-arguments
- : expr ( { commaBetweenParameters(", "); } expr )*
- ;
-
-parameter
- : n:NAMED_PARAM { out(n); }
- | p:PARAM { out(p); }
- ;
-
-addrExpr
- : #(r:DOT . .) { out(r); }
- | i:ALIAS_REF { out(i); }
- | j:INDEX_OP { out(j); }
- ;
-
-sqlToken
- : t:SQL_TOKEN { out(t); }
- ;
-
More information about the hibernate-commits
mailing list