#include "notmuch-private.h"
#include "database-private.h"
+#include "xapian-extra.h"
#include <glib.h> /* GHashTable, GPtrArray */
notmuch_sort_t sort;
notmuch_string_list_t *exclude_terms;
notmuch_exclude_t omit_excluded;
+ bool parsed;
+ notmuch_query_syntax_t syntax;
+ Xapian::Query xapian_query;
+ std::set<std::string> terms;
};
typedef struct _notmuch_mset_messages {
#define DOCIDSET_WORD(bit) ((bit) / CHAR_BIT)
#define DOCIDSET_BIT(bit) ((bit) % CHAR_BIT)
-struct visible _notmuch_threads {
+struct _notmuch_threads {
notmuch_query_t *query;
/* The ordered list of doc ids matched by the query. */
};
/* We need this in the message functions so forward declare. */
-static notmuch_bool_t
+static bool
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr);
-static notmuch_bool_t
+static bool
_debug_query (void)
{
char *env = getenv ("NOTMUCH_DEBUG_QUERY");
+
return (env && strcmp (env, "") != 0);
}
-notmuch_query_t *
-notmuch_query_create (notmuch_database_t *notmuch,
- const char *query_string)
+/* Explicit destructor call for placement new */
+static int
+_notmuch_query_destructor (notmuch_query_t *query)
+{
+ query->xapian_query.~Query();
+ query->terms.~set<std::string>();
+ return 0;
+}
+
+static notmuch_query_t *
+_notmuch_query_constructor (notmuch_database_t *notmuch,
+ const char *query_string)
{
notmuch_query_t *query;
if (unlikely (query == NULL))
return NULL;
+ new (&query->xapian_query) Xapian::Query ();
+ new (&query->terms) std::set<std::string> ();
+ query->parsed = false;
+
+ talloc_set_destructor (query, _notmuch_query_destructor);
+
query->notmuch = notmuch;
- query->query_string = talloc_strdup (query, query_string);
+ if (query_string)
+ query->query_string = talloc_strdup (query, query_string);
+ else
+ query->query_string = NULL;
query->sort = NOTMUCH_SORT_NEWEST_FIRST;
return query;
}
+notmuch_query_t *
+notmuch_query_create (notmuch_database_t *notmuch,
+ const char *query_string)
+{
+
+ notmuch_query_t *query;
+ notmuch_status_t status;
+
+ status = notmuch_query_create_with_syntax (notmuch, query_string,
+ NOTMUCH_QUERY_SYNTAX_XAPIAN,
+ &query);
+ if (status)
+ return NULL;
+
+ return query;
+}
+
+notmuch_status_t
+notmuch_query_create_with_syntax (notmuch_database_t *notmuch,
+ const char *query_string,
+ notmuch_query_syntax_t syntax,
+ notmuch_query_t **output)
+{
+
+ notmuch_query_t *query;
+
+ if (! output)
+ return NOTMUCH_STATUS_NULL_POINTER;
+
+ query = _notmuch_query_constructor (notmuch, query_string);
+ if (! query)
+ return NOTMUCH_STATUS_OUT_OF_MEMORY;
+
+ if (syntax == NOTMUCH_QUERY_SYNTAX_SEXP && ! HAVE_SFSEXP) {
+ _notmuch_database_log (notmuch, "sexp query parser not available");
+ return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
+ }
+
+ query->syntax = syntax;
+
+ *output = query;
+
+ return NOTMUCH_STATUS_SUCCESS;
+}
+
+static void
+_notmuch_query_cache_terms (notmuch_query_t *query)
+{
+ /* Xapian doesn't support skip_to on terms from a query since
+ * they are unordered, so cache a copy of all terms in
+ * something searchable.
+ */
+
+ for (Xapian::TermIterator t = query->xapian_query.get_terms_begin ();
+ t != query->xapian_query.get_terms_end (); ++t)
+ query->terms.insert (*t);
+}
+
+notmuch_status_t
+_notmuch_query_string_to_xapian_query (notmuch_database_t *notmuch,
+ std::string query_string,
+ Xapian::Query &output,
+ std::string &msg)
+{
+ try {
+ if (query_string == "" || query_string == "*") {
+ output = xapian_query_match_all ();
+ } else {
+ output =
+ notmuch->query_parser->
+ parse_query (query_string, NOTMUCH_QUERY_PARSER_FLAGS);
+ }
+ } catch (const Xapian::Error &error) {
+ if (! notmuch->exception_reported) {
+ _notmuch_database_log (notmuch,
+ "A Xapian exception occurred parsing query: %s\n",
+ error.get_msg ().c_str ());
+ _notmuch_database_log_append (notmuch,
+ "Query string was: %s\n",
+ query_string.c_str ());
+ notmuch->exception_reported = true;
+ }
+
+ msg = error.get_msg ();
+ return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
+ }
+ return NOTMUCH_STATUS_SUCCESS;
+}
+
+static notmuch_status_t
+_notmuch_query_ensure_parsed_xapian (notmuch_query_t *query)
+{
+ notmuch_status_t status;
+ std::string msg; /* ignored */
+
+ status = _notmuch_query_string_to_xapian_query (query->notmuch, query->query_string,
+ query->xapian_query, msg);
+ if (status)
+ return status;
+
+ query->parsed = true;
+
+ _notmuch_query_cache_terms (query);
+
+ return NOTMUCH_STATUS_SUCCESS;
+}
+
+#if HAVE_SFSEXP
+static notmuch_status_t
+_notmuch_query_ensure_parsed_sexpr (notmuch_query_t *query)
+{
+ notmuch_status_t status;
+
+ if (query->parsed)
+ return NOTMUCH_STATUS_SUCCESS;
+
+ status = _notmuch_sexp_string_to_xapian_query (query->notmuch, query->query_string,
+ query->xapian_query);
+ if (status)
+ return status;
+
+ _notmuch_query_cache_terms (query);
+ return NOTMUCH_STATUS_SUCCESS;
+}
+#endif
+
+static notmuch_status_t
+_notmuch_query_ensure_parsed (notmuch_query_t *query)
+{
+ if (query->parsed)
+ return NOTMUCH_STATUS_SUCCESS;
+
+#if HAVE_SFSEXP
+ if (query->syntax == NOTMUCH_QUERY_SYNTAX_SEXP)
+ return _notmuch_query_ensure_parsed_sexpr (query);
+#endif
+
+ return _notmuch_query_ensure_parsed_xapian (query);
+}
+
const char *
notmuch_query_get_query_string (const notmuch_query_t *query)
{
return query->sort;
}
-void
+notmuch_status_t
notmuch_query_add_tag_exclude (notmuch_query_t *query, const char *tag)
{
- char *term = talloc_asprintf (query, "%s%s", _find_prefix ("tag"), tag);
+ notmuch_status_t status;
+ char *term;
+
+ status = _notmuch_query_ensure_parsed (query);
+ if (status)
+ return status;
+
+ term = talloc_asprintf (query, "%s%s", _find_prefix ("tag"), tag);
+ if (query->terms.count (term) != 0)
+ return NOTMUCH_STATUS_IGNORED;
+
_notmuch_string_list_append (query->exclude_terms, term);
+ return NOTMUCH_STATUS_SUCCESS;
}
/* We end up having to call the destructors explicitly because we had
}
/* Return a query that matches messages with the excluded tags
- * registered with query. Any tags that explicitly appear in xquery
- * will not be excluded, and will be removed from the list of exclude
- * tags. The caller of this function has to combine the returned
+ * registered with query. The caller of this function has to combine the returned
* query appropriately.*/
static Xapian::Query
-_notmuch_exclude_tags (notmuch_query_t *query, Xapian::Query xquery)
+_notmuch_exclude_tags (notmuch_query_t *query)
{
Xapian::Query exclude_query = Xapian::Query::MatchNothing;
for (notmuch_string_node_t *term = query->exclude_terms->head; term;
term = term->next) {
- Xapian::TermIterator it = xquery.get_terms_begin ();
- Xapian::TermIterator end = xquery.get_terms_end ();
- for (; it != end; it++) {
- if ((*it).compare (term->string) == 0)
- break;
- }
- if (it == end)
- exclude_query = Xapian::Query (Xapian::Query::OP_OR,
- exclude_query, Xapian::Query (term->string));
- else
- term->string = talloc_strdup (query, "");
+ exclude_query = Xapian::Query (Xapian::Query::OP_OR,
+ exclude_query, Xapian::Query (term->string));
}
return exclude_query;
}
-notmuch_messages_t *
-notmuch_query_search_messages (notmuch_query_t *query)
-{
- notmuch_status_t status;
- notmuch_messages_t *messages;
- status = notmuch_query_search_messages_st (query, &messages);
- if (status)
- return NULL;
- else
- return messages;
-}
notmuch_status_t
notmuch_query_search_messages_st (notmuch_query_t *query,
notmuch_messages_t **out)
+{
+ return notmuch_query_search_messages (query, out);
+}
+
+notmuch_status_t
+notmuch_query_search_messages (notmuch_query_t *query,
+ notmuch_messages_t **out)
{
return _notmuch_query_search_documents (query, "mail", out);
}
notmuch_messages_t **out)
{
notmuch_database_t *notmuch = query->notmuch;
- const char *query_string = query->query_string;
notmuch_mset_messages_t *messages;
+ notmuch_status_t status;
+
+ status = _notmuch_query_ensure_parsed (query);
+ if (status)
+ return status;
messages = talloc (query, notmuch_mset_messages_t);
if (unlikely (messages == NULL))
try {
- messages->base.is_of_list_type = FALSE;
+ messages->base.is_of_list_type = false;
messages->base.iterator = NULL;
messages->notmuch = notmuch;
new (&messages->iterator) Xapian::MSetIterator ();
Xapian::Query mail_query (talloc_asprintf (query, "%s%s",
_find_prefix ("type"),
type));
- Xapian::Query string_query, final_query, exclude_query;
+ Xapian::Query final_query, exclude_query;
Xapian::MSet mset;
Xapian::MSetIterator iterator;
- if (strcmp (query_string, "") == 0 ||
- strcmp (query_string, "*") == 0)
- {
- final_query = mail_query;
- } else {
- string_query = notmuch->query_parser->
- parse_query (query_string, NOTMUCH_QUERY_PARSER_FLAGS);
- final_query = Xapian::Query (Xapian::Query::OP_AND,
- mail_query, string_query);
- }
+ final_query = Xapian::Query (Xapian::Query::OP_AND,
+ mail_query, query->xapian_query);
+
messages->base.excluded_doc_ids = NULL;
if ((query->omit_excluded != NOTMUCH_EXCLUDE_FALSE) && (query->exclude_terms)) {
- exclude_query = _notmuch_exclude_tags (query, final_query);
+ exclude_query = _notmuch_exclude_tags (query);
if (query->omit_excluded == NOTMUCH_EXCLUDE_TRUE ||
- query->omit_excluded == NOTMUCH_EXCLUDE_ALL)
- {
+ query->omit_excluded == NOTMUCH_EXCLUDE_ALL) {
final_query = Xapian::Query (Xapian::Query::OP_AND_NOT,
final_query, exclude_query);
} else { /* NOTMUCH_EXCLUDE_FLAG */
exclude_query = Xapian::Query (Xapian::Query::OP_AND,
- exclude_query, final_query);
+ exclude_query, final_query);
- enquire.set_weighting_scheme (Xapian::BoolWeight());
+ enquire.set_weighting_scheme (Xapian::BoolWeight ());
enquire.set_query (exclude_query);
mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
- GArray *excluded_doc_ids = g_array_new (FALSE, FALSE, sizeof (unsigned int));
+ GArray *excluded_doc_ids = g_array_new (false, false, sizeof (unsigned int));
for (iterator = mset.begin (); iterator != mset.end (); iterator++) {
unsigned int doc_id = *iterator;
}
- enquire.set_weighting_scheme (Xapian::BoolWeight());
+ enquire.set_weighting_scheme (Xapian::BoolWeight ());
switch (query->sort) {
case NOTMUCH_SORT_OLDEST_FIRST:
- enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, FALSE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, false);
break;
case NOTMUCH_SORT_NEWEST_FIRST:
- enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, TRUE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_TIMESTAMP, true);
break;
case NOTMUCH_SORT_MESSAGE_ID:
- enquire.set_sort_by_value (NOTMUCH_VALUE_MESSAGE_ID, FALSE);
+ enquire.set_sort_by_value (NOTMUCH_VALUE_MESSAGE_ID, false);
break;
case NOTMUCH_SORT_UNSORTED:
break;
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch,
"A Xapian exception occurred performing query: %s\n",
- error.get_msg().c_str());
+ error.get_msg ().c_str ());
_notmuch_database_log_append (notmuch,
- "Query string was: %s\n",
- query->query_string);
+ "Query string was: %s\n",
+ query->query_string);
- notmuch->exception_reported = TRUE;
+ notmuch->exception_reported = true;
talloc_free (messages);
return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
}
}
-notmuch_bool_t
+bool
_notmuch_mset_messages_valid (notmuch_messages_t *messages)
{
notmuch_mset_messages_t *mset_messages;
&status);
if (message == NULL &&
- status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND)
- {
+ status == NOTMUCH_PRIVATE_STATUS_NO_DOCUMENT_FOUND) {
INTERNAL_ERROR ("a messages iterator contains a non-existent document ID.\n");
}
if (messages->excluded_doc_ids &&
_notmuch_doc_id_set_contains (messages->excluded_doc_ids, doc_id))
- notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, TRUE);
+ notmuch_message_set_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED, true);
return message;
}
mset_messages->iterator++;
}
-static notmuch_bool_t
+static bool
_notmuch_doc_id_set_init (void *ctx,
notmuch_doc_id_set_t *doc_ids,
GArray *arr)
unsigned char *bitmap;
for (unsigned int i = 0; i < arr->len; i++)
- max = MAX(max, g_array_index (arr, unsigned int, i));
- bitmap = talloc_zero_array (ctx, unsigned char, DOCIDSET_WORD(max) + 1);
+ max = MAX (max, g_array_index (arr, unsigned int, i));
+ bitmap = talloc_zero_array (ctx, unsigned char, DOCIDSET_WORD (max) + 1);
if (bitmap == NULL)
- return FALSE;
+ return false;
doc_ids->bitmap = bitmap;
doc_ids->bound = max + 1;
for (unsigned int i = 0; i < arr->len; i++) {
unsigned int doc_id = g_array_index (arr, unsigned int, i);
- bitmap[DOCIDSET_WORD(doc_id)] |= 1 << DOCIDSET_BIT(doc_id);
+ bitmap[DOCIDSET_WORD (doc_id)] |= 1 << DOCIDSET_BIT (doc_id);
}
- return TRUE;
+ return true;
}
-notmuch_bool_t
+bool
_notmuch_doc_id_set_contains (notmuch_doc_id_set_t *doc_ids,
unsigned int doc_id)
{
if (doc_id >= doc_ids->bound)
- return FALSE;
- return doc_ids->bitmap[DOCIDSET_WORD(doc_id)] & (1 << DOCIDSET_BIT(doc_id));
+ return false;
+ return doc_ids->bitmap[DOCIDSET_WORD (doc_id)] & (1 << DOCIDSET_BIT (doc_id));
}
void
unsigned int doc_id)
{
if (doc_id < doc_ids->bound)
- doc_ids->bitmap[DOCIDSET_WORD(doc_id)] &= ~(1 << DOCIDSET_BIT(doc_id));
+ doc_ids->bitmap[DOCIDSET_WORD (doc_id)] &= ~(1 << DOCIDSET_BIT (doc_id));
}
/* Glib objects force use to use a talloc destructor as well, (but not
return 0;
}
-
-notmuch_threads_t *
-notmuch_query_search_threads (notmuch_query_t *query)
+notmuch_status_t
+notmuch_query_search_threads_st (notmuch_query_t *query, notmuch_threads_t **out)
{
- notmuch_status_t status;
- notmuch_threads_t *threads;
- status = notmuch_query_search_threads_st (query, &threads);
- if (status)
- return NULL;
- else
- return threads;
+ return notmuch_query_search_threads (query, out);
}
notmuch_status_t
-notmuch_query_search_threads_st (notmuch_query_t *query,
- notmuch_threads_t **out)
+notmuch_query_search_threads (notmuch_query_t *query,
+ notmuch_threads_t **out)
{
notmuch_threads_t *threads;
notmuch_messages_t *messages;
threads->query = query;
- status = notmuch_query_search_messages_st (query, &messages);
+ status = notmuch_query_search_messages (query, &messages);
if (status) {
talloc_free (threads);
return status;
}
- threads->doc_ids = g_array_new (FALSE, FALSE, sizeof (unsigned int));
+ threads->doc_ids = g_array_new (false, false, sizeof (unsigned int));
while (notmuch_messages_valid (messages)) {
unsigned int doc_id = _notmuch_mset_messages_get_doc_id (messages);
g_array_append_val (threads->doc_ids, doc_id);
unsigned int doc_id;
if (! threads)
- return FALSE;
+ return false;
while (threads->doc_id_pos < threads->doc_ids->len) {
doc_id = g_array_index (threads->doc_ids, unsigned int,
talloc_free (threads);
}
-unsigned int
-notmuch_query_count_messages (notmuch_query_t *query)
+notmuch_status_t
+notmuch_query_count_messages_st (notmuch_query_t *query, unsigned *count_out)
{
- notmuch_status_t status;
- unsigned int count;
-
- status = notmuch_query_count_messages_st (query, &count);
- return status ? 0 : count;
+ return notmuch_query_count_messages (query, count_out);
}
notmuch_status_t
-notmuch_query_count_messages_st (notmuch_query_t *query, unsigned *count_out)
+notmuch_query_count_messages (notmuch_query_t *query, unsigned *count_out)
{
return _notmuch_query_count_documents (query, "mail", count_out);
}
_notmuch_query_count_documents (notmuch_query_t *query, const char *type, unsigned *count_out)
{
notmuch_database_t *notmuch = query->notmuch;
- const char *query_string = query->query_string;
Xapian::doccount count = 0;
+ notmuch_status_t status;
+
+ status = _notmuch_query_ensure_parsed (query);
+ if (status)
+ return status;
try {
Xapian::Enquire enquire (*notmuch->xapian_db);
Xapian::Query mail_query (talloc_asprintf (query, "%s%s",
_find_prefix ("type"),
type));
- Xapian::Query string_query, final_query, exclude_query;
+ Xapian::Query final_query, exclude_query;
Xapian::MSet mset;
- if (strcmp (query_string, "") == 0 ||
- strcmp (query_string, "*") == 0)
- {
- final_query = mail_query;
- } else {
- string_query = notmuch->query_parser->
- parse_query (query_string, NOTMUCH_QUERY_PARSER_FLAGS);
- final_query = Xapian::Query (Xapian::Query::OP_AND,
- mail_query, string_query);
- }
+ final_query = Xapian::Query (Xapian::Query::OP_AND,
+ mail_query, query->xapian_query);
- exclude_query = _notmuch_exclude_tags (query, final_query);
+ exclude_query = _notmuch_exclude_tags (query);
final_query = Xapian::Query (Xapian::Query::OP_AND_NOT,
- final_query, exclude_query);
+ final_query, exclude_query);
- enquire.set_weighting_scheme(Xapian::BoolWeight());
- enquire.set_docid_order(Xapian::Enquire::ASCENDING);
+ enquire.set_weighting_scheme (Xapian::BoolWeight ());
+ enquire.set_docid_order (Xapian::Enquire::ASCENDING);
if (_debug_query ()) {
fprintf (stderr, "Exclude query is:\n%s\n",
/*
* Set the checkatleast parameter to the number of documents
* in the database to make get_matches_estimated() exact.
- * Set the max parameter to 0 to avoid fetching documents we will discard.
+ * Set the max parameter to 1 to avoid fetching documents we will discard.
*/
- mset = enquire.get_mset (0, 0,
+ mset = enquire.get_mset (0, 1,
notmuch->xapian_db->get_doccount ());
- count = mset.get_matches_estimated();
+ count = mset.get_matches_estimated ();
} catch (const Xapian::Error &error) {
_notmuch_database_log (notmuch,
"A Xapian exception occurred performing query: %s\n",
- error.get_msg().c_str());
+ error.get_msg ().c_str ());
_notmuch_database_log_append (notmuch,
"Query string was: %s\n",
query->query_string);
return NOTMUCH_STATUS_SUCCESS;
}
-unsigned
-notmuch_query_count_threads (notmuch_query_t *query)
+notmuch_status_t
+notmuch_query_count_threads_st (notmuch_query_t *query, unsigned *count)
{
- notmuch_status_t status;
- unsigned int count;
-
- status = notmuch_query_count_threads_st (query, &count);
- return status ? 0 : count;
+ return notmuch_query_count_threads (query, count);
}
notmuch_status_t
-notmuch_query_count_threads_st (notmuch_query_t *query, unsigned *count)
+notmuch_query_count_threads (notmuch_query_t *query, unsigned *count)
{
notmuch_messages_t *messages;
GHashTable *hash;
sort = query->sort;
query->sort = NOTMUCH_SORT_UNSORTED;
- ret = notmuch_query_search_messages_st (query, &messages);
+ ret = notmuch_query_search_messages (query, &messages);
if (ret)
return ret;
query->sort = sort;
{
return query->notmuch;
}
+
+notmuch_status_t
+_notmuch_query_expand (notmuch_database_t *notmuch, const char *field, Xapian::Query subquery,
+ Xapian::Query &output, std::string &msg)
+{
+ std::set<std::string> terms;
+ const std::string term_prefix = _find_prefix (field);
+
+ if (_debug_query ()) {
+ fprintf (stderr, "Expanding subquery:\n%s\n",
+ subquery.get_description ().c_str ());
+ }
+
+ try {
+ Xapian::Enquire enquire (*notmuch->xapian_db);
+ Xapian::MSet mset;
+
+ enquire.set_weighting_scheme (Xapian::BoolWeight ());
+ enquire.set_query (subquery);
+
+ mset = enquire.get_mset (0, notmuch->xapian_db->get_doccount ());
+
+ for (Xapian::MSetIterator iterator = mset.begin (); iterator != mset.end (); iterator++) {
+ Xapian::docid doc_id = *iterator;
+ Xapian::Document doc = notmuch->xapian_db->get_document (doc_id);
+ Xapian::TermIterator i = doc.termlist_begin ();
+
+ for (i.skip_to (term_prefix);
+ i != doc.termlist_end () && ((*i).rfind (term_prefix, 0) == 0); i++) {
+ terms.insert (*i);
+ }
+ }
+ output = Xapian::Query (Xapian::Query::OP_OR, terms.begin (), terms.end ());
+ if (_debug_query ()) {
+ fprintf (stderr, "Expanded query:\n%s\n",
+ subquery.get_description ().c_str ());
+ }
+
+ } catch (const Xapian::Error &error) {
+ _notmuch_database_log (notmuch,
+ "A Xapian exception occurred expanding query: %s\n",
+ error.get_msg ().c_str ());
+ msg = error.get_msg ();
+ return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
+ }
+
+ return NOTMUCH_STATUS_SUCCESS;
+}
projects / notmuch / blobdiff