LCOV - code coverage report
Current view: top level - backends/multi - multi_database.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 4ba52dacf4fb Lines: 306 366 83.6 %
Date: 2019-05-20 14:58:19 Functions: 46 56 82.1 %
Branches: 198 368 53.8 %

           Branch data     Line data    Source code
       1                 :            : /** @file multi_database.cc
       2                 :            :  * @brief Sharded database backend
       3                 :            :  */
       4                 :            : /* Copyright (C) 2017 Olly Betts
       5                 :            :  *
       6                 :            :  * This program is free software; you can redistribute it and/or modify
       7                 :            :  * it under the terms of the GNU General Public License as published by
       8                 :            :  * the Free Software Foundation; either version 2 of the License, or
       9                 :            :  * (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                 :            :  *
      14                 :            :  * You should have received a copy of the GNU General Public License
      15                 :            :  * along with this program; if not, write to the Free Software
      16                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
      17                 :            :  */
      18                 :            : 
      19                 :            : #include <config.h>
      20                 :            : 
      21                 :            : #include "multi_database.h"
      22                 :            : 
      23                 :            : #include "backends/backends.h"
      24                 :            : #include "backends/multi.h"
      25                 :            : #include "expand/ortermlist.h"
      26                 :            : #include "expand/termlistmerger.h"
      27                 :            : #include "multi_alltermslist.h"
      28                 :            : #include "multi_postlist.h"
      29                 :            : #include "multi_termlist.h"
      30                 :            : #include "multi_valuelist.h"
      31                 :            : 
      32                 :            : #include <memory>
      33                 :            : 
      34                 :            : using namespace std;
      35                 :            : 
      36                 :            : MultiDatabase::size_type
      37                 :      57346 : MultiDatabase::size() const
      38                 :            : {
      39                 :      57346 :     return shards.size();
      40                 :            : }
      41                 :            : 
      42                 :            : bool
      43                 :         24 : MultiDatabase::reopen()
      44                 :            : {
      45                 :         24 :     bool result = false;
      46         [ +  + ]:         68 :     for (auto&& shard : shards) {
      47         [ +  + ]:         46 :         if (shard->reopen()) {
      48                 :          7 :             result = true;
      49                 :            :         }
      50                 :            :     }
      51                 :         22 :     return result;
      52                 :            : }
      53                 :            : 
      54                 :            : void
      55                 :        148 : MultiDatabase::close()
      56                 :            : {
      57         [ +  + ]:        444 :     for (auto&& shard : shards) {
      58                 :        296 :         shard->close();
      59                 :            :     }
      60                 :        148 : }
      61                 :            : 
      62                 :            : PostList*
      63                 :        352 : MultiDatabase::open_post_list(const string& term) const
      64                 :            : {
      65         [ +  - ]:        352 :     PostList** postlists = new PostList*[shards.size()];
      66                 :        352 :     size_t count = 0;
      67                 :            :     try {
      68         [ +  + ]:       1048 :         for (auto&& shard : shards) {
      69         [ +  + ]:        700 :             postlists[count] = shard->open_post_list(term);
      70                 :        696 :             ++count;
      71                 :            :         }
      72 [ +  - ][ +  - ]:        348 :         return new MultiPostList(count, postlists);
      73                 :          8 :     } catch (...) {
      74         [ -  + ]:          4 :         while (count)
      75         [ #  # ]:          0 :             delete postlists[--count];
      76         [ +  - ]:          4 :         delete [] postlists;
      77                 :          4 :         throw;
      78                 :            :     }
      79                 :            : }
      80                 :            : 
      81                 :            : LeafPostList*
      82                 :          0 : MultiDatabase::open_leaf_post_list(const string&, bool) const
      83                 :            : {
      84                 :            :     // This should never get called.
      85                 :            :     Assert(false);
      86                 :          0 :     return NULL;
      87                 :            : }
      88                 :            : 
      89                 :            : TermList*
      90                 :       3080 : MultiDatabase::open_term_list(Xapian::docid did) const
      91                 :            : {
      92         [ +  - ]:       3080 :     return new MultiTermList(this, MultiDatabase::open_term_list_direct(did));
      93                 :            : }
      94                 :            : 
      95                 :            : TermList*
      96                 :       3148 : MultiDatabase::open_term_list_direct(Xapian::docid did) const
      97                 :            : {
      98                 :       3148 :     size_t n_shards = shards.size();
      99                 :       3148 :     auto shard = shards[shard_number(did, n_shards)];
     100                 :       3148 :     Xapian::docid shard_did = shard_docid(did, n_shards);
     101                 :       3148 :     return shard->open_term_list(shard_did);
     102                 :            : }
     103                 :            : 
     104                 :            : TermList*
     105                 :         79 : MultiDatabase::open_allterms(const string& prefix) const
     106                 :            : {
     107                 :         79 :     size_t count = 0;
     108         [ +  - ]:         79 :     TermList** termlists = new TermList*[shards.size()];
     109                 :            :     try {
     110         [ +  + ]:        249 :         for (auto&& shard : shards) {
     111         [ +  - ]:        170 :             termlists[count] = shard->open_allterms(prefix);
     112                 :        170 :             ++count;
     113                 :            :         }
     114 [ +  - ][ +  - ]:         79 :         return new MultiAllTermsList(count, termlists);
     115                 :          0 :     } catch (...) {
     116         [ #  # ]:          0 :         while (count)
     117         [ #  # ]:          0 :             delete termlists[--count];
     118         [ #  # ]:          0 :         delete [] termlists;
     119                 :          0 :         throw;
     120                 :            :     }
     121                 :            : }
     122                 :            : 
     123                 :            : bool
     124                 :      57055 : MultiDatabase::has_positions() const
     125                 :            : {
     126         [ +  + ]:      65303 :     for (auto&& shard : shards) {
     127         [ +  + ]:      61185 :         if (shard->has_positions()) {
     128                 :      52937 :             return true;
     129                 :            :         }
     130                 :            :     }
     131                 :       4118 :     return false;
     132                 :            : }
     133                 :            : 
     134                 :            : PositionList*
     135                 :         24 : MultiDatabase::open_position_list(Xapian::docid did, const string& term) const
     136                 :            : {
     137                 :         24 :     auto n_shards = shards.size();
     138                 :         24 :     auto shard = shards[shard_number(did, n_shards)];
     139                 :         24 :     auto shard_did = shard_docid(did, n_shards);
     140                 :         24 :     return shard->open_position_list(shard_did, term);
     141                 :            : }
     142                 :            : 
     143                 :            : Xapian::doccount
     144                 :      29630 : MultiDatabase::get_doccount() const
     145                 :            : {
     146                 :      29630 :     Xapian::doccount result = 0;
     147         [ +  + ]:      88912 :     for (auto&& shard : shards) {
     148                 :      59282 :         auto old_result = result;
     149                 :      59282 :         result += shard->get_doccount();
     150         [ -  + ]:      59282 :         if (result < old_result)
     151 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("doccount overflowed!");
                 [ #  # ]
     152                 :            :     }
     153                 :      29630 :     return result;
     154                 :            : }
     155                 :            : 
     156                 :            : Xapian::docid
     157                 :      22087 : MultiDatabase::get_lastdocid() const
     158                 :            : {
     159                 :      22087 :     Xapian::docid result = 0;
     160         [ +  - ]:      22087 :     auto n_shards = shards.size();
     161         [ +  + ]:      66261 :     for (size_t shard = 0; shard != n_shards; ++shard) {
     162         [ +  - ]:      44174 :         Xapian::docid shard_lastdocid = shards[shard]->get_lastdocid();
     163         [ +  + ]:      44174 :         if (shard_lastdocid == 0) {
     164                 :            :             // This shard is empty, so doesn't influence lastdocid for the
     165                 :            :             // combined database.
     166                 :        392 :             continue;
     167                 :            :         }
     168                 :      43782 :         result = max(result, unshard(shard_lastdocid, shard, n_shards));
     169                 :            :     }
     170                 :      22087 :     return result;
     171                 :            : }
     172                 :            : 
     173                 :            : Xapian::totallength
     174                 :        342 : MultiDatabase::get_total_length() const
     175                 :            : {
     176                 :        342 :     Xapian::totallength result = 0;
     177         [ +  + ]:       1026 :     for (auto&& shard : shards) {
     178                 :        684 :         auto old_result = result;
     179                 :        684 :         result += shard->get_total_length();
     180         [ -  + ]:        684 :         if (result < old_result)
     181 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("Total document length overflowed!");
                 [ #  # ]
     182                 :            :     }
     183                 :        342 :     return result;
     184                 :            : }
     185                 :            : 
     186                 :            : void
     187                 :       3414 : MultiDatabase::get_freqs(const string& term,
     188                 :            :                          Xapian::doccount* tf_ptr,
     189                 :            :                          Xapian::termcount* cf_ptr) const
     190                 :            : {
     191                 :            :     Assert(!term.empty());
     192                 :            : 
     193                 :            :     Xapian::doccount shard_tf;
     194         [ +  + ]:       3414 :     Xapian::doccount* shard_tf_ptr = tf_ptr ? &shard_tf : NULL;
     195                 :       3414 :     Xapian::doccount total_tf = 0;
     196                 :            : 
     197                 :            :     Xapian::termcount shard_cf;
     198         [ +  + ]:       3414 :     Xapian::termcount* shard_cf_ptr = cf_ptr ? &shard_cf : NULL;
     199                 :       3414 :     Xapian::termcount total_cf = 0;
     200                 :            : 
     201         [ +  + ]:      10242 :     for (auto&& shard : shards) {
     202         [ +  + ]:       6832 :         shard->get_freqs(term, shard_tf_ptr, shard_cf_ptr);
     203         [ +  + ]:       6828 :         if (shard_tf_ptr) {
     204                 :       2608 :             auto old_tf = total_tf;
     205                 :       2608 :             total_tf += *shard_tf_ptr;
     206         [ -  + ]:       2608 :             if (total_tf < old_tf)
     207 [ #  # ][ #  # ]:       2608 :                 throw Xapian::DatabaseError("termfreq overflowed!");
                 [ #  # ]
     208                 :            :         }
     209         [ +  + ]:       6828 :         if (shard_cf_ptr) {
     210                 :       4220 :             auto old_cf = total_cf;
     211                 :       4220 :             total_cf += *shard_cf_ptr;
     212         [ -  + ]:       4220 :             if (total_cf < old_cf)
     213 [ #  # ][ #  # ]:       4220 :                 throw Xapian::DatabaseError("Collection freq overflowed!");
                 [ #  # ]
     214                 :            :         }
     215                 :            :     }
     216         [ +  + ]:       3410 :     if (tf_ptr) {
     217                 :       1304 :         *tf_ptr = total_tf;
     218                 :            :     }
     219         [ +  + ]:       3410 :     if (cf_ptr) {
     220                 :       2106 :         *cf_ptr = total_cf;
     221                 :            :     }
     222                 :       3410 : }
     223                 :            : 
     224                 :            : Xapian::doccount
     225                 :         49 : MultiDatabase::get_value_freq(Xapian::valueno slot) const
     226                 :            : {
     227                 :         49 :     Xapian::termcount result = 0;
     228         [ +  + ]:        147 :     for (auto&& shard : shards) {
     229                 :         98 :         auto old_result = result;
     230                 :         98 :         result += shard->get_value_freq(slot);
     231         [ -  + ]:         98 :         if (result < old_result)
     232 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("Value freq overflowed!");
                 [ #  # ]
     233                 :            :     }
     234                 :         49 :     return result;
     235                 :            : }
     236                 :            : 
     237                 :            : string
     238                 :         26 : MultiDatabase::get_value_lower_bound(Xapian::valueno slot) const
     239                 :            : {
     240                 :         26 :     string result;
     241         [ +  + ]:         78 :     for (auto&& shard : shards) {
     242         [ +  - ]:         52 :         string shard_result = shard->get_value_lower_bound(slot);
     243         [ +  + ]:         52 :         if (shard_result.empty())
     244                 :         17 :             continue;
     245 [ +  + ][ +  - ]:         35 :         if (result.empty() || shard_result < result)
         [ +  + ][ +  + ]
     246 [ +  - ][ +  + ]:         52 :             result = std::move(shard_result);
     247                 :         52 :     }
     248                 :         26 :     return result;
     249                 :            : }
     250                 :            : 
     251                 :            : string
     252                 :         42 : MultiDatabase::get_value_upper_bound(Xapian::valueno slot) const
     253                 :            : {
     254                 :         42 :     string result;
     255         [ +  + ]:        126 :     for (auto&& shard : shards) {
     256         [ +  - ]:         84 :         string shard_result = shard->get_value_upper_bound(slot);
     257 [ +  - ][ +  + ]:         84 :         if (shard_result > result)
     258         [ +  - ]:         45 :             result = std::move(shard_result);
     259                 :         84 :     }
     260                 :         42 :     return result;
     261                 :            : }
     262                 :            : 
     263                 :            : Xapian::termcount
     264                 :     157487 : MultiDatabase::get_doclength_lower_bound() const
     265                 :            : {
     266                 :            :     // We want the smallest answer from amongst the shards, except that 0 means
     267                 :            :     // that all documents have length 0 (including the special case of there
     268                 :            :     // being no documents), so any non-zero answer should "beat" 0.  To achieve
     269                 :            :     // this we find the *maximum* after negating each of the values (which
     270                 :            :     // since Xapian::termcount is an unsigned type leaves 0 alone but flips the
     271                 :            :     // order of all other values), then negate the answer again at the end.
     272                 :            :     static_assert(std::is_unsigned<Xapian::termcount>::value,
     273                 :            :                   "Unsigned type required");
     274                 :     157487 :     Xapian::termcount result = 0;
     275         [ +  + ]:     472545 :     for (auto&& shard : shards) {
     276         [ +  - ]:     315058 :         Xapian::termcount shard_result = -shard->get_doclength_lower_bound();
     277                 :     315058 :         result = max(result, shard_result);
     278                 :            :     }
     279                 :     157487 :     return -result;
     280                 :            : }
     281                 :            : 
     282                 :            : Xapian::termcount
     283                 :        784 : MultiDatabase::get_doclength_upper_bound() const
     284                 :            : {
     285                 :        784 :     Xapian::termcount result = 0;
     286         [ +  + ]:       2352 :     for (auto&& shard : shards) {
     287         [ +  - ]:       1568 :         result = max(result, shard->get_doclength_upper_bound());
     288                 :            :     }
     289                 :        784 :     return result;
     290                 :            : }
     291                 :            : 
     292                 :            : Xapian::termcount
     293                 :     100648 : MultiDatabase::get_wdf_upper_bound(const string& term) const
     294                 :            : {
     295                 :            :     Assert(!term.empty());
     296                 :            : 
     297                 :     100648 :     Xapian::termcount result = 0;
     298         [ +  + ]:     301998 :     for (auto&& shard : shards) {
     299         [ +  + ]:     201351 :         result = max(result, shard->get_wdf_upper_bound(term));
     300                 :            :     }
     301                 :     100647 :     return result;
     302                 :            : }
     303                 :            : 
     304                 :            : ValueList*
     305                 :        250 : MultiDatabase::open_value_list(Xapian::valueno slot) const
     306                 :            : {
     307         [ +  - ]:        250 :     SubValueList** valuelists = new SubValueList*[shards.size()];
     308                 :        250 :     size_t count = 0;
     309                 :            :     try {
     310         [ +  + ]:        750 :         for (auto&& shard : shards) {
     311         [ +  - ]:        500 :             ValueList* vl = shard->open_value_list(slot);
     312         [ +  - ]:        500 :             valuelists[count] = new SubValueList(vl, count);
     313                 :        500 :             ++count;
     314                 :            :         }
     315 [ +  - ][ +  - ]:        250 :         return new MultiValueList(count, valuelists, slot);
     316                 :          0 :     } catch (...) {
     317         [ #  # ]:          0 :         while (count)
     318         [ #  # ]:          0 :             delete valuelists[--count];
     319         [ #  # ]:          0 :         delete [] valuelists;
     320                 :          0 :         throw;
     321                 :            :     }
     322                 :            : }
     323                 :            : 
     324                 :            : Xapian::termcount
     325                 :    9483594 : MultiDatabase::get_doclength(Xapian::docid did) const
     326                 :            : {
     327                 :            :     Assert(did != 0);
     328                 :            : 
     329                 :    9483594 :     auto n_shards = shards.size();
     330                 :    9483594 :     auto shard = shards[shard_number(did, n_shards)];
     331                 :    9483594 :     auto shard_did = shard_docid(did, n_shards);
     332                 :    9483594 :     return shard->get_doclength(shard_did);
     333                 :            : }
     334                 :            : 
     335                 :            : Xapian::termcount
     336                 :       3367 : MultiDatabase::get_unique_terms(Xapian::docid did) const
     337                 :            : {
     338                 :            :     Assert(did != 0);
     339                 :            : 
     340                 :       3367 :     auto n_shards = shards.size();
     341                 :       3367 :     auto shard = shards[shard_number(did, n_shards)];
     342                 :       3367 :     auto shard_did = shard_docid(did, n_shards);
     343                 :       3367 :     return shard->get_unique_terms(shard_did);
     344                 :            : }
     345                 :            : 
     346                 :            : Xapian::Document::Internal*
     347                 :      97959 : MultiDatabase::open_document(Xapian::docid did, bool lazy) const
     348                 :            : {
     349                 :            :     Assert(did != 0);
     350                 :            : 
     351                 :      97959 :     auto n_shards = shards.size();
     352                 :      97959 :     auto shard = shards[shard_number(did, n_shards)];
     353                 :      97959 :     auto shard_did = shard_docid(did, n_shards);
     354                 :      97959 :     return shard->open_document(shard_did, lazy);
     355                 :            : }
     356                 :            : 
     357                 :            : bool
     358                 :         79 : MultiDatabase::term_exists(const string& term) const
     359                 :            : {
     360         [ +  + ]:        104 :     for (auto&& shard : shards) {
     361         [ +  + ]:         92 :         if (shard->term_exists(term))
     362                 :         67 :             return true;
     363                 :            :     }
     364                 :         12 :     return false;
     365                 :            : }
     366                 :            : 
     367                 :            : void
     368                 :          1 : MultiDatabase::keep_alive()
     369                 :            : {
     370         [ +  + ]:          3 :     for (auto&& shard : shards) {
     371                 :          2 :         shard->keep_alive();
     372                 :            :     }
     373                 :          1 : }
     374                 :            : 
     375                 :            : TermList*
     376                 :         25 : MultiDatabase::open_spelling_termlist(const string& word) const
     377                 :            : {
     378                 :         25 :     vector<TermList*> termlists;
     379 [ +  - ][ +  - ]:         25 :     termlists.reserve(shards.size());
     380                 :            : 
     381                 :            :     try {
     382         [ +  + ]:         75 :         for (auto&& shard : shards) {
     383         [ +  - ]:         50 :             TermList* termlist = shard->open_spelling_termlist(word);
     384         [ +  + ]:         50 :             if (!termlist)
     385                 :         23 :                 continue;
     386         [ +  - ]:         27 :             termlists.push_back(termlist);
     387                 :            :         }
     388                 :            : 
     389         [ +  - ]:         50 :         return make_termlist_merger(termlists);
     390                 :          0 :     } catch (...) {
     391         [ #  # ]:          0 :         for (auto&& termlist : termlists)
     392         [ #  # ]:          0 :             delete termlist;
     393                 :          0 :         throw;
     394                 :         25 :     }
     395                 :            : }
     396                 :            : 
     397                 :            : TermList*
     398                 :          1 : MultiDatabase::open_spelling_wordlist() const
     399                 :            : {
     400                 :          1 :     vector<TermList*> termlists;
     401 [ +  - ][ +  - ]:          1 :     termlists.reserve(shards.size());
     402                 :            : 
     403                 :            :     try {
     404         [ +  + ]:          3 :         for (auto&& shard : shards) {
     405         [ +  - ]:          2 :             TermList* termlist = shard->open_spelling_wordlist();
     406         [ -  + ]:          2 :             if (!termlist)
     407                 :          0 :                 continue;
     408         [ +  - ]:          2 :             termlists.push_back(termlist);
     409                 :            :         }
     410                 :            : 
     411         [ +  - ]:          2 :         return make_termlist_merger<FreqAdderOrTermList>(termlists);
     412                 :          0 :     } catch (...) {
     413         [ #  # ]:          0 :         for (auto&& termlist : termlists)
     414         [ #  # ]:          0 :             delete termlist;
     415                 :          0 :         throw;
     416                 :          1 :     }
     417                 :            : }
     418                 :            : 
     419                 :            : Xapian::doccount
     420                 :         20 : MultiDatabase::get_spelling_frequency(const string& word) const
     421                 :            : {
     422                 :         20 :     Xapian::doccount result = 0;
     423         [ +  + ]:         60 :     for (auto&& shard : shards) {
     424                 :         40 :         auto old_result = result;
     425                 :         40 :         result += shard->get_spelling_frequency(word);
     426         [ -  + ]:         40 :         if (result < old_result)
     427 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("Spelling frequency overflowed!");
                 [ #  # ]
     428                 :            :     }
     429                 :         20 :     return result;
     430                 :            : }
     431                 :            : 
     432                 :            : TermList*
     433                 :      34334 : MultiDatabase::open_synonym_termlist(const string& term) const
     434                 :            : {
     435                 :      34334 :     vector<TermList*> termlists;
     436 [ +  - ][ +  - ]:      34334 :     termlists.reserve(shards.size());
     437                 :            : 
     438                 :            :     try {
     439         [ +  + ]:     103010 :         for (auto&& shard : shards) {
     440         [ +  + ]:      68677 :             TermList* termlist = shard->open_synonym_termlist(term);
     441         [ +  + ]:      68676 :             if (!termlist)
     442                 :      53361 :                 continue;
     443         [ +  - ]:      15315 :             termlists.push_back(termlist);
     444                 :            :         }
     445                 :            : 
     446         [ +  - ]:      68667 :         return make_termlist_merger(termlists);
     447                 :          2 :     } catch (...) {
     448         [ -  + ]:          1 :         for (auto&& termlist : termlists)
     449         [ #  # ]:          0 :             delete termlist;
     450                 :          1 :         throw;
     451                 :      34334 :     }
     452                 :            : }
     453                 :            : 
     454                 :            : TermList*
     455                 :      10295 : MultiDatabase::open_synonym_keylist(const string& prefix) const
     456                 :            : {
     457                 :      10295 :     vector<TermList*> termlists;
     458 [ +  - ][ +  - ]:      10295 :     termlists.reserve(shards.size());
     459                 :            : 
     460                 :            :     try {
     461         [ +  + ]:      30885 :         for (auto&& shard : shards) {
     462         [ +  + ]:      20591 :             TermList* termlist = shard->open_synonym_keylist(prefix);
     463         [ +  + ]:      20590 :             if (!termlist)
     464                 :          3 :                 continue;
     465         [ +  - ]:      20587 :             termlists.push_back(termlist);
     466                 :            :         }
     467                 :            : 
     468         [ +  - ]:      20589 :         return make_termlist_merger(termlists);
     469                 :          2 :     } catch (...) {
     470         [ -  + ]:          1 :         for (auto&& termlist : termlists)
     471         [ #  # ]:          0 :             delete termlist;
     472                 :          1 :         throw;
     473                 :      10295 :     }
     474                 :            : }
     475                 :            : 
     476                 :            : string
     477                 :         25 : MultiDatabase::get_metadata(const string& key) const
     478                 :            : {
     479                 :         25 :     return shards[0]->get_metadata(key);
     480                 :            : }
     481                 :            : 
     482                 :            : TermList*
     483                 :          9 : MultiDatabase::open_metadata_keylist(const string& prefix) const
     484                 :            : {
     485                 :          9 :     return shards[0]->open_metadata_keylist(prefix);
     486                 :            : }
     487                 :            : 
     488                 :            : string
     489                 :         14 : MultiDatabase::get_uuid() const
     490                 :            : {
     491         [ +  - ]:         14 :     string uuid;
     492         [ +  + ]:         42 :     for (auto&& shard : shards) {
     493         [ +  - ]:         33 :         const string& sub_uuid = shard->get_uuid();
     494                 :            :         // If any of the sub-databases have no uuid, we can't make a uuid for
     495                 :            :         // the combined database.
     496         [ +  + ]:         33 :         if (sub_uuid.empty())
     497         [ +  - ]:          5 :             return sub_uuid;
     498         [ +  + ]:         28 :         if (!uuid.empty())
     499         [ +  - ]:         14 :             uuid += ':';
     500 [ +  - ][ +  + ]:         33 :         uuid += sub_uuid;
     501                 :         28 :     }
     502                 :         14 :     return uuid;
     503                 :            : }
     504                 :            : 
     505                 :            : bool
     506                 :          0 : MultiDatabase::locked() const
     507                 :            : {
     508         [ #  # ]:          0 :     for (auto&& shard : shards) {
     509         [ #  # ]:          0 :         if (shard->locked()) {
     510                 :          0 :             return true;
     511                 :            :         }
     512                 :            :     }
     513                 :          0 :     return false;
     514                 :            : }
     515                 :            : 
     516                 :            : void
     517                 :          0 : MultiDatabase::write_changesets_to_fd(int,
     518                 :            :                                       const std::string&,
     519                 :            :                                       bool,
     520                 :            :                                       Xapian::ReplicationInfo*)
     521                 :            : {
     522                 :            :     throw Xapian::InvalidOperationError("write_changesets_to_fd() with "
     523 [ #  # ][ #  # ]:          0 :                                         "more than one subdatabase");
                 [ #  # ]
     524                 :            : }
     525                 :            : 
     526                 :            : Xapian::rev
     527                 :          0 : MultiDatabase::get_revision() const
     528                 :            : {
     529                 :            :     throw Xapian::InvalidOperationError("Database::get_revision() with "
     530 [ #  # ][ #  # ]:          0 :                                         "more than one subdatabase");
                 [ #  # ]
     531                 :            : }
     532                 :            : 
     533                 :            : void
     534                 :          0 : MultiDatabase::invalidate_doc_object(Xapian::Document::Internal*) const
     535                 :            : {
     536                 :            :     // This method should only be called on a single shard.
     537                 :            :     Assert(false);
     538                 :          0 : }
     539                 :            : 
     540                 :            : int
     541                 :          0 : MultiDatabase::get_backend_info(string*) const
     542                 :            : {
     543                 :            :     // This method should only be called on a single shard.
     544                 :            :     Assert(false);
     545                 :          0 :     return BACKEND_UNKNOWN;
     546                 :            : }
     547                 :            : 
     548                 :            : void
     549                 :       2105 : MultiDatabase::commit()
     550                 :            : {
     551         [ +  + ]:       6313 :     for (auto&& shard : shards) {
     552                 :       4209 :         shard->commit();
     553                 :            :     }
     554                 :       2104 : }
     555                 :            : 
     556                 :            : void
     557                 :          0 : MultiDatabase::cancel()
     558                 :            : {
     559         [ #  # ]:          0 :     for (auto&& shard : shards) {
     560                 :          0 :         shard->cancel();
     561                 :            :     }
     562                 :          0 : }
     563                 :            : 
     564                 :            : void
     565                 :          0 : MultiDatabase::begin_transaction(bool flushed)
     566                 :            : {
     567         [ #  # ]:          0 :     for (auto&& shard : shards) {
     568                 :          0 :         shard->begin_transaction(flushed);
     569                 :            :     }
     570                 :          0 : }
     571                 :            : 
     572                 :            : void
     573                 :          0 : MultiDatabase::end_transaction_(bool do_commit)
     574                 :            : {
     575         [ #  # ]:          0 :     for (auto&& shard : shards) {
     576                 :          0 :         shard->end_transaction(do_commit);
     577                 :            :     }
     578                 :          0 : }
     579                 :            : 
     580                 :            : Xapian::docid
     581                 :      21877 : MultiDatabase::add_document(const Xapian::Document& doc)
     582                 :            : {
     583                 :            :     // With a single shard, add_document() uses docid (get_lastdocid() + 1)
     584                 :            :     // which seems a sensible invariant to preserve with multiple shards.
     585                 :      21877 :     Xapian::docid did = get_lastdocid() + 1;
     586         [ +  + ]:      21877 :     if (rare(did == 0)) {
     587                 :            :         throw Xapian::DatabaseError("Run out of docids - you'll have to use "
     588                 :            :                                     "copydatabase to eliminate any gaps "
     589 [ +  - ][ +  - ]:          1 :                                     "before you can add more documents");
                 [ +  - ]
     590                 :            :     }
     591                 :            : 
     592                 :      21876 :     auto n_shards = shards.size();
     593                 :      21876 :     auto shard = shards[shard_number(did, n_shards)];
     594                 :      21876 :     shard->replace_document(shard_docid(did, n_shards), doc);
     595                 :      21830 :     return did;
     596                 :            : }
     597                 :            : 
     598                 :            : void
     599                 :       3026 : MultiDatabase::delete_document(Xapian::docid did)
     600                 :            : {
     601                 :       3026 :     auto n_shards = shards.size();
     602                 :       3026 :     auto shard = shards[shard_number(did, n_shards)];
     603                 :       3026 :     shard->delete_document(shard_docid(did, n_shards));
     604                 :       3024 : }
     605                 :            : 
     606                 :            : void
     607                 :          3 : MultiDatabase::delete_document(const string& term)
     608                 :            : {
     609         [ +  + ]:          9 :     for (auto&& shard : shards) {
     610                 :          6 :         shard->delete_document(term);
     611                 :            :     }
     612                 :          3 : }
     613                 :            : 
     614                 :            : void
     615                 :      13137 : MultiDatabase::replace_document(Xapian::docid did, const Xapian::Document& doc)
     616                 :            : {
     617                 :      13137 :     auto n_shards = shards.size();
     618                 :      13137 :     auto shard = shards[shard_number(did, n_shards)];
     619                 :      13137 :     shard->replace_document(shard_docid(did, n_shards), doc);
     620                 :      13135 : }
     621                 :            : 
     622                 :            : Xapian::docid
     623                 :         20 : MultiDatabase::replace_document(const string& term, const Xapian::Document& doc)
     624                 :            : {
     625         [ +  - ]:         20 :     auto n_shards = shards.size();
     626         [ +  + ]:         20 :     unique_ptr<PostList> pl(open_post_list(term));
     627         [ +  - ]:         19 :     pl->next();
     628                 :            :     // If no unique_term in the database, this is just an add_document().
     629 [ +  - ][ +  + ]:         19 :     if (pl->at_end()) {
     630                 :            :         // Which database will the next never used docid be in?
     631         [ +  - ]:          1 :         Xapian::docid did = get_lastdocid() + 1;
     632         [ -  + ]:          1 :         if (rare(did == 0)) {
     633                 :            :             throw Xapian::DatabaseError("Run out of docids - you'll have to "
     634                 :            :                                         "use copydatabase to eliminate any "
     635                 :            :                                         "gaps before you can add more "
     636 [ #  # ][ #  # ]:          0 :                                         "documents");
                 [ #  # ]
     637                 :            :         }
     638                 :          1 :         auto shard = shards[shard_number(did, n_shards)];
     639         [ +  - ]:          1 :         return shard->add_document(doc);
     640                 :            :     }
     641                 :            : 
     642         [ +  - ]:         18 :     Xapian::docid result = pl->get_docid();
     643                 :         18 :     auto replacing_shard = shards[shard_number(result, n_shards)];
     644         [ +  - ]:         18 :     replacing_shard->replace_document(shard_docid(result, n_shards), doc);
     645                 :            : 
     646                 :            :     // Delete any other occurrences of the unique term.
     647 [ +  - ][ +  - ]:         21 :     while (pl->next(), !pl->at_end()) {
                 [ +  + ]
     648         [ +  - ]:          3 :         Xapian::docid did = pl->get_docid();
     649                 :          3 :         auto shard = shards[shard_number(did, n_shards)];
     650         [ +  - ]:          3 :         shard->delete_document(shard_docid(did, n_shards));
     651                 :            :     }
     652                 :            : 
     653                 :         19 :     return result;
     654                 :            : }
     655                 :            : 
     656                 :            : void
     657                 :          6 : MultiDatabase::request_document(Xapian::docid did) const
     658                 :            : {
     659                 :            :     Assert(did != 0);
     660                 :            : 
     661                 :          6 :     auto n_shards = shards.size();
     662                 :          6 :     auto shard = shards[shard_number(did, n_shards)];
     663                 :          6 :     auto shard_did = shard_docid(did, n_shards);
     664                 :          6 :     shard->request_document(shard_did);
     665                 :          6 : }
     666                 :            : 
     667                 :            : void
     668                 :          3 : MultiDatabase::add_spelling(const string& word,
     669                 :            :                             Xapian::termcount freqinc) const
     670                 :            : {
     671                 :          3 :     shards[0]->add_spelling(word, freqinc);
     672                 :          3 : }
     673                 :            : 
     674                 :            : Xapian::termcount
     675                 :          0 : MultiDatabase::remove_spelling(const string& word,
     676                 :            :                                Xapian::termcount freqdec) const
     677                 :            : {
     678         [ #  # ]:          0 :     for (auto&& shard : shards) {
     679                 :          0 :         freqdec = shard->remove_spelling(word, freqdec);
     680         [ #  # ]:          0 :         if (freqdec == 0)
     681                 :          0 :             break;
     682                 :            :     }
     683                 :          0 :     return freqdec;
     684                 :            : }
     685                 :            : 
     686                 :            : void
     687                 :         26 : MultiDatabase::add_synonym(const string& term,
     688                 :            :                            const string& synonym) const
     689                 :            : {
     690                 :         26 :     shards[0]->add_synonym(term, synonym);
     691                 :         25 : }
     692                 :            : 
     693                 :            : void
     694                 :          2 : MultiDatabase::remove_synonym(const string& term,
     695                 :            :                               const string& synonym) const
     696                 :            : {
     697         [ +  + ]:          4 :     for (auto&& shard : shards) {
     698                 :          3 :         shard->remove_synonym(term, synonym);
     699                 :            :     }
     700                 :          1 : }
     701                 :            : 
     702                 :            : void
     703                 :          2 : MultiDatabase::clear_synonyms(const string& term) const
     704                 :            : {
     705         [ +  + ]:          4 :     for (auto&& shard : shards) {
     706                 :          3 :         shard->clear_synonyms(term);
     707                 :            :     }
     708                 :          1 : }
     709                 :            : 
     710                 :            : void
     711                 :         22 : MultiDatabase::set_metadata(const string& key, const string& value)
     712                 :            : {
     713                 :         22 :     shards[0]->set_metadata(key, value);
     714                 :         21 : }
     715                 :            : 
     716                 :            : string
     717                 :          1 : MultiDatabase::get_description() const
     718                 :            : {
     719                 :          1 :     string desc;
     720         [ +  + ]:          3 :     for (auto&& shard : shards) {
     721         [ +  + ]:          2 :         if (!desc.empty()) {
     722         [ +  - ]:          1 :             desc += ", ";
     723                 :            :         }
     724 [ +  - ][ +  - ]:          2 :         desc += shard->get_description();
     725                 :            :     }
     726         [ +  - ]:          1 :     desc += ')';
     727                 :          1 :     return desc;
     728                 :            : }

Generated by: LCOV version 1.11