public void AddOrderByClause(HqlExpression orderBy, HqlDirectionStatement direction)
        {
            var orderByRoot = Root.NodesPreOrder.Where(n => n is HqlOrderBy).FirstOrDefault();

            if (orderByRoot == null)
            {
                orderByRoot = TreeBuilder.OrderBy();
                Root.As<HqlQuery>().AddChild(orderByRoot);
            }

            orderByRoot.AddChild(orderBy);
            orderByRoot.AddChild(direction);
        }

		public static HqlExpression ConvertBooleanToCase(HqlExpression node)
		{
			if (node is HqlBooleanExpression)
			{
				var builder = new HqlTreeBuilder();

				return builder.Case(
					new[] {builder.When(node, builder.True())},
					builder.False());
			}

			return node;
		}

        public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject,
            ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
        {
            // There is a problem with NHibernate when an identifier matches an entity's name. The resulting
            // SQL may be null in that situation. The searchTable's name is split in 2 identifiers to mitigate the problem.
            string searchTable = (string)((ConstantExpression)arguments[2]).Value;
            var searchTableFullName = searchTable.Split('.');
            if (searchTableFullName.Length != 2)
                throw new FrameworkException("FullTextSearch table name '" + searchTable + "' must have format 'schema.table'.");

            string searchColumns = (string)((ConstantExpression)arguments[3]).Value;

            var parameters = new HqlExpression[]
            {
                visitor.Visit(arguments[0]).AsExpression(),
                visitor.Visit(arguments[1]).AsExpression(),
                treeBuilder.Ident(searchTableFullName[0]),
                treeBuilder.Ident(searchTableFullName[1]),
                treeBuilder.Ident(searchColumns),
            };

            return treeBuilder.BooleanMethodCall("FullTextSearch", parameters);
        }

		public HqlTreeNode Indices(HqlExpression dictionary)
		{
			return new HqlIndices(_factory, dictionary);
		}

		public HqlTreeNode Coalesce(HqlExpression lhs, HqlExpression rhs)
		{
			return new HqlCoalesce(_factory, lhs, rhs);
		}

		public HqlLeftFetchJoin LeftFetchJoin(HqlExpression expression, HqlAlias @alias)
		{
			return new HqlLeftFetchJoin(_factory, expression, @alias);
		}

		public HqlIsNotNull IsNotNull(HqlExpression lhs)
		{
			return new HqlIsNotNull(_factory, lhs);
		}

		public HqlJoin Join(HqlExpression expression, HqlAlias @alias)
		{
			return new HqlJoin(_factory, expression, @alias);
		}

		public HqlMin Min(HqlExpression expression)
		{
			return new HqlMin(_factory, expression);
		}

		public HqlSelect Select(HqlExpression expression)
		{
			return new HqlSelect(_factory, expression);
		}

		public HqlTake Take(HqlExpression parameter)
		{
			return new HqlTake(_factory, parameter);
		}

		public HqlSkip Skip(HqlExpression parameter)
		{
			return new HqlSkip(_factory, parameter);
		}

		public HqlWhere Where(HqlExpression expression)
		{
			return new HqlWhere(_factory, expression);
		}

		public HqlDot Dot(HqlExpression lhs, HqlExpression rhs)
		{
			return new HqlDot(_factory, lhs, rhs);
		}

		public HqlDivide Divide(HqlExpression lhs, HqlExpression rhs)
		{
			return new HqlDivide(_factory, lhs, rhs);
		}

		public HqlAverage Average(HqlExpression expression)
		{
			return new HqlAverage(_factory, expression);
		}

		public HqlSum Sum(HqlExpression expression)
		{
			return new HqlSum(_factory, expression);
		}

		public HqlCase Case(HqlWhen[] whenClauses, HqlExpression ifFalse)
		{
			return new HqlCase(_factory, whenClauses, ifFalse);
		}

		public HqlMax Max(HqlExpression expression)
		{
			return new HqlMax(_factory, expression);
		}

		public HqlWhen When(HqlExpression predicate, HqlExpression ifTrue)
		{
			return new HqlWhen(_factory, predicate, ifTrue);
		}