Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[5638] trunk/nhibernate/src/NHibernate/Linq/ DefaultQueryProvider.cs
|
From: <fab...@us...> - 2011-04-08 05:28:22
|
Revision: 5638
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5638&view=rev
Author: fabiomaulo
Date: 2011-04-08 05:28:16 +0000 (Fri, 08 Apr 2011)
Log Message:
-----------
Minor (reformatting)
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Linq/DefaultQueryProvider.cs
Modified: trunk/nhibernate/src/NHibernate/Linq/DefaultQueryProvider.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Linq/DefaultQueryProvider.cs 2011-04-08 05:24:48 UTC (rev 5637)
+++ trunk/nhibernate/src/NHibernate/Linq/DefaultQueryProvider.cs 2011-04-08 05:28:16 UTC (rev 5638)
@@ -1,4 +1,3 @@
-using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
@@ -19,159 +18,160 @@
_session = session;
}
+ #region IQueryProvider Members
+
public object Execute(Expression expression)
{
- IQuery query;
- NhLinqExpression nhQuery;
- NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query, out nhQuery);
-
+ IQuery query;
+ NhLinqExpression nhQuery;
+ NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query, out nhQuery);
+
return ExecuteQuery(nhLinqExpression, query, nhQuery);
}
- public object ExecuteFuture(Expression expression)
- {
- IQuery query;
- NhLinqExpression nhQuery;
- NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query, out nhQuery);
- return ExecuteFutureQuery(nhLinqExpression, query, nhQuery);
- }
+ public TResult Execute<TResult>(Expression expression)
+ {
+ return (TResult) Execute(expression);
+ }
- private NhLinqExpression PrepareQuery(Expression expression, out IQuery query, out NhLinqExpression nhQuery)
- {
- var nhLinqExpression = new NhLinqExpression(expression);
+ public IQueryable CreateQuery(Expression expression)
+ {
+ MethodInfo m = ReflectionHelper.GetMethodDefinition((DefaultQueryProvider p) => p.CreateQuery<object>(null)).MakeGenericMethod(expression.Type.GetGenericArguments()[0]);
- query = _session.CreateQuery(nhLinqExpression);
+ return (IQueryable) m.Invoke(this, new[] {expression});
+ }
- nhQuery = query.As<ExpressionQueryImpl>().QueryExpression.As<NhLinqExpression>();
+ public IQueryable<T> CreateQuery<T>(Expression expression)
+ {
+ return new NhQueryable<T>(this, expression);
+ }
- SetParameters(query, nhLinqExpression.ParameterValuesByName);
- SetResultTransformerAndAdditionalCriteria(query, nhQuery, nhLinqExpression.ParameterValuesByName);
- return nhLinqExpression;
- }
+ #endregion
- private object ExecuteFutureQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery)
- {
- MethodInfo method;
- if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence)
- {
- method = typeof (IQuery).GetMethod("Future").MakeGenericMethod(nhQuery.Type);
- }
- else
- {
- method = typeof(IQuery).GetMethod("FutureValue").MakeGenericMethod(nhQuery.Type);
- }
+ public object ExecuteFuture(Expression expression)
+ {
+ IQuery query;
+ NhLinqExpression nhQuery;
+ NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query, out nhQuery);
+ return ExecuteFutureQuery(nhLinqExpression, query, nhQuery);
+ }
- var result = method.Invoke(query, new object[0]);
+ private NhLinqExpression PrepareQuery(Expression expression, out IQuery query, out NhLinqExpression nhQuery)
+ {
+ var nhLinqExpression = new NhLinqExpression(expression);
+ query = _session.CreateQuery(nhLinqExpression);
-
- if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null)
- {
- ((IDelayedValue) result).ExecuteOnEval = nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer;
- }
+ nhQuery = query.As<ExpressionQueryImpl>().QueryExpression.As<NhLinqExpression>();
- return result;
+ SetParameters(query, nhLinqExpression.ParameterValuesByName);
+ SetResultTransformerAndAdditionalCriteria(query, nhQuery, nhLinqExpression.ParameterValuesByName);
+ return nhLinqExpression;
+ }
- }
+ private object ExecuteFutureQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery)
+ {
+ MethodInfo method;
+ if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence)
+ {
+ method = typeof (IQuery).GetMethod("Future").MakeGenericMethod(nhQuery.Type);
+ }
+ else
+ {
+ method = typeof (IQuery).GetMethod("FutureValue").MakeGenericMethod(nhQuery.Type);
+ }
- private object ExecuteQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery)
- {
- var results = query.List();
+ object result = method.Invoke(query, new object[0]);
- if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null)
- {
- try
- {
- return nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer.DynamicInvoke(results.AsQueryable());
- }
- catch (TargetInvocationException e)
- {
- throw e.InnerException;
- }
- }
- if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence)
- {
- return results.AsQueryable();
- }
+ if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null)
+ {
+ ((IDelayedValue) result).ExecuteOnEval = nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer;
+ }
- return results[0];
- }
-
- public TResult Execute<TResult>(Expression expression)
- {
- return (TResult) Execute(expression);
+ return result;
}
- public IQueryable CreateQuery(Expression expression)
+ private object ExecuteQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery)
{
- var m = ReflectionHelper.GetMethodDefinition((DefaultQueryProvider p) => p.CreateQuery<object>(null)).MakeGenericMethod(expression.Type.GetGenericArguments()[0]);
+ IList results = query.List();
- return (IQueryable) m.Invoke(this, new[] {expression});
- }
+ if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null)
+ {
+ try
+ {
+ return nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer.DynamicInvoke(results.AsQueryable());
+ }
+ catch (TargetInvocationException e)
+ {
+ throw e.InnerException;
+ }
+ }
- public IQueryable<T> CreateQuery<T>(Expression expression)
- {
- return new NhQueryable<T>(this, expression);
+ if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence)
+ {
+ return results.AsQueryable();
+ }
+
+ return results[0];
}
- static void SetParameters(IQuery query, IDictionary<string, Tuple<object, IType>> parameters)
+ private static void SetParameters(IQuery query, IDictionary<string, Tuple<object, IType>> parameters)
{
- foreach (var parameterName in query.NamedParameters)
+ foreach (string parameterName in query.NamedParameters)
{
- var param = parameters[parameterName];
+ Tuple<object, IType> param = parameters[parameterName];
- if (param.First == null)
- {
- if (typeof(ICollection).IsAssignableFrom(param.Second.ReturnedClass))
- {
- query.SetParameterList(parameterName, null, param.Second);
- }
- else
- {
- query.SetParameter(parameterName, null, param.Second);
- }
- }
- else
- {
- if (param.First is ICollection)
- {
- query.SetParameterList(parameterName, (ICollection) param.First);
- }
- else if (param.Second != null)
- {
- query.SetParameter(parameterName, param.First, param.Second);
- }
- else
- {
- query.SetParameter(parameterName, param.First);
- }
- }
+ if (param.First == null)
+ {
+ if (typeof (ICollection).IsAssignableFrom(param.Second.ReturnedClass))
+ {
+ query.SetParameterList(parameterName, null, param.Second);
+ }
+ else
+ {
+ query.SetParameter(parameterName, null, param.Second);
+ }
+ }
+ else
+ {
+ if (param.First is ICollection)
+ {
+ query.SetParameterList(parameterName, (ICollection) param.First);
+ }
+ else if (param.Second != null)
+ {
+ query.SetParameter(parameterName, param.First, param.Second);
+ }
+ else
+ {
+ query.SetParameter(parameterName, param.First);
+ }
+ }
}
}
- public void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters)
- {
- query.SetResultTransformer(nhExpression.ExpressionToHqlTranslationResults.ResultTransformer);
+ public void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters)
+ {
+ query.SetResultTransformer(nhExpression.ExpressionToHqlTranslationResults.ResultTransformer);
- foreach (var criteria in nhExpression.ExpressionToHqlTranslationResults.AdditionalCriteria)
- {
- criteria(query, parameters);
- }
- }
+ foreach (var criteria in nhExpression.ExpressionToHqlTranslationResults.AdditionalCriteria)
+ {
+ criteria(query, parameters);
+ }
+ }
}
- public class Tuple<T1, T2>
- {
- public T1 First { get; set; }
- public T2 Second { get; set; }
-
- }
+ public class Tuple<T1, T2>
+ {
+ public T1 First { get; set; }
+ public T2 Second { get; set; }
+ }
- public class Tuple<T1, T2, T3>
- {
- public T1 First { get; set; }
- public T2 Second { get; set; }
- public T3 Third { get; set; }
- }
+ public class Tuple<T1, T2, T3>
+ {
+ public T1 First { get; set; }
+ public T2 Second { get; set; }
+ public T3 Third { get; set; }
+ }
}
\ No newline at end of file
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
