xapian-core/backends/honey/honey_postlist.h

   1 /** @file honey_postlist.h
   2  * @brief PostList in a honey database.
   3  */
   4 /* Copyright (C) 2007,2009,2011,2013,2015,2016,2017 Olly Betts
   5  * Copyright (C) 2009 Lemur Consulting Ltd
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  20  */
  21
  22 #ifndef XAPIAN_INCLUDED_HONEY_POSTLIST_H
  23 #define XAPIAN_INCLUDED_HONEY_POSTLIST_H
  24
  25 #include "api/leafpostlist.h"
  26 #include "honey_positionlist.h"
  27 #include "pack.h"
  28
  29 #include <string>
  30
  31 class HoneyCursor;
  32 class HoneyDatabase;
  33
  34 namespace Honey {
  35
  36 /** Generate a key for a posting initial chunk. */
  37 inline std::string
  38 make_postingchunk_key(const std::string& term)
  39 {
  40     std::string key;
  41     pack_string_preserving_sort(key, term, true);
  42     return key;
  43 }
  44
  45 /** Generate a key for a posting continuation chunk. */
  46 inline std::string
  47 make_postingchunk_key(const std::string& term, Xapian::docid did)
  48 {
  49     std::string key;
  50     pack_string_preserving_sort(key, term);
  51     pack_uint_preserving_sort(key, did);
  52     return key;
  53 }
  54
  55 inline Xapian::docid
  56 docid_from_key(const std::string& term, const std::string& key)
  57 {
  58     if (key.size() < term.size()) {
  59         // A key can't be shorter than the term it contains.
  60         return false;
  61     }
  62     const char * p = key.data();
  63     const char * end = p + key.size();
  64     // Most terms don't contain zero bytes, so we could optimise this.
  65     std::string term_in_key;
  66     // FIXME: the next key might not be for a postlist chunk...
  67     if (!unpack_string_preserving_sort(&p, end, term_in_key))
  68         throw Xapian::DatabaseCorruptError("bad postlist key");
  69     if (term_in_key != term)
  70         return false;
  71     Xapian::docid did;
  72     if (!unpack_uint_preserving_sort(&p, end, &did))
  73         throw Xapian::DatabaseCorruptError("bad postlist key");
  74     return did;
  75 }
  76
  77 class PostingChunkReader {
  78     const char *p;
  79     const char *end;
  80
  81     Xapian::docid did;
  82
  83     Xapian::termcount wdf;
  84
  85     /// The last docid in this chunk.
  86     Xapian::docid last_did;
  87
  88     Xapian::doccount termfreq;
  89
  90     Xapian::termcount collfreq;
  91
  92   public:
  93     /// Create an uninitialised PostingChunkReader.
  94     PostingChunkReader() : p(NULL) { }
  95
  96     /// Initialise already at_end().
  97     void init() {
  98         p = NULL;
  99         termfreq = 0;
 100     }
 101
 102     /// Initialise.
 103     void init(Xapian::doccount tf, Xapian::termcount cf) {
 104         p = NULL;
 105         termfreq = tf;
 106         collfreq = cf;
 107     }
 108
 109     void assign(const char * p_, size_t len, Xapian::docid did);
 110
 111     void assign(const char * p_, size_t len, Xapian::docid did_,
 112                 Xapian::docid last_did_in_chunk,
 113                 Xapian::termcount wdf_);
 114
 115     bool at_end() const { return p == NULL; }
 116
 117     Xapian::doccount get_termfreq() const { return termfreq; }
 118
 119     Xapian::docid get_docid() const { return did; }
 120
 121     Xapian::termcount get_wdf() const { return wdf; }
 122
 123     /// Advance, returning false if we've run out of data.
 124     bool next();
 125
 126     /// Skip ahead, returning false if we've run out of data.
 127     bool skip_to(Xapian::docid target);
 128 };
 129
 130 }
 131
 132 /** PostList in a honey database. */
 133 class HoneyPostList : public LeafPostList {
 134     /// Don't allow assignment.
 135     HoneyPostList& operator=(const HoneyPostList&) = delete;
 136
 137     /// Don't allow copying.
 138     HoneyPostList(const HoneyPostList&) = delete;
 139
 140     /// Cursor on the postlist table.
 141     HoneyCursor* cursor;
 142
 143     Honey::PostingChunkReader reader;
 144
 145     /// The highest document id in this posting list.
 146     Xapian::docid last_did;
 147
 148     /// HoneyDatabase to get position table object from.
 149     const HoneyDatabase* db;
 150
 151     /** Needed so that first next() does nothing.
 152      *
 153      *  FIXME: Can we arrange not to need this?
 154      */
 155     bool started = false;
 156
 157     /// Update @a reader to use the chunk currently pointed to by @a cursor.
 158     bool update_reader();
 159
 160   public:
 161     /// Create HoneyPostList from already positioned @a cursor_.
 162     HoneyPostList(const HoneyDatabase* db_,
 163                   const std::string& term_,
 164                   HoneyCursor* cursor_);
 165
 166     ~HoneyPostList();
 167
 168     Xapian::doccount get_termfreq() const;
 169
 170     LeafPostList* open_nearby_postlist(const std::string& term_,
 171                                        bool need_pos) const;
 172
 173     Xapian::docid get_docid() const;
 174
 175     Xapian::termcount get_wdf() const;
 176
 177     bool at_end() const;
 178
 179     PositionList* open_position_list() const;
 180
 181     PostList* next(double w_min);
 182
 183     PostList* skip_to(Xapian::docid did, double w_min);
 184
 185     std::string get_description() const;
 186 };
 187
 188 /** PostList in a honey database with positions.
 189  *
 190  *  Use a special subclass to avoid the size cost for the common case where we
 191  *  don't want positional data.
 192  */
 193 class HoneyPosPostList : public HoneyPostList {
 194     /** PositionList object to reuse for OP_NEAR and OP_PHRASE.
 195      *
 196      *  This saves the overhead of creating objects for every document
 197      *  considered.
 198      */
 199     HoneyRePositionList position_list;
 200
 201   public:
 202     HoneyPosPostList(const HoneyDatabase* db_,
 203                      const std::string& term_,
 204                      HoneyCursor* cursor_);
 205
 206     PositionList* read_position_list();
 207
 208     std::string get_description() const;
 209 };
 210
 211 #endif // XAPIAN_INCLUDED_HONEY_POSTLIST_H