public virtual Task AcceptAsync(IQueryNodeVisitor visitor, IQueryVisitorContext context)
{
if (this is GroupNode node)
{
return(visitor.VisitAsync(node, context));
}
if (this is TermNode termNode)
{
return(visitor.VisitAsync(termNode, context));
}
if (this is TermRangeNode rangeNode)
{
return(visitor.VisitAsync(rangeNode, context));
}
if (this is MissingNode missingNode)
{
return(visitor.VisitAsync(missingNode, context));
}
if (this is ExistsNode existsNode)
{
return(visitor.VisitAsync(existsNode, context));
}
return(Task.CompletedTask);
}
public virtual async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
foreach (var child in node.Children)
{
await VisitAsync(child, context).ConfigureAwait(false);
}
}
public override async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
if (node.Field == "@custom" && node.Left != null)
{
string term = ToTerm(node);
var ids = await GetIdsAsync(term);
if (ids != null && ids.Count > 0)
{
node.Parent.SetQuery(new TermsQuery {
Field = "id", Terms = ids
});
}
else
{
node.Parent.SetQuery(new TermQuery {
Field = "id", Value = "none"
});
}
node.Left = null;
node.Right = null;
}
await base.VisitAsync(node, context);
}
public override void Visit(MissingNode node, IQueryVisitorContext context)
{
var validationInfo = context.GetValidationInfo();
AddField(validationInfo, node, context);
AddOperation(validationInfo, "missing", node.Field);
}
public override Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
if (String.IsNullOrEmpty(node.Field))
{
return(base.VisitAsync(node, context));
}
if (!(node.Left is TermNode leftTerm) || !String.IsNullOrEmpty(leftTerm.Field))
{
throw new ApplicationException("The first item in an aggregation group must be the name of the target field.");
}
if (!IsKnownAggregationType(node.Field))
{
return(base.VisitAsync(node, context));
}
node.SetOperationType(node.Field);
node.Field = leftTerm.Term;
node.Boost = leftTerm.Boost;
node.Proximity = leftTerm.Proximity;
node.Left = null;
return(base.VisitAsync(node, context));
}
public override void Visit(TermRangeNode node, IQueryVisitorContext context)
{
var validationInfo = context.GetValidationInfo();
string field = null;
if (!String.IsNullOrEmpty(node.Field))
{
field = String.Equals(validationInfo.QueryType, QueryType.Query) ? node.GetFullName() : node.Field;
if (!field.StartsWith("@"))
{
validationInfo.ReferencedFields.Add(field);
}
}
else
{
if (String.Equals(validationInfo.QueryType, QueryType.Aggregation))
{
validationInfo.IsValid = false;
}
var nameParts = node.GetNameParts();
if (nameParts.Length == 0)
{
validationInfo.ReferencedFields.Add("_all");
}
}
AddOperation(validationInfo, node.GetOperationType(), field);
}
public override async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
var validationInfo = context.GetValidationInfo();
if (validationInfo.QueryType == null)
{
validationInfo.QueryType = node.GetQueryType();
}
string field = null;
if (!String.IsNullOrEmpty(node.Field))
{
field = String.Equals(validationInfo.QueryType, QueryType.Query) ? node.GetFullName() : node.Field;
if (!field.StartsWith("@"))
{
validationInfo.ReferencedFields.Add(field);
}
if (node.HasParens)
{
validationInfo.CurrentNodeDepth++;
}
}
AddOperation(validationInfo, node.GetOperationType(), field);
await base.VisitAsync(node, context).ConfigureAwait(false);
if (!String.IsNullOrEmpty(node.Field) && node.HasParens)
{
validationInfo.CurrentNodeDepth--;
}
}
private void ResolveField(IFieldQueryNode node, IQueryVisitorContext context)
{
if (node.Parent == null || node.Field == null)
{
return;
}
var contextResolver = context.GetFieldResolver();
string resolvedField = node.Field;
if (_globalResolver != null)
{
resolvedField = _globalResolver(resolvedField) ?? resolvedField;
}
if (contextResolver != null)
{
resolvedField = contextResolver(resolvedField) ?? resolvedField;
}
if (resolvedField != null && !resolvedField.Equals(node.Field, StringComparison.OrdinalIgnoreCase))
{
node.SetOriginalField(node.Field);
node.Field = resolvedField;
}
}
public static GroupOperator GetOperator(this IQueryNode node, IQueryVisitorContext context)
{
var defaultOperator = GroupOperator.And;
if (context != null && context.DefaultOperator != GroupOperator.Default)
{
defaultOperator = context.DefaultOperator;
}
var groupNode = node as GroupNode;
if (groupNode == null)
{
groupNode = node.Parent as GroupNode;
}
if (groupNode == null)
{
return(defaultOperator);
}
switch (groupNode.Operator)
{
case GroupOperator.And:
return(GroupOperator.And);
case GroupOperator.Or:
return(GroupOperator.Or);
default:
return(defaultOperator);
}
}
public virtual Task VisitAsync(IQueryNode node, IQueryVisitorContext context)
{
if (node is GroupNode groupNode)
{
return(VisitAsync(groupNode, context));
}
if (node is TermNode termNode)
{
return(VisitAsync(termNode, context));
}
if (node is TermRangeNode termRangeNode)
{
return(VisitAsync(termRangeNode, context));
}
if (node is MissingNode missingNode)
{
return(VisitAsync(missingNode, context));
}
if (node is ExistsNode existsNode)
{
return(VisitAsync(existsNode, context));
}
return(Task.CompletedTask);
}
private string GetNestedProperty(string fullName, IQueryVisitorContext context)
{
string[] nameParts = fullName?.Split('.').ToArray();
if (nameParts == null || !(context is IElasticQueryVisitorContext elasticContext) || nameParts.Length == 0)
{
return(null);
}
string fieldName = String.Empty;
for (int i = 0; i < nameParts.Length; i++)
{
if (i > 0)
{
fieldName += ".";
}
fieldName += nameParts[i];
if (elasticContext.MappingResolver.IsNestedPropertyType(fieldName))
{
return(fieldName);
}
}
return(null);
}
private IRepositoryQuery GetSystemFilterQuery(IQueryVisitorContext context)
{
var builderContext = context as IQueryBuilderContext;
var systemFilter = builderContext?.Source.GetSystemFilter();
var systemFilterQuery = systemFilter?.GetQuery().Clone();
if (systemFilterQuery == null)
{
systemFilterQuery = new RepositoryQuery <Stack>();
foreach (var range in builderContext?.Source.GetDateRanges() ?? Enumerable.Empty <DateRange>())
{
systemFilterQuery.DateRange(range.StartDate, range.EndDate, range.Field, range.TimeZone);
}
}
if (!systemFilterQuery.HasAppFilter())
{
systemFilterQuery.AppFilter(builderContext?.Source.GetAppFilter());
}
foreach (var range in systemFilterQuery.GetDateRanges() ?? Enumerable.Empty <DateRange>())
{
if (range.Field == _inferredEventDateField || range.Field == "date")
{
range.Field = _inferredStackLastOccurrenceField;
}
}
return(systemFilterQuery);
}
public override async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
var childTerms = new List <string>();
if (node.Left is TermNode leftTermNode && leftTermNode.Field == null)
{
childTerms.Add(leftTermNode.Term);
}
if (node.Left is TermRangeNode leftTermRangeNode && leftTermRangeNode.Field == null)
{
childTerms.Add(leftTermRangeNode.Min);
childTerms.Add(leftTermRangeNode.Max);
}
if (node.Right is TermNode rightTermNode && rightTermNode.Field == null)
{
childTerms.Add(rightTermNode.Term);
}
if (node.Right is TermRangeNode rightTermRangeNode && rightTermRangeNode.Field == null)
{
childTerms.Add(rightTermRangeNode.Min);
childTerms.Add(rightTermRangeNode.Max);
}
node.Field = GetCustomFieldName(node.Field, childTerms.ToArray()) ?? node.Field;
foreach (var child in node.Children)
{
await child.AcceptAsync(this, context).AnyContext();
}
}
private void ApplyAlias(IFieldQueryNode node, IQueryVisitorContext context)
{
if (node.Parent == null)
{
return;
}
var resolver = node.Parent.GetAliasResolver(context);
var result = resolver != null && node.Field != null?resolver(node.Field) : null;
if (result == null)
{
var groupNode = node as GroupNode;
if (groupNode != null)
{
node.SetAliasResolver(_useNestedResolvers ? GetScopedResolver(resolver, node.Field) : resolver);
}
return;
}
node.SetOriginalField(node.Field);
node.Field = result.Name;
if (node is GroupNode)
{
node.SetAliasResolver(_useNestedResolvers ? result.Resolver : resolver);
}
}
public virtual Task AcceptAsync(IQueryNodeVisitor visitor, IQueryVisitorContext context)
{
if (this is GroupNode)
{
return(visitor.VisitAsync((GroupNode)this, context));
}
if (this is TermNode)
{
return(visitor.VisitAsync((TermNode)this, context));
}
if (this is TermRangeNode)
{
return(visitor.VisitAsync((TermRangeNode)this, context));
}
if (this is MissingNode)
{
return(visitor.VisitAsync((MissingNode)this, context));
}
if (this is ExistsNode)
{
return(visitor.VisitAsync((ExistsNode)this, context));
}
return(Task.CompletedTask);
}
public override void Visit(MissingNode node, IQueryVisitorContext context)
{
if (!String.IsNullOrEmpty(node.Field))
{
AddField(node);
}
}
private bool IsNestedPropertyType(string[] nameParts, IQueryVisitorContext context)
{
if (nameParts == null || !(context is IElasticQueryVisitorContext elasticContext) || nameParts.Length == 0)
{
return(false);
}
string fieldName = String.Empty;
for (int i = 0; i < nameParts.Length; i++)
{
if (i > 0)
{
fieldName += ".";
}
fieldName += nameParts[i];
if (elasticContext.IsNestedPropertyType(fieldName))
{
return(true);
}
}
return(false);
}
public static IFieldSort GetDefaultSort(this TermNode node, IQueryVisitorContext context)
{
var elasticContext = context as IElasticQueryVisitorContext;
if (elasticContext == null)
{
throw new ArgumentException("Context must be of type IElasticQueryVisitorContext", nameof(context));
}
string field = elasticContext.GetNonAnalyzedFieldName(node.Field, "sort");
var sort = new SortField {
Field = field
};
if (node.IsNodeOrGroupedParentNegated())
{
sort.Order = SortOrder.Descending;
}
else
{
sort.Order = SortOrder.Ascending;
}
return(sort);
}
public static QueryBase GetDefaultQuery(this IQueryNode node, IQueryVisitorContext context)
{
if (node is TermNode termNode)
{
return(termNode.GetDefaultQuery(context));
}
if (node is TermRangeNode termRangeNode)
{
return(termRangeNode.GetDefaultQuery(context));
}
if (node is ExistsNode existsNode)
{
return(existsNode.GetDefaultQuery(context));
}
if (node is MissingNode missingNode)
{
return(missingNode.GetDefaultQuery(context));
}
if (node is GroupNode groupNode)
{
return(groupNode.GetDefaultQuery(context));
}
return(null);
}
public override async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
await _writer.WriteLineAsync("Group:").ConfigureAwait(false);
_writer.Indent++;
_writer.WriteLineIf(node.IsNegated.HasValue, "IsNegated: {0}", node.IsNegated);
_writer.WriteLineIf(node.Field != null, "Field: {0}", node.Field);
_writer.WriteLineIf(node.Prefix != null, "Prefix: {0}", node.Prefix);
_writer.WriteLineIf(node.Boost != null, "Boost: {0}", node.Boost);
_writer.WriteLineIf(node.Proximity != null, "Proximity: {0}", node.Proximity);
_writer.WriteIf(node.Left != null, "Left - ");
if (node.Left != null)
{
await node.Left.AcceptAsync(this, context).ConfigureAwait(false);
}
_writer.WriteIf(node.Right != null, "Right - ");
if (node.Right != null)
{
await node.Right.AcceptAsync(this, context).ConfigureAwait(false);
}
_writer.WriteLineIf(node.Operator != GroupOperator.Default, "Operator: {0}", node.Operator);
_writer.WriteLineIf(node.HasParens, "Parens: true");
WriteData(node);
_writer.Indent--;
}
public static QueryBase GetDefaultQuery(this GroupNode node, IQueryVisitorContext context)
{
if (!(context is IElasticQueryVisitorContext elasticContext))
{
throw new ArgumentException("Context must be of type IElasticQueryVisitorContext", nameof(context));
}
if ((node.Parent == null || node.HasParens) && node is IFieldQueryNode)
{
if (node.Data.ContainsKey("match_terms"))
{
var fields = !String.IsNullOrEmpty(node.GetFullName()) ? new[] { node.GetFullName() } : elasticContext.DefaultFields;
string values = String.Join(" ", ((List <TermNode>)node.Data["match_terms"]).Select(t => t.UnescapedTerm));
if (fields.Length == 1)
{
return(new MatchQuery {
Field = fields[0],
Query = values
});
}
return(new MultiMatchQuery {
Fields = fields,
Query = values,
Type = TextQueryType.BestFields
});
}
}
return(null);
}
public static QueryValidationInfo GetValidationInfo(this IQueryVisitorContext context)
{
if (!(context is IQueryVisitorContextWithValidator validatorContext))
{
throw new ArgumentException("Context must be of type IQueryVisitorContextWithValidator", nameof(context));
}
return(validatorContext.ValidationInfo ?? (validatorContext.ValidationInfo = new QueryValidationInfo()));
}
public static Func <QueryValidationInfo, Task <bool> > GetValidator(this IQueryVisitorContext context)
{
if (!(context is IQueryVisitorContextWithValidator validatorContext))
{
throw new ArgumentException("Context must be of type IQueryVisitorContextWithValidator", nameof(context));
}
return(validatorContext.Validator);
}
public override void Visit(TermNode node, IQueryVisitorContext context)
{
if (String.IsNullOrEmpty(node.Field))
{
return;
}
_fields.Add(node.GetSort(() => node.GetDefaultSort(context)));
}
private static DateTime?GetDate(IQueryVisitorContext context, string key)
{
if (context.Data.TryGetValue(key, out var value) && value is DateTime date)
{
return(date);
}
return(null);
}
public async Task <string> GetEventFilterAsync(string query, IQueryVisitorContext context = null)
{
context = context ?? new ElasticQueryVisitorContext();
var result = await _parser.ParseAsync(query, context);
await _eventQueryVisitor.AcceptAsync(result, context);
return(result.ToString());
}
public override async Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
await base.VisitAsync(node, context).ConfigureAwait(false);
if (!(context is IElasticQueryVisitorContext elasticContext))
{
throw new ArgumentException("Context must be of type IElasticQueryVisitorContext", nameof(context));
}
QueryBase query = node.GetQuery(() => node.GetDefaultQuery(context));
QueryBase container = query;
var nested = query as NestedQuery;
if (nested != null && node.Parent != null)
{
container = null;
}
foreach (var child in node.Children.OfType <IFieldQueryNode>())
{
var childQuery = child.GetQuery(() => child.GetDefaultQuery(context));
if (childQuery == null)
{
continue;
}
var op = node.GetOperator(elasticContext.DefaultOperator);
if (child.IsNodeNegated())
{
childQuery = !childQuery;
}
if (op == Operator.Or && !String.IsNullOrEmpty(node.Prefix) && node.Prefix == "+")
{
op = Operator.And;
}
if (op == Operator.And)
{
container &= childQuery;
}
else if (op == Operator.Or)
{
container |= childQuery;
}
}
if (nested != null)
{
nested.Query = container;
node.SetQuery(nested);
}
else
{
node.SetQuery(container);
}
}
public override Task VisitAsync(GroupNode node, IQueryVisitorContext context)
{
if (!String.IsNullOrEmpty(node.Field))
{
AddField(node);
}
return(base.VisitAsync(node, context));
}
private static string GetString(IQueryVisitorContext context, string key)
{
if (context.Data.TryGetValue(key, out var value) && value is string str)
{
return(str);
}
return(null);
}
public static IncludeResolver GetIncludeResolver(this IQueryVisitorContext context)
{
if (!(context is IQueryVisitorContextWithIncludeResolver includeContext))
{
throw new ArgumentException("Context must be of type IQueryVisitorContextWithIncludeResolver", nameof(context));
}
return(includeContext.IncludeResolver);
}
