qofquery-serialize.c

/********************************************************************\
 * qofquery-serialize.c -- Convert QofQuery to XML                  *
 * Copyright (C) 2001,2002,2004 Linas Vepstas <linas@linas.org>     *
 *                                                                  *
 * 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 2 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, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 59 Temple Place - Suite 330        Fax:    +1-617-542-2652       *
 * Boston, MA  02111-1307,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/

#include "config.h"

#include "qofquery-serialize.h"
#include "qofquery-p.h"
#include "qofquerycore-p.h"
#include "kvp_frame.h"

/* NOTE: Development of this idea has ceased and this file is
no longer included in the QOF library. It remains in CVS for now.*/

/* ======================================================= */

#define PUT_STR(TOK,VAL) {                           \
   xmlNodePtr node;                                  \
   const char * str = (VAL);                         \
   if (str && 0 != str[0])                           \
   {                                                 \
      node = xmlNewNode (NULL, TOK);                 \
      xmlNodeAddContent(node, str);                  \
      xmlAddChild (topnode, node);                   \
   }                                                 \
}

#define PUT_INT32(TOK,VAL) {                         \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%d", (VAL));     \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_INT64(TOK,VAL) {                         \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%" G_GINT64_FORMAT, (VAL));   \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_DBL(TOK,VAL) {                           \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   g_snprintf (buff, sizeof(buff), "%.18g", (VAL));  \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_GUID(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   guid_to_string_buff ((VAL), buff);                \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_DATE(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   char buff[80];                                    \
   gnc_timespec_to_iso8601_buff ((VAL), buff);       \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, buff);                    \
   xmlAddChild (topnode, node);                      \
}

#define PUT_NUMERIC(TOK,VAL) {                       \
   xmlNodePtr node;                                  \
   char *str;                                        \
   str = gnc_numeric_to_string (VAL);                \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   g_free (str);                                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_BOOL(TOK,VAL) {                          \
   xmlNodePtr node;                                  \
   gboolean boll = (VAL);                            \
   node = xmlNewNode (NULL, TOK);                    \
   if (boll) {                                       \
      xmlNodeAddContent(node, "T");                  \
   } else {                                          \
      xmlNodeAddContent(node, "F");                  \
   }                                                 \
   xmlAddChild (topnode, node);                      \
}

#define PUT_HOW(TOK,VAL,A,B,C,D,E,F) {               \
   xmlNodePtr node;                                  \
   const char * str = "EQUAL";                       \
   switch (VAL)                                      \
   {                                                 \
      case QOF_COMPARE_##A: str = #A; break;         \
      case QOF_COMPARE_##B: str = #B; break;         \
      case QOF_COMPARE_##C: str = #C; break;         \
      case QOF_COMPARE_##D: str = #D; break;         \
      case QOF_COMPARE_##E: str = #E; break;         \
      case QOF_COMPARE_##F: str = #F; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH2(TOK,VAL,PFX,A,B) {                \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH3(TOK,VAL,PFX,A,B,C) {              \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
      case QOF_##PFX##_##C: str = #C; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

#define PUT_MATCH5(TOK,VAL,PFX,A,B,C,D,E) {          \
   xmlNodePtr node;                                  \
   const char * str = #A;                            \
   switch (VAL)                                      \
   {                                                 \
      case QOF_##PFX##_##A: str = #A; break;         \
      case QOF_##PFX##_##B: str = #B; break;         \
      case QOF_##PFX##_##C: str = #C; break;         \
      case QOF_##PFX##_##D: str = #D; break;         \
      case QOF_##PFX##_##E: str = #E; break;         \
   }                                                 \
   node = xmlNewNode (NULL, TOK);                    \
   xmlNodeAddContent(node, str);                     \
   xmlAddChild (topnode, node);                      \
}

/* ======================================================= */

