public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var ids = ctx.Source.GetIds();
if (ids.Count > 0)
{
ctx.Filter &= new IdsQuery {
Values = ids.Select(id => new Nest.Id(id))
}
}
;
var excludesIds = ctx.Source.GetExcludedIds();
if (excludesIds.Count > 0)
{
ctx.Filter &= !new IdsQuery {
Values = excludesIds.Select(id => new Nest.Id(id))
}
}
;
return(Task.CompletedTask);
}
}
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var childQuery = ctx.GetSourceAs <IChildQuery>();
if (childQuery?.ChildQuery == null)
{
return;
}
if (String.IsNullOrEmpty(childQuery.ChildQuery.Type))
{
throw new ArgumentException("Must specify a child type for child queries.");
}
// this should pass an options object that is for the child index type
var childContext = new QueryBuilderContext <T>(childQuery.ChildQuery, ctx.Options, null, ctx, ContextType.Child);
await _queryBuilder.BuildAsync(childContext).AnyContext();
if ((childContext.Query == null || childContext.Query.IsConditionless) &&
(childContext.Filter == null || childContext.Filter.IsConditionless))
{
return;
}
ctx.Filter &= new HasChildFilter {
Query = childContext.Query,
Filter = childContext.Filter,
Type = childQuery.ChildQuery.Type
};
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var dateRanges = ctx.Source.GetDateRanges();
if (dateRanges.Count <= 0)
{
return(Task.CompletedTask);
}
var elasticQueryOptions = ctx.Options.GetElasticTypeSettings();
foreach (var dateRange in dateRanges.Where(dr => dr.UseDateRange))
{
string fieldName = dateRange.Field?.Name;
if (elasticQueryOptions?.IndexType != null && !String.IsNullOrEmpty(fieldName))
{
fieldName = elasticQueryOptions.IndexType.GetFieldName(fieldName);
}
ctx.Filter &= new DateRangeQuery {
Field = fieldName ?? dateRange.Field,
GreaterThanOrEqualTo = dateRange.GetStartDate(),
LessThanOrEqualTo = dateRange.GetEndDate()
};
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var dateRanges = ctx.Source.GetDateRanges();
if (dateRanges.Count <= 0)
{
return(Task.CompletedTask);
}
var resolver = ctx.GetMappingResolver();
foreach (var dateRange in dateRanges.Where(dr => dr.UseDateRange))
{
var rangeQuery = new DateRangeQuery {
Field = resolver.ResolveFieldName(dateRange.Field)
};
if (dateRange.UseStartDate)
{
rangeQuery.GreaterThanOrEqualTo = dateRange.GetStartDate();
}
if (dateRange.UseEndDate)
{
rangeQuery.LessThanOrEqualTo = dateRange.GetEndDate();
}
if (!String.IsNullOrEmpty(dateRange.TimeZone))
{
rangeQuery.TimeZone = dateRange.TimeZone;
}
ctx.Filter &= rangeQuery;
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var childQuery = ctx.Source.GetChildQuery();
if (childQuery == null)
{
return;
}
var childContext = new QueryBuilderContext <T>(childQuery.Query, ctx.Options, null, ctx, ContextType.Child);
await _queryBuilder.BuildAsync(childContext).AnyContext();
if ((childContext.Query == null || ((IQueryContainer)childContext.Query).IsConditionless) &&
(childContext.Filter == null || ((IQueryContainer)childContext.Filter).IsConditionless))
{
return;
}
ctx.Filter &= new HasChildQuery {
Type = childQuery.Type,
Query = new BoolQuery {
Must = new QueryContainer[] { childContext.Query },
Filter = new QueryContainer[] { childContext.Filter },
}
};
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
int limit = ctx.Options.GetLimit();
if (limit >= ctx.Options.GetMaxLimit() || ctx.Options.ShouldUseSnapshotPaging())
{
ctx.Search.Size(limit);
}
else
{
// add 1 to limit if not snapshot paging so we can know if we have more results
ctx.Search.Size(limit + 1);
}
// can only use search_after or skip
if (ctx.Options.HasSearchAfter())
{
ctx.Search.SearchAfter(ctx.Options.GetSearchAfter());
}
else if (ctx.Options.HasSearchBefore())
{
ctx.Search.SearchAfter(ctx.Options.GetSearchBefore());
}
else if (ctx.Options.ShouldUseSkip())
{
ctx.Search.Skip(ctx.Options.GetSkip());
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
foreach (var builder in _partBuilders)
{
await builder.BuildAsync(ctx).AnyContext();
}
}
public static async Task <QueryContainer> BuildQueryAsync <T>(this IElasticQueryBuilder builder, IRepositoryQuery query, ICommandOptions options, SearchDescriptor <T> search) where T : class, new()
{
var ctx = new QueryBuilderContext <T>(query, options, search);
await builder.BuildAsync(ctx).AnyContext();
return(new BoolQuery {
Must = new[] { ctx.Query },
Filter = new[] { ctx.Filter ?? new MatchAllQuery() }
});
}
public static async Task <QueryContainer> BuildQueryAsync <T>(this IElasticQueryBuilder builder, IRepositoryQuery query, IQueryOptions options, SearchDescriptor <T> search) where T : class, new()
{
var ctx = new QueryBuilderContext <T>(query, options, search);
await builder.BuildAsync(ctx).AnyContext();
return(new FilteredQuery {
Filter = ctx.Filter,
Query = ctx.Query
});
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var parentQuery = ctx.GetSourceAs <IParentQuery>();
bool hasIds = ctx.GetSourceAs <IIdentityQuery>()?.Ids.Count > 0;
if (parentQuery == null)
{
return;
}
var options = ctx.GetOptionsAs <IElasticQueryOptions>();
IQueryOptions parentOptions = null;
if (options != null && options.HasParent == false)
{
return;
}
if (options != null && options.ParentSupportsSoftDeletes && hasIds == false)
{
if (parentQuery.ParentQuery == null)
{
parentQuery.ParentQuery = new ParentQuery();
}
var parentType = options.ChildType.GetParentIndexType();
if (parentType == null)
{
throw new ApplicationException("ParentIndexTypeName on child index type must match the name of the parent type.");
}
parentOptions = new ElasticQueryOptions(parentType);
}
if (parentQuery.ParentQuery == null)
{
return;
}
var parentContext = new QueryBuilderContext <object>(parentQuery.ParentQuery, parentOptions, null, ctx, ContextType.Parent);
await _queryBuilder.BuildAsync(parentContext).AnyContext();
if ((parentContext.Query == null || parentContext.Query.IsConditionless) &&
(parentContext.Filter == null || parentContext.Filter.IsConditionless))
{
return;
}
ctx.Filter &= new HasParentFilter {
Query = parentContext.Query,
Filter = parentContext.Filter,
Type = options?.ChildType?.GetParentIndexType().Name
};
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
// dont add filter to child query system filters
if (ctx.Type == ContextType.Child)
{
return(Task.CompletedTask);
}
// get soft delete mode, use parent query as default if it exists
var mode = ctx.Source.GetSoftDeleteMode(ctx.Parent?.Source?.GetSoftDeleteMode() ?? SoftDeleteQueryMode.ActiveOnly);
// no filter needed if we want all
if (mode == SoftDeleteQueryMode.All)
{
return(Task.CompletedTask);
}
// check to see if the model supports soft deletes
var options = ctx.Options.GetElasticTypeSettings();
if (options == null || !options.SupportsSoftDeletes)
{
return(Task.CompletedTask);
}
// if we are querying for specific ids then we don't need a deleted filter
var ids = ctx.Source.GetIds();
if (ids.Count > 0)
{
return(Task.CompletedTask);
}
string fieldName = options.IndexType?.GetFieldName(IsDeleted) ?? IsDeleted;
if (mode == SoftDeleteQueryMode.ActiveOnly)
{
ctx.Filter &= new TermQuery {
Field = fieldName, Value = false
}
}
;
else if (mode == SoftDeleteQueryMode.DeletedOnly)
{
ctx.Filter &= new TermQuery {
Field = fieldName, Value = true
}
}
;
return(Task.CompletedTask);
}
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
if (_queryBuilders == null)
{
Interlocked.CompareExchange(ref _queryBuilders, _registrations.OrderBy(v => v.Priority).Select(r => r.Builder).ToArray(), null);
}
foreach (var builder in _queryBuilders)
{
await builder.BuildAsync(ctx).AnyContext();
}
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var elasticQuery = ctx.GetSourceAs <IElasticFilterQuery>();
if (elasticQuery?.ElasticFilter == null)
{
return(Task.CompletedTask);
}
ctx.Filter &= elasticQuery.ElasticFilter;
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var searchQuery = ctx.GetSourceAs <ISearchQuery>();
if (searchQuery == null)
{
return(Task.CompletedTask);
}
if (!String.IsNullOrEmpty(searchQuery.Filter))
{
var result = _parser.Parse(searchQuery.Filter);
searchQuery.Filter = GenerateQueryVisitor.Run(AliasedQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Filter &= new QueryFilter {
Query = new QueryStringQuery {
Query = searchQuery.Filter,
DefaultOperator = Operator.And,
AnalyzeWildcard = false
}.ToContainer()
};
}
if (!String.IsNullOrEmpty(searchQuery.Criteria))
{
var result = _parser.Parse(searchQuery.Criteria);
searchQuery.Criteria = GenerateQueryVisitor.Run(AliasedQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Query &= new QueryStringQuery {
Query = searchQuery.Criteria,
DefaultOperator = searchQuery.DefaultCriteriaOperator == SearchOperator.Or ? Operator.Or : Operator.And,
AnalyzeWildcard = true
};
}
if (!String.IsNullOrEmpty(searchQuery.Sort))
{
var result = _parser.Parse(searchQuery.Sort);
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
TermToFieldVisitor.Run(result, ctx);
AliasedQueryVisitor.Run(result, _aliasMap, ctx);
var fields = GetReferencedFieldsQueryVisitor.Run(result);
// TODO: Check referenced fields against opt.AllowedSortFields
var sort = GetSortFieldsVisitor.Run(result, ctx);
ctx.Search.Sort(sort);
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var options = ctx.Options.GetElasticTypeSettings();
if (options.HasParent == false)
{
return;
}
var parentQuery = ctx.Source.GetParentQuery();
bool hasIds = ctx.Source.GetIds().Count > 0;
// even if no parent query has been set, run it through to get soft delete filter
if (options.ParentSupportsSoftDeletes && hasIds == false && parentQuery == null)
{
parentQuery = new RepositoryQuery();
}
if (parentQuery == null)
{
return;
}
var parentType = options.ChildType.GetParentIndexType();
if (parentType == null)
{
throw new ApplicationException("ParentIndexTypeName on child index type must match the name of the parent type.");
}
var parentOptions = new CommandOptions().ElasticType(parentType);
var parentContext = new QueryBuilderContext <object>(parentQuery, parentOptions, null, ctx, ContextType.Parent);
await _queryBuilder.BuildAsync(parentContext).AnyContext();
if ((parentContext.Query == null || ((IQueryContainer)parentContext.Query).IsConditionless) &&
(parentContext.Filter == null || ((IQueryContainer)parentContext.Filter).IsConditionless))
{
return;
}
ctx.Filter &= new HasParentQuery {
Type = parentType.Name,
Query = new BoolQuery {
Must = new QueryContainer[] { parentContext.Query },
Filter = new QueryContainer[] { parentContext.Filter },
}
};
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
// add 1 to limit if not snapshot paging so we can know if we have more results
if (ctx.Options.HasPageLimit())
{
ctx.Search.Size(ctx.Options.GetLimit() + (ctx.Options.ShouldUseSnapshotPaging() == false ? 1 : 0));
}
if (ctx.Options.ShouldUseSkip())
{
ctx.Search.Skip(ctx.Options.GetSkip());
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var elasticFilters = ctx.Source.GetElasticFilters();
if (elasticFilters.Count == 0)
{
return(Task.CompletedTask);
}
foreach (var filter in elasticFilters)
{
ctx.Filter &= filter;
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var sortFields = ctx.Source.GetSorts();
if (sortFields.Count <= 0)
{
return(Task.CompletedTask);
}
//var opt = ctx.GetOptionsAs<IElasticQueryOptions>();
//foreach (var sort in sortableQuery.SortFields.Where(s => CanSortByField(opt?.AllowedSortFields, s.Field)))
// ctx.Search.Sort(s => s.Field(sort.Field, sort.Order == Foundatio.Repositories.Models.SortOrder.Ascending ? SortOrder.Ascending : SortOrder.Descending));
ctx.Search.Sort(sortFields);
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var sortFields = ctx.Source.GetSorts();
if (sortFields.Count <= 0)
{
return(Task.CompletedTask);
}
var resolver = ctx.GetMappingResolver();
sortFields = resolver.GetResolvedFields(sortFields);
ctx.Search.Sort(sortFields);
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
string filter = ctx.Source.GetFilterExpression();
string search = ctx.Source.GetSearchExpression();
string sort = ctx.Source.GetSortExpression();
if (!String.IsNullOrEmpty(filter))
{
var result = _parser.Parse(filter);
filter = GenerateQueryVisitor.Run(FieldResolverQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Filter &= new QueryStringQuery {
Query = filter,
DefaultOperator = Operator.And,
AnalyzeWildcard = false
};
}
if (!String.IsNullOrEmpty(search))
{
var result = _parser.Parse(search);
search = GenerateQueryVisitor.Run(FieldResolverQueryVisitor.Run(result, _aliasMap, ctx), ctx);
ctx.Query &= new QueryStringQuery {
Query = search,
DefaultOperator = ctx.Source.GetSearchExpressionDefaultOperator() == SearchOperator.Or ? Operator.Or : Operator.And,
AnalyzeWildcard = true
};
}
if (!String.IsNullOrEmpty(sort))
{
var result = _parser.Parse(sort);
TermToFieldVisitor.Run(result, ctx);
FieldResolverQueryVisitor.Run(result, _aliasMap, ctx);
var fields = GetReferencedFieldsQueryVisitor.Run(result);
// TODO: Check referenced fields against opt.AllowedSortFields
var sortFields = GetSortFieldsVisitor.Run(result, ctx).ToList();
ctx.Search.Sort(sortFields);
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var includes = ctx.Source.GetIncludes();
if (includes.Count > 0)
{
ctx.Search.Source(s => s.Includes(i => i.Fields(includes.ToArray())));
}
var excludes = ctx.Source.GetExcludes();
if (excludes.Count > 0)
{
ctx.Search.Source(s => s.Excludes(i => i.Fields(excludes.ToArray())));
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var childQueries = ctx.Source.GetChildQueries();
if (childQueries.Count == 0)
{
return;
}
var index = ctx.Options.GetElasticIndex();
foreach (var childQuery in childQueries)
{
var childOptions = ctx.Options.Clone();
childOptions.DocumentType(childQuery.GetDocumentType());
var childContext = new QueryBuilderContext <object>(childQuery, childOptions, null);
await index.QueryBuilder.BuildAsync(childContext);
if (childContext.Filter != null && ((IQueryContainer)childContext.Filter).IsConditionless == false)
{
ctx.Filter &= new HasChildQuery {
Type = childQuery.GetDocumentType(),
Query = new BoolQuery {
Filter = new[] { childContext.Filter }
}
}
}
;
if (childContext.Query != null && ((IQueryContainer)childContext.Query).IsConditionless == false)
{
ctx.Query &= new HasChildQuery {
Type = childQuery.GetDocumentType(),
Query = new BoolQuery {
Must = new[] { childContext.Query }
}
}
}
;
}
}
}
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var fieldValuesQuery = ctx.GetSourceAs <IFieldConditionsQuery>();
if (fieldValuesQuery?.FieldConditions == null || fieldValuesQuery.FieldConditions.Count <= 0)
{
return(Task.CompletedTask);
}
foreach (var fieldValue in fieldValuesQuery.FieldConditions)
{
switch (fieldValue.Operator)
{
case ComparisonOperator.Equals:
ctx.Filter &= new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
};
break;
case ComparisonOperator.NotEquals:
ctx.Filter &= new NotFilter {
Filter = FilterContainer.From(new TermFilter {
Field = fieldValue.Field, Value = fieldValue.Value
})
};
break;
case ComparisonOperator.IsEmpty:
ctx.Filter &= new MissingFilter {
Field = fieldValue.Field
};
break;
case ComparisonOperator.HasValue:
ctx.Filter &= new ExistsFilter {
Field = fieldValue.Field
};
break;
}
}
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var selectedFieldsQuery = ctx.GetSourceAs <ISelectedFieldsQuery>();
if (selectedFieldsQuery?.SelectedFields?.Count > 0)
{
ctx.Search.Source(s => s.Include(selectedFieldsQuery.SelectedFields.ToArray()));
return(Task.CompletedTask);
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt?.DefaultExcludes?.Count > 0)
{
ctx.Search.Source(s => s.Exclude(opt.DefaultExcludes.ToArray()));
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var aggregationQuery = ctx.GetSourceAs <IAggregationQuery>();
if (String.IsNullOrEmpty(aggregationQuery?.Aggregations))
{
return;
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
if (opt?.AllowedAggregationFields?.Count > 0 && !(await GetAggregationFieldsAsync(aggregationQuery.Aggregations).AnyContext()).All(f => opt.AllowedAggregationFields.Contains(f)))
{
throw new InvalidOperationException("All aggregation fields must be allowed.");
}
var result = await _parser.BuildAggregationsAsync(aggregationQuery.Aggregations, ctx).AnyContext();
ctx.Search.Aggregations(result);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var sortableQuery = ctx.GetSourceAs <ISortableQuery>();
if (sortableQuery?.SortFields == null || sortableQuery.SortFields.Count <= 0)
{
return(Task.CompletedTask);
}
var opt = ctx.GetOptionsAs <IElasticQueryOptions>();
// TODO: Check SortFields against opt.AllowedSortFields
//foreach (var sort in sortableQuery.SortFields.Where(s => CanSortByField(opt?.AllowedSortFields, s.Field.ToString())))
// ctx.Search.Sort(s => s.OnField(sort.Field)
// .Order(sort.Order == Foundatio.Repositories.Models.SortOrder.Ascending ? SortOrder.Ascending : SortOrder.Descending));
ctx.Search.Sort(sortableQuery.SortFields);
return(Task.CompletedTask);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var dateRangeQuery = ctx.GetSourceAs <IDateRangeQuery>();
if (dateRangeQuery?.DateRanges == null || dateRangeQuery.DateRanges.Count <= 0)
{
return(Task.CompletedTask);
}
foreach (var dateRange in dateRangeQuery.DateRanges.Where(dr => dr.UseDateRange))
{
ctx.Filter &= new RangeFilter {
Field = dateRange.Field,
GreaterThanOrEqualTo = dateRange.GetStartDate().ToString("o"),
LowerThanOrEqualTo = dateRange.GetEndDate().ToString("O")
};
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var elasticOptions = ctx.Options.GetElasticTypeSettings();
if (elasticOptions?.IndexType?.QueryParser == null)
{
return;
}
string aggregations = ctx.Source.GetAggregationsExpression();
if (String.IsNullOrEmpty(aggregations))
{
return;
}
var result = await elasticOptions.IndexType.QueryParser.BuildAggregationsAsync(aggregations, ctx).AnyContext();
ctx.Search.Aggregations(result);
}
public Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var pagableQuery = ctx.GetSourceAs <IPagableQuery>();
if (pagableQuery == null)
{
return(Task.CompletedTask);
}
// add 1 to limit if not auto paging so we can know if we have more results
if (pagableQuery.ShouldUseLimit())
{
ctx.Search.Size(pagableQuery.GetLimit() + (pagableQuery.ShouldUseSnapshotPaging() == false ? 1 : 0));
}
if (pagableQuery.ShouldUseSkip())
{
ctx.Search.Skip(pagableQuery.GetSkip());
}
return(Task.CompletedTask);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
string filter = ctx.Source.GetFilterExpression();
string search = ctx.Source.GetSearchExpression();
string sort = ctx.Source.GetSortExpression();
// NOTE: Calling UseScoring here to keep the query from being wrapped in a filter which happens ElasticQueryBuilderExtensions.BuildQuery
if (!String.IsNullOrEmpty(filter))
{
ctx.Filter &= await _parser.BuildQueryAsync(filter, ctx.SetDefaultOperator(Operator.And).UseScoring()).AnyContext();
}
if (!String.IsNullOrEmpty(search))
{
ctx.Query &= await _parser.BuildQueryAsync(search, ctx.SetDefaultOperator(Operator.Or).UseScoring()).AnyContext();
}
if (!String.IsNullOrEmpty(sort))
{
ctx.Search.Sort(await _parser.BuildSortAsync(sort, ctx).AnyContext());
}
}
