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)); }