Query: Querying for Objects

BASIC QUERY API: With this API you can create arbitrary logical queries to find sets of arbitrary object. More...

Files
file	qofquery.h
	find objects that match a certain expression.
file	qofquerycore.h
	API for providing core Query data types.

Data Structures
struct	QofQueryPredData
	No extended comparisons for QOF_TYPE_INT32, QOF_TYPE_INT64, QOF_TYPE_DOUBLE, QOF_TYPE_BOOLEAN. More...

Macros
#define	QOF_MOD_QUERY   "qof.query"
#define	QOF_QUERY_FIRST_TERM   QOF_QUERY_AND
	First/only term is same as 'and'.
#define	QUERY_DEFAULT_SORT   "QofQueryDefaultSort"
	Default sort object type.
#define	QOF_PARAM_BOOK   "book"
	"Known" Object Parameters – all objects must support these
#define	QOF_PARAM_GUID   "guid"
#define	QOF_PARAM_KVP   "kvp"
	"Known" Object Parameters – some objects might support these
#define	QOF_PARAM_ACTIVE   "active"
#define	QOF_PARAM_VERSION   "version"

Typedefs
typedef GSList	QofQueryParamList
	A list of parameters (QofIdType) used to describe a parameter to use in a predicate or when sorting.

Enumerations
enum	QofQueryOp {   QOF_QUERY_AND = 1 , QOF_QUERY_OR , QOF_QUERY_NAND , QOF_QUERY_NOR ,   QOF_QUERY_XOR }
	Query Term Operators, for combining Query Terms. More...
enum	QofQueryCompare {   QOF_COMPARE_LT = 1 , QOF_COMPARE_LTE , QOF_COMPARE_EQUAL , QOF_COMPARE_GT ,   QOF_COMPARE_GTE , QOF_COMPARE_NEQ , QOF_COMPARE_CONTAINS , QOF_COMPARE_NCONTAINS }
	Standard Query comparators, for how to compare objects in a predicate. More...
enum	QofStringMatch { QOF_STRING_MATCH_NORMAL = 1 , QOF_STRING_MATCH_CASEINSENSITIVE }
	List of known core query data-types... Each core query type defines it's set of optional "comparator qualifiers". More...
enum	QofDateMatch { QOF_DATE_MATCH_NORMAL = 1 , QOF_DATE_MATCH_DAY }
	Comparisons for QOF_TYPE_DATE The QOF_DATE_MATCH_DAY comparison rounds the two time values to mid-day and then compares these rounded values. More...
enum	QofNumericMatch { QOF_NUMERIC_MATCH_DEBIT = 1 , QOF_NUMERIC_MATCH_CREDIT , QOF_NUMERIC_MATCH_ANY }
	Comparisons for QOF_TYPE_NUMERIC, QOF_TYPE_DEBCRED. More...
enum	QofGuidMatch {   QOF_GUID_MATCH_ANY = 1 , QOF_GUID_MATCH_NONE , QOF_GUID_MATCH_NULL , QOF_GUID_MATCH_ALL ,   QOF_GUID_MATCH_LIST_ANY }
enum	QofCharMatch { QOF_CHAR_MATCH_ANY = 1 , QOF_CHAR_MATCH_NONE }
	A CHAR type is for a RECNCell, Comparisons for QOF_TYPE_CHAR 'ANY' will match any character in the string. More...

Variables
QofType	QofQueryPredData::type_name
QofQueryCompare	QofQueryPredData::how

Query Subsystem Initialization and Shutdown <br>
void	qof_query_init (void)
	Subsystem initialization and shutdown.
void	qof_query_shutdown (void)

Low-Level API Functions
QofQueryParamList *	qof_query_build_param_list (char const *param,...)
QofQuery *	qof_query_create (void)
	Create a new query.
QofQuery *	qof_query_create_for (QofIdTypeConst obj_type)
void	qof_query_destroy (QofQuery *q)
	Frees the resources associate with a Query object.
void	qof_query_search_for (QofQuery *query, QofIdTypeConst obj_type)
	Set the object type to be searched for.
void	qof_query_set_book (QofQuery *q, QofBook *book)
	Set the book to be searched.
void	qof_query_add_term (QofQuery *query, QofQueryParamList *param_list, QofQueryPredData *pred_data, QofQueryOp op)
	This is the general function that adds a new Query Term to a query.
void	qof_query_add_guid_match (QofQuery *q, QofQueryParamList *param_list, const GncGUID *guid, QofQueryOp op)
	DOCUMENT ME !!
void	qof_query_add_guid_list_match (QofQuery *q, QofQueryParamList *param_list, GList *guid_list, QofGuidMatch options, QofQueryOp op)
	DOCUMENT ME !!
void	qof_query_add_boolean_match (QofQuery *q, QofQueryParamList *param_list, gboolean value, QofQueryOp op)
	Handy-dandy convenience routines, avoids having to create a separate predicate for boolean matches.
GList *	qof_query_run (QofQuery *query)
	Perform the query, return the results.
GList *	qof_query_last_run (QofQuery *query)
	Return the results of the last query, without causing the query to be re-run.
GList *	qof_query_run_subquery (QofQuery *subquery, const QofQuery *primary_query)
	Perform a subquery, return the results.
void	qof_query_clear (QofQuery *query)
	Remove all query terms from query.
void	qof_query_purge_terms (QofQuery *q, QofQueryParamList *param_list)
	Remove query terms of a particular type from q.
int	qof_query_has_terms (QofQuery *q)
	Return boolean FALSE if there are no terms in the query Can be used as a predicate to see if the query has been initialized (return value > 0) or is "blank" (return value == 0).
int	qof_query_num_terms (QofQuery *q)
	Return the number of terms in the canonical form of the query.
gboolean	qof_query_has_term_type (QofQuery *q, QofQueryParamList *term_param)
	DOCUMENT ME !!
GSList *	qof_query_get_term_type (QofQuery *q, QofQueryParamList *term_param)
QofQuery *	qof_query_copy (QofQuery *q)
	Make a copy of the indicated query.
QofQuery *	qof_query_invert (QofQuery *q)
	Make a copy of the indicated query, inverting the sense of the search.
QofQuery *	qof_query_merge (QofQuery *q1, QofQuery *q2, QofQueryOp op)
	Combine two queries together using the Boolean set (logical) operator 'op'.
void	qof_query_merge_in_place (QofQuery *q1, QofQuery *q2, QofQueryOp op)
	Like qof_query_merge, but this will merge a copy of q2 into q1.