static void
qof_kvp_value_to_xml (KvpValue *kval, xmlNodePtr topnode)
{
        KvpValueType kvt = kvp_value_get_type (kval);

        switch (kvt)
        {
                case KVP_TYPE_GINT64:
                        PUT_INT64 ("qofquery:int64", kvp_value_get_gint64(kval));
                        break;
                case KVP_TYPE_DOUBLE:
                        PUT_DBL ("qofquery:double", kvp_value_get_double(kval));
                        break;
                case KVP_TYPE_NUMERIC:
                        PUT_NUMERIC ("qofquery:numeric", kvp_value_get_numeric(kval));
                        break;
                case KVP_TYPE_GUID:
                        PUT_GUID ("qofquery:guid", kvp_value_get_guid(kval));
                        break;
                case KVP_TYPE_STRING:
                        PUT_STR ("qofquery:string", kvp_value_get_string(kval));
                        break;
                case KVP_TYPE_TIMESPEC:
                        PUT_DATE ("qofquery:date", kvp_value_get_timespec(kval));
                        break;
                case KVP_TYPE_BINARY:
                case KVP_TYPE_GLIST:
                case KVP_TYPE_FRAME:
                        // XXX don't know how to support these.
                        break;
        }
}

/* ======================================================= */

static xmlNodePtr
qof_query_pred_data_to_xml (QofQueryPredData *pd)
{
        GList *n;
        GSList *ns;
        xmlNodePtr topnode;
        query_guid_t pdata_g;
        query_string_t pdata_s;
        query_numeric_t pdata_n;
        query_kvp_t pdata_k;
        query_date_t pdata_d;
        query_int64_t pdata_i64;
        query_int32_t pdata_i32;
        query_double_t pdata_db;
        query_boolean_t pdata_bool;
        query_char_t pdata_c;
        
        if (!safe_strcmp (pd->type_name, QOF_TYPE_GUID))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-guid");
                /* GUID Predicate doesn't do a PUT_HOW */

                pdata_g = (query_guid_t) pd;
                PUT_MATCH5("qofquery:guid-match", pdata_g->options, 
                                GUID_MATCH, ANY, ALL, NONE, NULL, LIST_ANY);

                for (n = pdata_g->guids; n; n = n->next)
                {
                        PUT_GUID ("qofquery:guid", n->data);
                }
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_STRING))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-string");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_s = (query_string_t) pd;
                PUT_MATCH2("qofquery:string-match", pdata_s->options,
                       STRING_MATCH, NORMAL, CASEINSENSITIVE);
                PUT_BOOL ("qofquery:is-regex", pdata_s->is_regex);
                PUT_STR ("qofquery:string", pdata_s->matchstring);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_NUMERIC))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-numeric");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_n = (query_numeric_t) pd;
                PUT_MATCH3("qofquery:numeric-match", pdata_n->options,
                                 NUMERIC_MATCH, DEBIT, CREDIT, ANY);
                
                PUT_NUMERIC ("qofquery:numeric", pdata_n->amount);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_KVP))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-kvp");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_k = (query_kvp_t) pd;
                for (ns=pdata_k->path; ns; ns=ns->next)
                {
                        PUT_STR ("qofquery:kvp-path", ns->data);
                }
                qof_kvp_value_to_xml (pdata_k->value, topnode);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_DATE))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-date");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_d = (query_date_t) pd;
                
                PUT_MATCH2("qofquery:date-match", pdata_d->options,
                                 DATE_MATCH, NORMAL, DAY);

                PUT_DATE ("qofquery:date", pdata_d->date);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_INT64))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-int64");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_i64 = (query_int64_t) pd;
                PUT_INT64 ("qofquery:int64", pdata_i64->val);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_INT32))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-int32");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_i32 = (query_int32_t) pd;
                
                PUT_INT32 ("qofquery:int32", pdata_i32->val);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_DOUBLE))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-double");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_db = (query_double_t) pd;
                
                PUT_DBL ("qofquery:double", pdata_db->val);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_BOOLEAN))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-boolean");
                PUT_HOW ("qofquery:compare", pd->how, LT, LTE, EQUAL, GT, GTE, NEQ);

                pdata_bool = (query_boolean_t) pd;
                
                PUT_BOOL ("qofquery:boolean", pdata_bool->val);
                return topnode;
        }
        if (!safe_strcmp (pd->type_name, QOF_TYPE_CHAR))
        {
                topnode = xmlNewNode (NULL, "qofquery:pred-char");
                /* There is no PUT_HOW for char-match */
                pdata_c = (query_char_t) pd;
                
                PUT_MATCH2("qofquery:char-match", pdata_c->options,
                                 CHAR_MATCH, ANY, NONE);
                
                PUT_STR ("qofquery:char-list", pdata_c->char_list);
                return topnode;
        }
        return NULL;
}

