Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » src » modules » extra

m_sqlv2.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *          the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef INSPIRCD_SQLAPI_2
#define INSPIRCD_SQLAPI_2

#include <string>
#include <deque>
#include <map>
#include "modules.h"

#define SQLREQID "SQLv2 Request"
#define SQLRESID "SQLv2 Result"
#define SQLSUCCESS "You shouldn't be reading this (success)"

enum SQLerrorNum { SQL_NO_ERROR, SQL_BAD_DBID, SQL_BAD_CONN, SQL_QSEND_FAIL, SQL_QREPLY_FAIL };

typedef std::deque<std::string> ParamL;

class SQLexception : public ModuleException
{
 public:
        SQLexception(const std::string &reason) : ModuleException(reason)
        {
        }

        SQLexception() : ModuleException("SQLv2: Undefined exception")
        {
        }
};

class SQLbadColName : public SQLexception
{
public:
        SQLbadColName() : SQLexception("SQLv2: Bad column name")
        {
        }
};

class SQLerror : public classbase
{
        SQLerrorNum id;
        std::string str;
public:
        SQLerror(SQLerrorNum i = SQL_NO_ERROR, const std::string &s = "")
        : id(i), str(s)
        {
        }

        SQLerrorNum Id()
        {
                return id;
        }

        SQLerrorNum Id(SQLerrorNum i)
        {
                id = i;
                return id;
        }

        void Str(const std::string &s)
        {
                str = s;
        }

        const char* Str()
        {
                if(str.length())
                        return str.c_str();

                switch(id)
                {
                        case SQL_NO_ERROR:
                                return "No error";
                        case SQL_BAD_DBID:
                                return "Invalid database ID";
                        case SQL_BAD_CONN:
                                return "Invalid connection";
                        case SQL_QSEND_FAIL:
                                return "Sending query failed";
                        case SQL_QREPLY_FAIL:
                                return "Getting query result failed";
                        default:
                                return "Unknown error";
                }
        }
};

class SQLquery : public classbase
{
public:
        std::string q;
        ParamL p;

        SQLquery(const std::string &query)
        : q(query)
        {
        }

        SQLquery(const std::string &query, const ParamL &params)
        : q(query), p(params)
        {
        }

        template<typename T> SQLquery& operator,(const T &foo)
        {
                p.push_back(ConvToStr(foo));
                return *this;
        }

        template<typename T> SQLquery& operator%(const T &foo)
        {
                p.push_back(ConvToStr(foo));
                return *this;
        }
};

class SQLrequest : public Request
{
public:
        SQLquery query;
        std::string dbid;
        bool pri;
        unsigned long id;
        SQLerror error;

        SQLrequest(Module* s, Module* d, const std::string &databaseid, const SQLquery &q)
        : Request(s, d, SQLREQID), query(q), dbid(databaseid), pri(false), id(0)
        {
        }

        void Priority(bool p = true)
        {
                pri = p;
        }

        void SetSource(Module* mod)
        {
                source = mod;
        }
};

class SQLfield
{
public:
        std::string d;

        bool null;

        SQLfield(const std::string &data = "", bool n = false)
        : d(data), null(n)
        {

        }
};

typedef std::vector<SQLfield> SQLfieldList;
typedef std::map<std::string, SQLfield> SQLfieldMap;

class SQLresult : public Request
{
public:
        std::string query;
        std::string dbid;
        SQLerror error;
        unsigned long id;

        SQLresult(Module* s, Module* d, unsigned long i)
        : Request(s, d, SQLRESID), id(i)
        {
        }

        virtual int Rows() = 0;

        virtual int Cols() = 0;

        virtual std::string ColName(int column) = 0;

        virtual int ColNum(const std::string &column) = 0;

        virtual SQLfield GetValue(int row, int column) = 0;

        virtual SQLfieldList& GetRow() = 0;

        virtual SQLfieldMap& GetRowMap() = 0;

        virtual SQLfieldList* GetRowPtr() = 0;

        virtual SQLfieldMap* GetRowMapPtr() = 0;

        virtual void Free(SQLfieldMap* fm) = 0;

        virtual void Free(SQLfieldList* fl) = 0;
};


class SQLhost
{
 public:
        std::string             id;             /* Database handle id */
        std::string             host;   /* Database server hostname */
        std::string             ip;             /* resolved IP, needed for at least pgsql.so */
        unsigned int    port;   /* Database server port */
        std::string             name;   /* Database name */
        std::string             user;   /* Database username */
        std::string             pass;   /* Database password */
        bool                    ssl;    /* If we should require SSL */

        SQLhost()
        : id(""), host(""), ip(""), port(0), name(""), user(""), pass(""), ssl(0)
        {
        }

        SQLhost(const std::string& i, const std::string& h, unsigned int p, const std::string& n, const std::string& u, const std::string& pa, bool s)
        : id(i), host(h), ip(""), port(p), name(n), user(u), pass(pa), ssl(s)
        {
        }

        std::string GetDSN();
};

bool operator== (const SQLhost& l, const SQLhost& r)
{
        return (l.id == r.id && l.host == r.host && l.port == r.port && l.name == r.name && l.user == r.user && l.pass == r.pass && l.ssl == r.ssl);
}
bool operator!= (const SQLhost& l, const SQLhost& r)
{
        return (l.id != r.id || l.host != r.host || l.port != r.port || l.name != r.name || l.user != r.user || l.pass != r.pass || l.ssl != r.ssl);
}


class QueryQueue : public classbase
{
private:
        typedef std::deque<SQLrequest> ReqDeque;

        ReqDeque priority;      /* The priority queue */
        ReqDeque normal;        /* The 'normal' queue */
        enum { PRI, NOR, NON } which;   /* Which queue the currently active element is at the front of */

public:
        QueryQueue()
        : which(NON)
        {
        }

        void push(const SQLrequest &q)
        {
                if(q.pri)
                        priority.push_back(q);
                else
                        normal.push_back(q);
        }

        void pop()
        {
                if((which == PRI) && priority.size())
                {
                        priority.pop_front();
                }
                else if((which == NOR) && normal.size())
                {
                        normal.pop_front();
                }

                /* Reset this */
                which = NON;

                /* Silently do nothing if there was no element to pop() */
        }

        SQLrequest& front()
        {
                switch(which)
                {
                        case PRI:
                                return priority.front();
                        case NOR:
                                return normal.front();
                        default:
                                if(priority.size())
                                {
                                        which = PRI;
                                        return priority.front();
                                }

                                if(normal.size())
                                {
                                        which = NOR;
                                        return normal.front();
                                }

                                /* This will probably result in a segfault,
                                 * but the caller should have checked totalsize()
                                 * first so..meh - moron :p
                                 */

                                return priority.front();
                }
        }

        std::pair<int, int> size()
        {
                return std::make_pair(priority.size(), normal.size());
        }

        int totalsize()
        {
                return priority.size() + normal.size();
        }

        void PurgeModule(Module* mod)
        {
                DoPurgeModule(mod, priority);
                DoPurgeModule(mod, normal);
        }

private:
        void DoPurgeModule(Module* mod, ReqDeque& q)
        {
                for(ReqDeque::iterator iter = q.begin(); iter != q.end(); iter++)
                {
                        if(iter->GetSource() == mod)
                        {
                                if(iter->id == front().id)
                                {
                                        /* It's the currently active query.. :x */
                                        iter->SetSource(NULL);
                                }
                                else
                                {
                                        /* It hasn't been executed yet..just remove it */
                                        iter = q.erase(iter);
                                }
                        }
                }
        }
};


#endif