public virtual void TestEquals() { AutomatonQuery a1 = new AutomatonQuery(NewTerm("foobar"), BasicAutomata.MakeString("foobar")); // reference to a1 AutomatonQuery a2 = a1; // same as a1 (accepts the same language, same term) AutomatonQuery a3 = new AutomatonQuery(NewTerm("foobar"), BasicOperations.Concatenate(BasicAutomata.MakeString("foo"), BasicAutomata.MakeString("bar"))); // different than a1 (same term, but different language) AutomatonQuery a4 = new AutomatonQuery(NewTerm("foobar"), BasicAutomata.MakeString("different")); // different than a1 (different term, same language) AutomatonQuery a5 = new AutomatonQuery(NewTerm("blah"), BasicAutomata.MakeString("foobar")); Assert.AreEqual(a1.GetHashCode(), a2.GetHashCode()); Assert.AreEqual(a1, a2); Assert.AreEqual(a1.GetHashCode(), a3.GetHashCode()); Assert.AreEqual(a1, a3); // different class AutomatonQuery w1 = new WildcardQuery(NewTerm("foobar")); // different class AutomatonQuery w2 = new RegexpQuery(NewTerm("foobar")); Assert.IsFalse(a1.Equals(w1)); Assert.IsFalse(a1.Equals(w2)); Assert.IsFalse(w1.Equals(w2)); Assert.IsFalse(a1.Equals(a4)); Assert.IsFalse(a1.Equals(a5)); Assert.IsFalse(a1.Equals(null)); }
public virtual void TestCustomProvider() { IAutomatonProvider myProvider = new AutomatonProviderAnonymousInnerClassHelper(this); RegexpQuery query = new RegexpQuery(NewTerm("<quickBrown>"), RegExpSyntax.ALL, myProvider); Assert.AreEqual(1, Searcher.Search(query, 5).TotalHits); }
private void AssertPatternHits(string pattern, int numHits) { Query wq = new RegexpQuery(new Term("field", FillPattern(pattern))); TopDocs docs = Searcher.Search(wq, 25); Assert.AreEqual(numHits, docs.TotalHits, "Incorrect hits for pattern: " + pattern); }
/// <summary> /// check that the # of hits is the same as from a very /// simple regexpquery implementation. /// </summary> protected internal virtual void AssertSame(string regexp) { RegexpQuery smart = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE); DumbRegexpQuery dumb = new DumbRegexpQuery(this, new Term(FieldName, regexp), RegExp.NONE); TopDocs smartDocs = Searcher1.Search(smart, 25); TopDocs dumbDocs = Searcher2.Search(dumb, 25); CheckHits.CheckEqual(smart, smartDocs.ScoreDocs, dumbDocs.ScoreDocs); }
/// <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), RegExpSyntax.NONE); docValues.MultiTermRewriteMethod = (new DocTermOrdsRewriteMethod()); RegexpQuery inverted = new RegexpQuery(new Term(fieldName, regexp), RegExpSyntax.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), RegExpSyntax.NONE); fieldCache.MultiTermRewriteMethod = (new FieldCacheRewriteMethod()); RegexpQuery filter = new RegexpQuery(new Term(fieldName, regexp), RegExpSyntax.NONE); filter.MultiTermRewriteMethod = (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 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]"), RegExpSyntax.NONE); RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExpSyntax.NONE); RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExpSyntax.NONE); Assert.AreEqual(a1, a2); Assert.IsFalse(a1.Equals(b)); a1.MultiTermRewriteMethod = (new DocTermOrdsRewriteMethod()); a2.MultiTermRewriteMethod = (new DocTermOrdsRewriteMethod()); b.MultiTermRewriteMethod = (new DocTermOrdsRewriteMethod()); Assert.AreEqual(a1, a2); Assert.IsFalse(a1.Equals(b)); QueryUtils.Check(a1); }
private int RegexQueryNrHits(string regex) { RegexpQuery query = new RegexpQuery(NewTerm(regex)); return(Searcher.Search(query, 5).TotalHits); }
/// <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 TestCustomProvider() { AutomatonProvider myProvider = new AutomatonProviderAnonymousInnerClassHelper(this); RegexpQuery query = new RegexpQuery(NewTerm("<quickBrown>"), RegExp.ALL, myProvider); Assert.AreEqual(1, Searcher.Search(query, 5).TotalHits); }
public virtual void TestEquals() { AutomatonQuery a1 = new AutomatonQuery(NewTerm("foobar"), BasicAutomata.MakeString("foobar")); // reference to a1 AutomatonQuery a2 = a1; // same as a1 (accepts the same language, same term) AutomatonQuery a3 = new AutomatonQuery(NewTerm("foobar"), BasicOperations.Concatenate(BasicAutomata.MakeString("foo"), BasicAutomata.MakeString("bar"))); // different than a1 (same term, but different language) AutomatonQuery a4 = new AutomatonQuery(NewTerm("foobar"), BasicAutomata.MakeString("different")); // different than a1 (different term, same language) AutomatonQuery a5 = new AutomatonQuery(NewTerm("blah"), BasicAutomata.MakeString("foobar")); Assert.AreEqual(a1.GetHashCode(), a2.GetHashCode()); Assert.AreEqual(a1, a2); Assert.AreEqual(a1.GetHashCode(), a3.GetHashCode()); Assert.AreEqual(a1, a3); // different class AutomatonQuery w1 = new WildcardQuery(NewTerm("foobar")); // different class AutomatonQuery w2 = new RegexpQuery(NewTerm("foobar")); Assert.IsFalse(a1.Equals(w1)); Assert.IsFalse(a1.Equals(w2)); Assert.IsFalse(w1.Equals(w2)); Assert.IsFalse(a1.Equals(a4)); Assert.IsFalse(a1.Equals(a5)); Assert.IsFalse(a1.Equals(null)); }
private int RegexQueryNrHits(string regex) { RegexpQuery query = new RegexpQuery(NewTerm(regex)); return Searcher.Search(query, 5).TotalHits; }
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)); }
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> /// check that the # of hits is the same as from a very /// simple regexpquery implementation. /// </summary> protected internal virtual void AssertSame(string regexp) { RegexpQuery smart = new RegexpQuery(new Term(FieldName, regexp), RegExp.NONE); DumbRegexpQuery dumb = new DumbRegexpQuery(new Term(FieldName, regexp), RegExp.NONE); TopDocs smartDocs = Searcher1.Search(smart, 25); TopDocs dumbDocs = Searcher2.Search(dumb, 25); CheckHits.CheckEqual(smart, smartDocs.ScoreDocs, dumbDocs.ScoreDocs); }
public void TestRegexQueryParsing() { String[] fields = { "b", "t" }; StandardQueryParser parser = new StandardQueryParser(); parser.SetMultiFields(fields); parser.DefaultOperator = (StandardQueryConfigHandler.Operator.AND); parser.Analyzer = (new MockAnalyzer(Random())); BooleanQuery exp = new BooleanQuery(); exp.Add(new BooleanClause(new RegexpQuery(new Term("b", "ab.+")), BooleanClause.Occur.SHOULD));//TODO spezification? was "MUST" exp.Add(new BooleanClause(new RegexpQuery(new Term("t", "ab.+")), BooleanClause.Occur.SHOULD));//TODO spezification? was "MUST" assertEquals(exp, parser.Parse("/ab.+/", null)); RegexpQuery regexpQueryexp = new RegexpQuery(new Term("test", "[abc]?[0-9]")); assertEquals(regexpQueryexp, parser.Parse("test:/[abc]?[0-9]/", null)); }
private void AssertPatternHits(string pattern, int numHits) { Query wq = new RegexpQuery(new Term("field", FillPattern(pattern))); TopDocs docs = Searcher.Search(wq, 25); Assert.AreEqual(numHits, docs.TotalHits, "Incorrect hits for pattern: " + pattern); }
/// <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; }