---

d_xpath_f.c

Go to the documentation of this file.

/* GtkSQL -- an interactive graphical query tool for PostgreSQL, MySQL and XPath.
 * Copyright (C) 2003 Darryl Luff
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include "../config.h"

#ifdef USE_XPATH

#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include "buf.h"
#include "dbapi.h"

#define XMLFILE "XML File"

enum {
    FLD_TYPE = 0,       
    FLD_NAME,           
    FLD_ATTRIB,         
    FLD_CONTENT         
} FldTypes;

#define FLD_COUNT   4

typedef struct {
    /* table fields. These should be in the common part. */
    int tableCount;             
    DBTableDef *tableDef;       
    xmlDocPtr doc;              
    char *filename;             
    xmlXPathObjectPtr result;   
    int status;                 
    char *errmsg;               
} DBConnection_XPath;

static char *xpathKeywords[] = {
    "SELECT",
    NULL
};

void *xpath_query(DBConnection * dbc, char *xpstr)
{
    DBConnection_XPath *dbcxp;
    xmlXPathContextPtr context;
    if (!dbc)
        return NULL;

    if (!dbc->pvt)
        return NULL;

    dbcxp = (DBConnection_XPath *) (dbc->pvt);
    dbcxp->status = DB_QUERY_RECORDS_OK;

    if (!dbcxp->doc) {
        dbcxp->status = DB_QUERY_ERROR;
        return NULL;
    }

    if (dbcxp->result) {
        printf("WARNING: Result already exists.\n");
        xmlXPathFreeObject(dbcxp->result);
    }

    context = xmlXPathNewContext(dbcxp->doc);
    dbcxp->result = xmlXPathEvalExpression(xpstr, context);

    if (xmlXPathNodeSetIsEmpty(dbcxp->result->nodesetval)) {
        dbcxp->status = DB_QUERY_EMPTY;
        printf("No result\n");
    }

    xmlXPathFreeContext(context);
    return dbcxp->result;
}

DBConnection *xpath_dbconnection_free(DBConnection * c)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    free(dbxpath->filename);

    /* Clear Keywords memory */
    keywords_remove_all(c);

    /* Free structure memory */
    free(dbxpath);
    free(c);
    return NULL;
}

char *xpath_error()
{
    g_warning("xpath_error() not implemented\n");
    return "Not implemented";
}

static void xp_DBclear_result(DBConnection * c, void *result)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    if (!dbxpath)
        return;

    if (dbxpath->result) {
        xmlXPathFreeObject(dbxpath->result);
        dbxpath->result = NULL;
    }
}

static int xp_DBdisconnect(DBConnection * c)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);

    /* End connection */
    xp_DBclear_result(c, NULL);
    if (dbxpath->doc) {
        xmlFreeDoc(dbxpath->doc);
        dbxpath->doc = NULL;
    }
    return 0;
}

static char *xp_DBget_error_message(DBConnection * c)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    if (!dbxpath)
        return "Connection invalid";

    return xpath_error(dbxpath->filename);
}

static char *xp_DBget_db_name(DBConnection * c)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    if (!dbxpath)
        return NULL;
    return dbxpath->filename;
}

static void *xp_DBexecute_query(DBConnection * c, char *query)
{
    return xpath_query(c, query);
}

static int xp_DBget_query_status(DBConnection * c, void *result)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    if (!dbxpath)
        return DB_QUERY_ERROR;

    return dbxpath->status;
}

static int xp_DBget_record_number(DBConnection * c, void *result)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    if (!dbxpath)
        return 0;

    if (!dbxpath->result)
        return 0;

    if (!dbxpath->result->nodesetval)
        return 0;

    return dbxpath->result->nodesetval->nodeNr;
}

static int xp_DBget_field_number(DBConnection * c, void *result)
{
    return FLD_COUNT;
}

static char *xp_DBget_field_name(DBConnection * c, void *result, int field)
{
    switch (field) {
    case FLD_TYPE:
        return "Type";
    case FLD_NAME:
        return "Name";
    case FLD_ATTRIB:
        return "Attributes";
    case FLD_CONTENT:
        return "Content";
    }
    return "";
}

