Beispiel #1
0
        private void btnExecuteSearch_Click(object sender, EventArgs e)
        {
            Directory indexDirectory = FSDirectory.Open(new System.IO.DirectoryInfo(tempPath));
            IndexSearcher searcher = new IndexSearcher(indexDirectory, true); // read-only=true

            QueryParser qp = new HebrewQueryParser(Lucene.Net.Util.Version.LUCENE_29, "content", analyzer);
            qp.SetDefaultOperator(QueryParser.Operator.AND);
            Query query = qp.Parse(txbSearchQuery.Text);

            ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;

            // Iterate through the results:
            BindingList<SearchResult> l = new BindingList<SearchResult>();
            for (int i = 0; i < hits.Length; i++)
            {
                Document hitDoc = searcher.Doc(hits[i].doc);
                SearchResult sr = new SearchResult(hitDoc.GetField("title").StringValue(),
                    hitDoc.GetField("path").StringValue(), hits[i].score);
                l.Add(sr);
            }

            searcher.Close();
            indexDirectory.Close();

            dgvResults.DataSource = l;
        }
        private void RunQuery(string query, int expectedPosition)
        {
            var hqp = new HebrewQueryParser(global::Lucene.Net.Util.Version.LUCENE_29, "Text", analyzer);

            Query q = hqp.Parse(query);

            TopDocs td = searcher.Search(q, 10000);

            int num = td.ScoreDocs[0].Doc;
            var tf = searcher.IndexReader.GetTermFreqVectors(num)[0];
            var tp = (TermPositionVector)tf;

	        var trms_list = new SortedSet<Term>();
            q.ExtractTerms(trms_list);
            foreach (var t in trms_list)
            {
                int[] pos = tp.GetTermPositions(tp.IndexOf(t.Text));
                TermVectorOffsetInfo[] off = tp.GetOffsets(tp.IndexOf(t.Text));
                AssertSinglePositionExists(pos, expectedPosition);

                /*
                string sPos = "";
                string sOff = "";
                foreach (int p in pos)
                {
                    sPos += " " + p;
                }
                foreach (TermVectorOffsetInfo o in off)
                {
                    sOff += " (" + o.GetStartOffset() + "," + o.GetEndOffset() + ")";
                }
                Trace.WriteLine(string.Format("Term: {0} Pos:{1} Off:{2}", t.Text(), sPos, sOff));
                */
            }
        }
 /// <summary> Parses a query, searching on the fields specified. Use this if you need
 /// to specify certain fields as required, and others as prohibited.
 /// <p/>
 /// 
 /// <pre>
 /// Usage:
 /// &lt;code&gt;
 /// String[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
 /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
 /// BooleanClause.Occur.MUST,
 /// BooleanClause.Occur.MUST_NOT};
 /// MultiFieldQueryParser.parse(&quot;query&quot;, fields, flags, analyzer);
 /// &lt;/code&gt;
 /// </pre>
 /// <p/>
 /// The code above would construct a query:
 /// 
 /// <pre>
 /// &lt;code&gt;
 /// (filename:query) +(contents:query) -(description:query)
 /// &lt;/code&gt;
 /// </pre>
 /// 
 /// </summary>
 /// <param name="matchVersion">Lucene version to match; this is passed through to
 /// QueryParser.
 /// </param>
 /// <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>
 /// <throws>  ParseException </throws>
 /// <summary>             if query parsing fails
 /// </summary>
 /// <throws>  IllegalArgumentException </throws>
 /// <summary>             if the length of the fields array differs from the length of
 /// the flags array
 /// </summary>
 public new static Query Parse(Lucene.Net.Util.Version matchVersion, string query, string[] fields, Occur[] flags, Analyzer analyzer)
 {
     if (fields.Length > flags.Length)
         throw new System.ArgumentException("fields.length != flags.length");
     BooleanQuery bQuery = new BooleanQuery();
     for (int i = 0; i < fields.Length; i++)
     {
         QueryParser qp = new HebrewQueryParser(matchVersion, fields[i], analyzer);
         Query q = qp.Parse(query);
         if (q != null && (!(q is BooleanQuery) || ((BooleanQuery)q).GetClauses().Length > 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.
        /// <p/>
        ///
        /// <pre>
        /// Usage:
        /// &lt;code&gt;
        /// String[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
        /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
        /// BooleanClause.Occur.MUST,
        /// BooleanClause.Occur.MUST_NOT};
        /// MultiFieldQueryParser.parse(&quot;query&quot;, fields, flags, analyzer);
        /// &lt;/code&gt;
        /// </pre>
        /// <p/>
        /// The code above would construct a query:
        ///
        /// <pre>
        /// &lt;code&gt;
        /// (filename:query) +(contents:query) -(description:query)
        /// &lt;/code&gt;
        /// </pre>
        ///
        /// </summary>
        /// <param name="matchVersion">Lucene version to match; this is passed through to
        /// QueryParser.
        /// </param>
        /// <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>
        /// <throws>  ParseException </throws>
        /// <summary>             if query parsing fails
        /// </summary>
        /// <throws>  IllegalArgumentException </throws>
        /// <summary>             if the length of the fields array differs from the length of
        /// the flags array
        /// </summary>
        public new static Query Parse(Lucene.Net.Util.Version matchVersion, string query, string[] fields, Occur[] flags, Analyzer analyzer)
        {
            if (fields.Length > flags.Length)
            {
                throw new System.ArgumentException("fields.length != flags.length");
            }
            BooleanQuery bQuery = new BooleanQuery();

            for (int i = 0; i < fields.Length; i++)
            {
                QueryParser qp = new HebrewQueryParser(matchVersion, fields[i], analyzer);
                Query       q  = qp.Parse(query);
                if (q != null && (!(q is BooleanQuery) || ((BooleanQuery)q).GetClauses().Length > 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.
 /// <p/>
 /// 
 /// <pre>
 /// Usage:
 /// &lt;code&gt;
 /// String[] query = {&quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot;};
 /// String[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
 /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
 /// BooleanClause.Occur.MUST,
 /// BooleanClause.Occur.MUST_NOT};
 /// MultiFieldQueryParser.parse(query, fields, flags, analyzer);
 /// &lt;/code&gt;
 /// </pre>
 /// <p/>
 /// The code above would construct a query:
 /// 
 /// <pre>
 /// &lt;code&gt;
 /// (filename:query1) +(contents:query2) -(description:query3)
 /// &lt;/code&gt;
 /// </pre>
 /// 
 /// </summary>
 /// <param name="matchVersion">Lucene version to match; this is passed through to
 /// QueryParser.
 /// </param>
 /// <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>
 /// <throws>  ParseException </throws>
 /// <summary>             if query parsing fails
 /// </summary>
 /// <throws>  IllegalArgumentException </throws>
 /// <summary>             if the length of the queries, fields, and flags array differ
 /// </summary>
 public static new Query Parse(Lucene.Net.Util.Version matchVersion, string[] queries, string[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
 {
     if (!(queries.Length == fields.Length && queries.Length == flags.Length))
         throw new System.ArgumentException("queries, fields, and flags array have have different length");
     BooleanQuery bQuery = new BooleanQuery();
     for (int i = 0; i < fields.Length; i++)
     {
         QueryParser qp = new HebrewQueryParser(matchVersion, fields[i], analyzer);
         Query q = qp.Parse(queries[i]);
         if (q != null && (!(q is BooleanQuery) || ((BooleanQuery)q).GetClauses().Length > 0))
         {
             bQuery.Add(q, flags[i]);
         }
     }
     return bQuery;
 }
		public static Query ParseIntoDMQ(string query, string[] fields, Analyzer analyzer)
		{
			var dmQuery = new DisjunctionMaxQuery(0.0f);
			foreach (var t in fields)
			{
				QueryParser qp = new HebrewQueryParser(Lucene.Net.Util.Version.LUCENE_29, t, analyzer);
				var q = qp.Parse(query);
				if (q != null && (!(q is BooleanQuery) || ((BooleanQuery)q).GetClauses().Length > 0))
					dmQuery.Add(q);
			}
			return dmQuery;
		}