db.h

Go to the documentation of this file.

/*                                                              
 * A database abstraction layer for C++ and ACE framework
 * 
 * (C) 2006-2007 Thralling Penguin LLC. All rights reserved.
 *
 * 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                                                                 
 */
#ifndef _DB_H
#define _DB_H

#include <fstream>
#include <iomanip>
#include <strstream>
#include "ace/Log_Msg.h"
#include "ace/DLL.h"

namespace DB
{
    class ResultSet
    {
    public:
        virtual ~ResultSet(void) {};

        virtual bool close(void) = 0;
        virtual bool next(void) = 0;

        virtual unsigned int findColumn(const char *field) const = 0;
        virtual unsigned long recordCount(void) const = 0;

        virtual const char *getString(const int idx) const = 0;
        virtual const int getInteger(const int idx) const = 0;
        virtual const bool getBool(const int idx) const = 0;
        virtual const time_t getUnixTime(const int idx) const = 0;
        virtual const double getDouble(const int idx) const = 0;
        virtual const float getFloat(const int idx) const = 0;
        virtual const long getLong(const int idx) const = 0;
        virtual const short getShort(const int idx) const = 0;
    };

    class Connection
    {
    public:
        virtual ~Connection(void) {};

        virtual bool open(const char *database, const char *host, const int port, const char *user, const char *pass) = 0;

        virtual bool close(void) = 0;

        virtual bool isConnected(void) = 0;

        virtual bool execute(const char *sql) = 0;

        virtual ResultSet *executeQuery(const char *sql) = 0;

        virtual char *escape(const char *) = 0;

        virtual const char *unixtimeToSql(const time_t) = 0;

        virtual const unsigned long insertId(void) = 0;

        virtual bool beginTrans(void) = 0;

        virtual bool commitTrans(void) = 0;

        virtual bool rollbackTrans(void) = 0;

        enum TRANS_MODE {
            READ_UNCOMMITTED, 
            READ_COMMITTED, 
            REPEATABLE_READ, 
            SERIALIZABLE 
        };
        virtual bool setTransactionMode(const enum TRANS_MODE mode) = 0;

        virtual unsigned int errorno(void) const = 0;

        virtual const char *errormsg(void) const = 0;

        virtual const char *version(void) const = 0;

        typedef Connection* (*Connection_Creator) (void);

        static Connection *
        factory(const char *db_dll_name)
        {
            ACE_DLL dll;

            int ret = dll.open(ACE_TEXT(db_dll_name),
                        ACE_DEFAULT_SHLIB_MODE,
                        0);
            if (ret != 0) {
                ACE_ERROR_RETURN((LM_ERROR, "%p", "dll.open"), 0);
            }
            Connection_Creator cc;
            void *void_ptr = dll.symbol(ACE_TEXT("create_connection"));
            ptrdiff_t tmp = reinterpret_cast<ptrdiff_t>(void_ptr);
            cc = reinterpret_cast<Connection_Creator>(tmp);
            if (cc == NULL) {
                ACE_ERROR_RETURN((LM_ERROR, "%p", "dll.symbol"), 0);
            }
            return (cc());
        }
    };

    class Query
    {
    private:
        Connection &conn_;      
        std::ostrstream sql_;   
    public:
        Query(Connection &conn) : conn_(conn) {}
        ~Query() { sql_.freeze(false); }

        ACE_INLINE Query& operator<<(const char *sql)
        {
            sql_ << sql;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const int val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const long val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const double val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const float val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const short val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const unsigned char *sql)
        {
            sql_ << sql;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const unsigned int val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const unsigned long val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE Query& operator<<(const unsigned short val)
        {
            sql_ << val;
            return (*this);
        }

        ACE_INLINE const char *str(void)
        {
            sql_ << std::ends;
            return (sql_.str());
        }

        // Friend functions for stream manipulators
        friend Query &unixtime_impl(Query &Out, const time_t ut);
        friend Query &qstr_impl(Query &Out, const char *str);
    };

    ACE_INLINE Query &unixtime_impl(Query &Out, const time_t ut)
    {
        const char *buf = Out.conn_.unixtimeToSql(ut);
        Out << buf;
        delete [] buf;
        return (Out);
    }

    ACE_INLINE Query &qstr_impl(Query &Out, const char *str)
    {
        const char *buf = Out.conn_.escape(str);
        Out << buf;
        delete [] buf;
        return (Out);
    }

    class unixtime {
        time_t t;
    public:
        unixtime(time_t ti) : t(ti) {}
        friend Query& operator<<(Query& Out, const unixtime& ref) {
            return unixtime_impl(Out, ref.t);
        }
    };


    class qstr {
        std::string s;
    public:
        qstr(const char *str) : s(str) {}
        friend Query& operator<<(Query& Out, const qstr& q) {
                return qstr_impl(Out, q.s.c_str());
        }
    };
}

#endif

---