public NhLinqExpression(Expression expression, ISessionFactoryImplementor sessionFactory) { _expression = NhRelinqQueryParser.PreTransform(expression); // We want logging to be as close as possible to the original expression sent from the // application. But if we log before partial evaluation done in PreTransform, the log won't // include e.g. subquery expressions if those are defined by the application in a variable // referenced from the main query. LinqLogging.LogExpression("Expression (partially evaluated)", _expression); _constantToParameterMap = ExpressionParameterVisitor.Visit(ref _expression, sessionFactory); ParameterValuesByName = _constantToParameterMap.Values.ToDictionary(p => p.Name, p => System.Tuple.Create(p.Value, p.Type)); Key = ExpressionKeyVisitor.Visit(_expression, _constantToParameterMap); Type = _expression.Type; // Note - re-linq handles return types via the GetOutputDataInfo method, and allows for SingleOrDefault here for the ChoiceResultOperator... ReturnType = NhLinqExpressionReturnType.Scalar; if (typeof(IQueryable).IsAssignableFrom(Type)) { Type = Type.GetGenericArguments()[0]; ReturnType = NhLinqExpressionReturnType.Sequence; } }
public NhLinqExpression(Expression expression) { _expression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(expression); _expression = NameUnNamedParameters.Visit(_expression); _constantToParameterMap = ExpressionParameterVisitor.Visit(_expression); ParameterValuesByName = _constantToParameterMap.Values.ToDictionary(p => p.Name, p => new Tuple <object, IType> { First = p.Value, Second = p.Type }); Key = ExpressionKeyVisitor.Visit(_expression, _constantToParameterMap); Type = _expression.Type; // Note - re-linq handles return types via the GetOutputDataInfo method, and allows for SingleOrDefault here for the ChoiceResultOperator... ReturnType = NhLinqExpressionReturnType.Scalar; if (typeof(IQueryable).IsAssignableFrom(Type)) { Type = Type.GetGenericArguments()[0]; ReturnType = NhLinqExpressionReturnType.Sequence; } }
public static ExpressionKeysResult GetExpressionKeys <T, TKey>(Expression <Func <T, TKey> > getKey) { var vis = new ExpressionKeyVisitor(); vis.Visit(getKey); return(vis.Result); }
public void ConstantInWhereDoesNotCauseManyKeys() { var q1 = (from c in db.Customers where c.CustomerId == "ALFKI" select c); var q2 = (from c in db.Customers where c.CustomerId == "ANATR" select c); var parameters1 = ExpressionParameterVisitor.Visit(q1.Expression, Sfi); var k1 = ExpressionKeyVisitor.Visit(q1.Expression, parameters1); var parameters2 = ExpressionParameterVisitor.Visit(q2.Expression, Sfi); var k2 = ExpressionKeyVisitor.Visit(q2.Expression, parameters2); Assert.That(parameters1, Has.Count.GreaterThan(0), "parameters1"); Assert.That(parameters2, Has.Count.GreaterThan(0), "parameters2"); Assert.That(k2, Is.EqualTo(k1)); }
public void ConstantInWhereDoesNotCauseManyKeys() { var q1 = (from c in db.Customers where c.CustomerId == "ALFKI" select c); var q2 = (from c in db.Customers where c.CustomerId == "ANATR" select c); var preTransformParameters = new PreTransformationParameters(QueryMode.Select, Sfi); var preTransformResult = NhRelinqQueryParser.PreTransform(q1.Expression, preTransformParameters); var parameters1 = ExpressionParameterVisitor.Visit(preTransformResult); var k1 = ExpressionKeyVisitor.Visit(preTransformResult.Expression, parameters1, Sfi); var preTransformResult2 = NhRelinqQueryParser.PreTransform(q2.Expression, preTransformParameters); var parameters2 = ExpressionParameterVisitor.Visit(preTransformResult2); var k2 = ExpressionKeyVisitor.Visit(preTransformResult2.Expression, parameters2, Sfi); Assert.That(parameters1, Has.Count.GreaterThan(0), "parameters1"); Assert.That(parameters2, Has.Count.GreaterThan(0), "parameters2"); Assert.That(k2, Is.EqualTo(k1)); }
private static string GetCacheKey(Expression exp) { return(ExpressionKeyVisitor.Visit(exp, new Dictionary <ConstantExpression, NamedParameter>())); }