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)); //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 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 NHibernateNodeTypeProvider() { var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry(); methodInfoRegistry.Register( new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) }, typeof(FetchOneExpressionNode)); methodInfoRegistry.Register( new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchLazyProperties <object>(null)) }, typeof(FetchLazyPropertiesExpressionNode)); 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; }
/// <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(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 }; }
/// <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; }
private static CompoundNodeTypeProvider CreateNodeTypeProvider() { var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes .Select(ti => ti.AsType()) .ToList(); var methodInfoBasedNodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes); methodInfoBasedNodeTypeRegistry .Register(AsNoTrackingExpressionNode.SupportedMethods, typeof(AsNoTrackingExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode)); var innerProviders = new INodeTypeProvider[] { methodInfoBasedNodeTypeRegistry, MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes) }; return(new CompoundNodeTypeProvider(innerProviders)); }
private static IServiceCollection AddQuery(this IServiceCollection serviceCollection) { return(serviceCollection .AddSingleton <IMemoryCache, MemoryCache>() .AddSingleton <ICompiledQueryCache, CompiledQueryCache>() .AddSingleton(_ => MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly()) .AddScoped <IAsyncQueryProvider, EntityQueryProvider>() .AddScoped <IQueryCompiler, QueryCompiler>() .AddScoped <IQueryAnnotationExtractor, QueryAnnotationExtractor>() .AddScoped <IQueryOptimizer, QueryOptimizer>() .AddScoped <IEntityTrackingInfoFactory, EntityTrackingInfoFactory>() .AddScoped <ISubQueryMemberPushDownExpressionVisitor, SubQueryMemberPushDownExpressionVisitor>() .AddScoped <ITaskBlockingExpressionVisitor, TaskBlockingExpressionVisitor>() .AddScoped <IEntityResultFindingExpressionVisitorFactory, EntityResultFindingExpressionVisitorFactory>() .AddScoped <IMemberAccessBindingExpressionVisitorFactory, MemberAccessBindingExpressionVisitorFactory>() .AddScoped <INavigationRewritingExpressionVisitorFactory, NavigationRewritingExpressionVisitorFactory>() .AddScoped <IOrderingExpressionVisitorFactory, OrderingExpressionVisitorFactory>() .AddScoped <IQuerySourceTracingExpressionVisitorFactory, QuerySourceTracingExpressionVisitorFactory>() .AddScoped <IRequiresMaterializationExpressionVisitorFactory, RequiresMaterializationExpressionVisitorFactory>() .AddScoped <CompiledQueryCacheKeyGenerator>() .AddScoped <ExpressionPrinter>() .AddScoped <ResultOperatorHandler>() .AddScoped <QueryCompilationContextFactory>() .AddScoped <ProjectionExpressionVisitorFactory>() .AddScoped(p => GetProviderServices(p).QueryContextFactory) .AddScoped(p => GetProviderServices(p).QueryCompilationContextFactory) .AddScoped(p => GetProviderServices(p).CompiledQueryCacheKeyGenerator) .AddScoped(p => GetProviderServices(p).EntityQueryModelVisitorFactory) .AddScoped(p => GetProviderServices(p).EntityQueryableExpressionVisitorFactory) .AddScoped(p => GetProviderServices(p).ExpressionPrinter) .AddScoped(p => GetProviderServices(p).ResultOperatorHandler) .AddScoped(p => GetProviderServices(p).ProjectionExpressionVisitorFactory)); }
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.SupportedMethods, typeof(SelectExpressionNode)); nodeTypeRegistry.Register(SelectManyExpressionNode.SupportedMethods, typeof(SelectManyExpressionNode)); nodeTypeRegistry.Register(WhereExpressionNode.SupportedMethods, 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 = TransparentIdentifierRemovingExpressionTreeVisitor.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)); }
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; }
static MethodInfo GetSupportedMethod <T>(Expression <Func <T> > methodCall) { Utils.CheckNotNull("methodCall", methodCall); var method = ReflectionUtility.GetMethod(methodCall); return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method, throwOnAmbiguousMatch: true)); }
public static MethodInfo GetSupportedMethod <T>(Expression <Func <T> > methodCall) { CheckNotNull("methodCall", methodCall); var method = GetMethod(methodCall); return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method, true)); }
public void Test_UsesPublicStaticField() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNode) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1)); Assert.That(registry.GetNodeType(typeof(TestExpressionNode).GetMethod("RegisteredMethod")), Is.SameAs(typeof(TestExpressionNode))); }
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. }
/// <summary> /// Gets the <see cref="MethodInfo"/> from a given <see cref="LambdaExpression"/> that has to wrap a <see cref="MethodCallExpression"/>. /// If the method is a generic method, its open generic method definition is returned. /// This method can be used for registration of the node type with an <see cref="MethodInfoBasedNodeTypeRegistry"/>. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="methodCall">The method call.</param> /// <returns></returns> protected static MethodInfo GetSupportedMethod <T> (Expression <Func <T> > methodCall) { ArgumentUtility.CheckNotNull("methodCall", methodCall); var method = ReflectionUtility.GetMethod(methodCall); return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method)); }
protected override Expression VisitMethodCallExpression(MethodCallExpression expression) { var method = expression.Method; Func <MethodCallExpression, IEnumerable> handler; if (method.IsSpecialName && method.Name == "get_Item" && expression.Arguments.Count == 1) { var arg = expression.Arguments[0]; if (arg.NodeType == ExpressionType.Constant && arg.Type == typeof(string)) { if (!(expression.Object is QuerySourceReferenceExpression || expression.Object is ParameterExpression)) { Append(expression.Object, "."); } Append((string)((ConstantExpression)arg).Value); return(expression); } } else if (new INodeTypeProvider[] { MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) }), MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) }) }.Any(provider => provider.IsRegistered(method))) { Expression source; Expression target; if (expression.Object != null) { source = expression.Object; target = expression.Arguments[0]; } else { source = expression.Arguments[0]; target = expression.Arguments[1]; } var constExpr = source as ConstantExpression; if (constExpr != null) { if (!(constExpr.Value is Array)) { source = Expression.Constant(((IEnumerable)constExpr.Value).Cast <object>().ToArray()); } Append("(", target, " in ", source, ")"); return(expression); } } if (!_methodMappings.TryGetValue(new MethodMappingKey(method.DeclaringType, method.Name), out handler)) { throw new NotSupportedException(string.Format("Method '{0}.{1}' not supported", method.DeclaringType, method.Name)); } Append(handler(expression)); return(expression); }
/// <summary> /// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered. Users can add inner providers to register their own expression node parsers. /// </summary> /// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered.</returns> public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { var innerProviders = new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new CompoundNodeTypeProvider(innerProviders)); }
private static CompoundNodeTypeProvider CreateNodeTypeProvider() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(RelinqQueryParserFactory).Assembly.GetTypes()); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Add(registry); return(nodeTypeProvider); }
public void Test_WithStaticFieldIgnoresStaticFieldFromBaseType() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNode) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1)); Assert.That( registry.GetNodeType(typeof(DerivedTestExpressionNode).GetMethod("MethodOnDerivedNode")), Is.SameAs(typeof(DerivedTestExpressionNode))); }
public MySQLQueryCompilationContextFactory( [NotNull] IModel model, [NotNull] ISensitiveDataLogger <MySQLQueryCompilationContextFactory> logger, [NotNullAttribute] IEntityQueryModelVisitorFactory entityQueryModelVisitorFactory, [NotNullAttribute] IRequiresMaterializationExpressionVisitorFactory requiresMaterializationExpressionVisitorFactory, [NotNullAttribute] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry, [NotNullAttribute] ICurrentDbContext currentContext) : base(model, logger, entityQueryModelVisitorFactory, requiresMaterializationExpressionVisitorFactory, methodInfoBasedNodeTypeRegistry, currentContext) { }
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { var types = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes(); return(new CompoundNodeTypeProvider( new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromTypes(types), MethodNameBasedNodeTypeRegistry.CreateFromTypes(types) })); }
/// <summary> /// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered. Users can add inner providers to register their own expression node parsers. /// </summary> /// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered.</returns> public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes.Select(ti => ti.AsType()).ToList(); var innerProviders = new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes), MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes) }; return(new CompoundNodeTypeProvider(innerProviders)); }
private static IQueryParser CreateQueryParser() { var nodeTypeProvider = new CompoundNodeTypeProvider(new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly() }); var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry)); return(new QueryParser(expressionTreeParser)); }
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 "ExtentName" expression node parser customNodeTypeRegistry.Register(ExtentNameExpressionNode.SupportedMethods, typeof(ExtentNameExpressionNode)); //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 Test() { MethodInfoBasedNodeTypeRegistry registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes( new[] { typeof(SelectExpressionNode), typeof(WhereExpressionNode) }); Assert.That( registry.RegisteredMethodInfoCount, Is.EqualTo(SelectExpressionNode.SupportedMethods.Length + WhereExpressionNode.SupportedMethods.Length)); AssertAllMethodsRegistered(registry, typeof(SelectExpressionNode)); AssertAllMethodsRegistered(registry, typeof(WhereExpressionNode)); }
public MartenQueryParser() { var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry); var expressionTreeParser = new ExpressionTreeParser(MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), processor); _parser = new QueryParser(expressionTreeParser); }
public void Test_NonGenericMethod_InClosedGenericType_HavingOverloadsDistinguishedByParameterTypeFromGenericClass_WithDoNotThrowOnAmbiguity_ReturnsNull() { var methodName = "NonGenericMethodOverloadedWithGenericParameterFromTypeAndSameParameterName"; var method1 = typeof(GenericClass <int, string>).GetMethods() .Single(m => m.Name == methodName && m.GetParameters()[0].ParameterType.Name == "Int32"); var method2 = typeof(GenericClass <int, string>).GetMethods() .Single(m => m.Name == methodName && m.GetParameters()[0].ParameterType.Name == "String"); Assert.That(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method1, throwOnAmbiguousMatch: false), Is.Null); Assert.That(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method2, throwOnAmbiguousMatch: false), Is.Null); }
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 the node type provider. /// </summary> private static INodeTypeProvider CreateNodeTypeProvider() { var methodInfoRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(); methodInfoRegistry.Register(RemoveAllExpressionNode.GetSupportedMethods(), typeof(RemoveAllExpressionNode)); return(new CompoundNodeTypeProvider(new INodeTypeProvider[] { methodInfoRegistry, MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() })); }
public LiteDBQueryCompilationContextFactory( IModel model, ISensitiveDataLogger <LiteDBQueryCompilationContextFactory> logger, IEntityQueryModelVisitorFactory entityQueryModelVisitorFactory, IRequiresMaterializationExpressionVisitorFactory requiresMaterializationExpressionVisitorFactory, MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry, ICurrentDbContext currentContext) : base(model, logger, entityQueryModelVisitorFactory, requiresMaterializationExpressionVisitorFactory, currentContext) { }
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 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; }