/* ======================================================= */

static xmlNodePtr
qof_query_param_path_to_xml (GSList *param_path)
{
        xmlNodePtr topnode;
        GSList *n;
        QofIdTypeConst path;
        
        n = param_path;
        topnode = xmlNewNode (NULL, "qofquery:param-path");
        for ( ; n; n=n->next)
        {
                path = n->data;
                if (!path) continue;
                PUT_STR ("qofquery:param", path);
        }
        return topnode;
}

/* ======================================================= */

static xmlNodePtr
qof_query_one_term_to_xml (QofQueryTerm *qt)
{
        xmlNodePtr node;
        xmlNodePtr term;
        xmlNodePtr topnode;
        gboolean invert;
        GSList *path;
        QofQueryPredData *pd;

        invert = qof_query_term_is_inverted (qt);
        term = xmlNewNode (NULL, "qofquery:term");
        topnode = term;
        path = qof_query_term_get_param_path (qt);
        pd = qof_query_term_get_pred_data (qt);
        if (invert)
        {
                /* inverter becomes new top mode */
                topnode = xmlNewNode (NULL, "qofquery:invert");
                xmlAddChild (term, topnode);
        }

        node = qof_query_param_path_to_xml (path);
        if (node) xmlAddChild (topnode, node);

        node = qof_query_pred_data_to_xml (pd);
        if (node) xmlAddChild (topnode, node);

        return term;
}

/* ======================================================= */

static xmlNodePtr
qof_query_and_terms_to_xml (GList *and_terms)
{
        xmlNodePtr terms;
        GList *n;
        QofQueryTerm *qt;
        xmlNodePtr t;
        
        terms = xmlNewNode (NULL, "qofquery:and-terms");
        n = and_terms;
        for ( ; n; n=n->next)
        {
                qt = n->data;
                if (!qt) continue;

                t = qof_query_one_term_to_xml (n->data);
                if (t) xmlAddChild (terms, t);
        }
        return terms;
}

/* ======================================================= */

static xmlNodePtr
qof_query_terms_to_xml (QofQuery *q)
{
        xmlNodePtr terms;
        GList *n;
        xmlNodePtr andt;
        
        terms = NULL;
        n = qof_query_get_terms (q);
        if (!n) return NULL;
        terms = xmlNewNode (NULL, "qofquery:or-terms");

        for ( ; n; n=n->next)
        {
                andt = qof_query_and_terms_to_xml (n->data);
                if (andt) xmlAddChild (terms, andt);
        }
        return terms;
}

/* ======================================================= */

static xmlNodePtr
qof_query_sorts_to_xml (QofQuery *q)
{
        QofQuerySort *s[3];
        xmlNodePtr sortlist;
        GSList *plist;
        xmlNodePtr sort;
        xmlNodePtr topnode;
        gboolean increasing;
        gint opt;
        xmlNodePtr pl;
        int i;
        
        qof_query_get_sorts (q, &s[0], &s[1], &s[2]);

        if (NULL == s[0]) return NULL;

        sortlist = xmlNewNode (NULL, "qofquery:sort-list");
        for (i=0; i<3; i++)
        {
                if (NULL == s[i]) continue;

                plist = qof_query_sort_get_param_path (s[i]);
                if (!plist) continue;

                sort = xmlNewNode (NULL, "qofquery:sort");
                xmlAddChild (sortlist, sort);

                topnode = sort;

                increasing = qof_query_sort_get_increasing (s[i]);
                PUT_STR ("qofquery:order", increasing ? "DESCENDING" : "ASCENDING");

                opt = qof_query_sort_get_sort_options (s[i]);
                PUT_INT32 ("qofquery:options", opt);

                pl = qof_query_param_path_to_xml (plist);
                if (pl) xmlAddChild (sort, pl);
        }

        return sortlist;
}