void	qof_query_set_sort_order (QofQuery *q, QofQueryParamList *primary_sort_params, QofQueryParamList *secondary_sort_params, QofQueryParamList *tertiary_sort_params)
	When a query is run, the results are sorted before being returned.
void	qof_query_set_sort_options (QofQuery *q, gint prim_op, gint sec_op, gint tert_op)
void	qof_query_set_sort_increasing (QofQuery *q, gboolean prim_inc, gboolean sec_inc, gboolean tert_inc)
	When a query is run, the results are sorted before being returned.
void	qof_query_set_max_results (QofQuery *q, int n)
	Set the maximum number of results that should be returned.
gboolean	qof_query_equal (const QofQuery *q1, const QofQuery *q2)
	Compare two queries for equality.
QofIdType	qof_query_get_search_for (const QofQuery *q)
	Return the type of data we're querying for.
GList *	qof_query_get_books (QofQuery *q)
	Return the list of books we're using.

Core Data Type Predicates
QofQueryPredData *	qof_query_string_predicate (QofQueryCompare how, const gchar *str, QofStringMatch options, gboolean is_regex)
QofQueryPredData *	qof_query_date_predicate (QofQueryCompare how, QofDateMatch options, time64 date)
QofQueryPredData *	qof_query_numeric_predicate (QofQueryCompare how, QofNumericMatch options, gnc_numeric value)
QofQueryPredData *	qof_query_guid_predicate (QofGuidMatch options, GList *guids)
QofQueryPredData *	qof_query_int32_predicate (QofQueryCompare how, gint32 val)
QofQueryPredData *	qof_query_int64_predicate (QofQueryCompare how, gint64 val)
QofQueryPredData *	qof_query_double_predicate (QofQueryCompare how, double val)
QofQueryPredData *	qof_query_boolean_predicate (QofQueryCompare how, gboolean val)
QofQueryPredData *	qof_query_char_predicate (QofCharMatch options, const gchar *chars)
QofQueryPredData *	qof_query_choice_predicate (QofGuidMatch options, GList *guids)
QofQueryPredData *	qof_query_core_predicate_copy (const QofQueryPredData *pdata)
	Copy a predicate.
void	qof_query_core_predicate_free (QofQueryPredData *pdata)
	Destroy a predicate.
gboolean	qof_query_date_predicate_get_date (const QofQueryPredData *pd, time64 *date)
	Retrieve a predicate.
gboolean	qof_query_char_predicate_get_char (const QofQueryPredData *pd, char **chars)
char *	qof_query_core_to_string (QofType, gpointer object, QofParam *getter)
	Return a printable string for a core data object.
int	qof_string_number_compare_func (gpointer a, gpointer b, gint options, QofParam *this_param)
	Compare two parameter(strings) as if they are numbers! the two objects, a and b, are the objects being compared this_param is the QofParam for this parameter in the objects.

Detailed Description

BASIC QUERY API: With this API you can create arbitrary logical queries to find sets of arbitrary object.

To make simple queries (1 term, such as a search for a parameter with one value), create the appropriate QueryTerm structure and stick it in a Query object using xaccInitQuery. The QueryTerm should be malloc'd but the Query object will handle freeing it. To make compound queries, make multiple simple queries and combine them using qof_query_merge() and the logical operations of your choice.

SQL QUERY API: As an alternative to building queries one predicate at a time, you can use the SQL query interface. This interface will accept a string containing an SQL query, parse it, convert it into the core representation, and execute it.

STRUCTURE OF A QUERY: A Query is a logical function of any number of QueryTerms. A QueryTerm consists of a C function pointer (the Predicate) and a PredicateData structure containing data passed to the predicate function. The PredicateData structure is a constant associated with the Term and is identical for every object that is tested.

The terms of the Query may represent any logical function and are stored in canonical form, i.e. the function is expressed as a logical sum of logical products. So if you have QueryTerms a, b, c, d, e and you have the logical function a(b+c) + !(c(d+e)), it gets stored as ab + ac + !c + !c!e +!d!c + !d!e. This may not be optimal for evaluation of some functions but it's easy to store, easy to manipulate, and it doesn't require a complete algebra system to deal with.

The representation is of a GList of GLists of QueryTerms. The "backbone" GList q->terms represents the OR-chain, and every item on the backbone is a GList of QueryTerms representing an AND-chain corresponding to a single product-term in the canonical representation. QueryTerms are duplicated when necessary to fill out the canonical form, and the same predicate may be evaluated multiple times per split for complex queries. This is a place where we could probably optimize.

Macro Definition Documentation

QOF_MOD_QUERY

#define QOF_MOD_QUERY   "qof.query"

Definition at line 86 of file qofquery.h.

QOF_PARAM_ACTIVE

#define QOF_PARAM_ACTIVE   "active"

Definition at line 113 of file qofquery.h.

QOF_PARAM_BOOK

#define QOF_PARAM_BOOK   "book"

"Known" Object Parameters – all objects must support these

Definition at line 108 of file qofquery.h.

QOF_PARAM_GUID

#define QOF_PARAM_GUID   "guid"

Definition at line 109 of file qofquery.h.

QOF_PARAM_KVP

#define QOF_PARAM_KVP   "kvp"

"Known" Object Parameters – some objects might support these

Definition at line 112 of file qofquery.h.

QOF_PARAM_VERSION

#define QOF_PARAM_VERSION   "version"

Definition at line 114 of file qofquery.h.

QOF_QUERY_FIRST_TERM

#define QOF_QUERY_FIRST_TERM   QOF_QUERY_AND

First/only term is same as 'and'.

Definition at line 102 of file qofquery.h.

QUERY_DEFAULT_SORT

#define QUERY_DEFAULT_SORT   "QofQueryDefaultSort"

Default sort object type.

Definition at line 105 of file qofquery.h.

Typedef Documentation

QofQueryParamList

typedef GSList QofQueryParamList

A list of parameters (QofIdType) used to describe a parameter to use in a predicate or when sorting.

Definition at line 151 of file qofquerycore.h.

Enumeration Type Documentation

QofCharMatch

enum QofCharMatch

A CHAR type is for a RECNCell, Comparisons for QOF_TYPE_CHAR 'ANY' will match any character in the string.

Match 'ANY' is a convenience/performance-enhanced predicate for the compound statement (value==char1) || (value==char2) || etc. Match 'NONE' is equivalent to (value != char1) && (value != char2) && etc.

Definition at line 132 of file qofquerycore.h.

{
    QOF_CHAR_MATCH_ANY = 1,
    QOF_CHAR_MATCH_NONE
} QofCharMatch;

QofDateMatch

enum QofDateMatch

