public async Task VerifyRootNestedAliasAsync()
{
var client = GetClient();
var visitor = new AliasMappingVisitor(client.Infer);
var walker = new MappingWalker(visitor);
walker.Accept(new TypeMappingDescriptor <Employee>().Properties(p => p
.Object <object>(o => o.Name("data").Properties(p1 => p1
.Keyword(f => f.Name("Profile_URL").RootAlias("url"))))));
var map = visitor.RootAliasMap;
Assert.Equal(2, map.Count);
Assert.True(map.ContainsKey("url"));
Assert.Equal("data.Profile_URL", map["url"].Name);
Assert.False(map["url"].HasChildMappings);
Assert.True(map.ContainsKey("data"));
Assert.Equal("data", map["data"].Name);
Assert.False(map["data"].HasChildMappings);
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("url:test");
var aliased = await AliasedQueryVisitor.RunAsync(result, map);
Assert.Equal("data.Profile_URL:test", aliased.ToString());
}
public async Task CanUseResolverAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested:value");
var aliased = await AliasedQueryVisitor.RunAsync(result, f => f == "field1.nested"?new GetAliasResult { Name = "field2.nested" } : null);
Assert.Equal("field2.nested:value", aliased.ToString());
}
public async Task AliasMapShouldBeAppliedToAllLevels4Async()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested:value");
var aliasMap = new AliasMap {
{ "field1.nested", "field2.other" }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2.other:value", aliased.ToString());
}
public async Task CanUseAliasMapForTopLevelAliasAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1:value");
var aliasMap = new AliasMap {
{ "field1", "field2" }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2:value", aliased.ToString());
}
public ElasticQueryParserConfiguration UseAliases(AliasResolver defaultAliasResolver, int priority = 50)
{
DefaultAliasResolver = defaultAliasResolver;
var visitor = new AliasedQueryVisitor();
QueryVisitor.AddVisitor(visitor, priority);
SortVisitor.AddVisitor(visitor, priority);
AggregationVisitor.AddVisitor(new AliasedQueryVisitor(false), priority);
return(this);
}
public async Task AliasMapShouldBeAppliedToAllLevels7Async()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested.childproperty:value");
var aliasMap = new AliasMap {
{ "field1", new AliasMapValue {
Name = "field2", ChildMap = { { "nested", "other" } }
} }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2.other.childproperty:value", aliased.ToString());
}
public async Task CanApplyRootLevelAliasMapOnNestedTermAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested.morenested:value");
var aliasMap = new AliasMap {
{ "field1", new AliasMapValue {
Name = "field2", ChildMap = { { "stuff", "other" } }
} }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2.nested.morenested:value", aliased.ToString());
}
public async Task AliasMapShouldAllowDeepAliasesAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("level1.level2.level3:(level4:value)");
var aliasMap = new AliasMap {
{ "level1", new AliasMapValue {
Name = "alias1", ChildMap = { { "level2", "alias2" }, { "level4", "alias4" } }
} }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("alias1.alias2.level3:(level4:value)", aliased.ToString());
}
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 AliasMapShouldWorkOnGroupsAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1:(nested:value OR thing:yep) another:works");
var aliasMap = new AliasMap {
{
"field1",
new AliasMapValue {
Name = "field2", ChildMap = { { "nested", "other" }, { "thing", "nice" } }
}
}
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2:(other:value OR nice:yep) another:works", aliased.ToString());
}
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(AliasedQueryVisitor.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(AliasedQueryVisitor.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);
var opt = ctx.Options.GetElasticTypeSettings();
TermToFieldVisitor.Run(result, ctx);
AliasedQueryVisitor.Run(result, _aliasMap, ctx);
var fields = GetReferencedFieldsQueryVisitor.Run(result);
// TODO: Check referenced fields against opt.AllowedSortFields
var fieldSort = GetSortFieldsVisitor.Run(result, ctx);
ctx.Search.Sort(fieldSort);
}
return(Task.CompletedTask);
}
public async Task VerifyComplexNestedAliasAsync()
{
var client = GetClient();
var visitor = new AliasMappingVisitor(client.Infer);
var walker = new MappingWalker(visitor);
walker.Accept(new TypeMappingDescriptor <Employee>().Properties(p => p
.Object <object>(o1 => o1.Name("data").Properties(p1 => p1
.Object <object>(o2 => o2.Name("@request_info").Properties(p2 => p2
.Keyword(f => f.Name("user_agent").RootAlias("useragent"))
.Text(f4 => f4.Name("@browser_major_version").RootAlias("browser.major")
.Fields(sf => sf.Keyword(s => s.Name("keyword").IgnoreAbove(256))))
.Object <object>(o3 => o3.Name("data").Properties(p3 => p3
.Keyword(f => f.Name("@is_bot").RootAlias("bot"))))))))));
var map = visitor.RootAliasMap;
Assert.Equal(4, map.Count);
Assert.True(map.ContainsKey("useragent"));
Assert.Equal("data.@request_info.user_agent", map["useragent"].Name);
Assert.False(map["useragent"].HasChildMappings);
Assert.True(map.ContainsKey("browser.major"));
Assert.Equal("data.@request_info.@browser_major_version", map["browser.major"].Name);
Assert.False(map["browser.major"].HasChildMappings);
Assert.True(map.ContainsKey("bot"));
Assert.Equal("data.@request_info.data.@is_bot", map["bot"].Name);
Assert.False(map["bot"].HasChildMappings);
Assert.True(map.ContainsKey("data"));
Assert.Equal("data", map["data"].Name);
Assert.True(map["data"].HasChildMappings);
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("useragent:test browser.major:10 bot:true");
var aliased = await AliasedQueryVisitor.RunAsync(result, map);
Assert.Equal("data.@request_info.user_agent:test data.@request_info.@browser_major_version:10 data.@request_info.data.@is_bot:true", aliased.ToString());
}
public async Task VerifySimpleAliasAsync()
{
var client = GetClient();
var visitor = new AliasMappingVisitor(client.Infer);
var walker = new MappingWalker(visitor);
walker.Accept(new TypeMappingDescriptor <Employee>().Properties(p => p
.Keyword(f => f.Name(e => e.Id).Alias("employee_id"))));
var map = visitor.RootAliasMap;
Assert.Single(map);
Assert.True(map.ContainsKey("employee_id"));
Assert.Equal("id", map["employee_id"].Name);
Assert.False(map["employee_id"].HasChildMappings);
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("employee_id:1234");
var aliased = await AliasedQueryVisitor.RunAsync(result, map);
Assert.Equal("id:1234", aliased.ToString());
}
