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
{
    
    [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;
        
        public IndexSearcher(Directory path)
            : this(IndexReader.Open(path, true), true)
        {
        }
        
        public IndexSearcher(Directory path, bool readOnly):this(IndexReader.Open(path, readOnly), true)
        {
        }

        public IndexSearcher(IndexReader r):this(r, false)
        {
        }
        
        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);
        }

        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);
        }
        
        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;
        
        public virtual void  SetDefaultFieldSortScoring(bool doTrackScores, bool doMaxScore)
        {
            fieldSortDoTrackScores = doTrackScores;
            fieldSortDoMaxScore = doMaxScore;
        }

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