static DateTimeTransformationRegistry()
{
var registry = new ExpressionTransformerRegistry();
registry.Register(new DateTimeComparisonExpressionTransformer());
Default = registry;
}
/// <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;
}
static Transformer()
{
__registry = new ExpressionTransformerRegistry();
__registry.Register(new NullableTransformer());
__registry.Register(new FirstLastNormalizingTransformer());
__registry.Register(new SelectSelectCombiningTransformer());
__registry.Register(new ConstantOnRightTransformer());
__registry.Register(new VBStringIndexComparisonTransformer());
__registry.Register(new VBCompareStringTransformer());
__registry.Register(new VBNothingConversionRemovalTransformer());
__registry.Register(new VBCoalesceTransformer());
__registry.Register(new VBInformationIsNothingTransformer());
}
private static ExpressionTransformerRegistry CreateDefaultTransformerRegistry()
{
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());
return(transformerRegistry);
}
protected virtual void VisitGroupResultOperator(GroupResultOperator groupResultOperator, QueryModel queryModel)
{
_groupingExpressionTransformerRegistry = new ExpressionTransformerRegistry();
// Add GROUP BY clause for the grouping key
// And add transformations for any references to the key
if (groupResultOperator.KeySelector.NodeType == ExpressionType.New)
{
// Grouping by a multipart key, so add each key to the GROUP BY clause
var newExpression = (NewExpression)groupResultOperator.KeySelector;
foreach (var argument in newExpression.Arguments)
{
_queryPartsAggregator.AddGroupByPart(GetN1QlExpression(argument));
}
// Use MultiKeyExpressionTransformer to remap access to the Key property
_groupingExpressionTransformerRegistry.Register(
new MultiKeyExpressionTransfomer(_queryGenerationContext.GroupingQuerySource, newExpression));
}
else
{
// Grouping by a single column
_queryPartsAggregator.AddGroupByPart(GetN1QlExpression(groupResultOperator.KeySelector));
// Use KeyExpressionTransformer to remap access to the Key property
_groupingExpressionTransformerRegistry.Register(
new KeyExpressionTransfomer(_queryGenerationContext.GroupingQuerySource, groupResultOperator.KeySelector));
}
// Add transformations for any references to the element selector
if (groupResultOperator.ElementSelector.NodeType == QuerySourceReferenceExpression.ExpressionType)
{
_queryGenerationContext.ExtentNameProvider.LinkExtents(
((QuerySourceReferenceExpression)groupResultOperator.ElementSelector).ReferencedQuerySource,
_queryGenerationContext.GroupingQuerySource.ReferencedQuerySource);
}
else
{
throw new NotSupportedException("Unsupported GroupResultOperator ElementSelector Type");
}
}
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);
}
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);
}
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);
}
public static (SelectExpression, IReadOnlyDictionary <string, object>) Compile(
this DbContext dbContext, Expression linqExpression)
{
QueryContext queryContext = dbContext.GetService <IQueryContextFactory>().Create();
IEvaluatableExpressionFilter evaluatableExpressionFilter = dbContext.GetService <IEvaluatableExpressionFilter>();
linqExpression = new ParameterExtractingExpressionVisitor(
evaluatableExpressionFilter: evaluatableExpressionFilter,
parameterValues: queryContext,
logger: dbContext.GetService <IDiagnosticsLogger <DbLoggerCategory.Query> >(),
context: dbContext,
parameterize: true).ExtractParameters(linqExpression);
QueryParser queryParser = new QueryParser(new ExpressionTreeParser(
nodeTypeProvider: dbContext.GetService <INodeTypeProviderFactory>().Create(),
processor: new CompoundExpressionTreeProcessor(new IExpressionTreeProcessor[]
{
new PartialEvaluatingExpressionTreeProcessor(evaluatableExpressionFilter),
new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault())
})));
QueryModel queryModel = queryParser.GetParsedQuery(linqExpression);
Type resultType = queryModel.GetResultType();
if (resultType.IsConstructedGenericType && resultType.GetGenericTypeDefinition() == typeof(IQueryable <>))
{
resultType = resultType.GenericTypeArguments.Single();
}
QueryCompilationContext compilationContext = dbContext.GetService <IQueryCompilationContextFactory>()
.Create(async: false);
RelationalQueryModelVisitor queryModelVisitor = (RelationalQueryModelVisitor)compilationContext
.CreateQueryModelVisitor();
queryModelVisitor.GetType()
.GetMethod(nameof(RelationalQueryModelVisitor.CreateQueryExecutor))
.MakeGenericMethod(resultType)
.Invoke(queryModelVisitor, new object[] { queryModel });
SelectExpression databaseExpression = queryModelVisitor.TryGetQuery(queryModel.MainFromClause);
databaseExpression.QuerySource = queryModel.MainFromClause;
return(databaseExpression, queryContext.ParameterValues);
}
/// <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));
}
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);
}
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(Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByExpressionNode));
customNodeTypeRegistry.Register(OrderByDescendingSupportedMethods, typeof(Remotion.Linq.Parsing.Structure.IntermediateModel.OrderByDescendingExpressionNode));
customNodeTypeRegistry.Register(SelectManySupportedMethods, typeof(Remotion.Linq.Parsing.Structure.IntermediateModel.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 CreateDefault()
{
var registry = ExpressionTransformerRegistry.CreateDefault();
var equalTranformations = registry.GetAllTransformations(ExpressionType.Equal);
var equalTransformers = GetTransformersFromTransformations(equalTranformations);
Assert.That(equalTransformers, Has.Some.TypeOf(typeof(VBCompareStringExpressionTransformer)));
var callTranformations = registry.GetAllTransformations(ExpressionType.Call);
var callTransformers = GetTransformersFromTransformations(callTranformations);
Assert.That(callTransformers, Has.Some.TypeOf(typeof(VBInformationIsNothingExpressionTransformer)));
Assert.That(callTransformers, Has.Some.TypeOf(typeof(AttributeEvaluatingExpressionTransformer)));
var invocationTranformations = registry.GetAllTransformations(ExpressionType.Invoke);
var invocationTransformers = GetTransformersFromTransformations(invocationTranformations);
Assert.That(invocationTransformers, Has.Some.TypeOf(typeof(InvocationOfLambdaExpressionTransformer)));
var memberTranformations = registry.GetAllTransformations(ExpressionType.MemberAccess);
var memberTransformers = GetTransformersFromTransformations(memberTranformations);
Assert.That(memberTransformers, Has.Some.TypeOf(typeof(NullableValueTransformer)));
Assert.That(memberTransformers, Has.Some.TypeOf(typeof(AttributeEvaluatingExpressionTransformer)));
var newTranformations = registry.GetAllTransformations(ExpressionType.New);
var newTransformers = GetTransformersFromTransformations(newTranformations);
Assert.That(newTransformers, Has.Some.TypeOf(typeof(KeyValuePairNewExpressionTransformer)));
Assert.That(newTransformers, Has.Some.TypeOf(typeof(DictionaryEntryNewExpressionTransformer)));
Assert.That(newTransformers, Has.Some.TypeOf(typeof(TupleNewExpressionTransformer)));
var memberAddingTransformers = newTransformers.OfType <MemberAddingNewExpressionTransformerBase>().ToArray();
Assert.That(memberAddingTransformers.Length, Is.EqualTo(3));
Assert.That(registry.RegisteredTransformerCount, Is.EqualTo(14));
}
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 QueryParser CreateQueryParser(INodeTypeProvider nodeTypeProvider)
=> new QueryParser(
new ExpressionTreeParser(
nodeTypeProvider,
new CompoundExpressionTreeProcessor(
new IExpressionTreeProcessor[] { new PartialEvaluatingExpressionTreeProcessor(_reLinqEvaluatableExpressionFilter), new TransformingExpressionTreeProcessor(ExpressionTransformerRegistry.CreateDefault()) })));
static QueryParserHelper()
{
_nodeTypeProvider = CreateDefaultNodeTypeProvider();
_transformerRegistry = CreateDefaultTransformerRegistry();
_prePartialEvaluationTransformerRegistry = CreatePrePartialEvaluationDefaultTransformerRegistry();
}
public void SetUp()
{
_registry = new ExpressionTransformerRegistry();
}
protected virtual void VisitGroupResultOperator(GroupResultOperator groupResultOperator, QueryModel queryModel)
{
_groupingExpressionTransformerRegistry = new ExpressionTransformerRegistry();
// Add GROUP BY clause for the grouping key
// And add transformations for any references to the key
if (groupResultOperator.KeySelector.NodeType == ExpressionType.New)
{
// Grouping by a multipart key, so add each key to the GROUP BY clause
var newExpression = (NewExpression) groupResultOperator.KeySelector;
foreach (var argument in newExpression.Arguments) {
_queryPartsAggregator.AddGroupByPart(GetN1QlExpression(argument));
}
// Use MultiKeyExpressionTransformer to remap access to the Key property
_groupingExpressionTransformerRegistry.Register(
new MultiKeyExpressionTransfomer(_queryGenerationContext.GroupingQuerySource, newExpression));
}
else
{
// Grouping by a single column
_queryPartsAggregator.AddGroupByPart(GetN1QlExpression(groupResultOperator.KeySelector));
// Use KeyExpressionTransformer to remap access to the Key property
_groupingExpressionTransformerRegistry.Register(
new KeyExpressionTransfomer(_queryGenerationContext.GroupingQuerySource, groupResultOperator.KeySelector));
}
// Add transformations for any references to the element selector
if (groupResultOperator.ElementSelector.NodeType == QuerySourceReferenceExpression.ExpressionType)
{
_queryGenerationContext.ExtentNameProvider.LinkExtents(
((QuerySourceReferenceExpression) groupResultOperator.ElementSelector).ReferencedQuerySource,
_queryGenerationContext.GroupingQuerySource.ReferencedQuerySource);
}
else
{
throw new NotSupportedException("Unsupported GroupResultOperator ElementSelector Type");
}
}
public void Register(ExpressionTransformerRegistry expressionTransformerRegistry)
{
expressionTransformerRegistry.Register(new LikeTransformer());
}
static QueryParserHelper()
{
_nodeTypeProvider = CreateDefaultNodeTypeProvider();
_transformerRegistry = CreateDefaultTransformerRegistry();
}