Comparisons for QOF_TYPE_DATE The QOF_DATE_MATCH_DAY comparison rounds the two time values to mid-day and then compares these rounded values.

The QOF_DATE_MATCH_NORMAL comparison matches the time values, down to the second.

Definition at line 83 of file qofquerycore.h.

{
    QOF_DATE_MATCH_NORMAL = 1,
    QOF_DATE_MATCH_DAY
} QofDateMatch;

QofGuidMatch

enum QofGuidMatch

Enumerator
QOF_GUID_MATCH_ANY	These expect a single object and expect the QofAccessFunc returns GncGUID*.
QOF_GUID_MATCH_ALL	These expect a GList* of objects and calls the QofAccessFunc routine on each item in the list to obtain a GncGUID* for each object.
QOF_GUID_MATCH_LIST_ANY	These expect a single object and expect the QofAccessFunc function to return a GList* of GncGUID* (the list is the property of the caller)

Definition at line 109 of file qofquerycore.h.

{
    QOF_GUID_MATCH_ANY = 1,
    QOF_GUID_MATCH_NONE,
    QOF_GUID_MATCH_NULL,
    QOF_GUID_MATCH_ALL,
    QOF_GUID_MATCH_LIST_ANY,
} QofGuidMatch;

QofNumericMatch

enum QofNumericMatch

Comparisons for QOF_TYPE_NUMERIC, QOF_TYPE_DEBCRED.

XXX Should be deprecated, or at least wrapped up as a convenience function, this is based on the old bill gribble code, which assumed the amount was always positive, and then specified a funds-flow direction (credit, debit, or either).

The point being that 'match credit' is equivalent to the compound predicate (amount >= 0) && (amount 'op' value) while the 'match debit' predicate is equivalent to (amount <= 0) && (abs(amount) 'op' value)

Definition at line 101 of file qofquerycore.h.

{
    QOF_NUMERIC_MATCH_DEBIT = 1,
    QOF_NUMERIC_MATCH_CREDIT,
    QOF_NUMERIC_MATCH_ANY
} QofNumericMatch;

QofQueryCompare

enum QofQueryCompare

Standard Query comparators, for how to compare objects in a predicate.

Note that not all core types implement all comparators

Definition at line 54 of file qofquerycore.h.

{
    QOF_COMPARE_LT = 1,
    QOF_COMPARE_LTE,
    QOF_COMPARE_EQUAL,
    QOF_COMPARE_GT,
    QOF_COMPARE_GTE,
    QOF_COMPARE_NEQ,
    QOF_COMPARE_CONTAINS,
    QOF_COMPARE_NCONTAINS
} QofQueryCompare;

QofQueryOp

enum QofQueryOp

Query Term Operators, for combining Query Terms.

Definition at line 92 of file qofquery.h.

{
    QOF_QUERY_AND = 1,
    QOF_QUERY_OR,
    QOF_QUERY_NAND,
    QOF_QUERY_NOR,
    QOF_QUERY_XOR
} QofQueryOp;

QofStringMatch

enum QofStringMatch

List of known core query data-types... Each core query type defines it's set of optional "comparator qualifiers".

Definition at line 70 of file qofquerycore.h.

{
    QOF_STRING_MATCH_NORMAL = 1,
    QOF_STRING_MATCH_CASEINSENSITIVE
} QofStringMatch;

Function Documentation

qof_query_add_boolean_match()

void qof_query_add_boolean_match	(	QofQuery *	q,
		QofQueryParamList *	param_list,
		gboolean	value,
		QofQueryOp	op
	)

Handy-dandy convenience routines, avoids having to create a separate predicate for boolean matches.

We might want to create handy-dandy sugar routines for the other predicate types as well.

Definition at line 1347 of file qofquery.cpp.

{
    QofQueryPredData *pdata;
    if (!q || !param_list) return;
 
    pdata = qof_query_boolean_predicate (QOF_COMPARE_EQUAL, value);
    qof_query_add_term (q, param_list, pdata, op);
}

qof_query_add_guid_list_match()

void qof_query_add_guid_list_match	(	QofQuery *	q,
		QofQueryParamList *	param_list,
		GList *	guid_list,
		QofGuidMatch	options,
		QofQueryOp	op
	)

DOCUMENT ME !!

Definition at line 1295 of file qofquery.cpp.

{
    QofQueryPredData *pdata;
 
    if (!q || !param_list) return;
 
    if (!guid_list)
        g_return_if_fail (options == QOF_GUID_MATCH_NULL);
 
    pdata = qof_query_guid_predicate (options, guid_list);
    qof_query_add_term (q, param_list, pdata, op);
}

qof_query_add_guid_match()

void qof_query_add_guid_match	(	QofQuery *	q,
		QofQueryParamList *	param_list,
		const GncGUID *	guid,
		QofQueryOp	op
	)

DOCUMENT ME !!

Definition at line 1310 of file qofquery.cpp.

{
    GList *g = nullptr;
 
    if (!q || !param_list) return;
 
    if (guid)
        g = g_list_prepend (g, (gpointer)guid);
 
    qof_query_add_guid_list_match (q, param_list, g,
                                   g ? QOF_GUID_MATCH_ANY : QOF_GUID_MATCH_NULL, op);
 
    g_list_free (g);
}

qof_query_add_term()

void qof_query_add_term	(	QofQuery *	query,
		QofQueryParamList *	param_list,
		QofQueryPredData *	pred_data,
		QofQueryOp	op
	)

This is the general function that adds a new Query Term to a query.

It will find the 'obj_type' object of the search item and compare the 'param_list' parameter to the predicate data via the comparator.

The param_list is a recursive list of parameters. For example, you can say 'split->memo' by creating a list of one element, "SPLIT_MEMO". You can say 'split->account->name' by creating a list of two elements, "SPLIT_ACCOUNT" and "ACCOUNT_NAME". The list becomes the property of the Query.

For example:

acct_name_pred_data = make_string_pred_data(QOF_STRING_MATCH_CASEINSENSITIVE, account_name); param_list = make_list (SPLIT_ACCOUNT, ACCOUNT_NAME, NULL); qof_query_add_term (query, param_list, QOF_COMPARE_EQUAL, acct_name_pred_data, QOF_QUERY_AND);

Please note that QofQuery does not, at this time, support joins. That is, one cannot specify a predicate that is a parameter list. Put another way, one cannot search for objects where obja->thingy == objb->stuff

Definition at line 681 of file qofquery.cpp.

