/// <summary>
/// check that the # of hits is the same as if the query
/// is run against the inverted index
/// </summary>
protected internal virtual void AssertSame(string regexp)
{
RegexpQuery docValues = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
docValues.SetRewriteMethod(new DocTermOrdsRewriteMethod());
RegexpQuery inverted = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
TopDocs invertedDocs = Searcher1.Search(inverted, 25);
TopDocs docValuesDocs = Searcher2.Search(docValues, 25);
CheckHits.CheckEqual(inverted, invertedDocs.ScoreDocs, docValuesDocs.ScoreDocs);
}
/// <summary>
/// Test fieldcache rewrite against filter rewrite </summary>
protected internal override void AssertSame(string regexp)
{
RegexpQuery fieldCache = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
fieldCache.SetRewriteMethod(new FieldCacheRewriteMethod());
RegexpQuery filter = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
filter.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
TopDocs fieldCacheDocs = Searcher1.Search(fieldCache, 25);
TopDocs filterDocs = Searcher2.Search(filter, 25);
CheckHits.CheckEqual(fieldCache, fieldCacheDocs.ScoreDocs, filterDocs.ScoreDocs);
}
/// <summary>
/// Test fieldcache rewrite against filter rewrite </summary>
protected internal override void AssertSame(string regexp)
{
RegexpQuery fieldCache = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
fieldCache.SetRewriteMethod(new FieldCacheRewriteMethod());
RegexpQuery filter = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
filter.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
TopDocs fieldCacheDocs = Searcher1.Search(fieldCache, 25);
TopDocs filterDocs = Searcher2.Search(filter, 25);
CheckHits.CheckEqual(fieldCache, fieldCacheDocs.ScoreDocs, filterDocs.ScoreDocs);
}
public virtual void TestEquals()
{
RegexpQuery a1 = new RegexpQuery(new Term(FieldName, "[aA]"), RegExp.NONE);
RegexpQuery a2 = new RegexpQuery(new Term(FieldName, "[aA]"), RegExp.NONE);
RegexpQuery b = new RegexpQuery(new Term(FieldName, "[bB]"), RegExp.NONE);
Assert.AreEqual(a1, a2);
Assert.IsFalse(a1.Equals(b));
a1.SetRewriteMethod(new FieldCacheRewriteMethod());
a2.SetRewriteMethod(new FieldCacheRewriteMethod());
b.SetRewriteMethod(new FieldCacheRewriteMethod());
Assert.AreEqual(a1, a2);
Assert.IsFalse(a1.Equals(b));
QueryUtils.Check(a1);
}
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.SetRewriteMethod(method);
}
return q;
}
public virtual void TestEquals()
{
RegexpQuery a1 = new RegexpQuery(new Term(FieldName, "[aA]"), RegExp.NONE);
RegexpQuery a2 = new RegexpQuery(new Term(FieldName, "[aA]"), RegExp.NONE);
RegexpQuery b = new RegexpQuery(new Term(FieldName, "[bB]"), RegExp.NONE);
Assert.AreEqual(a1, a2);
Assert.IsFalse(a1.Equals(b));
a1.SetRewriteMethod(new FieldCacheRewriteMethod());
a2.SetRewriteMethod(new FieldCacheRewriteMethod());
b.SetRewriteMethod(new FieldCacheRewriteMethod());
Assert.AreEqual(a1, a2);
Assert.IsFalse(a1.Equals(b));
QueryUtils.Check(a1);
}
public void TestRegexps()
{
StandardQueryParser qp = new StandardQueryParser();
String df = "field";
RegexpQuery q = new RegexpQuery(new Term("field", "[a-z][123]"));
assertEquals(q, qp.Parse("/[a-z][123]/", df));
qp.LowercaseExpandedTerms = (true);
assertEquals(q, qp.Parse("/[A-Z][123]/", df));
q.Boost = (0.5f);
assertEquals(q, qp.Parse("/[A-Z][123]/^0.5", df));
qp.MultiTermRewriteMethod = (MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
q.SetRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); // LUCENENET TODO: Inconsistent API betwen RegexpQuery and StandardQueryParser
assertTrue(qp.Parse("/[A-Z][123]/^0.5", df) is RegexpQuery);
assertEquals(q, qp.Parse("/[A-Z][123]/^0.5", df));
assertEquals(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE, ((RegexpQuery)qp.Parse("/[A-Z][123]/^0.5", df)).GetRewriteMethod());
qp.MultiTermRewriteMethod = (MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
assertEquals(escaped, qp.Parse("/[a-z]\\/[123]/", df));
Query escaped2 = new RegexpQuery(new Term("field", "[a-z]\\*[123]"));
assertEquals(escaped2, qp.Parse("/[a-z]\\*[123]/", df));
BooleanQuery complex = new BooleanQuery();
complex.Add(new RegexpQuery(new Term("field", "[a-z]\\/[123]")), BooleanClause.Occur.MUST);
complex.Add(new TermQuery(new Term("path", "/etc/init.d/")), BooleanClause.Occur.MUST);
complex.Add(new TermQuery(new Term("field", "/etc/init[.]d/lucene/")), BooleanClause.Occur.SHOULD);
assertEquals(complex, qp.Parse("/[a-z]\\/[123]/ AND path:\"/etc/init.d/\" OR \"/etc\\/init\\[.\\]d/lucene/\" ", df));
Query re = new RegexpQuery(new Term("field", "http.*"));
assertEquals(re, qp.Parse("field:/http.*/", df));
assertEquals(re, qp.Parse("/http.*/", df));
re = new RegexpQuery(new Term("field", "http~0.5"));
assertEquals(re, qp.Parse("field:/http~0.5/", df));
assertEquals(re, qp.Parse("/http~0.5/", df));
re = new RegexpQuery(new Term("field", "boo"));
assertEquals(re, qp.Parse("field:/boo/", df));
assertEquals(re, qp.Parse("/boo/", df));
assertEquals(new TermQuery(new Term("field", "/boo/")), qp.Parse("\"/boo/\"", df));
assertEquals(new TermQuery(new Term("field", "/boo/")), qp.Parse("\\/boo\\/", df));
BooleanQuery two = new BooleanQuery();
two.Add(new RegexpQuery(new Term("field", "foo")), BooleanClause.Occur.SHOULD);
two.Add(new RegexpQuery(new Term("field", "bar")), BooleanClause.Occur.SHOULD);
assertEquals(two, qp.Parse("field:/foo/ field:/bar/", df));
assertEquals(two, qp.Parse("/foo/ /bar/", df));
}
/// <summary>
/// check that the # of hits is the same as if the query
/// is run against the inverted index
/// </summary>
protected internal virtual void AssertSame(string regexp)
{
RegexpQuery docValues = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
docValues.SetRewriteMethod(new DocTermOrdsRewriteMethod());
RegexpQuery inverted = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE);
TopDocs invertedDocs = Searcher1.Search(inverted, 25);
TopDocs docValuesDocs = Searcher2.Search(docValues, 25);
CheckHits.CheckEqual(inverted, invertedDocs.ScoreDocs, docValuesDocs.ScoreDocs);
}
public virtual void TestRegexps()
{
ICommonQueryParserConfiguration qp = GetParserConfig(new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false));
RegexpQuery q = new RegexpQuery(new Term("field", "[a-z][123]"));
assertEquals(q, GetQuery("/[a-z][123]/", qp));
qp.LowercaseExpandedTerms = (true);
assertEquals(q, GetQuery("/[A-Z][123]/", qp));
q.Boost = (0.5f);
assertEquals(q, GetQuery("/[A-Z][123]/^0.5", qp));
qp.MultiTermRewriteMethod=(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
q.SetRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
assertTrue(GetQuery("/[A-Z][123]/^0.5", qp) is RegexpQuery);
assertEquals(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE, ((RegexpQuery)GetQuery("/[A-Z][123]/^0.5", qp)).GetRewriteMethod());
assertEquals(q, GetQuery("/[A-Z][123]/^0.5", qp));
qp.MultiTermRewriteMethod=(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
assertEquals(escaped, GetQuery("/[a-z]\\/[123]/", qp));
Query escaped2 = new RegexpQuery(new Term("field", "[a-z]\\*[123]"));
assertEquals(escaped2, GetQuery("/[a-z]\\*[123]/", qp));
BooleanQuery complex = new BooleanQuery();
complex.Add(new RegexpQuery(new Term("field", "[a-z]\\/[123]")), BooleanClause.Occur.MUST);
complex.Add(new TermQuery(new Term("path", "/etc/init.d/")), BooleanClause.Occur.MUST);
complex.Add(new TermQuery(new Term("field", "/etc/init[.]d/lucene/")), BooleanClause.Occur.SHOULD);
assertEquals(complex, GetQuery("/[a-z]\\/[123]/ AND path:\"/etc/init.d/\" OR \"/etc\\/init\\[.\\]d/lucene/\" ", qp));
Query re = new RegexpQuery(new Term("field", "http.*"));
assertEquals(re, GetQuery("field:/http.*/", qp));
assertEquals(re, GetQuery("/http.*/", qp));
re = new RegexpQuery(new Term("field", "http~0.5"));
assertEquals(re, GetQuery("field:/http~0.5/", qp));
assertEquals(re, GetQuery("/http~0.5/", qp));
re = new RegexpQuery(new Term("field", "boo"));
assertEquals(re, GetQuery("field:/boo/", qp));
assertEquals(re, GetQuery("/boo/", qp));
assertEquals(new TermQuery(new Term("field", "/boo/")), GetQuery("\"/boo/\"", qp));
assertEquals(new TermQuery(new Term("field", "/boo/")), GetQuery("\\/boo\\/", qp));
BooleanQuery two = new BooleanQuery();
two.Add(new RegexpQuery(new Term("field", "foo")), BooleanClause.Occur.SHOULD);
two.Add(new RegexpQuery(new Term("field", "bar")), BooleanClause.Occur.SHOULD);
assertEquals(two, GetQuery("field:/foo/ field:/bar/", qp));
assertEquals(two, GetQuery("/foo/ /bar/", qp));
}
/// <summary>
/// Builds a new RegexpQuery instance
/// </summary>
/// <param name="regexp">Regexp term</param>
/// <returns>new RegexpQuery instance</returns>
protected internal virtual Query NewRegexpQuery(Term regexp)
{
RegexpQuery query = new RegexpQuery(regexp);
query.SetRewriteMethod(MultiTermRewriteMethod);
return query;
}