/// <summary>
/// Builds a new <see cref="RegexpQuery"/> instance
/// </summary>
/// <param name="regexp">Regexp term</param>
/// <returns>new <see cref="RegexpQuery"/> instance</returns>
protected internal virtual Query NewRegexpQuery(Term regexp)
{
RegexpQuery query = new RegexpQuery(regexp);
query.MultiTermRewriteMethod = MultiTermRewriteMethod;
return(query);
}
public virtual void TestNoSuchMultiTermsInOr()
{
//test to make sure non existent multiterms aren't throwing null pointer exceptions
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(fuzzyNoSuch);
SpanQuery term = new SpanTermQuery(new Term("field", "brown"));
SpanOrQuery near = new SpanOrQuery(new SpanQuery[] { term, spanNoSuch });
Assert.AreEqual(1, searcher.Search(near, 10).TotalHits);
//flip
near = new SpanOrQuery(new SpanQuery[] { spanNoSuch, term });
Assert.AreEqual(1, searcher.Search(near, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(wcNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanWCNoSuch });
Assert.AreEqual(1, searcher.Search(near, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(rgxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanRgxNoSuch });
Assert.AreEqual(1, searcher.Search(near, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(prfxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanPrfxNoSuch });
Assert.AreEqual(1, searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch });
Assert.AreEqual(0, searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch, spanPrfxNoSuch });
Assert.AreEqual(0, searcher.Search(near, 10).TotalHits);
}
public virtual void TestNoSuchMultiTermsInSpanFirst()
{
//this hasn't been a problem
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(fuzzyNoSuch);
SpanQuery spanFirst = new SpanFirstQuery(spanNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(wcNoSuch);
spanFirst = new SpanFirstQuery(spanWCNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(rgxNoSuch);
spanFirst = new SpanFirstQuery(spanRgxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(prfxNoSuch);
spanFirst = new SpanFirstQuery(spanPrfxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
}
public void TestOneRegexp()
{
Directory dir = NewDirectory();
// use simpleanalyzer for more natural tokenization (else "test." is a token)
Analyzer analyzer = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true);
IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
iwc.SetMergePolicy(NewLogMergePolicy());
RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, iwc);
FieldType offsetsType = new FieldType(TextField.TYPE_STORED);
offsetsType.IndexOptions = (IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
Field body = new Field("body", "", offsetsType);
Document doc = new Document();
doc.Add(body);
body.SetStringValue("This is a test.");
iw.AddDocument(doc);
body.SetStringValue("Test a one sentence document.");
iw.AddDocument(doc);
IndexReader ir = iw.Reader;
iw.Dispose();
IndexSearcher searcher = NewSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighterAnalyzerHelper(analyzer);
//PostingsHighlighter highlighter = new PostingsHighlighter() {
// @Override
// protected Analyzer getIndexAnalyzer(String field)
//{
// return analyzer;
//}
// };
Query query = new RegexpQuery(new Term("body", "te.*"));
TopDocs topDocs = searcher.Search(query, null, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.TotalHits);
String[] snippets = highlighter.Highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.Length);
assertEquals("This is a <b>test</b>.", snippets[0]);
assertEquals("<b>Test</b> a one sentence document.", snippets[1]);
// wrong field
BooleanQuery bq = new BooleanQuery();
bq.Add(new MatchAllDocsQuery(), Occur.SHOULD);
bq.Add(new RegexpQuery(new Term("bogus", "te.*")), Occur.SHOULD);
topDocs = searcher.Search(bq, null, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.TotalHits);
snippets = highlighter.Highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.Length);
assertEquals("This is a test.", snippets[0]);
assertEquals("Test a one sentence document.", snippets[1]);
ir.Dispose();
dir.Dispose();
}
public void Export_Omits_Field_If_Not_Provided()
{
var query = new RegexpQuery("regex");
var expected = JsonConvert.SerializeObject(new
{
regexp = "regex"
}, Formatting.None);
Assert.Equal(expected, query.Export().ToString(Formatting.None));
}
public void TestNullPointerException()
{
RegexpQuery regex = new RegexpQuery(new Term("field", "worl."));
SpanQuery wrappedquery = new SpanMultiTermQueryWrapper <RegexpQuery>(regex);
MemoryIndex mindex = new MemoryIndex(Random().nextBoolean(), Random().nextInt(50) * 1024 * 1024);
mindex.AddField("field", new MockAnalyzer(Random()).GetTokenStream("field", "hello there"));
// This throws an NPE
assertEquals(0, mindex.Search(wrappedquery), 0.00001f);
}
public void TestPassesIfWrapped()
{
RegexpQuery regex = new RegexpQuery(new Term("field", "worl."));
SpanQuery wrappedquery = new SpanOrQuery(new SpanMultiTermQueryWrapper <RegexpQuery>(regex));
MemoryIndex mindex = new MemoryIndex(Random.nextBoolean(), Random.nextInt(50) * 1024 * 1024);
mindex.AddField("field", new MockAnalyzer(Random).GetTokenStream("field", "hello there"));
// This passes though
assertEquals(0, mindex.Search(wrappedquery), 0.00001f);
}
public void Export_Returns_Valud_Json()
{
var query = new RegexpQuery("regex")
.Field("field");
var expected = JsonConvert.SerializeObject(new
{
regexp = "regex",
field = "field"
}, Formatting.None);
Assert.Equal(expected, query.Export().ToString(Formatting.None));
}
public virtual Query Build(IQueryNode queryNode)
{
RegexpQueryNode regexpNode = (RegexpQueryNode)queryNode;
RegexpQuery q = new RegexpQuery(new Term(regexpNode.GetFieldAsString(),
regexpNode.TextToBytesRef()));
MultiTermQuery.RewriteMethod method = (MultiTermQuery.RewriteMethod)queryNode
.GetTag(MultiTermRewriteMethodProcessor.TAG_ID);
if (method != null)
{
q.MultiTermRewriteMethod = method;
}
return(q);
}
/// <summary>
/// 正则表达式查询
/// </summary>
/// <param name="keyword"></param>
/// <returns></returns>
public List <MeetupEvents> GetResult_RegexpQuery(string keyword)
{
SearchRequest sr = new SearchRequest();
RegexpQuery rq = new RegexpQuery();
rq.Field = "description";
rq.Value = keyword + "*";
rq.MaximumDeterminizedStates = 20000;
sr.Query = rq;
var result = client.Search <MeetupEvents>(sr);
return(result.Documents.ToList <MeetupEvents>());
}
public void RegexpQueryTest()
{
var rq = new RegexpQuery()
{
Field = "eventname",
Value = @"Test_[0-9]\d{5}(?!\d)"
};
var sr = new SearchRequest();
sr.Query = rq;
var result = esClient.Search <MeetupEvents>(sr);
var items = result.Documents.ToList();
Assert.IsTrue(items.Any());
}
/// <summary>
/// 根据查询条件、排序条件获取索引实体集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="keyword"></param>
/// <param name="orderbys"></param>
/// <param name="indexname"></param>
/// <param name="strdoctype"></param>
/// <returns></returns>
public List <T> GetEntities <T>(string keyword, string[] orderbys = null, string indexname = "", string strdoctype = "") where T : class
{
if (string.IsNullOrWhiteSpace(indexname))
{
indexname = this.mIndexName;
}
if (string.IsNullOrWhiteSpace(strdoctype))
{
strdoctype = this.mStrDocType;
}
SearchRequest sr = new SearchRequest(indexname, strdoctype);
RegexpQuery rq = new RegexpQuery();
rq.Value = string.Format("*{0}*", keyword);
rq.MaximumDeterminizedStates = 20000;
sr.Query = rq;
if (orderbys != null)
{
for (int i = 0; i < orderbys.Length; i++)
{
string[] sortArry = orderbys[0].Split(':');
string filed = sortArry[0];
string order = sortArry[1];
ISort sort = new SortField {
Field = filed, Order = (order.ToLower() == "asc" ? SortOrder.Ascending : SortOrder.Descending)
};
sr.Sort = new List <ISort>();
sr.Sort.Add(sort);
}
}
var searchResults = this.mElasticClent.Search <T>(sr);
return(searchResults.Documents.ToList());
}
public Query CreateQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JObject query)
{
if (type != "regexp")
{
return(null);
}
var first = query.Properties().First();
switch (first.Value.Type)
{
case JTokenType.String:
return(new RegexpQuery(new Term(first.Name, first.Value.ToString())));
case JTokenType.Object:
var obj = (JObject)first.Value;
if (!obj.TryGetValue("value", out var value))
{
throw new ArgumentException("Missing value in regexp query");
}
// TODO: Support flags
var regexpQuery = new RegexpQuery(new Term(value.Value <string>()));
if (obj.TryGetValue("boost", out var boost))
{
regexpQuery.Boost = boost.Value <float>();
}
return(regexpQuery);
default: throw new ArgumentException("Invalid regexp query");
}
}
public virtual void TestNoSuchMultiTermsInNotNear()
{
//test to make sure non existent multiterms aren't throwing non-matching field exceptions
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(fuzzyNoSuch);
SpanQuery term = new SpanTermQuery(new Term("field", "brown"));
SpanNotQuery notNear = new SpanNotQuery(term, spanNoSuch, 0, 0);
Assert.AreEqual(1, Searcher.Search(notNear, 10).TotalHits);
//flip
notNear = new SpanNotQuery(spanNoSuch, term, 0, 0);
Assert.AreEqual(0, Searcher.Search(notNear, 10).TotalHits);
//both noSuch
notNear = new SpanNotQuery(spanNoSuch, spanNoSuch, 0, 0);
Assert.AreEqual(0, Searcher.Search(notNear, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(wcNoSuch);
notNear = new SpanNotQuery(term, spanWCNoSuch, 0, 0);
Assert.AreEqual(1, Searcher.Search(notNear, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(rgxNoSuch);
notNear = new SpanNotQuery(term, spanRgxNoSuch, 1, 1);
Assert.AreEqual(1, Searcher.Search(notNear, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(prfxNoSuch);
notNear = new SpanNotQuery(term, spanPrfxNoSuch, 1, 1);
Assert.AreEqual(1, Searcher.Search(notNear, 10).TotalHits);
}
public virtual void TestNoSuchMultiTermsInSpanFirst()
{
//this hasn't been a problem
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(fuzzyNoSuch);
SpanQuery spanFirst = new SpanFirstQuery(spanNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(wcNoSuch);
spanFirst = new SpanFirstQuery(spanWCNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(rgxNoSuch);
spanFirst = new SpanFirstQuery(spanRgxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(prfxNoSuch);
spanFirst = new SpanFirstQuery(spanPrfxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
}
public void Boost_ReturnsRegexQuery()
{
var query = new RegexpQuery("*").Boost(2.2);
Assert.IsType <RegexpQuery> (query);
}
public void Boost_WhenBoostIsLessThanZero_ThrowsArgumentOutOfRangeException()
{
var query = new RegexpQuery("*");
Assert.Throws <ArgumentOutOfRangeException>(() => query.Boost(-.1));
}
public virtual void TestNoSuchMultiTermsInOr()
{
//test to make sure non existent multiterms aren't throwing null pointer exceptions
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(fuzzyNoSuch);
SpanQuery term = new SpanTermQuery(new Term("field", "brown"));
SpanOrQuery near = new SpanOrQuery(new SpanQuery[] { term, spanNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
//flip
near = new SpanOrQuery(new SpanQuery[] { spanNoSuch, term });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(wcNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanWCNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(rgxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanRgxNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(prfxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanPrfxNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch });
Assert.AreEqual(0, Searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch, spanPrfxNoSuch });
Assert.AreEqual(0, Searcher.Search(near, 10).TotalHits);
}