{
    QofQueryTerm *qt;
    QofQuery *qr, *qs;
 
    if (!q || !param_list || !pred_data) return;
 
    qt = g_new0 (QofQueryTerm, 1);
    qt->param_list = param_list;
    qt->pdata = pred_data;
    qs = qof_query_create ();
    query_init (qs, qt);
 
    if (q->terms != nullptr)
        qr = qof_query_merge (q, qs, op);
    else
        qr = qof_query_merge (q, qs, QOF_QUERY_OR);
 
    swap_terms (q, qr);
    qof_query_destroy (qs);
    qof_query_destroy (qr);
}

qof_query_boolean_predicate()

QofQueryPredData * qof_query_boolean_predicate	(	QofQueryCompare	how,
		gboolean	val
	)

Definition at line 1108 of file qofquerycore.cpp.

{
    query_boolean_t pdata;
    g_return_val_if_fail (how == QOF_COMPARE_EQUAL || how == QOF_COMPARE_NEQ, nullptr);
 
    pdata = g_new0 (query_boolean_def, 1);
    pdata->pd.type_name = query_boolean_type;
    pdata->pd.how = how;
    pdata->val = val;
    return ((QofQueryPredData*)pdata);
}

qof_query_build_param_list()

QofQueryParamList * qof_query_build_param_list	(	char const *	param,
			...
	)

Definition at line 662 of file qofquery.cpp.

{
    QofQueryParamList *param_list = nullptr;
    char const *this_param;
    va_list ap;
 
    if (!param)
        return nullptr;
 
    va_start (ap, param);
 
    for (this_param = param; this_param; this_param = va_arg (ap, const char *))
        param_list = g_slist_prepend (param_list, (gpointer)this_param);
 
    va_end (ap);
 
    return g_slist_reverse (param_list);
}

qof_query_char_predicate_get_char()

gboolean qof_query_char_predicate_get_char	(	const QofQueryPredData *	pd,
		char **	chars
	)

Definition at line 1206 of file qofquerycore.cpp.

{
    const query_char_t pdata = (const query_char_t)pd;
 
    if (pdata->pd.type_name != query_char_type)
        return FALSE;
 
    *chars = g_strdup (pdata->char_list);
    return TRUE;
}

qof_query_choice_predicate()

QofQueryPredData * qof_query_choice_predicate	(	QofGuidMatch	options,
		GList *	guids
	)

Definition at line 1372 of file qofquerycore.cpp.

{
    query_choice_t pdata;
    GList *node;
 
    if (nullptr == guid_list) return nullptr;
 
    pdata = g_new0 (query_choice_def, 1);
    pdata->pd.how = QOF_COMPARE_EQUAL;
    pdata->pd.type_name = query_choice_type;
    pdata->options = options;
 
    pdata->guids = g_list_copy (guid_list);
    for (node = pdata->guids; node; node = node->next)
    {
        GncGUID *guid = guid_malloc ();
        *guid = *((GncGUID *)node->data);
        node->data = guid;
    }
    return ((QofQueryPredData*)pdata);
}

qof_query_clear()

void qof_query_clear

(

QofQuery *

query

)

Remove all query terms from query.

query matches nothing after qof_query_clear().

Definition at line 905 of file qofquery.cpp.

{
    QofQuery *q2 = qof_query_create ();
    swap_terms (query, q2);
    qof_query_destroy (q2);
 
    g_list_free (query->books);
    query->books = nullptr;
    g_list_free (query->results);
    query->results = nullptr;
    query->changed = 1;
}

qof_query_copy()

QofQuery * qof_query_copy

(

QofQuery *

q

)

Make a copy of the indicated query.

Definition at line 1018 of file qofquery.cpp.

{
    QofQuery *copy;
    GHashTable *ht;
 
    if (!q) return nullptr;
    copy = qof_query_create ();
    ht = copy->be_compiled;
    free_members (copy);
 
    *copy = *q;
 
    copy->be_compiled = ht;
    copy->terms = copy_or_terms (q->terms);
    copy->books = g_list_copy (q->books);
    copy->results = g_list_copy (q->results);
 
    copy_sort (&(copy->primary_sort), &(q->primary_sort));
    copy_sort (&(copy->secondary_sort), &(q->secondary_sort));
    copy_sort (&(copy->tertiary_sort), &(q->tertiary_sort));
 
    copy->changed = 1;
 
    return copy;
}

qof_query_core_predicate_copy()

QofQueryPredData * qof_query_core_predicate_copy

(

const QofQueryPredData *

pdata

)

Copy a predicate.

Definition at line 1603 of file qofquerycore.cpp.

{
    QueryPredicateCopyFunc copy;
 
    g_return_val_if_fail (pdata, nullptr);
    g_return_val_if_fail (pdata->type_name, nullptr);
 
    copy = qof_query_copy_predicate (pdata->type_name);
    return (copy (pdata));
}

qof_query_core_predicate_free()

void qof_query_core_predicate_free

(

QofQueryPredData *

pdata

)

Destroy a predicate.

Definition at line 1591 of file qofquerycore.cpp.

{
    QueryPredDataFree free_fcn;
 
    g_return_if_fail (pdata);
    g_return_if_fail (pdata->type_name);
 
    free_fcn = qof_query_predicate_free (pdata->type_name);
    free_fcn (pdata);
}

qof_query_core_to_string()

char * qof_query_core_to_string	(	QofType	type,
		gpointer	object,
		QofParam *	getter
	)

Return a printable string for a core data object.

Caller needs to g_free() the returned string.

Definition at line 1615 of file qofquerycore.cpp.

{
    QueryToString toString;
 
    g_return_val_if_fail (type, nullptr);
    g_return_val_if_fail (object, nullptr);
    g_return_val_if_fail (getter, nullptr);
 
    toString = reinterpret_cast<QueryToString>(g_hash_table_lookup (toStringTable, type));
    g_return_val_if_fail (toString, nullptr);
 
    return toString (object, getter);
}

qof_query_create()

QofQuery * qof_query_create

(

void

)

Create a new query.

Before running the query, a 'search-for' type must be set otherwise nothing will be returned. The results of the query is a list of the indicated search-for type.

Allocates and initializes a Query structure which must be freed by the user with qof_query_destroy(). A newly-allocated QofQuery object matches nothing (qof_query_run() will return NULL).

Definition at line 918 of file qofquery.cpp.

{
    QofQuery *qp = g_new0 (QofQuery, 1);
    qp->be_compiled = g_hash_table_new (g_direct_hash, g_direct_equal);
    query_init (qp, nullptr);
    return qp;
}

qof_query_create_for()

QofQuery * qof_query_create_for

(

QofIdTypeConst

obj_type

)

