dui-initdb.c

Go to the documentation of this file.

/********************************************************************\
 * dui-initdb.c -- DUI wrapper for different database drivers       *
 * Copyright (C) 2002,2003,2004 Linas Vepstas <linas@linas.org>     *
 * http://dwi.sourceforge.net                                       *
 *                                                                  *
 * This library is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU Lesser General Public       *
 * License as published by the Free Software Foundation; either     *
 * version 2.1 of the License, or (at your option) any later version.
 *                                                                  *
 * This library 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 Lesser General Public License for more details.              *
 *                                                                  *
 * You should have received a copy of the GNU Lesser 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 <dlfcn.h>
#include <string.h>

#include <glib.h>
#include <gmodule.h>
#include "dui-initdb.h"
#include "dui-initdb-p.h"
#include "perr.h"

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

static GList *db_provider_list = NULL;

void 
dui_db_provider_register (DuiDBPlugin *plg)
{
    db_provider_list = g_list_prepend (db_provider_list, plg);
}

static void
load_driver (const gchar *libname, const gchar * driver, const gchar * name)
{
    gchar *fullpath;
    typedef void (*backend_init) (void);
    GModule *backend;
    backend_init gmod_init;
    gpointer g;

    g_return_if_fail (g_module_supported ());
    fullpath = g_module_build_path (PKGLIBDIR, libname);
    backend = g_module_open (fullpath, G_MODULE_BIND_LAZY);
    if (!backend)
    {
        PERR (" No %s backend found. %s", name, g_module_error ());
        return;
    }
    g = &gmod_init;
    if (!g_module_symbol (backend, driver, g))
    {
        PERR (" %s backend did not initialise. %s", name, g_module_error ());
        return;
    }
    g_module_make_resident (backend);
    gmod_init ();
    g_free (fullpath);
}

void
dui_db_init (void)
{
}

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

static inline DuiDBPlugin *
find_provider (GList *list, const char * provider)
{
    GList *node;
    for (node=list; node; node=node->next)
    {
        DuiDBPlugin *cand = node->data;
        if (!strcmp (provider, cand->db_provider_name)) 
        {
            return cand;
        }
    }
    return NULL;
}

DuiDBConnection * 
dui_connection_new (const char * provider,
                    const char * dbname, 
                    const char * username,
                    const char * authentication_token)
{
    DuiDBPlugin *plg = NULL;
    DuiDBConnection *dbc = NULL;

    if (!provider) return NULL;

   plg = find_provider (db_provider_list, provider);
    if (!plg) 
    {
        if (!strcmp (provider, "odbc"))
        {
            load_driver ("libdwi-db-odbc.so", "dui_odbc_init", "ODBC");
        }
        else
        if (!strcmp (provider, "libpg"))
        {
            load_driver ("libdwi-db-libpg.so", "dui_libpg_init", "Postgres");
        }
        else
        if (!strcmp (provider, "libdbi"))
        {
            load_driver ("libdwi-db-libdbi.so", "dui_libdbi_init", "DBI");
        }

    plg = find_provider (db_provider_list, provider);
    }
    if (!plg) 
    {
        PERR ("Can't find database provider \"%s\" for database \"%s\"", 
               provider, dbname);
        return NULL;
    }

    if (!plg->connection_new) return NULL;

    dbc = (plg->connection_new) (dbname, username, authentication_token);
    
    if (!dbc) return NULL;
    dbc->provider = plg;
    return dbc;
}

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

void 
dui_connection_free (DuiDBConnection *conn)
{
    DuiDBPlugin *plg;
    if (!conn) return;

    plg = conn->provider;
    if (!plg) return;

    
    if (plg->connection_free)
    {
        (plg->connection_free) (conn);
    }
}

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

int 
dui_connection_catch_error (DuiDBConnection *conn, char ** ret_str)
{
    return 0;
}
 
/* ========================================================= */

