public static IQueryParser CreateFetchXmlQueryParser() { var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); RegisterCustomNodes(customNodeTypeRegistry); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry); var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); // Register custom expression transformers executed _after_ partial evaluation here (this should be the default): // transformerRegistry.Register (new MyExpressionTransformer()); var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry); // To register custom expression transformers executed _before_ partial evaluation, use this code: // var earlyTransformerRegistry = new ExpressionTransformerRegistry(); // earlyTransformerRegistry.Register (new MyEarlyExpressionTransformer()); // processor.InnerProcessors.Insert (0, new TransformingExpressionTreeProcessor (tranformationProvider)); // Add custom processors here (use Insert (0, ...) to add at the beginning): // processor.InnerProcessors.Add (new MyExpressionTreeProcessor()); var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor); var queryParser = new QueryParser(expressionTreeParser); return(queryParser); }
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 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 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 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 virtual void SetUp() { SourceNode = ExpressionNodeObjectMother.CreateMainSource(); ClauseGenerationContext = new ClauseGenerationContext(ExpressionTreeParser.CreateDefaultNodeTypeProvider()); QueryModel = SourceNode.Apply(null, ClauseGenerationContext); SourceClause = QueryModel.MainFromClause; SourceReference = (QuerySourceReferenceExpression)QueryModel.SelectClause.Selector; }
private static void CreateDefaultNodeTypeProvider() { Console.WriteLine("Creating NodeTypeProvider..."); var stopwatch = Stopwatch.StartNew(); ExpressionTreeParser.CreateDefaultNodeTypeProvider(); stopwatch.Stop(); Console.WriteLine("Time taken: {0}ms, reference time: ~30ms", stopwatch.ElapsedMilliseconds); }
private QueryParser CreateQueryParserWithCustimizedPartialEvaluation() { var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var evaluatableExpressionFilter = new QueryParserIntegrationTestsEvaluatableExpressionFilter(); var expressionTreeParser = new ExpressionTreeParser( ExpressionTreeParser.CreateDefaultNodeTypeProvider(), ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry, evaluatableExpressionFilter)); return(new QueryParser(expressionTreeParser)); }
private static CompoundNodeTypeProvider CreateNodeTypeProvider() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(RelinqQueryParserFactory).Assembly.GetTypes()); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Add(registry); return(nodeTypeProvider); }
/// <summary> /// Creates the parser. /// </summary> private static QueryParser CreateParser() { var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var proc = CreateCompoundProcessor(transformerRegistry); var parser = new ExpressionTreeParser(ExpressionTreeParser.CreateDefaultNodeTypeProvider(), proc); return(new QueryParser(parser)); }
public static CustomQueryParser CreateDefault() { var compoundNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); return (new CustomQueryParser( new ExpressionTreeParser( compoundNodeTypeProvider, ExpressionTreeParserHelper.CreateDefaultProcessor( ExpressionTransformerRegistry.CreateDefault())))); }
public void CreateDefaultNodeTypeProvider() { var result = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); Assert.That(result.InnerProviders.Count, Is.EqualTo(2)); Assert.That(result.InnerProviders[0], Is.TypeOf(typeof(MethodInfoBasedNodeTypeRegistry))); Assert.That(result.InnerProviders[1], Is.TypeOf(typeof(MethodNameBasedNodeTypeRegistry))); Assert.That(((MethodInfoBasedNodeTypeRegistry)result.InnerProviders[0]).RegisteredMethodInfoCount, Is.GreaterThan(0)); Assert.That(((MethodNameBasedNodeTypeRegistry)result.InnerProviders[1]).RegisteredNamesCount, Is.GreaterThan(0)); }
private static IQueryParser CreateQueryParser() { var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var expressionTreeParser = new ExpressionTreeParser( ExpressionTreeParser.CreateDefaultNodeTypeProvider(), 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); }
/// <summary> /// The create query parser. /// </summary> /// <returns> /// The <see cref="IQueryParser" />. /// </returns> public static IQueryParser CreateQueryParser() { CompoundNodeTypeProvider nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); var earlyTransformerRegistry = new ExpressionTransformerRegistry(); earlyTransformerRegistry.Register(new DateTimeEarlyExpressionTransformer()); CompoundExpressionTreeProcessor processor = CreateDefaultProcessor(earlyTransformerRegistry); var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor); var queryParser = new QueryParser(expressionTreeParser); return(queryParser); }
protected virtual ExpressionTreeParser CreateExpressionTreeParser(INodeTypeProvider customNodeTypeProvider) { ArgumentUtility.CheckNotNull("customNodeTypeProvider", customNodeTypeProvider); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Insert(0, customNodeTypeProvider); var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry); return(new ExpressionTreeParser(nodeTypeProvider, processor)); }
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)); }
/// <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)); }
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); }
static QueryParser CreateParser() { //Create Custom node registry var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); customNodeTypeRegistry.Register(FullTextSearchExpressionNode.SupportedMethods, typeof(FullTextSearchExpressionNode)); //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 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); }
public static IQueryParser CreateQueryParser() { //Create Custom node registry var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry(); //Register new clause type customNodeTypeRegistry.Register(FilterExpressionNode.SupportedMethods, 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(GroupByExpressionNode.GroupBySupportedMethods, typeof(GroupByExpressionNode)); customNodeTypeRegistry.Register(LimitExpressionNode.SupportedMethods, typeof(LimitExpressionNode)); customNodeTypeRegistry.Register(UpdateAndReturnExpressionNode.SupportedMethods, typeof(UpdateAndReturnExpressionNode)); customNodeTypeRegistry.Register(RemoveAndReturnExpressionNode.SupportedMethods, typeof(RemoveAndReturnExpressionNode)); customNodeTypeRegistry.Register(InsertAndReturnExpressionNode.SupportedMethods, typeof(InsertAndReturnExpressionNode)); customNodeTypeRegistry.Register(UpsertAndReturnExpressionNode.SupportedMethods, typeof(UpsertAndReturnExpressionNode)); customNodeTypeRegistry.Register(InModifyExpressionNode.SupportedMethods, typeof(InModifyExpressionNode)); customNodeTypeRegistry.Register(ReturnResultModifyExpressionNode.SupportedMethods, typeof(ReturnResultModifyExpressionNode)); customNodeTypeRegistry.Register(QueryableExtensions.OrderBySupportedMethods, typeof(ArangoDB.Client.Common.Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByExpressionNode)); customNodeTypeRegistry.Register(QueryableExtensions.OrderByDescendingSupportedMethods, typeof(ArangoDB.Client.Common.Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByDescendingExpressionNode)); customNodeTypeRegistry.Register(QueryableExtensions.SelectManySupportedMethods, typeof(ArangoDB.Client.Common.Remotion.Linq.Parsing.Structure.IntermediateModel.SelectManyExpressionNode)); //This creates all the default node types var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); //add custom node provider to the providers //nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry); nodeTypeProvider.InnerProviders.Insert(0, customNodeTypeRegistry); var transformerRegistry = ExpressionTransformerRegistry.CreateDefault(); var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry); var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor); var queryParser = new QueryParser(expressionTreeParser); return(queryParser); }
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); }
public MongoNodeTypeProvider() { defaultNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); }
public SDataQueryModelVisitor(INodeTypeProvider nodeTypeProvider = null, INamingScheme namingScheme = null) { _nodeTypeProvider = nodeTypeProvider ?? ExpressionTreeParser.CreateDefaultNodeTypeProvider(); _namingScheme = namingScheme ?? NamingScheme.Default; }
private static void AssertFetchPath <TInput, TOutput>(Expression <Func <TInput, TOutput> > expr, params string[] expected) { var actual = PropertyPathExtractionVisitor.ExtractPaths(expr.Body, ExpressionTreeParser.CreateDefaultNodeTypeProvider(), false, false, NamingScheme.Basic, "/"); Assert.That(actual, Is.EqualTo(expected)); }