duitxnquery.c File Reference

---

Detailed Description

Implementation of SQL Query Handler.

Author:

Copyright (C) 2002,2004 Linas Vepstas <linas@linas.org>

Definition in file duitxnquery.c.

#include "config.h"
#include <string.h>
#include <glib.h>
#include "builder.h"
#include "estron.h"
#include "dui-initdb.h"
#include "duifield.h"
#include "duifield-sql.h"
#include "duifieldmap.h"
#include "duifilter.h"
#include "duiresolver.h"
#include "duitxnquery.h"
#include "perr.h"

Go to the source code of this file.

Enumerations
enum	MetaQueryType { QUERY_NONE, QUERY_SIMPLE, QUERY_TABLES, QUERY_FIELDS }
Functions
static void	dui_txnquery_init (DuiTxnQuery *q)
DuiTxnQuery *	dui_txnquery_new (void)
void	dui_txnquery_destroy (DuiTxnQuery *q)
void	dui_txnquery_set_database (DuiTxnQuery *q, DuiDatabase *db)
void	dui_txnquery_set_tablename (DuiTxnQuery *qry, const gchar *tablename)
void	dui_txnquery_set_querytype (DuiTxnQuery *qry, const gchar *sql_querytype)
void	dui_txnquery_set_table (DuiTxnQuery *qry, DuiField *tabfld, const gchar *sql_querytype)
void	dui_txnquery_add_term (DuiTxnQuery *qry, DuiFieldMap *fm)
void	dui_txnquery_add_source_match_term (DuiTxnQuery *qry, DuiFieldMap *fm)
DuiFieldMap *	dui_txnquery_get_source_match_term (DuiTxnQuery *qry)
void	dui_txnquery_set_resolver (DuiTxnQuery *qry, DuiResolver *res)
void	dui_txnquery_do_realize (DuiTxnQuery *qry)
void	dui_txnquery_connect (DuiTxnQuery *qry)
static DuiDBRecordSet *	dui_txnquery_run_one_query (DuiTxnQuery *qry)
DuiDBRecordSet *	dui_txnquery_run (DuiTxnQuery *qry)
DuiDBRecordSet *	dui_txnquery_rerun_last_query (DuiTxnQuery *qry)

---

Function Documentation

static DuiDBRecordSet* dui_txnquery_run_one_query

(

DuiTxnQuery *

qry

)

[static]

< Database table column

< match to database column

< match to database column

Definition at line 356 of file duitxnquery.c.

{
    DuiDBRecordSet *recs = NULL;
    if (!qry) return NULL;

    ENTER ("(qry=%p)", qry);
    switch (qry->meta_qtype)
    {
        case QUERY_NONE: break;
        case QUERY_SIMPLE: break;
        case QUERY_TABLES:
            if (qry->db_conn)
            {
                recs = dui_connection_tables(qry->db_conn);
                return recs;
            }
            break;
        case QUERY_FIELDS:
            if ((qry->db_conn) && (qry->table->get_field_value))
            {
                const char * table;
                table = qry->table->get_field_value(qry->table);
                PINFO ("perform fields query with table=\'%s\'", table);
                recs = dui_connection_table_columns(qry->db_conn, table);
                return recs;
            }
            break;
    }

    /* If we have data we need to query, then do the query.  */
    if (qry->sql_builder)
    {
        GList *node;
        SqlBuilder *dupe;
        short broken_select = 0;
        short wild_select = 1;

        g_free (qry->query_string);
        qry->query_string = NULL;

        /* Make a copy of the query, which might be holding statically
         * compiled 'SELECT term FROM table' in it.  These static terms
         * were added with the dui_txnquery_add_term() routine above.
         * We append dynamic terms below, dynamic in that we need the
         * values for the INSERT, UPDATE and WHERE terms.
         *
         * Note also: if the sql_builder is empty, then there MUST be
         * some insert/update terms; alternately, if the sql_builder
         * is not empty, there must NOT be any insert/update terms,
         * else bad SQL will be generated.
         */
        dupe = sql_builder_copy (qry->sql_builder);

        /* Loop, looking for INSERT/UPDATE terms */
        for (node = qry->terms; node; node=node->next)
        {
            DuiFieldMap *fm = node->data;
            const char * fieldval;
            if ((!DUI_FIELD_IS_TYPE(&fm->target,DUI_FIELD_SQL)) &&
                (!DUI_FIELD_IS_TYPE(&fm->target,DUI_FIELD_WHERE))) continue;

            fieldval = dui_field_map_get_value (fm);
            if ((NULL == fieldval) && ((SQL_INSERT == qry->qtype) ||
                                       (SQL_UPDATE == qry->qtype)))
            {
                PERR ("Null field value for insert/update not allowed, field=%s\n",
                       fm->target.fieldname);
                sql_builder_destroy (dupe);
                return NULL;
            }
            sql_builder_set_str (dupe, fm->target.fieldname, fieldval);
            PINFO ("insert/update %s=%s", fm->target.fieldname, fieldval);
        }

        /* Loop again, this time for where terms */
        for (node = qry->terms; node; node=node->next)
        {
            DuiFieldMap *fm = node->data;
            const char * fieldval;

            if (!DUI_FIELD_IS_TYPE(&fm->target,DUI_FIELD_WHERE)) continue;
            wild_select = 0;

            fieldval = dui_field_map_get_value (fm);
            PINFO ("where (%s %s %s)", fm->target.fieldname,
                            dui_field_where_get_op(&fm->target), fieldval);
            /* fields left blank don't match anything */
            fieldval = whitespace_filter (fieldval);
            if (fieldval)
            {
                /* Do not use 'where' term when inserting;
                 * This was already picked up above. */
                if (SQL_INSERT != qry->qtype)
                {
                    sql_builder_where_str (dupe,
                       fm->target.fieldname,
                        fieldval, dui_field_where_get_op(&fm->target));
                }
            }
            else
            {
                broken_select = 1;
            }
        }

        if (NULL == qry->db_conn)
        {
            /* Now get the database too */
            if (NULL == qry->database)
            {
                PERR ("Can't perform query, no database specified!\n");
                sql_builder_destroy (dupe);
                return NULL;
            }
            qry->db_conn = dui_database_do_realize (qry->database);
        }

        /* Perform the query only if its an intentional wild-card
         * or has valid WHERE terms.  Goal is to try to prevent
         * stupid DUI XML file errors from doing a global clobber.
         * (e.g. an unintentional wildcard delete, because some
         * value for the where clause couldn't be found.)
         */
        if (wild_select || !broken_select || (SQL_SELECT == qry->qtype))
        {
            const gchar * stmt;

            /* Get the sql statement string */
            stmt = sql_builder_query (dupe);
            qry->query_string = g_strdup (stmt);

            /* Now run the query */
            if (qry->db_conn)
            {
                recs = dui_connection_exec(qry->db_conn, stmt);
            }
        }
        else
        {
            PERR ("Can't perform query, missing WHERE term (%d %d)",
                   wild_select, broken_select);
            sql_builder_destroy (dupe);
            return NULL;
        }
        sql_builder_destroy (dupe);
    }
    else
    {
        PERR ("Failed to specify table for query");
    }

    LEAVE(" got recs=%p for query=\"%s\"\n", recs, qry->query_string);

    return recs;
}