X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=notmuch-search.c;h=fc2baaa71aa91d1a574f0ec00e7094c28340ccba;hp=4d2c73616768fc58e955e87fd9d8ce818da5195e;hb=60817c39d83a67e0dca5e154588672d962d24c5c;hpb=50144f95cababfb73027ca95ad1fb303c235a893 diff --git a/notmuch-search.c b/notmuch-search.c index 4d2c7361..fc2baaa7 100644 --- a/notmuch-search.c +++ b/notmuch-search.c @@ -20,49 +20,54 @@ #include "notmuch-client.h" -int -notmuch_search_command (void *ctx, int argc, char *argv[]) +/* 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) { - void *local = talloc_new (ctx); - notmuch_database_t *notmuch = NULL; - notmuch_query_t *query; - notmuch_threads_t *threads; notmuch_thread_t *thread; + notmuch_threads_t *threads; notmuch_tags_t *tags; - char *query_str; - const char *relative_date; time_t date; - notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; - - notmuch = notmuch_database_open (NULL); - if (notmuch == NULL) { - ret = 1; - goto DONE; - } - - query_str = query_string_from_args (local, argc, argv); - - query = notmuch_query_create (notmuch, query_str); - if (query == NULL) { - fprintf (stderr, "Out of memory\n"); - ret = 1; - goto DONE; - } + const char *relative_date; + int num_threads = 0; - for (threads = notmuch_query_search_threads (query); + for (threads = notmuch_query_search_threads (query, first, max_threads); notmuch_threads_has_more (threads); notmuch_threads_advance (threads)) { - int first = 1; + 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); - date = notmuch_thread_get_oldest_date (thread); - relative_date = notmuch_time_relative_date (local, date); + relative_date = notmuch_time_relative_date (ctx, date); - printf ("thread:%s %12s %s", + 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 (" ("); @@ -70,22 +75,119 @@ notmuch_search_command (void *ctx, int argc, char *argv[]) notmuch_tags_has_more (tags); notmuch_tags_advance (tags)) { - if (! first) + if (! first_tag) printf (" "); printf ("%s", notmuch_tags_get (tags)); - first = 0; + first_tag = 0; } printf (")\n"); notmuch_thread_destroy (thread); } - notmuch_query_destroy (query); + return num_threads; +} - DONE: - if (notmuch) - notmuch_database_close (notmuch); - talloc_free (local); +int +notmuch_search_command (void *ctx, int argc, char *argv[]) +{ + notmuch_config_t *config; + notmuch_database_t *notmuch; + notmuch_query_t *query; + char *query_str; + 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_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 search requires at least one search term.\n"); + return 1; + } + + query = notmuch_query_create (notmuch, query_str); + if (query == NULL) { + fprintf (stderr, "Out of memory\n"); + return 1; + } + + notmuch_query_set_sort (query, sort); + + /* 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; + + do { + threads_in_chunk = do_search_threads (ctx, query, sort, + first, chunk_size); + if (chunk_size == max_threads) + break; + + first += chunk_size; + + chunk_size *= 2; + + } while (threads_in_chunk); + + notmuch_query_destroy (query); + notmuch_database_close (notmuch); - return ret; + return 0; }