Definition at line 108 of file fake-qofquery.cpp.

{
    return (QofQuery*)queryPool.request_query(obj_type);
}

qof_query_date_predicate()

QofQueryPredData * qof_query_date_predicate	(	QofQueryCompare	how,
		QofDateMatch	options,
		time64	date
	)

Definition at line 420 of file qofquerycore.cpp.

{
    query_date_t pdata;
 
    pdata = g_new0 (query_date_def, 1);
    pdata->pd.type_name = query_date_type;
    pdata->pd.how = how;
    pdata->options = options;
    pdata->date = date;
    return ((QofQueryPredData*)pdata);
}

qof_query_date_predicate_get_date()

gboolean qof_query_date_predicate_get_date	(	const QofQueryPredData *	pd,
		time64 *	date
	)

Retrieve a predicate.

Definition at line 434 of file qofquerycore.cpp.

{
    const query_date_t pdata = (const query_date_t)pd;
 
    if (pdata->pd.type_name != query_date_type)
        return FALSE;
    *date = pdata->date;
    return TRUE;
}

qof_query_destroy()

void qof_query_destroy

(

QofQuery *

q

)

Frees the resources associate with a Query object.

Definition at line 114 of file fake-qofquery.cpp.

{
    queryPool.release_query((QofFakeQuery*)query);
}

qof_query_double_predicate()

QofQueryPredData * qof_query_double_predicate	(	QofQueryCompare	how,
		double	val
	)

Definition at line 1027 of file qofquerycore.cpp.

{
    query_double_t pdata = g_new0 (query_double_def, 1);
    pdata->pd.type_name = query_double_type;
    pdata->pd.how = how;
    pdata->val = val;
    return ((QofQueryPredData*)pdata);
}

qof_query_equal()

gboolean qof_query_equal	(	const QofQuery *	q1,
		const QofQuery *	q2
	)

Compare two queries for equality.

Query terms are compared each to each. This is a simplistic implementation – logical equivalences between different and/or trees are ignored.

Definition at line 1472 of file qofquery.cpp.

{
    GList *or1, *or2;
 
    if (q1 == q2) return TRUE;
    if (!q1 || !q2) return FALSE;
 
    if (q1->max_results != q2->max_results) return FALSE;
 
    for (or1 = q1->terms, or2 = q2->terms; or1 || or2;
         or1 = or1->next, or2 = or2->next)
    {
        GList *and1, *and2;
 
        if (!or1 || !or2)
            return FALSE;
        and1 = static_cast<GList*>(or1->data);
        and2 = static_cast<GList*>(or2->data);
 
        for (; and1 || and2; and1 = and1->next, and2 = and2->next)
        {
            if (!and1 || !and2)
                return FALSE;
            if (!qof_query_term_equal (static_cast<QofQueryTerm*>(and1->data),
                       static_cast<QofQueryTerm*>(and2->data)))
                return FALSE;
        }
    }
 
    if (!qof_query_sort_equal (&(q1->primary_sort), &(q2->primary_sort)))
        return FALSE;
    if (!qof_query_sort_equal (&(q1->secondary_sort), &(q2->secondary_sort)))
        return FALSE;
    if (!qof_query_sort_equal (&(q1->tertiary_sort), &(q2->tertiary_sort)))
        return FALSE;
 
    return TRUE;
}

qof_query_get_books()

GList * qof_query_get_books

(

QofQuery *

q

)

Return the list of books we're using.

Definition at line 1341 of file qofquery.cpp.

{
    if (!q) return nullptr;
    return q->books;
}

qof_query_get_search_for()

QofIdType qof_query_get_search_for

(

const QofQuery *

q

)

Return the type of data we're querying for.

Definition at line 1380 of file qofquery.cpp.

{
    if (!q) return nullptr;
    return q->search_for;
}

qof_query_get_term_type()

GSList * qof_query_get_term_type	(	QofQuery *	q,
		QofQueryParamList *	term_param
	)

Definition at line 986 of file qofquery.cpp.

{
    GList *_or_;
    GList *_and_;
    GSList *results = nullptr;
 
    if (!q || !term_param)
        return FALSE;
 
    for (_or_ = q->terms; _or_; _or_ = _or_->next)
    {
        for (_and_ = static_cast<GList*>(_or_->data); _and_;
         _and_ = static_cast<GList*>(_and_->next))
        {
            QofQueryTerm *qt = static_cast<QofQueryTerm*>(_and_->data);
            if (!param_list_cmp (term_param, qt->param_list))
                results = g_slist_prepend (results, qt->pdata);
        }
    }
 
    return g_slist_reverse (results);
}

qof_query_guid_predicate()

QofQueryPredData * qof_query_guid_predicate	(	QofGuidMatch	options,
		GList *	guids
	)

Definition at line 744 of file qofquerycore.cpp.

{
    query_guid_t pdata;
    GList *node;
 
    /* An empty list of guids is only valid when testing for a null GUID value */
    if (!guid_list)
        g_return_val_if_fail (options == QOF_GUID_MATCH_NULL, nullptr);
 
    pdata = g_new0 (query_guid_def, 1);
    pdata->pd.how = QOF_COMPARE_EQUAL;
    pdata->pd.type_name = query_guid_type;
    pdata->options = options;
 
    pdata->guids = g_list_copy (guid_list);
    for (node = pdata->guids; node; node = node->next)
    {
        GncGUID *guid = guid_malloc ();
        *guid = *((GncGUID *)node->data);
        node->data = guid;
    }
    return ((QofQueryPredData*)pdata);
}

qof_query_has_term_type()

gboolean qof_query_has_term_type	(	QofQuery *	q,
		QofQueryParamList *	term_param
	)

DOCUMENT ME !!

Definition at line 964 of file qofquery.cpp.

{
    GList *_or_;
    GList *_and_;
 
    if (!q || !term_param)
        return FALSE;
 
    for (_or_ = q->terms; _or_; _or_ = _or_->next)
    {
        for (_and_ = static_cast<GList*>(_or_->data); _and_;
         _and_ = static_cast<GList*>(_and_->next))
        {
            QofQueryTerm* qt = static_cast<QofQueryTerm*>(_and_->data);
            if (!param_list_cmp (term_param, qt->param_list))
                return TRUE;
        }
    }
 
    return FALSE;
}

qof_query_has_terms()

int qof_query_has_terms

(

QofQuery *

q

)

Return boolean FALSE if there are no terms in the query Can be used as a predicate to see if the query has been initialized (return value > 0) or is "blank" (return value == 0).

Definition at line 948 of file qofquery.cpp.

