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)); }