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 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 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 EventStackFilter()
{
var stackOnlyFields = _stackOnlyFields.Union(_stackOnlySpecialFields);
var stackFields = stackOnlyFields.Union(_stackAndEventFields);
_parser = new LuceneQueryParser();
_eventQueryVisitor = new ChainedQueryVisitor();
_eventQueryVisitor.AddVisitor(new RemoveFieldsQueryVisitor(stackOnlyFields));
_eventQueryVisitor.AddVisitor(new CleanupQueryVisitor());
_stackQueryVisitor = new ChainedQueryVisitor();
// remove everything not in the stack fields list
_stackQueryVisitor.AddVisitor(new RemoveFieldsQueryVisitor(f => !stackFields.Contains(f)));
_stackQueryVisitor.AddVisitor(new CleanupQueryVisitor());
// handles stack special fields and changing event field names to their stack equivalent
_stackQueryVisitor.AddVisitor(new StackFilterQueryVisitor());
_stackQueryVisitor.AddVisitor(new CleanupQueryVisitor());
_invertedStackQueryVisitor = new ChainedQueryVisitor();
// remove everything not in the stack fields list
_invertedStackQueryVisitor.AddVisitor(new RemoveFieldsQueryVisitor(f => !stackFields.Contains(f)));
_invertedStackQueryVisitor.AddVisitor(new CleanupQueryVisitor());
// handles stack special fields and changing event field names to their stack equivalent
_invertedStackQueryVisitor.AddVisitor(new StackFilterQueryVisitor());
_invertedStackQueryVisitor.AddVisitor(new CleanupQueryVisitor());
// inverts the filter
_invertedStackQueryVisitor.AddVisitor(new InvertQueryVisitor(_stackNonInvertedFields));
_invertedStackQueryVisitor.AddVisitor(new CleanupQueryVisitor());
}
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 static QueryProcessResult Process(string query)
{
if (String.IsNullOrWhiteSpace(query))
{
return new QueryProcessResult {
IsValid = true
}
}
;
GroupNode result;
try {
var parser = new LuceneQueryParser();
result = parser.Parse(query);
} catch (Exception ex) {
return(new QueryProcessResult {
Message = ex.Message
});
}
var validator = new QueryProcessorVisitor(_freeFields);
var context = new ElasticQueryVisitorContext();
result.Accept(validator, context);
var expandedQuery = validator.UsesDataFields ? GenerateQueryVisitor.Run(result) : query;
return(new QueryProcessResult {
IsValid = true,
UsesPremiumFeatures = validator.UsesPremiumFeatures,
ExpandedQuery = expandedQuery
});
}
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 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);
}
}
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);
}
}
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 static QueryProcessResult Validate(string query)
{
if (String.IsNullOrEmpty(query))
{
return new QueryProcessResult {
IsValid = true
}
}
;
GroupNode result;
try {
var parser = new LuceneQueryParser();
result = parser.Parse(query);
} catch (Exception ex) {
return(new QueryProcessResult {
Message = ex.Message
});
}
var validator = new QueryProcessorVisitor(_freeFields);
var context = new ElasticQueryVisitorContext();
result.Accept(validator, context);
return(new QueryProcessResult {
IsValid = true,
UsesPremiumFeatures = validator.UsesPremiumFeatures
});
}
}
public void DoubleOperatorsIsNotValid()
{
var sut = new LuceneQueryParser();
Assert.Throws <FormatException>(() => {
var result = sut.Parse("something AND OR otherthing");
});
}
public static Query BuildQuery(string query, QueryOperator defaultOperator, string defaultField, Analyzer analyzer)
{
using (CultureHelper.EnsureInvariantCulture())
{
if (UseLuceneASTParser)
{
try
{
var parser = new LuceneQueryParser();
parser.Parse(query);
var res = parser.LuceneAST.ToQuery(
new LuceneASTQueryConfiguration
{
Analayzer = analyzer,
DefaultOperator = defaultOperator,
FieldName = defaultField ?? string.Empty
});
// The parser should throw ParseException in this case.
if (res == null)
{
throw new GeoAPI.IO.ParseException("Could not parse query");
}
return(res);
}
catch (ParseException pe)
{
throw new ParseException("Could not parse: '" + query + "'", pe);
}
}
var originalQuery = query;
try
{
var queryParser = new RangeQueryParser(Version.LUCENE_29, defaultField ?? string.Empty, analyzer)
{
DefaultOperator = defaultOperator == QueryOperator.Or
? QueryParser.Operator.OR
: QueryParser.Operator.AND,
AllowLeadingWildcard = true
};
query = PreProcessComments(query);
query = PreProcessMixedInclusiveExclusiveRangeQueries(query);
query = PreProcessUntokenizedTerms(query, queryParser);
query = PreProcessSearchTerms(query);
query = PreProcessDateTerms(query, queryParser);
var generatedQuery = queryParser.Parse(query);
generatedQuery = HandleMethods(generatedQuery, analyzer);
return(generatedQuery);
}
catch (ParseException pe)
{
if (originalQuery == query)
{
throw new ParseException("Could not parse: '" + query + "'", pe);
}
throw new ParseException("Could not parse modified query: '" + query + "' original was: '" + originalQuery + "'", pe);
}
}
}
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 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 void CanParseQueryConcurrently()
{
var parser = new LuceneQueryParser();
Parallel.For(0, 100, i => {
var result = parser.Parse("criteria some:criteria blah:(more stuff)");
Assert.NotNull(result);
});
}
void CanParseThreeTermsWithDiffrentOperators2()
{
var parser = new LuceneQueryParser();
parser.Parse("foo:a AND foo:b foo:-c");
var query = parser.LuceneAST.ToQuery(config);
Assert.Equal("+foo:a +foo:b foo:c", query.ToString());
}
public void CanParseQueriesAndOutputWithNoChanges(string expectedQuery)
{
var sut = new LuceneQueryParser();
var rootNode = sut.Parse(expectedQuery);
var actualResult = rootNode.ToString();
Assert.Equal(expectedQuery, actualResult);
}
void CanParseComplexedBooleanQuery()
{
var parser = new LuceneQueryParser();
parser.Parse("(foo:a foo:b) (foo:b +d) AND (foo:(e -c) OR g)");
var query = parser.LuceneAST.ToQuery(config);
Assert.Equal("(foo:a foo:b) +(foo:b +foo:d) +((foo:e -foo:c) foo:g)", query.ToString());
}
void CanParseParenthesisInsideNextedBooleanQuery2()
{
var parser = new LuceneQueryParser();
parser.Parse("foo:a AND (foo:b -d) foo:-c");
var query = parser.LuceneAST.ToQuery(config);
Assert.Equal("+foo:a +(foo:b -foo:d) foo:c", query.ToString());
}
public void MultipleOperatorsIsNotValid()
{
var sut = new LuceneQueryParser();
Assert.Throws <FormatException>(() => {
var result = sut.Parse("something AND NOT OR otherthing");
var ast = DebugQueryVisitor.Run(result);
});
}
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 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 void CanParseNotBeforeParens()
{
var sut = new LuceneQueryParser();
var result = sut.Parse("NOT (dog parrot)");
Assert.IsType <GroupNode>(result.Left);
Assert.True((result.Left as GroupNode).HasParens);
Assert.True((result.Left as GroupNode).IsNegated);
}
public void UnterminatedParensIsNotValid()
{
var sut = new LuceneQueryParser();
var ex = Assert.Throws <FormatException>(() => {
var result = sut.Parse("(something");
});
Assert.Contains("Missing closing paren ')' for group expression", ex.Message);
}
public void PrefixWithoutImmediateExpressionIsInvalid()
{
var sut = new LuceneQueryParser();
var ex = Assert.Throws <FormatException>(() => {
var result = sut.Parse("something + other");
var ast = DebugQueryVisitor.Run(result);
});
Assert.Contains("Unexpected character '+'.", ex.Message);
}
public void DoubleUnterminatedQuotedStringIsNotValid()
{
var sut = new LuceneQueryParser();
var ex = Assert.Throws <FormatException>(() => {
var result = sut.Parse("\"something\"\"");
var ast = DebugQueryVisitor.Run(result);
});
Assert.Contains("Unexpected character", ex.Message);
}
public void CanHandleUnterminatedRegex()
{
var sut = new LuceneQueryParser();
var ex = Assert.Throws <FormatException>(() => {
var result = sut.Parse(@"/\(\[A-Za-z\/\]+\).*?");
var ast = DebugQueryVisitor.Run(result);
});
Assert.Contains("Unterminated regex", ex.Message);
}
