public object Execute(Expression expression) { var nhLinqExpression = new NhLinqExpression(expression); var query = _session.CreateQuery(nhLinqExpression); var nhQuery = query.As <ExpressionQueryImpl>().QueryExpression.As <NhLinqExpression>(); SetParameters(query, nhLinqExpression.ParameterValuesByName); SetResultTransformerAndAdditionalCriteria(query, nhQuery, nhLinqExpression.ParameterValuesByName); var results = query.List(); 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()); } return(results[0]); }
public virtual object Execute(Expression expression) { IQuery query; NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query); return(ExecuteQuery(nhLinqExpression, query, nhLinqExpression)); }
internal void CopyExpressionTranslation(NhLinqExpression other) { ExpressionToHqlTranslationResults = other.ExpressionToHqlTranslationResults; ParameterDescriptors = other.ParameterDescriptors; // Type could have been overridden by translation. Type = other.Type; }
public object ExecuteFuture(Expression expression) { IQuery query; NhLinqExpression nhQuery; NhLinqExpression nhLinqExpression = PrepareQuery(expression, out query, out nhQuery); return(ExecuteFutureQuery(nhLinqExpression, query, nhQuery)); }
protected virtual object ExecuteQuery(NhLinqExpression nhLinqExpression, IQuery query) { // For avoiding breaking derived classes, call the obsolete method until it is dropped. #pragma warning disable 618 return(ExecuteQuery(nhLinqExpression, query, nhLinqExpression)); #pragma warning restore 618 }
private static void SetupFutureResult(NhLinqExpression nhQuery, IDelayedValue result) { if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer == null) { return; } result.ExecuteOnEval = nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer; }
public virtual 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); } }
protected virtual NhLinqExpression PrepareQuery(Expression expression, out IQuery query) { var nhLinqExpression = new NhLinqExpression(expression, Session.Factory); query = Session.CreateQuery(nhLinqExpression); SetParameters(query, nhLinqExpression.ParameterValuesByName); SetResultTransformerAndAdditionalCriteria(query, nhLinqExpression, nhLinqExpression.ParameterValuesByName); return(nhLinqExpression); }
protected NhLinqExpression PrepareQuery(Expression expression, out IQuery query, out NhLinqExpression nhQuery) { var nhLinqExpression = new NhLinqExpression(expression); query = Session.CreateQuery(nhLinqExpression); nhQuery = query.As <ExpressionQueryImpl>().QueryExpression.As <NhLinqExpression>(); SetParameters(query, nhLinqExpression.ParameterValuesByName); SetResultTransformerAndAdditionalCriteria(query, nhQuery, nhLinqExpression.ParameterValuesByName); return(nhLinqExpression); }
protected virtual Task <object> ExecuteQueryAsync(NhLinqExpression nhLinqExpression, IQuery query, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(Task.FromCanceled <object>(cancellationToken)); } // For avoiding breaking derived classes, call the obsolete method until it is dropped. #pragma warning disable 618 return(ExecuteQueryAsync(nhLinqExpression, query, nhLinqExpression, cancellationToken)); #pragma warning restore 618 }
protected virtual object ExecuteFutureQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery) { var method = (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence ? Future : FutureValue) .MakeGenericMethod(nhQuery.Type); object result = method.Invoke(query, new object[0]); if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null) { ((IDelayedValue)result).ExecuteOnEval = nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer; } return(result); }
public void Different_Where_Clauses_Return_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable<Customer>>> london = () => from c in db.Customers where c.Address.City == "London" select c; Expression<Func<IEnumerable<Customer>>> company = () => from c in db.Customers where c.CompanyName == "Acme" select c; var nhLondon = new NhLinqExpression(london.Body, sessions); var nhNewYork = new NhLinqExpression(company.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
public void Identical_Expressions_Return_The_Same_Key() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable<Customer>>> london1 = () => from c in db.Customers where c.Address.City == "London" select c; Expression<Func<IEnumerable<Customer>>> london2 = () => from c in db.Customers where c.Address.City == "London" select c; var nhLondon1 = new NhLinqExpression(london1.Body, sessions); var nhLondon2 = new NhLinqExpression(london2.Body, sessions); Assert.AreEqual(nhLondon1.Key, nhLondon2.Key); } }
protected virtual NhLinqExpression PrepareQuery(Expression expression, out IQuery query) { var nhLinqExpression = new NhLinqExpression(expression, Session.Factory); if (Collection == null) { query = Session.CreateQuery(nhLinqExpression); } else { query = Session.CreateFilter(Collection, nhLinqExpression); } SetParameters(query, nhLinqExpression.ParameterValuesByName); ApplyOptions(query); SetResultTransformerAndAdditionalCriteria(query, nhLinqExpression, nhLinqExpression.ParameterValuesByName); return(nhLinqExpression); }
public void Expressions_Differing_Only_By_Constants_Return_The_Same_Key() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable<Customer>>> london = () => from c in db.Customers where c.Address.City == "London" select c; Expression<Func<IEnumerable<Customer>>> newYork = () => from c in db.Customers where c.Address.City == "New York" select c; var nhLondon = new NhLinqExpression(london.Body, sessions); var nhNewYork = new NhLinqExpression(newYork.Body, sessions); Assert.AreEqual(nhLondon.Key, nhNewYork.Key); Assert.AreEqual(1, nhLondon.ParameterValuesByName.Count); Assert.AreEqual(1, nhNewYork.ParameterValuesByName.Count); Assert.AreEqual("London", nhLondon.ParameterValuesByName.First().Value.Item1); Assert.AreEqual("New York", nhNewYork.ParameterValuesByName.First().Value.Item1); } }
protected virtual object ExecuteQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery) { IList results = query.List(); 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()); } return(results[0]); }
public void CanSpecifyParameterTypeInfo() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable<Customer>>> london = () => from c in db.Customers where c.Address.City == "London".MappedAs(NHibernateUtil.StringClob) select c; Expression<Func<IEnumerable<Customer>>> newYork = () => from c in db.Customers where c.Address.City == "New York".MappedAs(NHibernateUtil.AnsiString) select c; var nhLondon = new NhLinqExpression(london.Body, sessions); var nhNewYork = new NhLinqExpression(newYork.Body, sessions); var londonParameter = nhLondon.ParameterValuesByName.Single().Value; Assert.That(londonParameter.Item1, Is.EqualTo("London")); Assert.That(londonParameter.Item2, Is.EqualTo(NHibernateUtil.StringClob)); var newYorkParameter = nhNewYork.ParameterValuesByName.Single().Value; Assert.That(newYorkParameter.Item1, Is.EqualTo("New York")); Assert.That(newYorkParameter.Item2, Is.EqualTo(NHibernateUtil.AnsiString)); } }
protected virtual async Task <object> ExecuteQueryAsync(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); IList results = await(query.ListAsync(cancellationToken)).ConfigureAwait(false); if (nhQuery.ExpressionToHqlTranslationResults?.PostExecuteTransformer != null) { try { return(nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer.DynamicInvoke(results.AsQueryable())); } catch (TargetInvocationException e) { throw ReflectHelper.UnwrapTargetInvocationException(e); } } if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence) { return(results.AsQueryable()); } return(results[0]); }
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); } var result = method.Invoke(query, new object[0]); if (nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer != null) { ((IDelayedValue)result).ExecuteOnEval = nhQuery.ExpressionToHqlTranslationResults.PostExecuteTransformer; } return(result); }
public void DifferentKeyInDynamicComponentDictionaryReturnsDifferentExpressionKeys() { using (var session = OpenSession()) { // ReSharper disable AccessToDisposedClosure Ok since the expressions aren't actually used after the using block. Expression<Func<IEnumerable>> key1 = () => (from a in session.Query<Product>() where (string) a.Details.Properties["Name"] == "val" select a); Expression<Func<IEnumerable>> key2 = () => (from a in session.Query<Product>() where (string) a.Details.Properties["Description"] == "val" select a); // ReSharper restore AccessToDisposedClosure var nhKey1 = new NhLinqExpression(key1.Body, sessions); var nhKey2 = new NhLinqExpression(key2.Body, sessions); Assert.AreNotEqual(nhKey1.Key, nhKey2.Key); } }
internal void CopyExpressionTranslation(NhLinqExpression other) { ExpressionToHqlTranslationResults = other.ExpressionToHqlTranslationResults; ParameterDescriptors = other.ParameterDescriptors; }
public void Different_Select_Types_Return_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable>> newCustomerId = () => from c in db.Customers select new { c.CustomerId }; Expression<Func<IEnumerable>> customerId = () => from c in db.Customers select c.CustomerId; var nhLondon = new NhLinqExpression(newCustomerId.Body, sessions); var nhNewYork = new NhLinqExpression(customerId.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
public void Different_Select_Properties_Return_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable<string>>> customerId = () => from c in db.Customers select c.CustomerId; Expression<Func<IEnumerable<string>>> title = () => from c in db.Customers select c.ContactTitle; var nhLondon = new NhLinqExpression(customerId.Body, sessions); var nhNewYork = new NhLinqExpression(title.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
internal void CopyExpressionTranslation(NhLinqExpression other) { ExpressionToHqlTranslationResults = other.ExpressionToHqlTranslationResults; ParameterDescriptors = other.ParameterDescriptors; }
internal NhLinqExpression Clone() { var clone = new NhLinqExpression(); clone.CopyExpressionTranslation(this); return clone; }
public void Different_Null_Returns_Different_Keys() { using (var session = OpenSession()) { string nullVariable = null; string notNullVariable = "Hello"; Expression<Func<IEnumerable>> null1 = () => (from a in session.Query<Animal>() where a.Description == null select a); Expression<Func<IEnumerable>> null2 = () => (from a in session.Query<Animal>() where a.Description == nullVariable select a); Expression<Func<IEnumerable>> notNull = () => (from a in session.Query<Animal>() where a.Description == notNullVariable select a); var nhNull1 = new NhLinqExpression(null1.Body, sessions); var nhNull2 = new NhLinqExpression(null2.Body, sessions); var nhNotNull = new NhLinqExpression(notNull.Body, sessions); Assert.AreNotEqual(nhNull1.Key, nhNotNull.Key); Assert.AreNotEqual(nhNull2.Key, nhNotNull.Key); } }
public void Different_OfType_Returns_Different_Keys() { using (var session = OpenSession()) { Expression<Func<IEnumerable>> ofType1 = () => (from a in session.Query<Animal>().OfType<Cat>() where a.Pregnant select a.Id); Expression<Func<IEnumerable>> ofType2 = () => (from a in session.Query<Animal>().OfType<Dog>() where a.Pregnant select a.Id); var nhOfType1 = new NhLinqExpression(ofType1.Body, sessions); var nhOfType2 = new NhLinqExpression(ofType2.Body, sessions); Assert.AreNotEqual(nhOfType1.Key, nhOfType2.Key); } }
public virtual object Execute(Expression expression) { NhLinqExpression nhLinqExpression = PrepareQuery(expression, out var query); return(ExecuteQuery(nhLinqExpression, query)); }
public void Different_Conditionals_Return_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable>> newCustomerId = () => from c in db.Customers select new { Desc = c.CustomerId == "1" ? "First" : "Not First" }; Expression<Func<IEnumerable>> customerId = () => from c in db.Customers select new { Desc = c.CustomerId != "1" ? "First" : "Not First" }; var nhLondon = new NhLinqExpression(newCustomerId.Body, sessions); var nhNewYork = new NhLinqExpression(customerId.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
public void Different_Select_Member_Initialisation_Returns_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable>> newCustomerId = () => from c in db.Customers select new { Id = c.CustomerId, Title = c.ContactTitle }; Expression<Func<IEnumerable>> customerId = () => from c in db.Customers select new { Title = c.ContactTitle, Id = c.CustomerId }; var nhLondon = new NhLinqExpression(newCustomerId.Body, sessions); var nhNewYork = new NhLinqExpression(customerId.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
public String ToSql(System.Linq.IQueryable queryable) { var sessionProperty = typeof(DefaultQueryProvider).GetProperty("Session", BindingFlags.NonPublic | BindingFlags.Instance); var session = sessionProperty.GetValue(queryable.Provider, null) as ISession; var sessionImpl = session.GetSessionImplementation(); var factory = sessionImpl.Factory; var nhLinqExpression = new NhLinqExpression(queryable.Expression, factory); var translatorFactory = new ASTQueryTranslatorFactory(); var translator = translatorFactory.CreateQueryTranslators(nhLinqExpression, null, false, sessionImpl.EnabledFilters, factory).First(); //in case you want the parameters as well //var parameters = nhLinqExpression.ParameterValuesByName.ToDictionary(x => x.Key, x => x.Value.Item1); return translator.SQLString; }
public void Different_Key_In_DynamicComponentDictionary_Returns_Different_Keys() { using (var session = OpenSession()) { Expression<Func<IEnumerable>> key1 = () => (from a in session.Query<Product>() where a.Properties["Name"] == "val" select a); Expression<Func<IEnumerable>> key2 = () => (from a in session.Query<Product>() where a.Properties["Description"] == "val" select a); var nhKey1 = new NhLinqExpression(key1.Body, session.SessionFactory); var nhKey2 = new NhLinqExpression(key2.Body, session.SessionFactory); Assert.AreNotEqual(nhKey1.Key, nhKey2.Key); } }
public void Different_Unary_Operation_Returns_Different_Keys() { using (var s = OpenSession()) { var db = new Northwind(s); Expression<Func<IEnumerable>> newCustomerId = () => from c in db.Customers where c.CustomerId == "1" select c; Expression<Func<IEnumerable>> customerId = () => from c in db.Customers where !(c.CustomerId == "1") select c; var nhLondon = new NhLinqExpression(newCustomerId.Body, sessions); var nhNewYork = new NhLinqExpression(customerId.Body, sessions); Assert.AreNotEqual(nhLondon.Key, nhNewYork.Key); } }
public IQuery GetPreparedQuery(Expression expression, out NhLinqExpression nhExpression) { nhExpression = PrepareQuery(expression, out var query); return(query); }