char *xp_DBget_field_value_type(xmlNodePtr node)
{
    if (! node)
        return "";

    switch (node->type) {
        case XML_ELEMENT_NODE:
            return "NODE";
        case XML_ATTRIBUTE_NODE:
            return "ATTRIBUTE";
        case XML_TEXT_NODE:
            return "TEXT";
        case XML_CDATA_SECTION_NODE:
            return "CDATA";
        case XML_ENTITY_REF_NODE:
            return "ENTITY_REF";
        case XML_ENTITY_NODE:
            return "ENTITY";
        case XML_PI_NODE:
            return "PI";
        case XML_COMMENT_NODE:
            return "COMMENT";
        case XML_DOCUMENT_NODE:
            return "DOCUMENT";
        case XML_DOCUMENT_TYPE_NODE:
            return "DOCUMENT_TYPE";
        case XML_DOCUMENT_FRAG_NODE:
            return "DOCUMENT_FRAG";
        case XML_NOTATION_NODE:
            return "NOTATION";
        case XML_HTML_DOCUMENT_NODE:
            return "HTML_DOCUMENT";
        case XML_DTD_NODE:
            return "DTD";
        case XML_ELEMENT_DECL:
            return "ELEMENT_DECL";
        case XML_ATTRIBUTE_DECL:
            return "ATTRIBUTE_DECL";
        case XML_ENTITY_DECL:
            return "ENTITY_DECL";
        case XML_NAMESPACE_DECL:
            return "NAMESPACE_DECL";
        case XML_XINCLUDE_START:
            return "XINCLUDE_START";
        case XML_XINCLUDE_END:
            return "XINCLUDE_END";
        case XML_DOCB_DOCUMENT_NODE:
            return "DOCB_DOCUMENT";
        default:
            return "";
        }
}

static ABuf *contentbuf = NULL;
static ABuf *attrbuf = NULL;

char *xp_DBget_field_value_attrib(xmlNodePtr node) {
    xmlAttrPtr attr = NULL;
    xmlChar *txt;
    xmlNodePtr cur;

    if (! node)
        return "";

    cur = node;
    if (! cur)
        return "NIL: cur is NULL";

    attrbuf = buf_check(attrbuf, 1024);
    attrbuf = buf_strcpy(attrbuf, "");

    /* \todo Havent figured attributes out yet. The documentation isn't
     * very complete. Have to grab the libxml source. */
    attr = cur->properties;
    if (attr == NULL)
        attr = cur;
    
        //attrbuf = buf_strcat(attrbuf, "NIL: attr is NULL");

    while (attr != NULL) {
        if (attr->name)
            attrbuf = buf_strcat(attrbuf, (char *)attr->name);
        else
            attrbuf = buf_strcat(attrbuf, "NULL");

        attrbuf = buf_strcat(attrbuf, "=\"");
        txt = xmlNodeListGetString(node->doc, attr->children, 1);
        if (txt != NULL)
            attrbuf = buf_strcat(attrbuf, txt);

        attrbuf = buf_strcat(attrbuf, "\" ");
        attr = attr->next;
    }
    return attrbuf->b_dat;
}

