public void SetUp ()
{
_nodeTypeProviderMock1 = MockRepository.GenerateStrictMock<INodeTypeProvider>();
_nodeTypeProviderMock2 = MockRepository.GenerateStrictMock<INodeTypeProvider> ();
_compoundProvider = new CompoundNodeTypeProvider (new[] { _nodeTypeProviderMock1, _nodeTypeProviderMock2 });
_methodInfo = typeof (object).GetMethod ("ToString");
}
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;
}
private SubQueryFindingExpressionTreeVisitor(INodeTypeProvider nodeTypeProvider)
{
ArgumentUtility.CheckNotNull ("nodeTypeProvider", nodeTypeProvider);
_nodeTypeProvider = nodeTypeProvider;
_expressionTreeParser = new ExpressionTreeParser (_nodeTypeProvider, new NullExpressionTreeProcessor());
_queryParser = new QueryParser (_expressionTreeParser);
}
public static Expression Process(Expression expressionTree, INodeTypeProvider nodeTypeProvider)
{
ArgumentUtility.CheckNotNull ("expressionTree", expressionTree);
ArgumentUtility.CheckNotNull ("nodeTypeProvider", nodeTypeProvider);
var visitor = new SubQueryFindingExpressionTreeVisitor (nodeTypeProvider);
return visitor.VisitExpression (expressionTree);
}
public ClauseGenerationContext (
INodeTypeProvider nodeTypeProvider)
: this()
{
ArgumentUtility.CheckNotNull ("nodeTypeProvider", nodeTypeProvider);
_lookup = new Dictionary<IExpressionNode, object> ();
_nodeTypeProvider = nodeTypeProvider;
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider ()
{
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(),
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
};
return new CompoundNodeTypeProvider (innerProviders);
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider ()
{
var searchedTypes = typeof (MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes ();
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes (searchedTypes),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return new CompoundNodeTypeProvider (innerProviders);
}
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));
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
#if NETFX_CORE
var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes.Select(ti => ti.AsType()).ToList();
#else
var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.GetTypes().Select(ti => ti.AsType()).ToList();
#endif
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return(new CompoundNodeTypeProvider(innerProviders));
}
private static QueryModel CreateQueryModel(this DbContext dbContext, Expression expression)
{
INodeTypeProvider nodeTypeProvider = dbContext.GetService <MethodInfoBasedNodeTypeRegistry>();
var queryParser = new QueryParser(
new ExpressionTreeParser(nodeTypeProvider,
new CompoundExpressionTreeProcessor(
new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(new ApiCompilationFilter()),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
return(queryParser.GetParsedQuery(expression));
}
private static Func <QueryContext, TResult> CompileQueryCore <TResult>(
Expression query, INodeTypeProvider nodeTypeProvider, IDatabase database, ILogger logger, Type contextType)
{
var queryModel
= CreateQueryParser(nodeTypeProvider)
.GetParsedQuery(query);
var resultItemType
= (queryModel.GetOutputDataInfo()
as StreamedSequenceInfo)?.ResultItemType
?? typeof(TResult);
if (resultItemType == typeof(TResult))
{
var compiledQuery = database.CompileQuery <TResult>(queryModel);
return(qc =>
{
try
{
return compiledQuery(qc).First();
}
catch (Exception exception)
{
logger
.LogError(
CoreEventId.DatabaseError,
() => new DatabaseErrorLogState(contextType),
exception,
e => CoreStrings.LogExceptionDuringQueryIteration(Environment.NewLine, e));
throw;
}
});
}
try
{
return((Func <QueryContext, TResult>)CompileQueryMethod
.MakeGenericMethod(resultItemType)
.Invoke(database, new object[] { queryModel }));
}
catch (TargetInvocationException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
throw;
}
}
private Func <QueryContext, TResult> CompileQueryCore <TResult>(
Expression query,
INodeTypeProvider nodeTypeProvider,
IDatabase database,
IDiagnosticsLogger <DbLoggerCategory.Query> logger,
Type contextType)
{
var queryModel
= CreateQueryParser(nodeTypeProvider)
.GetParsedQuery(query);
var resultItemType
= (queryModel.GetOutputDataInfo()
as StreamedSequenceInfo)?.ResultItemType
?? typeof(TResult);
if (resultItemType == typeof(TResult))
{
var compiledQuery = database.CompileQuery <TResult>(queryModel);
return(qc =>
{
try
{
return compiledQuery(qc).First();
}
catch (Exception exception)
{
logger.QueryIterationFailed(contextType, exception);
throw;
}
});
}
try
{
return((Func <QueryContext, TResult>)CompileQueryMethod
.MakeGenericMethod(resultItemType)
.Invoke(database, new object[] { queryModel }));
}
catch (TargetInvocationException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
throw;
}
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public QueryModelGenerator(
[NotNull] INodeTypeProviderFactory nodeTypeProviderFactory,
[NotNull] ReLinq.IEvaluatableExpressionFilter reLinqEvaluatableExpressionFilter,
[NotNull] IEvaluatableExpressionFilter evaluatableExpressionFilter,
[NotNull] ICurrentDbContext currentDbContext)
{
Check.NotNull(nodeTypeProviderFactory, nameof(nodeTypeProviderFactory));
Check.NotNull(reLinqEvaluatableExpressionFilter, nameof(reLinqEvaluatableExpressionFilter));
Check.NotNull(evaluatableExpressionFilter, nameof(evaluatableExpressionFilter));
Check.NotNull(currentDbContext, nameof(currentDbContext));
_nodeTypeProvider = nodeTypeProviderFactory.Create();
_reLinqEvaluatableExpressionFilter = reLinqEvaluatableExpressionFilter;
_currentDbContext = currentDbContext;
EvaluatableExpressionFilter = evaluatableExpressionFilter;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Cacheable <object>(null)),
ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheMode <object>(null, CacheMode.Normal)),
ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheRegion <object>(null, null)),
}, typeof(CacheableExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Timeout <object>(null, 0)),
}, typeof(TimeoutExpressionNode)
);
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public static IList <string> ExtractPaths(Expression expression, INodeTypeProvider nodeTypeProvider, bool selectMode, bool includeProtocolProps, INamingScheme namingScheme, string separator)
{
var paths = ExtractPaths(expression, nodeTypeProvider, selectMode, includeProtocolProps, namingScheme);
if (selectMode)
{
var lookup = paths.ToLookup(path => path[0] == "*");
var dupes = lookup[true].SelectMany(wildcard => lookup[false].Select(path => new { wildcard, path }))
.Where(pair => pair.wildcard.Skip(1).SequenceEqual(pair.path.Skip(1)))
.Select(pair => pair.path)
.ToList();
paths = paths.Except(dupes).ToList();
}
return(paths
.Select(path => string.Join(separator, path.Reverse().ToArray()))
.Distinct()
.ToList());
}
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));
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
Type[] reflectedTypes;
try
{
reflectedTypes = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes();
}
catch (ReflectionTypeLoadException e)
{
reflectedTypes = e.Types;
}
var searchedTypes = reflectedTypes.Where(t => t != null).ToArray();
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes (searchedTypes),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return new CompoundNodeTypeProvider (innerProviders);
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
Type[] reflectedTypes;
try
{
reflectedTypes = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes();
}
catch (ReflectionTypeLoadException e)
{
reflectedTypes = e.Types;
}
var searchedTypes = reflectedTypes.Where(t => t != null).ToArray();
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return(new CompoundNodeTypeProvider(innerProviders));
}
private static CompoundNodeTypeProvider CreateNodeTypeProvider()
{
var searchedTypes
= typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes
.Select(ti => ti.AsType())
.ToList();
var methodInfoBasedNodeTypeRegistry
= MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes);
methodInfoBasedNodeTypeRegistry
.Register(AsNoTrackingExpressionNode.SupportedMethods, typeof(AsNoTrackingExpressionNode));
var innerProviders
= new INodeTypeProvider[]
{
methodInfoBasedNodeTypeRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return(new CompoundNodeTypeProvider(innerProviders));
}
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));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
private static ReadonlyNodeTypeProvider CreateNodeTypeProvider()
{
var methodInfoBasedNodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly();
methodInfoBasedNodeTypeRegistry
.Register(QueryAnnotationExpressionNode.SupportedMethods, typeof(QueryAnnotationExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
var innerProviders
= new INodeTypeProvider[]
{
methodInfoBasedNodeTypeRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
};
return(new ReadonlyNodeTypeProvider(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;
}
/// <summary>
/// Creates a <see cref="INodeTypeProvider" />.
/// </summary>
/// <returns>The <see cref="INodeTypeProvider" />.</returns>
public virtual INodeTypeProvider Create()
{
_methodInfoBasedNodeTypeRegistry
.Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(StringIncludeExpressionNode.SupportedMethods, typeof(StringIncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
var innerProviders
= new INodeTypeProvider[]
{
_methodInfoBasedNodeTypeRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
};
return(new CompoundNodeTypeProvider(innerProviders));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionTreeParser"/> class with a custom <see cref="INodeTypeProvider"/> and
/// <see cref="IExpressionTreeProcessor"/> implementation.
/// </summary>
/// <param name="nodeTypeProvider">The <see cref="INodeTypeProvider"/> to use when parsing <see cref="Expression"/> trees. Use
/// <see cref="CreateDefaultNodeTypeProvider"/> to create an instance of <see cref="CompoundNodeTypeProvider"/> that already includes all
/// default node types. (The <see cref="CompoundNodeTypeProvider"/> can be customized as needed by adding or removing
/// <see cref="CompoundNodeTypeProvider.InnerProviders"/>).</param>
/// <param name="processor">The <see cref="IExpressionTreeProcessor"/> to apply to <see cref="Expression"/> trees before parsing their nodes. Use
/// <see cref="CreateDefaultProcessor"/> to create an instance of <see cref="CompoundExpressionTreeProcessor"/> that already includes
/// the default steps. (The <see cref="CompoundExpressionTreeProcessor"/> can be customized as needed by adding or removing
/// <see cref="CompoundExpressionTreeProcessor.InnerProcessors"/>).</param>
public ExpressionTreeParser(INodeTypeProvider nodeTypeProvider, IExpressionTreeProcessor processor)
{
_nodeTypeProvider = nodeTypeProvider;
_processor = processor;
_methodCallExpressionParser = new MethodCallExpressionParser(_nodeTypeProvider);
}
private QueryParser CreateQueryParser(INodeTypeProvider nodeTypeProvider)
=> new QueryParser(
new ExpressionTreeParser(
nodeTypeProvider,
new CompoundExpressionTreeProcessor(
new IExpressionTreeProcessor[] { new PartialEvaluatingExpressionTreeProcessor(_reLinqEvaluatableExpressionFilter), new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault()) })));
public MethodCallExpressionParser (INodeTypeProvider nodeTypeProvider)
{
ArgumentUtility.CheckNotNull ("nodeTypeProvider", nodeTypeProvider);
_nodeTypeProvider = nodeTypeProvider;
}
static QueryParserHelper()
{
_nodeTypeProvider = CreateDefaultNodeTypeProvider();
_transformerRegistry = CreateDefaultTransformerRegistry();
_prePartialEvaluationTransformerRegistry = CreatePrePartialEvaluationDefaultTransformerRegistry();
}
static QueryParserHelper()
{
_nodeTypeProvider = CreateDefaultNodeTypeProvider();
_transformerRegistry = CreateDefaultTransformerRegistry();
}
/// <summary>
/// Initializes a new instance of the <see cref="ExpressionTreeParser"/> class with a custom <see cref="INodeTypeProvider"/> and
/// <see cref="IExpressionTreeProcessor"/> implementation.
/// </summary>
/// <param name="nodeTypeProvider">The <see cref="INodeTypeProvider"/> to use when parsing <see cref="Expression"/> trees. Use
/// <see cref="CreateDefaultNodeTypeProvider"/> to create an instance of <see cref="CompoundNodeTypeProvider"/> that already includes all
/// default node types. (The <see cref="CompoundNodeTypeProvider"/> can be customized as needed by adding or removing
/// <see cref="CompoundNodeTypeProvider.InnerProviders"/>).</param>
/// <param name="processor">The <see cref="IExpressionTreeProcessor"/> to apply to <see cref="Expression"/> trees before parsing their nodes. Use
/// <see cref="CreateDefaultProcessor"/> to create an instance of <see cref="CompoundExpressionTreeProcessor"/> that already includes
/// the default steps. (The <see cref="CompoundExpressionTreeProcessor"/> can be customized as needed by adding or removing
/// <see cref="CompoundExpressionTreeProcessor.InnerProcessors"/>).</param>
public ExpressionTreeParser (INodeTypeProvider nodeTypeProvider, IExpressionTreeProcessor processor)
{
ArgumentUtility.CheckNotNull ("nodeTypeProvider", nodeTypeProvider);
ArgumentUtility.CheckNotNull ("processor", processor);
_nodeTypeProvider = nodeTypeProvider;
_processor = processor;
_methodCallExpressionParser = new MethodCallExpressionParser (_nodeTypeProvider);
}
public static Expression Process(Expression expressionTree, INodeTypeProvider nodeTypeProvider)
{
var visitor = new SubQueryFindingExpressionTreeVisitor(nodeTypeProvider);
return(visitor.VisitExpression(expressionTree));
}
private SubQueryFindingExpressionTreeVisitor(INodeTypeProvider nodeTypeProvider)
{
_nodeTypeProvider = nodeTypeProvider;
_expressionTreeParser = new ExpressionTreeParser(_nodeTypeProvider, new NullExpressionTreeProcessor());
_queryParser = new QueryParser(_expressionTreeParser);
}
public MongoNodeTypeProvider()
{
defaultNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
}
public MethodCallExpressionParser(INodeTypeProvider nodeTypeProvider)
{
ArgumentUtility.CheckNotNull("nodeTypeProvider", nodeTypeProvider);
_nodeTypeProvider = nodeTypeProvider;
}
public NodeTypeProviderProxy(INodeTypeProvider inner)
{
_inner = inner;
}
public SDataQueryModelVisitor(INodeTypeProvider nodeTypeProvider = null, INamingScheme namingScheme = null)
{
_nodeTypeProvider = nodeTypeProvider ?? ExpressionTreeParser.CreateDefaultNodeTypeProvider();
_namingScheme = namingScheme ?? NamingScheme.Default;
}
public MethodCallExpressionParser(INodeTypeProvider nodeTypeProvider)
{
_nodeTypeProvider = nodeTypeProvider;
}
public SDataQueryModelVisitor(INodeTypeProvider nodeTypeProvider = null, INamingScheme namingScheme = null)
{
_nodeTypeProvider = nodeTypeProvider ?? ExpressionTreeParser.CreateDefaultNodeTypeProvider();
_namingScheme = namingScheme ?? NamingScheme.Default;
}
public ReadonlyNodeTypeProvider(INodeTypeProvider nodeTypeProvider)
{
_nodeTypeProvider = nodeTypeProvider;
}
