Hql-ast.nitra

using Nitra;
using Nitra.Declarations;

namespace Hql
{
  ast Start
  {
    Query : Query;
  }

  ast Query
  {    
     SelectStms : SelectStm*;
	   UnionTypes : UnionType*;
  }

  abstract ast UnionType
  {
    | Union 
	  | UnionAll
  }

  ast SelectStm
  {
     in ContainingTable: TableScope;

	   FromClause.ContainingTable = ContainingTable;

     FromClause   : FromClause?;
	   SelectClause : SelectClause;
	   WhereClause  : WhereClause?;
	   GroupClause  : GroupClause?;
	   OrderClause  : OrderClause?;
  }  

  ast OrderClause
  {
     OrderFields : OrderField*;
  }

  abstract ast OrderField
  {
    | OrderAsc  { Expression : Expression; }
    | OrderDesc { Expression : Expression; }
  }

  ast GroupClause
  {
     Expressions  : Expression*;
	   HavingClause : HavingClause?;
  }

  ast HavingClause
  {
    LogicalExpression : LogicalExpression;
  }

  ast WhereClause
  {
     LogicalExpression : LogicalExpression;
  }

  ast SelectClause
  {
     Distinct : bool;
	   Columns : Column*;
  }

  abstract ast Column
  {
    | AllTabAllFields
	  | OneTabAllFields { TableName : QualifiedIdentifier; }
	  | ColumnExpressionWithAlias { Expression : Expression; Alias : Alias?; }
  }

  ast FromClause
  {
    in ContainingTable: TableScope; 

    TableSource : TableSource;
  }

  ast TableSource
  {     
     TableSourceItem : TableSourceItem; 
	   JoinParts       : JoinPart*;
  }

  abstract ast JoinPart
  {
    | Join { JoinType : JoinType; TableSource : TableSource; Expression : LogicalExpression; }
	  | Link { TableSource : TableSource; }
	  | JoinList { TableSource : TableSource; }
  }

  abstract ast JoinType
  {
    | Inner
	  | Left
	  | Right
	  | Full
  }

  abstract ast TableSourceItem
  {
     | SubQuery            { Query : Query; Alias : Alias; } 
	   | TableSourceNameFull { TableNameFull : TableNameFull; }
  }

  ast TableNameFull
  {
     TableName : QualifiedIdentifier; 
	   Alias     : Alias?;
  }

  ast Alias
  {
     Name : string;
  }

  abstract ast StringAlias
  {
      | StringAliasQualifiedIdentifierPart { QualifiedIdentifierPart : QualifiedIdentifierPart; }
	    | StringAliasStringLiteral { StringLiteralRule : StringLiteralRule; }
  }

  abstract ast StringLiteralRule
  {
     | DoubleStringLiteralPartRule { Value : string; }
	   | SingleStringLiteralPartRule { Value : string; }
  }

  ast QualifiedIdentifier
  {
     QualifiedIdentifierParts : QualifiedIdentifierPart*;
	   Delimiters               : Delimiter*;
  }

  ast QualifiedIdentifierPartHolder
  {
      QualifiedIdentifierPart : QualifiedIdentifierPart; 
  }

  ast QualifiedIdentifierPart
  {
     Value : string;
  }

  abstract ast Delimiter
  {
    | FullJoinDelimiter
	  | RightJoinDelimiter
	  | LeftJoinDelimiter
	  | DefaultJoinDelimiter
  }

  abstract ast MyValues
  {
    | QueryExpression    { Query : Query;}
	  | BracketsExpression { Expressions : Expression*;}
  }

  abstract ast LogicalUnary : LogicalExpression
  {
      Expr : LogicalExpression;
  }

  abstract ast ExpLogicalUnary : LogicalExpression
  {
      Expr : Expression;
  }

  abstract ast LogicalBinary : LogicalExpression
  {
      Expr1 : LogicalExpression;
	    Expr2 : LogicalExpression;
  }

  abstract ast ExpLogicalBinary : LogicalExpression
  {
     Expr1 : Expression;
	   Expr2 : Expression;
  }

  abstract ast LogicalIn : LogicalExpression
  {
     Expr   : Expression;
	   Values : MyValues;
  }

  abstract ast LogicalExists : LogicalExpression
  {
	   Query : Query;
  }

  abstract ast LogicalExpression
  {
    | ValueIsNotNull : ExpLogicalUnary
	  | ValueIsNull    : ExpLogicalUnary
	  | Like           : ExpLogicalBinary
	  | NotLike        : ExpLogicalBinary
	  | In             : LogicalIn
	  | NotIn          : LogicalIn
	  | Exists         : LogicalExists
	  | Or             : LogicalBinary
	  | And            : LogicalBinary
	  | Not            : LogicalUnary
	  | Equal          : ExpLogicalBinary
    | NotEqual       : ExpLogicalBinary
	  | LessEqual      : ExpLogicalBinary
	  | Less           : ExpLogicalBinary
	  | GreaterEqual   : ExpLogicalBinary
	  | Greater        : ExpLogicalBinary
  }

  abstract ast Unary : Expression 
  { 
    Expr : Expression; 
  }   

  abstract ast Binary : Expression 
  { 
    Expr1 : Expression; 
	  Expr2 : Expression; 
  }     

  abstract ast Field
  {
    | SingleField { FieldName : QualifiedIdentifierPart; }
	  | TableLinkField { TableLinks : TableLink*; FieldName : QualifiedIdentifierPart;}
  }

  ast TableLink
  {
     LinkName : QualifiedIdentifierPart;
	   LinkDelimiter : Delimiter?;
  }

  ast CaseCondition
  {
     Condition : LogicalExpression;
	   Then      : Expression; 
  }
  
  abstract ast Expression : BindableAst
  {
    | IntegerLiteral    { Value : int; }
    | FloatLiteral      { Value : double; }
    | StringLiteralRule { Value : string; }
    | DateLiteral       { Value : System.DateTime; }	  
	  | SubQueryExpression { Query : Query; }
	  | Null
	  | FieldExpression { Field : Field; }
	  | Case { Conditions : CaseCondition*; Else : Expression?; }
	  | CountAll
	  | FunCall           { FuncName : Field;  Arguments : Expression*;}
	  | Argument          { Expr : Expression; }
	  | Concat : Binary
	  | Sum : Binary
	  | Sub : Binary
	  | Modulus : Binary
	  | Multiply : Binary
	  | Divide : Binary
	  | Plus : Unary
	  | Minus : Unary
  }  

  declaration Root : Container {}
}