{
    if (!q) return 0;
    return g_list_length (q->terms);
}

qof_query_init()

void qof_query_init

(

void

)

Subsystem initialization and shutdown.

Call init() once to initialize the query subsystem; call shutdown() to free up any resources associated with the query subsystem. Typically called during application startup, shutdown.

Definition at line 1360 of file qofquery.cpp.

{
    ENTER (" ");
    qof_query_core_init ();
    qof_class_init ();
    LEAVE ("Completed initialization of QofQuery");
}

qof_query_int32_predicate()

QofQueryPredData * qof_query_int32_predicate	(	QofQueryCompare	how,
		gint32	val
	)

Definition at line 843 of file qofquerycore.cpp.

{
    query_int32_t pdata = g_new0 (query_int32_def, 1);
    pdata->pd.type_name = query_int32_type;
    pdata->pd.how = how;
    pdata->val = val;
    return ((QofQueryPredData*)pdata);
}

qof_query_int64_predicate()

QofQueryPredData * qof_query_int64_predicate	(	QofQueryCompare	how,
		gint64	val
	)

Definition at line 935 of file qofquerycore.cpp.

{
    query_int64_t pdata = g_new0 (query_int64_def, 1);
    pdata->pd.type_name = query_int64_type;
    pdata->pd.how = how;
    pdata->val = val;
    return ((QofQueryPredData*)pdata);
}

qof_query_invert()

QofQuery * qof_query_invert

(

QofQuery *

q

)

Make a copy of the indicated query, inverting the sense of the search.

In other words, if the original query search for all objects with a certain condition, the inverted query will search for all object with NOT that condition. The union of the results returned by the original and inverted queries equals the set of all searched objects. These to sets are disjoint (share no members in common).

This will return a newly allocated QofQuery object, or NULL on error. Free it with qof_query_destroy() when no longer needed.

Definition at line 1050 of file qofquery.cpp.

{
    QofQuery  * retval;
    QofQuery  * right, * left, * iright, * ileft;
    QofQueryTerm * qt;
    GList  * aterms;
    GList  * cur;
    GList  * new_oterm;
    int    num_or_terms;
 
    if (!q)
        return nullptr;
 
    num_or_terms = g_list_length(q->terms);
 
    switch (num_or_terms)
    {
    case 0:
        retval = qof_query_create();
        retval->max_results = q->max_results;
        break;
 
        /* This is the DeMorgan expansion for a single AND expression. */
        /* !(abc) = !a + !b + !c */
    case 1:
        retval = qof_query_create();
        retval->max_results = q->max_results;
        retval->books = g_list_copy (q->books);
        retval->search_for = q->search_for;
        retval->changed = 1;
 
        aterms = static_cast<GList*>(g_list_nth_data(q->terms, 0));
        new_oterm = nullptr;
        for (cur = aterms; cur; cur = cur->next)
        {
            qt = copy_query_term(static_cast<QofQueryTerm*>(cur->data));
            qt->invert = !(qt->invert);
            new_oterm = g_list_append(nullptr, qt);
            retval->terms = g_list_prepend(retval->terms, new_oterm);
        }
        retval->terms = g_list_reverse(retval->terms);
        break;
 
        /* If there are multiple OR-terms, we just recurse by
         * breaking it down to !(a + b + c) =
         * !a * !(b + c) = !a * !b * !c.  */
    default:
        right        = qof_query_create();
        right->terms = copy_or_terms(g_list_nth(q->terms, 1));
 
        left         = qof_query_create();
        left->terms  = g_list_append(nullptr,
                                     copy_and_terms(static_cast<GList*>(g_list_nth_data(q->terms, 0))));
 
        iright       = qof_query_invert(right);
        ileft        = qof_query_invert(left);
 
        retval = qof_query_merge(iright, ileft, QOF_QUERY_AND);
        retval->books          = g_list_copy (q->books);
        retval->max_results    = q->max_results;
        retval->search_for     = q->search_for;
        retval->changed        = 1;
 
        qof_query_destroy(iright);
        qof_query_destroy(ileft);
        qof_query_destroy(right);
        qof_query_destroy(left);
        break;
    }
 
    return retval;
}

qof_query_last_run()

GList * qof_query_last_run

(

QofQuery *

query

)

Return the results of the last query, without causing the query to be re-run.

Do NOT free the resulting list. This list is managed internally by QofQuery.

Definition at line 897 of file qofquery.cpp.

{
    if (!query)
        return nullptr;
 
    return query->results;
}

qof_query_merge()

QofQuery * qof_query_merge	(	QofQuery *	q1,
		QofQuery *	q2,
		QofQueryOp	op
	)

Combine two queries together using the Boolean set (logical) operator 'op'.

For example, if the operator 'op' is set to QUERY_AND, then the set of results returned by the query will will be the Boolean set intersection of the results returned by q1 and q2. Similarly, QUERY_OR maps to set union, etc.

Both queries must have compatible search-types. If both queries are set, they must search for the same object type. If only one is set, the resulting query will search for the set type. If neither query has the search-type set, the result will be unset as well.

This will return a newly allocated QofQuery object, or NULL on error. Free it with qof_query_destroy() when no longer needed. Note that if either input query is NULL then the returned query is NOT newly allocated – it will return the non-NULL query. You only need to call this function when both q1 and q2 are non-NULL.

Definition at line 1129 of file qofquery.cpp.

