IndexSearcher.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Linq;
using Lucene.Net.Index;
using Document = Lucene.Net.Documents.Document;
using FieldSelector = Lucene.Net.Documents.FieldSelector;
using CorruptIndexException = Lucene.Net.Index.CorruptIndexException;
using IndexReader = Lucene.Net.Index.IndexReader;
using Term = Lucene.Net.Index.Term;
using Directory = Lucene.Net.Store.Directory;
using ReaderUtil = Lucene.Net.Util.ReaderUtil;

namespace Lucene.Net.Search
{
    
    /// <summary>Implements search over a single IndexReader.
    /// 
    /// <p/>Applications usually need only call the inherited <see cref="Searcher.Search(Query,int)" />
    /// or <see cref="Searcher.Search(Query,Filter,int)" /> methods. For performance reasons it is 
    /// recommended to open only one IndexSearcher and use it for all of your searches.
    /// 
    /// <a name="thread-safety"></a><p/><b>NOTE</b>:
    /// <see cref="IndexSearcher" /> instances are completely
    /// thread safe, meaning multiple threads can call any of its
    /// methods, concurrently.  If your application requires
    /// external synchronization, you should <b>not</b>
    /// synchronize on the <c>IndexSearcher</c> instance;
    /// use your own (non-Lucene) objects instead.<p/>
    /// </summary>
    [Serializable]
    public class IndexSearcher : Searcher
    {
        internal IndexReader reader;
        private bool closeReader;
        private bool isDisposed;

        // NOTE: these members might change in incompatible ways
        // in the next release
        private IndexReader[] subReaders;
        private int[] docStarts;
        
        /// <summary>Creates a searcher searching the index in the named
        /// directory, with readOnly=true</summary>
        /// <throws>CorruptIndexException if the index is corrupt</throws>
        /// <throws>IOException if there is a low-level IO error</throws>
        public IndexSearcher(Directory path)
            : this(IndexReader.Open(path, true), true)
        {
        }
        
        /// <summary>Creates a searcher searching the index in the named
        /// directory.  You should pass readOnly=true, since it
        /// gives much better concurrent performance, unless you
        /// intend to do write operations (delete documents or
        /// change norms) with the underlying IndexReader.
        /// </summary>
        /// <throws>  CorruptIndexException if the index is corrupt </throws>
        /// <throws>  IOException if there is a low-level IO error </throws>
        /// <param name="path">directory where IndexReader will be opened
        /// </param>
        /// <param name="readOnly">if true, the underlying IndexReader
        /// will be opened readOnly
        /// </param>
        public IndexSearcher(Directory path, bool readOnly):this(IndexReader.Open(path, readOnly), true)
        {
        }

        /// <summary>Creates a searcher searching the provided index
        /// <para>
        /// Note that the underlying IndexReader is not closed, if
        /// IndexSearcher was constructed with IndexSearcher(IndexReader r).
        /// If the IndexReader was supplied implicitly by specifying a directory, then
        /// the IndexReader gets closed.
        /// </para>
        /// </summary>
        public IndexSearcher(IndexReader r):this(r, false)
        {
        }
        
        /// <summary>
        /// Expert: directly specify the reader, subReaders and their
        /// DocID starts
        /// <p/>
        /// <b>NOTE:</b> This API is experimental and
        /// might change in incompatible ways in the next
        /// release<p/>
        /// </summary>
        public IndexSearcher(IndexReader reader, IndexReader[] subReaders, int[] docStarts)
        {
            this.reader = reader;
            this.subReaders = subReaders;
            this.docStarts = docStarts;
            this.closeReader = false;
        }

        private IndexSearcher(IndexReader r, bool closeReader)
        {
            reader = r;
            this.closeReader = closeReader;

            System.Collections.Generic.IList<IndexReader> subReadersList = new System.Collections.Generic.List<IndexReader>();
            GatherSubReaders(subReadersList, reader);
            subReaders = subReadersList.ToArray();
            docStarts = new int[subReaders.Length];
            int maxDoc = 0;
            for (int i = 0; i < subReaders.Length; i++)
            {
                docStarts[i] = maxDoc;
                maxDoc += subReaders[i].MaxDoc;
            }
        }
        
        protected internal virtual void  GatherSubReaders(System.Collections.Generic.IList<IndexReader> allSubReaders, IndexReader r)
        {
            ReaderUtil.GatherSubReaders(allSubReaders, r);
        }

        /// <summary>Return the <see cref="Index.IndexReader" /> this searches. </summary>
        public virtual IndexReader IndexReader
        {
            get { return reader; }
        }

        protected override void Dispose(bool disposing)
        {
            if (isDisposed) return;

            if (disposing)
            {
                if (closeReader)
                    reader.Close();
            }

            isDisposed = true;
        }
        
        // inherit javadoc
        public override int DocFreq(Term term)
        {
            return reader.DocFreq(term);
        }
        
        // inherit javadoc
        public override Document Doc(int i)
        {
            return reader.Document(i);
        }
        
        // inherit javadoc
        public override Document Doc(int i, FieldSelector fieldSelector)
        {
            return reader.Document(i, fieldSelector);
        }
        
        // inherit javadoc
        public override int MaxDoc
        {
            get { return reader.MaxDoc; }
        }
        
