public async Task CanSkipIncludes()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("outter @include:other @skipped:(other stuff @include:other)");
var includes = new Dictionary <string, string> {
{ "other", "field:value" },
{ "nested", "field:value @include:other" }
};
var resolved = await IncludeVisitor.RunAsync(result, includes, shouldSkipInclude : (n, ctx) => true);
Assert.Equal("outter @include:other @skipped:(other stuff @include:other)", resolved.ToString());
resolved = await IncludeVisitor.RunAsync(result, includes, shouldSkipInclude : ShouldSkipInclude);
Assert.Equal("outter (field:value) @skipped:(other stuff @include:other)", resolved.ToString());
resolved = await IncludeVisitor.RunAsync(result, includes, shouldSkipInclude : (n, ctx) => !ShouldSkipInclude(n, ctx));
Assert.Equal("outter (field:value) @skipped:(other stuff (field:value))", resolved.ToString());
var nestedResult = await parser.ParseAsync("outter @skipped:(other stuff @include:nested)");
resolved = await IncludeVisitor.RunAsync(nestedResult, includes, shouldSkipInclude : ShouldSkipInclude);
Assert.Equal("outter @skipped:(other stuff @include:nested)", resolved.ToString());
}
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 static async Task <EventStackFilterQueryResult> RunAsync(string query, EventStackFilterQueryMode queryMode, IQueryVisitorContext context = null)
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync(query, context).AnyContext();
return(await RunAsync(result, queryMode, context).AnyContext());
}
public async Task CanUseAliasMapForTopLevelAliasAsync() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1:value");
var aliasMap = new FieldMap { { "field1", "field2" } };
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2:value", aliased.ToString());
}
public async Task CanParseFieldRegex()
{
string query = @"myfield:/\(\[A-Za-z\]+\).*?/";
#if ENABLE_TRACING
var tracer = new LoggingTracer(_logger, reportPerformance: true);
#else
var tracer = NullTracer.Instance;
#endif
var parser = new LuceneQueryParser {
Tracer = tracer
};
try {
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
var groupNode = result as GroupNode;
Assert.NotNull(groupNode);
var leftNode = groupNode.Left as TermNode;
Assert.NotNull(leftNode);
Assert.Equal("myfield", leftNode.Field);
Assert.True(leftNode.IsRegexTerm);
} catch (FormatException ex) {
var cursor = ex.Data["cursor"] as Cursor;
throw new FormatException($"[{cursor.Line}:{cursor.Column}] {ex.Message}", ex);
}
}
public async Task CanParseEscapedQuery(string escaped)
{
// https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html#_reserved_characters
// + - && || ! ( ) { } [ ] ^ " ~ * ? : \ /
string query = @"\" + escaped;
#if ENABLE_TRACING
var tracer = new LoggingTracer(_logger, reportPerformance: true);
#else
var tracer = NullTracer.Instance;
#endif
var parser = new LuceneQueryParser {
Tracer = tracer
};
try {
_logger.LogInformation($"Attempting: {escaped}");
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
} catch (FormatException ex) {
var cursor = ex.Data["cursor"] as Cursor;
throw new FormatException($"[{cursor.Line}:{cursor.Column}] {ex.Message}", ex);
}
}
public async Task CanUseForwardSlashes()
{
string query = @"hey/now";
#if ENABLE_TRACING
var tracer = new LoggingTracer(_logger, reportPerformance: true);
#else
var tracer = NullTracer.Instance;
#endif
var parser = new LuceneQueryParser {
Tracer = tracer
};
try {
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
} catch (FormatException ex) {
_logger.LogInformation(tracer.ToString());
var cursor = ex.Data["cursor"] as Cursor;
throw new FormatException($"[{cursor.Line}:{cursor.Column}] {ex.Message}", ex);
}
}
private async Task ParseAndValidateQuery(string query, string expected, bool isValid)
{
#if ENABLE_TRACING
var tracer = new LoggingTracer(_logger, reportPerformance: true);
#else
var tracer = NullTracer.Instance;
#endif
var parser = new LuceneQueryParser {
Tracer = tracer
};
IQueryNode result;
try {
result = await parser.ParseAsync(query);
} catch (FormatException ex) {
Assert.False(isValid, ex.Message);
return;
}
string nodes = await DebugQueryVisitor.RunAsync(result);
_logger.LogInformation(nodes);
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(expected, generatedQuery);
}
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 AliasMapShouldBeAppliedToAllLevels2Async() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("(field1.nested:value field1.another:blah)");
var aliasMap = new FieldMap {
{ "field1.nested", "field2.other" }
};
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("(field2.other:value field1.another:blah)", aliased.ToString());
}
public async Task AliasMapShouldBeAppliedToAllLevels8Async() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested.childproperty:value");
var aliasMap = new FieldMap {
{ "field1.nested.childproperty", "field2.other.childproperty" }
};
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2.other.childproperty:value", aliased.ToString());
}
public async Task AliasMapShouldAllowDeepAliasesAsync() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("level1.level2.level3.level4:value");
var aliasMap = new FieldMap {
{ "level1.level2.level3.level4", "alias1.alias2.level3.level4" }
};
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("alias1.alias2.level3.level4:value", 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 CanApplyRootLevelAliasMapOnNestedTermAsync() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested.morenested:value");
var aliasMap = new FieldMap {
{ "field1.nested.morenested", "field2.nested.morenested" }
};
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field2.nested.morenested:value", aliased.ToString());
}
public async Task AliasMapShouldWorkOnGroupsAsync() {
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("(field1.nested:value OR field1.thing:yep) another:works");
var aliasMap = new FieldMap {
{ "field1.nested", "field2.other" },
{ "field1.thing", "field2.nice" }
};
var aliased = await FieldResolverQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("(field2.other:value OR field2.nice:yep) another:works", aliased.ToString());
}
public async Task CanExpandIncludesAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("@include:other");
var includes = new Dictionary <string, string> {
{ "other", "field:value" }
};
var resolved = await IncludeVisitor.RunAsync(result, includes);
Assert.Equal("(field:value)", resolved.ToString());
}
public async Task AliasMapShouldBeAppliedToAllLevels3Async()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1.nested:value");
var aliasMap = new AliasMap {
{ "nested", "field2" }
};
var aliased = await AliasedQueryVisitor.RunAsync(result, aliasMap);
Assert.Equal("field1.nested:value", aliased.ToString());
}
public async Task CanExpandIncludesWithOtherCriteriaAndGroupingAsync()
{
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync("field1:value1 OR (@include:other field2:value2)");
var includes = new Dictionary <string, string> {
{ "other", "field:value" }
};
var resolved = await IncludeVisitor.RunAsync(result, includes);
Assert.Equal("field1:value1 OR ((field:value) field2:value2)", resolved.ToString());
}
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 async Task CanGenerateSingleQueryAsync()
{
string query = "datehistogram:(date~2^-5\\:30 min:date max:date)";
var parser = new LuceneQueryParser();
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
await new AssignAggregationTypeVisitor().AcceptAsync(result, null);
_logger.LogInformation(DebugQueryVisitor.Run(result));
}
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 override async Task VisitAsync(TermNode node, IQueryVisitorContext context)
{
if (node.Field != "@include" || (_shouldSkipInclude != null && _shouldSkipInclude(node, context)))
{
return;
}
var includeResolver = context.GetIncludeResolver();
if (includeResolver == null)
{
return;
}
string includedQuery = await includeResolver(node.Term).ConfigureAwait(false);
if (String.IsNullOrEmpty(includedQuery))
{
return;
}
var result = (GroupNode)await _parser.ParseAsync(includedQuery).ConfigureAwait(false);
result.HasParens = true;
await VisitAsync(result, context).ConfigureAwait(false);
var parent = node.Parent as GroupNode;
if (parent == null)
{
return;
}
if (parent.Left == node)
{
parent.Left = result;
}
else if (parent.Right == node)
{
parent.Right = result;
}
}
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 CanUseForwardSlashes()
{
string query = @"hey/now";
var tracer = new StringBuilderTrace();
var parser = new LuceneQueryParser {
//Tracer = tracer
};
try {
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
} catch (FormatException ex) {
_logger.LogInformation(tracer.ToString());
var cursor = ex.Data["cursor"] as Cursor;
throw new FormatException($"[{cursor.Line}:{cursor.Column}] {ex.Message}", ex);
}
}
public async Task CanGenerateQueryAsync(string query, string expected, bool isValid)
{
var parser = new LuceneQueryParser();
Log.MinimumLevel = LogLevel.Information;
IQueryNode result;
try {
result = await parser.ParseAsync(query);
} catch (Exception ex) {
Assert.False(isValid, ex.Message);
return;
}
string nodes = await DebugQueryVisitor.RunAsync(result);
_logger.LogInformation(nodes);
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(expected, generatedQuery);
}
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());
}
public async Task CanParseEscapedQuery(string escaped)
{
// https://lucene.apache.org/core/2_9_4/queryparsersyntax.html#Escaping%20Special%20Characters
// + - && || ! ( ) { } [ ] ^ " ~ * ? : \
string query = @"\" + escaped;
var tracer = new StringBuilderTrace();
var parser = new LuceneQueryParser {
//Tracer = tracer
};
try {
_logger.LogInformation($"Attempting: {escaped}");
var result = await parser.ParseAsync(query);
_logger.LogInformation(await DebugQueryVisitor.RunAsync(result));
string generatedQuery = await GenerateQueryVisitor.RunAsync(result);
Assert.Equal(query, generatedQuery);
} catch (FormatException ex) {
_logger.LogInformation(tracer.ToString());
var cursor = ex.Data["cursor"] as Cursor;
throw new FormatException($"[{cursor.Line}:{cursor.Column}] {ex.Message}", ex);
}
}