xapian-core  2.0.0
api_wrdb.cc
Go to the documentation of this file.
1 
4 /* Copyright 1999,2000,2001 BrightStation PLC
5  * Copyright 2001 Hein Ragas
6  * Copyright 2002 Ananova Ltd
7  * Copyright 2002-2023 Olly Betts
8  * Copyright 2006 Richard Boulton
9  * Copyright 2007 Lemur Consulting Ltd
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of the
14  * License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, see
23  * <https://www.gnu.org/licenses/>.
24  */
25 
26 #include <config.h>
27 
28 #include "api_wrdb.h"
29 
30 #include <xapian.h>
31 
32 #include "filetests.h"
33 #include "negate_unsigned.h"
34 #include "omassert.h"
35 #include "str.h"
36 #include "stringutils.h"
37 #include "testsuite.h"
38 #include "testutils.h"
39 #include "unixcmds.h"
40 
41 #include "apitest.h"
42 
43 #include "safeunistd.h"
44 #include <cmath>
45 #include <cstdlib>
46 #include <limits>
47 #include <map>
48 #include <string>
49 
50 using namespace std;
51 
52 // #######################################################################
53 // # Tests start here
54 
55 // test that indexing a term more than once at the same position increases
56 // the wdf
57 DEFINE_TESTCASE(adddoc1, writable) {
58  Xapian::WritableDatabase db = get_writable_database();
59 
60  Xapian::Document doc1, doc2, doc3;
61 
62  // doc1 should come top, but if term "foo" gets wdf of 1, doc2 will beat it
63  // doc3 should beat both
64  // Note: all docs have same length
65  doc1.set_data(string("tom"));
66  doc1.add_posting("foo", 1);
67  doc1.add_posting("foo", 1);
68  doc1.add_posting("foo", 1);
69  doc1.add_posting("bar", 3);
70  doc1.add_posting("bar", 4);
71  db.add_document(doc1);
72 
73  doc2.set_data(string("dick"));
74  doc2.add_posting("foo", 1);
75  doc2.add_posting("foo", 2);
76  doc2.add_posting("bar", 3);
77  doc2.add_posting("bar", 3);
78  doc2.add_posting("bar", 3);
79  db.add_document(doc2);
80 
81  doc3.set_data(string("harry"));
82  doc3.add_posting("foo", 1);
83  doc3.add_posting("foo", 1);
84  doc3.add_posting("foo", 2);
85  doc3.add_posting("foo", 2);
86  doc3.add_posting("bar", 3);
87  db.add_document(doc3);
88 
89  Xapian::Query query("foo");
90 
91  Xapian::Enquire enq(db);
92  enq.set_query(query);
93 
94  Xapian::MSet mset = enq.get_mset(0, 10);
95 
96  mset_expect_order(mset, 3, 1, 2);
97 }
98 
99 // test that removing a posting and removing a term works
100 DEFINE_TESTCASE(adddoc2, writable) {
101  Xapian::WritableDatabase db = get_writable_database();
102  // get_termfreq() on a TermIterator from a Document returns the termfreq
103  // for just the shard the doc is in.
104  bool sharded = (db.size() > 1);
105 
106  Xapian::Document doc1;
107 
108  doc1.add_posting("foo", 1);
109  doc1.add_posting("foo", 1);
110  doc1.add_posting("foo", 2);
111  doc1.add_posting("foo", 2);
112  doc1.add_posting("bar", 3);
113  doc1.add_posting("gone", 1);
114  // Quartz had a bug handling a term >= 128 characters longer than the
115  // preceding term in the sort order - this is "foo" + 130 "X"s
116  doc1.add_posting("fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 1);
117  Xapian::docid did;
118 
119  Xapian::Document doc2 = db.get_document(did = db.add_document(doc1));
120  TEST_EQUAL(did, 1);
121 
122  Xapian::TermIterator iter1 = doc1.termlist_begin();
123  Xapian::TermIterator iter2 = doc2.termlist_begin();
124  TEST(iter1 != doc1.termlist_end());
125  TEST(iter2 != doc2.termlist_end());
126  TEST_EQUAL(*iter1, "bar");
127  TEST_EQUAL(*iter2, *iter1);
128  TEST_EQUAL(iter1.get_wdf(), 1);
129  TEST_EQUAL(iter2.get_wdf(), 1);
130  if (!sharded) {
131  // TEST_EQUAL(iter1.get_termfreq(), 0);
132  TEST_EQUAL(iter2.get_termfreq(), 1);
133  }
134 
135  iter1++;
136  iter2++;
137  TEST(iter1 != doc1.termlist_end());
138  TEST(iter2 != doc2.termlist_end());
139  TEST_EQUAL(*iter1, "foo");
140  TEST_EQUAL(*iter2, *iter1);
141  TEST_EQUAL(iter1.get_wdf(), 4);
142  TEST_EQUAL(iter2.get_wdf(), 4);
143  if (!sharded) {
144  // TEST_EQUAL(iter1.get_termfreq(), 0);
145  TEST_EQUAL(iter2.get_termfreq(), 1);
146  }
147 
148  iter1++;
149  iter2++;
150  TEST(iter1 != doc1.termlist_end());
151  TEST(iter2 != doc2.termlist_end());
152  TEST_EQUAL(*iter1, "fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
153  TEST_EQUAL(*iter2, *iter1);
154  TEST_EQUAL(iter1.get_wdf(), 1);
155  TEST_EQUAL(iter2.get_wdf(), 1);
156  if (!sharded) {
157  // assertion fails in debug build! TEST_EQUAL(iter1.get_termfreq(), 0);
158  TEST_EQUAL(iter2.get_termfreq(), 1);
159  }
160 
161  iter1++;
162  iter2++;
163  TEST(iter1 != doc1.termlist_end());
164  TEST(iter2 != doc2.termlist_end());
165  TEST_EQUAL(*iter1, "gone");
166  TEST_EQUAL(*iter2, *iter1);
167  TEST_EQUAL(iter1.get_wdf(), 1);
168  TEST_EQUAL(iter2.get_wdf(), 1);
169  if (!sharded) {
170  // assertion fails in debug build! TEST_EQUAL(iter1.get_termfreq(), 0);
171  TEST_EQUAL(iter2.get_termfreq(), 1);
172  }
173 
174  iter1++;
175  iter2++;
176  TEST(iter1 == doc1.termlist_end());
177  TEST(iter2 == doc2.termlist_end());
178 
179  doc2.remove_posting("foo", 1, 5);
180  doc2.add_term("bat", 0);
181  doc2.add_term("bar", 8);
182  doc2.add_term("bag", 0);
183  doc2.remove_term("gone");
184  doc2.remove_term("fooXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
185 
186  // Should have (doc,wdf) pairs: (bag,0)(bar,9)(bat,0)(foo,0)
187  // positionlists (bag,none)(bar,3)(bat,none)(foo,2)
188 
189  iter2 = doc2.termlist_begin();
190  TEST(iter2 != doc2.termlist_end());
191  TEST_EQUAL(*iter2, "bag");
192  // TEST_EQUAL(iter2.get_termfreq(), 0);
193  iter2++;
194  TEST(iter2 != doc2.termlist_end());
195  TEST_EQUAL(*iter2, "bar");
196  // TEST_EQUAL(iter2.get_termfreq(), 0);
197  iter2++;
198  TEST(iter2 != doc2.termlist_end());
199  TEST_EQUAL(*iter2, "bat");
200  // TEST_EQUAL(iter2.get_termfreq(), 0);
201  iter2++;
202  TEST(iter2 != doc2.termlist_end());
203  TEST_EQUAL(*iter2, "foo");
204  // TEST_EQUAL(iter2.get_termfreq(), 0);
205  iter2++;
206  TEST(iter2 == doc2.termlist_end());
207 
208  doc1 = db.get_document(did = db.add_document(doc2));
209  TEST_EQUAL(did, 2);
210 
211  iter1 = doc1.termlist_begin();
212  iter2 = doc2.termlist_begin();
213  TEST(iter1 != doc1.termlist_end());
214  TEST(iter2 != doc2.termlist_end());
215  TEST_EQUAL(*iter1, "bag");
216  TEST_EQUAL(*iter2, *iter1);
217  TEST_EQUAL(iter1.get_wdf(), 0);
218  TEST_EQUAL(iter2.get_wdf(), 0);
219  if (!sharded) {
220  TEST_EQUAL(iter1.get_termfreq(), 1);
221  // TEST_EQUAL(iter2.get_termfreq(), 0);
222  }
223  TEST(iter1.positionlist_begin() == iter1.positionlist_end());
224  TEST(iter2.positionlist_begin() == iter2.positionlist_end());
225 
226  iter1++;
227  iter2++;
228  TEST(iter1 != doc1.termlist_end());
229  TEST(iter2 != doc2.termlist_end());
230  TEST_EQUAL(*iter1, "bar");
231  TEST_EQUAL(*iter2, *iter1);
232  TEST_EQUAL(iter1.get_wdf(), 9);
233  TEST_EQUAL(iter2.get_wdf(), 9);
234  if (!sharded) {
235  TEST_EQUAL(iter1.get_termfreq(), 2);
236  // TEST_EQUAL(iter2.get_termfreq(), 0);
237  }
238 
239  Xapian::PositionIterator pi1;
240  pi1 = iter1.positionlist_begin();
241  Xapian::PositionIterator pi2 = iter2.positionlist_begin();
242  TEST_EQUAL(*pi1, 3); pi1++;
243  TEST_EQUAL(*pi2, 3); pi2++;
244  TEST(pi1 == iter1.positionlist_end());
245  TEST(pi2 == iter2.positionlist_end());
246 
247  iter1++;
248  iter2++;
249  TEST(iter1 != doc1.termlist_end());
250  TEST(iter2 != doc2.termlist_end());
251  TEST_EQUAL(*iter1, "bat");
252  TEST_EQUAL(*iter2, *iter1);
253  TEST_EQUAL(iter1.get_wdf(), 0);
254  TEST_EQUAL(iter2.get_wdf(), 0);
255  if (!sharded) {
256  TEST_EQUAL(iter1.get_termfreq(), 1);
257  // TEST_EQUAL(iter2.get_termfreq(), 0);
258  }
259  TEST(iter1.positionlist_begin() == iter1.positionlist_end());
260  TEST(iter2.positionlist_begin() == iter2.positionlist_end());
261 
262  iter1++;
263  iter2++;
264  TEST(iter1 != doc1.termlist_end());
265  TEST(iter2 != doc2.termlist_end());
266  TEST_EQUAL(*iter1, "foo");
267  TEST_EQUAL(*iter2, *iter1);
268  TEST_EQUAL(iter1.get_wdf(), 0);
269  TEST_EQUAL(iter2.get_wdf(), 0);
270  if (!sharded) {
271  TEST_EQUAL(iter1.get_termfreq(), 2);
272  // TEST_EQUAL(iter2.get_termfreq(), 0);
273  }
274 
275  Xapian::PositionIterator temp1 = iter1.positionlist_begin();
276  pi1 = temp1;
277  Xapian::PositionIterator temp2 = iter2.positionlist_begin();
278  pi2 = temp2;
279  TEST_EQUAL(*pi1, 2); pi1++;
280  TEST_EQUAL(*pi2, 2); pi2++;
281  TEST(pi1 == iter1.positionlist_end());
282  TEST(pi2 == iter2.positionlist_end());
283 
284  iter1++;
285  iter2++;
286  TEST(iter1 == doc1.termlist_end());
287  TEST(iter2 == doc2.termlist_end());
288 }
289 
290 // test that adding lots of documents works, and doesn't leak memory
291 // REGRESSION FIXED:2003-09-07
292 DEFINE_TESTCASE(adddoc3, writable) {
293  Xapian::WritableDatabase db = get_writable_database();
294 
295  for (Xapian::doccount i = 0; i < 2100; ++i) {
296  Xapian::Document doc;
297  for (Xapian::termcount t = 0; t < 100; ++t) {
298  string term("foo");
299  term += char(t ^ 70 ^ i);
300  doc.add_posting(term, t);
301  }
302  db.add_document(doc);
303  }
304 }
305 
306 // We originally wanted to test that a termlist starting with a 48 character
307 // long term worked since that required special handling in flint for
308 // historical reasons. That's no longer relevant, but it seems useful to
309 // continue to test term lists starting with various term lengths work.
310 DEFINE_TESTCASE(adddoc4, writable) {
311  Xapian::WritableDatabase db = get_writable_database();
312 
313  for (Xapian::doccount i = 1; i <= 240; ++i) {
314  Xapian::Document doc;
315  string term(i, 'X');
316  doc.add_term(term);
317  db.add_document(doc);
318  }
319  db.add_document(Xapian::Document());
320  db.commit();
321 
322  for (Xapian::doccount i = 1; i <= 240; ++i) {
323  Xapian::Document doc = db.get_document(i);
324  Xapian::TermIterator t = doc.termlist_begin();
325  TEST(t != doc.termlist_end());
326  TEST_EQUAL((*t).size(), i);
327  ++t;
328  TEST(t == doc.termlist_end());
329  }
330 
331  // And test a document with no terms.
332  Xapian::Document doc = db.get_document(241);
333  TEST(doc.termlist_begin() == doc.termlist_end());
334 }
335 
336 // Test adding a document, and checking that it got added correctly.
337 // This testcase used to be adddoc2 in quartztest.
338 DEFINE_TESTCASE(adddoc5, writable) {
339  // FIXME: With multi, get_termfreq() on a TermIterator from a Document
340  // currently returns the termfreq for just the shard the doc is in.
341 
342  // Inmemory doesn't support get_writable_database_as_database().
343  SKIP_TEST_FOR_BACKEND("inmemory");
344 
345  Xapian::docid did;
346  Xapian::Document document_in;
347  document_in.set_data("Foobar rising");
348  document_in.add_value(7, "Value7");
349  document_in.add_value(13, "Value13");
350  document_in.add_posting("foobar", 1);
351  document_in.add_posting("rising", 2);
352  document_in.add_posting("foobar", 3);
353 
354  Xapian::Document document_in2;
355  document_in2.set_data("Foobar falling");
356  document_in2.add_posting("foobar", 1);
357  document_in2.add_posting("falling", 2);
358  {
359  Xapian::WritableDatabase database(get_writable_database());
360 
361  TEST_EQUAL(database.get_doccount(), 0);
362  TEST_EQUAL(database.get_avlength(), 0);
363 
364  did = database.add_document(document_in);
365  TEST_EQUAL(database.get_doccount(), 1);
366  TEST_EQUAL(database.get_avlength(), 3);
367 
368  TEST_EQUAL(database.get_termfreq("foobar"), 1);
369  TEST_EQUAL(database.get_collection_freq("foobar"), 2);
370  TEST_EQUAL(database.get_termfreq("rising"), 1);
371  TEST_EQUAL(database.get_collection_freq("rising"), 1);
372  TEST_EQUAL(database.get_termfreq("falling"), 0);
373  TEST_EQUAL(database.get_collection_freq("falling"), 0);
374 
375  Xapian::docid did2 = database.add_document(document_in2);
376  TEST_EQUAL(database.get_doccount(), 2);
377  TEST_NOT_EQUAL(did, did2);
378  TEST_EQUAL(database.get_avlength(), 5.0 / 2.0);
379 
380  TEST_EQUAL(database.get_termfreq("foobar"), 2);
381  TEST_EQUAL(database.get_collection_freq("foobar"), 3);
382  TEST_EQUAL(database.get_termfreq("rising"), 1);
383  TEST_EQUAL(database.get_collection_freq("rising"), 1);
384  TEST_EQUAL(database.get_termfreq("falling"), 1);
385  TEST_EQUAL(database.get_collection_freq("falling"), 1);
386 
387  database.delete_document(did);
388  TEST_EQUAL(database.get_doccount(), 1);
389  TEST_EQUAL(database.get_avlength(), 2);
390 
391  TEST_EQUAL(database.get_termfreq("foobar"), 1);
392  TEST_EQUAL(database.get_collection_freq("foobar"), 1);
393  TEST_EQUAL(database.get_termfreq("rising"), 0);
394  TEST_EQUAL(database.get_collection_freq("rising"), 0);
395  TEST_EQUAL(database.get_termfreq("falling"), 1);
396  TEST_EQUAL(database.get_collection_freq("falling"), 1);
397 
398  did = database.add_document(document_in);
399  TEST_EQUAL(database.get_doccount(), 2);
400  TEST_EQUAL(database.get_avlength(), 5.0 / 2.0);
401 
402  TEST_EQUAL(database.get_termfreq("foobar"), 2);
403  TEST_EQUAL(database.get_collection_freq("foobar"), 3);
404  TEST_EQUAL(database.get_termfreq("rising"), 1);
405  TEST_EQUAL(database.get_collection_freq("rising"), 1);
406  TEST_EQUAL(database.get_termfreq("falling"), 1);
407  TEST_EQUAL(database.get_collection_freq("falling"), 1);
408  }
409 
410  {
411  Xapian::Database database(get_writable_database_as_database());
412  Xapian::Document document_out = database.get_document(did);
413 
414  // get_termfreq() on a TermIterator from a Document returns the
415  // termfreq for just the shard the doc is in.
416  bool sharded = (database.size() > 1);
417 
418  TEST_EQUAL(document_in.get_data(), document_out.get_data());
419 
420  {
421  Xapian::ValueIterator i(document_in.values_begin());
422  Xapian::ValueIterator j(document_out.values_begin());
423  for (; i != document_in.values_end(); i++, j++) {
424  TEST_NOT_EQUAL(j, document_out.values_end());
425  TEST_EQUAL(*i, *j);
426  TEST_EQUAL(i.get_valueno(), j.get_valueno());
427  }
428  TEST_EQUAL(j, document_out.values_end());
429  }
430 
431  {
432  // Regression test for bug fixed in 1.0.5 - values_begin() didn't
433  // ensure that values had been read. However, values_end() did
434  // (and so did values_count()) so this wasn't generally an issue
435  // but it shouldn't happen anyway.
436  Xapian::Document doc_tmp = database.get_document(did);
437  Xapian::ValueIterator i = document_in.values_begin();
438  Xapian::ValueIterator j = doc_tmp.values_begin();
439  TEST_EQUAL(*i, *j);
440  }
441 
442  {
443  Xapian::TermIterator i(document_in.termlist_begin());
444  Xapian::TermIterator j(document_out.termlist_begin());
445  for (; i != document_in.termlist_end(); i++, j++) {
446  TEST_NOT_EQUAL(j, document_out.termlist_end());
447  TEST_EQUAL(*i, *j);
448  TEST_EQUAL(i.get_wdf(), j.get_wdf());
449  if (!sharded) {
450  // Actually use termfreq to stop compiler optimising away the
451  // call to get_termfreq().
452  TEST_EXCEPTION(Xapian::InvalidOperationError,
453  if (i.get_termfreq()) FAIL_TEST("?"));
454  TEST_NOT_EQUAL(0, j.get_termfreq());
455  if (*i == "foobar") {
456  // termfreq of foobar is 2
457  TEST_EQUAL(2, j.get_termfreq());
458  } else {
459  // termfreq of rising is 1
460  TEST_EQUAL(*i, "rising");
461  TEST_EQUAL(1, j.get_termfreq());
462  }
463  }
464  Xapian::PositionIterator k(i.positionlist_begin());
465  Xapian::PositionIterator l(j.positionlist_begin());
466  for (; k != i.positionlist_end(); k++, l++) {
467  TEST_NOT_EQUAL(l, j.positionlist_end());
468  TEST_EQUAL(*k, *l);
469  }
470  TEST_EQUAL(l, j.positionlist_end());
471  }
472  TEST_EQUAL(j, document_out.termlist_end());
473  }
474  }
475 }
476 
477 // Test adding a document, and checking that it got added correctly.
478 // This testcase used to be adddoc3 in quartztest.
479 DEFINE_TESTCASE(adddoc6, writable) {
480  // Inmemory doesn't support get_writable_database_again().
481  SKIP_TEST_FOR_BACKEND("inmemory");
482 
483  Xapian::docid did;
484  Xapian::Document document_in;
485  document_in.set_data("Foobar rising");
486  document_in.add_value(7, "Value7");
487  document_in.add_value(13, "Value13");
488  document_in.add_posting("foo", 1);
489  document_in.add_posting("bar", 2);
490 
491  {
492  Xapian::WritableDatabase database(get_writable_database());
493 
494  did = database.add_document(document_in);
495  TEST_EQUAL(did, 1);
496  TEST_EQUAL(database.get_doccount(), 1);
497  TEST_EQUAL(database.get_avlength(), 2);
498  }
499 
500  {
501  Xapian::WritableDatabase database(get_writable_database_again());
502 
503  document_in.remove_term("foo");
504  document_in.add_posting("baz", 1);
505 
506  database.replace_document(1, document_in);
507 
508  database.delete_document(1);
509 
510  TEST_EQUAL(database.get_doccount(), 0);
511  TEST_EQUAL(database.get_avlength(), 0);
512  TEST_EQUAL(database.get_termfreq("foo"), 0);
513  TEST_EQUAL(database.get_collection_freq("foo"), 0);
514  TEST_EQUAL(database.get_termfreq("bar"), 0);
515  TEST_EQUAL(database.get_collection_freq("bar"), 0);
516  TEST_EQUAL(database.get_termfreq("baz"), 0);
517  TEST_EQUAL(database.get_collection_freq("baz"), 0);
518  }
519 }
520 
521 // tests that database destructors commit if it isn't done explicitly
522 DEFINE_TESTCASE(implicitendsession1, writable) {
523  Xapian::WritableDatabase db = get_writable_database();
524 
525  Xapian::Document doc;
526 
527  doc.set_data(string("top secret"));
528  doc.add_posting("cia", 1);
529  doc.add_posting("nsa", 2);
530  doc.add_posting("fbi", 3);
531  db.add_document(doc);
532 }
533 
534 // tests that assignment of Xapian::Database and Xapian::WritableDatabase works
535 // as expected
536 DEFINE_TESTCASE(databaseassign1, writable) {
537  Xapian::WritableDatabase wdb = get_writable_database();
538  Xapian::Database db = get_database("");
539  Xapian::Database actually_wdb = wdb;
540  Xapian::WritableDatabase w1(wdb);
541  w1 = wdb;
542  Xapian::Database d1(wdb);
543  Xapian::Database d2(actually_wdb);
544  d2 = wdb;
545  d2 = actually_wdb;
546 #ifdef __has_warning
547 # if __has_warning("-Wself-assign-overloaded")
548  // Suppress warning from newer clang about self-assignment so we can
549  // test that self-assignment works!
550 # pragma clang diagnostic push
551 # pragma clang diagnostic ignored "-Wself-assign-overloaded"
552 # endif
553 #endif
554  wdb = wdb; // check assign to itself works
555  db = db; // check assign to itself works
556 #ifdef __has_warning
557 # if __has_warning("-Wself-assign-overloaded")
558 # pragma clang diagnostic pop
559 # endif
560 #endif
561 }
562 
563 // tests that deletion and updating of documents works as expected
564 DEFINE_TESTCASE(deldoc1, writable) {
565  Xapian::WritableDatabase db = get_writable_database();
566 
567  Xapian::Document doc1;
568 
569  doc1.add_posting("foo", 1);
570  doc1.add_posting("foo", 1);
571  doc1.add_posting("foo", 2);
572  doc1.add_posting("foo", 2);
573  doc1.add_posting("bar", 3);
574  doc1.add_posting("gone", 1);
575 
576  Xapian::docid did = db.add_document(doc1);
577  TEST_EQUAL(did, 1);
578 
579  doc1.remove_term("gone");
580 
581  did = db.add_document(doc1);
582  TEST_EQUAL(did, 2);
583 
584  doc1.add_term("new", 1);
585  did = db.add_document(doc1);
586  TEST_EQUAL(did, 3);
587 
588  db.delete_document(1);
589 
590  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
591 
592  doc1 = db.get_document(2);
593  doc1.remove_term("foo");
594  doc1.add_term("fwing");
595  db.replace_document(2, doc1);
596 
597  Xapian::Document doc2 = db.get_document(2);
598  Xapian::TermIterator tit = doc2.termlist_begin();
599  TEST_NOT_EQUAL(tit, doc2.termlist_end());
600  TEST_EQUAL(*tit, "bar");
601  tit++;
602  TEST_NOT_EQUAL(tit, doc2.termlist_end());
603  TEST_EQUAL(*tit, "fwing");
604  tit++;
605  TEST_EQUAL(tit, doc2.termlist_end());
606 }
607 
608 // tests that deletion and updating of documents works as expected
609 DEFINE_TESTCASE(deldoc2, writable) {
610  Xapian::WritableDatabase db = get_writable_database();
611 
612  Xapian::Document doc1;
613 
614  doc1.add_posting("one", 1);
615  doc1.add_posting("two", 2);
616  doc1.add_posting("two", 3);
617  Xapian::docid did;
618 
619  did = db.add_document(doc1);
620  TEST_EQUAL(did, 1);
621 
622  doc1.remove_term("one");
623  doc1.add_posting("three", 4);
624 
625  did = db.add_document(doc1);
626  TEST_EQUAL(did, 2);
627 
628  doc1.add_posting("one", 7);
629  doc1.remove_term("two");
630 
631  did = db.add_document(doc1);
632  TEST_EQUAL(did, 3);
633 
634  db.commit();
635 
636  // reopen() on a writable database shouldn't do anything.
637  TEST(!db.reopen());
638 
639  db.delete_document(1);
640  db.delete_document(2);
641  db.delete_document(3);
642 
643  db.commit();
644 
645  // reopen() on a writable database shouldn't do anything.
646  TEST(!db.reopen());
647 
648  TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
649  TEST_EQUAL(db.postlist_begin("two"), db.postlist_end("two"));
650  TEST_EQUAL(db.postlist_begin("three"), db.postlist_end("three"));
651 
652  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(1));
653  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(2));
654  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(3));
655  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(4));
656 
657  // test positionlist_{begin,end}?
658 
659  TEST_EQUAL(db.get_doccount(), 0);
660  TEST_EQUAL(db.get_avlength(), 0);
661  TEST_EQUAL(db.get_termfreq("one"), 0);
662  TEST_EQUAL(db.get_termfreq("two"), 0);
663  TEST_EQUAL(db.get_termfreq("three"), 0);
664 
665  TEST(!db.term_exists("one"));
666  TEST(!db.term_exists("two"));
667  TEST(!db.term_exists("three"));
668 
669  TEST_EQUAL(db.get_collection_freq("one"), 0);
670  TEST_EQUAL(db.get_collection_freq("two"), 0);
671  TEST_EQUAL(db.get_collection_freq("three"), 0);
672 
673  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(1));
674  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(2));
675  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(3));
676 
677  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(1));
678  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(2));
679  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(3));
680 
681  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
682  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
683  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(3));
684 
685  TEST_EQUAL(db.allterms_begin(), db.allterms_end());
686 }
687 
688 // another test of deletion of documents, a cut-down version of deldoc2
689 DEFINE_TESTCASE(deldoc3, writable) {
690  Xapian::WritableDatabase db = get_writable_database();
691 
692  Xapian::Document doc1;
693 
694  doc1.add_posting("one", 1);
695 
696  Xapian::docid did = db.add_document(doc1);
697  TEST_EQUAL(did, 1);
698 
699  db.commit();
700 
701  // reopen() on a writable database shouldn't do anything.
702  TEST(!db.reopen());
703 
704  db.delete_document(1);
705 
706  db.commit();
707 
708  // reopen() on a writable database shouldn't do anything.
709  TEST(!db.reopen());
710 
711  TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
712 
713  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(1));
714  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(2));
715 
716  // test positionlist_{begin,end}?
717 
718  TEST_EQUAL(db.get_doccount(), 0);
719  TEST_EQUAL(db.get_avlength(), 0);
720  TEST_EQUAL(db.get_termfreq("one"), 0);
721 
722  TEST(!db.term_exists("one"));
723 
724  TEST_EQUAL(db.get_collection_freq("one"), 0);
725 
726  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(1));
727  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(2));
728 
729  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(1));
730  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(2));
731 
732  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
733  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
734 
735  TEST_EQUAL(db.allterms_begin(), db.allterms_end());
736 }
737 
738 // tests that deletion and updating of (lots of) documents works as expected
739 DEFINE_TESTCASE(deldoc4, writable) {
740  Xapian::WritableDatabase db = get_writable_database();
741 
742  Xapian::Document doc1;
743 
744  doc1.add_posting("one", 1);
745  doc1.add_posting("two", 2);
746  doc1.add_posting("two", 3);
747 
748  Xapian::Document doc2 = doc1;
749  doc2.remove_term("one");
750  doc2.add_posting("three", 4);
751 
752  Xapian::Document doc3 = doc2;
753  doc3.add_posting("one", 7);
754  doc3.remove_term("two");
755 
756  const Xapian::docid maxdoc = 1000 * 3;
757  Xapian::docid did;
758  for (Xapian::docid i = 0; i < maxdoc / 3; ++i) {
759  did = db.add_document(doc1);
760  TEST_EQUAL(did, i * 3 + 1);
761  did = db.add_document(doc2);
762  TEST_EQUAL(did, i * 3 + 2);
763  did = db.add_document(doc3);
764  TEST_EQUAL(did, i * 3 + 3);
765 
766  bool is_power_of_two = ((i & negate_unsigned(i)) == 0);
767  if (is_power_of_two) {
768  db.commit();
769  // reopen() on a writable database shouldn't do anything.
770  TEST(!db.reopen());
771  }
772  }
773  db.commit();
774  // reopen() on a writable database shouldn't do anything.
775  TEST(!db.reopen());
776 
777  /* delete the documents in a peculiar order */
778  for (Xapian::docid i = 0; i < maxdoc / 3; ++i) {
779  db.delete_document(maxdoc - i);
780  db.delete_document(maxdoc / 3 + i + 1);
781  db.delete_document(i + 1);
782  }
783 
784  db.commit();
785  // reopen() on a writable database shouldn't do anything.
786  TEST(!db.reopen());
787 
788  TEST_EQUAL(db.postlist_begin("one"), db.postlist_end("one"));
789  TEST_EQUAL(db.postlist_begin("two"), db.postlist_end("two"));
790  TEST_EQUAL(db.postlist_begin("three"), db.postlist_end("three"));
791 
792  for (Xapian::docid i = 1; i <= maxdoc; ++i) {
793  // TEST_EXCEPTION writes to tout each time if the test is run
794  // in verbose mode and some string stream implementations get
795  // very inefficient with large strings, so clear tout on each pass of
796  // the loop to speed up the test since the older information isn't
797  // interesting anyway.
798  tout.str(string());
799  TEST_EXCEPTION(Xapian::DocNotFoundError, db.termlist_begin(i));
800  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_doclength(i));
801  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_unique_terms(i));
802  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(i));
803  }
804 
805  // test positionlist_{begin,end}?
806 
807  TEST_EQUAL(db.get_doccount(), 0);
808  TEST_EQUAL(db.get_avlength(), 0);
809  TEST_EQUAL(db.get_termfreq("one"), 0);
810  TEST_EQUAL(db.get_termfreq("two"), 0);
811  TEST_EQUAL(db.get_termfreq("three"), 0);
812 
813  TEST(!db.term_exists("one"));
814  TEST(!db.term_exists("two"));
815  TEST(!db.term_exists("three"));
816 
817  TEST_EQUAL(db.get_collection_freq("one"), 0);
818  TEST_EQUAL(db.get_collection_freq("two"), 0);
819  TEST_EQUAL(db.get_collection_freq("three"), 0);
820 
821  TEST_EQUAL(db.allterms_begin(), db.allterms_end());
822 }
823 
824 // Test deleting a document which was added in the same batch.
825 DEFINE_TESTCASE(deldoc5, writable) {
826  Xapian::WritableDatabase db = get_writable_database();
827 
828  Xapian::Document doc1;
829 
830  doc1.add_posting("foo", 1);
831  doc1.add_posting("bar", 2);
832  doc1.add_posting("aardvark", 3);
833 
834  Xapian::docid did = db.add_document(doc1);
835  TEST_EQUAL(did, 1);
836 
837  doc1.remove_term("bar");
838  doc1.add_term("hello");
839 
840  did = db.add_document(doc1);
841  TEST_EQUAL(did, 2);
842 
843  doc1.add_term("world", 1);
844  did = db.add_document(doc1);
845  TEST_EQUAL(did, 3);
846 
847  db.delete_document(2);
848 
849  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
850 
851  db.commit();
852 
853  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
854 
855  TEST_EQUAL(db.get_termfreq("foo"), 2);
856  TEST_EQUAL(db.get_termfreq("aardvark"), 2);
857  TEST_EQUAL(db.get_termfreq("hello"), 1);
858 
859  Xapian::PostingIterator p = db.postlist_begin("foo");
860  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
861  TEST_EQUAL(*p, 1);
862  ++p;
863  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
864  TEST_EQUAL(*p, 3);
865  ++p;
866  TEST_EQUAL(p, db.postlist_end("foo"));
867 }
868 
869 // Regression test for bug in quartz and flint, fixed in 1.0.2.
870 DEFINE_TESTCASE(deldoc6, writable) {
871  Xapian::WritableDatabase db = get_writable_database();
872 
873  Xapian::Document doc1;
874 
875  doc1.add_posting("foo", 1);
876  doc1.add_posting("bar", 2);
877  doc1.add_posting("aardvark", 3);
878 
879  Xapian::docid did = db.add_document(doc1);
880  TEST_EQUAL(did, 1);
881 
882  doc1.remove_term("bar");
883  doc1.add_term("hello");
884 
885  did = db.add_document(doc1);
886  TEST_EQUAL(did, 2);
887 
888  db.commit();
889 
890  db.delete_document(2);
891  TEST_EXCEPTION(Xapian::DocNotFoundError, db.delete_document(3));
892 
893  db.commit();
894 
895  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(2));
896 }
897 
898 DEFINE_TESTCASE(replacedoc1, writable) {
899  Xapian::WritableDatabase db = get_writable_database();
900 
901  Xapian::Document doc1;
902 
903  doc1.add_posting("foo", 1);
904  doc1.add_posting("foo", 2);
905  doc1.add_posting("gone", 3);
906  doc1.add_posting("bar", 4);
907  doc1.add_posting("foo", 5);
908  Xapian::docid did;
909 
910  did = db.add_document(doc1);
911  TEST_EQUAL(did, 1);
912 
913  Xapian::Document doc2;
914 
915  doc2.add_posting("foo", 1);
916  doc2.add_posting("pipco", 2);
917  doc2.add_posting("bar", 4);
918  doc2.add_posting("foo", 5);
919 
920  db.replace_document(did, doc2);
921 
922  Xapian::Document doc3 = db.get_document(did);
923  Xapian::TermIterator t_iter = doc3.termlist_begin();
924  TEST_EQUAL(*t_iter, "bar");
925  Xapian::PositionIterator p_iter = t_iter.positionlist_begin();
926  TEST_EQUAL(*p_iter, 4);
927  ++t_iter;
928  TEST_EQUAL(*t_iter, "foo");
929  Xapian::PositionIterator q_iter = t_iter.positionlist_begin();
930  TEST_EQUAL(*q_iter, 1);
931  ++q_iter;
932  TEST_EQUAL(*q_iter, 5);
933  ++t_iter;
934  TEST_EQUAL(*t_iter, "pipco");
935  Xapian::PositionIterator r_iter = t_iter.positionlist_begin();
936  TEST_EQUAL(*r_iter, 2);
937  ++t_iter;
938  TEST_EQUAL(t_iter, doc3.termlist_end());
939 }
940 
941 // Test of new feature: WritableDatabase::replace_document accepts a docid
942 // which doesn't yet exist as of Xapian 0.8.2.
943 DEFINE_TESTCASE(replacedoc2, writable) {
944  Xapian::WritableDatabase db = get_writable_database();
945 
946  Xapian::Document doc1;
947 
948  doc1.add_posting("foo", 1);
949  doc1.add_posting("foo", 2);
950  doc1.add_posting("gone", 3);
951  doc1.add_posting("bar", 4);
952  doc1.add_posting("foo", 5);
953  Xapian::docid did = 31770;
954 
955  db.replace_document(did, doc1);
956 
957  // Regression tests for bug in the InMemory backend - fixed in 1.0.2.
958  TEST_EXCEPTION(Xapian::DocNotFoundError, db.get_document(1));
959  Xapian::PostingIterator postit = db.postlist_begin("");
960  TEST(postit != db.postlist_end(""));
961  TEST_EQUAL(*postit, 31770);
962 
963  Xapian::Document doc2;
964 
965  doc2.add_posting("foo", 1);
966  doc2.add_posting("pipco", 2);
967  doc2.add_posting("bar", 4);
968  doc2.add_posting("foo", 5);
969 
970  db.replace_document(did, doc2);
971  TEST_EQUAL(db.get_doccount(), 1);
972 
973  Xapian::Document doc3 = db.get_document(did);
974  Xapian::TermIterator t_iter = doc3.termlist_begin();
975  TEST_EQUAL(*t_iter, "bar");
976  Xapian::PositionIterator p_iter = t_iter.positionlist_begin();
977  TEST_EQUAL(*p_iter, 4);
978  ++t_iter;
979  TEST_EQUAL(*t_iter, "foo");
980  Xapian::PositionIterator q_iter = t_iter.positionlist_begin();
981  TEST_EQUAL(*q_iter, 1);
982  ++q_iter;
983  TEST_EQUAL(*q_iter, 5);
984  ++t_iter;
985  TEST_EQUAL(*t_iter, "pipco");
986  Xapian::PositionIterator r_iter = t_iter.positionlist_begin();
987  TEST_EQUAL(*r_iter, 2);
988  ++t_iter;
989  TEST_EQUAL(t_iter, doc3.termlist_end());
990 
991  did = db.add_document(doc1);
992  TEST_EQUAL(did, 31771);
993  TEST_EQUAL(db.get_doccount(), 2);
994 
995  TEST_EXCEPTION(Xapian::InvalidArgumentError, db.replace_document(0, doc2));
996 }
997 
998 // Test replacing a document which was added in the same batch.
999 DEFINE_TESTCASE(replacedoc3, writable) {
1000  Xapian::WritableDatabase db = get_writable_database();
1001 
1002  Xapian::Document doc1;
1003 
1004  doc1.add_posting("foo", 1);
1005  doc1.add_posting("bar", 2);
1006  doc1.add_posting("aardvark", 3);
1007 
1008  Xapian::docid did = db.add_document(doc1);
1009  TEST_EQUAL(did, 1);
1010 
1011  doc1.remove_term("bar");
1012  doc1.add_term("hello");
1013 
1014  did = db.add_document(doc1);
1015  TEST_EQUAL(did, 2);
1016 
1017  doc1.add_term("world", 1);
1018  did = db.add_document(doc1);
1019  TEST_EQUAL(did, 3);
1020 
1021  Xapian::Document doc2;
1022  doc2.add_term("world");
1023  db.replace_document(2, doc2);
1024 
1025  db.commit();
1026 
1027  // Check that the document exists (no DocNotFoundError).
1028  doc2 = db.get_document(2);
1029 
1030  TEST_EQUAL(db.get_termfreq("foo"), 2);
1031  TEST_EQUAL(db.get_termfreq("aardvark"), 2);
1032  TEST_EQUAL(db.get_termfreq("hello"), 1);
1033  TEST_EQUAL(db.get_termfreq("world"), 2);
1034 
1035  TEST_EQUAL(db.get_doclength(1), 3);
1036  TEST_EQUAL(db.get_doclength(2), 1);
1037  TEST_EQUAL(db.get_doclength(3), 4);
1038 
1039  TEST_EQUAL(db.get_unique_terms(1), 3);
1040  TEST_EQUAL(db.get_unique_terms(2), 1);
1041  TEST_EQUAL(db.get_unique_terms(3), 4);
1042 
1043  Xapian::PostingIterator p = db.postlist_begin("foo");
1044  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
1045  TEST_EQUAL(*p, 1);
1046  TEST_EQUAL(p.get_doclength(), 3);
1047  TEST_EQUAL(p.get_unique_terms(), 3);
1048  ++p;
1049  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
1050  TEST_EQUAL(*p, 3);
1051  TEST_EQUAL(p.get_doclength(), 4);
1052  TEST_EQUAL(p.get_unique_terms(), 4);
1053  ++p;
1054  TEST_EQUAL(p, db.postlist_end("foo"));
1055 
1056  p = db.postlist_begin("world");
1057  TEST_NOT_EQUAL(p, db.postlist_end("world"));
1058  TEST_EQUAL(*p, 2);
1059  TEST_EQUAL(p.get_doclength(), 1);
1060  TEST_EQUAL(p.get_unique_terms(), 1);
1061  ++p;
1062  TEST_NOT_EQUAL(p, db.postlist_end("world"));
1063  TEST_EQUAL(*p, 3);
1064  TEST_EQUAL(p.get_doclength(), 4);
1065  TEST_EQUAL(p.get_unique_terms(), 4);
1066  ++p;
1067  TEST_EQUAL(p, db.postlist_end("world"));
1068 }
1069 
1070 // Test replacing a document which was deleted in the same batch.
1071 DEFINE_TESTCASE(replacedoc4, writable) {
1072  Xapian::WritableDatabase db = get_writable_database();
1073 
1074  Xapian::Document doc1;
1075 
1076  doc1.add_posting("foo", 1);
1077  doc1.add_posting("bar", 2);
1078  doc1.add_posting("aardvark", 3);
1079 
1080  Xapian::docid did = db.add_document(doc1);
1081  TEST_EQUAL(did, 1);
1082 
1083  doc1.remove_term("bar");
1084  doc1.add_term("hello");
1085 
1086  did = db.add_document(doc1);
1087  TEST_EQUAL(did, 2);
1088 
1089  doc1.add_term("world", 1);
1090  did = db.add_document(doc1);
1091  TEST_EQUAL(did, 3);
1092 
1093  db.delete_document(2);
1094 
1095  Xapian::Document doc2;
1096  doc2.add_term("world");
1097  db.replace_document(2, doc2);
1098 
1099  db.commit();
1100 
1101  // Check that the document exists (no DocNotFoundError).
1102  doc2 = db.get_document(2);
1103 
1104  TEST_EQUAL(db.get_termfreq("foo"), 2);
1105  TEST_EQUAL(db.get_termfreq("aardvark"), 2);
1106  TEST_EQUAL(db.get_termfreq("hello"), 1);
1107  TEST_EQUAL(db.get_termfreq("world"), 2);
1108 
1109  Xapian::PostingIterator p = db.postlist_begin("foo");
1110  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
1111  TEST_EQUAL(*p, 1);
1112  ++p;
1113  TEST_NOT_EQUAL(p, db.postlist_end("foo"));
1114  TEST_EQUAL(*p, 3);
1115  ++p;
1116  TEST_EQUAL(p, db.postlist_end("foo"));
1117 
1118  p = db.postlist_begin("world");
1119  TEST_NOT_EQUAL(p, db.postlist_end("world"));
1120  TEST_EQUAL(*p, 2);
1121  ++p;
1122  TEST_NOT_EQUAL(p, db.postlist_end("world"));
1123  TEST_EQUAL(*p, 3);
1124  ++p;
1125  TEST_EQUAL(p, db.postlist_end("world"));
1126 }
1127 
1128 // Test replacing a document with itself without modifying postings.
1129 // Regression test for bug in 0.9.9 and earlier - there flint and quartz
1130 // lost all positional information for the document when you did this.
1131 DEFINE_TESTCASE(replacedoc5, writable) {
1132  Xapian::WritableDatabase db = get_writable_database();
1133 
1134  {
1135  Xapian::Document doc;
1136  doc.add_posting("hello", 1);
1137  doc.add_posting("world", 2);
1138 
1139  Xapian::docid did = db.add_document(doc);
1140  TEST_EQUAL(did, 1);
1141  db.commit();
1142  }
1143 
1144  {
1145  Xapian::Document doc = db.get_document(1);
1146  TEST(db.has_positions());
1147  TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
1148  TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
1149  db.replace_document(1, doc);
1150  db.commit();
1151 
1152  TEST(db.has_positions());
1153  TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
1154  TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
1155  }
1156 
1157  // The backends now spot simple cases of replacing the same document and
1158  // don't do needless work. Force them to actually do the replacement to
1159  // make sure that case works.
1160 
1161  {
1162  Xapian::Document doc;
1163  doc.add_term("Q2");
1164  db.add_document(doc);
1165  db.commit();
1166  }
1167 
1168  {
1169  Xapian::Document doc = db.get_document(1);
1170  TEST(db.has_positions());
1171  TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
1172  TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
1173  (void)db.get_document(2);
1174  db.replace_document(1, doc);
1175  db.commit();
1176 
1177  TEST(db.has_positions());
1178  TEST(db.positionlist_begin(1, "hello") != db.positionlist_end(1, "hello"));
1179  TEST(db.positionlist_begin(1, "world") != db.positionlist_end(1, "world"));
1180  }
1181 }
1182 
1183 // Test replacing a document while adding values, without changing anything
1184 // else. Regression test for a bug introduced while implementing lazy update,
1185 // and also covers a few other code paths.
1186 DEFINE_TESTCASE(replacedoc6, writable) {
1187  Xapian::WritableDatabase db = get_writable_database();
1188 
1189  Xapian::Document doc;
1190  Xapian::docid did = db.add_document(doc);
1191  TEST_EQUAL(did, 1);
1192  db.commit();
1193 
1194  // Add document
1195  doc = db.get_document(1);
1196  TEST_EQUAL(doc.get_value(1), "");
1197  TEST_EQUAL(doc.get_value(2), "");
1198  doc.add_value(1, "banana1");
1199  db.replace_document(1, doc);
1200 
1201  doc = db.get_document(1);
1202  TEST_EQUAL(doc.get_value(1), "banana1");
1203  TEST_EQUAL(doc.get_value(2), "");
1204  db.commit();
1205 
1206  doc = db.get_document(1);
1207  TEST_EQUAL(doc.get_value(1), "banana1");
1208  TEST_EQUAL(doc.get_value(2), "");
1209  doc.add_value(2, "banana2");
1210  db.replace_document(1, doc);
1211 
1212  TEST_EQUAL(doc.get_value(1), "banana1");
1213  TEST_EQUAL(doc.get_value(2), "banana2");
1214  db.commit();
1215 
1216  doc = db.get_document(1);
1217  TEST_EQUAL(doc.get_value(1), "banana1");
1218  TEST_EQUAL(doc.get_value(2), "banana2");
1219 }
1220 
1221 // Test of new feature: WritableDatabase::replace_document and delete_document
1222 // can take a unique termname instead of a document id as of Xapian 0.8.2.
1223 DEFINE_TESTCASE(uniqueterm1, writable) {
1224  Xapian::WritableDatabase db = get_writable_database();
1225 
1226  for (int n = 1; n <= 20; ++n) {
1227  Xapian::Document doc;
1228  string uterm = "U" + str(n % 16);
1229  doc.add_term(uterm);
1230  doc.add_term(str(n));
1231  doc.add_term(str(n ^ 9));
1232  doc.add_term("all");
1233  doc.set_data("pass1");
1234  db.add_document(doc);
1235  }
1236 
1237  TEST_EQUAL(db.get_doccount(), 20);
1238 
1239  static const Xapian::doccount sizes[20] = {
1240  19, 17, 16, 15,
1241  15, 15, 15, 15,
1242  15, 15, 15, 15,
1243  15, 15, 15, 15,
1244  15, 15, 15, 15
1245  };
1246  for (int n = 1; n <= 20; ++n) {
1247  string uterm = "U" + str(n % 16);
1248  if (uterm == "U2") {
1249  db.delete_document(uterm);
1250  } else {
1251  Xapian::Document doc;
1252  doc.add_term(uterm);
1253  doc.add_term(str(n));
1254  doc.add_term(str(n ^ 9));
1255  doc.add_term("all");
1256  doc.set_data("pass2");
1257  db.replace_document(uterm, doc);
1258  }
1259  TEST_EQUAL(db.get_doccount(), sizes[n - 1]);
1260  }
1261 
1262  string uterm = "U571";
1263  Xapian::Document doc;
1264  doc.add_term(uterm);
1265  doc.set_data("pass3");
1266  db.replace_document(uterm, doc);
1267 
1268  TEST_EQUAL(db.get_doccount(), 16);
1269 
1270  db.delete_document("U2");
1271 
1272  TEST_EQUAL(db.get_doccount(), 16);
1273 }
1274 
1275 // tests all document postlists
1276 DEFINE_TESTCASE(allpostlist2, writable) {
1277  Xapian::WritableDatabase db(get_writable_database("apitest_manydocs"));
1278  Xapian::PostingIterator i = db.postlist_begin("");
1279  unsigned int j = 1;
1280  while (i != db.postlist_end("")) {
1281  TEST_EQUAL(*i, j);
1282  i++;
1283  j++;
1284  }
1285  TEST_EQUAL(j, 513);
1286 
1287  db.delete_document(1);
1288  db.delete_document(50);
1289  db.delete_document(512);
1290 
1291  i = db.postlist_begin("");
1292  j = 2;
1293  while (i != db.postlist_end("")) {
1294  TEST_EQUAL(*i, j);
1295  i++;
1296  j++;
1297  if (j == 50) j++;
1298  }
1299  TEST_EQUAL(j, 512);
1300 
1301  i = db.postlist_begin("");
1302  j = 2;
1303  while (i != db.postlist_end("")) {
1304  TEST_EQUAL(*i, j);
1305  i++;
1306  j++;
1307  if (j == 40) {
1308  j += 10;
1309  i.skip_to(j);
1310  j++;
1311  }
1312  }
1313  TEST_EQUAL(j, 512);
1314 }
1315 
1316 static void test_emptyterm2_helper(Xapian::WritableDatabase & db)
1317 {
1318  // Don't bother with postlist_begin() because allpostlist tests cover that.
1319  TEST_EXCEPTION(Xapian::InvalidArgumentError, db.positionlist_begin(1, ""));
1320  TEST_EQUAL(db.get_doccount(), db.get_termfreq(""));
1321  TEST_EQUAL(db.get_doccount() != 0, db.term_exists(""));
1322  TEST_EQUAL(db.get_doccount(), db.get_collection_freq(""));
1323 }
1324 
1325 // tests results of passing an empty term to various methods
1326 // equivalent of emptyterm1 for a writable database
1327 DEFINE_TESTCASE(emptyterm2, writable) {
1328  {
1329  Xapian::WritableDatabase db(get_writable_database("apitest_manydocs"));
1330  TEST_EQUAL(db.get_doccount(), 512);
1331  test_emptyterm2_helper(db);
1332  db.delete_document(1);
1333  TEST_EQUAL(db.get_doccount(), 511);
1334  test_emptyterm2_helper(db);
1335  db.delete_document(50);
1336  TEST_EQUAL(db.get_doccount(), 510);
1337  test_emptyterm2_helper(db);
1338  db.delete_document(512);
1339  TEST_EQUAL(db.get_doccount(), 509);
1340  test_emptyterm2_helper(db);
1341  }
1342 
1343  {
1344  Xapian::WritableDatabase db(get_writable_database("apitest_onedoc"));
1345  TEST_EQUAL(db.get_doccount(), 1);
1346  test_emptyterm2_helper(db);
1347  db.delete_document(1);
1348  TEST_EQUAL(db.get_doccount(), 0);
1349  test_emptyterm2_helper(db);
1350  }
1351 
1352  {
1353  Xapian::WritableDatabase db(get_writable_database());
1354  TEST_EQUAL(db.get_doccount(), 0);
1355  test_emptyterm2_helper(db);
1356  }
1357 }
1358 
1359 static void
1360 gen_longpositionlist1_db(Xapian::WritableDatabase& db, const string&)
1361 {
1362  Xapian::Document doc;
1363  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1364  doc.add_posting("fork", n * 3);
1365  doc.add_posting("knife", n * unsigned(log(double(n + 2))));
1366  doc.add_posting("spoon", n * n);
1367  // Exercise positions up to 4 billion.
1368  Xapian::termpos half_cube = n * n / 2 * n;
1369  doc.add_posting("chopsticks", half_cube);
1370  if constexpr(sizeof(Xapian::termpos) >= 8) {
1371  // Exercise 64-bit positions.
1372  doc.add_posting("spork", half_cube * half_cube);
1373  }
1374  }
1375  doc.set_data("cutlery");
1376  db.add_document(doc);
1377 }
1378 
1379 // Check that a large number of position list entries for a particular term
1380 // works - regression test for flint.
1381 DEFINE_TESTCASE(longpositionlist1, backend) {
1382  Xapian::Database db = get_database("longpositionlist1",
1383  gen_longpositionlist1_db);
1384 
1385  Xapian::Document doc = db.get_document(1);
1386 
1387  Xapian::TermIterator t, tend;
1388  Xapian::PositionIterator p, pend;
1389 
1390  t = doc.termlist_begin();
1391  tend = doc.termlist_end();
1392 
1393  TEST(t != tend);
1394  TEST_EQUAL(*t, "chopsticks");
1395  p = t.positionlist_begin();
1396  pend = t.positionlist_end();
1397  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1398  TEST(p != pend);
1399  Xapian::termpos half_cube = n * n / 2 * n;
1400  TEST_EQUAL(*p, half_cube);
1401  ++p;
1402  }
1403  TEST(p == pend);
1404 
1405  ++t;
1406  TEST(t != tend);
1407  TEST_EQUAL(*t, "fork");
1408  p = t.positionlist_begin();
1409  pend = t.positionlist_end();
1410  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1411  TEST(p != pend);
1412  TEST_EQUAL(*p, n * 3);
1413  ++p;
1414  }
1415  TEST(p == pend);
1416 
1417  ++t;
1418  TEST(t != tend);
1419  TEST_EQUAL(*t, "knife");
1420  p = t.positionlist_begin();
1421  pend = t.positionlist_end();
1422  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1423  TEST(p != pend);
1424  TEST_EQUAL(*p, n * unsigned(log(double(n + 2))));
1425  ++p;
1426  }
1427  TEST(p == pend);
1428 
1429  ++t;
1430  TEST(t != tend);
1431  TEST_EQUAL(*t, "spoon");
1432  p = t.positionlist_begin();
1433  pend = t.positionlist_end();
1434  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1435  TEST(p != pend);
1436  TEST_EQUAL(*p, n * n);
1437  ++p;
1438  }
1439  TEST(p == pend);
1440 
1441  if constexpr(sizeof(Xapian::termpos) >= 8) {
1442  ++t;
1443  TEST(t != tend);
1444  TEST_EQUAL(*t, "spork");
1445  p = t.positionlist_begin();
1446  pend = t.positionlist_end();
1447  for (Xapian::termpos n = 1; n <= 2000; ++n) {
1448  TEST(p != pend);
1449  Xapian::termpos half_cube = n * n / 2 * n;
1450  TEST_EQUAL(*p, half_cube * half_cube);
1451  ++p;
1452  }
1453  TEST(p == pend);
1454  }
1455 
1456  ++t;
1457  TEST(t == tend);
1458 }
1459 
1460 static void
1461 gen_consistency2_db(Xapian::WritableDatabase& db, const string&)
1462 {
1463  char buf[2] = "X";
1464 
1465  // Add 5 documents indexed by "test" with wdf 1.
1466  for (int i = 0; i < 5; ++i) {
1467  Xapian::Document doc;
1468  *buf = '0' + i;
1469  doc.add_value(0, buf);
1470  doc.add_term("test");
1471  db.add_document(doc);
1472  }
1473 
1474  // Add 5 documents indexed by "test" with wdf 2.
1475  for (int i = 0; i < 5; ++i) {
1476  Xapian::Document doc;
1477  *buf = '0' + i;
1478  doc.add_value(0, buf);
1479  doc.add_term("test", 2);
1480  db.add_document(doc);
1481  }
1482 }
1483 
1484 // Regression test for bug#110: Inconsistent sort order between pages with
1485 // set_sort_by_value_then_relevance.
1486 DEFINE_TESTCASE(consistency2, backend) {
1487  Xapian::Database db = get_database("consistency2", gen_consistency2_db);
1488 
1489  Xapian::Enquire enq(db);
1490  enq.set_query(Xapian::Query("test"));
1491 
1492  enq.set_sort_by_value_then_relevance(0, true);
1493 
1494  // 10 results, unpaged.
1495  Xapian::MSet mset1 = enq.get_mset(0, 10);
1496  TEST_EQUAL(mset1.size(), 10);
1497 
1498  // 10 results, split.
1499  Xapian::MSet mset2a = enq.get_mset(0, 1);
1500  TEST_EQUAL(mset2a.size(), 1);
1501  Xapian::MSet mset2b = enq.get_mset(1, 1);
1502  TEST_EQUAL(mset2b.size(), 1);
1503  Xapian::MSet mset2c = enq.get_mset(2, 8);
1504  TEST_EQUAL(mset2c.size(), 8);
1505 
1506  TEST_EQUAL(*mset1[0], *mset2a[0]);
1507  TEST_EQUAL(*mset1[1], *mset2b[0]);
1508  for (Xapian::doccount i = 0; i < 8; ++i) {
1509  TEST_EQUAL(*mset1[i + 2], *mset2c[i]);
1510  }
1511 }
1512 
1513 // Check that DatabaseError is thrown if the docid counter would wrap.
1514 // Regression test for bug#152.
1515 DEFINE_TESTCASE(nomoredocids1, writable) {
1516  // The InMemory backend uses a vector for the documents, so trying to add
1517  // a document with a really large docid will fail because we can't allocate
1518  // enough memory!
1519  SKIP_TEST_FOR_BACKEND("inmemory");
1520 
1521  Xapian::WritableDatabase db = get_writable_database();
1522  Xapian::Document doc;
1523  doc.set_data("prose");
1524  doc.add_term("word");
1525 
1526  Xapian::docid max_id = numeric_limits<Xapian::docid>::max();
1527  db.replace_document(max_id, doc);
1528 
1529  TEST_EXCEPTION(Xapian::DatabaseError, db.add_document(doc));
1530 
1531  // Also test replace_document() by term which will try to add a new
1532  // document if the term isn't present - that should also fail if the
1533  // docid counter would wrap.
1534  TEST_EXCEPTION(Xapian::DatabaseError, db.replace_document("Q42", doc));
1535 }
1536 
1537 static void
1538 gen_synonym_merge1a_db(Xapian::WritableDatabase& db, const string&)
1539 {
1540  db.add_synonym("abc", "asd");
1541  db.add_synonym("abc", "asd2");
1542  db.add_synonym("abc", "asd4");
1543  db.add_synonym("abc", "asd6");
1544 }
1545 
1546 static void
1547 gen_synonym_merge1b_db(Xapian::WritableDatabase& db, const string&)
1548 {
1549  db.add_synonym("abc", "asd1");
1550  db.add_synonym("abc", "asd2");
1551  db.add_synonym("abc", "asd3");
1552  db.add_synonym("abc", "asd5");
1553  db.add_synonym("abc", "asd10");
1554 }
1555 
1556 // Test synonyms from subdbs are appropriately merged.
1557 DEFINE_TESTCASE(synonym_merge1, synonyms) {
1558  Xapian::Database db_multi;
1559  db_multi.add_database(get_database("synonym_merge1a",
1560  gen_synonym_merge1a_db));
1561  db_multi.add_database(get_database("synonym_merge1b",
1562  gen_synonym_merge1b_db));
1563 
1564  Xapian::TermIterator t;
1565  string s, e;
1566  s = "|";
1567  t = db_multi.synonyms_begin("abc");
1568  while (t != db_multi.synonyms_end("abc")) {
1569  s += *t++;
1570  s += '|';
1571  }
1572  e = "|asd|asd1|asd10|asd2|asd3|asd4|asd5|asd6|";
1573  TEST_STRINGS_EQUAL(s, e);
1574 }
1575 
1576 
1577 // Test synonym iterators.
1578 DEFINE_TESTCASE(synonymitor1, writable && synonyms) {
1579  Xapian::WritableDatabase db = get_writable_database();
1580 
1581  // Test iterators for terms which aren't there.
1582  TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
1583 
1584  // Test iterating the synonym keys when there aren't any.
1585  TEST(db.synonym_keys_begin() == db.synonym_keys_end());
1586 
1587  db.add_synonym("hello", "howdy");
1588  db.add_synonym("hello", "hi");
1589  db.add_synonym("goodbye", "bye");
1590  db.add_synonym("goodbye", "farewell");
1591 
1592  Xapian::TermIterator t;
1593  string s;
1594 
1595  // Try these tests twice - once before committing and once after.
1596  for (int times = 1; times <= 2; ++times) {
1597  // Test iterators for terms which aren't there.
1598  TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
1599  TEST(db.synonyms_begin("ghi") == db.synonyms_end("ghi"));
1600  TEST(db.synonyms_begin("zzzzz") == db.synonyms_end("zzzzz"));
1601 
1602  s = "|";
1603  t = db.synonyms_begin("hello");
1604  while (t != db.synonyms_end("hello")) {
1605  s += *t++;
1606  s += '|';
1607  }
1608  TEST_STRINGS_EQUAL(s, "|hi|howdy|");
1609 
1610  s = "|";
1611  t = db.synonyms_begin("goodbye");
1612  while (t != db.synonyms_end("goodbye")) {
1613  s += *t++;
1614  s += '|';
1615  }
1616  TEST_STRINGS_EQUAL(s, "|bye|farewell|");
1617 
1618  s = "|";
1619  t = db.synonym_keys_begin();
1620  while (t != db.synonym_keys_end()) {
1621  s += *t++;
1622  s += '|';
1623  }
1624  TEST_STRINGS_EQUAL(s, "|goodbye|hello|");
1625 
1626  db.commit();
1627  }
1628 
1629  // Delete a synonym for "hello" and all synonyms for "goodbye".
1630  db.remove_synonym("hello", "hi");
1631  db.clear_synonyms("goodbye");
1632 
1633  // Try these tests twice - once before committing and once after.
1634  for (int times = 1; times <= 2; ++times) {
1635  // Test iterators for terms which aren't there.
1636  TEST(db.synonyms_begin("abc") == db.synonyms_end("abc"));
1637  TEST(db.synonyms_begin("ghi") == db.synonyms_end("ghi"));
1638  TEST(db.synonyms_begin("zzzzz") == db.synonyms_end("zzzzz"));
1639 
1640  s = "|";
1641  t = db.synonyms_begin("hello");
1642  while (t != db.synonyms_end("hello")) {
1643  s += *t++;
1644  s += '|';
1645  }
1646  TEST_STRINGS_EQUAL(s, "|howdy|");
1647 
1648  TEST(db.synonyms_begin("goodbye") == db.synonyms_end("goodbye"));
1649 
1650  s = "|";
1651  t = db.synonym_keys_begin();
1652  while (t != db.synonym_keys_end()) {
1653  s += *t++;
1654  s += '|';
1655  }
1656  TEST_STRINGS_EQUAL(s, "|hello|");
1657 
1658  db.commit();
1659  }
1660 
1661  Xapian::Database db_multi;
1662  db_multi.add_database(db);
1663  db_multi.add_database(get_database("apitest_simpledata"));
1664 
1665  // Test iterators for terms which aren't there.
1666  TEST(db_multi.synonyms_begin("abc") == db_multi.synonyms_end("abc"));
1667  TEST(db_multi.synonyms_begin("ghi") == db_multi.synonyms_end("ghi"));
1668  TEST(db_multi.synonyms_begin("zzzzz") == db_multi.synonyms_end("zzzzz"));
1669 
1670  s = "|";
1671  t = db_multi.synonyms_begin("hello");
1672  while (t != db_multi.synonyms_end("hello")) {
1673  s += *t++;
1674  s += '|';
1675  }
1676  TEST_STRINGS_EQUAL(s, "|howdy|");
1677 
1678  TEST(db_multi.synonyms_begin("goodbye") == db_multi.synonyms_end("goodbye"));
1679 
1680  s = "|";
1681  t = db_multi.synonym_keys_begin();
1682  while (t != db_multi.synonym_keys_end()) {
1683  s += *t++;
1684  s += '|';
1685  }
1686  TEST_STRINGS_EQUAL(s, "|hello|");
1687 }
1688 
1689 // Test that adding a document with a really long term gives an error on
1690 // add_document() rather than on commit().
1691 DEFINE_TESTCASE(termtoolong1, writable) {
1692  // Inmemory doesn't impose a limit.
1693  SKIP_TEST_FOR_BACKEND("inmemory");
1694 
1695  Xapian::WritableDatabase db = get_writable_database();
1696 
1697  for (size_t i = 246; i <= 290; ++i) {
1698  tout.str(string());
1699  tout << "Term length " << i << '\n';
1700  Xapian::Document doc;
1701  string term(i, 'X');
1702  doc.add_term(term);
1703  try {
1704  db.add_document(doc);
1705  TEST_AND_EXPLAIN(false, "Expecting exception InvalidArgumentError");
1706  } catch (const Xapian::InvalidArgumentError &e) {
1707  // Check that the max length is correctly expressed in the
1708  // exception message - we've got this wrong in two different ways
1709  // in the past!
1710  tout << e.get_msg() << '\n';
1711  TEST(e.get_msg().find("Term too long (> 245)") != string::npos);
1712  }
1713  }
1714 
1715  for (size_t j = 240; j <= 245; ++j) {
1716  tout.str(string());
1717  tout << "Term length " << j << '\n';
1718  Xapian::Document doc;
1719  string term(j, 'X');
1720  doc.add_term(term);
1721  db.add_document(doc);
1722  }
1723 
1724  db.commit();
1725 
1726  size_t limit = 255;
1727  {
1728  // Currently glass escapes zero bytes from terms in keys for
1729  // some tables, so a term with 128 zero bytes won't work for glass.
1730  Xapian::Document doc;
1731  doc.add_term(string(limit / 2 + 1, '\0'));
1732  db.add_document(doc);
1733  try {
1734  db.commit();
1735  TEST_AND_EXPLAIN(false, "Expecting exception InvalidArgumentError");
1736  } catch (const Xapian::InvalidArgumentError &e) {
1737  // Check that the max length is correctly expressed in the
1738  // exception message - we've got this wrong in two different ways
1739  // in the past!
1740  tout << e.get_msg() << '\n';
1741  string target = " is ";
1742  target += str(limit);
1743  target += " bytes";
1744  TEST(e.get_msg().find(target) != string::npos);
1745  }
1746  }
1747 
1748  // Try adding a document. Regression test for a bug fixed in 1.4.15 - in
1749  // earlier versions the pending changes which caused the
1750  // InvalidArgumentError were left around and a subsequent commit() on the
1751  // same WritableDatabase would also fail with InvalidArgumentError.
1752  Xapian::Document doc;
1753  doc.add_term("ok");
1754  db.add_document(doc);
1755  db.commit();
1756 }
1757 
1759 DEFINE_TESTCASE(postlist7, writable) {
1760  Xapian::WritableDatabase db_w = get_writable_database();
1761 
1762  {
1763  Xapian::Document doc;
1764  doc.add_term("foo", 3);
1765  doc.add_term("zz", 4);
1766  db_w.replace_document(5, doc);
1767  }
1768 
1769  Xapian::PostingIterator p;
1770  p = db_w.postlist_begin("foo");
1771  TEST(p != db_w.postlist_end("foo"));
1772  TEST_EQUAL(*p, 5);
1773  TEST_EQUAL(p.get_wdf(), 3);
1774  TEST_EQUAL(p.get_doclength(), 7);
1775  TEST_EQUAL(p.get_unique_terms(), 2);
1776  ++p;
1777  TEST(p == db_w.postlist_end("foo"));
1778 
1779  {
1780  Xapian::Document doc;
1781  doc.add_term("foo", 1);
1782  doc.add_term("zz", 1);
1783  db_w.replace_document(6, doc);
1784  }
1785 
1786  p = db_w.postlist_begin("foo");
1787  TEST(p != db_w.postlist_end("foo"));
1788  TEST_EQUAL(*p, 5);
1789  TEST_EQUAL(p.get_wdf(), 3);
1790  TEST_EQUAL(p.get_doclength(), 7);
1791  TEST_EQUAL(p.get_unique_terms(), 2);
1792  ++p;
1793  TEST(p != db_w.postlist_end("foo"));
1794  TEST_EQUAL(*p, 6);
1795  TEST_EQUAL(p.get_wdf(), 1);
1796  TEST_EQUAL(p.get_doclength(), 2);
1797  TEST_EQUAL(p.get_unique_terms(), 2);
1798  ++p;
1799  TEST(p == db_w.postlist_end("foo"));
1800 }
1801 
1802 static void
1803 gen_lazytablebug1_db(Xapian::WritableDatabase& db, const string&)
1804 {
1805  Xapian::Document doc;
1806  doc.add_term("foo");
1807  db.add_document(doc);
1808  db.commit();
1809 
1810  string synonym(255, 'x');
1811  char buf[] = " iamafish!!!!!!!!!!";
1812  for (int i = 33; i < 120; ++i) {
1813  db.add_synonym(buf, synonym);
1814  ++buf[0];
1815  }
1816 }
1817 
1818 DEFINE_TESTCASE(lazytablebug1, synonyms) {
1819  Xapian::Database db = get_database("lazytablebug1", gen_lazytablebug1_db);
1820  for (Xapian::TermIterator t = db.synonym_keys_begin(); t != db.synonym_keys_end(); ++t) {
1821  tout << *t << '\n';
1822  }
1823 }
1824 
1826 DEFINE_TESTCASE(cursordelbug1, writable && path) {
1827  static const int terms[] = { 219, 221, 222, 223, 224, 225, 226 };
1828  static const int copies[] = { 74, 116, 199, 21, 45, 155, 189 };
1829 
1830  Xapian::WritableDatabase db;
1831  db = get_named_writable_database("cursordelbug1", string());
1832 
1833  for (size_t i = 0; i < sizeof(terms) / sizeof(terms[0]); ++i) {
1834  Xapian::Document doc;
1835  doc.add_term("XC" + str(terms[i]));
1836  doc.add_term("XTabc");
1837  doc.add_term("XAdef");
1838  doc.add_term("XRghi");
1839  doc.add_term("XYabc");
1840  for (size_t c = copies[i]; c; --c)
1841  db.add_document(doc);
1842  }
1843 
1844  db.commit();
1845 
1846  for (size_t i = 0; i < sizeof(terms) / sizeof(terms[0]); ++i) {
1847  db.delete_document("XC" + str(terms[i]));
1848  }
1849 
1850  db.commit();
1851 
1852  const string & db_path = get_named_writable_database_path("cursordelbug1");
1853  TEST_EQUAL(Xapian::Database::check(db_path), 0);
1854 }
1855 
1859 static void
1860 check_vals(const Xapian::Database & db, const map<Xapian::docid, string> & vals)
1861 {
1862  TEST_EQUAL(db.get_doccount(), vals.size());
1863  if (vals.empty()) return;
1864  TEST_REL(vals.rbegin()->first,<=,db.get_lastdocid());
1865  map<Xapian::docid, string>::const_iterator i;
1866  for (i = vals.begin(); i != vals.end(); ++i) {
1867  tout.str(string());
1868  tout << "Checking value in doc " << i->first << " - should be '" << i->second << "'\n";
1869  Xapian::Document doc = db.get_document(i->first);
1870  string dbval = doc.get_value(1);
1871  TEST_EQUAL(dbval, i->second);
1872  if (dbval.empty()) {
1873  TEST_EQUAL(0, doc.values_count());
1874  TEST_EQUAL(doc.values_begin(), doc.values_end());
1875  } else {
1876  TEST_EQUAL(1, doc.values_count());
1877  Xapian::ValueIterator valit = doc.values_begin();
1878  TEST_NOT_EQUAL(valit, doc.values_end());
1879  TEST_EQUAL(dbval, *valit);
1880  TEST_EQUAL(1, valit.get_valueno());
1881  ++valit;
1882  TEST_EQUAL(valit, doc.values_end());
1883  }
1884  }
1885 }
1886 
1890 DEFINE_TESTCASE(modifyvalues1, writable) {
1891  unsigned int seed = 7;
1892  Xapian::WritableDatabase db = get_writable_database();
1893  // Note: doccount must be coprime with 13
1894  const Xapian::doccount doccount = 1000;
1895  static_assert(doccount % 13 != 0, "doccount divisible by 13");
1896 
1897  map<Xapian::docid, string> vals;
1898 
1899  for (Xapian::doccount num = 1; num <= doccount; ++num) {
1900  tout.str(string());
1901  Xapian::Document doc;
1902  string val = "val" + str(num);
1903  tout << "Setting val '" << val << "' in doc " << num << "\n";
1904  doc.add_value(1, val);
1905  db.add_document(doc);
1906  vals[num] = val;
1907  }
1908  check_vals(db, vals);
1909  db.commit();
1910  check_vals(db, vals);
1911 
1912  // Modify one of the values (this is a regression test which failed with
1913  // the initial implementation of streaming values).
1914  {
1915  Xapian::Document doc;
1916  string val = "newval0";
1917  tout << "Setting val '" << val << "' in doc 2\n";
1918  doc.add_value(1, val);
1919  db.replace_document(2, doc);
1920  vals[2] = val;
1921  check_vals(db, vals);
1922  db.commit();
1923  check_vals(db, vals);
1924  }
1925 
1926  // Check that value doesn't get lost when replacing a document with itself.
1927  {
1928  tout << "Replacing document 1 with itself\n";
1929  Xapian::Document doc = db.get_document(1);
1930  db.replace_document(1, doc);
1931  check_vals(db, vals);
1932  db.commit();
1933  check_vals(db, vals);
1934  }
1935 
1936  // Check that value doesn't get lost when replacing a document with itself,
1937  // accessing another document in the meantime. This is a regression test
1938  // for a bug in the code which implements lazy updates - this used to
1939  // forget the values in the document in this situation.
1940  {
1941  tout << "Replacing document 1 with itself, after reading doc 2.\n";
1942  Xapian::Document doc = db.get_document(1);
1943  db.get_document(2);
1944  db.replace_document(1, doc);
1945  check_vals(db, vals);
1946  db.commit();
1947  check_vals(db, vals);
1948  }
1949 
1950  // Do some random modifications: seed random generator, for repeatable
1951  // results.
1952  tout << "Setting seed to " << seed << "\n";
1953  srand(seed);
1954  for (Xapian::doccount num = 1; num <= doccount * 2; ++num) {
1955  tout.str(string());
1956  Xapian::docid did = ((rand() >> 8) % doccount) + 1;
1957  Xapian::Document doc;
1958  string val;
1959 
1960  if (num % 5 != 0) {
1961  val = "newval" + str(num);
1962  tout << "Setting val '" << val << "' in doc " << did << "\n";
1963  doc.add_value(1, val);
1964  } else {
1965  tout << "Adding/replacing empty document " << did << "\n";
1966  }
1967  db.replace_document(did, doc);
1968  vals[did] = val;
1969  }
1970  check_vals(db, vals);
1971  db.commit();
1972  check_vals(db, vals);
1973 
1974  // Delete all the remaining values, in a slightly shuffled order.
1975  // This is where it's important that doccount is coprime with 13.
1976  for (Xapian::doccount num = 0; num < doccount * 13; num += 13) {
1977  tout.str(string());
1978  Xapian::docid did = (num % doccount) + 1;
1979  tout << "Clearing val in doc " << did << "\n";
1980  Xapian::Document doc;
1981  db.replace_document(did, doc);
1982  vals[did] = string();
1983  }
1984  check_vals(db, vals);
1985  db.commit();
1986  check_vals(db, vals);
1987 }
1988 
2002 DEFINE_TESTCASE(protocolbug1, remote && writable) {
2003  Xapian::WritableDatabase db = get_writable_database("");
2004  Xapian::Document doc;
2005  doc.add_term(string(300, 'x'));
2006 
2007  TEST_EXCEPTION(Xapian::InvalidArgumentError,
2008  db.replace_document(1, doc));
2009  db.commit();
2010 }
2011 
2012 DEFINE_TESTCASE(remotefdleak1, remote && writable) {
2013  Xapian::WritableDatabase wdb = get_writable_database("");
2014  TEST_EXCEPTION(Xapian::DatabaseLockError,
2015  auto wdb2 = get_writable_database_again());
2016 }
2017 
2018 // Test handling of corrupted item sizes.
2019 DEFINE_TESTCASE(corruptglass2, glass) {
2020  string src_db_path =
2021  test_driver::get_srcdir() + "/testdata/glass_corrupt_item_too_bigX";
2022 
2023  string db_path = get_named_writable_database_path("corruptglass2");
2024 
2025  for (int n = '1'; n <= '2'; ++n) {
2026  src_db_path.back() = n;
2027  rm_rf(db_path);
2028  cp_R(src_db_path, db_path);
2029  TEST_EXCEPTION(Xapian::DatabaseCorruptError,
2030  Xapian::Database::check(db_path));
2031 
2032  Xapian::WritableDatabase wdb(db_path);
2033  Xapian::Document doc;
2034  doc.set_data("hello world");
2035  TEST_EXCEPTION(Xapian::DatabaseCorruptError,
2036  wdb.add_document(doc));
2037  }
2038 }
query
static Xapian::Query query(Xapian::Query::op op, const string &t1=string(), const string &t2=string(), const string &t3=string(), const string &t4=string(), const string &t5=string(), const string &t6=string(), const string &t7=string(), const string &t8=string(), const string &t9=string(), const string &t10=string())
Definition: api_anydb.cc:62
gen_synonym_merge1b_db
static void gen_synonym_merge1b_db(Xapian::WritableDatabase &db, const string &)
Definition: api_wrdb.cc:1547
gen_synonym_merge1a_db
static void gen_synonym_merge1a_db(Xapian::WritableDatabase &db, const string &)
Definition: api_wrdb.cc:1538
test_emptyterm2_helper
static void test_emptyterm2_helper(Xapian::WritableDatabase &db)
Definition: api_wrdb.cc:1316
gen_consistency2_db
static void gen_consistency2_db(Xapian::WritableDatabase &db, const string &)
Definition: api_wrdb.cc:1461
gen_lazytablebug1_db
static void gen_lazytablebug1_db(Xapian::WritableDatabase &db, const string &)
Definition: api_wrdb.cc:1803
DEFINE_TESTCASE
DEFINE_TESTCASE(adddoc1, writable)
Definition: api_wrdb.cc:57
gen_longpositionlist1_db
static void gen_longpositionlist1_db(Xapian::WritableDatabase &db, const string &)
Definition: api_wrdb.cc:1360
check_vals
static void check_vals(const Xapian::Database &db, const map< Xapian::docid, string > &vals)
Helper function for modifyvalues1.
Definition: api_wrdb.cc:1860
api_wrdb.h
get_writable_database_as_database
Xapian::Database get_writable_database_as_database()
Definition: apitest.cc:126
get_writable_database
Xapian::WritableDatabase get_writable_database(const string &dbname)
Definition: apitest.cc:86
get_named_writable_database_path
std::string get_named_writable_database_path(const std::string &name)
Definition: apitest.cc:98
get_writable_database_again
Xapian::WritableDatabase get_writable_database_again()
Definition: apitest.cc:132
get_database
Xapian::Database get_database(const string &dbname)
Definition: apitest.cc:47
get_named_writable_database
Xapian::WritableDatabase get_named_writable_database(const std::string &name, const std::string &source)
Definition: apitest.cc:92
apitest.h
test functionality of the Xapian API
SKIP_TEST_FOR_BACKEND
#define SKIP_TEST_FOR_BACKEND(B)
Definition: apitest.h:84
Xapian::DatabaseCorruptError
DatabaseCorruptError indicates database corruption was detected.
Definition: error.h:397
Xapian::DatabaseError
DatabaseError indicates some sort of database related error.
Definition: error.h:355
Xapian::DatabaseLockError
DatabaseLockError indicates failure to lock a database.
Definition: error.h:481
Xapian::Database
An indexed database of documents.
Definition: database.h:75
Xapian::Database::get_termfreq
Xapian::doccount get_termfreq(std::string_view term) const
Get the number of documents indexed by a specified term.
Definition: database.cc:262
Xapian::Database::synonym_keys_begin
Xapian::TermIterator synonym_keys_begin(std::string_view prefix={}) const
An iterator which returns all terms which have synonyms.
Definition: database.cc:484
Xapian::Database::check
static size_t check(std::string_view path, int opts=0, std::ostream *out=NULL)
Check the integrity of a database or database table.
Definition: database.h:669
Xapian::Database::positionlist_end
PositionIterator positionlist_end(Xapian::docid, std::string_view) const noexcept
End iterator corresponding to positionlist_begin().
Definition: database.h:292
Xapian::Database::postlist_begin
PostingIterator postlist_begin(std::string_view term) const
Start iterating the postings of a term.
Definition: database.cc:192
Xapian::Database::termlist_begin
TermIterator termlist_begin(Xapian::docid did) const
Start iterating the terms in a document.
Definition: database.cc:200
Xapian::Database::get_avlength
double get_avlength() const
Old name for get_average_length() for backward compatibility.
Definition: database.h:322
Xapian::Database::positionlist_begin
PositionIterator positionlist_begin(Xapian::docid did, std::string_view term) const
Start iterating positions for a term in a document.
Definition: database.cc:221
Xapian::Database::size
size_t size() const
Return number of shards in this Database object.
Definition: database.cc:105
Xapian::Database::synonyms_end
Xapian::TermIterator synonyms_end(std::string_view) const noexcept
End iterator corresponding to synonyms_begin(term).
Definition: database.h:514
Xapian::Database::add_database
void add_database(const Database &other)
Add shards from another Database.
Definition: database.h:109
Xapian::Database::synonym_keys_end
Xapian::TermIterator synonym_keys_end(std::string_view={}) const noexcept
End iterator corresponding to synonym_keys_begin(prefix).
Definition: database.h:526
Xapian::Database::get_doclength
Xapian::termcount get_doclength(Xapian::docid did) const
Get the length of a specified document.
Definition: database.cc:341
Xapian::Database::term_exists
bool term_exists(std::string_view term) const
Test is a particular term is present in any document.
Definition: database.cc:378
Xapian::Database::allterms_end
TermIterator allterms_end(std::string_view={}) const noexcept
End iterator corresponding to allterms_begin(prefix).
Definition: database.h:307
Xapian::Database::has_positions
bool has_positions() const
Does this database have any positional information?
Definition: database.cc:215
Xapian::Database::get_collection_freq
Xapian::termcount get_collection_freq(std::string_view term) const
Get the total number of occurrences of a specified term.
Definition: database.cc:273
Xapian::Database::get_doccount
Xapian::doccount get_doccount() const
Get the number of documents in the database.
Definition: database.cc:233
Xapian::Database::postlist_end
PostingIterator postlist_end(std::string_view) const noexcept
End iterator corresponding to postlist_begin().
Definition: database.h:258
Xapian::Database::get_lastdocid
Xapian::docid get_lastdocid() const
Get the highest document id which has been used in the database.
Definition: database.cc:239
Xapian::Database::allterms_begin
TermIterator allterms_begin(std::string_view prefix={}) const
Start iterating all terms in the database with a given prefix.
Definition: database.cc:209
Xapian::Database::synonyms_begin
Xapian::TermIterator synonyms_begin(std::string_view term) const
An iterator which returns all the synonyms for a given term.
Definition: database.cc:478
Xapian::Database::reopen
bool reopen()
Reopen the database at the latest available revision.
Definition: database.cc:93
Xapian::Database::get_document
Xapian::Document get_document(Xapian::docid did, unsigned flags=0) const
Get a document from the database.
Definition: database.cc:368
Xapian::Database::get_unique_terms
Xapian::termcount get_unique_terms(Xapian::docid did) const
Get the number of unique terms in a specified document.
Definition: database.cc:350
Xapian::DocNotFoundError
Indicates an attempt to access a document not present in the database.
Definition: error.h:662
Xapian::Document
Class representing a document.
Definition: document.h:64
Xapian::Document::set_data
void set_data(std::string_view data)
Set the document data.
Definition: document.cc:81
Xapian::Document::get_data
std::string get_data() const
Get the document data.
Definition: document.cc:75
Xapian::Document::add_term
void add_term(std::string_view term, Xapian::termcount wdf_inc=1)
Add a term to this document.
Definition: document.cc:87
Xapian::Document::values_count
Xapian::valueno values_count() const
Count the value slots used in this document.
Definition: document.cc:203
Xapian::Document::values_begin
ValueIterator values_begin() const
Start iterating the values in this document.
Definition: document.cc:208
Xapian::Document::get_value
std::string get_value(Xapian::valueno slot) const
Read a value slot in this document.
Definition: document.cc:185
Xapian::Document::remove_term
void remove_term(std::string_view term)
Remove a term from this document.
Definition: document.cc:96
Xapian::Document::remove_posting
void remove_posting(std::string_view term, Xapian::termpos term_pos, Xapian::termcount wdf_dec=1)
Remove posting for a term.
Definition: document.cc:122
Xapian::Document::termlist_end
TermIterator termlist_end() const noexcept
End iterator corresponding to termlist_begin().
Definition: document.h:219
Xapian::Document::termlist_begin
TermIterator termlist_begin() const
Start iterating the terms in this document.
Definition: document.cc:179
Xapian::Document::values_end
ValueIterator values_end() const noexcept
End iterator corresponding to values_begin().
Definition: document.h:259
Xapian::Document::add_value
void add_value(Xapian::valueno slot, std::string_view value)
Add a value to a slot in this document.
Definition: document.cc:191
Xapian::Document::add_posting
void add_posting(std::string_view term, Xapian::termpos term_pos, Xapian::termcount wdf_inc=1)
Add a posting for a term.
Definition: document.cc:111
Xapian::Enquire
Querying session.
Definition: enquire.h:57
Xapian::Enquire::get_mset
MSet get_mset(doccount first, doccount maxitems, doccount checkatleast=0, const RSet *rset=NULL, const MatchDecider *mdecider=NULL) const
Run the query.
Definition: enquire.cc:200
Xapian::Enquire::set_sort_by_value_then_relevance
void set_sort_by_value_then_relevance(valueno sort_key, bool reverse)
Set the sorting to be by value, then by relevance for documents with the same value.
Definition: enquire.cc:123
Xapian::Enquire::set_query
void set_query(const Query &query, termcount query_length=0)
Set the query.
Definition: enquire.cc:72
Xapian::Error::get_msg
const std::string & get_msg() const noexcept
Message giving details of the error, intended for human consumption.
Definition: error.h:111
Xapian::InvalidArgumentError
InvalidArgumentError indicates an invalid parameter value was passed to the API.
Definition: error.h:229
Xapian::InvalidOperationError
InvalidOperationError indicates the API was used in an invalid way.
Definition: error.h:271
Xapian::MSet
Class representing a list of search results.
Definition: mset.h:46
Xapian::MSet::size
Xapian::doccount size() const
Return number of items in this MSet object.
Definition: mset.cc:374
Xapian::PositionIterator
Class for iterating over term positions.
Definition: positioniterator.h:39
Xapian::PostingIterator
Class for iterating over a list of terms.
Definition: postingiterator.h:40
Xapian::PostingIterator::skip_to
void skip_to(Xapian::docid did)
Advance the iterator to document did.
Definition: postingiterator.cc:150
Xapian::Query
Class representing a query.
Definition: query.h:45
Xapian::TermIterator
Class for iterating over a list of terms.
Definition: termiterator.h:41
Xapian::TermIterator::positionlist_end
PositionIterator positionlist_end() const noexcept
Return an end PositionIterator for the current term.
Definition: termiterator.h:109
Xapian::TermIterator::get_termfreq
Xapian::doccount get_termfreq() const
Return the term frequency for the term at the current position.
Definition: termiterator.cc:119
Xapian::TermIterator::get_wdf
Xapian::termcount get_wdf() const
Return the wdf for the term at the current position.
Definition: termiterator.cc:111
Xapian::TermIterator::positionlist_begin
PositionIterator positionlist_begin() const
Return a PositionIterator for the current term.
Definition: termiterator.cc:135
Xapian::ValueIterator
Class for iterating over document values.
Definition: valueiterator.h:39
Xapian::ValueIterator::get_valueno
Xapian::valueno get_valueno() const
Return the value slot number for the current position.
Definition: valueiterator.cc:111
Xapian::WritableDatabase
This class provides read/write access to a database.
Definition: database.h:964
Xapian::WritableDatabase::delete_document
void delete_document(Xapian::docid did)
Delete a document from the database.
Definition: database.cc:567
Xapian::WritableDatabase::clear_synonyms
void clear_synonyms(std::string_view term) const
Remove all synonyms for a term.
Definition: database.cc:628
Xapian::WritableDatabase::add_synonym
void add_synonym(std::string_view term, std::string_view synonym) const
Add a synonym for a term.
Definition: database.cc:614
Xapian::WritableDatabase::replace_document
void replace_document(Xapian::docid did, const Xapian::Document &document)
Replace a document in the database.
Definition: database.cc:582
Xapian::WritableDatabase::commit
void commit()
Commit pending modifications.
Definition: database.cc:543
Xapian::WritableDatabase::add_document
Xapian::docid add_document(const Xapian::Document &doc)
Add a document to the database.
Definition: database.cc:561
Xapian::WritableDatabase::remove_synonym
void remove_synonym(std::string_view term, std::string_view synonym) const
Remove a synonym for a term.
Definition: database.cc:621
test_driver::get_srcdir
static std::string get_srcdir()
Read srcdir from environment and if not present, make a valiant attempt to guess a value.
Definition: testsuite.cc:135
term
string term
Definition: databaseinternal.cc:439
p
PositionList * p
Definition: databaseinternal.cc:437
filetests.h
Utility functions for testing files.
Xapian::Internal::str
string str(int value)
Convert int to std::string.
Definition: str.cc:91
Xapian::termcount
unsigned XAPIAN_TERMCOUNT_BASE_TYPE termcount
A counts of terms.
Definition: types.h:64
Xapian::doccount
unsigned XAPIAN_DOCID_BASE_TYPE doccount
A count of documents.
Definition: types.h:37
Xapian::docid
unsigned XAPIAN_DOCID_BASE_TYPE docid
A unique identifier for a document.
Definition: types.h:51
Xapian::termpos
unsigned XAPIAN_TERMPOS_BASE_TYPE termpos
A term position within a document or query.
Definition: types.h:75
negate_unsigned.h
Negate unsigned integer, avoiding compiler warnings.
negate_unsigned
constexpr std::enable_if_t< std::is_unsigned_v< T >, T > negate_unsigned(T value)
Definition: negate_unsigned.h:35
omassert.h
Various assertion macros.
safeunistd.h
<unistd.h>, but with compat.
seed
static int seed
Definition: stemtest.cc:46
str.h
Convert types to std::string.
stringutils.h
Various handy string-related helpers.
TEST_REL
#define TEST_REL(A, REL, B)
Test a relation holds,e.g. TEST_REL(a,>,b);.
Definition: testmacros.h:35
tout
std::ostringstream tout
The debug printing stream.
Definition: testsuite.cc:104
testsuite.h
a generic test suite engine
FAIL_TEST
#define FAIL_TEST(MSG)
Fail the current testcase with message MSG.
Definition: testsuite.h:65
TEST_EQUAL
#define TEST_EQUAL(a, b)
Test for equality of two things.
Definition: testsuite.h:276
TEST_STRINGS_EQUAL
#define TEST_STRINGS_EQUAL(a, b)
Test for equality of two strings.
Definition: testsuite.h:285
TEST
#define TEST(a)
Test a condition, without an additional explanation for failure.
Definition: testsuite.h:273
TEST_NOT_EQUAL
#define TEST_NOT_EQUAL(a, b)
Test for non-equality of two things.
Definition: testsuite.h:303
TEST_AND_EXPLAIN
#define TEST_AND_EXPLAIN(a, b)
Test a condition, and display the test with an extra explanation if the condition fails.
Definition: testsuite.h:265
mset_expect_order
void mset_expect_order(const Xapian::MSet &A, Xapian::docid d1, Xapian::docid d2, Xapian::docid d3, Xapian::docid d4, Xapian::docid d5, Xapian::docid d6, Xapian::docid d7, Xapian::docid d8, Xapian::docid d9, Xapian::docid d10, Xapian::docid d11, Xapian::docid d12)
Definition: testutils.cc:224
testutils.h
Xapian-specific test helper functions and macros.
TEST_EXCEPTION
#define TEST_EXCEPTION(TYPE, CODE)
Check that CODE throws exactly Xapian exception TYPE.
Definition: testutils.h:112
cp_R
void cp_R(const std::string &src, const std::string &dest)
Recursively copy a directory.
Definition: unixcmds.cc:67
rm_rf
void rm_rf(const string &filename)
Remove a directory and contents, just like the Unix "rm -rf" command.
Definition: unixcmds.cc:111
unixcmds.h
C++ function versions of useful Unix commands.
xapian.h
Public interfaces for the Xapian library.
Generated by Doxygen 1.9.1