beagled/Lucene.Net/Index/SegmentsReader.cs

   1 using System;
   2 using System.Collections;
   3 using System.Runtime.CompilerServices;
   4
   5 using Lucene.Net.Documents;
   6 using Lucene.Net.Store;
   7
   8 namespace Lucene.Net.Index
   9 {
  10         /* ====================================================================
  11          * The Apache Software License, Version 1.1
  12          *
  13          * Copyright (c) 2001 The Apache Software Foundation.  All rights
  14          * reserved.
  15          *
  16          * Redistribution and use in source and binary forms, with or without
  17          * modification, are permitted provided that the following conditions
  18          * are met:
  19          *
  20          * 1. Redistributions of source code must retain the above copyright
  21          *    notice, this list of conditions and the following disclaimer.
  22          *
  23          * 2. Redistributions in binary form must reproduce the above copyright
  24          *    notice, this list of conditions and the following disclaimer in
  25          *    the documentation and/or other materials provided with the
  26          *    distribution.
  27          *
  28          * 3. The end-user documentation included with the redistribution,
  29          *    if any, must include the following acknowledgment:
  30          *       "This product includes software developed by the
  31          *        Apache Software Foundation (http://www.apache.org/)."
  32          *    Alternately, this acknowledgment may appear in the software itself,
  33          *    if and wherever such third-party acknowledgments normally appear.
  34          *
  35          * 4. The names "Apache" and "Apache Software Foundation" and
  36          *    "Apache Lucene" must not be used to endorse or promote products
  37          *    derived from this software without prior written permission. For
  38          *    written permission, please contact apache@apache.org.
  39          *
  40          * 5. Products derived from this software may not be called "Apache",
  41          *    "Apache Lucene", nor may "Apache" appear in their name, without
  42          *    prior written permission of the Apache Software Foundation.
  43          *
  44          * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  45          * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  46          * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  47          * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  48          * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  49          * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  50          * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  51          * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  52          * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  53          * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  54          * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55          * SUCH DAMAGE.
  56          * ====================================================================
  57          *
  58          * This software consists of voluntary contributions made by many
  59          * individuals on behalf of the Apache Software Foundation.  For more
  60          * information on the Apache Software Foundation, please see
  61          * <http://www.apache.org/>.
  62          */
  63
  64         sealed class SegmentsReader : IndexReader
  65         {
  66                 private SegmentReader[] readers;
  67                 private int[] starts;                     // 1st docno for each segment
  68                 private Hashtable normsCache = new Hashtable();
  69                 private int maxDoc = 0;
  70                 private int numDocs = -1;
  71                 private bool hasDeletions = false;
  72
  73                 internal SegmentsReader(Directory directory, SegmentReader[] r)
  74                         : base(directory)
  75                 {
  76                         readers = r;
  77                         starts = new int[readers.Length + 1];     // build starts array
  78                         for (int i = 0; i < readers.Length; i++)
  79                         {
  80                                 starts[i] = maxDoc;
  81                                 maxDoc += readers[i].MaxDoc();            // compute maxDocs
  82
  83                                 if (readers[i].HasDeletions())
  84                                         hasDeletions = true;
  85                         }
  86                         starts[readers.Length] = maxDoc;
  87                 }
  88
  89                 [MethodImpl(MethodImplOptions.Synchronized)]
  90                 override public int NumDocs()
  91                 {
  92                         if (numDocs == -1)
  93                         {                         // check cache
  94                                 int n = 0;                                // cache miss--recompute
  95                                 for (int i = 0; i < readers.Length; i++)
  96                                         n += readers[i].NumDocs();                // sum from readers
  97                                 numDocs = n;
  98                         }
  99                         return numDocs;
 100                 }
 101
 102                 override public int MaxDoc()
 103                 {
 104                         return maxDoc;
 105                 }
 106
 107                 override public Document Document(int n)
 108                 {
 109                         int i = ReaderIndex(n);                   // find segment num
 110                         return readers[i].Document(n - starts[i]);        // dispatch to segment reader
 111                 }
 112
 113                 override public bool IsDeleted(int n)
 114                 {
 115                         int i = ReaderIndex(n);                   // find segment num
 116                         return readers[i].IsDeleted(n - starts[i]);       // dispatch to segment reader
 117                 }
 118
 119                 public override bool HasDeletions()
 120                 {
 121                         return hasDeletions;
 122                 }
 123
 124                 [MethodImpl(MethodImplOptions.Synchronized)]
 125                 override protected internal void DoDelete(int n)
 126                 {
 127                         numDocs = -1;                             // invalidate cache
 128                         int i = ReaderIndex(n);                   // find segment num
 129                         readers[i].DoDelete(n - starts[i]);               // dispatch to segment reader
 130                         hasDeletions = true;
 131                 }
 132
 133                 public override void UndeleteAll()
 134                 {
 135                         for (int i = 0; i < readers.Length; i++)
 136                                 readers[i].UndeleteAll();
 137                 }
 138
 139                 private int ReaderIndex(int n)
 140                 {         // find reader for doc n:
 141                         int lo = 0;                                       // search starts array
 142                         int hi = readers.Length - 1;                  // for first element less
 143
 144                         while (hi >= lo)
 145                         {
 146                                 int mid = (lo + hi) >> 1;
 147                                 int midValue = starts[mid];
 148                                 if (n < midValue)
 149                                         hi = mid - 1;
 150                                 else if (n > midValue)
 151                                         lo = mid + 1;
 152                                 else
 153                                 {                                      // found a match
 154                                         while (mid+1 < readers.Length && starts[mid+1] == midValue)
 155                                         {
 156                                                 mid++;                                  // scan to last match
 157                                         }
 158                                         return mid;
 159                                 }
 160                         }
 161                         return hi;
 162                 }
 163
 164                 [MethodImpl(MethodImplOptions.Synchronized)]
 165                 override public byte[] Norms(String field)
 166                 {
 167                         byte[] bytes = (byte[])normsCache[field];
 168                         if (bytes != null)
 169                                 return bytes;                             // cache hit
 170
 171                         bytes = new byte[MaxDoc()];
 172                         for (int i = 0; i < readers.Length; i++)
 173                                 readers[i].Norms(field, bytes, starts[i]);
 174                         normsCache.Add(field, bytes);             // update cache
 175                         return bytes;
 176                 }
 177
 178                 override public TermEnum Terms()
 179                 {
 180                         return new SegmentsTermEnum(readers, starts, null);
 181                 }
 182
 183                 override public TermEnum Terms(Term term)
 184                 {
 185                         return new SegmentsTermEnum(readers, starts, term);
 186                 }
 187
 188                 override public int DocFreq(Term t)
 189                 {
 190                         int total = 0;                            // sum freqs in segments
 191                         for (int i = 0; i < readers.Length; i++)
 192                                 total += readers[i].DocFreq(t);
 193                         return total;
 194                 }
 195
 196                 override public TermDocs TermDocs()
 197                 {
 198                         return new SegmentsTermDocs(readers, starts);
 199                 }
 200
 201                 override public TermPositions TermPositions()
 202                 {
 203                         return new SegmentsTermPositions(readers, starts);
 204                 }
 205
 206                 [MethodImpl(MethodImplOptions.Synchronized)]
 207                 override protected internal void DoClose()
 208                 {
 209                         for (int i = 0; i < readers.Length; i++)
 210                                 readers[i].Close();
 211                 }
 212
 213                 override public ICollection GetFieldNames()
 214                 {
 215                         // maintain a unique set of field names
 216                         Hashtable fieldSet = new Hashtable();
 217                         for (int i = 0; i < readers.Length; i++)
 218                         {
 219                                 SegmentReader reader = readers[i];
 220                                 ICollection names = reader.GetFieldNames();
 221                                 // iterate through the field names and add them to the set
 222                                 foreach (string de in names)
 223                                 {
 224                                         fieldSet[de] = "";
 225                                 }
 226                         }
 227                         return fieldSet.Keys;
 228                 }
 229
 230                 public override ICollection GetFieldNames(bool indexed)
 231                 {
 232                         // maintain a unique set of field names
 233                         Hashtable fieldSet = new Hashtable();
 234                         for (int i = 0; i < readers.Length; i++)
 235                         {
 236                                 SegmentReader reader = readers[i];
 237                                 ICollection names = reader.GetFieldNames(indexed);
 238                                 foreach (string de in names)
 239                                 {
 240                                         fieldSet[de] = "";
 241                                 }
 242                         }
 243                         return fieldSet.Keys;
 244                 }
 245         }
 246
 247         class SegmentsTermEnum : TermEnum
 248         {
 249                 private SegmentMergeQueue queue;
 250
 251                 private Term term;
 252                 private int docFreq;
 253
 254                 internal SegmentsTermEnum(SegmentReader[] readers, int[] starts, Term t)
 255                 {
 256                         queue = new SegmentMergeQueue(readers.Length);
 257                         for (int i = 0; i < readers.Length; i++)
 258                         {
 259                                 SegmentReader reader = readers[i];
 260                                 SegmentTermEnum termEnum;
 261
 262                                 if (t != null)
 263                                 {
 264                                         termEnum = (SegmentTermEnum)reader.Terms(t);
 265                                 }
 266                                 else
 267                                         termEnum = (SegmentTermEnum)reader.Terms();
 268
 269                                 SegmentMergeInfo smi = new SegmentMergeInfo(starts[i], termEnum, reader);
 270                                 if (t == null ? smi.Next() : termEnum.Term() != null)
 271                                         queue.Put(smi);                           // initialize queue
 272                                 else
 273                                         smi.Close();
 274                         }
 275
 276                         if (t != null && queue.Size() > 0)
 277                         {
 278                                 Next();
 279                         }
 280                 }
 281
 282                 override public bool Next()
 283                 {
 284                         SegmentMergeInfo top = (SegmentMergeInfo)queue.Top();
 285                         if (top == null)
 286                         {
 287                                 term = null;
 288                                 return false;
 289                         }
 290
 291                         term = top.term;
 292                         docFreq = 0;
 293
 294                         while (top != null && term.CompareTo(top.term) == 0)
 295                         {
 296                                 queue.Pop();
 297                                 docFreq += top.termEnum.DocFreq();        // increment freq
 298                                 if (top.Next())
 299                                         queue.Put(top);                           // restore queue
 300                                 else
 301                                         top.Close();                              // done with a segment
 302                                 top = (SegmentMergeInfo)queue.Top();
 303                         }
 304                         return true;
 305                 }
 306
 307                 override public Term Term()
 308                 {
 309                         return term;
 310                 }
 311
 312                 override public int DocFreq()
 313                 {
 314                         return docFreq;
 315                 }
 316
 317                 override public void Close()
 318                 {
 319                         queue.Close();
 320                 }
 321         }
 322
 323         class SegmentsTermDocs : TermDocs
 324         {
 325                 protected SegmentReader[] readers;
 326                 protected int[] starts;
 327                 protected Term term;
 328
 329                 protected int _base = 0;
 330                 protected int pointer = 0;
 331
 332                 private SegmentTermDocs[] segTermDocs;
 333                 protected SegmentTermDocs current;              // == segTermDocs[pointer]
 334
 335                 internal SegmentsTermDocs(SegmentReader[] r, int[] s)
 336                 {
 337                         readers = r;
 338                         starts = s;
 339
 340                         segTermDocs = new SegmentTermDocs[r.Length];
 341                 }
 342
 343                 public int Doc()
 344                 {
 345                         return _base + current.doc;
 346                 }
 347                 public int Freq()
 348                 {
 349                         return current.freq;
 350                 }
 351
 352                 public void Seek(Term term)
 353                 {
 354                         this.term = term;
 355                         this._base = 0;
 356                         this.pointer = 0;
 357                         this.current = null;
 358                 }
 359
 360                 public void Seek(TermEnum termEnum)
 361                 {
 362                         Seek(termEnum.Term());
 363                 }
 364
 365                 public bool Next()
 366                 {
 367                         if (current != null && current.Next())
 368                         {
 369                                 return true;
 370                         }
 371                         else if (pointer < readers.Length)
 372                         {
 373                                 _base = starts[pointer];
 374                                 current = TermDocs(pointer++);
 375                                 return Next();
 376                         }
 377                         else
 378                                 return false;
 379                 }
 380
 381                 /// <summary>
 382                 /// Optimized implementation.
 383                 /// </summary>
 384                 /// <param name="docs"></param>
 385                 /// <param name="freqs"></param>
 386                 /// <returns></returns>
 387                 public int Read(int[] docs, int[] freqs)
 388                 {
 389                         while (true)
 390                         {
 391                                 while (current == null)
 392                                 {
 393                                         if (pointer < readers.Length)
 394                                         {                 // try next segment
 395                                                 _base = starts[pointer];
 396                                                 current = TermDocs(pointer++);
 397                                         }
 398                                         else
 399                                         {
 400                                                 return 0;
 401                                         }
 402                                 }
 403                                 int end = current.Read(docs, freqs);
 404                                 if (end == 0)
 405                                 {                                 // none left in segment
 406                                         current = null;
 407                                 }
 408                                 else
 409                                 {                                         // got some
 410                                         int b = _base;                    // adjust doc numbers
 411                                         for (int i = 0; i < end; i++)
 412                                                 docs[i] += b;
 413                                         return end;
 414                                 }
 415                         }
 416                 }
 417
 418                 /// <summary>
 419                 /// As yet unoptimized implementation.
 420                 /// </summary>
 421                 /// <param name="target"></param>
 422                 /// <returns></returns>
 423                 public bool SkipTo(int target)
 424                 {
 425                         do
 426                         {
 427                                 if (!Next())
 428                                         return false;
 429                         } while (target > Doc());
 430                         return true;
 431                 }
 432
 433                 private SegmentTermDocs TermDocs(int i)
 434                 {
 435                         if (term == null)
 436                                 return null;
 437                         SegmentTermDocs result = segTermDocs[i];
 438                         if (result == null)
 439                                 result = segTermDocs[i] = TermDocs(readers[i]);
 440                         result.Seek(term);
 441                         return result;
 442                 }
 443
 444                 virtual protected SegmentTermDocs TermDocs(SegmentReader reader)
 445                 {
 446                         return (SegmentTermDocs)reader.TermDocs();
 447                 }
 448
 449                 public void Close()
 450                 {
 451                         for (int i = 0; i < segTermDocs.Length; i++)
 452                         {
 453                                 if (segTermDocs[i] != null)
 454                                         segTermDocs[i].Close();
 455                         }
 456                 }
 457         }
 458
 459         class SegmentsTermPositions : SegmentsTermDocs, TermPositions
 460         {
 461                 internal SegmentsTermPositions(SegmentReader[] r, int[] s) : base(r,s)
 462                 {
 463                 }
 464
 465                 override protected SegmentTermDocs TermDocs(SegmentReader reader)
 466                 {
 467                         return (SegmentTermDocs)reader.TermPositions();
 468                 }
 469
 470                 public int NextPosition()
 471                 {
 472                         return ((SegmentTermPositions)current).NextPosition();
 473                 }
 474         }
 475 }