{
 
    QofQuery * retval = nullptr;
    QofQuery * i1, * i2;
    QofQuery * t1, * t2;
    GList * i, * j;
    QofIdType search_for;
 
    if (!q1) return q2;
    if (!q2) return q1;
 
    if (q1->search_for && q2->search_for)
        g_return_val_if_fail (g_strcmp0 (q1->search_for, q2->search_for) == 0,
                              nullptr);
 
    search_for = (q1->search_for ? q1->search_for : q2->search_for);
 
    /* Avoid merge surprises if op==QOF_QUERY_AND but q1 is empty.
     * The goal of this tweak is to allow the user to start with
     * an empty q1 and then append to it recursively
     * (and q1 (and q2 (and q3 (and q4 ....))))
     * without bombing out because the append started with an
     * empty list.
     * We do essentially the same check in qof_query_add_term()
     * so that the first term added to an empty query doesn't screw up.
     */
    if ((QOF_QUERY_AND == op) &&
        (q1->terms == nullptr || q2->terms == nullptr))
    {
        op = QOF_QUERY_OR;
    }
 
    switch (op)
    {
    case QOF_QUERY_OR:
        retval = qof_query_create();
        retval->terms =
            g_list_concat(copy_or_terms(q1->terms), copy_or_terms(q2->terms));
        retval->books           = merge_books (q1->books, q2->books);
        retval->max_results    = q1->max_results;
        retval->changed        = 1;
        break;
 
    case QOF_QUERY_AND:
        retval = qof_query_create();
        retval->books          = merge_books (q1->books, q2->books);
        retval->max_results    = q1->max_results;
        retval->changed        = 1;
 
        /* g_list_append() can take forever, so let's build the list in
         * reverse and then reverse it at the end, to deal better with
         * "large" queries.
         */
        for (i = q1->terms; i; i = i->next)
        {
            for (j = q2->terms; j; j = j->next)
            {
                retval->terms =
                    g_list_prepend(retval->terms,
                                   g_list_concat
                                   (copy_and_terms(static_cast<GList*>(i->data)),
                                    copy_and_terms(static_cast<GList*>(j->data))));
            }
        }
        retval->terms = g_list_reverse(retval->terms);
        break;
 
    case QOF_QUERY_NAND:
        /* !(a*b) = (!a + !b) */
        i1     = qof_query_invert(q1);
        i2     = qof_query_invert(q2);
        retval = qof_query_merge(i1, i2, QOF_QUERY_OR);
        qof_query_destroy(i1);
        qof_query_destroy(i2);
        break;
 
    case QOF_QUERY_NOR:
        /* !(a+b) = (!a*!b) */
        i1     = qof_query_invert(q1);
        i2     = qof_query_invert(q2);
        retval = qof_query_merge(i1, i2, QOF_QUERY_AND);
        qof_query_destroy(i1);
        qof_query_destroy(i2);
        break;
 
    case QOF_QUERY_XOR:
        /* a xor b = (a * !b) + (!a * b) */
        i1     = qof_query_invert(q1);
        i2     = qof_query_invert(q2);
        t1     = qof_query_merge(q1, i2, QOF_QUERY_AND);
        t2     = qof_query_merge(i1, q2, QOF_QUERY_AND);
        retval = qof_query_merge(t1, t2, QOF_QUERY_OR);
 
        qof_query_destroy(i1);
        qof_query_destroy(i2);
        qof_query_destroy(t1);
        qof_query_destroy(t2);
        break;
    }
 
    if (retval)
        retval->search_for = search_for;
    return retval;
}

qof_query_merge_in_place()

void qof_query_merge_in_place	(	QofQuery *	q1,
		QofQuery *	q2,
		QofQueryOp	op
	)

Like qof_query_merge, but this will merge a copy of q2 into q1.

q2 remains unchanged.

Definition at line 1236 of file qofquery.cpp.

{
    QofQuery *tmp_q;
 
    if (!q1 || !q2)
        return;
 
    tmp_q = qof_query_merge (q1, q2, op);
    swap_terms (q1, tmp_q);
    qof_query_destroy (tmp_q);
}

qof_query_num_terms()

int qof_query_num_terms

(

QofQuery *

q

)

Return the number of terms in the canonical form of the query.

Definition at line 954 of file qofquery.cpp.

{
    GList *o;
    int n = 0;
    if (!q) return 0;
    for (o = q->terms; o; o = o->next)
        n += g_list_length(static_cast<GList*>(o->data));
    return n;
}

qof_query_numeric_predicate()

QofQueryPredData * qof_query_numeric_predicate	(	QofQueryCompare	how,
		QofNumericMatch	options,
		gnc_numeric	value
	)

Definition at line 556 of file qofquerycore.cpp.

{
    query_numeric_t pdata;
    pdata = g_new0 (query_numeric_def, 1);
    pdata->pd.type_name = query_numeric_type;
    pdata->pd.how = how;
    pdata->options = options;
    pdata->amount = value;
    return ((QofQueryPredData*)pdata);
}

qof_query_purge_terms()

void qof_query_purge_terms	(	QofQuery *	q,
		QofQueryParamList *	param_list
	)

Remove query terms of a particular type from q.

The "type" of a term is determined by the type of data that gets passed to the predicate function. XXX ??? Huh? remove anything of that predicate type, or just the particular predicate ?

Definition at line 705 of file qofquery.cpp.

{
    QofQueryTerm *qt;
    GList *_or_, *_and_;
 
    if (!q || !param_list) return;
 
    for (_or_ = q->terms; _or_; _or_ = _or_->next)
    {
        for (_and_ = static_cast<GList*>(_or_->data); _and_;
         _and_ = static_cast<GList*>(_and_->next))
        {
            qt = static_cast<QofQueryTerm*>(_and_->data);
            if (!param_list_cmp (qt->param_list, param_list))
            {
                auto or_list = static_cast<GList*> (_or_->data);
                if (or_list && !or_list->next)
                {
                    q->terms = g_list_remove_link (static_cast<GList*>(q->terms), _or_);
                    g_list_free_1 (_or_);
                    _or_ = q->terms;
                    break;
                }
                else
                {
                    _or_->data = g_list_remove_link (or_list, _and_);
                    g_list_free_1 (_and_);
                    _and_ = static_cast<GList*>(_or_->data);
                    if (!_and_) break;
                }
                q->changed = 1;
                free_query_term (qt);
            }
        }
        if (!_or_) break;
    }
}

qof_query_run()

GList * qof_query_run

(

QofQuery *

query

)

Perform the query, return the results.

The returned list is a list of the 'search-for' type that was previously set with the qof_query_search_for() or the qof_query_create_for() routines. The returned list will have been sorted using the indicated sort order, and trimmed to the max_results length.

Do NOT free the resulting list. This list is managed internally by QofQuery.

Definition at line 149 of file fake-qofquery.cpp.

{
    GList *matching_objects = NULL;
    bool  query_used        = queryPool.query_used(query);
 
    EXPECT_TRUE(query_used);
    if (query_used)
    {
        auto matchingObjects = ((QofFakeQuery*)query)->run();
 
        for (auto object : matchingObjects)
        {
            matching_objects = g_list_append(matching_objects, static_cast<gpointer>(object));
        }
    }
 
    return matching_objects;
}

qof_query_run_subquery()

GList * qof_query_run_subquery	(	QofQuery *	subquery,
		const QofQuery *	primary_query
	)

Perform a subquery, return the results.

Instead of running over a book, the subquery runs over the results of the primary query.

Do NOT free the resulting list. This list is managed internally by QofQuery.

Definition at line 880 of file qofquery.cpp.

