Subqueries.cs

using System;
using System.Linq.Expressions;

using NHibernate.Criterion.Lambda;
using NHibernate.Impl;

namespace NHibernate.Criterion
{
	/// <summary>
	/// Factory class for AbstractCriterion instances that represent 
	/// involving subqueries.
	/// <c>Expression</c>
	/// <c>Projection</c>
	/// <c>AbstractCriterion</c>
	/// </summary>
	public class Subqueries
	{
		public static AbstractCriterion Exists(DetachedCriteria dc)
		{
			return new ExistsSubqueryExpression("exists", dc);
		}

		public static AbstractCriterion NotExists(DetachedCriteria dc)
		{
			return new ExistsSubqueryExpression("not exists", dc);
		}

		public static AbstractCriterion PropertyEqAll(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "=", "all", dc);
		}

		public static AbstractCriterion PropertyIn(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "in", null, dc);
		}

		public static AbstractCriterion PropertyNotIn(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "not in", null, dc);
		}

		public static AbstractCriterion PropertyEq(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "=", null, dc);
		}

		public static AbstractCriterion PropertyNe(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<>", null, dc);
		}

		public static AbstractCriterion PropertyGt(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">", null, dc);
		}

		public static AbstractCriterion PropertyLt(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<", null, dc);
		}

		public static AbstractCriterion PropertyGe(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">=", null, dc);
		}

		public static AbstractCriterion PropertyLe(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<=", null, dc);
		}

		public static AbstractCriterion PropertyGtAll(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">", "all", dc);
		}

		public static AbstractCriterion PropertyLtAll(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<", "all", dc);
		}

		public static AbstractCriterion PropertyGeAll(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">=", "all", dc);
		}

		public static AbstractCriterion PropertyLeAll(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<=", "all", dc);
		}

		public static AbstractCriterion PropertyGtSome(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">", "some", dc);
		}

		public static AbstractCriterion PropertyLtSome(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<", "some", dc);
		}

		public static AbstractCriterion PropertyGeSome(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, ">=", "some", dc);
		}

		public static AbstractCriterion PropertyLeSome(String propertyName, DetachedCriteria dc)
		{
			return new PropertySubqueryExpression(propertyName, "<=", "some", dc);
		}

		public static AbstractCriterion EqAll(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "=", "all", dc);
		}

		public static AbstractCriterion In(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "in", null, dc);
		}

		public static AbstractCriterion NotIn(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "not in", null, dc);
		}

		public static AbstractCriterion Eq(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "=", null, dc);
		}

		public static AbstractCriterion Gt(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">", null, dc);
		}

		public static AbstractCriterion Lt(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<", null, dc);
		}

		public static AbstractCriterion Ge(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">=", null, dc);
		}

		public static AbstractCriterion Le(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<=", null, dc);
		}

		public static AbstractCriterion Ne(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<>", null, dc);
		}

		public static AbstractCriterion GtAll(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">", "all", dc);
		}

		public static AbstractCriterion LtAll(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<", "all", dc);
		}

		public static AbstractCriterion GeAll(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">=", "all", dc);
		}

		public static AbstractCriterion LeAll(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<=", "all", dc);
		}

		public static AbstractCriterion GtSome(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">", "some", dc);
		}

		public static AbstractCriterion LtSome(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<", "some", dc);
		}

		public static AbstractCriterion GeSome(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, ">=", "some", dc);
		}

		public static AbstractCriterion LeSome(Object value, DetachedCriteria dc)
		{
			return new SimpleSubqueryExpression(value, "<=", "some", dc);
		}

		public static AbstractCriterion Select(DetachedCriteria detachedCriteria)
		{
			return new SelectSubqueryExpression(detachedCriteria);
		}

		/// <summary>
		/// Create a ICriterion for the specified property subquery expression
		/// </summary>
		/// <typeparam name="T">generic type</typeparam>
		/// <param name="expression">lambda expression</param>
		/// <returns>returns LambdaSubqueryBuilder</returns>
		public static LambdaSubqueryBuilder WhereProperty<T>(Expression<Func<T, object>> expression)
		{
			string property = ExpressionProcessor.FindMemberExpression(expression.Body);
			return new LambdaSubqueryBuilder(property, null);
		}

		/// <summary>
		/// Create a ICriterion for the specified property subquery expression
		/// </summary>
		/// <param name="expression">lambda expression</param>
		/// <returns>returns LambdaSubqueryBuilder</returns>
		public static LambdaSubqueryBuilder WhereProperty(Expression<Func<object>> expression)
		{
			string property = ExpressionProcessor.FindMemberExpression(expression.Body);
			return new LambdaSubqueryBuilder(property, null);
		}

		/// <summary>
		/// Create a ICriterion for the specified value subquery expression
		/// </summary>
		/// <param name="value">value</param>
		/// <returns>returns LambdaSubqueryBuilder</returns>
		public static LambdaSubqueryBuilder WhereValue(object value)
		{
			return new LambdaSubqueryBuilder(null, value);
		}

		/// <summary>
		/// Create ICriterion for subquery expression using lambda syntax
		/// </summary>
		/// <typeparam name="T">type of property</typeparam>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion Where<T>(Expression<Func<T, bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Exact, expression);
			return criterion;
		}

		/// <summary>
		/// Create ICriterion for (exact) subquery expression using lambda syntax
		/// </summary>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion Where(Expression<Func<bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Exact, expression);
			return criterion;
		}

		/// <summary>
		/// Create ICriterion for (all) subquery expression using lambda syntax
		/// </summary>
		/// <typeparam name="T">type of property</typeparam>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion WhereAll<T>(Expression<Func<T, bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.All, expression);
			return criterion;
		}

		/// <summary>
		/// Create ICriterion for (all) subquery expression using lambda syntax
		/// </summary>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion WhereAll(Expression<Func<bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.All, expression);
			return criterion;
		}

		/// <summary>
		/// Create ICriterion for (some) subquery expression using lambda syntax
		/// </summary>
		/// <typeparam name="T">type of property</typeparam>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion WhereSome<T>(Expression<Func<T, bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Some, expression);
			return criterion;
		}

		/// <summary>
		/// Create ICriterion for (some) subquery expression using lambda syntax
		/// </summary>
		/// <param name="expression">lambda expression</param>
		/// <returns>NHibernate.ICriterion.AbstractCriterion</returns>
		public static AbstractCriterion WhereSome(Expression<Func<bool>> expression)
		{
			AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Some, expression);
			return criterion;
		}

		/// <summary>
		/// Add an Exists subquery criterion
		/// </summary>
		public static AbstractCriterion WhereExists<U>(QueryOver<U> detachedQuery)
		{
			 return Subqueries.Exists(detachedQuery.DetachedCriteria);
		}

		/// <summary>
		/// Add a NotExists subquery criterion
		/// </summary>
		public static AbstractCriterion WhereNotExists<U>(QueryOver<U> detachedQuery)
		{
			return Subqueries.NotExists(detachedQuery.DetachedCriteria);
		}

        public static AbstractCriterion IsNull(DetachedCriteria dc)
        {
            return new NullSubqueryExpression("IS NULL", dc);
        }

        public static AbstractCriterion IsNotNull(DetachedCriteria dc)
        {
            return new NullSubqueryExpression("IS NOT NULL", dc);
        }
	}
}