LCOV - code coverage report
Current view: top level - backends/glass - glass_compact.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 503 608 82.7 %
Date: 2019-06-30 05:20:33 Functions: 24 24 100.0 %
Branches: 544 1170 46.5 %

           Branch data     Line data    Source code
       1                 :            : /** @file glass_compact.cc
       2                 :            :  * @brief Compact a glass database, or merge and compact several.
       3                 :            :  */
       4                 :            : /* Copyright (C) 2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2017 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
      19                 :            :  * USA
      20                 :            :  */
      21                 :            : 
      22                 :            : #include <config.h>
      23                 :            : 
      24                 :            : #include "xapian/compactor.h"
      25                 :            : #include "xapian/constants.h"
      26                 :            : #include "xapian/error.h"
      27                 :            : #include "xapian/types.h"
      28                 :            : 
      29                 :            : #include <algorithm>
      30                 :            : #include <memory>
      31                 :            : #include <queue>
      32                 :            : 
      33                 :            : #include <cerrno>
      34                 :            : #include <cstdio>
      35                 :            : 
      36                 :            : #include "backends/flint_lock.h"
      37                 :            : #include "glass_database.h"
      38                 :            : #include "glass_defs.h"
      39                 :            : #include "glass_table.h"
      40                 :            : #include "glass_cursor.h"
      41                 :            : #include "glass_version.h"
      42                 :            : #include "filetests.h"
      43                 :            : #include "internaltypes.h"
      44                 :            : #include "pack.h"
      45                 :            : #include "backends/valuestats.h"
      46                 :            : 
      47                 :            : #include "../byte_length_strings.h"
      48                 :            : #include "../prefix_compressed_strings.h"
      49                 :            : 
      50                 :            : using namespace std;
      51                 :            : 
      52                 :            : // Put all the helpers in a namespace to avoid symbols colliding with those of
      53                 :            : // the same name in other flint-derived backends.
      54                 :            : namespace GlassCompact {
      55                 :            : 
      56                 :            : static inline bool
      57                 :      13378 : is_user_metadata_key(const string & key)
      58                 :            : {
      59 [ +  + ][ +  + ]:      13378 :     return key.size() > 1 && key[0] == '\0' && key[1] == '\xc0';
                 [ -  + ]
      60                 :            : }
      61                 :            : 
      62                 :            : static inline bool
      63                 :      14311 : is_valuestats_key(const string & key)
      64                 :            : {
      65 [ +  + ][ +  + ]:      14311 :     return key.size() > 1 && key[0] == '\0' && key[1] == '\xd0';
                 [ +  + ]
      66                 :            : }
      67                 :            : 
      68                 :            : static inline bool
      69                 :      13769 : is_valuechunk_key(const string & key)
      70                 :            : {
      71 [ +  + ][ +  + ]:      13769 :     return key.size() > 1 && key[0] == '\0' && key[1] == '\xd8';
                 [ +  + ]
      72                 :            : }
      73                 :            : 
      74                 :            : static inline bool
      75                 :      21308 : is_doclenchunk_key(const string & key)
      76                 :            : {
      77 [ +  + ][ +  + ]:      21308 :     return key.size() > 1 && key[0] == '\0' && key[1] == '\xe0';
                 [ +  - ]
      78                 :            : }
      79                 :            : 
      80                 :        226 : class PostlistCursor : private GlassCursor {
      81                 :            :     Xapian::docid offset;
      82                 :            : 
      83                 :            :   public:
      84                 :            :     string key, tag;
      85                 :            :     Xapian::docid firstdid;
      86                 :            :     Xapian::termcount tf, cf;
      87                 :            : 
      88                 :        113 :     PostlistCursor(const GlassTable *in, Xapian::docid offset_)
      89 [ +  - ][ +  - ]:        113 :         : GlassCursor(in), offset(offset_), firstdid(0)
      90                 :            :     {
      91         [ +  - ]:        113 :         rewind();
      92         [ +  - ]:        113 :         next();
      93                 :        113 :     }
      94                 :            : 
      95                 :      13426 :     bool next() {
      96 [ +  - ][ +  + ]:      13426 :         if (!GlassCursor::next()) return false;
      97                 :            :         // We put all chunks into the non-initial chunk form here, then fix up
      98                 :            :         // the first chunk for each term in the merged database as we merge.
      99         [ +  - ]:      13313 :         read_tag();
     100         [ +  - ]:      13313 :         key = current_key;
     101         [ +  - ]:      13313 :         tag = current_tag;
     102                 :      13313 :         tf = cf = 0;
     103         [ -  + ]:      13313 :         if (is_user_metadata_key(key)) return true;
     104         [ +  + ]:      13313 :         if (is_valuestats_key(key)) return true;
     105         [ +  + ]:      12380 :         if (is_valuechunk_key(key)) {
     106                 :       1324 :             const char * p = key.data();
     107                 :       1324 :             const char * end = p + key.length();
     108                 :       1324 :             p += 2;
     109                 :            :             Xapian::valueno slot;
     110         [ -  + ]:       1324 :             if (!unpack_uint(&p, end, &slot))
     111 [ #  # ][ #  # ]:          0 :                 throw Xapian::DatabaseCorruptError("bad value key");
                 [ #  # ]
     112                 :            :             Xapian::docid did;
     113         [ -  + ]:       1324 :             if (!unpack_uint_preserving_sort(&p, end, &did))
     114 [ #  # ][ #  # ]:          0 :                 throw Xapian::DatabaseCorruptError("bad value key");
                 [ #  # ]
     115                 :       1324 :             did += offset;
     116                 :            : 
     117         [ +  - ]:       1324 :             key.assign("\0\xd8", 2);
     118         [ +  - ]:       1324 :             pack_uint(key, slot);
     119         [ +  - ]:       1324 :             pack_uint_preserving_sort(key, did);
     120                 :       1324 :             return true;
     121                 :            :         }
     122                 :            : 
     123                 :            :         // Adjust key if this is *NOT* an initial chunk.
     124                 :            :         // key is: pack_string_preserving_sort(key, tname)
     125                 :            :         // plus optionally: pack_uint_preserving_sort(key, did)
     126                 :      11056 :         const char * d = key.data();
     127                 :      11056 :         const char * e = d + key.size();
     128         [ +  + ]:      11056 :         if (is_doclenchunk_key(key)) {
     129                 :        140 :             d += 2;
     130                 :            :         } else {
     131         [ +  - ]:      10916 :             string tname;
     132 [ +  - ][ -  + ]:      10916 :             if (!unpack_string_preserving_sort(&d, e, tname))
     133 [ #  # ][ #  # ]:      10916 :                 throw Xapian::DatabaseCorruptError("Bad postlist key");
                 [ #  # ]
     134                 :            :         }
     135                 :            : 
     136         [ +  + ]:      11056 :         if (d == e) {
     137                 :            :             // This is an initial chunk for a term, so adjust tag header.
     138                 :      11008 :             d = tag.data();
     139                 :      11008 :             e = d + tag.size();
     140 [ +  - ][ -  + ]:      33024 :             if (!unpack_uint(&d, e, &tf) ||
     141 [ +  - ][ -  + ]:      22016 :                 !unpack_uint(&d, e, &cf) ||
     142                 :      11008 :                 !unpack_uint(&d, e, &firstdid)) {
     143 [ #  # ][ #  # ]:          0 :                 throw Xapian::DatabaseCorruptError("Bad postlist key");
                 [ #  # ]
     144                 :            :             }
     145                 :      11008 :             ++firstdid;
     146         [ +  - ]:      11008 :             tag.erase(0, d - tag.data());
     147                 :            :         } else {
     148                 :            :             // Not an initial chunk, so adjust key.
     149                 :         48 :             size_t tmp = d - key.data();
     150 [ +  - ][ -  + ]:         48 :             if (!unpack_uint_preserving_sort(&d, e, &firstdid) || d != e)
                 [ -  + ]
     151 [ #  # ][ #  # ]:          0 :                 throw Xapian::DatabaseCorruptError("Bad postlist key");
                 [ #  # ]
     152         [ +  + ]:         48 :             if (is_doclenchunk_key(key)) {
     153         [ +  - ]:         27 :                 key.erase(tmp);
     154                 :            :             } else {
     155         [ +  - ]:         21 :                 key.erase(tmp - 1);
     156                 :            :             }
     157                 :            :         }
     158                 :      11056 :         firstdid += offset;
     159                 :      13426 :         return true;
     160                 :            :     }
     161                 :            : };
     162                 :            : 
     163                 :            : class PostlistCursorGt {
     164                 :            :   public:
     165                 :            :     /** Return true if and only if a's key is strictly greater than b's key.
     166                 :            :      */
     167                 :       7764 :     bool operator()(const PostlistCursor *a, const PostlistCursor *b) const {
     168         [ +  + ]:       7764 :         if (a->key > b->key) return true;
     169         [ +  + ]:       5515 :         if (a->key != b->key) return false;
     170                 :       1753 :         return (a->firstdid > b->firstdid);
     171                 :            :     }
     172                 :            : };
     173                 :            : 
     174                 :            : static string
     175                 :        555 : encode_valuestats(Xapian::doccount freq,
     176                 :            :                   const string & lbound, const string & ubound)
     177                 :            : {
     178                 :        555 :     string value;
     179         [ +  - ]:        555 :     pack_uint(value, freq);
     180         [ +  - ]:        555 :     pack_string(value, lbound);
     181                 :            :     // We don't store or count empty values, so neither of the bounds
     182                 :            :     // can be empty.  So we can safely store an empty upper bound when
     183                 :            :     // the bounds are equal.
     184 [ +  - ][ +  + ]:        555 :     if (lbound != ubound) value += ubound;
                 [ +  - ]
     185                 :        555 :     return value;
     186                 :            : }
     187                 :            : 
     188                 :            : static void
     189                 :         72 : merge_postlists(Xapian::Compactor * compactor,
     190                 :            :                 GlassTable * out, vector<Xapian::docid>::const_iterator offset,
     191                 :            :                 vector<const GlassTable*>::const_iterator b,
     192                 :            :                 vector<const GlassTable*>::const_iterator e)
     193                 :            : {
     194         [ +  - ]:         72 :     priority_queue<PostlistCursor *, vector<PostlistCursor *>, PostlistCursorGt> pq;
     195         [ +  + ]:        203 :     for ( ; b != e; ++b, ++offset) {
     196                 :        131 :         const GlassTable *in = *b;
     197         [ +  + ]:        131 :         if (in->empty()) {
     198                 :            :             // Skip empty tables.
     199                 :         18 :             continue;
     200                 :            :         }
     201                 :            : 
     202 [ +  - ][ +  - ]:        113 :         pq.push(new PostlistCursor(in, *offset));
                 [ +  - ]
     203                 :            :     }
     204                 :            : 
     205         [ +  - ]:        144 :     string last_key;
     206                 :            :     {
     207                 :            :         // Merge user metadata.
     208                 :         72 :         vector<string> tags;
     209         [ +  + ]:         72 :         while (!pq.empty()) {
     210                 :         65 :             PostlistCursor * cur = pq.top();
     211                 :         65 :             const string& key = cur->key;
     212         [ +  - ]:         65 :             if (!is_user_metadata_key(key)) break;
     213                 :            : 
     214 [ #  # ][ #  # ]:          0 :             if (key != last_key) {
     215         [ #  # ]:          0 :                 if (!tags.empty()) {
     216 [ #  # ][ #  # ]:          0 :                     if (tags.size() > 1 && compactor) {
                 [ #  # ]
     217                 :            :                         Assert(!last_key.empty());
     218                 :            :                         // FIXME: It would be better to merge all duplicates
     219                 :            :                         // for a key in one call, but currently we don't in
     220                 :            :                         // multipass mode.
     221                 :            :                         const string & resolved_tag =
     222                 :            :                             compactor->resolve_duplicate_metadata(last_key,
     223                 :            :                                                                   tags.size(),
     224         [ #  # ]:          0 :                                                                   &tags[0]);
     225         [ #  # ]:          0 :                         if (!resolved_tag.empty())
     226 [ #  # ][ #  # ]:          0 :                             out->add(last_key, resolved_tag);
     227                 :            :                     } else {
     228                 :            :                         Assert(!last_key.empty());
     229 [ #  # ][ #  # ]:          0 :                         out->add(last_key, tags[0]);
     230                 :            :                     }
     231         [ #  # ]:          0 :                     tags.resize(0);
     232                 :            :                 }
     233         [ #  # ]:          0 :                 last_key = key;
     234                 :            :             }
     235         [ #  # ]:          0 :             tags.push_back(cur->tag);
     236                 :            : 
     237         [ #  # ]:          0 :             pq.pop();
     238 [ #  # ][ #  # ]:          0 :             if (cur->next()) {
     239         [ #  # ]:          0 :                 pq.push(cur);
     240                 :            :             } else {
     241         [ #  # ]:          0 :                 delete cur;
     242                 :            :             }
     243                 :            :         }
     244         [ -  + ]:         72 :         if (!tags.empty()) {
     245 [ #  # ][ #  # ]:          0 :             if (tags.size() > 1 && compactor) {
                 [ #  # ]
     246                 :            :                 Assert(!last_key.empty());
     247                 :            :                 const string & resolved_tag =
     248                 :            :                     compactor->resolve_duplicate_metadata(last_key,
     249                 :            :                                                           tags.size(),
     250         [ #  # ]:          0 :                                                           &tags[0]);
     251         [ #  # ]:          0 :                 if (!resolved_tag.empty())
     252 [ #  # ][ #  # ]:          0 :                     out->add(last_key, resolved_tag);
     253                 :            :             } else {
     254                 :            :                 Assert(!last_key.empty());
     255 [ #  # ][ #  # ]:          0 :                 out->add(last_key, tags[0]);
     256                 :            :             }
     257                 :         72 :         }
     258                 :            :     }
     259                 :            : 
     260                 :            :     {
     261                 :            :         // Merge valuestats.
     262                 :         72 :         Xapian::doccount freq = 0;
     263 [ +  - ][ +  - ]:        144 :         string lbound, ubound;
     264                 :            : 
     265         [ +  + ]:       1005 :         while (!pq.empty()) {
     266                 :        998 :             PostlistCursor * cur = pq.top();
     267                 :        998 :             const string& key = cur->key;
     268         [ +  + ]:        998 :             if (!is_valuestats_key(key)) break;
     269 [ +  - ][ +  + ]:        933 :             if (key != last_key) {
     270                 :            :                 // For the first valuestats key, last_key will be the previous
     271                 :            :                 // key we wrote, which we don't want to overwrite.  This is the
     272                 :            :                 // only time that freq will be 0, so check that.
     273         [ +  + ]:        555 :                 if (freq) {
     274 [ +  - ][ +  - ]:        514 :                     out->add(last_key, encode_valuestats(freq, lbound, ubound));
     275                 :        514 :                     freq = 0;
     276                 :            :                 }
     277         [ +  - ]:        555 :                 last_key = key;
     278                 :            :             }
     279                 :            : 
     280                 :        933 :             const string & tag = cur->tag;
     281                 :            : 
     282                 :        933 :             const char * pos = tag.data();
     283                 :        933 :             const char * end = pos + tag.size();
     284                 :            : 
     285                 :            :             Xapian::doccount f;
     286 [ +  - ][ +  - ]:       1866 :             string l, u;
     287         [ -  + ]:        933 :             if (!unpack_uint(&pos, end, &f)) {
     288 [ #  # ][ #  # ]:          0 :                 if (*pos == 0) throw Xapian::DatabaseCorruptError("Incomplete stats item in value table");
         [ #  # ][ #  # ]
     289 [ #  # ][ #  # ]:          0 :                 throw Xapian::RangeError("Frequency statistic in value table is too large");
                 [ #  # ]
     290                 :            :             }
     291 [ +  - ][ -  + ]:        933 :             if (!unpack_string(&pos, end, l)) {
     292 [ #  # ][ #  # ]:          0 :                 if (*pos == 0) throw Xapian::DatabaseCorruptError("Incomplete stats item in value table");
         [ #  # ][ #  # ]
     293 [ #  # ][ #  # ]:          0 :                 throw Xapian::RangeError("Lower bound in value table is too large");
                 [ #  # ]
     294                 :            :             }
     295                 :        933 :             size_t len = end - pos;
     296         [ +  + ]:        933 :             if (len == 0) {
     297         [ +  - ]:        273 :                 u = l;
     298                 :            :             } else {
     299         [ +  - ]:        660 :                 u.assign(pos, len);
     300                 :            :             }
     301         [ +  + ]:        933 :             if (freq == 0) {
     302                 :        555 :                 freq = f;
     303         [ +  - ]:        555 :                 lbound = l;
     304         [ +  - ]:        555 :                 ubound = u;
     305                 :            :             } else {
     306                 :        378 :                 freq += f;
     307 [ +  - ][ +  + ]:        378 :                 if (l < lbound) lbound = l;
                 [ +  - ]
     308 [ +  - ][ +  + ]:        378 :                 if (u > ubound) ubound = u;
                 [ +  - ]
     309                 :            :             }
     310                 :            : 
     311         [ +  - ]:        933 :             pq.pop();
     312 [ +  - ][ +  - ]:        933 :             if (cur->next()) {
     313         [ +  - ]:        933 :                 pq.push(cur);
     314                 :            :             } else {
     315         [ #  # ]:          0 :                 delete cur;
     316                 :            :             }
     317                 :        933 :         }
     318                 :            : 
     319         [ +  + ]:         72 :         if (freq) {
     320 [ +  - ][ +  - ]:         41 :             out->add(last_key, encode_valuestats(freq, lbound, ubound));
     321                 :         72 :         }
     322                 :            :     }
     323                 :            : 
     324                 :            :     // Merge valuestream chunks.
     325         [ +  + ]:       1396 :     while (!pq.empty()) {
     326                 :       1389 :         PostlistCursor * cur = pq.top();
     327                 :       1389 :         const string & key = cur->key;
     328         [ +  + ]:       1389 :         if (!is_valuechunk_key(key)) break;
     329                 :            :         Assert(!is_user_metadata_key(key));
     330 [ +  - ][ +  - ]:       1324 :         out->add(key, cur->tag);
     331         [ +  - ]:       1324 :         pq.pop();
     332 [ +  - ][ +  - ]:       1324 :         if (cur->next()) {
     333         [ +  - ]:       1324 :             pq.push(cur);
     334                 :            :         } else {
     335         [ #  # ]:       1324 :             delete cur;
     336                 :            :         }
     337                 :            :     }
     338                 :            : 
     339                 :         72 :     Xapian::termcount tf = 0, cf = 0; // Initialise to avoid warnings.
     340                 :        144 :     vector<pair<Xapian::docid, string>> tags;
     341                 :            :     while (true) {
     342                 :      11128 :         PostlistCursor * cur = NULL;
     343         [ +  + ]:      11128 :         if (!pq.empty()) {
     344                 :      11056 :             cur = pq.top();
     345         [ +  - ]:      11056 :             pq.pop();
     346                 :            :         }
     347                 :            :         Assert(cur == NULL || !is_user_metadata_key(cur->key));
     348 [ +  + ][ +  - ]:      11128 :         if (cur == NULL || cur->key != last_key) {
         [ +  + ][ +  + ]
     349         [ +  + ]:      10276 :             if (!tags.empty()) {
     350         [ +  - ]:      10204 :                 string first_tag;
     351         [ +  - ]:      10204 :                 pack_uint(first_tag, tf);
     352         [ +  - ]:      10204 :                 pack_uint(first_tag, cf);
     353         [ +  - ]:      10204 :                 pack_uint(first_tag, tags[0].first - 1);
     354         [ +  - ]:      20408 :                 string tag = tags[0].second;
     355 [ +  - ][ +  + ]:      10204 :                 tag[0] = (tags.size() == 1) ? '1' : '0';
     356         [ +  - ]:      10204 :                 first_tag += tag;
     357 [ +  - ][ +  - ]:      10204 :                 out->add(last_key, first_tag);
     358                 :            : 
     359         [ +  - ]:      20408 :                 string term;
     360         [ +  + ]:      10204 :                 if (!is_doclenchunk_key(last_key)) {
     361                 :      10139 :                     const char * p = last_key.data();
     362                 :      10139 :                     const char * end = p + last_key.size();
     363 [ +  - ][ +  - ]:      10139 :                     if (!unpack_string_preserving_sort(&p, end, term) || p != end)
         [ -  + ][ -  + ]
     364 [ #  # ][ #  # ]:      10139 :                         throw Xapian::DatabaseCorruptError("Bad postlist chunk key");
                 [ #  # ]
     365                 :            :                 }
     366                 :            : 
     367                 :      10204 :                 auto i = tags.begin();
     368         [ +  + ]:      11056 :                 while (++i != tags.end()) {
     369         [ +  - ]:        852 :                     tag = i->second;
     370 [ +  - ][ +  + ]:        852 :                     tag[0] = (i + 1 == tags.end()) ? '1' : '0';
     371 [ +  - ][ +  - ]:        852 :                     out->add(pack_glass_postlist_key(term, i->first), tag);
                 [ +  - ]
     372                 :      10204 :                 }
     373                 :            :             }
     374                 :      10276 :             tags.clear();
     375         [ +  + ]:      10276 :             if (cur == NULL) break;
     376                 :      10204 :             tf = cf = 0;
     377         [ +  - ]:      10204 :             last_key = cur->key;
     378                 :            :         }
     379                 :      11056 :         tf += cur->tf;
     380                 :      11056 :         cf += cur->cf;
     381 [ +  - ][ +  - ]:      11056 :         tags.push_back(make_pair(cur->firstdid, cur->tag));
     382 [ +  - ][ +  + ]:      11056 :         if (cur->next()) {
     383         [ +  - ]:      10943 :             pq.push(cur);
     384                 :            :         } else {
     385         [ +  - ]:      11056 :             delete cur;
     386                 :            :         }
     387                 :         72 :     }
     388                 :         72 : }
     389                 :            : 
     390                 :         24 : struct MergeCursor : public GlassCursor {
     391                 :         24 :     explicit MergeCursor(const GlassTable *in) : GlassCursor(in) {
     392         [ +  - ]:         12 :         rewind();
     393         [ +  - ]:         12 :         next();
     394                 :         12 :     }
     395                 :            : };
     396                 :            : 
     397                 :            : struct CursorGt {
     398                 :            :     /// Return true if and only if a's key is strictly greater than b's key.
     399                 :         24 :     bool operator()(const GlassCursor *a, const GlassCursor *b) const {
     400         [ -  + ]:         24 :         if (b->after_end()) return false;
     401         [ -  + ]:         24 :         if (a->after_end()) return true;
     402                 :         24 :         return (a->current_key > b->current_key);
     403                 :            :     }
     404                 :            : };
     405                 :            : 
     406                 :            : static void
     407                 :          8 : merge_spellings(GlassTable * out,
     408                 :            :                 vector<const GlassTable*>::const_iterator b,
     409                 :            :                 vector<const GlassTable*>::const_iterator e)
     410                 :            : {
     411         [ +  - ]:          8 :     priority_queue<MergeCursor *, vector<MergeCursor *>, CursorGt> pq;
     412         [ +  + ]:         34 :     for ( ; b != e; ++b) {
     413                 :         26 :         const GlassTable *in = *b;
     414         [ +  + ]:         26 :         if (!in->empty()) {
     415 [ +  - ][ +  - ]:          6 :             pq.push(new MergeCursor(in));
                 [ +  - ]
     416                 :            :         }
     417                 :            :     }
     418                 :            : 
     419         [ +  + ]:         38 :     while (!pq.empty()) {
     420                 :         30 :         MergeCursor * cur = pq.top();
     421         [ +  - ]:         30 :         pq.pop();
     422                 :            : 
     423         [ +  - ]:         30 :         string key = cur->current_key;
     424 [ +  + ][ +  - ]:         30 :         if (pq.empty() || pq.top()->current_key > key) {
         [ +  - ][ +  - ]
     425                 :            :             // No need to merge the tags, just copy the (possibly compressed)
     426                 :            :             // tag value.
     427         [ +  - ]:         30 :             bool compressed = cur->read_tag(true);
     428 [ +  - ][ +  - ]:         30 :             out->add(key, cur->current_tag, compressed);
     429 [ +  - ][ +  + ]:         30 :             if (cur->next()) {
     430         [ +  - ]:         24 :                 pq.push(cur);
     431                 :            :             } else {
     432         [ +  - ]:          6 :                 delete cur;
     433                 :            :             }
     434                 :         30 :             continue;
     435                 :            :         }
     436                 :            : 
     437                 :            :         // Merge tag values with the same key:
     438 [ #  # ][ -  + ]:         30 :         string tag;
     439 [ #  # ][ #  # ]:          0 :         if (key[0] != 'W') {
     440                 :            :             // We just want the union of words, so copy over the first instance
     441                 :            :             // and skip any identical ones.
     442                 :            :             priority_queue<PrefixCompressedStringItor *,
     443                 :            :                            vector<PrefixCompressedStringItor *>,
     444         [ #  # ]:          0 :                            PrefixCompressedStringItorGt> pqtag;
     445                 :            :             // Stick all the MergeCursor pointers in a vector because their
     446                 :            :             // current_tag members must remain valid while we're merging their
     447                 :            :             // tags, but we need to call next() on them all afterwards.
     448                 :          0 :             vector<MergeCursor *> vec;
     449         [ #  # ]:          0 :             vec.reserve(pq.size());
     450                 :            : 
     451                 :            :             while (true) {
     452         [ #  # ]:          0 :                 cur->read_tag();
     453 [ #  # ][ #  # ]:          0 :                 pqtag.push(new PrefixCompressedStringItor(cur->current_tag));
                 [ #  # ]
     454         [ #  # ]:          0 :                 vec.push_back(cur);
     455 [ #  # ][ #  # ]:          0 :                 if (pq.empty() || pq.top()->current_key != key) break;
         [ #  # ][ #  # ]
     456                 :          0 :                 cur = pq.top();
     457         [ #  # ]:          0 :                 pq.pop();
     458                 :            :             }
     459                 :            : 
     460         [ #  # ]:          0 :             PrefixCompressedStringWriter wr(tag);
     461         [ #  # ]:          0 :             string lastword;
     462         [ #  # ]:          0 :             while (!pqtag.empty()) {
     463                 :          0 :                 PrefixCompressedStringItor * it = pqtag.top();
     464         [ #  # ]:          0 :                 pqtag.pop();
     465         [ #  # ]:          0 :                 string word = **it;
     466 [ #  # ][ #  # ]:          0 :                 if (word != lastword) {
     467         [ #  # ]:          0 :                     lastword = word;
     468         [ #  # ]:          0 :                     wr.append(lastword);
     469                 :            :                 }
     470         [ #  # ]:          0 :                 ++*it;
     471         [ #  # ]:          0 :                 if (!it->at_end()) {
     472         [ #  # ]:          0 :                     pqtag.push(it);
     473                 :            :                 } else {
     474         [ #  # ]:          0 :                     delete it;
     475                 :            :                 }
     476                 :          0 :             }
     477                 :            : 
     478                 :          0 :             vector<MergeCursor *>::const_iterator i;
     479         [ #  # ]:          0 :             for (i = vec.begin(); i != vec.end(); ++i) {
     480                 :          0 :                 cur = *i;
     481 [ #  # ][ #  # ]:          0 :                 if (cur->next()) {
     482         [ #  # ]:          0 :                     pq.push(cur);
     483                 :            :                 } else {
     484         [ #  # ]:          0 :                     delete cur;
     485                 :            :                 }
     486                 :          0 :             }
     487                 :            :         } else {
     488                 :            :             // We want to sum the frequencies from tags for the same key.
     489                 :          0 :             Xapian::termcount tot_freq = 0;
     490                 :            :             while (true) {
     491         [ #  # ]:          0 :                 cur->read_tag();
     492                 :            :                 Xapian::termcount freq;
     493                 :          0 :                 const char * p = cur->current_tag.data();
     494                 :          0 :                 const char * end = p + cur->current_tag.size();
     495 [ #  # ][ #  # ]:          0 :                 if (!unpack_uint_last(&p, end, &freq) || freq == 0) {
                 [ #  # ]
     496 [ #  # ][ #  # ]:          0 :                     throw Xapian::DatabaseCorruptError("Bad spelling word freq");
                 [ #  # ]
     497                 :            :                 }
     498                 :          0 :                 tot_freq += freq;
     499 [ #  # ][ #  # ]:          0 :                 if (cur->next()) {
     500         [ #  # ]:          0 :                     pq.push(cur);
     501                 :            :                 } else {
     502         [ #  # ]:          0 :                     delete cur;
     503                 :            :                 }
     504 [ #  # ][ #  # ]:          0 :                 if (pq.empty() || pq.top()->current_key != key) break;
         [ #  # ][ #  # ]
     505                 :          0 :                 cur = pq.top();
     506         [ #  # ]:          0 :                 pq.pop();
     507                 :            :             }
     508         [ #  # ]:          0 :             tag.resize(0);
     509         [ #  # ]:          0 :             pack_uint_last(tag, tot_freq);
     510                 :            :         }
     511 [ #  # ][ #  # ]:          0 :         out->add(key, tag);
     512                 :         38 :     }
     513                 :          8 : }
     514                 :            : 
     515                 :            : static void
     516                 :          8 : merge_synonyms(GlassTable * out,
     517                 :            :                vector<const GlassTable*>::const_iterator b,
     518                 :            :                vector<const GlassTable*>::const_iterator e)
     519                 :            : {
     520         [ +  - ]:          8 :     priority_queue<MergeCursor *, vector<MergeCursor *>, CursorGt> pq;
     521         [ +  + ]:         34 :     for ( ; b != e; ++b) {
     522                 :         26 :         const GlassTable *in = *b;
     523         [ +  + ]:         26 :         if (!in->empty()) {
     524 [ +  - ][ +  - ]:          6 :             pq.push(new MergeCursor(in));
                 [ +  - ]
     525                 :            :         }
     526                 :            :     }
     527                 :            : 
     528         [ +  + ]:         20 :     while (!pq.empty()) {
     529                 :         12 :         MergeCursor * cur = pq.top();
     530         [ +  - ]:         12 :         pq.pop();
     531                 :            : 
     532         [ +  - ]:         12 :         string key = cur->current_key;
     533 [ +  + ][ +  - ]:         12 :         if (pq.empty() || pq.top()->current_key > key) {
         [ +  + ][ +  + ]
     534                 :            :             // No need to merge the tags, just copy the (possibly compressed)
     535                 :            :             // tag value.
     536         [ +  - ]:         10 :             bool compressed = cur->read_tag(true);
     537 [ +  - ][ +  - ]:         10 :             out->add(key, cur->current_tag, compressed);
     538 [ +  - ][ +  + ]:         10 :             if (cur->next()) {
     539         [ +  - ]:          4 :                 pq.push(cur);
     540                 :            :             } else {
     541         [ +  - ]:          6 :                 delete cur;
     542                 :            :             }
     543                 :         10 :             continue;
     544                 :            :         }
     545                 :            : 
     546                 :            :         // Merge tag values with the same key:
     547 [ +  - ][ +  + ]:         14 :         string tag;
     548                 :            : 
     549                 :            :         // We just want the union of words, so copy over the first instance
     550                 :            :         // and skip any identical ones.
     551                 :            :         priority_queue<ByteLengthPrefixedStringItor *,
     552                 :            :                        vector<ByteLengthPrefixedStringItor *>,
     553         [ +  - ]:          4 :                        ByteLengthPrefixedStringItorGt> pqtag;
     554                 :          4 :         vector<MergeCursor *> vec;
     555                 :            : 
     556                 :            :         while (true) {
     557         [ +  - ]:          4 :             cur->read_tag();
     558 [ +  - ][ +  - ]:          4 :             pqtag.push(new ByteLengthPrefixedStringItor(cur->current_tag));
     559         [ +  - ]:          4 :             vec.push_back(cur);
     560 [ +  + ][ +  - ]:          4 :             if (pq.empty() || pq.top()->current_key != key) break;
         [ -  + ][ +  + ]
     561                 :          2 :             cur = pq.top();
     562         [ +  - ]:          2 :             pq.pop();
     563                 :            :         }
     564                 :            : 
     565         [ +  - ]:          4 :         string lastword;
     566         [ +  + ]:          6 :         while (!pqtag.empty()) {
     567                 :          4 :             ByteLengthPrefixedStringItor * it = pqtag.top();
     568         [ +  - ]:          4 :             pqtag.pop();
     569 [ +  - ][ +  - ]:          4 :             if (**it != lastword) {
                 [ +  - ]
     570 [ +  - ][ +  - ]:          4 :                 lastword = **it;
     571         [ +  - ]:          4 :                 tag += uint8_t(lastword.size() ^ MAGIC_XOR_VALUE);
     572         [ +  - ]:          4 :                 tag += lastword;
     573                 :            :             }
     574         [ +  - ]:          4 :             ++*it;
     575         [ -  + ]:          4 :             if (!it->at_end()) {
     576         [ #  # ]:          0 :                 pqtag.push(it);
     577                 :            :             } else {
     578                 :          4 :                 delete it;
     579                 :            :             }
     580                 :            :         }
     581                 :            : 
     582                 :          2 :         vector<MergeCursor *>::const_iterator i;
     583         [ +  + ]:          6 :         for (i = vec.begin(); i != vec.end(); ++i) {
     584                 :          4 :             cur = *i;
     585 [ +  - ][ +  - ]:          4 :             if (cur->next()) {
     586         [ +  - ]:          4 :                 pq.push(cur);
     587                 :            :             } else {
     588         [ #  # ]:          0 :                 delete cur;
     589                 :            :             }
     590                 :            :         }
     591                 :            : 
     592 [ +  - ][ +  - ]:          2 :         out->add(key, tag);
     593                 :         20 :     }
     594                 :          8 : }
     595                 :            : 
     596                 :            : static void
     597                 :          2 : multimerge_postlists(Xapian::Compactor * compactor,
     598                 :            :                      GlassTable * out, const char * tmpdir,
     599                 :            :                      vector<const GlassTable *> tmp,
     600                 :            :                      vector<Xapian::docid> off)
     601                 :            : {
     602                 :          2 :     unsigned int c = 0;
     603         [ +  + ]:          5 :     while (tmp.size() > 3) {
     604                 :          3 :         vector<const GlassTable *> tmpout;
     605         [ +  - ]:          3 :         tmpout.reserve(tmp.size() / 2);
     606                 :          6 :         vector<Xapian::docid> newoff;
     607         [ +  - ]:          3 :         newoff.resize(tmp.size() / 2);
     608         [ +  + ]:         11 :         for (unsigned int i = 0, j; i < tmp.size(); i = j) {
     609                 :          8 :             j = i + 2;
     610         [ -  + ]:          8 :             if (j == tmp.size() - 1) ++j;
     611                 :            : 
     612         [ +  - ]:          8 :             string dest = tmpdir;
     613                 :            :             char buf[64];
     614                 :          8 :             sprintf(buf, "/tmp%u_%u.", c, i / 2);
     615         [ +  - ]:          8 :             dest += buf;
     616                 :            : 
     617 [ +  - ][ +  - ]:          8 :             GlassTable * tmptab = new GlassTable("postlist", dest, false);
     618                 :            : 
     619                 :            :             // Use maximum blocksize for temporary tables.  And don't compress
     620                 :            :             // entries in temporary tables, even if the final table would do
     621                 :            :             // so.  Any already compressed entries will get copied in
     622                 :            :             // compressed form.
     623         [ +  - ]:         16 :             RootInfo root_info;
     624         [ +  - ]:          8 :             root_info.init(65536, 0);
     625                 :          8 :             const int flags = Xapian::DB_DANGEROUS|Xapian::DB_NO_SYNC;
     626         [ +  - ]:          8 :             tmptab->create_and_open(flags, root_info);
     627                 :            : 
     628                 :          8 :             merge_postlists(compactor, tmptab, off.begin() + i,
     629         [ +  - ]:         16 :                             tmp.begin() + i, tmp.begin() + j);
     630         [ +  + ]:          8 :             if (c > 0) {
     631         [ +  + ]:          6 :                 for (unsigned int k = i; k < j; ++k) {
     632         [ +  - ]:          4 :                     unlink(tmp[k]->get_path().c_str());
     633         [ +  - ]:          4 :                     delete tmp[k];
     634                 :          4 :                     tmp[k] = NULL;
     635                 :            :                 }
     636                 :            :             }
     637         [ +  - ]:          8 :             tmpout.push_back(tmptab);
     638         [ +  - ]:          8 :             tmptab->flush_db();
     639         [ +  - ]:          8 :             tmptab->commit(1, &root_info);
     640                 :            :             AssertRel(root_info.get_blocksize(),==,65536);
     641                 :          8 :         }
     642                 :          3 :         swap(tmp, tmpout);
     643         [ +  - ]:          3 :         swap(off, newoff);
     644                 :          3 :         ++c;
     645                 :          3 :     }
     646         [ +  - ]:          2 :     merge_postlists(compactor, out, off.begin(), tmp.begin(), tmp.end());
     647         [ +  - ]:          2 :     if (c > 0) {
     648         [ +  + ]:          6 :         for (size_t k = 0; k < tmp.size(); ++k) {
     649                 :          4 :             unlink(tmp[k]->get_path().c_str());
     650         [ +  - ]:          4 :             delete tmp[k];
     651                 :          4 :             tmp[k] = NULL;
     652                 :            :         }
     653                 :            :     }
     654                 :          2 : }
     655                 :            : 
     656                 :        136 : class PositionCursor : private GlassCursor {
     657                 :            :     Xapian::docid offset;
     658                 :            : 
     659                 :            :   public:
     660                 :            :     string key;
     661                 :            :     Xapian::docid firstdid;
     662                 :            : 
     663                 :         68 :     PositionCursor(const GlassTable *in, Xapian::docid offset_)
     664         [ +  - ]:         68 :         : GlassCursor(in), offset(offset_), firstdid(0) {
     665         [ +  - ]:         68 :         rewind();
     666         [ +  - ]:         68 :         next();
     667                 :         68 :     }
     668                 :            : 
     669                 :      50000 :     bool next() {
     670 [ +  - ][ +  + ]:      50000 :         if (!GlassCursor::next()) return false;
     671         [ +  - ]:      49932 :         read_tag();
     672                 :      49932 :         const char * d = current_key.data();
     673                 :      49932 :         const char * e = d + current_key.size();
     674         [ +  - ]:      49932 :         string term;
     675                 :            :         Xapian::docid did;
     676   [ +  -  +  - ]:     149796 :         if (!unpack_string_preserving_sort(&d, e, term) ||
                 [ -  + ]
     677 [ +  - ][ -  + ]:      99864 :             !unpack_uint_preserving_sort(&d, e, &did) ||
     678                 :      49932 :             d != e) {
     679 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseCorruptError("Bad position key");
                 [ #  # ]
     680                 :            :         }
     681                 :            : 
     682         [ +  - ]:      49932 :         key.resize(0);
     683         [ +  - ]:      49932 :         pack_string_preserving_sort(key, term);
     684         [ +  - ]:      49932 :         pack_uint_preserving_sort(key, did + offset);
     685                 :      50000 :         return true;
     686                 :            :     }
     687                 :            : 
     688                 :      49932 :     const string & get_tag() const {
     689                 :      49932 :         return current_tag;
     690                 :            :     }
     691                 :            : };
     692                 :            : 
     693                 :            : class PositionCursorGt {
     694                 :            :   public:
     695                 :            :     /** Return true if and only if a's key is strictly greater than b's key.
     696                 :            :      */
     697                 :       6055 :     bool operator()(const PositionCursor *a, const PositionCursor *b) const {
     698                 :       6055 :         return a->key > b->key;
     699                 :            :     }
     700                 :            : };
     701                 :            : 
     702                 :            : static void
     703                 :         47 : merge_positions(GlassTable *out, const vector<const GlassTable*> & inputs,
     704                 :            :                 const vector<Xapian::docid> & offset)
     705                 :            : {
     706         [ +  - ]:         47 :     priority_queue<PositionCursor *, vector<PositionCursor *>, PositionCursorGt> pq;
     707         [ +  + ]:        137 :     for (size_t i = 0; i < inputs.size(); ++i) {
     708                 :         90 :         const GlassTable *in = inputs[i];
     709         [ +  + ]:         90 :         if (in->empty()) {
     710                 :            :             // Skip empty tables.
     711                 :         22 :             continue;
     712                 :            :         }
     713                 :            : 
     714 [ +  - ][ +  - ]:         68 :         pq.push(new PositionCursor(in, offset[i]));
                 [ +  - ]
     715                 :            :     }
     716                 :            : 
     717         [ +  + ]:      49979 :     while (!pq.empty()) {
     718                 :      49932 :         PositionCursor * cur = pq.top();
     719         [ +  - ]:      49932 :         pq.pop();
     720 [ +  - ][ +  - ]:      49932 :         out->add(cur->key, cur->get_tag());
     721 [ +  - ][ +  + ]:      49932 :         if (cur->next()) {
     722         [ +  - ]:      49864 :             pq.push(cur);
     723                 :            :         } else {
     724         [ +  - ]:      49932 :             delete cur;
     725                 :            :         }
     726                 :         47 :     }
     727                 :         47 : }
     728                 :            : 
     729                 :            : static void
     730                 :        116 : merge_docid_keyed(GlassTable *out, const vector<const GlassTable*> & inputs,
     731                 :            :                   const vector<Xapian::docid> & offset)
     732                 :            : {
     733         [ +  + ]:        342 :     for (size_t i = 0; i < inputs.size(); ++i) {
     734                 :        226 :         Xapian::docid off = offset[i];
     735                 :            : 
     736                 :        226 :         const GlassTable * in = inputs[i];
     737         [ +  + ]:        226 :         if (in->empty()) continue;
     738                 :            : 
     739         [ +  - ]:        193 :         GlassCursor cur(in);
     740         [ +  - ]:        193 :         cur.rewind();
     741                 :            : 
     742         [ +  - ]:        386 :         string key;
     743 [ +  - ][ +  + ]:      26460 :         while (cur.next()) {
     744                 :            :             // Adjust the key if this isn't the first database.
     745         [ +  + ]:      26267 :             if (off) {
     746                 :            :                 Xapian::docid did;
     747                 :       5285 :                 const char * d = cur.current_key.data();
     748                 :       5285 :                 const char * e = d + cur.current_key.size();
     749         [ -  + ]:       5285 :                 if (!unpack_uint_preserving_sort(&d, e, &did)) {
     750         [ #  # ]:          0 :                     string msg = "Bad key in ";
     751 [ #  # ][ #  # ]:          0 :                     msg += inputs[i]->get_path();
     752 [ #  # ][ #  # ]:          0 :                     throw Xapian::DatabaseCorruptError(msg);
     753                 :            :                 }
     754                 :       5285 :                 did += off;
     755         [ +  - ]:       5285 :                 key.resize(0);
     756         [ +  - ]:       5285 :                 pack_uint_preserving_sort(key, did);
     757         [ +  + ]:       5285 :                 if (d != e) {
     758                 :            :                     // Copy over anything extra in the key (e.g. the zero byte
     759                 :            :                     // at the end of "used value slots" in the termlist table).
     760         [ +  - ]:       5285 :                     key.append(d, e - d);
     761                 :            :                 }
     762                 :            :             } else {
     763         [ +  - ]:      20982 :                 key = cur.current_key;
     764                 :            :             }
     765         [ +  - ]:      26267 :             bool compressed = cur.read_tag(true);
     766 [ +  - ][ +  - ]:      26267 :             out->add(key, cur.current_tag, compressed);
     767                 :            :         }
     768                 :        193 :     }
     769                 :        116 : }
     770                 :            : 
     771                 :            : }
     772                 :            : 
     773                 :            : using namespace GlassCompact;
     774                 :            : 
     775                 :            : void
     776                 :         68 : GlassDatabase::compact(Xapian::Compactor * compactor,
     777                 :            :                        const char * destdir,
     778                 :            :                        int fd,
     779                 :            :                        const vector<const Xapian::Database::Internal*>& sources,
     780                 :            :                        const vector<Xapian::docid> & offset,
     781                 :            :                        size_t block_size,
     782                 :            :                        Xapian::Compactor::compaction_level compaction,
     783                 :            :                        unsigned flags,
     784                 :            :                        Xapian::docid last_docid)
     785                 :            : {
     786                 :            :     struct table_list {
     787                 :            :         // The "base name" of the table.
     788                 :            :         char name[9];
     789                 :            :         // The type.
     790                 :            :         Glass::table_type type;
     791                 :            :         // Create tables after position lazily.
     792                 :            :         bool lazy;
     793                 :            :     };
     794                 :            : 
     795                 :            :     static const table_list tables[] = {
     796                 :            :         // name         type                    lazy
     797                 :            :         { "postlist", Glass::POSTLIST,        false },
     798                 :            :         { "docdata",  Glass::DOCDATA,         true },
     799                 :            :         { "termlist", Glass::TERMLIST,        false },
     800                 :            :         { "position", Glass::POSITION,        true },
     801                 :            :         { "spelling", Glass::SPELLING,        true },
     802                 :            :         { "synonym",  Glass::SYNONYM,         true }
     803                 :            :     };
     804                 :         68 :     const table_list * tables_end = tables +
     805                 :        136 :         (sizeof(tables) / sizeof(tables[0]));
     806                 :            : 
     807                 :         68 :     const int FLAGS = Xapian::DB_DANGEROUS;
     808                 :            : 
     809                 :         68 :     bool single_file = (flags & Xapian::DBCOMPACT_SINGLE_FILE);
     810                 :         68 :     bool multipass = (flags & Xapian::DBCOMPACT_MULTIPASS);
     811         [ +  + ]:         68 :     if (single_file) {
     812                 :            :         // FIXME: Support this combination - we need to put temporary files
     813                 :            :         // somewhere.
     814                 :         32 :         multipass = false;
     815                 :            :     }
     816                 :            : 
     817         [ +  + ]:        191 :     for (size_t i = 0; i != sources.size(); ++i) {
     818                 :        127 :         auto db = static_cast<const GlassDatabase*>(sources[i]);
     819 [ +  - ][ +  + ]:        127 :         if (db->has_uncommitted_changes()) {
     820                 :            :             const char * m =
     821                 :            :                 "Can't compact from a WritableDatabase with uncommitted "
     822                 :            :                 "changes - either call commit() first, or create a new "
     823                 :          4 :                 "Database object from the filename on disk";
     824 [ +  - ][ +  - ]:          4 :             throw Xapian::InvalidOperationError(m);
                 [ +  - ]
     825                 :            :         }
     826                 :            :     }
     827                 :            : 
     828 [ -  + ][ #  # ]:         64 :     if (block_size < GLASS_MIN_BLOCKSIZE ||
     829         [ #  # ]:          0 :         block_size > GLASS_MAX_BLOCKSIZE ||
     830                 :          0 :         (block_size & (block_size - 1)) != 0) {
     831                 :         64 :         block_size = GLASS_DEFAULT_BLOCKSIZE;
     832                 :            :     }
     833                 :            : 
     834 [ +  + ][ +  - ]:         64 :     FlintLock lock(destdir ? destdir : "");
                 [ +  - ]
     835         [ +  + ]:         64 :     if (!single_file) {
     836         [ +  - ]:         34 :         string explanation;
     837         [ +  - ]:         34 :         FlintLock::reason why = lock.lock(true, false, explanation);
     838         [ -  + ]:         34 :         if (why != FlintLock::SUCCESS) {
     839         [ #  # ]:          0 :             lock.throw_databaselockerror(why, destdir, explanation);
     840                 :         34 :         }
     841                 :            :     }
     842                 :            : 
     843         [ +  - ]:         64 :     unique_ptr<GlassVersion> version_file_out;
     844         [ +  + ]:         64 :     if (single_file) {
     845         [ +  + ]:         30 :         if (destdir) {
     846         [ +  - ]:         24 :             fd = open(destdir, O_RDWR|O_CREAT|O_TRUNC|O_BINARY|O_CLOEXEC, 0666);
     847         [ -  + ]:         24 :             if (fd < 0) {
     848 [ #  # ][ #  # ]:          0 :                 throw Xapian::DatabaseCreateError("open() failed", errno);
     849                 :            :             }
     850                 :            :         }
     851 [ +  - ][ +  - ]:         30 :         version_file_out.reset(new GlassVersion(fd));
     852                 :            :     } else {
     853                 :         34 :         fd = -1;
     854 [ +  - ][ +  - ]:         34 :         version_file_out.reset(new GlassVersion(destdir));
                 [ +  - ]
     855                 :            :     }
     856                 :            : 
     857         [ +  - ]:         64 :     version_file_out->create(block_size);
     858         [ +  + ]:        187 :     for (size_t i = 0; i != sources.size(); ++i) {
     859                 :        123 :         auto db = static_cast<const GlassDatabase*>(sources[i]);
     860         [ +  - ]:        123 :         version_file_out->merge_stats(db->version_file);
     861                 :            :     }
     862                 :            : 
     863 [ +  - ][ +  - ]:        128 :     string fl_serialised;
     864         [ +  + ]:         64 :     if (single_file) {
     865                 :         30 :         GlassFreeList fl;
     866                 :         30 :         fl.set_first_unused_block(1); // FIXME: Assumption?
     867         [ +  - ]:         30 :         fl.pack(fl_serialised);
     868                 :            :     }
     869                 :            : 
     870         [ +  - ]:        128 :     vector<GlassTable *> tabs;
     871         [ +  - ]:         64 :     tabs.reserve(tables_end - tables);
     872                 :         64 :     off_t prev_size = block_size;
     873         [ +  + ]:        448 :     for (const table_list * t = tables; t < tables_end; ++t) {
     874                 :            :         // The postlist table requires an N-way merge, adjusting the
     875                 :            :         // headers of various blocks.  The spelling and synonym tables also
     876                 :            :         // need special handling.  The other tables have keys sorted in
     877                 :            :         // docid order, so we can merge them by simply copying all the keys
     878                 :            :         // from each source table in turn.
     879         [ -  + ]:        384 :         if (compactor)
     880 [ #  # ][ #  # ]:          0 :             compactor->set_status(t->name, string());
                 [ #  # ]
     881                 :            : 
     882         [ +  - ]:        384 :         string dest;
     883         [ +  + ]:        384 :         if (!single_file) {
     884         [ +  - ]:        204 :             dest = destdir;
     885         [ +  - ]:        204 :             dest += '/';
     886         [ +  - ]:        204 :             dest += t->name;
     887         [ +  - ]:        204 :             dest += '.';
     888                 :            :         }
     889                 :            : 
     890                 :        384 :         bool output_will_exist = !t->lazy;
     891                 :            : 
     892                 :            :         // Sometimes stat can fail for benign reasons (e.g. >= 2GB file
     893                 :            :         // on certain systems).
     894                 :        384 :         bool bad_stat = false;
     895                 :            : 
     896                 :            :         // We can't currently report input sizes if there's a single file DB
     897                 :            :         // amongst the inputs.
     898                 :        384 :         bool single_file_in = false;
     899                 :            : 
     900                 :        384 :         off_t in_size = 0;
     901                 :            : 
     902      [ +  -  + ]:        768 :         vector<const GlassTable*> inputs;
     903         [ +  - ]:        384 :         inputs.reserve(sources.size());
     904                 :        384 :         size_t inputs_present = 0;
     905         [ +  + ]:       1122 :         for (auto src : sources) {
     906                 :        738 :             auto db = static_cast<const GlassDatabase*>(src);
     907                 :            :             const GlassTable * table;
     908   [ +  +  +  +  :        738 :             switch (t->type) {
                +  +  - ]
     909                 :            :                 case Glass::POSTLIST:
     910                 :        123 :                     table = &(db->postlist_table);
     911                 :        123 :                     break;
     912                 :            :                 case Glass::DOCDATA:
     913                 :        123 :                     table = &(db->docdata_table);
     914                 :        123 :                     break;
     915                 :            :                 case Glass::TERMLIST:
     916                 :        123 :                     table = &(db->termlist_table);
     917                 :        123 :                     break;
     918                 :            :                 case Glass::POSITION:
     919                 :        123 :                     table = &(db->position_table);
     920                 :        123 :                     break;
     921                 :            :                 case Glass::SPELLING:
     922                 :        123 :                     table = &(db->spelling_table);
     923                 :        123 :                     break;
     924                 :            :                 case Glass::SYNONYM:
     925                 :        123 :                     table = &(db->synonym_table);
     926                 :        123 :                     break;
     927                 :            :                 default:
     928                 :            :                     Assert(false);
     929                 :         64 :                     return;
     930                 :            :             }
     931                 :            : 
     932         [ +  + ]:        738 :             if (db->single_file()) {
     933 [ +  + ][ +  + ]:         90 :                 if (t->lazy && table->empty()) {
                 [ +  + ]
     934                 :            :                     // Essentially doesn't exist.
     935                 :            :                 } else {
     936                 :            :                     // FIXME: Find actual size somehow?
     937                 :            :                     // in_size += table->size() / 1024;
     938                 :         54 :                     single_file_in = true;
     939                 :         54 :                     output_will_exist = true;
     940                 :         90 :                     ++inputs_present;
     941                 :            :                 }
     942                 :            :             } else {
     943         [ +  - ]:        648 :                 off_t db_size = file_size(table->get_path());
     944         [ +  + ]:        648 :                 if (errno == 0) {
     945                 :        435 :                     in_size += db_size / 1024;
     946                 :        435 :                     output_will_exist = true;
     947                 :        435 :                     ++inputs_present;
     948         [ -  + ]:        213 :                 } else if (errno != ENOENT) {
     949                 :            :                     // We get ENOENT for an optional table.
     950                 :          0 :                     bad_stat = true;
     951                 :          0 :                     output_will_exist = true;
     952                 :          0 :                     ++inputs_present;
     953                 :            :                 }
     954                 :            :             }
     955         [ +  - ]:        738 :             inputs.push_back(table);
     956                 :            :         }
     957                 :            : 
     958                 :            :         // If any inputs lack a termlist table, suppress it in the output.
     959 [ +  + ][ -  + ]:        384 :         if (t->type == Glass::TERMLIST && inputs_present != sources.size()) {
                 [ -  + ]
     960         [ #  # ]:          0 :             if (inputs_present != 0) {
     961         [ #  # ]:          0 :                 if (compactor) {
     962         [ #  # ]:          0 :                     string m = str(inputs_present);
     963         [ #  # ]:          0 :                     m += " of ";
     964 [ #  # ][ #  # ]:          0 :                     m += str(sources.size());
     965         [ #  # ]:          0 :                     m += " inputs present, so suppressing output";
     966 [ #  # ][ #  # ]:          0 :                     compactor->set_status(t->name, m);
     967                 :            :                 }
     968                 :          0 :                 continue;
     969                 :            :             }
     970                 :          0 :             output_will_exist = false;
     971                 :            :         }
     972                 :            : 
     973         [ +  + ]:        384 :         if (!output_will_exist) {
     974         [ -  + ]:        141 :             if (compactor)
     975 [ #  # ][ #  # ]:          0 :                 compactor->set_status(t->name, "doesn't exist");
                 [ #  # ]
     976                 :        141 :             continue;
     977                 :            :         }
     978                 :            : 
     979                 :            :         GlassTable * out;
     980         [ +  + ]:        243 :         if (single_file) {
     981                 :        118 :             out = new GlassTable(t->name, fd, version_file_out->get_offset(),
     982 [ +  - ][ +  - ]:        118 :                                  false, false);
     983                 :            :         } else {
     984 [ +  - ][ +  - ]:        125 :             out = new GlassTable(t->name, dest, false, t->lazy);
     985                 :            :         }
     986         [ +  - ]:        243 :         tabs.push_back(out);
     987                 :        243 :         RootInfo * root_info = version_file_out->root_to_set(t->type);
     988         [ +  + ]:        243 :         if (single_file) {
     989         [ +  - ]:        118 :             root_info->set_free_list(fl_serialised);
     990         [ +  - ]:        118 :             out->open(FLAGS, version_file_out->get_root(t->type), version_file_out->get_revision());
     991                 :            :         } else {
     992         [ +  - ]:        125 :             out->create_and_open(FLAGS, *root_info);
     993                 :            :         }
     994                 :            : 
     995         [ +  - ]:        243 :         out->set_full_compaction(compaction != compactor->STANDARD);
     996         [ -  + ]:        243 :         if (compaction == compactor->FULLER) out->set_max_item_size(1);
     997                 :            : 
     998   [ +  +  +  +  :        243 :         switch (t->type) {
                      + ]
     999                 :            :             case Glass::POSTLIST: {
    1000 [ +  + ][ +  - ]:         64 :                 if (multipass && inputs.size() > 3) {
                 [ +  + ]
    1001                 :            :                     multimerge_postlists(compactor, out, destdir,
    1002 [ +  - ][ +  - ]:          2 :                                          inputs, offset);
                 [ +  - ]
    1003                 :            :                 } else {
    1004                 :            :                     merge_postlists(compactor, out, offset.begin(),
    1005         [ +  - ]:         62 :                                     inputs.begin(), inputs.end());
    1006                 :            :                 }
    1007                 :         64 :                 break;
    1008                 :            :             }
    1009                 :            :             case Glass::SPELLING:
    1010         [ +  - ]:          8 :                 merge_spellings(out, inputs.begin(), inputs.end());
    1011                 :          8 :                 break;
    1012                 :            :             case Glass::SYNONYM:
    1013         [ +  - ]:          8 :                 merge_synonyms(out, inputs.begin(), inputs.end());
    1014                 :          8 :                 break;
    1015                 :            :             case Glass::POSITION:
    1016         [ +  - ]:         47 :                 merge_positions(out, inputs, offset);
    1017                 :         47 :                 break;
    1018                 :            :             default:
    1019                 :            :                 // DocData, Termlist
    1020         [ +  - ]:        116 :                 merge_docid_keyed(out, inputs, offset);
    1021                 :        116 :                 break;
    1022                 :            :         }
    1023                 :            : 
    1024                 :            :         // Commit as revision 1.
    1025         [ +  - ]:        243 :         out->flush_db();
    1026         [ +  - ]:        243 :         out->commit(1, root_info);
    1027         [ +  - ]:        243 :         out->sync();
    1028 [ +  + ][ +  - ]:        243 :         if (single_file) fl_serialised = root_info->get_free_list();
    1029                 :            : 
    1030                 :        243 :         off_t out_size = 0;
    1031 [ +  - ][ +  + ]:        243 :         if (!bad_stat && !single_file_in) {
    1032                 :            :             off_t db_size;
    1033         [ +  + ]:        211 :             if (single_file) {
    1034                 :        106 :                 db_size = file_size(fd);
    1035                 :            :             } else {
    1036         [ +  - ]:        105 :                 db_size = file_size(dest + GLASS_TABLE_EXTENSION);
    1037                 :            :             }
    1038         [ +  + ]:        211 :             if (errno == 0) {
    1039         [ +  + ]:        196 :                 if (single_file) {
    1040         [ +  - ]:        106 :                     off_t old_prev_size = max(prev_size, off_t(block_size));
    1041                 :        106 :                     prev_size = db_size;
    1042                 :        106 :                     db_size -= old_prev_size;
    1043                 :            :                 }
    1044                 :        196 :                 out_size = db_size / 1024;
    1045                 :            :             } else {
    1046                 :        211 :                 bad_stat = (errno != ENOENT);
    1047                 :            :             }
    1048                 :            :         }
    1049         [ -  + ]:        243 :         if (bad_stat) {
    1050         [ #  # ]:          0 :             if (compactor)
    1051 [ #  # ][ #  # ]:          0 :                 compactor->set_status(t->name, "Done (couldn't stat all the DB files)");
                 [ #  # ]
    1052         [ +  + ]:        243 :         } else if (single_file_in) {
    1053         [ -  + ]:         32 :             if (compactor)
    1054 [ #  # ][ #  # ]:          0 :                 compactor->set_status(t->name, "Done (table sizes unknown for single file DB input)");
                 [ #  # ]
    1055                 :            :         } else {
    1056         [ +  - ]:        211 :             string status;
    1057         [ +  + ]:        211 :             if (out_size == in_size) {
    1058         [ +  - ]:          8 :                 status = "Size unchanged (";
    1059                 :            :             } else {
    1060                 :            :                 off_t delta;
    1061         [ +  + ]:        203 :                 if (out_size < in_size) {
    1062                 :         79 :                     delta = in_size - out_size;
    1063         [ +  - ]:         79 :                     status = "Reduced by ";
    1064                 :            :                 } else {
    1065                 :        124 :                     delta = out_size - in_size;
    1066         [ +  - ]:        124 :                     status = "INCREASED by ";
    1067                 :            :                 }
    1068         [ +  + ]:        203 :                 if (in_size) {
    1069 [ +  - ][ +  - ]:        193 :                     status += str(100 * delta / in_size);
    1070         [ +  - ]:        193 :                     status += "% ";
    1071                 :            :                 }
    1072 [ +  - ][ +  - ]:        203 :                 status += str(delta);
    1073         [ +  - ]:        203 :                 status += "K (";
    1074 [ +  - ][ +  - ]:        203 :                 status += str(in_size);
    1075         [ +  - ]:        203 :                 status += "K -> ";
    1076                 :            :             }
    1077 [ +  - ][ +  - ]:        211 :             status += str(out_size);
    1078         [ +  - ]:        211 :             status += "K)";
    1079         [ -  + ]:        211 :             if (compactor)
    1080 [ #  # ][ #  # ]:        384 :                 compactor->set_status(t->name, status);
              [ +  -  + ]
    1081                 :            :         }
    1082                 :        384 :     }
    1083                 :            : 
    1084                 :            :     // If compacting to a single file output and all the tables are empty, pad
    1085                 :            :     // the output so that it isn't mistaken for a stub database when we try to
    1086                 :            :     // open it.  For this it needs to be a multiple of 2KB in size.
    1087 [ +  + ][ -  + ]:         64 :     if (single_file && prev_size < off_t(block_size)) {
    1088                 :            : #ifdef HAVE_FTRUNCATE
    1089         [ #  # ]:          0 :         if (ftruncate(fd, block_size) < 0) {
    1090 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("Failed to set size of output database", errno);
    1091                 :            :         }
    1092                 :            : #else
    1093                 :            :         const off_t off = block_size - 1;
    1094                 :            :         if (lseek(fd, off, SEEK_SET) != off || write(fd, "", 1) != 1) {
    1095                 :            :             throw Xapian::DatabaseError("Failed to set size of output database", errno);
    1096                 :            :         }
    1097                 :            : #endif
    1098                 :            :     }
    1099                 :            : 
    1100         [ +  + ]:         64 :     if (single_file) {
    1101         [ -  + ]:         30 :         if (lseek(fd, version_file_out->get_offset(), SEEK_SET) < 0) {
    1102 [ #  # ][ #  # ]:          0 :             throw Xapian::DatabaseError("lseek() failed", errno);
    1103                 :            :         }
    1104                 :            :     }
    1105                 :         64 :     version_file_out->set_last_docid(last_docid);
    1106         [ +  - ]:         64 :     string tmpfile = version_file_out->write(1, FLAGS);
    1107         [ +  + ]:        307 :     for (unsigned j = 0; j != tabs.size(); ++j) {
    1108         [ +  - ]:        243 :         tabs[j]->sync();
    1109                 :            :     }
    1110                 :            :     // Commit with revision 1.
    1111         [ +  - ]:         64 :     version_file_out->sync(tmpfile, 1, FLAGS);
    1112         [ +  + ]:        307 :     for (unsigned j = 0; j != tabs.size(); ++j) {
    1113         [ +  - ]:        243 :         delete tabs[j];
    1114                 :            :     }
    1115                 :            : 
    1116 [ +  + ][ +  - ]:        128 :     if (!single_file) lock.release();
                 [ +  - ]
    1117                 :            : }

Generated by: LCOV version 1.11