public virtual IGraphQueryStep Visit(IGraphQueryStep root)
{
_token.ThrowIfCancellationRequested();
switch (root)
{
case QueryQueryStep qqs:
return(VisitQueryQueryStep(qqs));
case EdgeQueryStep eqs:
return(VisitEdgeQueryStep(eqs));
case CollectionDestinationQueryStep cdqs:
return(VisitCollectionDestinationQueryStep(cdqs));
case IntersectionQueryStep <Except> iqse:
return(VisitIntersectionQueryStepExcept(iqse));
case IntersectionQueryStep <Union> iqsu:
return(VisitIntersectionQueryStepUnion(iqsu));
case IntersectionQueryStep <Intersection> iqsi:
return(VisitIntersectionQueryStepIntersection(iqsi));
case RecursionQueryStep rqs:
return(VisitRecursionQueryStep(rqs));
default:
throw new NotSupportedException($"Unexpected type {root.GetType().Name} for QueryPlanRewriter.Visit");
}
}
public SingleEdgeMatcher(SingleEdgeMatcher step, IGraphQueryStep right)
{
Right = right;
QueryParameters = step.QueryParameters;
IncludedEdges = new Dictionary <string, Sparrow.Json.BlittableJsonReaderObject>(StringComparer.OrdinalIgnoreCase);
Results = new List <Match>();
Edge = step.Edge;
EdgeAlias = step.EdgeAlias;
}
public SingleEdgeMatcher(SingleEdgeMatcher step, IGraphQueryStep right, char identityPartsSeparator)
{
Right = right;
_identityPartsSeparator = identityPartsSeparator;
QueryParameters = step.QueryParameters;
IncludedEdges = new Dictionary <string, BlittableJsonReaderObject>(StringComparer.OrdinalIgnoreCase);
Results = new List <Match>();
Edge = step.Edge;
EdgeAlias = step.EdgeAlias;
}
private IGraphQueryStep BuildQueryPlanForRecursiveEdge(IGraphQueryStep left, int index, PatternMatchElementExpression patternExpression)
{
var recursive = patternExpression.Path[index].Recursive.Value;
var pattern = recursive.Pattern;
var steps = new List <SingleEdgeMatcher>((pattern.Count + 1) / 2);
for (int i = 0; i < pattern.Count; i += 2)
{
if (GraphQuery.WithEdgePredicates.TryGetValue(pattern[i].Alias, out var recursiveEdge) == false)
{
throw new InvalidOperationException($"BuildQueryPlanForEdge was invoked for recursive alias='{pattern[i].Alias}' which suppose to be an edge but no corresponding WITH EDGE clause was found.");
}
steps.Add(new SingleEdgeMatcher
{
IncludedEdges = new Dictionary <string, Sparrow.Json.BlittableJsonReaderObject>(StringComparer.OrdinalIgnoreCase),
QueryParameters = _query.QueryParameters,
Edge = recursiveEdge,
Results = new List <Match>(),
Right = i + 1 < pattern.Count ? BuildQueryPlanForMatchNode(pattern[i + 1]) : null,
EdgeAlias = pattern[i].Alias
});
}
var recursiveStep = new RecursionQueryStep(left, steps, recursive, recursive.GetOptions(_query.Metadata, _query.QueryParameters), _token)
{
CollectIntermediateResults = CollectIntermediateResults
};
if (index + 1 < patternExpression.Path.Length)
{
if (patternExpression.Path[index + 1].Recursive.HasValue)
{
throw new InvalidQueryException("Two adjacent 'recursive' queries are not allowed", GraphQuery.QueryText);
}
if (patternExpression.Path[index + 1].IsEdge)
{
var nextPlan = BuildQueryPlanForPattern(patternExpression, index + 2);
nextPlan = BuildQueryPlanForEdge(recursiveStep, nextPlan, patternExpression.Path[index + 1]);
recursiveStep.SetNext(nextPlan.GetSingleGraphStepExecution());
}
else
{
var nextPlan = BuildQueryPlanForPattern(patternExpression, index + 1);
recursiveStep.SetNext(nextPlan.GetSingleGraphStepExecution());
}
}
return(recursiveStep);
}
private IGraphQueryStep BuildQueryPlanForEdge(IGraphQueryStep left, IGraphQueryStep right, MatchPath edge)
{
var alias = edge.Alias;
if (GraphQuery.WithEdgePredicates.TryGetValue(alias, out var withEdge) == false)
{
throw new InvalidOperationException($"BuildQueryPlanForEdge was invoked for alias='{alias}' which suppose to be an edge but no corresponding WITH EDGE clause was found.");
}
return(new EdgeQueryStep(left, right, withEdge, edge, _query.QueryParameters, _token)
{
CollectIntermediateResults = CollectIntermediateResults
});
}
public EdgeQueryStep(IGraphQueryStep left, IGraphQueryStep right, EdgeQueryStep eqs, OperationCancelToken token)
{
_left = left;
_right = right;
_aliases = new HashSet <string>();
_aliases.UnionWith(_left.GetAllAliases());
_aliases.UnionWith(_right.GetAllAliases());
_aliases.Add(eqs._edgePath.Alias.Value);
_edgePath = eqs._edgePath;
_queryParameters = eqs._queryParameters;
_edgesExpression = eqs._edgesExpression;
_outputAlias = _right.GetOutputAlias();
_token = token;
}
public EdgeQueryStep(IGraphQueryStep left, IGraphQueryStep right, WithEdgesExpression edgesExpression, MatchPath edgePath, BlittableJsonReaderObject queryParameters, OperationCancelToken token)
{
_left = left;
_right = right;
_aliases = new HashSet <string>();
_aliases.UnionWith(_left.GetAllAliases());
_aliases.UnionWith(_right.GetAllAliases());
_aliases.Add(edgePath.Alias.Value);
_edgePath = edgePath;
_queryParameters = queryParameters;
_edgesExpression = edgesExpression;
_outputAlias = _right.GetOutputAlias();
_token = token;
}
public IntersectionQueryStep(IGraphQueryStep left, IGraphQueryStep right, OperationCancelToken token, bool returnEmptyIfRightEmpty = false, bool returnEmptyIfLeftEmpty = true)
{
_returnEmptyIfLeftEmpty = returnEmptyIfLeftEmpty;
_returnEmptyIfRightEmpty = returnEmptyIfRightEmpty;
_unionedAliases = new HashSet <string>();
_unionedAliases.UnionWith(left.GetAllAliases());
_unionedAliases.UnionWith(right.GetAllAliases());
var tmpIntersection = new HashSet <string>(left.GetAllAliases());
tmpIntersection.IntersectWith(right.GetAllAliases());
_intersectedAliases = tmpIntersection.ToList();
_left = left;
_right = right;
_token = token;
}
public virtual async Task VisitAsync(IGraphQueryStep root)
{
switch (root)
{
case QueryQueryStep qqs:
VisitQueryQueryStep(qqs);
return;
case EdgeQueryStep eqs:
await VisitEdgeQueryStepAsync(eqs);
return;
case CollectionDestinationQueryStep cdqs:
VisitCollectionDestinationQueryStep(cdqs);
return;
case IntersectionQueryStep <Except> iqse:
await VisitIntersectionQueryStepExceptAsync(iqse);
return;
case IntersectionQueryStep <Union> iqsu:
await VisitIntersectionQueryStepUnionAsync(iqsu);
return;
case IntersectionQueryStep <Intersection> iqsi:
await VisitIntersectionQueryStepIntersectionAsync(iqsi);
return;
case RecursionQueryStep rqs:
await VisitRecursionQueryStepAsync(rqs);
return;
default:
throw new NotSupportedException($"Unexpected type {root.GetType().Name} for QueryPlanVisitor.Visit");
}
}
public RecursionQueryStep(IGraphQueryStep left, RecursionQueryStep rqs, OperationCancelToken token)
{
_left = left;
_steps = rqs._steps;
_recursive = rqs._recursive;
_options = rqs._options;
_stepAliases.Add(left.GetOutputAlias());
foreach (var step in _steps)
{
if (step.Right == null)
{
continue;
}
_stepAliases.Add(step.Right.GetOutputAlias());
}
_outputAlias = _stepAliases.Last();
_token = token;
}
public RecursionQueryStep(IGraphQueryStep left, List <SingleEdgeMatcher> steps, RecursiveMatch recursive, RecursiveMatch.RecursiveOptions options, OperationCancelToken token)
{
_left = left;
_steps = steps;
_recursive = recursive;
_options = options;
_stepAliases.Add(left.GetOutputAlias());
foreach (var step in _steps)
{
if (step.Right == null)
{
continue;
}
_stepAliases.Add(step.Right.GetOutputAlias());
}
_outputAlias = _stepAliases.Last();
_allLliases.UnionWith(_left.GetAllAliases());
_allLliases.Add(_recursive.Alias.Value);
_token = token;
}
public void BuildQueryPlan()
{
new GraphQuerySyntaxValidatorVisitor(GraphQuery).Visit(_query.Metadata.Query); //this will throw if the syntax will be bad
RootQueryStep = BuildQueryPlanForExpression(_query.Metadata.Query.GraphQuery.MatchClause);
ClearUniqueQueriesFromIdenticalQueries();
}
public void OptimizeQueryPlan()
{
var cdqsr = new EdgeCollectionDestinationRewriter(_database.DocumentsStorage, _token);
RootQueryStep = cdqsr.Visit(RootQueryStep);
}
public void Set(IGraphQueryStep left, IGraphQueryStep right)
{
_leftAliases = left.GetAllAliases();
_rightAliases = right.GetAllAliases();
}
