protected HqlTreeNode(int type, string text, IASTFactory factory, IEnumerable<HqlTreeNode> children)
		{
			Factory = factory;
			_node = factory.CreateNode(type, text);
			_children = new List<HqlTreeNode>();

			AddChildren(children);
		}

        protected HqlTreeNode(int type, string text, IASTFactory factory, params HqlTreeNode[] children)
        {
            _node = factory.CreateNode(type, text);
            _children = new List<HqlTreeNode>();

            foreach (var child in children)
            {
                _children.Add(child);
                _node.AddChild(child.AstNode);
            }
        }

		/// <summary>
		/// Generates the scalar column AST nodes for a given array of SQL columns
		/// </summary>
		public static void GenerateScalarColumns(IASTFactory factory, IASTNode node, string[] sqlColumns, int i)
		{
			if (sqlColumns.Length == 1)
			{
				GenerateSingleScalarColumn(factory, node, i);
			}
			else
			{
				node.Text = sqlColumns[0]; // Use the DOT node to emit the first column name.

				// Create the column names, folled by the column aliases.
				for (int j = 0; j < sqlColumns.Length; j++)
				{
					if (j > 0)
					{
						node = node.AddSibling(factory.CreateNode(HqlSqlWalker.SQL_TOKEN, sqlColumns[j]));
					}

					node = node.AddSibling(factory.CreateNode(HqlSqlWalker.SELECT_COLUMNS, " as " + NameGenerator.ScalarName(i, j)));
				}
			}
		}

		/// <summary>
		/// Turns a path into an AST.
		/// </summary>
		/// <param name="path">The path.</param>
		/// <param name="factory">The AST factory to use.</param>
		/// <returns>An HQL AST representing the path.</returns>
		public static IASTNode ParsePath(string path, IASTFactory factory)
		{
			string[] identifiers = StringHelper.Split(".", path);
			IASTNode lhs = null;
			for (int i = 0; i < identifiers.Length; i++)
			{
				string identifier = identifiers[i];
				IASTNode child = factory.CreateNode(HqlSqlWalker.IDENT, identifier);
				if (i == 0)
				{
					lhs = child;
				}
				else
				{
					lhs = factory.CreateNode(HqlSqlWalker.DOT, ".", lhs, child);
				}
			}
			if (log.IsDebugEnabled)
			{
				log.Debug("parsePath() : " + path + " -> " + ASTUtil.GetDebugstring(lhs));
			}
			return lhs;
		}

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

		public HqlStar(IASTFactory factory) : base(HqlSqlWalker.ROW_STAR, "*", factory)
		{
		}

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

		public HqlConcat(IASTFactory factory, params HqlExpression[] args)
			: base(HqlSqlWalker.METHOD_CALL, "method", factory)
		{
			AddChild(new HqlIdent(factory, "concat"));
			AddChild(new HqlExpressionList(factory, args));
		}

		public HqlAll(IASTFactory factory)
			: base(HqlSqlWalker.ALL, "all", factory)
		{
		}

		public HqlDistinct(IASTFactory factory) : base(HqlSqlWalker.DISTINCT, "distinct", factory)
		{
		}

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

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

		public HqlSum(IASTFactory factory, HqlExpression expression)
			: base(HqlSqlWalker.AGGREGATE, "sum", factory, expression)
		{
		}

		public HqlBitwiseNot(IASTFactory factory) : base(HqlSqlWalker.BNOT, "not", factory)
		{
		}

		public HqlExists(IASTFactory factory, HqlQuery query) : base(HqlSqlWalker.EXISTS, "exists", factory, query)
		{
		}

		public HqlElements(IASTFactory factory) : base(HqlSqlWalker.ELEMENTS, "elements", factory)
		{
		}

		public HqlLeftFetchJoin(IASTFactory factory, HqlExpression expression, HqlAlias @alias)
			: base(HqlSqlWalker.JOIN, "join", factory, new HqlLeft(factory), new HqlFetch(factory), expression, @alias)
		{
		}

		public HqlGroupBy(IASTFactory factory, params HqlExpression[] expressions) : base(HqlSqlWalker.GROUP, "group by", factory, expressions)
		{
		}

		public HqlFetch(IASTFactory factory) : base(HqlSqlWalker.FETCH, "fetch", factory)
		{
		}

		public HqlLike(IASTFactory factory, HqlExpression lhs, HqlExpression rhs)
			: base(HqlSqlWalker.LIKE, "like", factory, lhs, rhs)
		{
		}