char *xp_DBget_field_value_content(xmlNodePtr node) {
    xmlNodePtr child = NULL;

    if (! node)
        return "";

    switch (node->type) {
        case XML_ELEMENT_NODE:
            child = node->children;
            contentbuf = buf_strcpy(contentbuf, "");
            while (child) {
                if (!strcmp(child->name, "text"))
                    contentbuf = buf_strcat(contentbuf, trimtext(child->content));
                child = child->next;
            }
            return contentbuf->b_dat;
        case XML_ATTRIBUTE_NODE:
            return "ATTRIBUTE";
        case XML_TEXT_NODE:
            return "TEXT";
        case XML_CDATA_SECTION_NODE:
            return "CDATA";
        case XML_ENTITY_REF_NODE:
            return "ENTITY_REF";
        case XML_ENTITY_NODE:
            return "ENTITY";
        case XML_PI_NODE:
            return "PI";
        case XML_COMMENT_NODE:
            return "COMMENT";
        case XML_DOCUMENT_NODE:
            return "DOCUMENT";
        case XML_DOCUMENT_TYPE_NODE:
            return "DOCUMENT_TYPE";
        case XML_DOCUMENT_FRAG_NODE:
            return "DOCUMENT_FRAG";
        case XML_NOTATION_NODE:
            return "NOTATION";
        case XML_HTML_DOCUMENT_NODE:
            return "HTML_DOCUMENT";
        case XML_DTD_NODE:
            return "DTD";
        case XML_ELEMENT_DECL:
            return "ELEMENT_DECL";
        case XML_ATTRIBUTE_DECL:
            return "ATTRIBUTE_DECL";
        case XML_ENTITY_DECL:
            return "ENTITY_DECL";
        case XML_XINCLUDE_START:
            return "XINCLUDE_START";
        case XML_XINCLUDE_END:
            return "XINCLUDE_END";
        case XML_DOCB_DOCUMENT_NODE:
            return "DOCB_DOCUMENT";
        default:
            return "";
    }
}

static char *xp_DBget_field_value(DBConnection * c, void *result, int record,
                                  int field)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);
    xmlNodePtr node = NULL;

    int rows = 0;

    if (!dbxpath)
        return "";

    if (!dbxpath->result)
        return "";

    if (!dbxpath->result->nodesetval)
        return "";

    rows = dbxpath->result->nodesetval->nodeNr;
    if (record >= rows)
        return "";

    node = dbxpath->result->nodesetval->nodeTab[record];
    if (!node)
        return "";

    /* Support four fields here, field 0 = type, field 1 = name, field 2 =
     * attributes, field 3 = contents */
    switch (field) {
    case FLD_TYPE:      return xp_DBget_field_value_type(node);
    case FLD_NAME:      return (char *)node->name;
    case FLD_ATTRIB:    return xp_DBget_field_value_attrib(node);
    case FLD_CONTENT:   return xp_DBget_field_value_content(node);
    default:
        return "";
    }
}

void xp_DBurl_to_form(Form *frm, char *url) {
    char *u;
    char *p;
    char *start;

    /* Clear the login parms    */
    frm_clear_fields(frm);

    if (url == NULL)
        return;

    u = strdup(url);
    start = u;

    /* Look for '://'   */
    p = strstr(start, "://");
    if (p != NULL) {
        p += 3;

        /* Set filename */
        frm_set_value_by_name(frm, XMLFILE, p);
    }
    free(u);
}

static int xp_add_field_def(DBConnection * c, DBTableDef * tbf)
{
    int i;
    char *fname;
    char *rtype, *rnotnull, *rhasdef;

    tbf->field_num = FLD_COUNT;
    tbf->field_def =
        (DBFieldDef *) malloc(tbf->field_num * sizeof(DBFieldDef));

    for (i = 0; i < tbf->field_num; i++) {
        switch (i) {
        case FLD_TYPE:
            fname = "Type";
            break;
        case FLD_NAME:
            fname = "Name";
            break;
        case FLD_ATTRIB:
            fname = "Atrib";
            break;
        case FLD_CONTENT:
            fname = "Content";
            break;
        default:
            fname = "";
        }
        add_keyword(c, fname, KEYWORD_FIELD);
        rtype = "int";
        rnotnull = "NO";
        rhasdef = "";

        /* allocate type_str */
        tbf->field_def[i].name = g_strdup(fname);
        tbf->field_def[i].type = g_strdup("varchar(255)");
        tbf->field_def[i].length = g_strdup("??");
    }
    return 0;
}