struct timespec
dui_connection_get_now (DuiDBConnection *conn)
{
    DuiDBPlugin *plg;
    struct timespec ts = {0,-1};
    if (!conn) return ts;

    plg = conn->provider;
    if (!plg) return ts;
    if (!plg->get_now) return ts;

    ts = (plg->get_now) (conn);
    return ts;
}

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

void
dui_connection_lock (DuiDBConnection *conn, const char * tablename)
{
    DuiDBPlugin *plg;

    if (!conn) return;
    plg = conn->provider;
    if (!plg) return;
    if (!plg->lock) return;

    (plg->lock) (conn, tablename);
}

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

void
dui_connection_unlock (DuiDBConnection *conn, const char * tablename)
{
    DuiDBPlugin *plg;
    if (!conn) return;

    plg = conn->provider;
    if (!plg) return;
    if (!plg->unlock) return;

    (plg->unlock) (conn, tablename);
}

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

DuiDBRecordSet * 
dui_connection_exec (DuiDBConnection *conn, const char * buff)
{
    DuiDBRecordSet *rs = NULL;
    DuiDBPlugin *plg;
    
    if (!conn) return NULL;

    plg = conn->provider;
    if (!plg) return NULL;
    
    if (plg->connection_exec)
    {
        rs = (plg->connection_exec) (conn, buff);
    }
    if (!rs) return NULL;
    rs->provider = plg;

    return rs;
}

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

DuiDBRecordSet * 
dui_connection_tables (DuiDBConnection *conn)
{
    DuiDBRecordSet *rs = NULL;
    DuiDBPlugin *plg;
    
    if (!conn) return NULL;

    plg = conn->provider;
    if (!plg) return NULL;
    
    if (plg->connection_tables)
    {
        rs = (plg->connection_tables) (conn);
    }
    if (!rs) return NULL;
    rs->provider = plg;

    return rs;
}

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

DuiDBRecordSet * 
dui_connection_table_columns (DuiDBConnection *conn, const char * tablename)
{
    DuiDBRecordSet *rs = NULL;
    DuiDBPlugin *plg;
    
    if (!conn) return NULL;

    plg = conn->provider;
    if (!plg) return NULL;
    
    if (plg->connection_table_columns)
    {
        rs = (plg->connection_table_columns) (conn, tablename);
    }
    if (!rs) return NULL;
    rs->provider = plg;

    return rs;
}

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

void 
dui_recordset_free (DuiDBRecordSet *rs)
{
    DuiDBPlugin *plg;
    
    if (!rs) return;

    plg = rs->provider;
    if (!plg) return;
    
    if (plg->recordset_free)
    {
        (plg->recordset_free) (rs);
    }
}

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

int 
dui_recordset_rewind (DuiDBRecordSet *rs)
{
    DuiDBPlugin *plg;
    
    if (!rs) return 0;

    plg = rs->provider;
    if (!plg) return 0;
    
    if (plg->recordset_rewind)
    {
        return (plg->recordset_rewind) (rs);
    }
    return 0;
}

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

int 
dui_recordset_fetch_row (DuiDBRecordSet *rs)
{
    DuiDBPlugin *plg;
    
    if (!rs) return 0;

    plg = rs->provider;
    if (!plg) return 0;
    
    if (plg->recordset_fetch_row)
    {
        return (plg->recordset_fetch_row) (rs);
    }
    return 0;
}

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

const char * 
dui_recordset_get_value (DuiDBRecordSet *rs, const char * fieldname)
{
    DuiDBPlugin *plg;
    
    if (!rs) return NULL;

    plg = rs->provider;
    if (!plg) return NULL;
    
    if (plg->recordset_get_value)
    {
        return (plg->recordset_get_value) (rs, fieldname);
    }
    return NULL;
}

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

int 
dui_recordset_catch_error (DuiDBRecordSet *rs, char ** ret_str)
{
    DuiDBPlugin *plg;

    if (!rs) return 0;

    plg = rs->provider;
    if (!plg) return 0;

    if (plg->recordset_get_error)
    {
        return (plg->recordset_get_error) (rs, ret_str);
    }
    return 0;
}

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

---