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