static int xp_DBget_table_def(DBConnection * c)
{
    int tables_in_list = 1;

    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);

    if (dbxpath->tableDef != NULL) {
        fprintf(stderr, "Internal error (memory leak)...\n");
        return -1;
    }

    /* Allocating table array */
    dbxpath->tableCount = 1;
    dbxpath->tableDef =
        (DBTableDef *) malloc(tables_in_list * sizeof(DBTableDef));

    /* Fill the table */

    /* Table name */
    dbxpath->tableDef[0].name = g_strdup("Dummy");

    /* Table fields */
    if (xp_add_field_def(c, dbxpath->tableDef + 0) < 0) {
        dbxpath->tableDef = NULL;
        return -1;
    }

    /* Keywords */
    // add_keyword(c, table_name, KEYWORD_TABLE);
    return 0;
}

static ABuf *f2ubuf = NULL;

char *xp_DBform_to_url(Form *frm) {
    char *s;

    if (frm == NULL)
        return NULL;

    f2ubuf = buf_check(f2ubuf, 100);
    f2ubuf = buf_strcat(f2ubuf, "xpath://");
    s = frm_get_value_by_name(frm, XMLFILE);
    if (s != NULL) {
        f2ubuf = buf_strcat(f2ubuf, s);
    }
    
    return f2ubuf->b_dat;
}

static void xp_DBfree_table_def(DBConnection * c)
{
    DBConnection_XPath *dbxpath = (DBConnection_XPath *) (c->pvt);

    if (dbxpath->tableDef == NULL) {
        fprintf(stderr, "Internal error (freeing a NULL connection)...\n"); /* Dont 
                                                                             * have 
                                                                             * to 
                                                                             * show 
                                                                             * an 
                                                                             * error 
                                                                             */
        return;
    }
    else {
        DBFieldDef *dbf;
        int i, j;

        for (j = 0; j < dbxpath->tableCount; j++) {
            int fnum = (dbxpath->tableDef)[j].field_num;

            if (dbxpath->tableDef[j].name)
                free(dbxpath->tableDef[j].name);

            dbf = (dbxpath->tableDef)[j].field_def;
            for (i = 0; i < fnum; i++) {
                free(dbf[i].name);
                free(dbf[i].type);
            }
            free(dbf);
        }
        free(dbxpath->tableDef);
        dbxpath->tableDef = NULL;

        /* Removing Keywords */
        keywords_remove(c, KEYWORD_TABLE);
        keywords_remove(c, KEYWORD_FIELD);
    }
}

static int xp_DBget_table_num(DBConnection * c)
{
    DBConnection_XPath *xpconn = (DBConnection_XPath *) (c->pvt);
    return xpconn->tableCount;
}

static DBTableDef *xp_DBget_table(DBConnection * c, int table)
{
    DBConnection_XPath *xpconn = (DBConnection_XPath *) (c->pvt);

    if (table > 0) {
        fprintf(stderr, "Internal error (table number too big)...\n");
        return NULL;
    }

    if (xpconn->tableDef == NULL) {
        fprintf(stderr, "Internal error (searching a NULL table)...\n");
        return NULL;
    }
    else {
        return xpconn->tableDef + table;
    }
    return NULL;
}

DBConnection *xpath_dbconnection_new()
{
    DBConnection *dbc = calloc(1, sizeof(DBConnection));
    DBConnection_XPath *pvtdata;
    int i;

    if (dbc) {
        dbc->DBdisconnect = xp_DBdisconnect;
        dbc->DBget_error_message = xp_DBget_error_message;
        dbc->DBget_db_name = xp_DBget_db_name;
        dbc->DBexecute_query = xp_DBexecute_query;
        dbc->DBget_query_status = xp_DBget_query_status;
        dbc->DBget_record_number = xp_DBget_record_number;
        dbc->DBget_field_number = xp_DBget_field_number;
        dbc->DBget_field_name = xp_DBget_field_name;
        dbc->DBget_field_value = xp_DBget_field_value;
        dbc->DBclear_result = xp_DBclear_result;

        /* Set up keywords */
        dbc->keylist = NULL;
        i = 0;
        while (xpathKeywords[i] != NULL)
            add_keyword((DBConnection *) dbc, xpathKeywords[i++],
                        KEYWORD_SQL);

        dbc->DBget_table_def = xp_DBget_table_def;
        dbc->DBfree_table_def = xp_DBfree_table_def;
        dbc->DBget_table_num = xp_DBget_table_num;
        dbc->DBget_table = xp_DBget_table;

        /* Setup private data. */
        pvtdata = calloc(1, sizeof(DBConnection_XPath));
        dbc->pvt = pvtdata;
        dbc->pvtlen = sizeof(DBConnection_XPath);
    }
    return dbc;
}

