2010-11-22 23:33:15 +01:00
|
|
|
/*
|
2011-01-04 22:44:18 +01:00
|
|
|
** Copyright (C) 2008-2011 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
|
2009-11-25 21:55:06 +01:00
|
|
|
**
|
|
|
|
** 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, write to the Free Software Foundation,
|
|
|
|
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
**
|
|
|
|
*/
|
|
|
|
|
2010-11-22 23:33:15 +01:00
|
|
|
#include <stdexcept>
|
|
|
|
#include <string>
|
|
|
|
#include <cctype>
|
|
|
|
#include <cstring>
|
2009-11-25 21:55:06 +01:00
|
|
|
#include <stdlib.h>
|
2010-11-22 23:33:15 +01:00
|
|
|
|
2009-11-25 21:55:06 +01:00
|
|
|
#include <xapian.h>
|
|
|
|
#include <glib/gstdio.h>
|
|
|
|
|
2010-08-25 20:46:16 +02:00
|
|
|
#include "mu-query.h"
|
2010-11-22 23:33:15 +01:00
|
|
|
#include "mu-msg-fields.h"
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-08-25 20:29:53 +02:00
|
|
|
#include "mu-msg-iter.h"
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-01-05 07:32:23 +01:00
|
|
|
#include "mu-util.h"
|
2010-11-22 23:44:18 +01:00
|
|
|
#include "mu-str.h"
|
2010-01-05 07:32:23 +01:00
|
|
|
|
2010-11-22 23:33:15 +01:00
|
|
|
/*
|
2010-11-23 21:06:57 +01:00
|
|
|
* custom parser for date ranges
|
|
|
|
*/
|
2010-11-22 23:33:15 +01:00
|
|
|
class MuDateRangeProcessor : public Xapian::ValueRangeProcessor {
|
|
|
|
public:
|
|
|
|
MuDateRangeProcessor() {}
|
|
|
|
|
|
|
|
Xapian::valueno operator()(std::string &begin, std::string &end) {
|
|
|
|
|
|
|
|
if (!clear_prefix (begin))
|
|
|
|
return Xapian::BAD_VALUENO;
|
2011-05-22 09:26:20 +02:00
|
|
|
|
|
|
|
// now and begin should only appear at the end, so
|
|
|
|
// correct them...
|
|
|
|
if (begin == "today" || begin == "now")
|
|
|
|
std::swap (begin, end);
|
2011-05-21 19:20:07 +02:00
|
|
|
|
2010-11-24 22:30:41 +01:00
|
|
|
substitute_date (begin);
|
|
|
|
substitute_date (end);
|
2010-11-22 23:33:15 +01:00
|
|
|
|
|
|
|
normalize_date (begin);
|
|
|
|
normalize_date (end);
|
2011-05-21 08:14:02 +02:00
|
|
|
|
|
|
|
// note, we'll have to compare the *completed*
|
|
|
|
// versions of begin and end to if the were specified
|
|
|
|
// in the opposite order; however, if that is true, we
|
|
|
|
// have to complete begin, end 'for real', as the
|
|
|
|
// begin date is completed to the begin of the
|
|
|
|
// interval, and the to the end of the interval
|
2011-05-21 19:20:07 +02:00
|
|
|
// ie. begin: 2008 -> 200801010000 end: 2008 ->
|
|
|
|
// 200812312359
|
2011-05-21 08:14:02 +02:00
|
|
|
if (complete_date12(begin,true) >
|
|
|
|
complete_date12(end, false))
|
|
|
|
std::swap (begin, end);
|
2010-11-23 21:06:57 +01:00
|
|
|
|
2011-05-21 08:14:02 +02:00
|
|
|
begin = complete_date12(begin,true);
|
|
|
|
end = complete_date12(end, false);
|
2010-11-22 23:33:15 +01:00
|
|
|
|
|
|
|
return (Xapian::valueno)MU_MSG_PSEUDO_FIELD_ID_DATESTR;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
bool clear_prefix (std::string& begin) {
|
|
|
|
|
|
|
|
const std::string colon (":");
|
2010-11-24 22:30:41 +01:00
|
|
|
const std::string name (mu_msg_field_name
|
|
|
|
(MU_MSG_FIELD_ID_DATE) + colon);
|
2010-11-22 23:33:15 +01:00
|
|
|
const std::string shortcut (
|
|
|
|
std::string(1, mu_msg_field_shortcut
|
|
|
|
(MU_MSG_FIELD_ID_DATE)) + colon);
|
|
|
|
|
|
|
|
if (begin.find (name) == 0) {
|
|
|
|
begin.erase (0, name.length());
|
|
|
|
return true;
|
|
|
|
} else if (begin.find (shortcut) == 0) {
|
|
|
|
begin.erase (0, shortcut.length());
|
|
|
|
return true;
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-11-24 22:30:41 +01:00
|
|
|
void substitute_date (std::string& date) {
|
2010-11-22 23:33:15 +01:00
|
|
|
char datebuf[13];
|
|
|
|
time_t now = time(NULL);
|
2010-11-24 22:30:41 +01:00
|
|
|
|
|
|
|
if (date == "today") {
|
|
|
|
strftime(datebuf, sizeof(datebuf), "%Y%m%d0000",
|
|
|
|
localtime(&now));
|
|
|
|
date = datebuf;
|
|
|
|
} else if (date == "now") {
|
|
|
|
strftime(datebuf, sizeof(datebuf), "%Y%m%d%H%M",
|
|
|
|
localtime(&now));
|
|
|
|
date = datebuf;
|
|
|
|
} else {
|
|
|
|
time_t t;
|
2010-11-30 21:33:15 +01:00
|
|
|
t = mu_str_date_parse_hdwmy (date.c_str());
|
2010-11-24 22:30:41 +01:00
|
|
|
if (t != (time_t)-1) {
|
2010-11-22 23:33:15 +01:00
|
|
|
strftime(datebuf, sizeof(datebuf), "%Y%m%d%H%M",
|
2010-11-24 22:30:41 +01:00
|
|
|
localtime(&t));
|
2010-11-22 23:33:15 +01:00
|
|
|
date = datebuf;
|
|
|
|
}
|
2010-11-24 22:30:41 +01:00
|
|
|
}
|
2010-11-22 23:33:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void normalize_date (std::string& date) {
|
|
|
|
std::string cleanup;
|
|
|
|
for (unsigned i = 0; i != date.length(); ++i) {
|
|
|
|
char k = date[i];
|
|
|
|
if (std::isdigit(k))
|
|
|
|
cleanup += date[i];
|
|
|
|
}
|
|
|
|
date = cleanup;
|
|
|
|
}
|
2010-11-21 17:12:01 +01:00
|
|
|
|
2011-05-21 08:14:02 +02:00
|
|
|
std::string complete_date12 (const std::string date, bool is_begin) const {
|
2010-11-23 21:06:57 +01:00
|
|
|
|
2011-05-21 08:14:02 +02:00
|
|
|
std::string compdate;
|
2010-11-23 21:06:57 +01:00
|
|
|
const std::string bsuffix ("00000101000000");
|
|
|
|
const std::string esuffix ("99991231235959");
|
2011-05-21 08:14:02 +02:00
|
|
|
const size_t size = 12;
|
|
|
|
|
2010-11-23 21:06:57 +01:00
|
|
|
if (is_begin)
|
2011-05-21 08:14:02 +02:00
|
|
|
compdate = std::string (date + bsuffix.substr (date.length()));
|
2010-11-23 21:06:57 +01:00
|
|
|
else
|
2011-05-21 08:14:02 +02:00
|
|
|
compdate = std::string (date + esuffix.substr (date.length()));
|
2010-11-22 23:33:15 +01:00
|
|
|
|
2011-05-21 08:14:02 +02:00
|
|
|
return compdate.substr (0, size);
|
2010-11-22 23:33:15 +01:00
|
|
|
}
|
2010-11-21 17:12:01 +01:00
|
|
|
};
|
|
|
|
|
2010-11-22 23:33:15 +01:00
|
|
|
|
2011-01-06 15:21:09 +01:00
|
|
|
class MuSizeRangeProcessor : public Xapian::NumberValueRangeProcessor {
|
|
|
|
public:
|
2011-03-22 22:37:01 +01:00
|
|
|
MuSizeRangeProcessor():
|
|
|
|
Xapian::NumberValueRangeProcessor(MU_MSG_FIELD_ID_SIZE) {
|
2011-01-06 15:21:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Xapian::valueno operator()(std::string &begin, std::string &end) {
|
|
|
|
|
|
|
|
if (!clear_prefix (begin))
|
|
|
|
return Xapian::BAD_VALUENO;
|
|
|
|
|
|
|
|
if (!substitute_size (begin) || !substitute_size (end))
|
|
|
|
return Xapian::BAD_VALUENO;
|
|
|
|
|
2011-05-21 08:14:02 +02:00
|
|
|
/* swap if b > e */
|
|
|
|
if (begin > end)
|
|
|
|
std::swap (begin, end);
|
|
|
|
|
|
|
|
begin = Xapian::sortable_serialise (atol(begin.c_str()));
|
|
|
|
end = Xapian::sortable_serialise (atol(end.c_str()));
|
|
|
|
|
2011-01-06 15:21:09 +01:00
|
|
|
return (Xapian::valueno)MU_MSG_FIELD_ID_SIZE;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
bool clear_prefix (std::string& begin) {
|
|
|
|
|
|
|
|
const std::string colon (":");
|
|
|
|
const std::string name (mu_msg_field_name
|
|
|
|
(MU_MSG_FIELD_ID_SIZE) + colon);
|
|
|
|
const std::string shortcut (
|
|
|
|
std::string(1, mu_msg_field_shortcut
|
|
|
|
(MU_MSG_FIELD_ID_SIZE)) + colon);
|
|
|
|
|
|
|
|
if (begin.find (name) == 0) {
|
|
|
|
begin.erase (0, name.length());
|
|
|
|
return true;
|
|
|
|
} else if (begin.find (shortcut) == 0) {
|
|
|
|
begin.erase (0, shortcut.length());
|
|
|
|
return true;
|
|
|
|
} else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool substitute_size (std::string& size) {
|
|
|
|
gchar str[16];
|
|
|
|
guint64 num = mu_str_size_parse_kmg (size.c_str());
|
|
|
|
if (num == G_MAXUINT64)
|
|
|
|
return false;
|
|
|
|
snprintf (str, sizeof(str), "%" G_GUINT64_FORMAT, num);
|
|
|
|
size = str;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-11-20 13:43:04 +01:00
|
|
|
static void add_prefix (MuMsgFieldId field, Xapian::QueryParser* qparser);
|
2009-12-05 19:10:58 +01:00
|
|
|
|
2010-08-25 20:46:16 +02:00
|
|
|
struct _MuQuery {
|
2011-03-22 22:37:01 +01:00
|
|
|
_MuQuery (const char* dbpath):
|
|
|
|
_db (Xapian::Database(dbpath)) {
|
2009-12-05 19:10:58 +01:00
|
|
|
|
2011-03-22 22:37:01 +01:00
|
|
|
_qparser.set_database (_db);
|
|
|
|
_qparser.set_default_op (Xapian::Query::OP_AND);
|
|
|
|
|
|
|
|
_qparser.add_valuerangeprocessor (&_date_range_processor);
|
|
|
|
_qparser.add_valuerangeprocessor (&_size_range_processor);
|
2010-11-21 17:12:01 +01:00
|
|
|
|
2009-12-05 19:10:58 +01:00
|
|
|
mu_msg_field_foreach ((MuMsgFieldForEachFunc)add_prefix,
|
2011-03-22 22:37:01 +01:00
|
|
|
&_qparser);
|
|
|
|
}
|
2010-11-22 23:33:15 +01:00
|
|
|
|
2011-03-22 22:37:01 +01:00
|
|
|
Xapian::Database _db;
|
|
|
|
Xapian::QueryParser _qparser;
|
|
|
|
MuDateRangeProcessor _date_range_processor;
|
|
|
|
MuSizeRangeProcessor _size_range_processor;
|
|
|
|
};
|
2009-12-08 23:01:49 +01:00
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
static bool
|
|
|
|
set_query (MuQuery *mqx, Xapian::Query& q, const char* searchexpr,
|
|
|
|
GError **err) {
|
2009-12-08 23:01:49 +01:00
|
|
|
try {
|
2011-03-22 22:37:01 +01:00
|
|
|
q = mqx->_qparser.parse_query
|
2009-12-05 19:10:58 +01:00
|
|
|
(searchexpr,
|
2010-11-21 14:42:53 +01:00
|
|
|
Xapian::QueryParser::FLAG_BOOLEAN |
|
|
|
|
Xapian::QueryParser::FLAG_PURE_NOT |
|
2011-05-09 08:33:33 +02:00
|
|
|
Xapian::QueryParser::FLAG_WILDCARD |
|
2010-11-20 13:43:04 +01:00
|
|
|
Xapian::QueryParser::FLAG_AUTO_SYNONYMS |
|
2010-09-12 15:30:29 +02:00
|
|
|
Xapian::QueryParser::FLAG_BOOLEAN_ANY_CASE);
|
2010-11-23 23:47:36 +01:00
|
|
|
|
|
|
|
return true;
|
2010-11-20 13:43:04 +01:00
|
|
|
|
2010-01-06 00:30:45 +01:00
|
|
|
} MU_XAPIAN_CATCH_BLOCK;
|
2010-01-31 13:17:23 +01:00
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
/* some error occured */
|
|
|
|
g_set_error (err, 0, MU_ERROR_QUERY, "parse error in query '%s'",
|
|
|
|
searchexpr);
|
2009-12-11 21:06:49 +01:00
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
return false;
|
2009-12-08 23:01:49 +01:00
|
|
|
}
|
2009-11-25 21:55:06 +01:00
|
|
|
|
|
|
|
static void
|
2010-11-20 13:43:04 +01:00
|
|
|
add_prefix (MuMsgFieldId mfid, Xapian::QueryParser* qparser)
|
2009-11-25 21:55:06 +01:00
|
|
|
{
|
2010-11-20 13:43:04 +01:00
|
|
|
if (!mu_msg_field_xapian_index(mfid) &&
|
|
|
|
!mu_msg_field_xapian_term(mfid) &&
|
|
|
|
!mu_msg_field_xapian_contact(mfid))
|
2009-11-25 21:55:06 +01:00
|
|
|
return;
|
2009-12-08 23:01:49 +01:00
|
|
|
|
2010-11-20 13:43:04 +01:00
|
|
|
try {
|
2010-11-20 15:37:23 +01:00
|
|
|
const std::string pfx
|
|
|
|
(1, mu_msg_field_xapian_prefix (mfid));
|
|
|
|
const std::string shortcut
|
|
|
|
(1, mu_msg_field_shortcut (mfid));
|
2011-05-20 20:30:04 +02:00
|
|
|
|
|
|
|
if (mu_msg_field_uses_boolean_prefix (mfid)) {
|
|
|
|
qparser->add_boolean_prefix
|
|
|
|
(mu_msg_field_name(mfid), pfx);
|
|
|
|
qparser->add_boolean_prefix (shortcut, pfx);
|
2010-11-20 13:43:04 +01:00
|
|
|
} else {
|
2011-05-20 20:30:04 +02:00
|
|
|
qparser->add_prefix
|
2010-11-20 13:43:04 +01:00
|
|
|
(mu_msg_field_name(mfid), pfx);
|
2011-05-20 20:30:04 +02:00
|
|
|
qparser->add_prefix (shortcut, pfx);
|
2010-11-20 13:43:04 +01:00
|
|
|
}
|
2011-05-20 20:30:04 +02:00
|
|
|
|
|
|
|
if (!mu_msg_field_needs_prefix(mfid))
|
|
|
|
qparser->add_prefix ("", pfx);
|
|
|
|
|
2010-11-20 13:43:04 +01:00
|
|
|
} MU_XAPIAN_CATCH_BLOCK;
|
2009-11-25 21:55:06 +01:00
|
|
|
}
|
|
|
|
|
2010-08-25 20:46:16 +02:00
|
|
|
MuQuery*
|
2010-11-23 23:47:36 +01:00
|
|
|
mu_query_new (const char* xpath, GError **err)
|
2009-11-25 21:55:06 +01:00
|
|
|
{
|
2010-01-06 00:30:45 +01:00
|
|
|
g_return_val_if_fail (xpath, NULL);
|
2011-03-22 22:37:01 +01:00
|
|
|
|
2010-01-06 00:30:45 +01:00
|
|
|
if (!mu_util_check_dir (xpath, TRUE, FALSE)) {
|
2010-11-23 23:47:36 +01:00
|
|
|
g_set_error (err, 0, MU_ERROR_XAPIAN_DIR,
|
|
|
|
"'%s' is not a readable xapian dir", xpath);
|
2009-11-25 21:55:06 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-11-23 23:47:36 +01:00
|
|
|
|
2011-01-12 22:13:03 +01:00
|
|
|
if (mu_util_xapian_needs_upgrade (xpath)) {
|
2010-11-23 23:47:36 +01:00
|
|
|
g_set_error (err, 0, MU_ERROR_XAPIAN_NOT_UPTODATE,
|
|
|
|
"%s is not up-to-date, needs a full update",
|
|
|
|
xpath);
|
2010-01-23 19:50:06 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-11-23 23:47:36 +01:00
|
|
|
|
2011-01-12 22:13:03 +01:00
|
|
|
if (mu_util_xapian_is_empty (xpath))
|
2010-11-23 23:47:36 +01:00
|
|
|
g_warning ("database %s is empty; nothing to do", xpath);
|
2010-01-06 00:30:45 +01:00
|
|
|
|
2011-03-22 22:37:01 +01:00
|
|
|
try {
|
|
|
|
|
|
|
|
return new MuQuery (xpath);
|
|
|
|
|
|
|
|
} MU_XAPIAN_CATCH_BLOCK_G_ERROR_RETURN (err, MU_ERROR_XAPIAN, NULL);
|
|
|
|
|
|
|
|
return 0;
|
2009-11-25 21:55:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2010-08-25 20:46:16 +02:00
|
|
|
mu_query_destroy (MuQuery *self)
|
2009-11-25 21:55:06 +01:00
|
|
|
{
|
2011-03-22 22:37:01 +01:00
|
|
|
try { delete self; } MU_XAPIAN_CATCH_BLOCK;
|
2010-09-12 15:30:29 +02:00
|
|
|
}
|
2009-12-11 18:44:05 +01:00
|
|
|
|
2010-09-12 15:30:29 +02:00
|
|
|
|
2010-09-09 07:21:01 +02:00
|
|
|
/* preprocess a query to make them a bit more permissive */
|
2010-09-12 15:30:29 +02:00
|
|
|
char*
|
|
|
|
mu_query_preprocess (const char *query)
|
2010-09-09 07:21:01 +02:00
|
|
|
{
|
|
|
|
gchar *my_query;
|
2010-09-12 15:30:29 +02:00
|
|
|
|
|
|
|
g_return_val_if_fail (query, NULL);
|
2010-11-29 20:29:43 +01:00
|
|
|
my_query = g_strdup (query);
|
2010-09-09 07:21:01 +02:00
|
|
|
|
2010-11-29 20:29:43 +01:00
|
|
|
/* remove accents and turn to lower-case */
|
|
|
|
mu_str_normalize_in_place (my_query, TRUE);
|
|
|
|
/* escape '@', single '_' and ':' if it's not following a
|
|
|
|
* xapian-pfx with '_' */
|
|
|
|
mu_str_ascii_xapian_escape_in_place (my_query);
|
|
|
|
|
2010-09-09 07:21:01 +02:00
|
|
|
return my_query;
|
|
|
|
}
|
|
|
|
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-08-25 20:29:53 +02:00
|
|
|
MuMsgIter*
|
2011-06-19 20:03:33 +02:00
|
|
|
mu_query_run (MuQuery *self, const char* searchexpr, gboolean threads,
|
2010-11-20 13:43:04 +01:00
|
|
|
MuMsgFieldId sortfieldid, gboolean ascending,
|
2011-06-02 16:35:46 +02:00
|
|
|
GError **err)
|
2009-11-25 21:55:06 +01:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (self, NULL);
|
2010-01-23 23:51:17 +01:00
|
|
|
g_return_val_if_fail (searchexpr, NULL);
|
2010-11-20 13:43:04 +01:00
|
|
|
g_return_val_if_fail (mu_msg_field_id_is_valid (sortfieldid) ||
|
2010-11-23 22:52:37 +01:00
|
|
|
sortfieldid == MU_MSG_FIELD_ID_NONE,
|
|
|
|
NULL);
|
2010-01-23 23:51:17 +01:00
|
|
|
try {
|
2010-11-23 23:47:36 +01:00
|
|
|
Xapian::Query query;
|
2010-09-09 07:21:01 +02:00
|
|
|
char *preprocessed;
|
2011-06-02 16:35:46 +02:00
|
|
|
|
2010-11-11 21:06:19 +01:00
|
|
|
preprocessed = mu_query_preprocess (searchexpr);
|
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
if (!set_query(self, query, preprocessed, err)) {
|
2010-09-09 07:21:01 +02:00
|
|
|
g_free (preprocessed);
|
2010-02-03 20:06:31 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-09-09 07:21:01 +02:00
|
|
|
g_free (preprocessed);
|
2010-09-05 20:21:26 +02:00
|
|
|
|
2011-03-22 22:37:01 +01:00
|
|
|
Xapian::Enquire enq (self->_db);
|
2010-01-24 12:15:04 +01:00
|
|
|
|
2011-07-02 10:27:08 +02:00
|
|
|
/* note, when our result will be *threaded*, we sort
|
|
|
|
* there, and don't let Xapian do any sorting */
|
|
|
|
if (!threads && sortfieldid != MU_MSG_FIELD_ID_NONE)
|
2010-11-23 22:52:37 +01:00
|
|
|
enq.set_sort_by_value ((Xapian::valueno)sortfieldid,
|
|
|
|
ascending ? true : false);
|
2010-11-23 23:47:36 +01:00
|
|
|
enq.set_query(query);
|
2010-01-23 23:51:17 +01:00
|
|
|
enq.set_cutoff(0,0);
|
2010-11-23 22:52:37 +01:00
|
|
|
|
2011-07-02 10:27:08 +02:00
|
|
|
return mu_msg_iter_new (
|
|
|
|
(XapianEnquire*)&enq,
|
|
|
|
self->_db.get_doccount(), threads,
|
|
|
|
threads ? sortfieldid : MU_MSG_FIELD_ID_NONE);
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-01-08 19:49:55 +01:00
|
|
|
} MU_XAPIAN_CATCH_BLOCK_RETURN(NULL);
|
2009-11-25 21:55:06 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
char*
|
2011-03-22 22:37:01 +01:00
|
|
|
mu_query_as_string (MuQuery *self, const char *searchexpr, GError **err)
|
2009-11-25 21:55:06 +01:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (self, NULL);
|
|
|
|
g_return_val_if_fail (searchexpr, NULL);
|
|
|
|
|
|
|
|
try {
|
2010-11-23 23:47:36 +01:00
|
|
|
Xapian::Query query;
|
2010-11-14 15:39:21 +01:00
|
|
|
char *preprocessed;
|
2010-11-20 13:43:04 +01:00
|
|
|
|
2010-11-14 15:39:21 +01:00
|
|
|
preprocessed = mu_query_preprocess (searchexpr);
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
if (!set_query(self, query, preprocessed, err)) {
|
|
|
|
g_free (preprocessed);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-11-14 15:39:21 +01:00
|
|
|
g_free (preprocessed);
|
2010-01-13 21:35:16 +01:00
|
|
|
|
2010-11-23 23:47:36 +01:00
|
|
|
return g_strdup(query.get_description().c_str());
|
2009-11-25 21:55:06 +01:00
|
|
|
|
2010-02-03 20:06:31 +01:00
|
|
|
} MU_XAPIAN_CATCH_BLOCK_RETURN(NULL);
|
2009-12-05 19:10:58 +01:00
|
|
|
}
|
2010-01-03 22:53:49 +01:00
|
|
|
|
|
|
|
|