/* ======================================================= */

static void
do_qof_query_to_xml (QofQuery *q, xmlNodePtr topnode)
{
        QofIdType search_for;
        xmlNodePtr terms;
        xmlNodePtr sorts;
        gint max_results;
        
        search_for = qof_query_get_search_for (q);
        PUT_STR ("qofquery:search-for", search_for);

        terms = qof_query_terms_to_xml(q);
        if (terms) xmlAddChild (topnode, terms);

        sorts = qof_query_sorts_to_xml (q);
        if (sorts) xmlAddChild (topnode, sorts);

        max_results = qof_query_get_max_results (q);
        PUT_INT32 ("qofquery:max-results", max_results);
}

/* ======================================================= */

xmlNodePtr
qof_query_to_xml (QofQuery *q)
{
        xmlNodePtr topnode;
        xmlNodePtr node;
        xmlNsPtr   ns;

        topnode = xmlNewNode(NULL, "qof:qofquery");
        xmlSetProp(topnode, "version", "1.0.1");

        // XXX path to DTD is wrong
        // ns = xmlNewNs (topnode, "file:" "/usr/share/lib" "/qofquery.dtd", "qof");

        do_qof_query_to_xml (q, topnode);

        return topnode;
}

/* =============================================================== */

#ifdef UNIT_TEST

#include <stdio.h>
#include <qof/qofsql.h>

int main (int argc, char * argv[])
{
        QofQuery *q;
        QofSqlQuery *sq;
        xmlDocPtr doc;
        xmlNodePtr topnode;
        xmlChar *xbuf;
        int bufsz;
        xmlOutputBufferPtr xbuf;
        
        qof_query_init();
        qof_object_initialize ();

        static QofParam params[] = {
                { "adate",  QOF_TYPE_DATE, NULL, NULL},
                { "aint",   QOF_TYPE_INT32, NULL, NULL},
                { "aint64", QOF_TYPE_INT64, NULL, NULL},
                { "astr",   QOF_TYPE_STRING, NULL, NULL},
                { NULL },
        };

        qof_class_register ("GncABC", NULL, params);
        sq = qof_sql_query_new();

        qof_sql_query_parse (sq, 
            "SELECT * from GncABC WHERE aint = 123 "
            "or not astr=\'asdf\' "
            "and aint64 = 9876123456789;");
        // qof_sql_query_parse (sq, "SELECT * from GncABC;");
        q = qof_sql_query_get_query (sq);

        qof_query_print (q);

        doc = doc = xmlNewDoc("1.0");
        topnode = qof_query_to_xml (q);
        xmlDocSetRootElement(doc,topnode);

        xmlDocDumpFormatMemory (doc, &xbuf, &bufsz, 1);

        printf ("%s\n", xbuf);
        xmlFree (xbuf);
        xmlFreeDoc(doc);

#if 0
printf ("duude\n");
        // xmlOutputBufferPtr xbuf = xmlAllocOutputBuffer (enc);
        xbuf = xmlOutputBufferCreateFile (stdout, NULL);
printf ("duude\n");

        xbuf = xmlOutputBufferCreateFd (1, NULL);
printf ("duude\n");
        xmlNodeDumpOutput (xbuf, NULL, topnode, 99, 99, "iso-8859-1");
        // xmlElemDump (stdout, NULL, topnode);
#endif

        return 0;
}

#endif /* UNIT_TEST */

/* ======================== END OF FILE =================== */

---