X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=lib%2Fdatabase.cc;h=7efd3b4ae3c1dea17833de6e1dba9f8cc9cbf536;hp=726c5a98a02b1e153358c0daff820dac8cac3cc3;hb=50ae83a17feb1fc2f48fb8e51ef73da08ae4e2f2;hpb=2ce25b93a72b4a8d6daa5321f9ef7df0772a789f diff --git a/lib/database.cc b/lib/database.cc index 726c5a98..7efd3b4a 100644 --- a/lib/database.cc +++ b/lib/database.cc @@ -37,7 +37,7 @@ typedef struct { /* Here's the current schema for our database: * - * We currently have two different types of documents: mail and timestamps. + * We currently have two different types of documents: mail and directory. * * Mail document * ------------- @@ -75,21 +75,19 @@ typedef struct { * user in searching. But the database doesn't really care itself * about any of these. * - * Timestamp document + * Directory document * ------------------ - * A timestamp document is used by a client of the notmuch library to + * A directory document is used by a client of the notmuch library to * maintain data necessary to allow for efficient polling of mail - * directories. The notmuch library does no interpretation of - * timestamps, but merely allows the user to store and retrieve - * timestamps as name/value pairs. + * directories. * - * The timestamp document is indexed with a single prefixed term: + * The directory document is indexed with a single prefixed term: * - * timestamp: The user's key value (likely a directory name) + * directory: The directory path (an absolute path) * * and has a single value: * - * TIMESTAMP: The time_t value from the user. + * TIMESTAMP: The mtime of the directory (at last scan) */ /* With these prefix values we follow the conventions published here: @@ -111,7 +109,8 @@ prefix_t BOOLEAN_PREFIX_INTERNAL[] = { { "type", "T" }, { "reference", "XREFERENCE" }, { "replyto", "XREPLYTO" }, - { "timestamp", "XTIMESTAMP" }, + /* XXX: Need a flag day to rename XTIMESTAMP. */ + { "directory", "XTIMESTAMP" }, }; prefix_t BOOLEAN_PREFIX_EXTERNAL[] = { @@ -147,17 +146,20 @@ _find_prefix (const char *name) { unsigned int i; - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_INTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_INTERNAL[i].name) == 0) return BOOLEAN_PREFIX_INTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) + for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { if (strcmp (name, BOOLEAN_PREFIX_EXTERNAL[i].name) == 0) return BOOLEAN_PREFIX_EXTERNAL[i].prefix; + } - for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) + for (i = 0; i < ARRAY_SIZE (PROBABILISTIC_PREFIX); i++) { if (strcmp (name, PROBABILISTIC_PREFIX[i].name) == 0) return PROBABILISTIC_PREFIX[i].prefix; + } INTERNAL_ERROR ("No prefix exists for '%s'\n", name); @@ -172,6 +174,8 @@ notmuch_status_to_string (notmuch_status_t status) return "No error occurred"; case NOTMUCH_STATUS_OUT_OF_MEMORY: return "Out of memory"; + case NOTMUCH_STATUS_READONLY_DATABASE: + return "The database is read-only"; case NOTMUCH_STATUS_XAPIAN_EXCEPTION: return "A Xapian exception occurred"; case NOTMUCH_STATUS_FILE_ERROR: @@ -293,13 +297,14 @@ skip_space_and_comments (const char **str) int nesting = 1; s++; while (*s && nesting) { - if (*s == '(') + if (*s == '(') { nesting++; - else if (*s == ')') + } else if (*s == ')') { nesting--; - else if (*s == '\\') + } else if (*s == '\\') { if (*(s+1)) s++; + } s++; } } @@ -323,7 +328,7 @@ _parse_message_id (void *ctx, const char *message_id, const char **next) const char *s, *end; char *result; - if (message_id == NULL) + if (message_id == NULL || *message_id == '\0') return NULL; s = message_id; @@ -391,7 +396,7 @@ parse_references (void *ctx, { char *ref; - if (refs == NULL) + if (refs == NULL || *refs == '\0') return; while (*refs) { @@ -438,7 +443,8 @@ notmuch_database_create (const char *path) goto DONE; } - notmuch = notmuch_database_open (path); + notmuch = notmuch_database_open (path, + NOTMUCH_DATABASE_MODE_READ_WRITE); DONE: if (notmuch_path) @@ -448,7 +454,8 @@ notmuch_database_create (const char *path) } notmuch_database_t * -notmuch_database_open (const char *path) +notmuch_database_open (const char *path, + notmuch_database_mode_t mode) { notmuch_database_t *notmuch = NULL; char *notmuch_path = NULL, *xapian_path = NULL; @@ -476,22 +483,30 @@ notmuch_database_open (const char *path) } notmuch = talloc (NULL, notmuch_database_t); + notmuch->exception_reported = FALSE; notmuch->path = talloc_strdup (notmuch, path); if (notmuch->path[strlen (notmuch->path) - 1] == '/') notmuch->path[strlen (notmuch->path) - 1] = '\0'; + notmuch->mode = mode; try { - notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, - Xapian::DB_CREATE_OR_OPEN); + if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) { + notmuch->xapian_db = new Xapian::WritableDatabase (xapian_path, + Xapian::DB_CREATE_OR_OPEN); + } else { + notmuch->xapian_db = new Xapian::Database (xapian_path); + } notmuch->query_parser = new Xapian::QueryParser; notmuch->term_gen = new Xapian::TermGenerator; notmuch->term_gen->set_stemmer (Xapian::Stem ("english")); + notmuch->value_range_processor = new Xapian::NumberValueRangeProcessor (NOTMUCH_VALUE_TIMESTAMP); notmuch->query_parser->set_default_op (Xapian::Query::OP_AND); notmuch->query_parser->set_database (*notmuch->xapian_db); notmuch->query_parser->set_stemmer (Xapian::Stem ("english")); notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME); + notmuch->query_parser->add_valuerangeprocessor (notmuch->value_range_processor); for (i = 0; i < ARRAY_SIZE (BOOLEAN_PREFIX_EXTERNAL); i++) { prefix_t *prefix = &BOOLEAN_PREFIX_EXTERNAL[i]; @@ -504,11 +519,11 @@ notmuch_database_open (const char *path) notmuch->query_parser->add_prefix (prefix->name, prefix->prefix); } } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s\n", + fprintf (stderr, "A Xapian exception occurred opening database: %s\n", error.get_msg().c_str()); notmuch = NULL; } - + DONE: if (notmuch_path) free (notmuch_path); @@ -521,11 +536,20 @@ notmuch_database_open (const char *path) void notmuch_database_close (notmuch_database_t *notmuch) { - notmuch->xapian_db->flush (); + try { + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_WRITE) + (static_cast (notmuch->xapian_db))->flush (); + } catch (const Xapian::Error &error) { + if (! notmuch->exception_reported) { + fprintf (stderr, "Error: A Xapian exception occurred flushing database: %s\n", + error.get_msg().c_str()); + } + } delete notmuch->term_gen; delete notmuch->query_parser; delete notmuch->xapian_db; + delete notmuch->value_range_processor; talloc_free (notmuch); } @@ -536,98 +560,142 @@ notmuch_database_get_path (notmuch_database_t *notmuch) } static notmuch_private_status_t -find_timestamp_document (notmuch_database_t *notmuch, const char *db_key, +find_directory_document (notmuch_database_t *notmuch, const char *db_path, Xapian::Document *doc, unsigned int *doc_id) { - return find_unique_document (notmuch, "timestamp", db_key, doc, doc_id); + return find_unique_document (notmuch, "directory", db_path, doc, doc_id); } -/* We allow the user to use arbitrarily long keys for timestamps, - * (they're for filesystem paths after all, which have no limit we - * know about). But we have a term-length limit. So if we exceed that, - * we'll use the SHA-1 of the user's key as the actual key for - * constructing a database term. +/* We allow the user to use arbitrarily long paths for directories. But + * we have a term-length limit. So if we exceed that, we'll use the + * SHA-1 of the path for the database term. * - * Caution: This function returns a newly allocated string which the - * caller should free() when finished. + * Note: This function may return the original value of 'path'. If it + * does not, then the caller is responsible to free() the returned + * value. */ -static char * -timestamp_db_key (const char *key) +static const char * +directory_db_path (const char *path) { - int term_len = strlen (_find_prefix ("timestamp")) + strlen (key); + int term_len = strlen (_find_prefix ("directory")) + strlen (path); if (term_len > NOTMUCH_TERM_MAX) - return notmuch_sha1_of_string (key); + return notmuch_sha1_of_string (path); else - return strdup (key); + return path; +} + +/* Given a legal 'path' for the database, return the relative path. + * + * The return value will be a pointer to the originl path contents, + * and will be either the original string (if 'path' was relative) or + * a portion of the string (if path was absolute and begins with the + * database path). + */ +const char * +_notmuch_database_relative_path (notmuch_database_t *notmuch, + const char *path) +{ + const char *db_path, *relative; + unsigned int db_path_len; + + db_path = notmuch_database_get_path (notmuch); + db_path_len = strlen (db_path); + + relative = path; + + if (*relative == '/') { + while (*relative == '/' && *(relative+1) == '/') + relative++; + + if (strncmp (relative, db_path, db_path_len) == 0) + { + relative += db_path_len; + while (*relative == '/') + relative++; + } + } + + return relative; } notmuch_status_t -notmuch_database_set_timestamp (notmuch_database_t *notmuch, - const char *key, time_t timestamp) +notmuch_database_set_directory_mtime (notmuch_database_t *notmuch, + const char *path, + time_t mtime) { Xapian::Document doc; + Xapian::WritableDatabase *db; unsigned int doc_id; notmuch_private_status_t status; notmuch_status_t ret = NOTMUCH_STATUS_SUCCESS; - char *db_key = NULL; + const char *db_path = NULL; - db_key = timestamp_db_key (key); + if (notmuch->mode == NOTMUCH_DATABASE_MODE_READ_ONLY) { + fprintf (stderr, "Attempted to update a read-only database.\n"); + return NOTMUCH_STATUS_READONLY_DATABASE; + } + + db = static_cast (notmuch->xapian_db); + db_path = directory_db_path (path); try { - status = find_timestamp_document (notmuch, db_key, &doc, &doc_id); + status = find_directory_document (notmuch, db_path, &doc, &doc_id); doc.add_value (NOTMUCH_VALUE_TIMESTAMP, - Xapian::sortable_serialise (timestamp)); + Xapian::sortable_serialise (mtime)); if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { char *term = talloc_asprintf (NULL, "%s%s", - _find_prefix ("timestamp"), db_key); + _find_prefix ("directory"), db_path); doc.add_term (term); talloc_free (term); - notmuch->xapian_db->add_document (doc); + db->add_document (doc); } else { - notmuch->xapian_db->replace_document (doc_id, doc); + db->replace_document (doc_id, doc); } - } catch (Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", + } catch (const Xapian::Error &error) { + fprintf (stderr, "A Xapian exception occurred setting directory mtime: %s.\n", error.get_msg().c_str()); + notmuch->exception_reported = TRUE; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; } - if (db_key) - free (db_key); + if (db_path != path) + free ((char *) db_path); return ret; } time_t -notmuch_database_get_timestamp (notmuch_database_t *notmuch, const char *key) +notmuch_database_get_directory_mtime (notmuch_database_t *notmuch, + const char *path) { Xapian::Document doc; unsigned int doc_id; notmuch_private_status_t status; - char *db_key = NULL; + const char *db_path = NULL; time_t ret = 0; - db_key = timestamp_db_key (key); + db_path = directory_db_path (path); try { - status = find_timestamp_document (notmuch, db_key, &doc, &doc_id); + status = find_directory_document (notmuch, db_path, &doc, &doc_id); if (status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) goto DONE; ret = Xapian::sortable_unserialise (doc.get_value (NOTMUCH_VALUE_TIMESTAMP)); } catch (Xapian::Error &error) { + ret = 0; goto DONE; } DONE: - if (db_key) - free (db_key); + if (db_path != path) + free ((char *) db_path); return ret; } @@ -821,12 +889,11 @@ _notmuch_database_link_message_to_children (notmuch_database_t *notmuch, * * We first look at 'message_file' and its link-relevant headers * (References and In-Reply-To) for message IDs. We also look in the - * database for existing message that reference 'message'.p + * database for existing message that reference 'message'. * - * The end result is to call _notmuch_message_add_thread_id with one - * or more thread IDs to which this message belongs, (including - * generating a new thread ID if necessary if the message doesn't - * connect to any existing threads). + * The end result is to call _notmuch_message_ensure_thread_id which + * generates a new thread ID if the message doesn't connect to any + * existing threads. */ static notmuch_status_t _notmuch_database_link_message (notmuch_database_t *notmuch, @@ -865,7 +932,7 @@ notmuch_database_add_message (notmuch_database_t *notmuch, const char *date, *header; const char *from, *to, *subject; - char *message_id; + char *message_id = NULL; if (message_ret) *message_ret = NULL; @@ -896,9 +963,9 @@ notmuch_database_add_message (notmuch_database_t *notmuch, subject = notmuch_message_file_get_header (message_file, "subject"); to = notmuch_message_file_get_header (message_file, "to"); - if (from == NULL && - subject == NULL && - to == NULL) + if ((from == NULL || *from == '\0') && + (subject == NULL || *subject == '\0') && + (to == NULL || *to == '\0')) { ret = NOTMUCH_STATUS_FILE_NOT_EMAIL; goto DONE; @@ -908,13 +975,22 @@ notmuch_database_add_message (notmuch_database_t *notmuch, * is to find a message ID (or else create one ourselves). */ header = notmuch_message_file_get_header (message_file, "message-id"); - if (header) { + if (header && *header != '\0') { message_id = _parse_message_id (message_file, header, NULL); + /* So the header value isn't RFC-compliant, but it's * better than no message-id at all. */ if (message_id == NULL) message_id = talloc_strdup (message_file, header); - } else { + + /* Reject a Message ID that's too long. */ + if (message_id && strlen (message_id) + 1 > NOTMUCH_TERM_MAX) { + talloc_free (message_id); + message_id = NULL; + } + } + + if (message_id == NULL ) { /* No message-id at all, let's generate one by taking a * hash over the file's contents. */ char *sha1 = notmuch_sha1_of_file (filename); @@ -940,8 +1016,11 @@ notmuch_database_add_message (notmuch_database_t *notmuch, talloc_free (message_id); - if (message == NULL) + if (message == NULL) { + ret = COERCE_STATUS (private_status, + "Unexpected status value from _notmuch_message_create_for_message_id"); goto DONE; + } /* Is this a newly created message object? */ if (private_status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) { @@ -963,8 +1042,9 @@ notmuch_database_add_message (notmuch_database_t *notmuch, _notmuch_message_sync (message); } catch (const Xapian::Error &error) { - fprintf (stderr, "A Xapian exception occurred: %s.\n", - error.get_msg().c_str()); + fprintf (stderr, "A Xapian exception occurred adding message: %s.\n", + error.get_description().c_str()); + notmuch->exception_reported = TRUE; ret = NOTMUCH_STATUS_XAPIAN_EXCEPTION; goto DONE; } @@ -982,3 +1062,46 @@ notmuch_database_add_message (notmuch_database_t *notmuch, return ret; } + +notmuch_tags_t * +_notmuch_convert_tags (void *ctx, Xapian::TermIterator &i, + Xapian::TermIterator &end) +{ + const char *prefix = _find_prefix ("tag"); + notmuch_tags_t *tags; + std::string tag; + + /* Currently this iteration is written with the assumption that + * "tag" has a single-character prefix. */ + assert (strlen (prefix) == 1); + + tags = _notmuch_tags_create (ctx); + if (unlikely (tags == NULL)) + return NULL; + + i.skip_to (prefix); + + while (i != end) { + tag = *i; + + if (tag.empty () || tag[0] != *prefix) + break; + + _notmuch_tags_add_tag (tags, tag.c_str () + 1); + + i++; + } + + _notmuch_tags_prepare_iterator (tags); + + return tags; +} + +notmuch_tags_t * +notmuch_database_get_all_tags (notmuch_database_t *db) +{ + Xapian::TermIterator i, end; + i = db->xapian_db->allterms_begin(); + end = db->xapian_db->allterms_end(); + return _notmuch_convert_tags(db, i, end); +}