static NhRelinqQueryParser()
{
var preTransformerRegistry = new ExpressionTransformerRegistry();
// NH-3247: must remove .Net compiler char to int conversion before
// parameterization occurs.
preTransformerRegistry.Register(new RemoveCharToIntConversion());
PreProcessor = new TransformingExpressionTreeProcessor(preTransformerRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
transformerRegistry.Register(new RemoveRedundantCast());
transformerRegistry.Register(new SimplifyCompareTransformer());
// If needing a compound processor for adding other processing, do not use
// ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry), it would
// cause NH-3961 again by including a PartialEvaluatingExpressionTreeProcessor.
// Directly instantiate a CompoundExpressionTreeProcessor instead.
var processor = new TransformingExpressionTreeProcessor(transformerRegistry);
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
QueryParser = new QueryParser(expressionTreeParser);
}
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 static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//Register new clause type
customNodeTypeRegistry.Register(WhereMissingExpressionNode.SupportedMethods,
typeof(WhereMissingExpressionNode));
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void Initialization_Default()
{
var expressionTreeParser = _queryParser.ExpressionTreeParser;
Assert.That(expressionTreeParser.NodeTypeProvider, Is.TypeOf(typeof(CompoundNodeTypeProvider)));
var nodeTypeProviders = ((CompoundNodeTypeProvider)expressionTreeParser.NodeTypeProvider).InnerProviders;
Assert.That(nodeTypeProviders[0], Is.TypeOf(typeof(MethodInfoBasedNodeTypeRegistry)));
Assert.That(nodeTypeProviders[1], Is.TypeOf(typeof(MethodNameBasedNodeTypeRegistry)));
Assert.That(expressionTreeParser.Processor, Is.TypeOf(typeof(CompoundExpressionTreeProcessor)));
var processingSteps = ((CompoundExpressionTreeProcessor)expressionTreeParser.Processor).InnerProcessors;
Assert.That(processingSteps.Count, Is.EqualTo(2));
Assert.That(processingSteps[0], Is.TypeOf(typeof(PartialEvaluatingExpressionTreeProcessor)));
Assert.That(processingSteps[1], Is.TypeOf(typeof(TransformingExpressionTreeProcessor)));
Assert.That(((TransformingExpressionTreeProcessor)processingSteps[1]).Provider, Is.TypeOf(typeof(ExpressionTransformerRegistry)));
var expressionTransformerRegistry =
((ExpressionTransformerRegistry)((TransformingExpressionTreeProcessor)processingSteps[1]).Provider);
Assert.That(
expressionTransformerRegistry.RegisteredTransformerCount,
Is.EqualTo(ExpressionTransformerRegistry.CreateDefault().RegisteredTransformerCount));
}
private static QueryParser CreateQueryParser(INodeTypeProvider nodeTypeProvider)
=> new QueryParser(
new ExpressionTreeParser(
nodeTypeProvider,
new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(_evaluatableExpressionFilter),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
/// <summary>
/// Initializes a new instance of the <see cref="QueryParser"/> class, using default parameters for parsing.
/// The <see cref="Structure.ExpressionTreeParser.NodeTypeProvider"/> used has all relevant methods of the <see cref="Queryable"/> class
/// automatically registered, and the <see cref="Structure.ExpressionTreeParser.Processor"/> comprises partial evaluation, and default
/// expression transformations. See <see cref="Structure.ExpressionTreeParser.CreateDefaultNodeTypeProvider"/>,
/// <see cref="Structure.ExpressionTreeParser.CreateDefaultProcessor"/>, and <see cref="ExpressionTransformerRegistry.CreateDefault"/>
/// for details.
/// </summary>
public static QueryParser CreateDefault()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var expressionTreeParser = new ExpressionTreeParser(
ExpressionTreeParser.CreateDefaultNodeTypeProvider(),
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry));
return(new QueryParser(expressionTreeParser));
}
public void CreateDefaultProcessor_WithoutEvaluatableExpressionFilter_UsesANullImplementation()
{
var inputTransformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(inputTransformerRegistry);
Assert.That(processor.InnerProcessors.Count, Is.EqualTo(2));
Assert.That(processor.InnerProcessors[0], Is.TypeOf(typeof(PartialEvaluatingExpressionTreeProcessor)));
Assert.That(((PartialEvaluatingExpressionTreeProcessor)processor.InnerProcessors[0]).Filter, Is.Not.Null);
}
private static ExpressionTransformerRegistry CreatePrePartialEvaluationDefaultTransformerRegistry()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
//Register transformer to handle enum == and != comparisons
transformerRegistry.Register(new EnumComparisonExpressionTransformer());
return(transformerRegistry);
}
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));
}
/// <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));
}
private static QueryParser CreateQueryParser()
=> new QueryParser(
new ExpressionTreeParser(
_cachedNodeTypeProvider.Value,
new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(new NullEvaluatableExpressionFilter()),
new FunctionEvaluationEnablingProcessor(),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
// Based on the article: https://weblogs.asp.net/dixin/entity-framework-core-and-linq-to-entities-5-query-translation-implementation
public static (SelectExpression, IReadOnlyDictionary <string, object>) Compile(
this DbContext dbContext, Expression linqExp, bool extractParams = true)
{
if (linqExp == null)
{
throw new ArgumentNullException(nameof(linqExp));
}
var evalExpFilter = (dbContext ?? throw new ArgumentNullException(nameof(dbContext)))
.GetService <IEvaluatableExpressionFilter>();
QueryContext queryContext = null;
if (extractParams)
{
queryContext = dbContext.GetService <IQueryContextFactory>().Create();
linqExp = new ParameterExtractingExpressionVisitor(
evaluatableExpressionFilter: evalExpFilter,
parameterValues: queryContext,
logger: dbContext.GetService <IDiagnosticsLogger <DbLoggerCategory.Query> >(),
context: dbContext,
parameterize: true).ExtractParameters(linqExp);
}
var queryParser = new QueryParser(new ExpressionTreeParser(
nodeTypeProvider: dbContext.GetService <INodeTypeProviderFactory>().Create(),
processor: new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(evalExpFilter),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
var queryModel = queryParser.GetParsedQuery(linqExp);
var resultType = queryModel.GetResultType();
if (resultType.IsConstructedGenericType && resultType.IsAssignableTo(typeof(IQueryable <>)))
{
resultType = resultType.GenericTypeArguments.Single();
}
var compilationContext = dbContext.GetService <IQueryCompilationContextFactory>().Create(async: false);
var queryModelVisitor = (RelationalQueryModelVisitor)compilationContext.CreateQueryModelVisitor();
queryModelVisitor.GetType()
.GetMethod(nameof(RelationalQueryModelVisitor.CreateQueryExecutor))
.MakeGenericMethod(resultType)
.Invoke(queryModelVisitor, new object[] { queryModel });
var selectExp = queryModelVisitor.TryGetQuery(queryModel.MainFromClause);
selectExp.QuerySource = queryModel.MainFromClause;
return(selectExp, queryContext?.ParameterValues ?? new Dictionary <string, object>());
}
private static QueryParser CreateQueryParser()
{
return(new QueryParser(
new ExpressionTreeParser(
CreateNodeTypeProvider(),
new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
}))));
}
static MongoQueryParser()
{
var nodeTypeProvider = new MongoNodeTypeProvider();
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
queryParser = new QueryParser(expressionTreeParser);
}
/// <summary>
/// Creates an <c cref="IExpressionTreeProcessor"/> that will execute
/// <c cref="AllowSpecialCharactersExpressionTransformer"/>
/// before executing <c cref="PartialEvaluatingExpressionTreeProcessor"/>
/// and other default processors.
/// </summary>
internal static IExpressionTreeProcessor CreateExpressionTreeProcessor()
{
var firstRegistry = new ExpressionTransformerRegistry();
firstRegistry.Register(new AllowSpecialCharactersExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(ExpressionTransformerRegistry.CreateDefault());
processor.InnerProcessors.Insert(0, new TransformingExpressionTreeProcessor(firstRegistry));
return(processor);
}
public static CustomQueryParser CreateDefault()
{
var compoundNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
return
(new CustomQueryParser(
new ExpressionTreeParser(
compoundNodeTypeProvider,
ExpressionTreeParserHelper.CreateDefaultProcessor(
ExpressionTransformerRegistry.CreateDefault()))));
}
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 MartenQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser =
new ExpressionTreeParser(MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), processor);
_parser = new QueryParser(expressionTreeParser);
}
private static ExpressionTransformerRegistry CreateDefaultTransformerRegistry()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
//Register transformer to handle string comparisons
transformerRegistry.Register(new StringComparisonExpressionTransformer());
//Register transformer to handle DateTime comparisons
transformerRegistry.Register(new DateTimeComparisonExpressionTransformer());
return(transformerRegistry);
}
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));
}
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 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 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));
}
public void CreateQueryParser_HasDefaultNodesAndSteps()
{
var selectMethod = SelectExpressionNode.GetSupportedMethods().First();
var queryParser = (QueryParser)_factory.CreateQueryParser();
Assert.That(queryParser.NodeTypeProvider, Is.TypeOf(typeof(CompoundNodeTypeProvider)));
Assert.That(((CompoundNodeTypeProvider)queryParser.NodeTypeProvider).InnerProviders[1], Is.TypeOf(typeof(MethodInfoBasedNodeTypeRegistry)));
Assert.That(((CompoundNodeTypeProvider)queryParser.NodeTypeProvider).InnerProviders[2], Is.TypeOf(typeof(MethodNameBasedNodeTypeRegistry)));
Assert.That(queryParser.NodeTypeProvider.GetNodeType(selectMethod), Is.SameAs(typeof(SelectExpressionNode)));
var processingSteps = ((CompoundExpressionTreeProcessor)queryParser.Processor).InnerProcessors;
Assert.That(processingSteps.Count,
Is.EqualTo(ExpressionTreeParser.CreateDefaultProcessor(ExpressionTransformerRegistry.CreateDefault()).InnerProcessors.Count));
}
public MartenQueryParser(Action <MethodInfoBasedNodeTypeRegistry> registerNodeTypes = null)
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var nodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly();
registerNodeTypes?.Invoke(nodeTypeRegistry);
var expressionTreeParser =
new ExpressionTreeParser(nodeTypeRegistry, processor);
_parser = new QueryParser(expressionTreeParser);
}
public void CreateDefaultProcessor()
{
var inputTransformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(inputTransformerRegistry);
Assert.That(processor.InnerProcessors.Count, Is.EqualTo(2));
Assert.That(processor.InnerProcessors[0], Is.TypeOf(typeof(PartialEvaluatingExpressionTreeProcessor)));
Assert.That(processor.InnerProcessors[1], Is.TypeOf(typeof(TransformingExpressionTreeProcessor)));
Assert.That(
((TransformingExpressionTreeProcessor)processor.InnerProcessors[1]).Provider,
Is.TypeOf(typeof(ExpressionTransformerRegistry)));
var createdTransformerRegistry = ((ExpressionTransformerRegistry)((TransformingExpressionTreeProcessor)processor.InnerProcessors[1]).Provider);
Assert.That(createdTransformerRegistry, Is.SameAs(inputTransformerRegistry));
}
static NhRelinqQueryParser()
{
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
// Register custom expression transformers here:
// transformerRegistry.Register (new MyExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
// Add custom processors here:
// processor.InnerProcessors.Add (new MyExpressionTreeProcessor());
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
_queryParser = new QueryParser(expressionTreeParser);
}
static NhRelinqQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
transformerRegistry.Register(new RemoveCharToIntConversion());
transformerRegistry.Register(new RemoveRedundantCast());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
// Add custom processors here:
// processor.InnerProcessors.Add (new MyExpressionTreeProcessor());
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
QueryParser = new QueryParser(expressionTreeParser);
}
static NhRelinqQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
transformerRegistry.Register(new RemoveRedundantCast());
transformerRegistry.Register(new SimplifyCompareTransformer());
// If needing a compound processor for adding other processing, do not use
// ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry), it would
// cause NH-3961 again by including a PartialEvaluatingExpressionTreeProcessor.
// Directly instantiate a CompoundExpressionTreeProcessor instead.
var processor = new TransformingExpressionTreeProcessor(transformerRegistry);
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
QueryParser = 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));
}