{
    if (!subq) return nullptr;
    if (!primaryq) return nullptr;
 
    /* Make sure we're searching for the same thing */
    g_return_val_if_fail (subq->search_for, nullptr);
    g_return_val_if_fail (primaryq->search_for, nullptr);
    g_return_val_if_fail(!g_strcmp0(subq->search_for, primaryq->search_for),
                         nullptr);
 
    /* Perform the subquery */
    return qof_query_run_internal(subq, qof_query_run_subq_cb,
                                  (gpointer)primaryq);
}

qof_query_search_for()

void qof_query_search_for	(	QofQuery *	query,
		QofIdTypeConst	obj_type
	)

Set the object type to be searched for.

The results of performing the query will be a list of this obj_type.

Definition at line 926 of file qofquery.cpp.

{
    if (!q || !obj_type)
        return;
 
    if (g_strcmp0 (q->search_for, obj_type))
    {
        q->search_for = (QofIdType) obj_type;
        q->changed = 1;
    }
}

qof_query_set_book()

void qof_query_set_book	(	QofQuery *	q,
		QofBook *	book
	)

Set the book to be searched.

Books contain/identify collections of objects; the search will be performed over those books specified with this function. If no books are set, no results will be returned (since there is nothing to search over).

You can search multiple books. To specify multiple books, call this function multiple times with different arguments. XXX needed qof_query_clear_books() to reset the list ...

Definition at line 120 of file fake-qofquery.cpp.

{
    ASSERT_TRUE(queryPool.query_used(query));
    ASSERT_TRUE(QOF_IS_BOOK(book));
    ((QofFakeQuery*)query)->set_book(book);
}

qof_query_set_max_results()

void qof_query_set_max_results	(	QofQuery *	q,
		int	n
	)

Set the maximum number of results that should be returned.

If 'max-results' is set to -1, then all of the results are returned. If there are more results than 'max-results', then the result list is trimmed. Note that there is an important interplay between 'max-results' and the sort order: only the last bit of results are returned. For example, if the sort order is set to be increasing date order, then only the objects with the most recent dates will be returned.

Definition at line 1289 of file qofquery.cpp.

{
    if (!q) return;
    q->max_results = n;
}

qof_query_set_sort_increasing()

void qof_query_set_sort_increasing	(	QofQuery *	q,
		gboolean	prim_inc,
		gboolean	sec_inc,
		gboolean	tert_inc
	)

When a query is run, the results are sorted before being returned.

This routine can be used to control the direction of the ordering. A value of TRUE indicates the sort will be in increasing order, a value of FALSE will order results in decreasing order.

Note that if there are more results than the 'max-results' value, then only the last max-results will be returned. For example, if the sort is set to be increasing date order, then only the objects with the most recent dates will be returned.

Definition at line 1280 of file qofquery.cpp.

{
    if (!q) return;
    q->primary_sort.increasing = prim_inc;
    q->secondary_sort.increasing = sec_inc;
    q->tertiary_sort.increasing = tert_inc;
}

qof_query_set_sort_options()

void qof_query_set_sort_options	(	QofQuery *	q,
		gint	prim_op,
		gint	sec_op,
		gint	tert_op
	)

Definition at line 1271 of file qofquery.cpp.

{
    if (!q) return;
    q->primary_sort.options = prim_op;
    q->secondary_sort.options = sec_op;
    q->tertiary_sort.options = tert_op;
}

qof_query_set_sort_order()

void qof_query_set_sort_order	(	QofQuery *	q,
		QofQueryParamList *	primary_sort_params,
		QofQueryParamList *	secondary_sort_params,
		QofQueryParamList *	tertiary_sort_params
	)

When a query is run, the results are sorted before being returned.

This routine can be used to set the parameters on which the sort will be performed. Two objects in the result list will be compared using the 'primary_sort_params', and sorted based on that order. If the comparison shows that they are equal, then the 'secondary_sort_params' will be used. If still equal, then the tertiary parameters will be compared. Any or all of these parameter lists may be NULL. Any of these parameter lists may be set to QUERY_DEFAULT_SORT.

Note that if there are more results than the 'max-results' value, then only the last max-results will be returned. For example, if the sort is set to be increasing date order, then only the objects with the most recent dates will be returned.

The input lists become the property of QofQuery and are managed by it. They will be freed when the query is destroyed (or when new lists are set).

Definition at line 1249 of file qofquery.cpp.

{
    if (!q) return;
    if (q->primary_sort.param_list)
        g_slist_free (q->primary_sort.param_list);
    q->primary_sort.param_list = params1;
    q->primary_sort.options = 0;
 
    if (q->secondary_sort.param_list)
        g_slist_free (q->secondary_sort.param_list);
    q->secondary_sort.param_list = params2;
    q->secondary_sort.options = 0;
 
    if (q->tertiary_sort.param_list)
        g_slist_free (q->tertiary_sort.param_list);
    q->tertiary_sort.param_list = params3;
    q->tertiary_sort.options = 0;
 
    q->changed = 1;
}

qof_query_shutdown()

void qof_query_shutdown

(

void

)

Definition at line 1368 of file qofquery.cpp.

{
    qof_class_shutdown ();
    qof_query_core_shutdown ();
}

qof_string_number_compare_func()

int qof_string_number_compare_func	(	gpointer	a,
		gpointer	b,
		gint	options,
		QofParam *	this_param
	)

Compare two parameter(strings) as if they are numbers! the two objects, a and b, are the objects being compared this_param is the QofParam for this parameter in the objects.

Definition at line 209 of file qofquerycore.cpp.

{
    const char *s1, *s2;
    char *sr1, *sr2;
    long i1, i2;
    g_return_val_if_fail (a && b && getter && getter->param_getfcn, COMPARE_ERROR);
 
    s1 = ((query_string_getter)getter->param_getfcn) (a, getter);
    s2 = ((query_string_getter)getter->param_getfcn) (b, getter);
 
    // Deal with nullptr strings
    if (s1 == s2)  return 0;
    if (!s1 && s2) return -1;
    if (s1 && !s2) return 1;
 
    // Convert to integers and test
    i1 = strtol(s1, &sr1, 10);
    i2 = strtol(s2, &sr2, 10);
    if (i1 < i2)  return -1;
    if (i1 > i2)  return 1;
 
    // If the integers match, then test the REST of the string as text.
    if (options == QOF_STRING_MATCH_CASEINSENSITIVE)
        return safe_strcasecmp (sr1, sr2);
 
    return g_strcmp0 (sr1, sr2);
}

Variable Documentation

how

QofQueryCompare QofQueryPredData::how

Definition at line 146 of file qofquerycore.h.

type_name

QofType QofQueryPredData::type_name

Definition at line 145 of file qofquerycore.h.