Add 'notmuch count' command to show the count of matching messages
authorKeith Packard <keithp@keithp.com>
Sat, 21 Nov 2009 07:15:07 +0000 (23:15 -0800)
committerCarl Worth <cworth@cworth.org>
Mon, 23 Nov 2009 05:33:54 +0000 (06:33 +0100)
Getting the count of matching threads or messages is a fairly
expensive operation. Xapian provides a very efficient mechanism that
returns an approximate value, so use that for this new command.

This returns the number of matching messages, not threads, as that is
cheap to compute.

Signed-off-by: Keith Packard <keithp@keithp.com>
Makefile.local
lib/notmuch.h
lib/query.cc
notmuch-client.h
notmuch-count.c [new file with mode: 0644]
notmuch.c

index 28286597e8cc4685a51730dc3d4138fcbef89564..a3a19deadcf0d14b0acc09f75420be5490743c3f 100644 (file)
@@ -7,6 +7,7 @@ notmuch_client_srcs =           \
        gmime-filter-reply.c    \
        notmuch.c               \
        notmuch-config.c        \
        gmime-filter-reply.c    \
        notmuch.c               \
        notmuch-config.c        \
+       notmuch-count.c         \
        notmuch-dump.c          \
        notmuch-new.c           \
        notmuch-reply.c         \
        notmuch-dump.c          \
        notmuch-new.c           \
        notmuch-reply.c         \
index a61cd0207216b656724e0e1188b21cbb69e68d09..260cc22d370088bf74ca3cee81d5b88dc19dbb4b 100644 (file)
@@ -468,6 +468,14 @@ notmuch_threads_advance (notmuch_threads_t *threads);
 void
 notmuch_threads_destroy (notmuch_threads_t *threads);
 
 void
 notmuch_threads_destroy (notmuch_threads_t *threads);
 
