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 using System;
  17 using Document = Lucene.Net.Documents.Document;
  18 using IndexReader = Lucene.Net.Index.IndexReader;
  19 using Term = Lucene.Net.Index.Term;
  20 using Directory = Lucene.Net.Store.Directory;
  21 namespace Lucene.Net.Search
  22 {
  23
  24         /// <summary>Implements search over a single IndexReader.
  25         ///
  26         /// <p>Applications usually need only call the inherited {@link #Search(Query)}
  27         /// or {@link #Search(Query,Filter)} methods.
  28         /// </summary>
  29         public class IndexSearcher : Searcher
  30         {
  31                 private class AnonymousClassHitCollector : HitCollector
  32                 {
  33                         public AnonymousClassHitCollector(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.HitQueue hq, int nDocs, IndexSearcher enclosingInstance)
  34                         {
  35                                 InitBlock(bits, totalHits, hq, nDocs, enclosingInstance);
  36                         }
  37                         private void  InitBlock(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.HitQueue hq, int nDocs, IndexSearcher enclosingInstance)
  38                         {
  39                                 this.bits = bits;
  40                                 this.totalHits = totalHits;
  41                                 this.hq = hq;
  42                 this.nDocs = nDocs;
  43                 this.enclosingInstance = enclosingInstance;
  44                         }
  45                         private System.Collections.BitArray bits;
  46                         private int[] totalHits;
  47                         private Lucene.Net.Search.HitQueue hq;
  48             private int nDocs;
  49                         private IndexSearcher enclosingInstance;
  50                         public IndexSearcher Enclosing_Instance
  51                         {
  52                                 get
  53                                 {
  54                                         return enclosingInstance;
  55                                 }
  56
  57                         }
  58             private float minScore = 0.0f;
  59                         public override void  Collect(int doc, float score)
  60                         {
  61                                 if (score > 0.0f && (bits == null || bits.Get(doc)))
  62                                 {
  63                                         // skip docs not in bits
  64                                         totalHits[0]++;
  65                     if (hq.Size() < nDocs || score >= minScore)
  66                     {
  67                         hq.Insert(new ScoreDoc(doc, score));
  68                         minScore = ((ScoreDoc) hq.Top()).score; // maintain minScore
  69                     }
  70                 }
  71                         }
  72                 }
  73                 private class AnonymousClassHitCollector1 : HitCollector
  74                 {
  75                         public AnonymousClassHitCollector1(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.FieldSortedHitQueue hq, IndexSearcher enclosingInstance)
  76                         {
  77                                 InitBlock(bits, totalHits, hq, enclosingInstance);
  78                         }
  79                         private void  InitBlock(System.Collections.BitArray bits, int[] totalHits, Lucene.Net.Search.FieldSortedHitQueue hq, IndexSearcher enclosingInstance)
  80                         {
  81                                 this.bits = bits;
  82                                 this.totalHits = totalHits;
  83                                 this.hq = hq;
  84                                 this.enclosingInstance = enclosingInstance;
  85                         }
  86                         private System.Collections.BitArray bits;
  87                         private int[] totalHits;
  88                         private Lucene.Net.Search.FieldSortedHitQueue hq;
  89                         private IndexSearcher enclosingInstance;
  90                         public IndexSearcher Enclosing_Instance
  91                         {
  92                                 get
  93                                 {
  94                                         return enclosingInstance;
  95                                 }
  96
  97                         }
  98                         public override void  Collect(int doc, float score)
  99                         {
 100                                 if (score > 0.0f && (bits == null || bits.Get(doc)))
 101                                 {
 102                                         // skip docs not in bits
 103                                         totalHits[0]++;
 104                                         hq.Insert(new FieldDoc(doc, score));
 105                                 }
 106                         }
 107                 }
 108                 private class AnonymousClassHitCollector2 : HitCollector
 109                 {
 110                         public AnonymousClassHitCollector2(System.Collections.BitArray bits, Lucene.Net.Search.HitCollector results, IndexSearcher enclosingInstance)
 111                         {
 112                                 InitBlock(bits, results, enclosingInstance);
 113                         }
 114                         private void  InitBlock(System.Collections.BitArray bits, Lucene.Net.Search.HitCollector results, IndexSearcher enclosingInstance)
 115                         {
 116                                 this.bits = bits;
 117                                 this.results = results;
 118                                 this.enclosingInstance = enclosingInstance;
 119                         }
 120                         private System.Collections.BitArray bits;
 121                         private Lucene.Net.Search.HitCollector results;
 122                         private IndexSearcher enclosingInstance;
 123                         public IndexSearcher Enclosing_Instance
 124                         {
 125                                 get
 126                                 {
 127                                         return enclosingInstance;
 128                                 }
 129
 130                         }
 131                         public override void  Collect(int doc, float score)
 132                         {
 133                                 if (bits.Get(doc))
 134                                 {
 135                                         // skip docs not in bits
 136                                         results.Collect(doc, score);
 137                                 }
 138                         }
 139                 }
 140                 public /*internal*/ IndexReader reader;
 141                 private bool closeReader;
 142
 143                 /// <summary>Creates a searcher searching the index in the named directory. </summary>
 144                 public IndexSearcher(System.String path) : this(IndexReader.Open(path), true)
 145                 {
 146                 }
 147
 148                 /// <summary>Creates a searcher searching the index in the provided directory. </summary>
 149                 public IndexSearcher(Directory directory) : this(IndexReader.Open(directory), true)
 150                 {
 151                 }
 152
 153                 /// <summary>Creates a searcher searching the provided index. </summary>
 154                 public IndexSearcher(IndexReader r) : this(r, false)
 155                 {
 156                 }
 157
 158                 private IndexSearcher(IndexReader r, bool closeReader)
 159                 {
 160                         reader = r;
 161                         this.closeReader = closeReader;
 162                 }
 163
 164                 /// <summary> Note that the underlying IndexReader is not closed, if
 165                 /// IndexSearcher was constructed with IndexSearcher(IndexReader r).
 166                 /// If the IndexReader was supplied implicitly by specifying a directory, then
 167                 /// the IndexReader gets closed.
 168                 /// </summary>
 169                 public override void Close()
 170                 {
 171                         if (closeReader)
 172                                 reader.Close();
 173                 }
 174
 175                 // inherit javadoc
 176                 public override int DocFreq(Term term)
 177                 {
 178                         return reader.DocFreq(term);
 179                 }
 180
 181                 // inherit javadoc
 182                 public override Document Doc(int i)
 183                 {
 184                         return reader.Document(i);
 185                 }
 186
 187                 // inherit javadoc
 188                 public override int MaxDoc()
 189                 {
 190                         return reader.MaxDoc();
 191                 }
 192
 193                 // inherit javadoc
 194                 public override TopDocs Search(Query query, Filter filter, int nDocs)
 195                 {
 196                         Scorer scorer = query.Weight(this).Scorer(reader);
 197                         if (scorer == null)
 198                                 return new TopDocs(0, new ScoreDoc[0]);
 199
 200                         System.Collections.BitArray bits = filter != null ? filter.Bits(reader) : null;
 201                         HitQueue hq = new HitQueue(nDocs);
 202                         int[] totalHits = new int[1];
 203                         scorer.Score(new AnonymousClassHitCollector(bits, totalHits, hq, nDocs, this));
 204
 205                         ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
 206                         for (int i = hq.Size() - 1; i >= 0; i--)
 207                         // put docs in array
 208                                 scoreDocs[i] = (ScoreDoc) hq.Pop();
 209
 210                         return new TopDocs(totalHits[0], scoreDocs);
 211                 }
 212
 213                 // inherit javadoc
 214                 public override TopFieldDocs Search(Query query, Filter filter, int nDocs, Sort sort)
 215                 {
 216                         Scorer scorer = query.Weight(this).Scorer(reader);
 217                         if (scorer == null)
 218                                 return new TopFieldDocs(0, new ScoreDoc[0], sort.fields);
 219
 220                         System.Collections.BitArray bits = filter != null ? filter.Bits(reader) : null;
 221                         FieldSortedHitQueue hq = new FieldSortedHitQueue(reader, sort.fields, nDocs);
 222                         int[] totalHits = new int[1];
 223                         scorer.Score(new AnonymousClassHitCollector1(bits, totalHits, hq, this));
 224
 225                         ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
 226                         for (int i = hq.Size() - 1; i >= 0; i--)
 227                         // put docs in array
 228                                 scoreDocs[i] = hq.FillFields((FieldDoc) hq.Pop());
 229
 230                         return new TopFieldDocs(totalHits[0], scoreDocs, hq.GetFields());
 231                 }
 232
 233
 234                 // inherit javadoc
 235                 public override void  Search(Query query, Filter filter, HitCollector results)
 236                 {
 237                         HitCollector collector = results;
 238                         if (filter != null)
 239                         {
 240                                 System.Collections.BitArray bits = filter.Bits(reader);
 241                                 collector = new AnonymousClassHitCollector2(bits, results, this);
 242                         }
 243
 244                         Scorer scorer = query.Weight(this).Scorer(reader);
 245                         if (scorer == null)
 246                                 return ;
 247                         scorer.Score(collector);
 248                 }
 249
 250                 public override Query Rewrite(Query original)
 251                 {
 252                         Query query = original;
 253                         for (Query rewrittenQuery = query.Rewrite(reader); rewrittenQuery != query; rewrittenQuery = query.Rewrite(reader))
 254                         {
 255                                 query = rewrittenQuery;
 256                         }
 257                         return query;
 258                 }
 259
 260                 public override Explanation Explain(Query query, int doc)
 261                 {
 262                         return query.Weight(this).Explain(reader, doc);
 263                 }
 264         }
 265 }