git.notmuchmail.org Git - notmuch/blob - lib/query.cc

   1 /* query.cc - Support for searching a notmuch database
   2  *
   3  * Copyright © 2009 Carl Worth
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see https://www.gnu.org/licenses/ .
  17  *
  18  * Author: Carl Worth <cworth@cworth.org>
  19  */
  20
  21 #include "notmuch-private.h"
  22 #include "database-private.h"
  23
  24 #include <glib.h> /* GHashTable, GPtrArray */
  25
  26 struct _notmuch_query {
  27     notmuch_database_t *notmuch;
  28     const char *query_string;
  29     notmuch_sort_t sort;
  30     notmuch_string_list_t *exclude_terms;
  31     notmuch_exclude_t omit_excluded;
  32     bool parsed;
  33     notmuch_query_syntax_t syntax;
  34     Xapian::Query xapian_query;
  35     std::set<std::string> terms;
  36 };
  37
  38 typedef struct _notmuch_mset_messages {
  39     notmuch_messages_t base;
  40     notmuch_database_t *notmuch;
  41     Xapian::MSetIterator iterator;
  42     Xapian::MSetIterator iterator_end;
  43 } notmuch_mset_messages_t;
  44
  45 struct _notmuch_doc_id_set {
  46     unsigned char *bitmap;
  47     unsigned int bound;
  48 };
  49
  50 #define DOCIDSET_WORD(bit) ((bit) / CHAR_BIT)
  51 #define DOCIDSET_BIT(bit) ((bit) % CHAR_BIT)
  52
  53 struct _notmuch_threads {
  54     notmuch_query_t *query;
  55
  56     /* The ordered list of doc ids matched by the query. */
  57     GArray *doc_ids;
  58     /* Our iterator's current position in doc_ids. */
  59     unsigned int doc_id_pos;
  60     /* The set of matched docid's that have not been assigned to a
  61      * thread. Initially, this contains every docid in doc_ids. */
  62     notmuch_doc_id_set_t match_set;
  63 };
  64
  65 /* We need this in the message functions so forward declare. */
  66 static bool
  67 _notmuch_doc_id_set_init (void *ctx,
  68                           notmuch_doc_id_set_t *doc_ids,
  69                           GArray *arr);
  70
  71 static bool
  72 _debug_query (void)
  73 {
  74     char *env = getenv ("NOTMUCH_DEBUG_QUERY");
  75
  76     return (env && strcmp (env, "") != 0);
  77 }
  78
  79 /* Explicit destructor call for placement new */
  80 static int
  81 _notmuch_query_destructor (notmuch_query_t *query)
  82 {
  83     query->xapian_query.~Query();
  84     query->terms.~set<std::string>();
  85     return 0;
  86 }
  87
  88 static notmuch_query_t *
  89 _notmuch_query_constructor (notmuch_database_t *notmuch,
  90                             const char *query_string)
  91 {
  92     notmuch_query_t *query;
  93
  94     if (_debug_query ())
  95         fprintf (stderr, "Query string is:\n%s\n", query_string);
  96
  97     query = talloc (notmuch, notmuch_query_t);
  98     if (unlikely (query == NULL))
  99         return NULL;
 100
 101     new (&query->xapian_query) Xapian::Query ();
 102     new (&query->terms) std::set<std::string> ();
 103     query->parsed = false;
 104
 105     talloc_set_destructor (query, _notmuch_query_destructor);
 106
 107     query->notmuch = notmuch;
 108
 109     if (query_string)
 110         query->query_string = talloc_strdup (query, query_string);
 111     else
 112         query->query_string = NULL;
 113
 114     query->sort = NOTMUCH_SORT_NEWEST_FIRST;
 115
 116     query->exclude_terms = _notmuch_string_list_create (query);
 117
 118     query->omit_excluded = NOTMUCH_EXCLUDE_TRUE;
 119
 120     return query;
 121 }
 122
 123 notmuch_query_t *
 124 notmuch_query_create (notmuch_database_t *notmuch,
 125                       const char *query_string)
 126 {
 127
 128     notmuch_query_t *query;
 129     notmuch_status_t status;
 130
 131     status = notmuch_query_create_with_syntax (notmuch, query_string,
 132                                                NOTMUCH_QUERY_SYNTAX_XAPIAN,
 133                                                &query);
 134     if (status)
 135         return NULL;
 136
 137     return query;
 138 }
 139
 140 notmuch_status_t
 141 notmuch_query_create_with_syntax (notmuch_database_t *notmuch,
 142                                   const char *query_string,
 143                                   notmuch_query_syntax_t syntax,
 144                                   notmuch_query_t **output)
 145 {
 146
 147     notmuch_query_t *query;
 148
 149     if (! output)
 150         return NOTMUCH_STATUS_NULL_POINTER;
 151
 152     query = _notmuch_query_constructor (notmuch, query_string);
 153     if (! query)
 154         return NOTMUCH_STATUS_OUT_OF_MEMORY;
 155
 156     if (syntax == NOTMUCH_QUERY_SYNTAX_SEXP && ! HAVE_SFSEXP) {
 157         _notmuch_database_log (notmuch, "sexp query parser not available");
 158         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
 159     }
 160
 161     query->syntax = syntax;
 162
 163     *output = query;
 164
 165     return NOTMUCH_STATUS_SUCCESS;
 166 }
 167
 168 static void
 169 _notmuch_query_cache_terms (notmuch_query_t *query)
 170 {
 171     /* Xapian doesn't support skip_to on terms from a query since
 172      *  they are unordered, so cache a copy of all terms in
 173      *  something searchable.
 174      */
 175
 176     for (Xapian::TermIterator t = query->xapian_query.get_terms_begin ();
 177          t != query->xapian_query.get_terms_end (); ++t)
 178         query->terms.insert (*t);
 179 }
 180
 181 static notmuch_status_t
 182 _notmuch_query_ensure_parsed_xapian (notmuch_query_t *query)
 183 {
 184     try {
 185         query->xapian_query =
 186             query->notmuch->query_parser->
 187             parse_query (query->query_string, NOTMUCH_QUERY_PARSER_FLAGS);
 188
 189         _notmuch_query_cache_terms (query);
 190         query->parsed = true;
 191
 192     } catch (const Xapian::Error &error) {
 193         if (! query->notmuch->exception_reported) {
 194             _notmuch_database_log (query->notmuch,
 195                                    "A Xapian exception occurred parsing query: %s\n",
 196                                    error.get_msg ().c_str ());
 197             _notmuch_database_log_append (query->notmuch,
 198                                           "Query string was: %s\n",
 199                                           query->query_string);
 200             query->notmuch->exception_reported = true;
 201         }
 202
 203         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 204     }
 205     return NOTMUCH_STATUS_SUCCESS;
 206 }
 207
 208 static notmuch_status_t
 209 _notmuch_query_ensure_parsed_sexpr (notmuch_query_t *query)
 210 {
 211     notmuch_status_t status;
 212
 213     if (query->parsed)
 214         return NOTMUCH_STATUS_SUCCESS;
 215
 216     status = _notmuch_sexp_string_to_xapian_query (query->notmuch, query->query_string,
 217                                                    query->xapian_query);
 218     if (status)
 219         return status;
 220
 221     _notmuch_query_cache_terms (query);
 222     return NOTMUCH_STATUS_SUCCESS;
 223 }
 224
 225 static notmuch_status_t
 226 _notmuch_query_ensure_parsed (notmuch_query_t *query)
 227 {
 228     if (query->parsed)
 229         return NOTMUCH_STATUS_SUCCESS;
 230
 231 #if HAVE_SFSEXP
 232     if (query->syntax == NOTMUCH_QUERY_SYNTAX_SEXP)
 233         return _notmuch_query_ensure_parsed_sexpr (query);
 234 #endif
 235
 236     return _notmuch_query_ensure_parsed_xapian (query);
 237 }
 238
 239 const char *
 240 notmuch_query_get_query_string (const notmuch_query_t *query)
 241 {
 242     return query->query_string;
 243 }
 244
 245 void
 246 notmuch_query_set_omit_excluded (notmuch_query_t *query,
 247                                  notmuch_exclude_t omit_excluded)
 248 {
 249     query->omit_excluded = omit_excluded;
 250 }
 251
 252 void
 253 notmuch_query_set_sort (notmuch_query_t *query, notmuch_sort_t sort)
 254 {
 255     query->sort = sort;
 256 }
 257
 258 notmuch_sort_t
 259 notmuch_query_get_sort (const notmuch_query_t *query)
 260 {
 261     return query->sort;
 262 }
 263
 264 notmuch_status_t
 265 notmuch_query_add_tag_exclude (notmuch_query_t *query, const char *tag)
 266 {
 267     notmuch_status_t status;
 268     char *term;
 269
 270     status = _notmuch_query_ensure_parsed (query);
 271     if (status)
 272         return status;
 273
 274     term = talloc_asprintf (query, "%s%s", _find_prefix ("tag"), tag);
 275     if (query->terms.count (term) != 0)
 276         return NOTMUCH_STATUS_IGNORED;
 277
 278     _notmuch_string_list_append (query->exclude_terms, term);
 279     return NOTMUCH_STATUS_SUCCESS;
 280 }
 281
 282 /* We end up having to call the destructors explicitly because we had
 283  * to use "placement new" in order to initialize C++ objects within a
 284  * block that we allocated with talloc. So C++ is making talloc
 285  * slightly less simple to use, (we wouldn't need
 286  * talloc_set_destructor at all otherwise).
 287  */
 288 static int
 289 _notmuch_messages_destructor (notmuch_mset_messages_t *messages)
 290 {
 291     messages->iterator.~MSetIterator ();
 292     messages->iterator_end.~MSetIterator ();
 293
 294     return 0;
 295 }
 296
 297 /* Return a query that matches messages with the excluded tags
 298  * registered with query. The caller of this function has to combine the returned
 299  * query appropriately.*/
 300 static Xapian::Query
 301 _notmuch_exclude_tags (notmuch_query_t *query)
 302 {
 303     Xapian::Query exclude_query = Xapian::Query::MatchNothing;
 304
 305     for (notmuch_string_node_t *term = query->exclude_terms->head; term;
 306          term = term->next) {
 307         exclude_query = Xapian::Query (Xapian::Query::OP_OR,
 308                                        exclude_query, Xapian::Query (term->string));
 309     }
 310     return exclude_query;
 311 }
 312
 313
 314 notmuch_status_t
 315 notmuch_query_search_messages_st (notmuch_query_t *query,
 316                                   notmuch_messages_t **out)
 317 {
 318     return notmuch_query_search_messages (query, out);
 319 }
 320
 321 notmuch_status_t
 322 notmuch_query_search_messages (notmuch_query_t *query,
 323                                notmuch_messages_t **out)
 324 {
 325     return _notmuch_query_search_documents (query, "mail", out);
 326 }
 327
 328 notmuch_status_t
 329 _notmuch_query_search_documents (notmuch_query_t *query,
 330                                  const char *type,
 331                                  notmuch_messages_t **out)
 332 {
 333     notmuch_database_t *notmuch = query->notmuch;
 334     const char *query_string = query->query_string;
 335     notmuch_mset_messages_t *messages;
 336     notmuch_status_t status;
 337
 338     status = _notmuch_query_ensure_parsed (query);
 339     if (status)
 340         return status;
 341
 342     messages = talloc (query, notmuch_mset_messages_t);
 343     if (unlikely (messages == NULL))
 344         return NOTMUCH_STATUS_OUT_OF_MEMORY;
 345
 346     try {
 347
 348         messages->base.is_of_list_type = false;
 349         messages->base.iterator = NULL;
 350         messages->notmuch = notmuch;
 351         new (&messages->iterator) Xapian::MSetIterator ();
 352         new (&messages->iterator_end) Xapian::MSetIterator ();
 353
 354         talloc_set_destructor (messages, _notmuch_messages_destructor);
 355
 356         Xapian::Enquire enquire (*notmuch->xapian_db);
 357         Xapian::Query mail_query (talloc_asprintf (query, "%s%s",
 358                                                    _find_prefix ("type"),
 359                                                    type));
 360         Xapian::Query final_query, exclude_query;
 361         Xapian::MSet mset;
 362         Xapian::MSetIterator iterator;
 363
 364         if (strcmp (query_string, "") == 0 ||
 365             strcmp (query_string, "*") == 0) {
 366             final_query = mail_query;
 367         } else {
 368             final_query = Xapian::Query (Xapian::Query::OP_AND,
 369                                          mail_query, query->xapian_query);
 370         }
 371         messages->base.excluded_doc_ids = NULL;
 372
 373         if ((query->omit_excluded != NOTMUCH_EXCLUDE_FALSE) && (query->exclude_terms)) {
 374             exclude_query = _notmuch_exclude_tags (query);
 375
 376             if (query->omit_excluded == NOTMUCH_EXCLUDE_TRUE ||
 377                 query->omit_excluded == NOTMUCH_EXCLUDE_ALL) {
 378                 final_query = Xapian::Query (Xapian::Query::OP_AND_NOT,
 379                                              final_query, exclude_query);
 380             } else { /* NOTMUCH_EXCLUDE_FLAG */
 381                 exclude_query = Xapian::Query (Xapian::Query::OP_AND,
 382                                                exclude_query, final_query);
 383
 384                 enquire.set_weighting_scheme (Xapian::BoolWeight ());
 385                 enquire.set_query (exclude_query);
 386
 387                 mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
 388
 389                 GArray *excluded_doc_ids = g_array_new (false, false, sizeof (unsigned int));
 390
 391                 for (iterator = mset.begin (); iterator != mset.end (); iterator++) {
 392                     unsigned int doc_id = *iterator;
 393                     g_array_append_val (excluded_doc_ids, doc_id);
 394                 }
 395                 messages->base.excluded_doc_ids = talloc (messages, _notmuch_doc_id_set);
 396                 _notmuch_doc_id_set_init (query, messages->base.excluded_doc_ids,
 397                                           excluded_doc_ids);
 398                 g_array_unref (excluded_doc_ids);
 399             }
 400         }
 401
 402
 403         enquire.set_weighting_scheme (Xapian::BoolWeight ());
 404
 405         switch (query->sort) {
 406         case NOTMUCH_SORT_OLDEST_FIRST:
 407             enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, false);
 408             break;
 409         case NOTMUCH_SORT_NEWEST_FIRST:
 410             enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, true);
 411             break;
 412         case NOTMUCH_SORT_MESSAGE_ID:
 413             enquire.set_sort_by_value (NOTMUCH_VALUE_MESSAGE_ID, false);
 414             break;
 415         case NOTMUCH_SORT_UNSORTED:
 416             break;
 417         }
 418
 419         if (_debug_query ()) {
 420             fprintf (stderr, "Exclude query is:\n%s\n",
 421                      exclude_query.get_description ().c_str ());
 422             fprintf (stderr, "Final query is:\n%s\n",
 423                      final_query.get_description ().c_str ());
 424         }
 425
 426         enquire.set_query (final_query);
 427
 428         mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
 429
 430         messages->iterator = mset.begin ();
 431         messages->iterator_end = mset.end ();
 432
 433         *out = &messages->base;
 434         return NOTMUCH_STATUS_SUCCESS;
 435
 436     } catch (const Xapian::Error &error) {
 437         _notmuch_database_log (notmuch,
 438                                "A Xapian exception occurred performing query: %s\n",
 439                                error.get_msg ().c_str ());
 440         _notmuch_database_log_append (notmuch,
 441                                       "Query string was: %s\n",
 442                                       query->query_string);
 443
 444         notmuch->exception_reported = true;
 445         talloc_free (messages);
 446         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 447     }
 448 }
 449
 450 bool
 451 _notmuch_mset_messages_valid (notmuch_messages_t *messages)
 452 {
 453     notmuch_mset_messages_t *mset_messages;
 454
 455     mset_messages = (notmuch_mset_messages_t *) messages;
 456
 457     return (mset_messages->iterator != mset_messages->iterator_end);
 458 }
 459
 460 static Xapian::docid
 461 _notmuch_mset_messages_get_doc_id (notmuch_messages_t *messages)
 462 {
 463     notmuch_mset_messages_t *mset_messages;
 464
 465     mset_messages = (notmuch_mset_messages_t *) messages;
 466
 467     if (! _notmuch_mset_messages_valid (&mset_messages->base))
 468         return 0;
 469
 470     return *mset_messages->iterator;
 471 }
 472
 473 notmuch_message_t *
 474 _notmuch_mset_messages_get (notmuch_messages_t *messages)
 475 {
 476     notmuch_message_t *message;
 477     Xapian::docid doc_id;
 478     notmuch_private_status_t status;
 479     notmuch_mset_messages_t *mset_messages;
 480
 481     mset_messages = (notmuch_mset_messages_t *) messages;
 482
 483     if (! _notmuch_mset_messages_valid (&mset_messages->base))
 484         return NULL;
 485
 486     doc_id = *mset_messages->iterator;
 487
 488     message = _notmuch_message_create (mset_messages,
 489                                        mset_messages->notmuch, doc_id,
 490                                        &status);
 491
 492     if (message == NULL &&
 493         status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
 494         INTERNAL_ERROR ("a messages iterator contains a non-existent document ID.\n");
 495     }
 496
 497     if (messages->excluded_doc_ids &&
 498         _notmuch_doc_id_set_contains (messages->excluded_doc_ids, doc_id))
 499         notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, true);
 500
 501     return message;
 502 }
 503
 504 void
 505 _notmuch_mset_messages_move_to_next (notmuch_messages_t *messages)
 506 {
 507     notmuch_mset_messages_t *mset_messages;
 508
 509     mset_messages = (notmuch_mset_messages_t *) messages;
 510
 511     mset_messages->iterator++;
 512 }
 513
 514 static bool
 515 _notmuch_doc_id_set_init (void *ctx,
 516                           notmuch_doc_id_set_t *doc_ids,
 517                           GArray *arr)
 518 {
 519     unsigned int max = 0;
 520     unsigned char *bitmap;
 521
 522     for (unsigned int i = 0; i < arr->len; i++)
 523         max = MAX (max, g_array_index (arr, unsigned int, i));
 524     bitmap = talloc_zero_array (ctx, unsigned char, DOCIDSET_WORD (max) + 1);
 525
 526     if (bitmap == NULL)
 527         return false;
 528
 529     doc_ids->bitmap = bitmap;
 530     doc_ids->bound = max + 1;
 531
 532     for (unsigned int i = 0; i < arr->len; i++) {
 533         unsigned int doc_id = g_array_index (arr, unsigned int, i);
 534         bitmap[DOCIDSET_WORD (doc_id)] |= 1 << DOCIDSET_BIT (doc_id);
 535     }
 536
 537     return true;
 538 }
 539
 540 bool
 541 _notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
 542                               unsigned int doc_id)
 543 {
 544     if (doc_id >= doc_ids->bound)
 545         return false;
 546     return doc_ids->bitmap[DOCIDSET_WORD (doc_id)] & (1 << DOCIDSET_BIT (doc_id));
 547 }
 548
 549 void
 550 _notmuch_doc_id_set_remove (notmuch_doc_id_set_t *doc_ids,
 551                             unsigned int doc_id)
 552 {
 553     if (doc_id < doc_ids->bound)
 554         doc_ids->bitmap[DOCIDSET_WORD (doc_id)] &= ~(1 << DOCIDSET_BIT (doc_id));
 555 }
 556
 557 /* Glib objects force use to use a talloc destructor as well, (but not
 558  * nearly as ugly as the for messages due to C++ objects). At
 559  * this point, I'd really like to have some talloc-friendly
 560  * equivalents for the few pieces of glib that I'm using. */
 561 static int
 562 _notmuch_threads_destructor (notmuch_threads_t *threads)
 563 {
 564     if (threads->doc_ids)
 565         g_array_unref (threads->doc_ids);
 566
 567     return 0;
 568 }
 569
 570 notmuch_status_t
 571 notmuch_query_search_threads_st (notmuch_query_t *query, notmuch_threads_t **out)
 572 {
 573     return notmuch_query_search_threads (query, out);
 574 }
 575
 576 notmuch_status_t
 577 notmuch_query_search_threads (notmuch_query_t *query,
 578                               notmuch_threads_t **out)
 579 {
 580     notmuch_threads_t *threads;
 581     notmuch_messages_t *messages;
 582     notmuch_status_t status;
 583
 584     threads = talloc (query, notmuch_threads_t);
 585     if (threads == NULL)
 586         return NOTMUCH_STATUS_OUT_OF_MEMORY;
 587     threads->doc_ids = NULL;
 588     talloc_set_destructor (threads, _notmuch_threads_destructor);
 589
 590     threads->query = query;
 591
 592     status = notmuch_query_search_messages (query, &messages);
 593     if (status) {
 594         talloc_free (threads);
 595         return status;
 596     }
 597
 598     threads->doc_ids = g_array_new (false, false, sizeof (unsigned int));
 599     while (notmuch_messages_valid (messages)) {
 600         unsigned int doc_id = _notmuch_mset_messages_get_doc_id (messages);
 601         g_array_append_val (threads->doc_ids, doc_id);
 602         notmuch_messages_move_to_next (messages);
 603     }
 604     threads->doc_id_pos = 0;
 605
 606     talloc_free (messages);
 607
 608     if (! _notmuch_doc_id_set_init (threads, &threads->match_set,
 609                                     threads->doc_ids)) {
 610         talloc_free (threads);
 611         return NOTMUCH_STATUS_OUT_OF_MEMORY;
 612     }
 613
 614     *out = threads;
 615     return NOTMUCH_STATUS_SUCCESS;
 616 }
 617
 618 void
 619 notmuch_query_destroy (notmuch_query_t *query)
 620 {
 621     talloc_free (query);
 622 }
 623
 624 notmuch_bool_t
 625 notmuch_threads_valid (notmuch_threads_t *threads)
 626 {
 627     unsigned int doc_id;
 628
 629     if (! threads)
 630         return false;
 631
 632     while (threads->doc_id_pos < threads->doc_ids->len) {
 633         doc_id = g_array_index (threads->doc_ids, unsigned int,
 634                                 threads->doc_id_pos);
 635         if (_notmuch_doc_id_set_contains (&threads->match_set, doc_id))
 636             break;
 637
 638         threads->doc_id_pos++;
 639     }
 640
 641     return threads->doc_id_pos < threads->doc_ids->len;
 642 }
 643
 644 notmuch_thread_t *
 645 notmuch_threads_get (notmuch_threads_t *threads)
 646 {
 647     unsigned int doc_id;
 648
 649     if (! notmuch_threads_valid (threads))
 650         return NULL;
 651
 652     doc_id = g_array_index (threads->doc_ids, unsigned int,
 653                             threads->doc_id_pos);
 654     return _notmuch_thread_create (threads->query,
 655                                    threads->query->notmuch,
 656                                    doc_id,
 657                                    &threads->match_set,
 658                                    threads->query->exclude_terms,
 659                                    threads->query->omit_excluded,
 660                                    threads->query->sort);
 661 }
 662
 663 void
 664 notmuch_threads_move_to_next (notmuch_threads_t *threads)
 665 {
 666     threads->doc_id_pos++;
 667 }
 668
 669 void
 670 notmuch_threads_destroy (notmuch_threads_t *threads)
 671 {
 672     talloc_free (threads);
 673 }
 674
 675 notmuch_status_t
 676 notmuch_query_count_messages_st (notmuch_query_t *query, unsigned *count_out)
 677 {
 678     return notmuch_query_count_messages (query, count_out);
 679 }
 680
 681 notmuch_status_t
 682 notmuch_query_count_messages (notmuch_query_t *query, unsigned *count_out)
 683 {
 684     return _notmuch_query_count_documents (query, "mail", count_out);
 685 }
 686
 687 notmuch_status_t
 688 _notmuch_query_count_documents (notmuch_query_t *query, const char *type, unsigned *count_out)
 689 {
 690     notmuch_database_t *notmuch = query->notmuch;
 691     const char *query_string = query->query_string;
 692     Xapian::doccount count = 0;
 693     notmuch_status_t status;
 694
 695     status = _notmuch_query_ensure_parsed (query);
 696     if (status)
 697         return status;
 698
 699     try {
 700         Xapian::Enquire enquire (*notmuch->xapian_db);
 701         Xapian::Query mail_query (talloc_asprintf (query, "%s%s",
 702                                                    _find_prefix ("type"),
 703                                                    type));
 704         Xapian::Query final_query, exclude_query;
 705         Xapian::MSet mset;
 706
 707         if (strcmp (query_string, "") == 0 ||
 708             strcmp (query_string, "*") == 0) {
 709             final_query = mail_query;
 710         } else {
 711             final_query = Xapian::Query (Xapian::Query::OP_AND,
 712                                          mail_query, query->xapian_query);
 713         }
 714
 715         exclude_query = _notmuch_exclude_tags (query);
 716
 717         final_query = Xapian::Query (Xapian::Query::OP_AND_NOT,
 718                                      final_query, exclude_query);
 719
 720         enquire.set_weighting_scheme (Xapian::BoolWeight ());
 721         enquire.set_docid_order (Xapian::Enquire::ASCENDING);
 722
 723         if (_debug_query ()) {
 724             fprintf (stderr, "Exclude query is:\n%s\n",
 725                      exclude_query.get_description ().c_str ());
 726             fprintf (stderr, "Final query is:\n%s\n",
 727                      final_query.get_description ().c_str ());
 728         }
 729
 730         enquire.set_query (final_query);
 731
 732         /*
 733          * Set the checkatleast parameter to the number of documents
 734          * in the database to make get_matches_estimated() exact.
 735          * Set the max parameter to 1 to avoid fetching documents we will discard.
 736          */
 737         mset = enquire.get_mset (0, 1,
 738                                  notmuch->xapian_db->get_doccount ());
 739
 740         count = mset.get_matches_estimated ();
 741
 742     } catch (const Xapian::Error &error) {
 743         _notmuch_database_log (notmuch,
 744                                "A Xapian exception occurred performing query: %s\n",
 745                                error.get_msg ().c_str ());
 746         _notmuch_database_log_append (notmuch,
 747                                       "Query string was: %s\n",
 748                                       query->query_string);
 749         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 750     }
 751
 752     *count_out = count;
 753     return NOTMUCH_STATUS_SUCCESS;
 754 }
 755
 756 notmuch_status_t
 757 notmuch_query_count_threads_st (notmuch_query_t *query, unsigned *count)
 758 {
 759     return notmuch_query_count_threads (query, count);
 760 }
 761
 762 notmuch_status_t
 763 notmuch_query_count_threads (notmuch_query_t *query, unsigned *count)
 764 {
 765     notmuch_messages_t *messages;
 766     GHashTable *hash;
 767     notmuch_sort_t sort;
 768     notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS;
 769
 770     sort = query->sort;
 771     query->sort = NOTMUCH_SORT_UNSORTED;
 772     ret = notmuch_query_search_messages (query, &messages);
 773     if (ret)
 774         return ret;
 775     query->sort = sort;
 776     if (messages == NULL)
 777         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 778
 779     hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
 780     if (hash == NULL) {
 781         talloc_free (messages);
 782         return NOTMUCH_STATUS_OUT_OF_MEMORY;
 783     }
 784
 785     while (notmuch_messages_valid (messages)) {
 786         notmuch_message_t *message = notmuch_messages_get (messages);
 787         const char *thread_id = notmuch_message_get_thread_id (message);
 788         char *thread_id_copy = talloc_strdup (messages, thread_id);
 789         if (unlikely (thread_id_copy == NULL)) {
 790             notmuch_message_destroy (message);
 791             ret = NOTMUCH_STATUS_OUT_OF_MEMORY;
 792             goto DONE;
 793         }
 794         g_hash_table_insert (hash, thread_id_copy, NULL);
 795         notmuch_message_destroy (message);
 796         notmuch_messages_move_to_next (messages);
 797     }
 798
 799     *count = g_hash_table_size (hash);
 800
 801   DONE:
 802     g_hash_table_unref (hash);
 803     talloc_free (messages);
 804
 805     return ret;
 806 }
 807
 808 notmuch_database_t *
 809 notmuch_query_get_database (const notmuch_query_t *query)
 810 {
 811     return query->notmuch;
 812 }