+/* Return an estimate of the number of messages matching a search
+ *
+ * This function performs a search and returns Xapian's best
+ * guess as to number of matching messages.
+ */
+unsigned
+notmuch_query_count_messages (notmuch_query_t *query);
 /* Get the thread ID of 'thread'.
  *
  * The returned string belongs to 'thread' and as such, should not be
 /* Get the thread ID of 'thread'.
  *
  * The returned string belongs to 'thread' and as such, should not be
index 86167352381e5ed22dd3177e1ce32d98c2b2559d..686d75f9657cf4e142a1983c41e0ab29ee3ff960 100644 (file)
@@ -279,3 +279,55 @@ notmuch_threads_destroy (notmuch_threads_t *threads)
 {
     talloc_free (threads);
 }
 {
     talloc_free (threads);
 }
+
+unsigned
+notmuch_query_count_messages (notmuch_query_t *query)
+{
+    notmuch_database_t *notmuch = query->notmuch;
+    const char *query_string = query->query_string;
+    Xapian::doccount count;
+
+    try {
+       Xapian::Enquire enquire (*notmuch->xapian_db);
+       Xapian::Query mail_query (talloc_asprintf (query, "%s%s",
+                                                  _find_prefix ("type"),
+                                                  "mail"));
+       Xapian::Query string_query, final_query;
+       Xapian::MSet mset;
+       unsigned int flags = (Xapian::QueryParser::FLAG_BOOLEAN |
+                             Xapian::QueryParser::FLAG_PHRASE |
+                             Xapian::QueryParser::FLAG_LOVEHATE |
+                             Xapian::QueryParser::FLAG_BOOLEAN_ANY_CASE |
+                             Xapian::QueryParser::FLAG_WILDCARD |
+                             Xapian::QueryParser::FLAG_PURE_NOT);
+
+       if (strcmp (query_string, "") == 0) {
+           final_query = mail_query;
+       } else {
+           string_query = notmuch->query_parser->
+               parse_query (query_string, flags);
+           final_query = Xapian::Query (Xapian::Query::OP_AND,
+                                        mail_query, string_query);
+       }
+
+       enquire.set_weighting_scheme(Xapian::BoolWeight());
+       enquire.set_docid_order(Xapian::Enquire::ASCENDING);
+
+#if DEBUG_QUERY
+       fprintf (stderr, "Final query is:\n%s\n", final_query.get_description().c_str());
+#endif
+
+       enquire.set_query (final_query);
+
+       mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
+
+       count = mset.get_matches_estimated();
+
+    } catch (const Xapian::Error &error) {
+       fprintf (stderr, "A Xapian exception occurred: %s\n",
+                error.get_msg().c_str());
+       fprintf (stderr, "Query string was: %s\n", query->query_string);
+    }
+
+    return count;
+}
index 4fe182ee7890ba6934f0297af53e269eee185650..c04eaeb40a9c652cc82dd175c15741f9848e7ea7 100644 (file)
@@ -92,6 +92,9 @@ chomp_newline (char *str)
        str[strlen(str)-1] = '\0';
 }
 
        str[strlen(str)-1] = '\0';
 }
 
+int
+notmuch_count_command (void *ctx, int argc, char *argv[]);
+
 int
 notmuch_dump_command (void *ctx, int argc, char *argv[]);
 
 int
 notmuch_dump_command (void *ctx, int argc, char *argv[]);
 
diff --git a/notmuch-count.c b/notmuch-count.c
new file mode 100644 (file)
index 0000000..77aa433
--- /dev/null
@@ -0,0 +1,110 @@
+/* notmuch - Not much of an email program, (just index and search)
+ *
+ * Copyright © 2009 Carl Worth
+ * Copyright © 2009 Keith Packard
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see http://www.gnu.org/licenses/ .
+ *
+ * Author: Keith Packard <keithp@keithp.com>
+ */
+
+#include "notmuch-client.h"
+
+int
+notmuch_count_command (void *ctx, int argc, char *argv[])
+{
+    notmuch_config_t *config;
+    notmuch_database_t *notmuch;
+    notmuch_query_t *query;
+    char *query_str;
+    int i;
+#if 0
+    char *opt, *end;
+    int i, first = 0, max_threads = -1;
+    notmuch_sort_t sort = NOTMUCH_SORT_NEWEST_FIRST;
+#endif
+
+    for (i = 0; i < argc && argv[i][0] == '-'; i++) {
+       if (strcmp (argv[i], "--") == 0) {
+           i++;
+           break;
+       }
+#if 0
+       if (STRNCMP_LITERAL (argv[i], "--first=") == 0) {
+           opt = argv[i] + sizeof ("--first=") - 1;
+           first = strtoul (opt, &end, 10);
+           if (*opt == '\0' || *end != '\0') {
+               fprintf (stderr, "Invalid value for --first: %s\n", opt);
+               return 1;
+           }
+       } else if (STRNCMP_LITERAL (argv[i], "--max-threads=") == 0) {
+           opt = argv[i] + sizeof ("--max-threads=") - 1;
+           max_threads = strtoul (opt, &end, 10);
+           if (*opt == '\0' || *end != '\0') {
+               fprintf (stderr, "Invalid value for --max-threads: %s\n", opt);
+               return 1;
+           }
+       } else if (STRNCMP_LITERAL (argv[i], "--sort=") == 0) {
+           opt = argv[i] + sizeof ("--sort=") - 1;
+           if (strcmp (opt, "oldest-first") == 0) {
+               sort = NOTMUCH_SORT_OLDEST_FIRST;
+           } else if (strcmp (opt, "newest-first") == 0) {
+               sort = NOTMUCH_SORT_NEWEST_FIRST;
+           } else {
+               fprintf (stderr, "Invalid value for --sort: %s\n", opt);
+               return 1;
+           }
+       } else
+#endif
+       {
+           fprintf (stderr, "Unrecognized option: %s\n", argv[i]);
+           return 1;
+       }
+    }
+
+    argc -= i;
+    argv += i;
+
+    config = notmuch_config_open (ctx, NULL, NULL);
+    if (config == NULL)
+       return 1;
+
+    notmuch = notmuch_database_open (notmuch_config_get_database_path (config),
+                                    NOTMUCH_DATABASE_MODE_READ_ONLY);
+    if (notmuch == NULL)
+       return 1;
+
+    query_str = query_string_from_args (ctx, argc, argv);
+    if (query_str == NULL) {
+       fprintf (stderr, "Out of memory.\n");
+       return 1;
+    }
+    if (*query_str == '\0') {
+       fprintf (stderr, "Error: notmuch count requires at least one count term.\n");
+       return 1;
+    }
+
+    query = notmuch_query_create (notmuch, query_str);
+    if (query == NULL) {
+       fprintf (stderr, "Out of memory\n");
+       return 1;
+    }
+
+    printf ("%u\n", notmuch_query_count_messages(query));
+
+    notmuch_query_destroy (query);
+    notmuch_database_close (notmuch);
+
+    return 0;
+}
index d84cea595202f21227ca529728bf9237cbbb576b..72ca62044e90a2a3ccd2a0cee493f81141504fa4 100644 (file)
--- a/notmuch.c
+++ b/notmuch.c
@@ -187,6 +187,17 @@ command_t commands[] = {
       "\n"
       "\t\tSee \"notmuch help search-terms\" for details of the search\n"
       "\t\tterms syntax." },
       "\n"
       "\t\tSee \"notmuch help search-terms\" for details of the search\n"
       "\t\tterms syntax." },
+    { "count", notmuch_count_command,
+      "<search-terms> [...]",
+      "\t\tCount messages matching the search terms.",
+      "\t\tThe number of matching messages is output to stdout.\n"
+      "\n"
+      "\t\tA common use of \"notmuch count\" is to display the count\n"
+      "\t\tof messages matching both a specific tag and either inbox\n"
+      "\t\tor unread\n"
+      "\n"
+      "\t\tSee \"notmuch help search-terms\" for details of the search\n"
+      "\t\tterms syntax." },
     { "reply", notmuch_reply_command,
       "<search-terms> [...]",
       "\t\tConstruct a reply template for a set of messages.",
     { "reply", notmuch_reply_command,
       "<search-terms> [...]",
       "\t\tConstruct a reply template for a set of messages.",