void
xaccQueryAddClearedMatch(QofQuery * q, cleared_match_t how, QofQueryOp op)
{
QofQueryPredData *pred_data;
GSList *param_list;
char chars[6];
int i = 0;
if (!q)
return;
if (how & CLEARED_CLEARED)
chars[i++] = CREC;
if (how & CLEARED_RECONCILED)
chars[i++] = YREC;
if (how & CLEARED_FROZEN)
chars[i++] = FREC;
if (how & CLEARED_NO)
chars[i++] = NREC;
if (how & CLEARED_VOIDED)
chars[i++] = VREC;
chars[i] = '\0';
pred_data = qof_query_char_predicate (QOF_CHAR_MATCH_ANY, chars);
if (!pred_data)
return;
param_list = qof_query_build_param_list (SPLIT_RECONCILE, NULL);
qof_query_add_term (q, param_list, pred_data, op);
}
void
xaccQueryAddKVPMatch(QofQuery *q, GSList *path, const KvpValue *value,
QofQueryCompare how, QofIdType id_type,
QofQueryOp op)
{
GSList *param_list = NULL;
QofQueryPredData *pred_data;
if (!q || !path || !value || !id_type)
return;
pred_data = qof_query_kvp_predicate (how, path, value);
if (!pred_data)
return;
if (!g_strcmp0 (id_type, GNC_ID_SPLIT))
param_list = qof_query_build_param_list (SPLIT_KVP, NULL);
else if (!g_strcmp0 (id_type, GNC_ID_TRANS))
param_list = qof_query_build_param_list (SPLIT_TRANS, TRANS_KVP, NULL);
else if (!g_strcmp0 (id_type, GNC_ID_ACCOUNT))
param_list = qof_query_build_param_list (SPLIT_ACCOUNT, ACCOUNT_KVP, NULL);
else
PERR ("Invalid match type: %s", id_type);
qof_query_add_term (q, param_list, pred_data, op);
}
void
xaccQueryAddStringMatch (QofQuery* q, const char *matchstring,
gboolean case_sens, gboolean use_regexp,
QofQueryCompare how, QofQueryOp op,
const char * path, ...)
{
QofQueryPredData *pred_data;
GSList *param_list;
va_list ap;
if (!path || !q)
return;
pred_data = qof_query_string_predicate (how, (char *)matchstring,
(case_sens ? QOF_STRING_MATCH_NORMAL :
QOF_STRING_MATCH_CASEINSENSITIVE),
use_regexp);
if (!pred_data)
return;
va_start (ap, path);
param_list = build_param_list_internal (path, ap);
va_end (ap);
qof_query_add_term (q, param_list, pred_data, op);
}
static int
get_num_xactions_before_date(QofBook *book, time64 close_date)
{
QofQuery *q;
GSList *param;
QofQueryPredData *pred;
GList *res, *n;
int cnt = 0;
q = qof_query_create_for(GNC_ID_TRANS);
qof_query_set_max_results(q, -1);
qof_query_set_book (q, book);
/* Look for transactions earlier than the closing date */
param = g_slist_prepend (NULL, TRANS_DATE_POSTED);
pred = qof_query_date_predicate (QOF_COMPARE_LTE, QOF_DATE_MATCH_NORMAL, close_date);
qof_query_add_term (q, param, pred, QOF_QUERY_FIRST_TERM);
/* Run the query, find how many transactions there are */
res = qof_query_run (q);
cnt = 0;
for (n = res; n; n = n->next) cnt ++;
qof_query_destroy (q);
return cnt;
}
void
xaccQueryAddDateMatchTS (QofQuery * q,
gboolean use_start, Timespec sts,
gboolean use_end, Timespec ets,
QofQueryOp op)
{
QofQuery *tmp_q = NULL;
QofQueryPredData *pred_data;
GSList *param_list;
if (!q || (!use_start && !use_end))
return;
tmp_q = qof_query_create ();
if (use_start)
{
pred_data = qof_query_date_predicate (QOF_COMPARE_GTE, QOF_DATE_MATCH_NORMAL, sts);
if (!pred_data)
{
qof_query_destroy (tmp_q);
return;
}
param_list = qof_query_build_param_list (SPLIT_TRANS, TRANS_DATE_POSTED, NULL);
qof_query_add_term (tmp_q, param_list, pred_data, QOF_QUERY_AND);
}
if (use_end)
{
pred_data = qof_query_date_predicate (QOF_COMPARE_LTE, QOF_DATE_MATCH_NORMAL, ets);
if (!pred_data)
{
qof_query_destroy (tmp_q);
return;
}
param_list = qof_query_build_param_list (SPLIT_TRANS, TRANS_DATE_POSTED, NULL);
qof_query_add_term (tmp_q, param_list, pred_data, QOF_QUERY_AND);
}
qof_query_merge_in_place (q, tmp_q, op);
qof_query_destroy (tmp_q);
}
/** Creates a new query that searches for an GncEntry item with
* description string equal to the given "desc" argument. The query
* will find the single GncEntry with the latest (=newest)
* DATE_ENTERED. */
static QofQuery *new_query_for_entry_desc(GncEntryLedger *reg, const char* desc, gboolean use_invoice)
{
QofQuery *query = NULL;
QofQueryPredData *predData = NULL;
GSList *param_list = NULL;
GSList *primary_sort_params = NULL;
const char* should_be_null = (use_invoice ? ENTRY_BILL : ENTRY_INVOICE);
g_assert(reg);
g_assert(desc);
/* The query itself and its book */
query = qof_query_create_for (GNC_ID_ENTRY);
qof_query_set_book (query, reg->book);
/* Predicate data: We want to compare one string, namely the given
* argument */
predData =
qof_query_string_predicate (QOF_COMPARE_EQUAL, desc,
QOF_STRING_MATCH_CASEINSENSITIVE, FALSE);
/* Search Parameter: We want to query on the ENTRY_DESC column */
param_list = qof_query_build_param_list (ENTRY_DESC, NULL);
/* Register this in the query */
qof_query_add_term (query, param_list, predData, QOF_QUERY_FIRST_TERM);
/* For invoice entries, Entry->Bill must be NULL, and vice versa */
qof_query_add_guid_match (query,
qof_query_build_param_list (should_be_null,
QOF_PARAM_GUID, NULL),
NULL, QOF_QUERY_AND);
/* Set the sort order: By DATE_ENTERED, increasing, and returning
* only one single resulting item. */
primary_sort_params = qof_query_build_param_list(ENTRY_DATE_ENTERED, NULL);
qof_query_set_sort_order (query, primary_sort_params, NULL, NULL);
qof_query_set_sort_increasing (query, TRUE, TRUE, TRUE);
qof_query_set_max_results(query, 1);
return query;
}
void
xaccQueryAddNumericMatch (QofQuery *q, gnc_numeric amount, QofNumericMatch sign,
QofQueryCompare how, QofQueryOp op,
const char * path, ...)
{
QofQueryPredData *pred_data;
GSList *param_list;
va_list ap;
if (!q || !path)
return;
pred_data = qof_query_numeric_predicate (how, sign, amount);
if (!pred_data)
return;
va_start (ap, path);
param_list = build_param_list_internal (path, ap);
va_end (ap);
qof_query_add_term (q, param_list, pred_data, op);
}
void
xaccQueryAddAccountGUIDMatch(QofQuery *q, AccountGUIDList *guid_list,
QofGuidMatch how, QofQueryOp op)
{
QofQueryPredData *pred_data;
GSList *param_list = NULL;
if (!q) return;
if (!guid_list && how != QOF_GUID_MATCH_NULL)
{
g_warning("Got a NULL guid_list but the QofGuidMatch is not MATCH_NULL (but instead %d). In other words, the list of GUID matches is empty but it must contain something non-empty.", how);
/* qof_query_guid_predicate() would trigger a g_warning as well */
return;
}
pred_data = qof_query_guid_predicate (how, guid_list);
if (!pred_data)
return;
switch (how)
{
case QOF_GUID_MATCH_ANY:
case QOF_GUID_MATCH_NONE:
param_list = qof_query_build_param_list (SPLIT_ACCOUNT, QOF_PARAM_GUID, NULL);
break;
case QOF_GUID_MATCH_ALL:
param_list = qof_query_build_param_list (SPLIT_TRANS, TRANS_SPLITLIST,
SPLIT_ACCOUNT_GUID, NULL);
break;
default:
PERR ("Invalid match type: %d", how);
break;
}
qof_query_add_term (q, param_list, pred_data, op);
}
static void
search_update_query (GNCSearchWindow *sw)
{
static GSList *active_params = NULL;
QofQuery *q, *q2, *new_q;
GList *node;
QofQueryOp op;
QofQueryPredData* pdata;
if (sw->grouping == GNC_SEARCH_MATCH_ANY)
op = QOF_QUERY_OR;
else
op = QOF_QUERY_AND;
if (active_params == NULL)
active_params = g_slist_prepend (NULL, QOF_PARAM_ACTIVE);
/* Make sure we supply a book! */
if (sw->start_q == NULL)
{
sw->start_q = qof_query_create_for (sw->search_for);
qof_query_set_book (sw->start_q, gnc_get_current_book ());
}
else
{
/* We've got a query -- purge it of any "active" parameters */
qof_query_purge_terms (sw->start_q, active_params);
}
/* Now create a new query to work from */
q = qof_query_create_for (sw->search_for);
/* Walk the list of criteria */
for (node = sw->crit_list; node; node = node->next)
{
struct _crit_data *data = node->data;
pdata = gnc_search_core_type_get_predicate (data->element);
if (pdata)
qof_query_add_term (q, gnc_search_param_get_param_path (data->param),
pdata, op);
}
/* Now combine this query with the existing query, depending on
* what we want to do... We can assume that cases 1, 2, and 3
* already have sw->q being valid!
*/
switch (sw->search_type)
{
case 0: /* New */
new_q = qof_query_merge (sw->start_q, q, QOF_QUERY_AND);
qof_query_destroy (q);
break;
case 1: /* Refine */
new_q = qof_query_merge (sw->q, q, QOF_QUERY_AND);
qof_query_destroy (q);
break;
case 2: /* Add */
new_q = qof_query_merge (sw->q, q, QOF_QUERY_OR);
qof_query_destroy (q);
break;
case 3: /* Delete */
q2 = qof_query_invert (q);
new_q = qof_query_merge (sw->q, q2, QOF_QUERY_AND);
qof_query_destroy (q2);
qof_query_destroy (q);
break;
default:
g_warning ("bad search type: %d", sw->search_type);
new_q = q;
break;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (sw->active_only_check)))
{
qof_query_add_boolean_match (new_q, active_params, TRUE, QOF_QUERY_AND);
active_params = NULL;
}
/* Destroy the old query */
if (sw->q)
qof_query_destroy (sw->q);
/* And save the new one */
sw->q = new_q;
}
