Branch data Line data Source code
1 : : /** @file mset.cc
2 : : * @brief Xapian::MSet class
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 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this program; if not, write to the Free Software
18 : : * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 : : */
20 : :
21 : : #include <config.h>
22 : :
23 : : #include "msetinternal.h"
24 : : #include "xapian/mset.h"
25 : :
26 : : #include "net/serialise.h"
27 : : #include "matcher/msetcmp.h"
28 : : #include "pack.h"
29 : : #include "roundestimate.h"
30 : : #include "serialise-double.h"
31 : : #include "str.h"
32 : : #include "unicode/description_append.h"
33 : :
34 : : #include <algorithm>
35 : : #include <cfloat>
36 : : #include <string>
37 : :
38 : : using namespace std;
39 : :
40 : : namespace Xapian {
41 : :
42 : : MSet::MSet(const MSet&) = default;
43 : :
44 : : MSet&
45 : : MSet::operator=(const MSet&) = default;
46 : :
47 : : MSet::MSet(MSet&&) = default;
48 : :
49 : : MSet&
50 : : MSet::operator=(MSet&&) = default;
51 : :
52 [ + - ]: 172748 : MSet::MSet() : internal(new MSet::Internal) {}
53 : :
54 : 300100 : MSet::MSet(Internal* internal_) : internal(internal_) {}
55 : :
56 : 67257928 : MSet::~MSet() {}
57 : :
58 : : void
59 : 28 : MSet::fetch_(Xapian::doccount first, Xapian::doccount last) const
60 : : {
61 : 28 : internal->fetch(first, last);
62 : 28 : }
63 : :
64 : : void
65 : 21 : MSet::set_item_weight(Xapian::doccount i, double weight)
66 : : {
67 : 21 : internal->set_item_weight(i, weight);
68 : 21 : }
69 : :
70 : : void
71 : 7 : MSet::sort_by_relevance()
72 : : {
73 : 14 : std::sort(internal->items.begin(), internal->items.end(),
74 : 21 : get_msetcmp_function(Enquire::Internal::REL, true, false));
75 : 7 : }
76 : :
77 : : int
78 : 48531 : MSet::convert_to_percent(double weight) const
79 : : {
80 : 48531 : return internal->convert_to_percent(weight);
81 : : }
82 : :
83 : : Xapian::doccount
84 : 127 : MSet::get_termfreq(const std::string& term) const
85 : : {
86 : : // Check the cached data for query terms first.
87 : : Xapian::doccount termfreq;
88 [ + + ][ + - ]: 127 : if (usual(internal->stats && internal->stats->get_stats(term, termfreq))) {
[ + + ][ + + ]
89 : 112 : return termfreq;
90 : : }
91 : :
92 [ + + ]: 15 : if (rare(internal->enquire.get() == NULL)) {
93 : : // Consistent with get_termfreq() on an empty database which always
94 : : // returns 0.
95 : 1 : return 0;
96 : : }
97 : :
98 : : // Fall back to asking the database via enquire.
99 [ + - ]: 127 : return internal->enquire->get_termfreq(term);
100 : : }
101 : :
102 : : double
103 : 99 : MSet::get_termweight(const std::string& term) const
104 : : {
105 : : // A term not in the query has no termweight, so 0.0 makes sense as the
106 : : // answer in such cases.
107 : 99 : double weight = 0.0;
108 [ + + ]: 99 : if (usual(internal->stats)) {
109 [ + - ]: 98 : (void)internal->stats->get_termweight(term, weight);
110 : : }
111 : 99 : return weight;
112 : : }
113 : :
114 : : Xapian::doccount
115 : 54 : MSet::get_firstitem() const
116 : : {
117 : 54 : return internal->first;
118 : : }
119 : :
120 : : Xapian::doccount
121 : 1163 : MSet::get_matches_lower_bound() const
122 : : {
123 : 1163 : return internal->matches_lower_bound;
124 : : }
125 : :
126 : : Xapian::doccount
127 : 889 : MSet::get_matches_estimated() const
128 : : {
129 : : // Doing this here avoids calculating if the estimate is never looked at,
130 : : // though does mean we recalculate if this method is called more than once.
131 : 889 : return round_estimate(internal->matches_lower_bound,
132 : 889 : internal->matches_upper_bound,
133 : 1778 : internal->matches_estimated);
134 : : }
135 : :
136 : : Xapian::doccount
137 : 1016 : MSet::get_matches_upper_bound() const
138 : : {
139 : 1016 : return internal->matches_upper_bound;
140 : : }
141 : :
142 : : Xapian::doccount
143 : 648 : MSet::get_uncollapsed_matches_lower_bound() const
144 : : {
145 : 648 : return internal->uncollapsed_lower_bound;
146 : : }
147 : :
148 : : Xapian::doccount
149 : 481 : MSet::get_uncollapsed_matches_estimated() const
150 : : {
151 : : // Doing this here avoids calculating if the estimate is never looked at,
152 : : // though does mean we recalculate if this method is called more than once.
153 : 481 : return round_estimate(internal->uncollapsed_lower_bound,
154 : 481 : internal->uncollapsed_upper_bound,
155 : 962 : internal->uncollapsed_estimated);
156 : : }
157 : :
158 : : Xapian::doccount
159 : 479 : MSet::get_uncollapsed_matches_upper_bound() const
160 : : {
161 : 479 : return internal->uncollapsed_upper_bound;
162 : : }
163 : :
164 : : double
165 : 61 : MSet::get_max_attained() const
166 : : {
167 : 61 : return internal->max_attained;
168 : : }
169 : :
170 : : double
171 : 224 : MSet::get_max_possible() const
172 : : {
173 : 224 : return internal->max_possible;
174 : : }
175 : :
176 : : Xapian::doccount
177 : 41793522 : MSet::size() const
178 : : {
179 : : Assert(internal.get());
180 : 41793522 : return internal->items.size();
181 : : }
182 : :
183 : : std::string
184 : 554 : MSet::snippet(const std::string& text,
185 : : size_t length,
186 : : const Xapian::Stem& stemmer,
187 : : unsigned flags,
188 : : const std::string& hi_start,
189 : : const std::string& hi_end,
190 : : const std::string& omit) const
191 : : {
192 : : // The actual implementation is in queryparser/termgenerator_internal.cc.
193 : : return internal->snippet(text, length, stemmer, flags,
194 : 554 : hi_start, hi_end, omit);
195 : : }
196 : :
197 : : std::string
198 : 124 : MSet::get_description() const
199 : : {
200 : 124 : return internal->get_description();
201 : : }
202 : :
203 : : Document
204 : 200240 : MSet::Internal::get_document(Xapian::doccount index) const
205 : : {
206 [ - + ]: 200240 : if (index >= items.size()) {
207 [ # # ]: 0 : string msg = "Requested index ";
208 [ # # ][ # # ]: 0 : msg += str(index);
209 [ # # ]: 0 : msg += " in MSet of size ";
210 [ # # ][ # # ]: 0 : msg += str(items.size());
211 [ # # ][ # # ]: 0 : throw Xapian::RangeError(msg);
212 : : }
213 : : Assert(enquire.get());
214 : 200240 : return enquire->get_document(items[index].get_docid());
215 : : }
216 : :
217 : : void
218 : 28 : MSet::Internal::fetch(Xapian::doccount first_, Xapian::doccount last) const
219 : : {
220 [ + - ][ - + ]: 28 : if (items.empty() || enquire.get() == NULL) {
[ - + ]
221 : 0 : return;
222 : : }
223 [ + + ]: 28 : if (last > items.size() - 1) {
224 : 14 : last = items.size() - 1;
225 : : }
226 [ + + ]: 28 : if (first_ <= last) {
227 : 7 : Xapian::doccount n = last - first_;
228 [ + + ]: 49 : for (Xapian::doccount i = 0; i <= n; ++i) {
229 : 42 : enquire->request_document(items[i].get_docid());
230 : : }
231 : : }
232 : : }
233 : :
234 : : void
235 : 21 : MSet::Internal::set_item_weight(Xapian::doccount i, double weight)
236 : : {
237 : : // max_attained is updated assuming that set_item_weight is called on every
238 : : // MSet item from 0 up. While assigning new weights max_attained is updated
239 : : // as the maximum of the new weights set till Xapian::doccount i.
240 [ + + ]: 21 : if (i == 0)
241 : 14 : max_attained = weight;
242 : : else
243 : 7 : max_attained = max(max_attained, weight);
244 : : // Ideally the max_possible should be the maximum possible weight that
245 : : // can be assigned by the reranking algorithm, but since it is not always
246 : : // possible to calculate the max possible weight for a reranking algorithm
247 : : // we use this approach.
248 : 21 : max_possible = max(max_possible, max_attained);
249 : 21 : items[i].set_weight(weight);
250 : 21 : }
251 : :
252 : : int
253 : 48531 : MSet::Internal::convert_to_percent(double weight) const
254 : : {
255 : : int percent;
256 [ - + ]: 48531 : if (percent_scale_factor == 0.0) {
257 : : // For an unweighted search, give all matches 100%.
258 : 0 : percent = 100;
259 [ - + ]: 48531 : } else if (weight <= 0.0) {
260 : : // Some weighting schemes can return zero relevance while matching,
261 : : // so give such matches 0%.
262 : 0 : percent = 0;
263 : : } else {
264 : : // Adding on 100 * DBL_EPSILON was a hack to work around excess
265 : : // precision (e.g. on x86 when not using SSE), but this code seems like
266 : : // it's generally asking for problems with floating point rounding
267 : : // issues - maybe we ought to carry through the matching and total
268 : : // number of subqueries and calculate using those instead.
269 : : //
270 : : // There are corresponding hacks in matcher/matcher.cc.
271 : 48531 : percent = int(weight * percent_scale_factor + 100.0 * DBL_EPSILON);
272 [ - + ]: 48531 : if (percent <= 0) {
273 : : // Make any non-zero weight give a non-zero percentage.
274 : 0 : percent = 1;
275 [ - + ]: 48531 : } else if (percent > 100) {
276 : : // Make sure we don't ever exceed 100%.
277 : 0 : percent = 100;
278 : : }
279 : : // FIXME: Ideally we should also make sure any non-exact match gives
280 : : // < 100%.
281 : : }
282 : 48531 : return percent;
283 : : }
284 : :
285 : : void
286 : 48 : MSet::Internal::unshard_docids(Xapian::doccount shard,
287 : : Xapian::doccount n_shards)
288 : : {
289 [ + + ]: 150 : for (auto& result : items) {
290 : 102 : result.unshard_docid(shard, n_shards);
291 : : }
292 : 48 : }
293 : :
294 : : void
295 : 62 : MSet::Internal::merge_stats(const Internal* o)
296 : : {
297 [ + - ]: 62 : if (snippet_bg_relevance.empty()) {
298 : 62 : snippet_bg_relevance = o->snippet_bg_relevance;
299 : : } else {
300 : : Assert(snippet_bg_relevance == o->snippet_bg_relevance);
301 : : }
302 : 62 : matches_lower_bound += o->matches_lower_bound;
303 : 62 : matches_estimated += o->matches_estimated;
304 : 62 : matches_upper_bound += o->matches_upper_bound;
305 : 62 : uncollapsed_lower_bound += o->uncollapsed_lower_bound;
306 : 62 : uncollapsed_estimated += o->uncollapsed_estimated;
307 : 62 : uncollapsed_upper_bound += o->uncollapsed_upper_bound;
308 : 62 : max_possible = max(max_possible, o->max_possible);
309 [ + + ]: 62 : if (o->max_attained > max_attained) {
310 : 30 : max_attained = o->max_attained;
311 : 30 : percent_scale_factor = o->percent_scale_factor;
312 : : }
313 : 62 : }
314 : :
315 : : string
316 : 10638 : MSet::Internal::serialise() const
317 : : {
318 : 10638 : string result;
319 : :
320 [ + - ][ + - ]: 10638 : result += serialise_double(max_possible);
321 [ + - ][ + - ]: 10638 : result += serialise_double(max_attained);
322 : :
323 [ + - ][ + - ]: 10638 : result += serialise_double(percent_scale_factor);
324 : :
325 [ + - ]: 10638 : pack_uint(result, first);
326 : : // Send back the raw matches_* values. MSet::get_matches_estimated()
327 : : // rounds the estimate lazily, but when we merge MSet objects we really
328 : : // want to merge based on the raw estimates.
329 : : //
330 : : // It is also cleaner that a round-trip through serialisation gives you an
331 : : // object which is as close to the original as possible.
332 [ + - ]: 10638 : pack_uint(result, matches_lower_bound);
333 [ + - ]: 10638 : pack_uint(result, matches_estimated);
334 [ + - ]: 10638 : pack_uint(result, matches_upper_bound);
335 [ + - ]: 10638 : pack_uint(result, uncollapsed_lower_bound);
336 [ + - ]: 10638 : pack_uint(result, uncollapsed_estimated);
337 [ + - ]: 10638 : pack_uint(result, uncollapsed_upper_bound);
338 : :
339 [ + - ]: 10638 : pack_uint(result, items.size());
340 [ + + ]: 120900 : for (auto&& item : items) {
341 [ + - ][ + - ]: 110262 : result += serialise_double(item.get_weight());
342 [ + - ]: 110262 : pack_uint(result, item.get_docid());
343 [ + - ]: 110262 : pack_string(result, item.get_sort_key());
344 [ + - ]: 110262 : pack_string(result, item.get_collapse_key());
345 [ + - ]: 110262 : pack_uint(result, item.get_collapse_count());
346 : : }
347 : :
348 [ + - ]: 10638 : if (stats)
349 [ + - ][ + - ]: 10638 : result += serialise_stats(*stats);
[ + - ]
350 : :
351 : 10638 : return result;
352 : : }
353 : :
354 : : void
355 : 10638 : MSet::Internal::unserialise(const char * p, const char * p_end)
356 : : {
357 : 10638 : items.clear();
358 : :
359 [ + - ]: 10638 : max_possible = unserialise_double(&p, p_end);
360 [ + - ]: 10638 : max_attained = unserialise_double(&p, p_end);
361 : :
362 [ + - ]: 10638 : percent_scale_factor = unserialise_double(&p, p_end);
363 : :
364 : : size_t msize;
365 [ + - ][ - + ]: 31914 : if (!unpack_uint(&p, p_end, &first) ||
366 [ + - ]: 21276 : !unpack_uint(&p, p_end, &matches_lower_bound) ||
367 [ + - ]: 21276 : !unpack_uint(&p, p_end, &matches_estimated) ||
368 [ + - ]: 21276 : !unpack_uint(&p, p_end, &matches_upper_bound) ||
369 [ + - ]: 21276 : !unpack_uint(&p, p_end, &uncollapsed_lower_bound) ||
370 [ + - ]: 21276 : !unpack_uint(&p, p_end, &uncollapsed_estimated) ||
371 [ + - ][ - + ]: 31914 : !unpack_uint(&p, p_end, &uncollapsed_upper_bound) ||
372 : 10638 : !unpack_uint(&p, p_end, &msize)) {
373 : 0 : unpack_throw_serialisation_error(p);
374 : : }
375 [ + + ]: 120900 : while (msize-- > 0) {
376 [ + - ]: 110262 : double wt = unserialise_double(&p, p_end);
377 : : Xapian::docid did;
378 [ + - ][ + - ]: 220524 : string sort_key, key;
379 : : Xapian::doccount collapse_cnt;
380 [ + - ][ - + ]: 330786 : if (!unpack_uint(&p, p_end, &did) ||
381 [ + - ][ + - ]: 220524 : !unpack_string(&p, p_end, sort_key) ||
382 [ + - ]: 330786 : !unpack_string(&p, p_end, key) ||
[ + - - + ]
383 : 110262 : !unpack_uint(&p, p_end, &collapse_cnt)) {
384 : 0 : unpack_throw_serialisation_error(p);
385 : : }
386 : 110262 : items.emplace_back(wt, did, std::move(key), collapse_cnt,
387 [ + - ]: 220524 : std::move(sort_key));
388 : 110262 : }
389 : :
390 [ + - ]: 10638 : if (p != p_end) {
391 [ + - ][ + - ]: 10638 : stats.reset(new Xapian::Weight::Internal());
392 [ + - ][ + - ]: 10638 : unserialise_stats(string(p, p_end - p), *stats);
[ + - ]
393 : : }
394 : 10638 : }
395 : :
396 : : string
397 : 124 : MSet::Internal::get_description() const
398 : : {
399 [ + - ]: 124 : string desc = "MSet(matches_lower_bound=";
400 [ + - ][ + - ]: 124 : desc += str(matches_lower_bound);
401 [ + - ]: 124 : desc += ", matches_estimated=";
402 [ + - ][ + - ]: 124 : desc += str(matches_estimated);
403 [ + - ]: 124 : desc += ", matches_upper_bound=";
404 [ + - ][ + - ]: 124 : desc += str(matches_upper_bound);
405 [ - + ]: 124 : if (uncollapsed_lower_bound != matches_lower_bound) {
406 [ # # ]: 0 : desc += ", uncollapsed_lower_bound=";
407 [ # # ][ # # ]: 0 : desc += str(uncollapsed_lower_bound);
408 : : }
409 [ - + ]: 124 : if (uncollapsed_estimated != matches_estimated) {
410 [ # # ]: 0 : desc += ", uncollapsed_estimated=";
411 [ # # ][ # # ]: 0 : desc += str(uncollapsed_estimated);
412 : : }
413 [ - + ]: 124 : if (uncollapsed_upper_bound != matches_upper_bound) {
414 [ # # ]: 0 : desc += ", uncollapsed_upper_bound=";
415 [ # # ][ # # ]: 0 : desc += str(uncollapsed_upper_bound);
416 : : }
417 [ - + ]: 124 : if (first != 0) {
418 [ # # ]: 0 : desc += ", first=";
419 [ # # ][ # # ]: 0 : desc += str(first);
420 : : }
421 [ + + ]: 124 : if (max_possible > 0) {
422 [ + - ]: 112 : desc += ", max_possible=";
423 [ + - ][ + - ]: 112 : desc += str(max_possible);
424 : : }
425 [ + + ]: 124 : if (max_attained > 0) {
426 [ + - ]: 112 : desc += ", max_attained=";
427 [ + - ][ + - ]: 112 : desc += str(max_attained);
428 : : }
429 [ + - ]: 124 : desc += ", [";
430 : 124 : bool comma = false;
431 [ + + ]: 3344 : for (auto&& item : items) {
432 [ + + ]: 3220 : if (comma) {
433 [ + - ]: 3101 : desc += ", ";
434 : : } else {
435 : 119 : comma = true;
436 : : }
437 [ + - ][ + - ]: 3220 : desc += item.get_description();
438 : : }
439 [ + - ]: 124 : desc += "])";
440 : 124 : return desc;
441 : : }
442 : :
443 : : }
|
