beagled/Lucene.Net/Search/IndexSearcher.cs

   1 /*
   2  * Copyright 2004 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using Document = Lucene.Net.Documents.Document;
  19 using IndexReader = Lucene.Net.Index.IndexReader;
  20 using Term = Lucene.Net.Index.Term;
  21 using Directory = Lucene.Net.Store.Directory;
  22
  23 namespace Lucene.Net.Search
  24 {
  25
  26         /// <summary>Implements search over a single IndexReader.
  27         ///
  28         /// <p>Applications usually need only call the inherited {@link #Search(Query)}
  29         /// or {@link #Search(Query,Filter)} methods. For performance reasons it is
  30         /// recommended to open only one IndexSearcher and use it for all of your searches.
  31         ///
  32         /// <p>Note that you can only access Hits from an IndexSearcher as long as it is
  33         /// not yet closed, otherwise an IOException will be thrown.
  34         /// </summary>
  35         public class IndexSearcher : Searcher
  36         {
  37                 private class AnonymousClassHitCollector : HitCollector
  38                 {
  39                         public AnonymousClassHitCollector(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.HitQueue hq, int nDocs, IndexSearcher enclosingInstance)
  40                         {
  41                                 InitBlock(bits, totalHits, hq, nDocs, enclosingInstance);
  42                         }
  43                         private void  InitBlock(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.HitQueue hq, int nDocs, IndexSearcher enclosingInstance)
  44                         {
  45                                 this.bits = bits;
  46                                 this.totalHits = totalHits;
  47                                 this.hq = hq;
  48                                 this.nDocs = nDocs;
  49                                 this.enclosingInstance = enclosingInstance;
  50                         }
  51                         private System.Collections.BitArray bits;
  52                         private int[] totalHits;
  53                         private Lucene.Net.Search.HitQueue hq;
  54                         private int nDocs;
  55                         private IndexSearcher enclosingInstance;
  56                         public IndexSearcher Enclosing_Instance
  57                         {
  58                                 get
  59                                 {
  60                                         return enclosingInstance;
  61                                 }
  62
  63                         }
  64                         private float minScore = 0.0f;
  65                         public override void  Collect(int doc, float score)
  66                         {
  67                                 if (score > 0.0f && (bits == null || bits.Get(doc)))
  68                                 {
  69                                         // skip docs not in bits
  70                                         totalHits[0]++;
  71                                         if (hq.Size() < nDocs || score >= minScore)
  72                                         {
  73                                                 hq.Insert(new ScoreDoc(doc, score));
  74                                                 minScore = ((ScoreDoc) hq.Top()).score; // maintain minScore
  75                                         }
  76                                 }
  77                         }
  78                 }
  79                 private class AnonymousClassHitCollector1 : HitCollector
  80                 {
  81                         public AnonymousClassHitCollector1(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.FieldSortedHitQueue hq, IndexSearcher enclosingInstance)
  82                         {
  83                                 InitBlock(bits, totalHits, hq, enclosingInstance);
  84                         }
  85                         private void  InitBlock(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.FieldSortedHitQueue hq, IndexSearcher enclosingInstance)
  86                         {
  87                                 this.bits = bits;
  88                                 this.totalHits = totalHits;
  89                                 this.hq = hq;
  90                                 this.enclosingInstance = enclosingInstance;
  91                         }
  92                         private System.Collections.BitArray bits;
  93                         private int[] totalHits;
  94                         private Lucene.Net.Search.FieldSortedHitQueue hq;
  95                         private IndexSearcher enclosingInstance;
  96                         public IndexSearcher Enclosing_Instance
  97                         {
  98                                 get
  99                                 {
 100                                         return enclosingInstance;
 101                                 }
 102
 103                         }
 104                         public override void  Collect(int doc, float score)
 105                         {
 106                                 if (score > 0.0f && (bits == null || bits.Get(doc)))
 107                                 {
 108                                         // skip docs not in bits
 109                                         totalHits[0]++;
 110                                         hq.Insert(new FieldDoc(doc, score));
 111                                 }
 112                         }
 113                 }
 114                 private class AnonymousClassHitCollector2 : HitCollector
 115                 {
 116                         public AnonymousClassHitCollector2(System.Collections.BitArray bits, Lucene.Net.Search.HitCollector results, IndexSearcher enclosingInstance)
 117                         {
 118                                 InitBlock(bits, results, enclosingInstance);
 119                         }
 120                         private void  InitBlock(System.Collections.BitArray bits, Lucene.Net.Search.HitCollector results, IndexSearcher enclosingInstance)
 121                         {
 122                                 this.bits = bits;
 123                                 this.results = results;
 124                                 this.enclosingInstance = enclosingInstance;
 125                         }
 126                         private System.Collections.BitArray bits;
 127                         private Lucene.Net.Search.HitCollector results;
 128                         private IndexSearcher enclosingInstance;
 129                         public IndexSearcher Enclosing_Instance
 130                         {
 131                                 get
 132                                 {
 133                                         return enclosingInstance;
 134                                 }
 135
 136                         }
 137                         public override void  Collect(int doc, float score)
 138                         {
 139                                 if (bits.Get(doc))
 140                                 {
 141                                         // skip docs not in bits
 142                                         results.Collect(doc, score);
 143                                 }
 144                         }
 145                 }
 146                 internal IndexReader reader;
 147                 private bool closeReader;
 148
 149         public IndexReader Reader
 150         {
 151             get {   return reader;  }
 152         }
 153
 154                 /// <summary>Creates a searcher searching the index in the named directory. </summary>
 155                 public IndexSearcher(System.String path) : this(IndexReader.Open(path), true)
 156                 {
 157                 }
 158
 159                 /// <summary>Creates a searcher searching the index in the provided directory. </summary>
 160                 public IndexSearcher(Directory directory) : this(IndexReader.Open(directory), true)
 161                 {
 162                 }
 163
 164                 /// <summary>Creates a searcher searching the provided index. </summary>
 165                 public IndexSearcher(IndexReader r) : this(r, false)
 166                 {
 167                 }
 168
 169                 private IndexSearcher(IndexReader r, bool closeReader)
 170                 {
 171                         reader = r;
 172                         this.closeReader = closeReader;
 173                 }
 174
 175                 /// <summary>Return the {@link IndexReader} this searches. </summary>
 176                 public virtual IndexReader GetIndexReader()
 177                 {
 178                         return reader;
 179                 }
 180
 181                 /// <summary> Note that the underlying IndexReader is not closed, if
 182                 /// IndexSearcher was constructed with IndexSearcher(IndexReader r).
 183                 /// If the IndexReader was supplied implicitly by specifying a directory, then
 184                 /// the IndexReader gets closed.
 185                 /// </summary>
 186                 public override void  Close()
 187                 {
 188                         if (closeReader)
 189                                 reader.Close();
 190                 }
 191
 192                 // inherit javadoc
 193                 public override int DocFreq(Term term)
 194                 {
 195                         return reader.DocFreq(term);
 196                 }
 197
 198                 // inherit javadoc
 199                 public override Document Doc(int i)
 200                 {
 201                         return reader.Document(i);
 202                 }
 203
 204                 // inherit javadoc
 205                 public override int MaxDoc()
 206                 {
 207                         return reader.MaxDoc();
 208                 }
 209
 210                 // inherit javadoc
 211                 public override TopDocs Search(Weight weight, Filter filter, int nDocs)
 212                 {
 213
 214                         if (nDocs <= 0)
 215                             // null might be returned from hq.top() below.
 216                                 throw new System.ArgumentException("nDocs must be > 0");
 217
 218                         Scorer scorer = weight.Scorer(reader);
 219                         if (scorer == null)
 220                                 return new TopDocs(0, new ScoreDoc[0], System.Single.NegativeInfinity);
 221
 222                         System.Collections.BitArray bits = filter != null?filter.Bits(reader):null;
 223                         HitQueue hq = new HitQueue(nDocs);
 224                         int[] totalHits = new int[1];
 225                         scorer.Score(new AnonymousClassHitCollector(bits, totalHits, hq, nDocs, this));
 226
 227                         ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
 228                         for (int i = hq.Size() - 1; i >= 0; i--)
 229                             // put docs in array
 230                                 scoreDocs[i] = (ScoreDoc) hq.Pop();
 231
 232                         float maxScore = (totalHits[0] == 0) ? System.Single.NegativeInfinity : scoreDocs[0].score;
 233
 234                         return new TopDocs(totalHits[0], scoreDocs, maxScore);
 235                 }
 236
 237                 // inherit javadoc
 238                 public override TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort)
 239                 {
 240                         Scorer scorer = weight.Scorer(reader);
 241                         if (scorer == null)
 242                                 return new TopFieldDocs(0, new ScoreDoc[0], sort.fields, System.Single.NegativeInfinity);
 243
 244                         System.Collections.BitArray bits = filter != null ? filter.Bits(reader) : null;
 245                         FieldSortedHitQueue hq = new FieldSortedHitQueue(reader, sort.fields, nDocs);
 246                         int[] totalHits = new int[1];
 247                         scorer.Score(new AnonymousClassHitCollector1(bits, totalHits, hq, this));
 248
 249                         ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
 250                         for (int i = hq.Size() - 1; i >= 0; i--)
 251                         // put docs in array
 252                                 scoreDocs[i] = hq.FillFields((FieldDoc) hq.Pop());
 253
 254                         return new TopFieldDocs(totalHits[0], scoreDocs, hq.GetFields(), hq.GetMaxScore());
 255                 }
 256
 257                 // inherit javadoc
 258                 public override void  Search(Weight weight, Filter filter, HitCollector results)
 259                 {
 260                         HitCollector collector = results;
 261                         if (filter != null)
 262                         {
 263                                 System.Collections.BitArray bits = filter.Bits(reader);
 264                                 collector = new AnonymousClassHitCollector2(bits, results, this);
 265                         }
 266
 267                         Scorer scorer = weight.Scorer(reader);
 268                         if (scorer == null)
 269                                 return ;
 270                         scorer.Score(collector);
 271                 }
 272
 273                 public override Query Rewrite(Query original)
 274                 {
 275                         Query query = original;
 276                         for (Query rewrittenQuery = query.Rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.Rewrite(reader))
 277                         {
 278                                 query = rewrittenQuery;
 279                         }
 280                         return query;
 281                 }
 282
 283                 public override Explanation Explain(Weight weight, int doc)
 284                 {
 285                         return weight.Explain(reader, doc);
 286                 }
 287         }
 288 }