Hql-mapping.nitra

using Nitra;
using Nitra.Runtime;
using Nitra.Declarations;
using System.Globalization;

namespace Hql
{
   map syntax HqlSyntax.Start -> Start
   {
      Query -> Query;
   }

   map syntax HqlSyntax.Query -> Query
   {     
      SelectStms.Item1 -> SelectStms;
	    SelectStms.Item2 -> UnionTypes;
   }
   
   map syntax HqlSyntax.UnionType -> UnionType
   {
      | Union -> Union {}
	    | UnionAll -> UnionAll {}
   }  

   map syntax HqlSyntax.SelectStm -> SelectStm
   {
      FromClause   -> FromClause;
	    SelectClause -> SelectClause;
	    WhereClause  -> WhereClause;
	    GroupClause  -> GroupClause;
	    OrderClause  -> OrderClause;
   }   

   map syntax HqlSyntax.FromClause -> FromClause
   {
      TableSource -> TableSource;
   }

   map syntax HqlSyntax.TableSource -> TableSource
   {
      | TableSourceItemJoined { TableSourceItemJoined.TableSourceItem -> TableSourceItem; TableSourceItemJoined.JoinParts -> JoinParts; }
	    | TableSourceItemJoinedWithBrackets { TableSourceItemJoined.TableSourceItem -> TableSourceItem; TableSourceItemJoined.JoinParts -> JoinParts; }
   }

   map syntax HqlSyntax.JoinPart -> JoinPart
   {
     | Join -> Join { JoinType -> JoinType; RightTableSource -> TableSource; LogicalExpression -> Expression; }
	   | Link -> Link { TableSource -> TableSource; } 
	   | List -> JoinList { TableSource -> TableSource; } 
   }

   map syntax HqlSyntax.OuterJoinType -> JoinType
   {
		  | Left -> Left {}
		  | Right -> Right {}
		  | Full -> Full {}
   }

   map syntax HqlSyntax.JoinType -> JoinType
   {
     | Inner -> Inner {}
	   | OuterJoin -> this
   }

   map syntax HqlSyntax.TableSourceItem -> TableSourceItem
   {
      | SubQuery -> SubQuery { SubQuery.Query -> Query; SubQuery.Alias -> Alias; }
	    | TableNameFull -> TableSourceNameFull { TableNameFull -> TableNameFull;}
   }

   map syntax HqlSyntax.TableNameFull -> TableNameFull
   {
      TableName -> TableName;
	    match(Alias)
			   {
			     | Some(value) -> Some(value)
			     | None() -> None()
			   } -> Alias;
   }

   map syntax HqlSyntax.QualifiedIdentifier -> QualifiedIdentifier
   {
     QualifiedIdentifierParts.Item1 -> QualifiedIdentifierParts;
	   QualifiedIdentifierParts.Item2 -> Delimiters;
   }

   map syntax HqlSyntax.QualifiedIdentifierPart -> QualifiedIdentifierPart
   {      
      | SingleReference 
			    {
			       Value = ParsedValue(Reference.Span, GetText(Reference.Span));
			    }
	    | QuotedReference 
			    {
			       Value = ParsedValue(Ref, GetText(Ref));
			    }
   }

   map syntax HqlSyntax.Delimiter -> Delimiter
   {
      | FullJoin -> FullJoinDelimiter {}
	    | RightJoin -> RightJoinDelimiter {}
	    | LeftJoin -> LeftJoinDelimiter {}
	    | DefaultJoin -> DefaultJoinDelimiter {}
   }

   
   map syntax HqlSyntax.Alias -> Alias
   {       
     Name =  ParsedValue(StringAlias.Span, StringAlias.Value());
   }
   
   map syntax HqlSyntax.SelectClause -> SelectClause
   {
      Distinct = ParsedValue(if (Distinct.HasValue) Distinct.Value else NSpan(0), Distinct.HasValue);	

	    Columns.Item1 -> Columns;
   }

   map syntax HqlSyntax.Column -> Column
   {
     | AllTabAllFields -> AllTabAllFields {}
	   | OneTabAllFields -> OneTabAllFields { QualifiedIdentifier -> TableName;}
	   | Expression -> ColumnExpressionWithAlias { Expression -> Expression; None() -> Alias; }
	   | ExpressionWithAlias -> ColumnExpressionWithAlias { Expression -> Expression; Some(Alias) -> Alias; }
   }

