LCOV - code coverage report
Current view: top level - backends/honey - honey_database.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core c2b6f1024d3a Lines: 143 182 78.6 %
Date: 2019-05-16 09:13:18 Functions: 36 50 72.0 %
Branches: 90 202 44.6 %

           Branch data     Line data    Source code
       1                 :            : /** @file honey_database.cc
       2                 :            :  * @brief Honey backend database class
       3                 :            :  */
       4                 :            : /* Copyright 2015,2017,2018 Olly Betts
       5                 :            :  *
       6                 :            :  * This program is free software; you can redistribute it and/or
       7                 :            :  * modify it under the terms of the GNU General Public License as
       8                 :            :  * published by the Free Software Foundation; either version 2 of the
       9                 :            :  * License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This program is distributed in the hope that it will be useful,
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            :  * GNU General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU General Public License
      17                 :            :  * along with this program; if not, write to the Free Software
      18                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
      19                 :            :  */
      20                 :            : 
      21                 :            : #include <config.h>
      22                 :            : 
      23                 :            : #include "honey_database.h"
      24                 :            : 
      25                 :            : #include "honey_alltermslist.h"
      26                 :            : #include "honey_document.h"
      27                 :            : #include "honey_metadata.h"
      28                 :            : #include "honey_termlist.h"
      29                 :            : #include "honey_spellingwordslist.h"
      30                 :            : #include "honey_valuelist.h"
      31                 :            : 
      32                 :            : #include "api/leafpostlist.h"
      33                 :            : #include "backends/backends.h"
      34                 :            : #include "xapian/error.h"
      35                 :            : 
      36                 :            : using namespace std;
      37                 :            : 
      38                 :            : void
      39                 :          1 : HoneyDatabase::throw_termlist_table_close_exception() const
      40                 :            : {
      41                 :            :     // Either the database has been closed, or else there's no termlist table.
      42                 :            :     // Check if the postlist table is open to determine which is the case.
      43         [ +  - ]:          1 :     if (!postlist_table.is_open())
      44                 :          1 :         HoneyTable::throw_database_closed();
      45 [ #  # ][ #  # ]:          0 :     throw Xapian::FeatureUnavailableError("Database has no termlist");
                 [ #  # ]
      46                 :            : }
      47                 :            : 
      48                 :            : // Relied on below - opening to read should allow the termlist to be missing.
      49                 :            : static_assert(Xapian::DB_READONLY_ & Xapian::DB_NO_TERMLIST,
      50                 :            :         "Xapian::DB_READONLY_ should imply Xapian::DB_NO_TERMLIST");
      51                 :            : 
      52                 :        304 : HoneyDatabase::HoneyDatabase(const std::string& path_, int flags)
      53                 :            :     : Xapian::Database::Internal(TRANSACTION_READONLY),
      54                 :            :       path(path_),
      55                 :            :       version_file(path_),
      56                 :            :       docdata_table(path_, true),
      57                 :            :       postlist_table(path_, true),
      58                 :            :       position_table(path_, true),
      59                 :            :       spelling_table(path_, true),
      60                 :            :       synonym_table(path_, true),
      61                 :            :       // Note: (Xapian::DB_READONLY_ & Xapian::DB_NO_TERMLIST) is true, so
      62                 :            :       // opening to read we always allow the termlist to be missing.
      63                 :        304 :       termlist_table(path_, true, (flags & Xapian::DB_NO_TERMLIST)),
      64 [ +  - ][ +  - ]:        304 :       value_manager(postlist_table, termlist_table)
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
                 [ +  - ]
      65                 :            : {
      66         [ +  - ]:        304 :     version_file.read();
      67                 :        304 :     auto rev = version_file.get_revision();
      68         [ +  - ]:        304 :     docdata_table.open(flags, version_file.get_root(Honey::DOCDATA), rev);
      69         [ +  - ]:        304 :     postlist_table.open(flags, version_file.get_root(Honey::POSTLIST), rev);
      70         [ +  - ]:        304 :     position_table.open(flags, version_file.get_root(Honey::POSITION), rev);
      71         [ +  - ]:        304 :     spelling_table.open(flags, version_file.get_root(Honey::SPELLING), rev);
      72         [ +  - ]:        304 :     synonym_table.open(flags, version_file.get_root(Honey::SYNONYM), rev);
      73         [ +  - ]:        304 :     termlist_table.open(flags, version_file.get_root(Honey::TERMLIST), rev);
      74                 :        304 : }
      75                 :            : 
      76                 :          1 : HoneyDatabase::HoneyDatabase(int fd, int flags)
      77                 :            :     : Xapian::Database::Internal(TRANSACTION_READONLY),
      78                 :            :       version_file(fd),
      79                 :            :       docdata_table(fd, version_file.get_offset(), true),
      80                 :            :       postlist_table(fd, version_file.get_offset(), true),
      81                 :            :       position_table(fd, version_file.get_offset(), true),
      82                 :            :       spelling_table(fd, version_file.get_offset(), true),
      83                 :            :       synonym_table(fd, version_file.get_offset(), true),
      84                 :            :       // Note: (Xapian::DB_READONLY_ & Xapian::DB_NO_TERMLIST) is true, so
      85                 :            :       // opening to read we always allow the termlist to be missing.
      86                 :            :       termlist_table(fd, version_file.get_offset(), true,
      87                 :          1 :                      (flags & Xapian::DB_NO_TERMLIST)),
      88 [ +  - ][ +  - ]:          1 :       value_manager(postlist_table, termlist_table)
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
                 [ +  - ]
      89                 :            : {
      90         [ +  - ]:          1 :     version_file.read();
      91                 :          1 :     auto rev = version_file.get_revision();
      92         [ +  - ]:          1 :     docdata_table.open(flags, version_file.get_root(Honey::DOCDATA), rev);
      93         [ +  - ]:          1 :     postlist_table.open(flags, version_file.get_root(Honey::POSTLIST), rev);
      94         [ +  - ]:          1 :     position_table.open(flags, version_file.get_root(Honey::POSITION), rev);
      95         [ +  - ]:          1 :     spelling_table.open(flags, version_file.get_root(Honey::SPELLING), rev);
      96         [ +  - ]:          1 :     synonym_table.open(flags, version_file.get_root(Honey::SYNONYM), rev);
      97         [ +  - ]:          1 :     termlist_table.open(flags, version_file.get_root(Honey::TERMLIST), rev);
      98                 :          1 : }
      99                 :            : 
     100                 :        915 : HoneyDatabase::~HoneyDatabase()
     101                 :            : {
     102         [ +  + ]:        305 :     delete doclen_cursor;
     103         [ -  + ]:        610 : }
     104                 :            : 
     105                 :            : void
     106                 :      26679 : HoneyDatabase::readahead_for_query(const Xapian::Query& query) const
     107                 :            : {
     108                 :            :     (void)query;
     109                 :            :     // FIXME: Implement - pre-read the start of the postlist table?
     110                 :      26679 : }
     111                 :            : 
     112                 :            : Xapian::doccount
     113                 :     110044 : HoneyDatabase::get_doccount() const
     114                 :            : {
     115                 :     110044 :     return version_file.get_doccount();
     116                 :            : }
     117                 :            : 
     118                 :            : Xapian::docid
     119                 :        188 : HoneyDatabase::get_lastdocid() const
     120                 :            : {
     121                 :        188 :     return version_file.get_last_docid();
     122                 :            : }
     123                 :            : 
     124                 :            : Xapian::totallength
     125                 :      53975 : HoneyDatabase::get_total_length() const
     126                 :            : {
     127                 :      53975 :     return version_file.get_total_doclen();
     128                 :            : }
     129                 :            : 
     130                 :            : Xapian::termcount
     131                 :    9512534 : HoneyDatabase::get_doclength(Xapian::docid did) const
     132                 :            : {
     133                 :            :     Assert(did != 0);
     134         [ +  + ]:    9512534 :     if (usual(did <= version_file.get_last_docid())) {
     135         [ +  + ]:    9512527 :         if (doclen_cursor == NULL) {
     136         [ +  - ]:        170 :             doclen_cursor = get_postlist_cursor();
     137                 :            :         } else {
     138 [ +  - ][ +  + ]:    9512357 :             if (doclen_chunk_reader.find_doclength(did)) {
     139                 :    9512314 :                 return doclen_chunk_reader.get_doclength();
     140                 :            :             }
     141                 :            :         }
     142                 :            : 
     143                 :            :         // If exact is true, the desired docid is the last in this chunk.
     144                 :            :         bool exact =
     145 [ +  - ][ +  - ]:        213 :             doclen_cursor->find_entry_ge(Honey::make_doclenchunk_key(did));
     146 [ +  - ][ +  - ]:        213 :         if (doclen_chunk_reader.update(doclen_cursor)) {
     147         [ +  + ]:        213 :             if (exact)
     148         [ +  - ]:         19 :                 return doclen_chunk_reader.back();
     149 [ +  - ][ +  - ]:        194 :             if (doclen_chunk_reader.find_doclength(did)) {
     150                 :        194 :                 return doclen_chunk_reader.get_doclength();
     151                 :            :             }
     152                 :            :         }
     153                 :            :     }
     154                 :            : 
     155         [ +  - ]:          7 :     string message = "Document ID not in use: ";
     156 [ +  - ][ +  - ]:          7 :     message += str(did);
     157 [ +  - ][ +  - ]:    9512534 :     throw Xapian::DocNotFoundError(message);
     158                 :            : }
     159                 :            : 
     160                 :            : Xapian::termcount
     161                 :        536 : HoneyDatabase::get_unique_terms(Xapian::docid did) const
     162                 :            : {
     163                 :            :     Assert(did != 0);
     164         [ +  - ]:        536 :     return HoneyTermList(this, did).get_unique_terms();
     165                 :            : }
     166                 :            : 
     167                 :            : void
     168                 :      59748 : HoneyDatabase::get_freqs(const string& term,
     169                 :            :                          Xapian::doccount* termfreq_ptr,
     170                 :            :                          Xapian::termcount* collfreq_ptr) const
     171                 :            : {
     172                 :      59748 :     postlist_table.get_freqs(term, termfreq_ptr, collfreq_ptr);
     173                 :      59744 : }
     174                 :            : 
     175                 :            : Xapian::doccount
     176                 :        239 : HoneyDatabase::get_value_freq(Xapian::valueno slot) const
     177                 :            : {
     178                 :        239 :     return value_manager.get_value_freq(slot);
     179                 :            : }
     180                 :            : 
     181                 :            : string
     182                 :        335 : HoneyDatabase::get_value_lower_bound(Xapian::valueno slot) const
     183                 :            : {
     184                 :        335 :     return value_manager.get_value_lower_bound(slot);
     185                 :            : }
     186                 :            : 
     187                 :            : string
     188                 :        351 : HoneyDatabase::get_value_upper_bound(Xapian::valueno slot) const
     189                 :            : {
     190                 :        351 :     return value_manager.get_value_upper_bound(slot);
     191                 :            : }
     192                 :            : 
     193                 :            : Xapian::termcount
     194                 :      77029 : HoneyDatabase::get_doclength_lower_bound() const
     195                 :            : {
     196                 :      77029 :     return version_file.get_doclength_lower_bound();
     197                 :            : }
     198                 :            : 
     199                 :            : Xapian::termcount
     200                 :        716 : HoneyDatabase::get_doclength_upper_bound() const
     201                 :            : {
     202                 :        716 :     return version_file.get_doclength_upper_bound();
     203                 :            : }
     204                 :            : 
     205                 :            : Xapian::termcount
     206                 :      50374 : HoneyDatabase::get_wdf_upper_bound(const string& term) const
     207                 :            : {
     208                 :      50374 :     Xapian::termcount wdf_bound = version_file.get_wdf_upper_bound();
     209                 :            :     // It's unlikely wdf is always 0, but when it is there's no need to do any
     210                 :            :     // further work.
     211         [ +  + ]:      50374 :     if (usual(wdf_bound != 0)) {
     212                 :            :         // We don't store per-term wdf upper bounds currently, but
     213                 :            :         // HoneyPostListTable can provide an upper bound based on termfreq,
     214                 :            :         // coll_freq, and the first wdf value, which more often than not is
     215                 :            :         // actually the exact bound (in 77% of cases in an example database of
     216                 :            :         // wikipedia data).
     217         [ +  + ]:      50358 :         wdf_bound = min(wdf_bound, postlist_table.get_wdf_upper_bound(term));
     218                 :            :     }
     219                 :      50373 :     return wdf_bound;
     220                 :            : }
     221                 :            : 
     222                 :            : Xapian::termcount
     223                 :          2 : HoneyDatabase::get_unique_terms_lower_bound() const
     224                 :            : {
     225                 :          2 :     return version_file.get_unique_terms_lower_bound();
     226                 :            : }
     227                 :            : 
     228                 :            : Xapian::termcount
     229                 :          2 : HoneyDatabase::get_unique_terms_upper_bound() const
     230                 :            : {
     231                 :          2 :     return version_file.get_unique_terms_upper_bound();
     232                 :            : }
     233                 :            : 
     234                 :            : bool
     235                 :        156 : HoneyDatabase::term_exists(const string& term) const
     236                 :            : {
     237         [ +  + ]:        156 :     if (term.empty())
     238                 :          3 :         return HoneyDatabase::get_doccount() != 0;
     239                 :        153 :     return postlist_table.term_exists(term);
     240                 :            : }
     241                 :            : 
     242                 :            : bool
     243                 :      26763 : HoneyDatabase::has_positions() const
     244                 :            : {
     245                 :      26763 :     return !position_table.empty();
     246                 :            : }
     247                 :            : 
     248                 :            : PostList*
     249                 :        507 : HoneyDatabase::open_post_list(const string& term) const
     250                 :            : {
     251                 :        507 :     return HoneyDatabase::open_leaf_post_list(term, false);
     252                 :            : }
     253                 :            : 
     254                 :            : LeafPostList*
     255                 :      27031 : HoneyDatabase::open_leaf_post_list(const string& term, bool need_read_pos) const
     256                 :            : {
     257         [ +  + ]:      27031 :     if (term.empty()) {
     258                 :            :         Assert(!need_read_pos);
     259         [ +  - ]:         42 :         return new HoneyAllDocsPostList(this, get_doccount());
     260                 :            :     }
     261                 :            : 
     262                 :      27031 :     return postlist_table.open_post_list(this, term, need_read_pos);
     263                 :            : }
     264                 :            : 
     265                 :            : ValueList*
     266                 :       3045 : HoneyDatabase::open_value_list(Xapian::valueno slot) const
     267                 :            : {
     268         [ +  - ]:       3045 :     return new HoneyValueList(slot, this);
     269                 :            : }
     270                 :            : 
     271                 :            : TermList*
     272                 :        236 : HoneyDatabase::open_term_list(Xapian::docid did) const
     273                 :            : {
     274                 :            :     Assert(did != 0);
     275         [ +  + ]:        236 :     if (!termlist_table.is_open())
     276                 :          1 :         throw_termlist_table_close_exception();
     277         [ +  - ]:        235 :     HoneyTermList* tl = new HoneyTermList(this, did);
     278         [ +  + ]:        235 :     if (tl->size() == 0) {
     279                 :            :         // It could be the document has no terms, but maybe it doesn't exist -
     280                 :            :         // in the latter case we ought to throw DocNotFoundError.  FIXME: If
     281                 :            :         // the document has no terms, but does have values, we should be able
     282                 :            :         // to avoid this check.
     283                 :            : 
     284                 :            :         // Put the pointer in a unique_ptr so it gets released if an exception
     285                 :            :         // is thrown.
     286                 :          2 :         unique_ptr<TermList> tl_ptr(tl);
     287                 :            : 
     288                 :            :         // This will throw DocNotFoundError if did isn't in use.
     289         [ -  + ]:          2 :         (void)HoneyDatabase::get_doclength(did);
     290                 :          2 :         tl_ptr.release();
     291                 :            :     }
     292                 :        233 :     return tl;
     293                 :            : }
     294                 :            : 
     295                 :            : TermList*
     296                 :         46 : HoneyDatabase::open_term_list_direct(Xapian::docid did) const
     297                 :            : {
     298                 :            :     // Same as open_term_list() except for MultiDatabase.
     299                 :         46 :     return HoneyDatabase::open_term_list(did);
     300                 :            : }
     301                 :            : 
     302                 :            : TermList*
     303                 :         79 : HoneyDatabase::open_allterms(const string& prefix) const
     304                 :            : {
     305         [ +  - ]:         79 :     return new HoneyAllTermsList(this, prefix);
     306                 :            : }
     307                 :            : 
     308                 :            : PositionList*
     309                 :       2409 : HoneyDatabase::open_position_list(Xapian::docid did, const string& term) const
     310                 :            : {
     311         [ +  + ]:       2409 :     return new HoneyPositionList(position_table, did, term);
     312                 :            : }
     313                 :            : 
     314                 :            : Xapian::Document::Internal*
     315                 :      34109 : HoneyDatabase::open_document(Xapian::docid did, bool lazy) const
     316                 :            : {
     317                 :            :     Assert(did != 0);
     318         [ +  + ]:      34109 :     if (!lazy) {
     319                 :            :         // This will throw DocNotFoundError if did isn't in use.
     320                 :      32803 :         (void)HoneyDatabase::get_doclength(did);
     321                 :            :     }
     322         [ +  - ]:      34104 :     return new HoneyDocument(this, did, &value_manager, &docdata_table);
     323                 :            : }
     324                 :            : 
     325                 :            : TermList*
     326                 :          0 : HoneyDatabase::open_spelling_termlist(const string& word) const
     327                 :            : {
     328                 :          0 :     return spelling_table.open_termlist(word);
     329                 :            : }
     330                 :            : 
     331                 :            : TermList*
     332                 :          0 : HoneyDatabase::open_spelling_wordlist() const
     333                 :            : {
     334                 :          0 :     auto cursor = spelling_table.cursor_get();
     335         [ #  # ]:          0 :     if (rare(cursor == NULL)) {
     336                 :            :         // No spelling table.
     337                 :          0 :         return NULL;
     338                 :            :     }
     339         [ #  # ]:          0 :     return new HoneySpellingWordsList(this, cursor);
     340                 :            : }
     341                 :            : 
     342                 :            : Xapian::doccount
     343                 :          0 : HoneyDatabase::get_spelling_frequency(const string& word) const
     344                 :            : {
     345                 :          0 :     return spelling_table.get_word_frequency(word);
     346                 :            : }
     347                 :            : 
     348                 :            : void
     349                 :          0 : HoneyDatabase::add_spelling(const string& word, Xapian::termcount freqinc) const
     350                 :            : {
     351                 :            :     (void)word;
     352                 :            :     (void)freqinc;
     353 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     354                 :            : }
     355                 :            : 
     356                 :            : Xapian::termcount
     357                 :          0 : HoneyDatabase::remove_spelling(const string& word,
     358                 :            :                                Xapian::termcount freqdec) const
     359                 :            : {
     360                 :            :     (void)word;
     361                 :            :     (void)freqdec;
     362 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     363                 :            : }
     364                 :            : 
     365                 :            : TermList*
     366                 :          0 : HoneyDatabase::open_synonym_termlist(const string& term) const
     367                 :            : {
     368                 :          0 :     return synonym_table.open_termlist(term);
     369                 :            : }
     370                 :            : 
     371                 :            : TermList*
     372                 :          0 : HoneyDatabase::open_synonym_keylist(const string& prefix) const
     373                 :            : {
     374                 :          0 :     auto cursor = synonym_table.cursor_get();
     375         [ #  # ]:          0 :     if (rare(cursor == NULL)) {
     376                 :            :         // No synonym table.
     377                 :          0 :         return NULL;
     378                 :            :     }
     379         [ #  # ]:          0 :     return new HoneySynonymTermList(this, cursor, prefix);
     380                 :            : }
     381                 :            : 
     382                 :            : void
     383                 :          0 : HoneyDatabase::add_synonym(const string& term, const string& synonym) const
     384                 :            : {
     385                 :            :     (void)term;
     386                 :            :     (void)synonym;
     387 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     388                 :            : }
     389                 :            : 
     390                 :            : void
     391                 :          0 : HoneyDatabase::remove_synonym(const string& term, const string& synonym) const
     392                 :            : {
     393                 :            :     (void)term;
     394                 :            :     (void)synonym;
     395 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     396                 :            : }
     397                 :            : 
     398                 :            : void
     399                 :          0 : HoneyDatabase::clear_synonyms(const string& term) const
     400                 :            : {
     401                 :            :     (void)term;
     402 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     403                 :            : }
     404                 :            : 
     405                 :            : string
     406                 :          0 : HoneyDatabase::get_metadata(const string& key) const
     407                 :            : {
     408                 :          0 :     return postlist_table.get_metadata(key);
     409                 :            : }
     410                 :            : 
     411                 :            : TermList*
     412                 :          0 : HoneyDatabase::open_metadata_keylist(const string& prefix) const
     413                 :            : {
     414                 :          0 :     auto cursor = postlist_table.cursor_get();
     415                 :            :     Assert(cursor != NULL);
     416         [ #  # ]:          0 :     return new HoneyMetadataTermList(this, cursor, prefix);
     417                 :            : }
     418                 :            : 
     419                 :            : void
     420                 :          0 : HoneyDatabase::set_metadata(const string& key, const string& value)
     421                 :            : {
     422                 :            :     (void)key;
     423                 :            :     (void)value;
     424 [ #  # ][ #  # ]:          0 :     throw Xapian::UnimplementedError("Honey backend doesn't support update");
                 [ #  # ]
     425                 :            : }
     426                 :            : 
     427                 :            : bool
     428                 :          3 : HoneyDatabase::reopen()
     429                 :            : {
     430         [ +  + ]:          3 :     if (!postlist_table.is_open())
     431                 :          2 :         HoneyTable::throw_database_closed();
     432                 :          1 :     return false;
     433                 :            : }
     434                 :            : 
     435                 :            : void
     436                 :          3 : HoneyDatabase::close()
     437                 :            : {
     438                 :          3 :     docdata_table.close(true);
     439                 :          3 :     postlist_table.close(true);
     440                 :          3 :     position_table.close(true);
     441                 :          3 :     spelling_table.close(true);
     442                 :          3 :     synonym_table.close(true);
     443                 :          3 :     termlist_table.close(true);
     444                 :          3 : }
     445                 :            : 
     446                 :            : void
     447                 :          6 : HoneyDatabase::request_document(Xapian::docid did) const
     448                 :            : {
     449                 :            :     Assert(did != 0);
     450                 :            :     (void)did; // FIXME
     451                 :          6 : }
     452                 :            : 
     453                 :            : Xapian::rev
     454                 :          0 : HoneyDatabase::get_revision() const
     455                 :            : {
     456                 :          0 :     return version_file.get_revision();
     457                 :            : }
     458                 :            : 
     459                 :            : string
     460                 :         10 : HoneyDatabase::get_uuid() const
     461                 :            : {
     462                 :         10 :     return version_file.get_uuid_string();
     463                 :            : }
     464                 :            : 
     465                 :            : int
     466                 :      26694 : HoneyDatabase::get_backend_info(string* path_ptr) const
     467                 :            : {
     468         [ +  + ]:      26694 :     if (path_ptr)
     469                 :         15 :         *path_ptr = path;
     470                 :      26694 :     return BACKEND_HONEY;
     471                 :            : }
     472                 :            : 
     473                 :            : void
     474                 :         12 : HoneyDatabase::get_used_docid_range(Xapian::docid& first,
     475                 :            :                                     Xapian::docid& last) const
     476                 :            : {
     477                 :         12 :     auto doccount = version_file.get_doccount();
     478         [ -  + ]:         12 :     if (doccount == 0) {
     479                 :            :         // Empty database.
     480                 :          0 :         first = last = 0;
     481                 :          0 :         return;
     482                 :            :     }
     483                 :         12 :     auto last_docid = version_file.get_last_docid();
     484         [ +  - ]:         12 :     if (last_docid == doccount) {
     485                 :            :         // Contiguous range starting at 1.
     486                 :         12 :         first = 1;
     487                 :         12 :         last = last_docid;
     488                 :         12 :         return;
     489                 :            :     }
     490                 :          0 :     postlist_table.get_used_docid_range(doccount, first, last);
     491                 :            : }
     492                 :            : 
     493                 :            : string
     494                 :          1 : HoneyDatabase::get_description() const
     495                 :            : {
     496         [ +  - ]:          1 :     string desc = "Honey(";
     497         [ +  - ]:          1 :     desc += path;
     498         [ +  - ]:          1 :     desc += ')';
     499                 :          1 :     return desc;
     500                 :            : }

Generated by: LCOV version 1.11