public void TestPosIncrementAnalyzer()
{
StandardQueryParser qp = new StandardQueryParser();
qp.Analyzer = (new PosIncrementAnalyzer());
assertEquals("quick brown", qp.Parse("the quick brown", "").toString());
assertEquals("\"? quick brown\"", qp.Parse("\"the quick brown\"", "")
.toString());
assertEquals("quick brown fox", qp.Parse("the quick brown fox", "")
.toString());
assertEquals("\"? quick brown fox\"", qp.Parse("\"the quick brown fox\"", "")
.toString());
}
public void TestStopWordSearching()
{
Analyzer analyzer = new MockAnalyzer(Random);
Store.Directory ramDir = NewDirectory();
IndexWriter iw = new IndexWriter(ramDir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
Document doc = new Document();
doc.Add(NewTextField("body", "blah the footest blah", Field.Store.NO));
iw.AddDocument(doc);
iw.Dispose();
StandardQueryParser mfqp = new StandardQueryParser();
mfqp.SetMultiFields(new String[] { "body" });
mfqp.Analyzer = (analyzer);
mfqp.DefaultOperator = (StandardQueryConfigHandler.Operator.AND);
Query q = mfqp.Parse("the footest", null);
IndexReader ir = DirectoryReader.Open(ramDir);
IndexSearcher @is = NewSearcher(ir);
ScoreDoc[] hits = @is.Search(q, null, 1000).ScoreDocs;
assertEquals(1, hits.Length);
ir.Dispose();
ramDir.Dispose();
}
private void TestQuery(String queryStr, int expectedDocCount)
{
if (VERBOSE)
{
Console.WriteLine("Parsing: " + queryStr);
}
Query query = qp.Parse(queryStr, FIELD_NAME);
if (VERBOSE)
{
Console.WriteLine("Querying: " + query);
}
TopDocs topDocs = searcher.Search(query, 1000);
String msg = "Query <" + queryStr + "> retrieved " + topDocs.TotalHits
+ " document(s), " + expectedDocCount + " document(s) expected.";
if (VERBOSE)
{
Console.WriteLine(msg);
}
assertEquals(msg, expectedDocCount, topDocs.TotalHits);
}
/// <summary>
/// Parses a query, searching on the fields specified. Use this if you need to
/// specify certain fields as required, and others as prohibited.
/// <para/>
/// Usage:
/// <code>
/// string[] fields = {"filename", "contents", "description"};
/// Occur[] flags = {Occur.SHOULD,
/// Occur.MUST,
/// Occur.MUST_NOT};
/// MultiFieldQueryParser.Parse("query", fields, flags, analyzer);
/// </code>
/// <para/>
/// The code above would construct a query:
/// <code>
/// (filename:query) +(contents:query) -(description:query)
/// </code>
/// </summary>
/// <param name="query">Query string to parse</param>
/// <param name="fields">Fields to search on</param>
/// <param name="flags">Flags describing the fields</param>
/// <param name="analyzer">Analyzer to use</param>
/// <exception cref="ArgumentException">
/// if the length of the fields array differs from the length of the
/// flags array
/// </exception>
public static Query Parse(string query, string[] fields,
Occur[] flags, Analyzer analyzer)
{
if (fields.Length != flags.Length)
{
throw new ArgumentException("fields.length != flags.length");
}
BooleanQuery bQuery = new BooleanQuery();
StandardQueryParser qp = new StandardQueryParser();
qp.Analyzer = analyzer;
for (int i = 0; i < fields.Length; i++)
{
Query q = qp.Parse(query, fields[i]);
if (q != null && // q never null, just being defensive
(!(q is BooleanQuery) || ((BooleanQuery)q).Clauses.Count > 0))
{
bQuery.Add(q, flags[i]);
}
}
return(bQuery);
}
/// <summary>
/// Parses a query, searching on the fields specified. Use this if you need to
/// specify certain fields as required, and others as prohibited.
/// <para/>
/// Usage:
/// <code>
/// string[] query = {"query1", "query2", "query3"};
/// string[] fields = {"filename", "contents", "description"};
/// Occur[] flags = {Occur.SHOULD,
/// Occur.MUST,
/// Occur.MUST_NOT};
/// MultiFieldQueryParser.Parse(query, fields, flags, analyzer);
/// </code>
/// <para/>
/// The code above would construct a query:
/// <code>
/// (filename:query1) +(contents:query2) -(description:query3)
/// </code>
/// </summary>
/// <param name="queries">Queries string to parse</param>
/// <param name="fields">Fields to search on</param>
/// <param name="flags">Flags describing the fields</param>
/// <param name="analyzer">Analyzer to use</param>
/// <exception cref="ArgumentException">
/// if the length of the queries, fields, and flags array differ
/// </exception>
public static Query Parse(string[] queries, string[] fields,
Occur[] flags, Analyzer analyzer)
{
if (!(queries.Length == fields.Length && queries.Length == flags.Length))
{
throw new ArgumentException(
"queries, fields, and flags array have have different length");
}
BooleanQuery bQuery = new BooleanQuery();
StandardQueryParser qp = new StandardQueryParser();
qp.Analyzer = analyzer;
for (int i = 0; i < fields.Length; i++)
{
Query q = qp.Parse(queries[i], fields[i]);
if (q != null && // q never null, just being defensive
(!(q is BooleanQuery booleanQuery) || booleanQuery.Clauses.Count > 0))
{
bQuery.Add(q, flags[i]);
}
}
return(bQuery);
}
/// <summary>
/// Parses a query which searches on the fields specified.
/// <para/>
/// If x fields are specified, this effectively constructs:
/// <code>
/// (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
/// </code>
/// </summary>
/// <param name="queries">Queries strings to parse</param>
/// <param name="fields">Fields to search on</param>
/// <param name="analyzer">Analyzer to use</param>
/// <exception cref="ArgumentException">
/// if the length of the queries array differs from the length of the
/// fields array
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="queries"/> or <paramref name="fields"/> is <c>null</c>
/// </exception>
public static Query Parse(string[] queries, string[] fields, Analyzer analyzer)
{
// LUCENENET: Added null guard clauses
if (queries is null)
{
throw new ArgumentNullException(nameof(queries));
}
if (fields is null)
{
throw new ArgumentNullException(nameof(fields));
}
if (queries.Length != fields.Length)
{
throw new ArgumentException("queries.Length != fields.Length");
}
BooleanQuery bQuery = new BooleanQuery();
StandardQueryParser qp = new StandardQueryParser();
qp.Analyzer = analyzer;
for (int i = 0; i < fields.Length; i++)
{
Query q = qp.Parse(queries[i], fields[i]);
if (q != null && // q never null, just being defensive
(!(q is BooleanQuery booleanQuery) || booleanQuery.Clauses.Count > 0))
{
bQuery.Add(q, Occur.SHOULD);
}
}
return(bQuery);
}
public override void TestNewFieldQuery()
{
/** ordinary behavior, synonyms form uncoordinated boolean query */
StandardQueryParser dumb = GetParser(new Analyzer1());
BooleanQuery expanded = new BooleanQuery(true);
expanded.Add(new TermQuery(new Term("field", "dogs")),
BooleanClause.Occur.SHOULD);
expanded.Add(new TermQuery(new Term("field", "dog")),
BooleanClause.Occur.SHOULD);
assertEquals(expanded, dumb.Parse("\"dogs\"", "field"));
/** even with the phrase operator the behavior is the same */
assertEquals(expanded, dumb.Parse("dogs", "field"));
/**
* custom behavior, the synonyms are expanded, unless you use quote operator
*/
//TODO test something like "SmartQueryParser()"
}
public void TestAnalyzerReturningNull()
{
String[]
fields = new String[] { "f1", "f2", "f3" };
StandardQueryParser parser = new StandardQueryParser();
parser.SetMultiFields(fields);
parser.Analyzer = (new AnalyzerReturningNull());
Query q = parser.Parse("bla AND blo", null);
assertEquals("+(f2:bla f3:bla) +(f2:blo f3:blo)", q.toString());
// the following queries are not affected as their terms are not
// analyzed anyway:
q = parser.Parse("bla*", null);
assertEquals("f1:bla* f2:bla* f3:bla*", q.toString());
q = parser.Parse("bla~", null);
assertEquals("f1:bla~2 f2:bla~2 f3:bla~2", q.toString());
q = parser.Parse("[a TO c]", null);
assertEquals("f1:[a TO c] f2:[a TO c] f3:[a TO c]", q.toString());
}
public void TestBoostsSimple()
{
IDictionary <String, float?> boosts = new Dictionary <String, float?>();
boosts.Put("b", 5);
boosts.Put("t", 10);
String[] fields = { "b", "t" };
StandardQueryParser mfqp = new StandardQueryParser();
mfqp.SetMultiFields(fields);
mfqp.FieldsBoost = (boosts);
mfqp.Analyzer = (new MockAnalyzer(Random));
// Check for simple
Query q = mfqp.Parse("one", null);
assertEquals("b:one^5.0 t:one^10.0", q.toString());
// Check for AND
q = mfqp.Parse("one AND two", null);
assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0)", q
.toString());
// Check for OR
q = mfqp.Parse("one OR two", null);
assertEquals("(b:one^5.0 t:one^10.0) (b:two^5.0 t:two^10.0)", q.toString());
// Check for AND and a field
q = mfqp.Parse("one AND two AND foo:test", null);
assertEquals("+(b:one^5.0 t:one^10.0) +(b:two^5.0 t:two^10.0) +foo:test", q
.toString());
q = mfqp.Parse("one^3 AND two^4", null);
assertEquals("+((b:one^5.0 t:one^10.0)^3.0) +((b:two^5.0 t:two^10.0)^4.0)",
q.toString());
}
// verify parsing of query using a stopping analyzer
private void assertStopQueryEquals(String qtxt, String expectedRes)
{
String[]
fields = { "b", "t" };
Occur[] occur = { Occur.SHOULD, Occur.SHOULD };
TestQPHelper.QPTestAnalyzer a = new TestQPHelper.QPTestAnalyzer();
StandardQueryParser mfqp = new StandardQueryParser();
mfqp.SetMultiFields(fields);
mfqp.Analyzer = (a);
Query q = mfqp.Parse(qtxt, null);
assertEquals(expectedRes, q.toString());
q = QueryParserUtil.Parse(qtxt, fields, occur, a);
assertEquals(expectedRes, q.toString());
}
// verify parsing of query using a stopping analyzer
private void assertStopQueryEquals(String qtxt, String expectedRes)
{
String[]
fields = { "b", "t" };
BooleanClause.Occur[] occur = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD }; // LUCENENET TODO: Make this Occur.Should instead of BooleanClause.Occur.Should
TestQPHelper.QPTestAnalyzer a = new TestQPHelper.QPTestAnalyzer();
StandardQueryParser mfqp = new StandardQueryParser();
mfqp.SetMultiFields(fields);
mfqp.Analyzer = (a);
Query q = mfqp.Parse(qtxt, null);
assertEquals(expectedRes, q.toString());
q = QueryParserUtil.Parse(qtxt, fields, occur, a);
assertEquals(expectedRes, q.toString());
}
public void TestSimple()
{
String[]
fields = { "b", "t" };
StandardQueryParser mfqp = new StandardQueryParser();
mfqp.SetMultiFields(fields);
mfqp.Analyzer = (new MockAnalyzer(Random));
Query q = mfqp.Parse("one", null);
assertEquals("b:one t:one", q.toString());
q = mfqp.Parse("one two", null);
assertEquals("(b:one t:one) (b:two t:two)", q.toString());
q = mfqp.Parse("+one +two", null);
assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
q = mfqp.Parse("+one -two -three", null);
assertEquals("+(b:one t:one) -(b:two t:two) -(b:three t:three)", q
.toString());
q = mfqp.Parse("one^2 two", null);
assertEquals("((b:one t:one)^2.0) (b:two t:two)", q.toString());
q = mfqp.Parse("one~ two", null);
assertEquals("(b:one~2 t:one~2) (b:two t:two)", q.toString());
q = mfqp.Parse("one~0.8 two^2", null);
assertEquals("(b:one~0 t:one~0) ((b:two t:two)^2.0)", q.toString());
q = mfqp.Parse("one* two*", null);
assertEquals("(b:one* t:one*) (b:two* t:two*)", q.toString());
q = mfqp.Parse("[a TO c] two", null);
assertEquals("(b:[a TO c] t:[a TO c]) (b:two t:two)", q.toString());
q = mfqp.Parse("w?ldcard", null);
assertEquals("b:w?ldcard t:w?ldcard", q.toString());
q = mfqp.Parse("\"foo bar\"", null);
assertEquals("b:\"foo bar\" t:\"foo bar\"", q.toString());
q = mfqp.Parse("\"aa bb cc\" \"dd ee\"", null);
assertEquals("(b:\"aa bb cc\" t:\"aa bb cc\") (b:\"dd ee\" t:\"dd ee\")", q
.toString());
q = mfqp.Parse("\"foo bar\"~4", null);
assertEquals("b:\"foo bar\"~4 t:\"foo bar\"~4", q.toString());
// LUCENE-1213: QueryParser was ignoring slop when phrase
// had a field.
q = mfqp.Parse("b:\"foo bar\"~4", null);
assertEquals("b:\"foo bar\"~4", q.toString());
// make sure that terms which have a field are not touched:
q = mfqp.Parse("one f:two", null);
assertEquals("(b:one t:one) f:two", q.toString());
// AND mode:
mfqp.DefaultOperator = (StandardQueryConfigHandler.Operator.AND);
q = mfqp.Parse("one two", null);
assertEquals("+(b:one t:one) +(b:two t:two)", q.toString());
q = mfqp.Parse("\"aa bb cc\" \"dd ee\"", null);
assertEquals("+(b:\"aa bb cc\" t:\"aa bb cc\") +(b:\"dd ee\" t:\"dd ee\")",
q.toString());
}
public void TestMultiAnalyzer()
{
StandardQueryParser qp = new StandardQueryParser();
qp.Analyzer = (new MultiAnalyzer());
// trivial, no multiple tokens:
assertEquals("foo", qp.Parse("foo", "").toString());
assertEquals("foo", qp.Parse("\"foo\"", "").toString());
assertEquals("foo foobar", qp.Parse("foo foobar", "").toString());
assertEquals("\"foo foobar\"", qp.Parse("\"foo foobar\"", "").toString());
assertEquals("\"foo foobar blah\"", qp.Parse("\"foo foobar blah\"", "")
.toString());
// two tokens at the same position:
assertEquals("(multi multi2) foo", qp.Parse("multi foo", "").toString());
assertEquals("foo (multi multi2)", qp.Parse("foo multi", "").toString());
assertEquals("(multi multi2) (multi multi2)", qp.Parse("multi multi", "")
.toString());
assertEquals("+(foo (multi multi2)) +(bar (multi multi2))", qp.Parse(
"+(foo multi) +(bar multi)", "").toString());
assertEquals("+(foo (multi multi2)) field:\"bar (multi multi2)\"", qp
.Parse("+(foo multi) field:\"bar multi\"", "").toString());
// phrases:
assertEquals("\"(multi multi2) foo\"", qp.Parse("\"multi foo\"", "")
.toString());
assertEquals("\"foo (multi multi2)\"", qp.Parse("\"foo multi\"", "")
.toString());
assertEquals("\"foo (multi multi2) foobar (multi multi2)\"", qp.Parse(
"\"foo multi foobar multi\"", "").toString());
// fields:
assertEquals("(field:multi field:multi2) field:foo", qp.Parse(
"field:multi field:foo", "").toString());
assertEquals("field:\"(multi multi2) foo\"", qp.Parse(
"field:\"multi foo\"", "").toString());
// three tokens at one position:
assertEquals("triplemulti multi3 multi2", qp.Parse("triplemulti", "")
.toString());
assertEquals("foo (triplemulti multi3 multi2) foobar", qp.Parse(
"foo triplemulti foobar", "").toString());
// phrase with non-default slop:
assertEquals("\"(multi multi2) foo\"~10", qp.Parse("\"multi foo\"~10", "")
.toString());
// phrase with non-default boost:
assertEquals("\"(multi multi2) foo\"^2.0", qp.Parse("\"multi foo\"^2", "")
.toString());
// phrase after changing default slop
#pragma warning disable 612, 618
qp.SetDefaultPhraseSlop(99);
#pragma warning restore 612, 618
assertEquals("\"(multi multi2) foo\"~99 bar", qp.Parse("\"multi foo\" bar",
"").toString());
assertEquals("\"(multi multi2) foo\"~99 \"foo bar\"~2", qp.Parse(
"\"multi foo\" \"foo bar\"~2", "").toString());
#pragma warning disable 612, 618
qp.SetDefaultPhraseSlop(0);
#pragma warning restore 612, 618
// non-default operator:
qp.DefaultOperator = (StandardQueryConfigHandler.Operator.AND);
assertEquals("+(multi multi2) +foo", qp.Parse("multi foo", "").toString());
}
public Query Parse(String query, StandardQueryParser qp)
{
return(qp.Parse(query, DefaultField));
}