public HqlJoin(IASTFactory factory, HqlTreeNode expression, HqlAlias @alias) : base(HqlSqlWalker.JOIN, "join", factory, expression, @alias)
 {
 }

 internal void AddChild(HqlTreeNode child)
 {
     _children.Add(child);
     _node.AddChild(child.AstNode);
 }

 public HqlMin(IASTFactory factory, HqlTreeNode expression)
     : base(HqlSqlWalker.AGGREGATE, "min", factory, expression)
 {
 }

 public HqlAnd(IASTFactory factory, HqlTreeNode left, HqlTreeNode right) : base(HqlSqlWalker.AND, "and", factory, left, right)
 {
 }

 public HqlCast(IASTFactory factory, HqlTreeNode expression, System.Type type) : base(HqlSqlWalker.METHOD_CALL, "method", factory)
 {
     AddChild(new HqlIdent(factory, "cast"));
     AddChild(new HqlExpressionList(factory, expression, new HqlIdent(factory, type)));
 }

 public HqlAverage(IASTFactory factory, HqlTreeNode expression) : base(HqlSqlWalker.AGGREGATE, "avg", factory, expression)
 {
 }

 public HqlAs(IASTFactory factory, HqlTreeNode expression, System.Type type) : base(HqlSqlWalker.AS, "as", factory, expression)
 {
     switch (System.Type.GetTypeCode(type))
     {
         case TypeCode.Int32:
             AddChild(new HqlIdent(factory, "integer"));
             break;
         default:
             throw new InvalidOperationException();
     }
 }

 public HqlCount(IASTFactory factory, HqlTreeNode child)
     : base(HqlSqlWalker.COUNT, "count", factory, child)
 {
 }

 public HqlOrderBy(IASTFactory factory, HqlTreeNode expression, HqlDirection hqlDirection)
     : base(HqlSqlWalker.ORDER, "", factory, expression,
            hqlDirection == HqlDirection.Ascending ?
                 (HqlTreeNode)new HqlDirectionAscending(factory) : (HqlTreeNode)new HqlDirectionDescending(factory))
 {
 }

		private void ExecuteAddOrderBy(HqlTreeNode orderBy)
		{
			if (orderBy == null)
				return;

			if (!_root.NodesPreOrder.OfType<HqlOrderBy>().Any())
				_root.As<HqlQuery>().AddChild(orderBy);
		}

		public HqlRange Range(HqlTreeNode ident, HqlAlias alias)
		{
			return new HqlRange(_factory, ident, alias);
		}

		internal void AddChild(HqlTreeNode child)
		{
			if (child is HqlExpressionSubTreeHolder) 
			{
				AddChildren(child.Children);
			}
			else
			{
				_children.Add(child);
				_node.AddChild(child.AstNode);
			}
		}

		public HqlIn(IASTFactory factory, HqlExpression itemExpression, HqlTreeNode source)
			: base(HqlSqlWalker.IN, "in", factory, itemExpression)
		{
			AddChild(new HqlInList(factory, source));
		}

		public HqlInList(IASTFactory factory, HqlTreeNode source)
			: base(HqlSqlWalker.IN_LIST, "inlist", factory, source)
		{
		}

		public void AddSelectClause(HqlTreeNode select)
		{
			_root.NodesPreOrder.OfType<HqlSelectFrom>().First().AddChild(select);
		}

		public HqlExpressionSubTreeHolder(IASTFactory factory, HqlTreeNode[] children) : base(int.MinValue, "expression sub-tree holder", factory, children)
		{
		}

 public void AddFromClause(HqlTreeNode from)
 {
     root.NodesPreOrder.Where(n => n is HqlFrom).First().AddChild(from);
 }

		public void AddFromClause(HqlTreeNode from)
		{
			_root.NodesPreOrder.OfType<HqlFrom>().First().AddChild(from);
		}

		public void SetRoot(HqlTreeNode newRoot)
		{
			_root = newRoot;
		}

		internal void AddChild(HqlTreeNode child)
		{
			if (child is HqlDistinctHolder)
			{
				AddChildren(child.Children);
			}
			else
			{
				_children.Add(child);
				_node.AddChild(child.AstNode);
			}
		}