cpp/galago/src/DocumentOrderedBinnedRetrieval.cpp

   1
   2 //
   3 // DocumentOrderedBinnedRetrieval
   4 //
   5 // 15 October 2007 -- tds
   6 //
   7
   8 #include "DocumentOrderedBinnedRetrieval.hpp"
   9 #include "indri/ScoredExtentResult.hpp"
  10 #include "Query.hpp"
  11 #include <vector>
  12 #include <queue>
  13 #include <assert.h>
  14 #include "lemur/Exception.hpp"
  15 #include "Logging.hpp"
  16
  17 //
  18 // openRead
  19 //
  20
  21 void DocumentOrderedBinnedRetrieval::openRead( const std::string& indexPath ) {
  22     _index.openRead( indexPath );
  23 }
  24
  25 //
  26 // runQuery
  27 //
  28
  29 std::vector<indri::api::ScoredExtentResult>
  30     DocumentOrderedBinnedRetrieval::runQuery( const std::vector<QueryTerm>& terms,
  31                                               int requested,
  32                                               int threshold ) {
  33     std::priority_queue<indri::api::ScoredExtentResult> results;
  34
  35     std::vector<DocumentOrderedBinnedIterator*> iterators = getIterators( terms );
  36     galago_log_query_terms( iterators.size() );
  37
  38     while (true) {
  39         // determine which document to score
  40         int document = MAX_INT32;
  41
  42         for( int i=0; i<iterators.size(); i++ ) {
  43             DocumentOrderedBinnedIterator* iterator = iterators[i];
  44             if( iterator->isDone() )
  45                 continue;
  46
  47             document = std::min( document, iterator->currentDocument() );
  48         }
  49
  50         if( document == MAX_INT32 )
  51             break;
  52
  53         // move all iterators to the document and score
  54         int score = 0;
  55
  56         for( int i=0; i<iterators.size(); i++ ) {
  57             DocumentOrderedBinnedIterator* iterator = iterators[i];
  58
  59             iterator->skipToDocument( document );
  60             if( iterator->isDone() || iterator->currentDocument() != document )
  61                 continue;
  62
  63             score += iterator->currentScore();
  64         }
  65
  66         // store this result
  67         results.push( indri::api::ScoredExtentResult( score, document, 0, 0 ) );
  68
  69         while( results.size() > requested )
  70             results.pop();
  71
  72         // move the matching iterators forward
  73         for( int i=0; i<iterators.size(); i++ ) {
  74             DocumentOrderedBinnedIterator* iterator = iterators[i];
  75
  76             if( !iterator->isDone() && iterator->currentDocument() == document )
  77                 iterator->nextDocument();
  78         }
  79     }
  80
  81     // convert priority queue into real results
  82     std::vector<indri::api::ScoredExtentResult> vectorResults;
  83
  84     while( results.size() > 0 ) {
  85         vectorResults.push_back( results.top() );
  86         results.pop();
  87     }
  88
  89     std::sort( vectorResults.begin(), vectorResults.end() );
  90     return vectorResults;
  91 }
  92
  93 //
  94 // getIterators
  95 //
  96
  97 std::vector<DocumentOrderedBinnedIterator*>
  98     DocumentOrderedBinnedRetrieval::getIterators( const std::vector<QueryTerm>& terms ) {
  99     std::vector<DocumentOrderedBinnedIterator*> iterators;
 100
 101     for( int i=0; i<terms.size(); i++ ) {
 102         const QueryTerm& term = terms[i];
 103         DocumentOrderedBinnedIterator* iterator = _index.getTerm( term.text, term.field );
 104
 105         if( iterator )
 106             iterators.push_back( iterator );
 107     }
 108
 109     return iterators;
 110 }
 111
 112 //
 113 // getDocument
 114 //
 115
 116 std::string DocumentOrderedBinnedRetrieval::getDocument( int doc ) {
 117     return _index.getDocument(doc);
 118 }
 119
 120 //
 121 // close
 122 //
 123
 124 void DocumentOrderedBinnedRetrieval::close() {
 125     _index.close();
 126 }