X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-search.c;h=fc2baaa71aa91d1a574f0ec00e7094c28340ccba;hp=3873a067cb59d5c21173ecdb23778848c6707a2b;hb=9eb90688b701b906b984eb433107acb7d3c5a288;hpb=13569ad6c96c3f3a653ac51274056614647ad7ef diff --git a/notmuch-search.c b/notmuch-search.c index 3873a067..fc2baaa7 100644 --- a/notmuch-search.c +++ b/notmuch-search.c @@ -20,30 +20,141 @@ #include "notmuch-client.h" +/* If the user asks for more than this number of threads, then break + the results down into chunks so that results start appearing + quickly rather than the user having to wait until all results are + available before anything appears. + + Since each subsequent chunk ends up having to re-do threading work + done by all previous chunks, we double the chunk size repeatedly + until all desired results have been returned. +*/ +#define NOTMUCH_SEARCH_INITIAL_CHUNK_SIZE 100 + +/* Do the actual search for a chunk of threads and display the results, + (returning the number of threads found in this chunk). */ +static int +do_search_threads (const void *ctx, + notmuch_query_t *query, + notmuch_sort_t sort, + int first, int max_threads) +{ + notmuch_thread_t *thread; + notmuch_threads_t *threads; + notmuch_tags_t *tags; + time_t date; + const char *relative_date; + int num_threads = 0; + + for (threads = notmuch_query_search_threads (query, first, max_threads); + notmuch_threads_has_more (threads); + notmuch_threads_advance (threads)) + { + int first_tag = 1; + + thread = notmuch_threads_get (threads); + num_threads++; + + if (sort == NOTMUCH_SORT_OLDEST_FIRST) + date = notmuch_thread_get_oldest_date (thread); + else + date = notmuch_thread_get_newest_date (thread); + + relative_date = notmuch_time_relative_date (ctx, date); + + printf ("thread:%s %12s [%d/%d] %s; %s", + notmuch_thread_get_thread_id (thread), + relative_date, + notmuch_thread_get_matched_messages (thread), + notmuch_thread_get_total_messages (thread), + notmuch_thread_get_authors (thread), + notmuch_thread_get_subject (thread)); + + printf (" ("); + for (tags = notmuch_thread_get_tags (thread); + notmuch_tags_has_more (tags); + notmuch_tags_advance (tags)) + { + if (! first_tag) + printf (" "); + printf ("%s", notmuch_tags_get (tags)); + first_tag = 0; + } + printf (")\n"); + + notmuch_thread_destroy (thread); + } + + return num_threads; +} + int notmuch_search_command (void *ctx, int argc, char *argv[]) { notmuch_config_t *config; notmuch_database_t *notmuch; notmuch_query_t *query; - notmuch_threads_t *threads; - notmuch_thread_t *thread; - notmuch_tags_t *tags; char *query_str; - const char *relative_date; - time_t date; + int i, first = 0, max_threads = -1; + char *opt, *end; + notmuch_sort_t sort = NOTMUCH_SORT_NEWEST_FIRST; + int chunk_size; + int threads_in_chunk; + + for (i = 0; i < argc && argv[i][0] == '-'; i++) { + if (strcmp (argv[i], "--") == 0) { + i++; + break; + } + 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 { + 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 = 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 moemory.\n"); + fprintf (stderr, "Out of memory.\n"); + return 1; + } + if (*query_str == '\0') { + fprintf (stderr, "Error: notmuch search requires at least one search term.\n"); return 1; } @@ -53,36 +164,27 @@ notmuch_search_command (void *ctx, int argc, char *argv[]) return 1; } - for (threads = notmuch_query_search_threads (query); - notmuch_threads_has_more (threads); - notmuch_threads_advance (threads)) - { - int first = 1; + notmuch_query_set_sort (query, sort); - thread = notmuch_threads_get (threads); + /* If we receive a max-threads option, then the user is + responsible for any chunking and we return all results at + once. */ + if (max_threads < 0) + chunk_size = NOTMUCH_SEARCH_INITIAL_CHUNK_SIZE; + else + chunk_size = max_threads; - date = notmuch_thread_get_oldest_date (thread); - relative_date = notmuch_time_relative_date (ctx, date); + do { + threads_in_chunk = do_search_threads (ctx, query, sort, + first, chunk_size); + if (chunk_size == max_threads) + break; - printf ("thread:%s %12s %s", - notmuch_thread_get_thread_id (thread), - relative_date, - notmuch_thread_get_subject (thread)); + first += chunk_size; - printf (" ("); - for (tags = notmuch_thread_get_tags (thread); - notmuch_tags_has_more (tags); - notmuch_tags_advance (tags)) - { - if (! first) - printf (" "); - printf ("%s", notmuch_tags_get (tags)); - first = 0; - } - printf (")\n"); + chunk_size *= 2; - notmuch_thread_destroy (thread); - } + } while (threads_in_chunk); notmuch_query_destroy (query); notmuch_database_close (notmuch);