public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.GetMethodDefinition(() => default(IQueryable <object>).WithLock(LockMode.Read)),
ReflectHelper.GetMethodDefinition(() => default(IEnumerable <object>).WithLock(LockMode.Read))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//Register new clause type
customNodeTypeRegistry.Register(WhereMissingExpressionNode.SupportedMethods,
typeof(WhereMissingExpressionNode));
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void IntegrationTest_WithExpressionNodes()
{
var query = from a in ExpressionHelper.CreateQueryable <Cook> ()
from b in ExpressionHelper.CreateQueryable <Cook>()
where a.ID > 5
select a.ID;
var nodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
nodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
nodeTypeRegistry.Register(SelectManyExpressionNode.GetSupportedMethods(), typeof(SelectManyExpressionNode));
nodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode));
var selectNode = (SelectExpressionNode) new ExpressionTreeParser(nodeTypeRegistry, new NullExpressionTreeProcessor()).ParseTree(query.Expression);
var clauseGenerationContext = new ClauseGenerationContext(new MethodInfoBasedNodeTypeRegistry());
var selectManyNode = (SelectManyExpressionNode)selectNode.Source.Source;
var mainSourceExpressionNode = (MainSourceExpressionNode)selectManyNode.Source;
var queryModel = mainSourceExpressionNode.Apply(null, clauseGenerationContext);
var mainFromClause = queryModel.MainFromClause;
selectManyNode.Apply(queryModel, clauseGenerationContext); // only to add the clause to the mapping
var selectProjection = selectNode.GetResolvedSelector(clauseGenerationContext); // new ( a = IR (a), b = IR (b) ).a.ID
var result = TransparentIdentifierRemovingExpressionVisitor.ReplaceTransparentIdentifiers(selectProjection);
// IR(a).ID
Assert.That(result, Is.InstanceOf(typeof(MemberExpression)));
Expression innerExpression = ((MemberExpression)result).Expression;
Assert.That(innerExpression, Is.InstanceOf(typeof(QuerySourceReferenceExpression)));
Assert.That(((QuerySourceReferenceExpression)innerExpression).ReferencedQuerySource, Is.SameAs(mainFromClause));
}
/// <summary>
/// Registers methods to be used with the <see cref="INodeTypeProvider" />.
/// </summary>
/// <param name="methods">The methods to register.</param>
/// <param name="nodeType">The node type for these methods.</param>
public virtual void RegisterMethods(IEnumerable <MethodInfo> methods, Type nodeType)
{
Check.NotNull(methods, nameof(methods));
Check.NotNull(nodeType, nameof(nodeType));
_methodInfoBasedNodeTypeRegistry.Register(methods, nodeType);
}
private static void RegisterCustomNodes(MethodInfoBasedNodeTypeRegistry customNodeTypeRegistry)
{
// Register custom node parsers here:
customNodeTypeRegistry.Register(FilterTypeNodeProvider.SupportedMethods, typeof(FilterTypeNodeProvider));
customNodeTypeRegistry.Register(SelectAttributesNodeProviders.SupportedMethods, typeof(SelectAttributesNodeProviders));
// Alternatively, use the CreateFromTypes factory method.
// Use MethodNameBasedNodeTypeRegistry to register parsers by query operator name instead of MethodInfo.
}
public void Test_WithMethodInfo()
{
Assert.That(_registry.RegisteredMethodInfoCount, Is.EqualTo(0));
_registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
Assert.That(_registry.RegisteredMethodInfoCount, Is.EqualTo(2));
}
public ReplaceQueryCompiler(
IQueryContextFactory queryContextFactory,
ICompiledQueryCache compiledQueryCache,
ICompiledQueryCacheKeyGenerator compiledQueryCacheKeyGenerator,
IDatabase database,
ISensitiveDataLogger <QueryCompiler> logger,
MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry,
ICurrentDbContext currentContext) : base(queryContextFactory, compiledQueryCache, compiledQueryCacheKeyGenerator, database, logger, methodInfoBasedNodeTypeRegistry, currentContext)
{
methodInfoBasedNodeTypeRegistry.Register(ReplaceIncludeExpressionNode.SupportedMethods, typeof(ReplaceIncludeExpressionNode));
methodInfoBasedNodeTypeRegistry.Register(ReplaceThenIncludeExpressionNode.SupportedMethods, typeof(ReplaceThenIncludeExpressionNode));
}
/// <summary>
/// Creates a new <see cref="MethodInfoBasedNodeTypeRegistryFactory" /> that will use the given
/// <see cref="MethodInfoBasedNodeTypeRegistry" />
/// </summary>
/// <param name="methodInfoBasedNodeTypeRegistry">The registry to use./></param>
public MethodInfoBasedNodeTypeRegistryFactory(
[NotNull] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry)
{
Check.NotNull(methodInfoBasedNodeTypeRegistry, nameof(methodInfoBasedNodeTypeRegistry));
_methodInfoBasedNodeTypeRegistry = methodInfoBasedNodeTypeRegistry;
_methodInfoBasedNodeTypeRegistry
.Register(ToOrderedEnumerableExpressionNode.SupportedMethods, typeof(ToOrderedEnumerableExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(ToOrderedQueryableExpressionNode.SupportedMethods, typeof(ToOrderedQueryableExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(TagExpressionNode.SupportedMethods, typeof(TagExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(IgnoreQueryFiltersExpressionNode.SupportedMethods, typeof(IgnoreQueryFiltersExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(StringIncludeExpressionNode.SupportedMethods, typeof(StringIncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
_nodeTypeProviders = new INodeTypeProvider[] { _methodInfoBasedNodeTypeRegistry, _methodNameBasedNodeTypeRegistry };
}
public void SetUp()
{
_methodInfoBasedNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
_methodInfoBasedNodeTypeRegistry.Register(WhereExpressionNode.SupportedMethods, typeof(WhereExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(SelectExpressionNode.SupportedMethods, typeof(SelectExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(TakeExpressionNode.SupportedMethods, typeof(TakeExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(CountExpressionNode.SupportedMethods, typeof(CountExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(ContainsExpressionNode.SupportedMethods, typeof(ContainsExpressionNode));
_expressionTreeParser = new ExpressionTreeParser(_methodInfoBasedNodeTypeRegistry, new PartialEvaluatingExpressionTreeProcessor());
_intSource = new[] { 1, 2, 3 }.AsQueryable();
}
public void SetUp()
{
_methodInfoBasedNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
_methodInfoBasedNodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(JoinExpressionNode.GetSupportedMethods(), typeof(JoinExpressionNode));
_parser = new MethodCallExpressionParser(_methodInfoBasedNodeTypeRegistry);
_source = ExpressionNodeObjectMother.CreateMainSource();
}
public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//register the "UseIndex" expression node parser
customNodeTypeRegistry.Register(UseIndexExpressionNode.SupportedMethods,
typeof(UseIndexExpressionNode));
//register the "ToQueryRequest" expression node parser
customNodeTypeRegistry.Register(ToQueryRequestExpressionNode.SupportedMethods,
typeof(ToQueryRequestExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
//Register transformer to handle enum == and != comparisons
transformerRegistry.Register(new EnumComparisonExpressionTransformer());
//Register transformer to handle string comparisons
transformerRegistry.Register(new StringComparisonExpressionTransformer());
//Register transformer to handle DateTime comparisons
transformerRegistry.Register(new DateTimeComparisonExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void ParseTree_MethodCallExpression_WithInstanceMethod()
{
var instanceMethod = typeof(NonGenericFakeCollection).GetMethod("Contains"); // use non-generic class
_methodInfoBasedNodeTypeRegistry.Register(new[] { instanceMethod }, typeof(ContainsExpressionNode));
var querySourceExpression = Expression.Parameter(typeof(NonGenericFakeCollection), "querySource");
var itemExpression = Expression.Constant(null);
var expression = Expression.Call(querySourceExpression, instanceMethod, itemExpression);
var result = _expressionTreeParser.ParseTree(expression);
Assert.That(result, Is.InstanceOf(typeof(ContainsExpressionNode)));
Assert.That(((ContainsExpressionNode)result).Item, Is.SameAs(itemExpression));
var source = ((ContainsExpressionNode)result).Source;
Assert.That(source, Is.InstanceOf(typeof(MainSourceExpressionNode)));
Assert.That(((MainSourceExpressionNode)source).ParsedExpression, Is.SameAs(querySourceExpression));
}
public void VisitorUsesExpressionTreeVisitor_ToGetPotentialQueryOperator()
{
_methodInfoBasedNodeTypeRegistry.Register(new[] { typeof(QueryableFakeWithCount <>).GetMethod("get_Count") }, typeof(CountExpressionNode));
Expression subQuery = ExpressionHelper.MakeExpression(() => new QueryableFakeWithCount <int>().Count);
Expression surroundingExpression = Expression.Lambda(subQuery);
var newLambdaExpression =
(LambdaExpression)SubQueryFindingExpressionTreeVisitor.Process(surroundingExpression, _methodInfoBasedNodeTypeRegistry);
Assert.That(newLambdaExpression.Body, Is.InstanceOf(typeof(SubQueryExpression)));
}
/// <summary>
/// Registers methods to be used with the <see cref="INodeTypeProvider" />.
/// </summary>
/// <param name="methods">The methods to register.</param>
/// <param name="nodeType">The node type for these methods.</param>
public virtual void RegisterMethods(IEnumerable <MethodInfo> methods, Type nodeType)
{
Check.NotNull(methods, nameof(methods));
Check.NotNull(nodeType, nameof(nodeType));
lock (_syncLock)
{
_methodInfoBasedNodeTypeRegistry.Register(methods, nodeType);
_nodeTypeProviders = new INodeTypeProvider[] { _methodInfoBasedNodeTypeRegistry, _methodNameBasedNodeTypeRegistry };
}
}
private static INodeTypeProvider CreateNodeTypeProvider(
MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry)
{
methodInfoBasedNodeTypeRegistry
.Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
var innerProviders
= new INodeTypeProvider[]
{
methodInfoBasedNodeTypeRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
};
return(new CompoundNodeTypeProvider(innerProviders));
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
typeof(LinqExtensionMethods).GetMethod("Cacheable"),
typeof(LinqExtensionMethods).GetMethod("CacheMode"),
typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
}, typeof(CacheableExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.Fetch, default(IQueryable <object>), default(Expression <Func <object, object> >)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchLazyProperties, default(IQueryable <object>)) },
typeof(FetchLazyPropertiesExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchMany, default(IQueryable <object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetch, default(INhFetchRequest <object, object>), default(Expression <Func <object, object> >)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetchMany, default(INhFetchRequest <object, object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IQueryable <object>), default(LockMode)),
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IEnumerable <object>), default(LockMode))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
methodInfoRegistry.Register(new[] { LinqExtensionMethods.SetOptionsDefinition }, typeof(OptionsExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
typeof(LinqExtensionMethods).GetMethod("Cacheable"),
typeof(LinqExtensionMethods).GetMethod("CacheMode"),
typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
}, typeof(CacheableExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public void Test_WithMethodInfo()
{
_registry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
var type = _registry.GetNodeType(SelectExpressionNode.GetSupportedMethods().First());
Assert.That(type, Is.SameAs(typeof(SelectExpressionNode)));
}
private static QueryParser CreateParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
customNodeTypeRegistry.Register(FullTextSearchExpressionNode.SupportedMethods,
typeof(FullTextSearchExpressionNode));
customNodeTypeRegistry.Register(OnlyIfCompleteExpressionNode.SupportedMethods,
typeof(OnlyIfCompleteExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void VisitorUsesNodeTypeRegistry_ToParseAndAnalyzeSubQueries()
{
Expression subQuery = ExpressionHelper.MakeExpression(() => CustomSelect(ExpressionHelper.CreateQueryable <Cook>(), s => s));
Expression surroundingExpression = Expression.Lambda(subQuery);
// evaluate the ExpressionHelper.CreateQueryable<Cook> () method
var inputExpression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(surroundingExpression);
var emptyNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
emptyNodeTypeRegistry.Register(new[] { ((MethodCallExpression)subQuery).Method }, typeof(SelectExpressionNode));
var newLambdaExpression =
(LambdaExpression)SubQueryFindingExpressionTreeVisitor.Process(inputExpression, emptyNodeTypeRegistry);
Assert.That(newLambdaExpression.Body, Is.InstanceOf(typeof(SubQueryExpression)));
}
public void Test_WithAmbiguousClosedGenericMethodInClosedGenericType_ReturnsFalse()
{
var methodInOpenGenericTypes = typeof(GenericClass <,>).GetMethods()
.Where(mi => mi.Name == "NonGenericMethodOverloadedWithGenericParameterFromTypeAndSameParameterName")
.ToArray();
_registry.Register(methodInOpenGenericTypes, typeof(SelectExpressionNode));
var methodCallExpressionInClosedGenericType =
(MethodCallExpression)ExpressionHelper.MakeExpression <GenericClass <int, string>, bool> (
l => l.NonGenericMethodOverloadedWithGenericParameterFromTypeAndSameParameterName("string", 1.0));
var result = _registry.IsRegistered(methodCallExpressionInClosedGenericType.Method);
Assert.That(result, Is.False);
}
public void Parse_WithSubQuery_UsesNodeTypeRegistry()
{
var emptyNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
emptyNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
var parser = new MethodCallExpressionParser(emptyNodeTypeRegistry);
var expression = (MethodCallExpression)ExpressionHelper.MakeExpression <IQueryable <Cook>, IQueryable <int> > (
q => q.Select(s => s.Assistants.Count()));
var result = parser.Parse("t", _source, expression.Arguments.Skip(1), expression);
Assert.That(result, Is.InstanceOf(typeof(SelectExpressionNode)));
Assert.That(((SelectExpressionNode)result).Selector, Is.Not.TypeOf(typeof(SubQueryExpression)),
"The given nodeTypeRegistry does not know any query methods, so no SubQueryExpression is generated.");
}
public RelationalQueryCompilationContextFactory(
[NotNull] IModel model,
[NotNull] ISensitiveDataLogger <RelationalQueryCompilationContextFactory> logger,
[NotNull] IEntityQueryModelVisitorFactory entityQueryModelVisitorFactory,
[NotNull] IRequiresMaterializationExpressionVisitorFactory requiresMaterializationExpressionVisitorFactory,
[NotNull] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry,
[NotNull] DbContext context)
: base(
Check.NotNull(model, nameof(model)),
Check.NotNull(logger, nameof(logger)),
Check.NotNull(entityQueryModelVisitorFactory, nameof(entityQueryModelVisitorFactory)),
Check.NotNull(requiresMaterializationExpressionVisitorFactory, nameof(requiresMaterializationExpressionVisitorFactory)),
Check.NotNull(context, nameof(context)))
{
methodInfoBasedNodeTypeRegistry
.Register(FromSqlExpressionNode.SupportedMethods, typeof(FromSqlExpressionNode));
}
/// <summary>
/// Create the parser we want to use to parse the LINQ query. If we need to add
/// some operators or other custom things into the parser, this is where it is done.
/// See https://www.re-motion.org/jira/browse/RM-3724 for sample code.
/// </summary>
internal static IQueryParser CreateLINQToTTreeParser()
{
//
// Provider for our classes, and they also go into the whole pot of soup
//
var mreg = new MethodInfoBasedNodeTypeRegistry();
mreg.Register(UniqueCombinationsExpressionNode.SupportedMethods, typeof(UniqueCombinationsExpressionNode));
mreg.Register(PairWiseAllExpressionNode.SupportedMethods, typeof(PairWiseAllExpressionNode));
mreg.Register(AsQueriableExpressionNode.SupportedMethods, typeof(AsQueriableExpressionNode));
mreg.Register(AsCSVExpressionNode.SupportedMethods, typeof(AsCSVExpressionNode));
mreg.Register(AsTTreeExpressionNode.SupportedMethods, typeof(AsTTreeExpressionNode));
mreg.Register(ConcatExpressionNode.GetSupportedMethods(), typeof(ConcatExpressionNode));
mreg.Register(TakeSkipExpressionNode.SupportedMethods, typeof(TakeSkipExpressionNode));
var defaultNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
var newProvider = new CompoundNodeTypeProvider(new INodeTypeProvider[] { mreg, defaultNodeTypeProvider });
//
// All the various transformers we need...
//
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
transformerRegistry.Register(new PropertyExpressionTransformer());
transformerRegistry.Register(new EnumerableRangeExpressionTransformer());
transformerRegistry.Register(new CreateTupleExpressionTransformer());
transformerRegistry.Register <MethodCallExpression>(new ExpressionVariableInvokeExpressionTransformer(new ExpressionType[] { ExpressionType.Call }));
transformerRegistry.Register <InvocationExpression>(new ExpressionVariableInvokeExpressionTransformer(new ExpressionType[] { ExpressionType.Invoke }));
//
// Create the query provider
//
var expressionTreeParser = new ExpressionTreeParser(
newProvider,
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry));
return(new QueryParser(expressionTreeParser));
}
public RelinqNorthwindDataProvider()
{
_manager = new NorthwindConnectionManager();
_context = new NorthwindDataContext(_manager.GetConnectionString());
_resolver = new MappingResolver(_context.Mapping);
_retriever = new QueryResultRetriever(_manager, _resolver);
_resultOperatorHandlerRegistry = ResultOperatorHandlerRegistry.CreateDefault();
var methodBasedTransformerRegistry = MethodInfoBasedMethodCallTransformerRegistry.CreateDefault();
var nameBasedTransformerRegistry = NameBasedMethodCallTransformerRegistry.CreateDefault();
_methodCallTransformerProvider = new CompoundMethodCallTransformerProvider(methodBasedTransformerRegistry, nameBasedTransformerRegistry);
methodBasedTransformerRegistry.Register(
typeof(SqlMethods).GetMethod("Like", new[] { typeof(string), typeof(string) }),
new LikeMethodCallTransformer());
methodBasedTransformerRegistry.Register(DateDiffDayMethodCallTransformer.SupportedMethods, new DateDiffDayMethodCallTransformer());
foreach (var userDefinedFunction in _context.GetType().GetMethods().Where(mi => mi.IsDefined(typeof(FunctionAttribute), false)))
{
methodBasedTransformerRegistry.Register(userDefinedFunction, new UserDefinedFunctionTransformer());
}
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
customNodeTypeRegistry.Register(new[] { typeof(EntitySet <>).GetMethod("Contains") }, typeof(ContainsExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
_queryParser = new QueryParser(expressionTreeParser);
_executor = new QueryExecutor(_resolver, _retriever, _resultOperatorHandlerRegistry, _methodCallTransformerProvider, false);
}
private static INodeTypeProvider CreateDefaultNodeTypeProvider()
{
//Create Custom node registry
var nodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the "Nest" clause type
nodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
nodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
nodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//register the "UseIndex" expression node parser
nodeTypeRegistry.Register(UseIndexExpressionNode.SupportedMethods,
typeof(UseIndexExpressionNode));
//register the "UseHash" expression node parser
nodeTypeRegistry.Register(UseHashExpressionNode.SupportedMethods,
typeof(UseHashExpressionNode));
//register the "ExtentName" expression node parser
nodeTypeRegistry.Register(ExtentNameExpressionNode.SupportedMethods,
typeof(ExtentNameExpressionNode));
//register the "ToQueryRequest" expression node parser
nodeTypeRegistry.Register(ToQueryRequestExpressionNode.SupportedMethods,
typeof(ToQueryRequestExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(nodeTypeRegistry);
return(nodeTypeProvider);
}
protected virtual MethodInfoBasedNodeTypeRegistry CreateCustomNodeTypeProvider()
{
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
customNodeTypeRegistry.Register(
new[] { MemberInfoFromExpressionUtility.GetMethod((DomainObjectCollection obj) => obj.ContainsObject(null)) },
typeof(ContainsExpressionNode));
customNodeTypeRegistry.Register(
new[] { MemberInfoFromExpressionUtility.GetProperty((DomainObjectCollection obj) => obj.Count).GetGetMethod() },
typeof(CountExpressionNode));
customNodeTypeRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchOne") }, typeof(FetchOneExpressionNode));
customNodeTypeRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
customNodeTypeRegistry.Register(
new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchOne") }, typeof(ThenFetchOneExpressionNode));
customNodeTypeRegistry.Register(
new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
return(customNodeTypeRegistry);
}
private static INodeTypeProvider CreateDefaultNodeTypeProvider()
{
//Create Custom node registry
var nodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the nodes for special Couchbase clauses
nodeTypeRegistry.Register(NestExpressionNode.SupportedMethods, typeof(NestExpressionNode));
nodeTypeRegistry.Register(ExplainExpressionNode.GetSupportedMethods(), typeof(ExplainExpressionNode));
nodeTypeRegistry.Register(ExplainAsyncExpressionNode.GetSupportedMethods(), typeof(ExplainAsyncExpressionNode));
nodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods, typeof(UseKeysExpressionNode));
nodeTypeRegistry.Register(UseIndexExpressionNode.SupportedMethods, typeof(UseIndexExpressionNode));
nodeTypeRegistry.Register(UseHashExpressionNode.SupportedMethods, typeof(UseHashExpressionNode));
nodeTypeRegistry.Register(ScanConsistencyExpressionNode.GetSupportedMethods(), typeof(ScanConsistencyExpressionNode));
nodeTypeRegistry.Register(ConsistentWithExpressionNode.GetSupportedMethods(), typeof(ConsistentWithExpressionNode));
//register the various asynchronous expression nodes
nodeTypeRegistry.Register(FirstAsyncExpressionNode.GetSupportedMethods(), typeof(FirstAsyncExpressionNode));
nodeTypeRegistry.Register(SingleAsyncExpressionNode.GetSupportedMethods(), typeof(SingleAsyncExpressionNode));
nodeTypeRegistry.Register(AnyAsyncExpressionNode.GetSupportedMethods(), typeof(AnyAsyncExpressionNode));
nodeTypeRegistry.Register(AllAsyncExpressionNode.GetSupportedMethods(), typeof(AllAsyncExpressionNode));
nodeTypeRegistry.Register(CountAsyncExpressionNode.GetSupportedMethods(), typeof(CountAsyncExpressionNode));
nodeTypeRegistry.Register(LongCountAsyncExpressionNode.GetSupportedMethods(), typeof(LongCountAsyncExpressionNode));
nodeTypeRegistry.Register(SumAsyncExpressionNode.GetSupportedMethods(), typeof(SumAsyncExpressionNode));
nodeTypeRegistry.Register(AverageAsyncExpressionNode.GetSupportedMethods(), typeof(AverageAsyncExpressionNode));
nodeTypeRegistry.Register(MinAsyncExpressionNode.GetSupportedMethods(), typeof(MinAsyncExpressionNode));
nodeTypeRegistry.Register(MaxAsyncExpressionNode.GetSupportedMethods(), typeof(MaxAsyncExpressionNode));
// register ArrayGeneratingFunctionExpressionNode
nodeTypeRegistry.Register(StringSplitMethodCallTranslator.SupportedMethodsStatic, typeof(ArrayGeneratingFunctionExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(nodeTypeRegistry);
return(nodeTypeProvider);
}
private IQueryParser CreateQueryParser()
{
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//customNodeTypeRegistry.Register(new[] { typeof(EntitySet<>).GetMethod("Contains") }, typeof(ContainsExpressionNode));
customNodeTypeRegistry.Register(GroupByExpressionNode.GetSupportedMethods, typeof(GroupByExpressionNode));
customNodeTypeRegistry.Register(FilterExpressionNode.GetSupportedMethods, typeof(FilterExpressionNode));
customNodeTypeRegistry.Register(LetSelectExpressionNode.SupportedMethods, typeof(LetSelectExpressionNode));
customNodeTypeRegistry.Register(LetLambdaExpressionNode.SupportedMethods, typeof(LetLambdaExpressionNode));
customNodeTypeRegistry.Register(TakeExpressionNode.SupportedMethods, typeof(TakeExpressionNode));
customNodeTypeRegistry.Register(SkipExpressionNode.SupportedMethods, typeof(SkipExpressionNode));
customNodeTypeRegistry.Register(OrderBySupportedMethods, typeof(OrderByExpressionNode));
customNodeTypeRegistry.Register(OrderByDescendingSupportedMethods, typeof(OrderByDescendingExpressionNode));
customNodeTypeRegistry.Register(SelectManySupportedMethods, typeof(SelectManyExpressionNode));
customNodeTypeRegistry.Register(RemoveExpressionNode.SupportedMethods, typeof(RemoveExpressionNode));
customNodeTypeRegistry.Register(InsertExpressionNode.SupportedMethods, typeof(InsertExpressionNode));
customNodeTypeRegistry.Register(UpdateReplaceExpressionNode.SupportedMethods,
typeof(UpdateReplaceExpressionNode));
customNodeTypeRegistry.Register(UpsertExpressionNode.SupportedMethods, typeof(UpsertExpressionNode));
customNodeTypeRegistry.Register(SelectModificationExpressionNode.SupportedMethods,
typeof(SelectModificationExpressionNode));
customNodeTypeRegistry.Register(InModificationExpressionNode.SupportedMethods,
typeof(InModificationExpressionNode));
customNodeTypeRegistry.Register(IgnoreModificationSelectExpressionNode.SupportedMethods,
typeof(IgnoreModificationSelectExpressionNode));
customNodeTypeRegistry.Register(TraversalExpressionNode.SupportedMethods, typeof(TraversalExpressionNode));
customNodeTypeRegistry.Register(TraversalDepthExpressionNode.SupportedMethods,
typeof(TraversalDepthExpressionNode));
customNodeTypeRegistry.Register(TraversalDirectionExpressionNode.SupportedMethods,
typeof(TraversalDirectionExpressionNode));
customNodeTypeRegistry.Register(TraversalGraphNameExpressionNode.SupportedMethods,
typeof(TraversalGraphNameExpressionNode));
customNodeTypeRegistry.Register(TraversalEdgeExpressionNode.SupportedMethods,
typeof(TraversalEdgeExpressionNode));
customNodeTypeRegistry.Register(TraversalOptionsExpressionNode.SupportedMethods,
typeof(TraversalOptionsExpressionNode));
customNodeTypeRegistry.Register(ShortestPathExpressionNode.SupportedMethods,
typeof(ShortestPathExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Insert(0, customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
return(new QueryParser(expressionTreeParser));
}
