xapian-core  1.4.19
api_nodb.cc
Go to the documentation of this file.
1 
4 /* Copyright 1999,2000,2001 BrightStation PLC
5  * Copyright 2002 Ananova Ltd
6  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010,2015,2016,2017,2019 Olly Betts
7  * Copyright 2006 Lemur Consulting Ltd
8  * Copyright (C) 2016 Vivek Pal
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; either version 2 of the
13  * License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
23  * USA
24  */
25 
26 #include <config.h>
27 
28 #include "api_nodb.h"
29 
30 #include <xapian.h>
31 
32 #include "apitest.h"
33 #include "testsuite.h"
34 #include "testutils.h"
35 
36 #include <list>
37 #include <string>
38 #include <vector>
39 
40 using namespace std;
41 
42 // always succeeds
43 DEFINE_TESTCASE(trivial1, !backend) {
44 }
45 
46 // tests that get_query_terms() returns the terms in the right order
47 DEFINE_TESTCASE(getqterms1, !backend) {
48  list<string> answers_list;
49  answers_list.push_back("one");
50  answers_list.push_back("two");
51  answers_list.push_back("three");
52  answers_list.push_back("four");
53 
56  Xapian::Query("one", 1, 1),
57  Xapian::Query("three", 1, 3)),
59  Xapian::Query("four", 1, 4),
60  Xapian::Query("two", 1, 2)));
61 
62  list<string> list1;
63  {
65  for (t = myquery.get_terms_begin(); t != myquery.get_terms_end(); ++t)
66  list1.push_back(*t);
67  }
68  TEST(list1 == answers_list);
69  list<string> list2(myquery.get_terms_begin(), myquery.get_terms_end());
70  TEST(list2 == answers_list);
71 }
72 
73 // tests that get_query_terms() doesn't SEGV on an empty query
74 // (regression test for bug in 0.9.0)
75 DEFINE_TESTCASE(getqterms2, !backend) {
76  Xapian::Query empty_query;
77  TEST_EQUAL(empty_query.get_terms_begin(), empty_query.get_terms_end());
78  TEST_EQUAL(empty_query.get_unique_terms_begin(),
79  empty_query.get_unique_terms_end());
80 }
81 
82 // tests that empty queries work correctly
83 DEFINE_TESTCASE(emptyquery2, !backend) {
84  // test that Query::empty() is true for an empty query.
85  TEST(Xapian::Query().empty());
86  // test that an empty query has length 0
87  TEST(Xapian::Query().get_length() == 0);
88  vector<Xapian::Query> v;
89  TEST(Xapian::Query(Xapian::Query::OP_OR, v.begin(), v.end()).empty());
90  TEST(Xapian::Query(Xapian::Query::OP_OR, v.begin(), v.end()).get_length() == 0);
91 }
92 
94 DEFINE_TESTCASE(emptyquery3, !backend) {
95  static const Xapian::Query::op ops[] = {
101  };
102 
103  for (size_t i = 0; i < sizeof(ops) / sizeof(ops[0]); ++i) {
104  tout << "Testing op #" << i << endl;
105  Xapian::Query empty;
106  Xapian::Query q("test");
107  Xapian::Query qcombine(ops[i], empty, q);
108  tout << qcombine.get_description() << endl;
109  Xapian::Query qcombine2(ops[i], q, empty);
110  tout << qcombine2.get_description() << endl;
111  Xapian::Query qcombine3(ops[i], empty, empty);
112  tout << qcombine3.get_description() << endl;
113  }
114 }
115 
116 // tests that query lengths are calculated correctly
117 DEFINE_TESTCASE(querylen1, !backend) {
118  // test that a simple query has the right length
119  Xapian::Query myquery;
121  Xapian::Query("foo"),
122  Xapian::Query("bar"));
124  myquery,
126  Xapian::Query("wibble"),
127  Xapian::Query("spoon")));
128 
129  TEST_EQUAL(myquery.get_length(), 4);
130  TEST(!myquery.empty());
131 }
132 
133 // tests that query lengths are calculated correctly
134 DEFINE_TESTCASE(querylen2, !backend) {
135  // test with an even bigger and strange query
136  string terms[3] = {
137  "foo",
138  "bar",
139  "baz"
140  };
141  Xapian::Query queries[3] = {
142  Xapian::Query("wibble"),
143  Xapian::Query("wobble"),
144  Xapian::Query(Xapian::Query::OP_OR, string("jelly"), string("belly"))
145  };
146 
147  Xapian::Query myquery;
148  vector<string> v1(terms, terms + 3);
149  vector<Xapian::Query> v2(queries, queries + 3);
150  vector<Xapian::Query *> v3;
151  Xapian::Query query1(Xapian::Query::OP_AND, string("ball"), string("club"));
152  Xapian::Query query2("ring");
153  v3.push_back(&query1);
154  v3.push_back(&query2);
155 
156  Xapian::Query myq1 = Xapian::Query(Xapian::Query::OP_AND, v1.begin(), v1.end());
157  tout << "myq1=" << myq1 << "\n";
158  TEST_EQUAL(myq1.get_length(), 3);
159 
160  Xapian::Query myq2_1 = Xapian::Query(Xapian::Query::OP_OR, v2.begin(), v2.end());
161  tout << "myq2_1=" << myq2_1 << "\n";
162  TEST_EQUAL(myq2_1.get_length(), 4);
163 
164  Xapian::Query myq2_2 = Xapian::Query(Xapian::Query::OP_AND, v3.begin(), v3.end());
165  tout << "myq2_2=" << myq2_2 << "\n";
166  TEST_EQUAL(myq2_2.get_length(), 3);
167 
168  Xapian::Query myq2 = Xapian::Query(Xapian::Query::OP_OR, myq2_1, myq2_2);
169  tout << "myq2=" << myq2 << "\n";
170  TEST_EQUAL(myq2.get_length(), 7);
171 
172  myquery = Xapian::Query(Xapian::Query::OP_OR, myq1, myq2);
173  tout << "myquery=" << myquery << "\n";
174  TEST_EQUAL(myquery.get_length(), 10);
175 }
176 
177 // tests that queries validate correctly
178 DEFINE_TESTCASE(queryvalid1, !backend) {
180  tout << "XOR (\"foo\", \"bar\") checked" << endl;
181 }
182 
189 DEFINE_TESTCASE(dontflattensubqueries1, !backend) {
190  Xapian::Query queries1[3] = {
191  Xapian::Query("wibble"),
192  Xapian::Query("wobble"),
193  Xapian::Query(Xapian::Query::OP_OR, string("jelly"), string("belly"))
194  };
195 
196  Xapian::Query queries2[3] = {
197  Xapian::Query(Xapian::Query::OP_AND, string("jelly"), string("belly")),
198  Xapian::Query("wibble"),
199  Xapian::Query("wobble")
200  };
201 
202  vector<Xapian::Query> vec1(queries1, queries1 + 3);
203  Xapian::Query myquery1(Xapian::Query::OP_OR, vec1.begin(), vec1.end());
204  TEST_EQUAL(myquery1.get_description(),
205  "Query((wibble OR wobble OR (jelly OR belly)))");
206 
207  vector<Xapian::Query> vec2(queries2, queries2 + 3);
208  Xapian::Query myquery2(Xapian::Query::OP_AND, vec2.begin(), vec2.end());
209  TEST_EQUAL(myquery2.get_description(),
210  "Query(((jelly AND belly) AND wibble AND wobble))");
211 }
212 
213 // test behaviour when creating a query from an empty vector
214 DEFINE_TESTCASE(emptyquerypart1, !backend) {
215  vector<string> emptyterms;
216  Xapian::Query query(Xapian::Query::OP_OR, emptyterms.begin(), emptyterms.end());
218  TEST(Xapian::Query(Xapian::Query::OP_AND, query, Xapian::Query("x")).get_length() == 0);
220  TEST(Xapian::Query(Xapian::Query::OP_OR, query, Xapian::Query("x")).get_length() == 1);
221 }
222 
223 DEFINE_TESTCASE(stemlangs1, !backend) {
224  string langs = Xapian::Stem::get_available_languages();
225  tout << "available languages '" << langs << "'" << endl;
226  TEST(!langs.empty());
227 
228  // Also test the language codes.
229  langs += " ar hy eu ca da nl en fi fr de hu id ga it lt ne nb nn no pt ro"
230  " ru es sv ta tr";
231 
232  string::size_type i = 0;
233  while (true) {
234  string::size_type spc = langs.find(' ', i);
235  // The only spaces in langs should be a single one between each pair
236  // of language names.
237  TEST_NOT_EQUAL(i, spc);
238 
239  // Try making a stemmer for this language. We should be able to create
240  // it without an exception being thrown.
241  string language(langs, i, spc - i);
242  tout << "checking language code '" << language << "' works" << endl;
243  Xapian::Stem stemmer(language);
244  TEST(!stemmer.is_none());
245  if (language.size() > 2) {
246  string expected("Xapian::Stem(");
247  expected += language;
248  expected += ')';
249  TEST_EQUAL(stemmer.get_description(), expected);
250  }
251 
252  if (spc == string::npos) break;
253  i = spc + 1;
254  }
255 
256  {
257  // Stem("none") should give a no-op stemmer.
258  Xapian::Stem stem_nothing = Xapian::Stem("none");
259  TEST(stem_nothing.is_none());
260  TEST_EQUAL(stem_nothing.get_description(), "Xapian::Stem(none)");
261  }
262 
263  {
264  // Stem("") should be equivalent.
265  Xapian::Stem stem_nothing = Xapian::Stem("");
266  TEST(stem_nothing.is_none());
267  TEST_EQUAL(stem_nothing.get_description(), "Xapian::Stem(none)");
268  }
269 }
270 
271 // Some simple tests of the built in weighting schemes.
272 DEFINE_TESTCASE(weight1, !backend) {
273  Xapian::Weight * wt;
274 
275  Xapian::BoolWeight boolweight;
276  TEST_EQUAL(boolweight.name(), "Xapian::BoolWeight");
277  wt = Xapian::BoolWeight().unserialise(boolweight.serialise());
278  TEST_EQUAL(boolweight.serialise(), wt->serialise());
279  delete wt;
280 
281  Xapian::CoordWeight coordweight;
282  TEST_EQUAL(coordweight.name(), "Xapian::CoordWeight");
283  wt = Xapian::CoordWeight().unserialise(coordweight.serialise());
284  TEST_EQUAL(coordweight.serialise(), wt->serialise());
285  delete wt;
286 
287  Xapian::TradWeight tradweight_dflt;
288  Xapian::TradWeight tradweight(1.0);
289  TEST_EQUAL(tradweight.name(), "Xapian::TradWeight");
290  TEST_EQUAL(tradweight_dflt.serialise(), tradweight.serialise());
291  wt = Xapian::TradWeight().unserialise(tradweight.serialise());
292  TEST_EQUAL(tradweight.serialise(), wt->serialise());
293  delete wt;
294 
295  Xapian::TradWeight tradweight2(2.0);
296  TEST_NOT_EQUAL(tradweight.serialise(), tradweight2.serialise());
297 
298  Xapian::BM25Weight bm25weight_dflt;
299  Xapian::BM25Weight bm25weight(1, 0, 1, 0.5, 0.5);
300  TEST_EQUAL(bm25weight.name(), "Xapian::BM25Weight");
301  TEST_EQUAL(bm25weight_dflt.serialise(), bm25weight.serialise());
302  wt = Xapian::BM25Weight().unserialise(bm25weight.serialise());
303  TEST_EQUAL(bm25weight.serialise(), wt->serialise());
304  delete wt;
305 
306  Xapian::BM25Weight bm25weight2(1, 0.5, 1, 0.5, 0.5);
307  TEST_NOT_EQUAL(bm25weight.serialise(), bm25weight2.serialise());
308 
309  Xapian::BM25PlusWeight bm25plusweight_dflt;
310  Xapian::BM25PlusWeight bm25plusweight(1, 0, 1, 0.5, 0.5, 1.0);
311  TEST_EQUAL(bm25plusweight.name(), "Xapian::BM25PlusWeight");
312  TEST_EQUAL(bm25plusweight_dflt.serialise(), bm25plusweight.serialise());
313  wt = Xapian::BM25PlusWeight().unserialise(bm25plusweight.serialise());
314  TEST_EQUAL(bm25plusweight.serialise(), wt->serialise());
315  delete wt;
316 
317  Xapian::BM25PlusWeight bm25plusweight2(1, 0, 1, 0.5, 0.5, 2.0);
318  TEST_NOT_EQUAL(bm25plusweight.serialise(), bm25plusweight2.serialise());
319 
320  Xapian::TfIdfWeight tfidfweight_dflt;
321  Xapian::TfIdfWeight tfidfweight("ntn");
322  TEST_EQUAL(tfidfweight.name(), "Xapian::TfIdfWeight");
323  TEST_EQUAL(tfidfweight_dflt.serialise(), tfidfweight.serialise());
324  wt = Xapian::TfIdfWeight().unserialise(tfidfweight.serialise());
325  TEST_EQUAL(tfidfweight.serialise(), wt->serialise());
326  delete wt;
327 
328  Xapian::TfIdfWeight tfidfweight2("bpn");
329  TEST_NOT_EQUAL(tfidfweight.serialise(), tfidfweight2.serialise());
330 
331  Xapian::InL2Weight inl2weight_dflt;
332  Xapian::InL2Weight inl2weight(1.0);
333  TEST_EQUAL(inl2weight.name(), "Xapian::InL2Weight");
334  TEST_EQUAL(inl2weight_dflt.serialise(), inl2weight.serialise());
335  wt = Xapian::InL2Weight().unserialise(inl2weight.serialise());
336  TEST_EQUAL(inl2weight.serialise(), wt->serialise());
337  delete wt;
338 
339  Xapian::InL2Weight inl2weight2(2.0);
340  TEST_NOT_EQUAL(inl2weight.serialise(), inl2weight2.serialise());
341 
342  Xapian::IfB2Weight ifb2weight_dflt;
343  Xapian::IfB2Weight ifb2weight(1.0);
344  TEST_EQUAL(ifb2weight.name(), "Xapian::IfB2Weight");
345  TEST_EQUAL(ifb2weight_dflt.serialise(), ifb2weight.serialise());
346  wt = Xapian::IfB2Weight().unserialise(ifb2weight.serialise());
347  TEST_EQUAL(ifb2weight.serialise(), wt->serialise());
348  delete wt;
349 
350  Xapian::IfB2Weight ifb2weight2(2.0);
351  TEST_NOT_EQUAL(ifb2weight.serialise(), ifb2weight2.serialise());
352 
353  Xapian::IneB2Weight ineb2weight_dflt;
354  Xapian::IneB2Weight ineb2weight(1.0);
355  TEST_EQUAL(ineb2weight.name(), "Xapian::IneB2Weight");
356  TEST_EQUAL(ineb2weight_dflt.serialise(), ineb2weight.serialise());
357  wt = Xapian::IneB2Weight().unserialise(ineb2weight.serialise());
358  TEST_EQUAL(ineb2weight.serialise(), wt->serialise());
359  delete wt;
360 
361  Xapian::IneB2Weight ineb2weight2(2.0);
362  TEST_NOT_EQUAL(ineb2weight.serialise(), ineb2weight2.serialise());
363 
364  Xapian::BB2Weight bb2weight_dflt;
365  Xapian::BB2Weight bb2weight(1.0);
366  TEST_EQUAL(bb2weight.name(), "Xapian::BB2Weight");
367  TEST_EQUAL(bb2weight_dflt.serialise(), bb2weight.serialise());
368  wt = Xapian::BB2Weight().unserialise(bb2weight.serialise());
369  TEST_EQUAL(bb2weight.serialise(), wt->serialise());
370  delete wt;
371 
372  Xapian::BB2Weight bb2weight2(2.0);
373  TEST_NOT_EQUAL(bb2weight.serialise(), bb2weight2.serialise());
374 
375  Xapian::DLHWeight dlhweight;
376  TEST_EQUAL(dlhweight.name(), "Xapian::DLHWeight");
377  wt = Xapian::DLHWeight().unserialise(dlhweight.serialise());
378  TEST_EQUAL(dlhweight.serialise(), wt->serialise());
379  delete wt;
380 
381  Xapian::PL2Weight pl2weight_dflt;
382  Xapian::PL2Weight pl2weight(1.0);
383  TEST_EQUAL(pl2weight.name(), "Xapian::PL2Weight");
384  TEST_EQUAL(pl2weight_dflt.serialise(), pl2weight.serialise());
385  wt = Xapian::PL2Weight().unserialise(pl2weight.serialise());
386  TEST_EQUAL(pl2weight.serialise(), wt->serialise());
387  delete wt;
388 
389  Xapian::PL2Weight pl2weight2(2.0);
390  TEST_NOT_EQUAL(pl2weight.serialise(), pl2weight2.serialise());
391 
392  Xapian::PL2PlusWeight pl2plusweight_dflt;
393  Xapian::PL2PlusWeight pl2plusweight(1.0, 0.8);
394  TEST_EQUAL(pl2plusweight.name(), "Xapian::PL2PlusWeight");
395  TEST_EQUAL(pl2plusweight_dflt.serialise(), pl2plusweight.serialise());
396  wt = Xapian::PL2PlusWeight().unserialise(pl2plusweight.serialise());
397  TEST_EQUAL(pl2plusweight.serialise(), wt->serialise());
398  delete wt;
399 
400  Xapian::PL2PlusWeight pl2plusweight2(2.0, 0.9);
401  TEST_NOT_EQUAL(pl2plusweight.serialise(), pl2plusweight2.serialise());
402 
403  Xapian::DPHWeight dphweight;
404  TEST_EQUAL(dphweight.name(), "Xapian::DPHWeight");
405  wt = Xapian::DPHWeight().unserialise(dphweight.serialise());
406  TEST_EQUAL(dphweight.serialise(), wt->serialise());
407  delete wt;
408 
409  Xapian::LMWeight unigramlmweight_dflt;
410  Xapian::LMWeight unigramlmweight(32000, Xapian::Weight::DIRICHLET_SMOOTHING, 2034.0, 0.0);
411  TEST_EQUAL(unigramlmweight.name(), "Xapian::LMWeight");
412  TEST_NOT_EQUAL(unigramlmweight_dflt.serialise(), unigramlmweight.serialise());
413  wt = Xapian::LMWeight().unserialise(unigramlmweight.serialise());
414  TEST_EQUAL(unigramlmweight.serialise(), wt->serialise());
415  delete wt;
416 }
417 
418 // Regression test.
419 DEFINE_TESTCASE(nosuchdb1, !backend) {
420  // This is a "nodb" test because it doesn't test a particular backend.
421  try {
422  Xapian::Database db("NOsuChdaTabASe");
423  FAIL_TEST("Managed to open 'NOsuChdaTabASe'");
424  } catch (const Xapian::DatabaseOpeningError & e) {
425  // We don't really require this exact message, but in Xapian <= 1.1.0
426  // this gave "Couldn't detect type of database".
427  TEST_STRINGS_EQUAL(e.get_msg(), "Couldn't stat 'NOsuChdaTabASe'");
428  }
429 
430  try {
431  Xapian::Database::check("NOsuChdaTabASe");
432  FAIL_TEST("Managed to check 'NOsuChdaTabASe'");
433  } catch (const Xapian::DatabaseOpeningError & e) {
434  // In 1.4.3 and earlier, this threw DatabaseError with the message:
435  // "File is not a Xapian database or database table" (confusing as
436  // there is no file).
438  "Couldn't find Xapian database or table to check");
439  }
440 }
441 
442 // Feature tests for value manipulations.
443 DEFINE_TESTCASE(addvalue1, !backend) {
444  // Regression test for add_value on an existing value (bug#82).
445  Xapian::Document doc;
446  doc.add_value(1, "original");
447  doc.add_value(1, "replacement");
448  TEST_EQUAL(doc.get_value(1), "replacement");
449 
450  doc.add_value(2, "too");
451  doc.add_value(3, "free");
452  doc.add_value(4, "for");
453 
454  doc.remove_value(2);
455  doc.remove_value(4);
456  TEST_EQUAL(doc.get_value(0), "");
457  TEST_EQUAL(doc.get_value(1), "replacement");
458  TEST_EQUAL(doc.get_value(2), "");
459  TEST_EQUAL(doc.get_value(3), "free");
460  TEST_EQUAL(doc.get_value(4), "");
461 }
462 
463 // tests that the collapsing on termpos optimisation gives correct query length
464 DEFINE_TESTCASE(poscollapse2, !backend) {
465  Xapian::Query q(Xapian::Query::OP_OR, Xapian::Query("this", 1, 1), Xapian::Query("this", 1, 1));
466  TEST_EQUAL(q.get_length(), 2);
467 }
468 
469 // regression test of querying an uninitialised database: should report an
470 // error; used to segfault with 1.0.0.
471 DEFINE_TESTCASE(uninitdb1, !backend) {
472  Xapian::Database db;
474  Xapian::Enquire enq(db));
475 }
476 
477 // Test a scaleweight query applied to a match nothing query
478 DEFINE_TESTCASE(scaleweight3, !backend) {
481  TEST_EQUAL(query.get_description(), "Query()");
482 }
483 
484 // Regression test - before 1.1.0, you could add docid 0 to an RSet.
485 DEFINE_TESTCASE(rset3, !backend) {
486  Xapian::RSet rset;
488  TEST(rset.empty());
489  TEST_EQUAL(rset.size(), 0);
490  rset.add_document(1);
491  rset.add_document(static_cast<Xapian::docid>(-1));
493  TEST(!rset.empty());
494  TEST_EQUAL(rset.size(), 2);
495 }
496 
497 // Regression test - RSet::get_description() gave a malformed answer in 1.0.7.
498 DEFINE_TESTCASE(rset4, !backend) {
499  Xapian::RSet rset;
500  rset.add_document(1);
501  // In 1.0.7 this gave: RSet(RSet(RSet::Internal(, 1))
502  TEST_STRINGS_EQUAL(rset.get_description(), "RSet(RSet::Internal(1))");
503 }
504 
505 // Direct test of ValueSetMatchDecider
506 DEFINE_TESTCASE(valuesetmatchdecider1, !backend) {
507  Xapian::ValueSetMatchDecider vsmd1(0, true);
508  vsmd1.add_value("42");
509  Xapian::ValueSetMatchDecider vsmd2(0, false);
510  vsmd2.remove_value("nosuch"); // Test removing a value which isn't present.
511  vsmd2.add_value("42");
512  Xapian::ValueSetMatchDecider vsmd3(0, true);
513  vsmd3.add_value("42");
514  vsmd3.add_value("blah");
515 
516  Xapian::Document doc;
517  TEST(!vsmd1(doc));
518  TEST(vsmd2(doc));
519  TEST(!vsmd3(doc));
520  doc.add_value(0, "42");
521  TEST(vsmd1(doc));
522  TEST(!vsmd2(doc));
523  TEST(vsmd3(doc));
524  doc.add_value(0, "blah");
525  TEST(!vsmd1(doc));
526  TEST(vsmd2(doc));
527  TEST(vsmd3(doc));
528 
529  vsmd3.remove_value("nosuch"); // Test removing a value which isn't present.
530  vsmd3.remove_value("blah");
531  TEST(!vsmd1(doc));
532  TEST(vsmd2(doc));
533  TEST(!vsmd3(doc));
534  doc.add_value(0, "42");
535  TEST(vsmd1(doc));
536  TEST(!vsmd2(doc));
537  TEST(vsmd3(doc));
538 }
539 
540 // Test that asking for the termfreq on an empty mset raises an exception.
541 DEFINE_TESTCASE(emptymset1, !backend) {
542  Xapian::MSet emptymset;
544  emptymset.get_termfreq("foo"));
545 }
546 
547 DEFINE_TESTCASE(expanddeciderfilterprefix1, !backend) {
548  string prefix = "tw";
549  Xapian::ExpandDeciderFilterPrefix decider(prefix);
550  TEST(!decider("one"));
551  TEST(!decider("t"));
552  TEST(!decider(""));
553  TEST(!decider("Two"));
554  TEST(decider("two"));
555  TEST(decider("twitter"));
556  TEST(decider(prefix));
557 }
const TermIterator get_unique_terms_end() const
End iterator for unique terms in the query object.
Definition: query.h:516
Xapian::termcount get_length() const
Return the length of this query object.
Definition: query.cc:187
bool is_none() const
Return true if this is a no-op stemmer.
Definition: stem.h:166
ExpandDecider subclass which restrict terms to a particular prefix.
Xapian::doccount size() const
The number of documents in this R-Set.
Definition: omenquire.cc:92
void add_value(Xapian::valueno slot, const std::string &value)
Add a new value.
Definition: omdocument.cc:107
MatchDecider filtering results based on whether document values are in a user-defined set...
static size_t check(const std::string &path, int opts=0, std::ostream *out=NULL)
Check the integrity of a database or database table.
Definition: database.h:560
#define TEST(a)
Test a condition, without an additional explanation for failure.
Definition: testsuite.h:275
std::string get_description() const
Return a string describing this object.
Definition: omenquire.cc:123
This class is used to access a database, or a group of databases.
Definition: database.h:68
DEFINE_TESTCASE(trivial1, !backend)
Definition: api_nodb.cc:43
Match documents which an odd number of subqueries match.
Definition: query.h:107
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: tradweight.cc:133
InvalidOperationError indicates the API was used in an invalid way.
Definition: error.h:283
const TermIterator get_terms_begin() const
Begin iterator for terms in the query object.
Definition: query.cc:135
InL2Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: inl2weight.cc:103
DatabaseOpeningError indicates failure to open a database.
Definition: error.h:581
Class representing a stemming algorithm.
Definition: stem.h:62
op
Query operators.
Definition: query.h:78
PL2PlusWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
void remove_value(const std::string &value)
Remove a value from the test set.
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
const std::string & get_msg() const
Message giving details of the error, intended for human consumption.
Definition: error.h:122
a generic test suite engine
void add_value(const std::string &value)
Add a value to the test set.
Class representing a list of search results.
Definition: mset.h:44
This class implements the InL2 weighting scheme.
Definition: weight.h:838
STL namespace.
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: inl2weight.cc:97
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: bb2weight.cc:126
BM25PlusWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Xapian::Weight subclass implementing the PL2+ probabilistic formula.
Definition: weight.h:1257
static Xapian::Stem stemmer
Definition: stemtest.cc:41
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: ineb2weight.cc:99
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: tfidfweight.cc:86
void remove_value(Xapian::valueno slot)
Remove any value with the given number.
Definition: omdocument.cc:114
const TermIterator get_unique_terms_begin() const
Begin iterator for unique terms in the query object.
Definition: query.cc:160
test functionality of the Xapian API
std::string name() const
Return the name of this weighting scheme.
Definition: boolweight.cc:44
std::string name() const
Return the name of this weighting scheme.
Definition: bm25weight.cc:132
std::string name() const
Return the name of this weighting scheme.
This class implements the BB2 weighting scheme.
Definition: weight.h:1054
Class for iterating over a list of terms.
Definition: termiterator.h:41
#define TEST_NOT_EQUAL(a, b)
Test for non-equality of two things.
Definition: testsuite.h:305
IfB2Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: ifb2weight.cc:106
Xapian::Weight subclass implementing Coordinate Matching.
Definition: weight.h:1509
BM25Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: bm25weight.cc:149
InvalidArgumentError indicates an invalid parameter value was passed to the API.
Definition: error.h:241
std::string name() const
Return the name of this weighting scheme.
TfIdfWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: tfidfweight.cc:92
Class implementing a "boolean" weighting scheme.
Definition: weight.h:422
std::ostringstream tout
The debug printing stream.
Definition: testsuite.cc:103
Scale the weight contributed by a subquery.
Definition: query.h:166
Match the first subquery taking extra weight from other subqueries.
Definition: query.h:118
std::string get_description() const
Return a string describing this object.
Definition: stem.cc:147
Public interfaces for the Xapian library.
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: lmweight.cc:100
static std::string get_available_languages()
Return a list of available languages.
Definition: stem.h:181
DPHWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: dphweight.cc:128
#define TEST_EXCEPTION(TYPE, CODE)
Check that CODE throws exactly Xapian exception TYPE.
Definition: testutils.h:109
std::string name() const
Return the name of this weighting scheme.
Definition: lmweight.cc:94
IneB2Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: ineb2weight.cc:105
std::string name() const
Return the name of this weighting scheme.
Definition: ifb2weight.cc:94
std::string name() const
Return the name of this weighting scheme.
Definition: inl2weight.cc:91
Xapian::Weight subclass implementing the traditional probabilistic formula.
Definition: weight.h:768
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: pl2weight.cc:138
This class implements the DLH weighting scheme, which is a representative scheme of the Divergence fr...
Definition: weight.h:1130
std::string name() const
Return the name of this weighting scheme.
Definition: pl2weight.cc:132
This class implements the PL2 weighting scheme.
Definition: weight.h:1190
This class implements the IneB2 weighting scheme.
Definition: weight.h:982
BoolWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: boolweight.cc:57
std::string name() const
Return the name of this weighting scheme.
Definition: tradweight.cc:127
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: ifb2weight.cc:100
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: coordweight.cc:50
void add_document(Xapian::docid did)
Add a document to the relevance set.
Definition: omenquire.cc:104
This class implements the IfB2 weighting scheme.
Definition: weight.h:909
#define FAIL_TEST(MSG)
Fail the current testcase with message MSG.
Definition: testsuite.h:68
Match only documents which all subqueries match.
Definition: query.h:84
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:63
std::string name() const
Return the name of this weighting scheme.
Definition: bb2weight.cc:120
std::string get_description() const
Return a string describing this object.
Definition: query.cc:232
This class provides an interface to the information retrieval system for the purpose of searching...
Definition: enquire.h:152
CoordWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: coordweight.cc:57
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: bm25weight.cc:138
PL2Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: pl2weight.cc:144
This class implements the DPH weighting scheme.
Definition: weight.h:1353
bool empty() const
Check if this query is Xapian::Query::MatchNothing.
Definition: query.h:524
Match documents which the first subquery matches but no others do.
Definition: query.h:99
Match documents which at least one subquery matches.
Definition: query.h:92
Xapian-specific test helper functions and macros.
std::string name() const
Return the name of this weighting scheme.
Definition: ineb2weight.cc:93
static const Xapian::Query MatchNothing
A query matching no documents.
Definition: query.h:65
LMWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: lmweight.cc:110
#define TEST_STRINGS_EQUAL(a, b)
Test for equality of two strings.
Definition: testsuite.h:287
Definition: quest.cc:110
static string language
Definition: stemtest.cc:39
Xapian::doccount get_termfreq(const std::string &term) const
Get the termfreq of a term.
Definition: omenquire.cc:206
std::string name() const
Return the name of this weighting scheme.
Definition: coordweight.cc:44
Class representing a query.
Definition: query.h:46
#define TEST_EQUAL(a, b)
Test for equality of two things.
Definition: testsuite.h:278
bool empty() const
Test if this R-Set is empty.
Definition: omenquire.cc:98
Xapian::Weight subclass implementing the Language Model formula.
Definition: weight.h:1406
const TermIterator get_terms_end() const
End iterator for terms in the query object.
Definition: query.h:502
BB2Weight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: bb2weight.cc:132
std::string serialise() const
Return this object&#39;s parameters serialised as a single string.
Definition: boolweight.cc:50
std::string get_value(Xapian::valueno slot) const
Get value by number.
Definition: omdocument.cc:64
A handle representing a document in a Xapian database.
Definition: document.h:61
Xapian::Weight subclass implementing the BM25+ probabilistic formula.
Definition: weight.h:639
std::string name() const
Return the name of this weighting scheme.
Definition: tfidfweight.cc:80
Xapian::Weight subclass implementing the BM25 probabilistic formula.
Definition: weight.h:535
A relevance set (R-Set).
Definition: enquire.h:60
Xapian::Weight subclass implementing the tf-idf weighting scheme.
Definition: weight.h:447
Abstract base class for weighting schemes.
Definition: weight.h:35
TradWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: tradweight.cc:139
DLHWeight * unserialise(const std::string &serialised) const
Unserialise parameters.
Definition: dlhweight.cc:172