   map syntax HqlSyntax.OrderClause -> OrderClause
   {
      OrderList.Item1 -> OrderFields;
   }

   map syntax HqlSyntax.OrderField -> OrderField
   {
     | OrderAsc -> OrderAsc { Expression -> Expression; }
	   | OrderDesc -> OrderDesc { Expression -> Expression; }
   }

   map syntax HqlSyntax.GroupClause -> GroupClause
   {
      GroupList.Item1 -> Expressions;
	    HavingClause -> HavingClause; 
   }
   
   map syntax HqlSyntax.HavingClause -> HavingClause
   {
      LogicalExpression -> LogicalExpression;
   }

   map syntax HqlSyntax.WhereClause -> WhereClause
   {
      LogicalExpression -> LogicalExpression;
   }

   map syntax HqlSyntax.MyValues -> MyValues
   {
     | QueryExpression -> QueryExpression { Query -> Query; }
	   | BracketsExpression -> BracketsExpression { Expressions.Item1 -> Expressions; }
   }

   map syntax HqlSyntax.LogicalExpression -> LogicalExpression
   {
     | Braces -> LogicalExpression
	   | ValueIsNotNull { Expression -> Expr; }
	   | ValueIsNull { Expression -> Expr; }
	   | Like { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | NotLike { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | In { Expression -> Expr; MyValues -> Values; }
	   | NotIn { Expression -> Expr; MyValues -> Values; } 
	   | Exists  { Query -> Query; }
	   | Or { LogicalExpression1 -> Expr1; LogicalExpression2 -> Expr2; }
	   | And { LogicalExpression1 -> Expr1; LogicalExpression2 -> Expr2; }
	   | Not { LogicalExpression -> Expr; }
	   | Equal { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | NotEqual { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | LessEqual { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Less { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | GreaterEqual { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Greater { Expression1 -> Expr1; Expression2 -> Expr2; }
   }

   map syntax HqlSyntax.CaseCondition -> CaseCondition
   {
      Condition -> Condition;
	    Then -> Then;
   }

   map syntax HqlSyntax.Field -> Field
   {
     | SingleField -> SingleField { QualifiedIdentifierPart -> FieldName;}
	   | TableLink -> TableLinkField { TableLinkAndDelimitersIn -> TableLinks; Field -> FieldName; }
   }

   map syntax HqlSyntax.TableLinkAndDelimiter -> TableLink
   {
     QualifiedIdentifierPart -> LinkName;
	   match(TableDelimiter)
			 {
			   | Some(value) -> Some(value)
			   | None() -> None()
			 } -> LinkDelimiter;
   }


   map syntax HqlSyntax.Expression -> Expression
   {
     | Braces -> Expression
	   | Query -> SubQueryExpression { Query -> Query; }
	   | IntegerLiteral { Value = ParsedValue(IntegerLiteral, int.Parse(GetText(IntegerLiteral))); }
	   | FloatLiteral { Value = ParsedValue(FloatLiteral, double.Parse(GetText(FloatLiteral), NumberStyles.Any, CultureInfo.InvariantCulture)); }
     | StringLiteralRule { Value = ParsedValue(StringLiteralRule.Span, StringLiteralRule.Value()); }
	   | DateLiteral { 
	                    Value = ParsedValue(DateLiteral, 
	                                        System.DateTime.ParseExact(GetText(DateLiteral).Substring(1, GetText(DateLiteral).Length-2),
										                      array ["dd.MM.yyyy", "dd.MM.yyyy hh:mm", "dd.MM.yyyy hh:mm:ss"],
									                        null, 
										                      DateTimeStyles.None)); 
				           }
	   | Null {}
	   | Field -> FieldExpression { Field -> Field; }
	   | Case { 
	           Conditions -> Conditions; 
			       match(Else)
			       {
			         | Some((_, value)) -> Some(value)
			         | None() -> None()
			       } -> Else;
			     }	         
	   | CountAll {}
	   | FunCall { FuncName -> FuncName; Expressions.Item1 -> Arguments; }
	   | Concat { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Sum { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Sub { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Modulus { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Multiply { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Divide { Expression1 -> Expr1; Expression2 -> Expr2; }
	   | Plus { Expression -> Expr; }
	   | Minus { Expression -> Expr; }
   }

}