void dbconnection_xpath_set_filename(DBConnection * dbc, char *fn)
{
    DBConnection_XPath *dbcxp;

    if (!dbc)
        return;

    dbcxp = (DBConnection_XPath *) (dbc->pvt);
    if (!dbcxp)
        return;

    if (dbcxp->filename)
        free(dbcxp->filename);

    dbcxp->filename = strdup(fn);
}

void xpath_set_error(DBConnection_XPath * dbc, char *s)
{
    if (!dbc)
        return;

    if (dbc->errmsg)
        free(dbc->errmsg);

    dbc->errmsg = strdup(s);
}

int dbconnection_xpath_open_doc(DBConnection * dbc, char *fn)
{
    DBConnection_XPath *dbcxp;
    xmlNodePtr cur;

    if (!dbc)
        return CONNECT_ERROR;

    dbcxp = (DBConnection_XPath *) (dbc->pvt);

    if (!dbcxp)
        return CONNECT_ERROR;

    dbconnection_xpath_set_filename(dbc, fn);

    dbcxp->doc = xmlParseFile(fn);
    if (dbcxp->doc == NULL) {
        xpath_set_error(dbcxp, "Document not parsed successfully.");
        xmlFreeDoc(dbcxp->doc);
        dbcxp->doc = NULL;
        return CONNECT_ERROR;
    }

    cur = xmlDocGetRootElement(dbcxp->doc);
    if (cur == NULL) {
        xpath_set_error(dbcxp, "Document empty");
        xmlFreeDoc(dbcxp->doc);
        dbcxp->doc = NULL;
        return CONNECT_ERROR;
    }
    return CONNECT_OK;
}

static int connect_callback(DBConnector * dbc, DBConnection ** ret)
{
#define DB_CONNECT_ERROR_S  "Database connection error : \n %s"
    char *xmlname;
    DBConnection *ret_my;

    /* Gets the results */
    xmlname = frm_get_value_by_name(dbc->db_frm, XMLFILE);

    /* Tests the results */
    if ((xmlname == NULL) || (strlen(xmlname) == 0)) {
        dbc->app_error_dialog("Connection Error",
                              "You need to provide a database name");
        return CONNECT_ERROR;
    }

    ret_my = xpath_dbconnection_new();
    if (!ret_my)
        return CONNECT_ERROR;

    ret_my->connector = dbc;

    /* All OK - set things up */
    status_push("Parsing XML...");
    if (dbconnection_xpath_open_doc(ret_my, xmlname) != CONNECT_OK)
        return CONNECT_ERROR;

    status_pop();
    *ret = ret_my;
    return CONNECT_OK;
}

DBConnector *register_XPath(void (*error_dialog) (char *, char *))
{
#define XPATH_TYPEKEY   "XPath"
    DBConnector *ret;
    FormField *fld;

    ret = dbconnector_new();
    if (ret == NULL)
        return NULL;

    ret->dbtype = XPATH_TYPEKEY;

    /* Prepares all the structures */
    ret->app_error_dialog = error_dialog;
    ret->db_connect_callback = connect_callback;
    ret->url_to_form = xp_DBurl_to_form;
    ret->form_to_url = xp_DBform_to_url;

    /* Creates the data-structure */
    ret->db_frm = frm_new(NULL);
    frm_set_title(ret->db_frm, "XPath");
    fld = frm_add_field(ret->db_frm, XMLFILE, NULL);
    fld_set_relevance(fld, FR_REQUIRED);
    fld_set_type(fld, 0, FT_FILENAME);
    fld_set_tip(fld, "The filename for the XML file (required)");
    return ret;
}

#endif

---