public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
typeof(LinqExtensionMethods).GetMethod("Cacheable"),
typeof(LinqExtensionMethods).GetMethod("CacheMode"),
typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
}, typeof(CacheableExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchLazyProperties <object>(null)) },
typeof(FetchLazyPropertiesExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.GetMethodDefinition(() => default(IQueryable <object>).WithLock(LockMode.Read)),
ReflectHelper.GetMethodDefinition(() => default(IEnumerable <object>).WithLock(LockMode.Read))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
/// <summary>
/// Creates a new <see cref="MethodInfoBasedNodeTypeRegistryFactory" /> that will use the given
/// <see cref="MethodInfoBasedNodeTypeRegistry" />
/// </summary>
/// <param name="methodInfoBasedNodeTypeRegistry">The registry to use./></param>
public MethodInfoBasedNodeTypeRegistryFactory(
[NotNull] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry)
{
Check.NotNull(methodInfoBasedNodeTypeRegistry, nameof(methodInfoBasedNodeTypeRegistry));
_methodInfoBasedNodeTypeRegistry = methodInfoBasedNodeTypeRegistry;
_methodInfoBasedNodeTypeRegistry
.Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(TagExpressionNode.SupportedMethods, typeof(TagExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(IgnoreQueryFiltersExpressionNode.SupportedMethods, typeof(IgnoreQueryFiltersExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(StringIncludeExpressionNode.SupportedMethods, typeof(StringIncludeExpressionNode));
_methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
_nodeTypeProviders = new INodeTypeProvider[]
{
_methodInfoBasedNodeTypeRegistry,
_methodNameBasedNodeTypeRegistry
};
}
/// <summary>
/// Creates a new <see cref="MethodInfoBasedNodeTypeRegistryFactory" /> that will use the given
/// <see cref="MethodInfoBasedNodeTypeRegistry" />
/// </summary>
/// <param name="methodInfoBasedNodeTypeRegistry">The registry to use./></param>
public MethodInfoBasedNodeTypeRegistryFactory(
[NotNull] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry)
{
Check.NotNull(methodInfoBasedNodeTypeRegistry, nameof(methodInfoBasedNodeTypeRegistry));
_methodInfoBasedNodeTypeRegistry = methodInfoBasedNodeTypeRegistry;
}
private static CompoundNodeTypeProvider CreateNodeTypeProvider()
{
var searchedTypes
= typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes
.Select(ti => ti.AsType())
.ToList();
var methodInfoBasedNodeTypeRegistry
= MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes);
methodInfoBasedNodeTypeRegistry
.Register(AsNoTrackingExpressionNode.SupportedMethods, typeof(AsNoTrackingExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode));
methodInfoBasedNodeTypeRegistry
.Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode));
var innerProviders
= new INodeTypeProvider[]
{
methodInfoBasedNodeTypeRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return(new CompoundNodeTypeProvider(innerProviders));
}
private static IServiceCollection AddQuery(this IServiceCollection serviceCollection)
{
return(serviceCollection
.AddSingleton <IMemoryCache, MemoryCache>()
.AddSingleton <ICompiledQueryCache, CompiledQueryCache>()
.AddSingleton(_ => MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly())
.AddScoped <IAsyncQueryProvider, EntityQueryProvider>()
.AddScoped <IQueryCompiler, QueryCompiler>()
.AddScoped <IQueryAnnotationExtractor, QueryAnnotationExtractor>()
.AddScoped <IQueryOptimizer, QueryOptimizer>()
.AddScoped <IEntityTrackingInfoFactory, EntityTrackingInfoFactory>()
.AddScoped <ISubQueryMemberPushDownExpressionVisitor, SubQueryMemberPushDownExpressionVisitor>()
.AddScoped <ITaskBlockingExpressionVisitor, TaskBlockingExpressionVisitor>()
.AddScoped <IEntityResultFindingExpressionVisitorFactory, EntityResultFindingExpressionVisitorFactory>()
.AddScoped <IMemberAccessBindingExpressionVisitorFactory, MemberAccessBindingExpressionVisitorFactory>()
.AddScoped <INavigationRewritingExpressionVisitorFactory, NavigationRewritingExpressionVisitorFactory>()
.AddScoped <IOrderingExpressionVisitorFactory, OrderingExpressionVisitorFactory>()
.AddScoped <IQuerySourceTracingExpressionVisitorFactory, QuerySourceTracingExpressionVisitorFactory>()
.AddScoped <IRequiresMaterializationExpressionVisitorFactory, RequiresMaterializationExpressionVisitorFactory>()
.AddScoped <CompiledQueryCacheKeyGenerator>()
.AddScoped <ExpressionPrinter>()
.AddScoped <ResultOperatorHandler>()
.AddScoped <QueryCompilationContextFactory>()
.AddScoped <ProjectionExpressionVisitorFactory>()
.AddScoped(p => GetProviderServices(p).QueryContextFactory)
.AddScoped(p => GetProviderServices(p).QueryCompilationContextFactory)
.AddScoped(p => GetProviderServices(p).CompiledQueryCacheKeyGenerator)
.AddScoped(p => GetProviderServices(p).EntityQueryModelVisitorFactory)
.AddScoped(p => GetProviderServices(p).EntityQueryableExpressionVisitorFactory)
.AddScoped(p => GetProviderServices(p).ExpressionPrinter)
.AddScoped(p => GetProviderServices(p).ResultOperatorHandler)
.AddScoped(p => GetProviderServices(p).ProjectionExpressionVisitorFactory));
}
public void IntegrationTest_WithExpressionNodes()
{
var query = from a in ExpressionHelper.CreateQueryable <Cook> ()
from b in ExpressionHelper.CreateQueryable <Cook>()
where a.ID > 5
select a.ID;
var nodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
nodeTypeRegistry.Register(SelectExpressionNode.SupportedMethods, typeof(SelectExpressionNode));
nodeTypeRegistry.Register(SelectManyExpressionNode.SupportedMethods, typeof(SelectManyExpressionNode));
nodeTypeRegistry.Register(WhereExpressionNode.SupportedMethods, typeof(WhereExpressionNode));
var selectNode = (SelectExpressionNode) new ExpressionTreeParser(nodeTypeRegistry, new NullExpressionTreeProcessor()).ParseTree(query.Expression);
var clauseGenerationContext = new ClauseGenerationContext(new MethodInfoBasedNodeTypeRegistry());
var selectManyNode = (SelectManyExpressionNode)selectNode.Source.Source;
var mainSourceExpressionNode = (MainSourceExpressionNode)selectManyNode.Source;
var queryModel = mainSourceExpressionNode.Apply(null, clauseGenerationContext);
var mainFromClause = queryModel.MainFromClause;
selectManyNode.Apply(queryModel, clauseGenerationContext); // only to add the clause to the mapping
var selectProjection = selectNode.GetResolvedSelector(clauseGenerationContext); // new ( a = IR (a), b = IR (b) ).a.ID
var result = TransparentIdentifierRemovingExpressionTreeVisitor.ReplaceTransparentIdentifiers(selectProjection);
// IR(a).ID
Assert.That(result, Is.InstanceOf(typeof(MemberExpression)));
Expression innerExpression = ((MemberExpression)result).Expression;
Assert.That(innerExpression, Is.InstanceOf(typeof(QuerySourceReferenceExpression)));
Assert.That(((QuerySourceReferenceExpression)innerExpression).ReferencedQuerySource, Is.SameAs(mainFromClause));
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.Fetch, default(IQueryable <object>), default(Expression <Func <object, object> >)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchLazyProperties, default(IQueryable <object>)) },
typeof(FetchLazyPropertiesExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchMany, default(IQueryable <object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetch, default(INhFetchRequest <object, object>), default(Expression <Func <object, object> >)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetchMany, default(INhFetchRequest <object, object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IQueryable <object>), default(LockMode)),
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IEnumerable <object>), default(LockMode))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
static MethodInfo GetSupportedMethod <T>(Expression <Func <T> > methodCall)
{
Utils.CheckNotNull("methodCall", methodCall);
var method = ReflectionUtility.GetMethod(methodCall);
return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method, throwOnAmbiguousMatch: true));
}
public static MethodInfo GetSupportedMethod <T>(Expression <Func <T> > methodCall)
{
CheckNotNull("methodCall", methodCall);
var method = GetMethod(methodCall);
return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method, true));
}
public void Test_UsesPublicStaticField()
{
var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNode) });
Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1));
Assert.That(registry.GetNodeType(typeof(TestExpressionNode).GetMethod("RegisteredMethod")), Is.SameAs(typeof(TestExpressionNode)));
}
private static void RegisterCustomNodes(MethodInfoBasedNodeTypeRegistry customNodeTypeRegistry)
{
// Register custom node parsers here:
customNodeTypeRegistry.Register(FilterTypeNodeProvider.SupportedMethods, typeof(FilterTypeNodeProvider));
customNodeTypeRegistry.Register(SelectAttributesNodeProviders.SupportedMethods, typeof(SelectAttributesNodeProviders));
// Alternatively, use the CreateFromTypes factory method.
// Use MethodNameBasedNodeTypeRegistry to register parsers by query operator name instead of MethodInfo.
}
/// <summary>
/// Gets the <see cref="MethodInfo"/> from a given <see cref="LambdaExpression"/> that has to wrap a <see cref="MethodCallExpression"/>.
/// If the method is a generic method, its open generic method definition is returned.
/// This method can be used for registration of the node type with an <see cref="MethodInfoBasedNodeTypeRegistry"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="methodCall">The method call.</param>
/// <returns></returns>
protected static MethodInfo GetSupportedMethod <T> (Expression <Func <T> > methodCall)
{
ArgumentUtility.CheckNotNull("methodCall", methodCall);
var method = ReflectionUtility.GetMethod(methodCall);
return(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method));
}
protected override Expression VisitMethodCallExpression(MethodCallExpression expression)
{
var method = expression.Method;
Func <MethodCallExpression, IEnumerable> handler;
if (method.IsSpecialName && method.Name == "get_Item" && expression.Arguments.Count == 1)
{
var arg = expression.Arguments[0];
if (arg.NodeType == ExpressionType.Constant && arg.Type == typeof(string))
{
if (!(expression.Object is QuerySourceReferenceExpression ||
expression.Object is ParameterExpression))
{
Append(expression.Object, ".");
}
Append((string)((ConstantExpression)arg).Value);
return(expression);
}
}
else if (new INodeTypeProvider[]
{
MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) }),
MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) })
}.Any(provider => provider.IsRegistered(method)))
{
Expression source;
Expression target;
if (expression.Object != null)
{
source = expression.Object;
target = expression.Arguments[0];
}
else
{
source = expression.Arguments[0];
target = expression.Arguments[1];
}
var constExpr = source as ConstantExpression;
if (constExpr != null)
{
if (!(constExpr.Value is Array))
{
source = Expression.Constant(((IEnumerable)constExpr.Value).Cast <object>().ToArray());
}
Append("(", target, " in ", source, ")");
return(expression);
}
}
if (!_methodMappings.TryGetValue(new MethodMappingKey(method.DeclaringType, method.Name), out handler))
{
throw new NotSupportedException(string.Format("Method '{0}.{1}' not supported", method.DeclaringType, method.Name));
}
Append(handler(expression));
return(expression);
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(),
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
};
return(new CompoundNodeTypeProvider(innerProviders));
}
private static CompoundNodeTypeProvider CreateNodeTypeProvider()
{
var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(RelinqQueryParserFactory).Assembly.GetTypes());
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(registry);
return(nodeTypeProvider);
}
public void Test_WithStaticFieldIgnoresStaticFieldFromBaseType()
{
var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNode) });
Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1));
Assert.That(
registry.GetNodeType(typeof(DerivedTestExpressionNode).GetMethod("MethodOnDerivedNode")),
Is.SameAs(typeof(DerivedTestExpressionNode)));
}
public MySQLQueryCompilationContextFactory(
[NotNull] IModel model,
[NotNull] ISensitiveDataLogger <MySQLQueryCompilationContextFactory> logger,
[NotNullAttribute] IEntityQueryModelVisitorFactory entityQueryModelVisitorFactory,
[NotNullAttribute] IRequiresMaterializationExpressionVisitorFactory requiresMaterializationExpressionVisitorFactory,
[NotNullAttribute] MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry,
[NotNullAttribute] ICurrentDbContext currentContext) :
base(model, logger, entityQueryModelVisitorFactory, requiresMaterializationExpressionVisitorFactory, methodInfoBasedNodeTypeRegistry, currentContext)
{
}
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
var types = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes();
return(new CompoundNodeTypeProvider(
new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes(types),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(types)
}));
}
/// <summary>
/// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered. Users can add inner providers to register their own expression node parsers.
/// </summary>
/// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly
/// registered.</returns>
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider()
{
var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes.Select(ti => ti.AsType()).ToList();
var innerProviders = new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes),
MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes)
};
return(new CompoundNodeTypeProvider(innerProviders));
}
private static IQueryParser CreateQueryParser()
{
var nodeTypeProvider = new CompoundNodeTypeProvider(new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly()
});
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider,
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry));
return(new QueryParser(expressionTreeParser));
}
public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//register the "UseIndex" expression node parser
customNodeTypeRegistry.Register(UseIndexExpressionNode.SupportedMethods,
typeof(UseIndexExpressionNode));
//register the "ExtentName" expression node parser
customNodeTypeRegistry.Register(ExtentNameExpressionNode.SupportedMethods,
typeof(ExtentNameExpressionNode));
//register the "ToQueryRequest" expression node parser
customNodeTypeRegistry.Register(ToQueryRequestExpressionNode.SupportedMethods,
typeof(ToQueryRequestExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
//Register transformer to handle enum == and != comparisons
transformerRegistry.Register(new EnumComparisonExpressionTransformer());
//Register transformer to handle string comparisons
transformerRegistry.Register(new StringComparisonExpressionTransformer());
//Register transformer to handle DateTime comparisons
transformerRegistry.Register(new DateTimeComparisonExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void Test()
{
MethodInfoBasedNodeTypeRegistry registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(
new[] { typeof(SelectExpressionNode), typeof(WhereExpressionNode) });
Assert.That(
registry.RegisteredMethodInfoCount,
Is.EqualTo(SelectExpressionNode.SupportedMethods.Length + WhereExpressionNode.SupportedMethods.Length));
AssertAllMethodsRegistered(registry, typeof(SelectExpressionNode));
AssertAllMethodsRegistered(registry, typeof(WhereExpressionNode));
}
public MartenQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser =
new ExpressionTreeParser(MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), processor);
_parser = new QueryParser(expressionTreeParser);
}
public void Test_NonGenericMethod_InClosedGenericType_HavingOverloadsDistinguishedByParameterTypeFromGenericClass_WithDoNotThrowOnAmbiguity_ReturnsNull()
{
var methodName = "NonGenericMethodOverloadedWithGenericParameterFromTypeAndSameParameterName";
var method1 = typeof(GenericClass <int, string>).GetMethods()
.Single(m => m.Name == methodName && m.GetParameters()[0].ParameterType.Name == "Int32");
var method2 = typeof(GenericClass <int, string>).GetMethods()
.Single(m => m.Name == methodName && m.GetParameters()[0].ParameterType.Name == "String");
Assert.That(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method1, throwOnAmbiguousMatch: false), Is.Null);
Assert.That(MethodInfoBasedNodeTypeRegistry.GetRegisterableMethodDefinition(method2, throwOnAmbiguousMatch: false), Is.Null);
}
public ReplaceQueryCompiler(
IQueryContextFactory queryContextFactory,
ICompiledQueryCache compiledQueryCache,
ICompiledQueryCacheKeyGenerator compiledQueryCacheKeyGenerator,
IDatabase database,
ISensitiveDataLogger <QueryCompiler> logger,
MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry,
ICurrentDbContext currentContext) : base(queryContextFactory, compiledQueryCache, compiledQueryCacheKeyGenerator, database, logger, methodInfoBasedNodeTypeRegistry, currentContext)
{
methodInfoBasedNodeTypeRegistry.Register(ReplaceIncludeExpressionNode.SupportedMethods, typeof(ReplaceIncludeExpressionNode));
methodInfoBasedNodeTypeRegistry.Register(ReplaceThenIncludeExpressionNode.SupportedMethods, typeof(ReplaceThenIncludeExpressionNode));
}
/// <summary>
/// Creates the node type provider.
/// </summary>
private static INodeTypeProvider CreateNodeTypeProvider()
{
var methodInfoRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly();
methodInfoRegistry.Register(RemoveAllExpressionNode.GetSupportedMethods(),
typeof(RemoveAllExpressionNode));
return(new CompoundNodeTypeProvider(new INodeTypeProvider[]
{
methodInfoRegistry,
MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly()
}));
}
public LiteDBQueryCompilationContextFactory(
IModel model,
ISensitiveDataLogger <LiteDBQueryCompilationContextFactory> logger,
IEntityQueryModelVisitorFactory entityQueryModelVisitorFactory,
IRequiresMaterializationExpressionVisitorFactory requiresMaterializationExpressionVisitorFactory,
MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry,
ICurrentDbContext currentContext)
: base(model, logger,
entityQueryModelVisitorFactory,
requiresMaterializationExpressionVisitorFactory,
currentContext)
{
}
public void SetUp()
{
_methodInfoBasedNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
_methodInfoBasedNodeTypeRegistry.Register(WhereExpressionNode.GetSupportedMethods(), typeof(WhereExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(SelectExpressionNode.GetSupportedMethods(), typeof(SelectExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(TakeExpressionNode.GetSupportedMethods(), typeof(TakeExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(CountExpressionNode.GetSupportedMethods(), typeof(CountExpressionNode));
_methodInfoBasedNodeTypeRegistry.Register(JoinExpressionNode.GetSupportedMethods(), typeof(JoinExpressionNode));
_parser = new MethodCallExpressionParser(_methodInfoBasedNodeTypeRegistry);
_source = ExpressionNodeObjectMother.CreateMainSource();
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
typeof(LinqExtensionMethods).GetMethod("Cacheable"),
typeof(LinqExtensionMethods).GetMethod("CacheMode"),
typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
}, typeof(CacheableExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