        // inherit javadoc
        public override TopDocs Search(Weight weight, Filter filter, int nDocs)
        {
            
            if (nDocs <= 0)
            {
                throw new System.ArgumentException("nDocs must be > 0");
            }
            nDocs = Math.Min(nDocs, reader.MaxDoc);

            TopScoreDocCollector collector = TopScoreDocCollector.Create(nDocs, !weight.GetScoresDocsOutOfOrder());
            Search(weight, filter, collector);
            return collector.TopDocs();
        }
        
        public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
        {
            return Search(weight, filter, nDocs, sort, true);
        }
        
        /// <summary> Just like <see cref="Search(Weight, Filter, int, Sort)" />, but you choose
        /// whether or not the fields in the returned <see cref="FieldDoc" /> instances
        /// should be set by specifying fillFields.
        /// <p/>
        /// NOTE: this does not compute scores by default. If you need scores, create
        /// a <see cref="TopFieldCollector" /> instance by calling
        /// <see cref="TopFieldCollector.Create" /> and then pass that to
        /// <see cref="Search(Weight, Filter, Collector)" />.
        /// <p/>
        /// </summary>
        public virtual TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort, bool fillFields)
        {
            nDocs = Math.Min(nDocs, reader.MaxDoc);

            TopFieldCollector collector2 = TopFieldCollector.Create(sort, nDocs, fillFields, fieldSortDoTrackScores, fieldSortDoMaxScore, !weight.GetScoresDocsOutOfOrder());
            Search(weight, filter, collector2);
            return (TopFieldDocs) collector2.TopDocs();
        }
        
        public override void  Search(Weight weight, Filter filter, Collector collector)
        {
            
            if (filter == null)
            {
                for (int i = 0; i < subReaders.Length; i++)
                {
                    // search each subreader
                    collector.SetNextReader(subReaders[i], docStarts[i]);
                    Scorer scorer = weight.Scorer(subReaders[i], !collector.AcceptsDocsOutOfOrder, true);
                    if (scorer != null)
                    {
                        scorer.Score(collector);
                    }
                }
            }
            else
            {
                for (int i = 0; i < subReaders.Length; i++)
                {
                    // search each subreader
                    collector.SetNextReader(subReaders[i], docStarts[i]);
                    SearchWithFilter(subReaders[i], weight, filter, collector);
                }
            }
        }
        
        private void  SearchWithFilter(IndexReader reader, Weight weight, Filter filter, Collector collector)
        {
            
            System.Diagnostics.Debug.Assert(filter != null);
            
            Scorer scorer = weight.Scorer(reader, true, false);
            if (scorer == null)
            {
                return ;
            }
            
            int docID = scorer.DocID();
            System.Diagnostics.Debug.Assert(docID == - 1 || docID == DocIdSetIterator.NO_MORE_DOCS);
            
            // CHECKME: use ConjunctionScorer here?
            DocIdSet filterDocIdSet = filter.GetDocIdSet(reader);
            if (filterDocIdSet == null)
            {
                // this means the filter does not accept any documents.
                return ;
            }
            
            DocIdSetIterator filterIter = filterDocIdSet.Iterator();
            if (filterIter == null)
            {
                // this means the filter does not accept any documents.
                return ;
            }
            int filterDoc = filterIter.NextDoc();
            int scorerDoc = scorer.Advance(filterDoc);
            
            collector.SetScorer(scorer);
            while (true)
            {
                if (scorerDoc == filterDoc)
                {
                    // Check if scorer has exhausted, only before collecting.
                    if (scorerDoc == DocIdSetIterator.NO_MORE_DOCS)
                    {
                        break;
                    }
                    collector.Collect(scorerDoc);
                    filterDoc = filterIter.NextDoc();
                    scorerDoc = scorer.Advance(filterDoc);
                }
                else if (scorerDoc > filterDoc)
                {
                    filterDoc = filterIter.Advance(scorerDoc);
                }
                else
                {
                    scorerDoc = scorer.Advance(filterDoc);
                }
            }
        }
        
        public override Query Rewrite(Query original)
        {
            Query query = original;
            for (Query rewrittenQuery = query.Rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.Rewrite(reader))
            {
                query = rewrittenQuery;
            }
            return query;
        }
        
        public override Explanation Explain(Weight weight, int doc)
        {
            int n = ReaderUtil.SubIndex(doc, docStarts);
            int deBasedDoc = doc - docStarts[n];
            
            return weight.Explain(subReaders[n], deBasedDoc);
        }
        
        private bool fieldSortDoTrackScores;
        private bool fieldSortDoMaxScore;
        
        /// <summary> By default, no scores are computed when sorting by field (using
        /// <see cref="Searcher.Search(Query,Filter,int,Sort)" />). You can change that, per
        /// IndexSearcher instance, by calling this method. Note that this will incur
        /// a CPU cost.
        /// 
        /// </summary>
        /// <param name="doTrackScores">If true, then scores are returned for every matching document
        /// in <see cref="TopFieldDocs" />.
        /// 
        /// </param>
        /// <param name="doMaxScore">If true, then the max score for all matching docs is computed.
        /// </param>
        public virtual void  SetDefaultFieldSortScoring(bool doTrackScores, bool doMaxScore)
        {
            fieldSortDoTrackScores = doTrackScores;
            fieldSortDoMaxScore = doMaxScore;
        }

        public IndexReader reader_ForNUnit
        {
            get { return reader; }
        }
    }
}