dbixx.h

#ifndef _DBIXX_H_
#define _DBIXX_H_

#include <dbi/dbi.h>
#include <stdexcept>
#include <ctime>
#include <map>
#include <cstring>

namespace dbixx {

class dbixx_error : public std::runtime_error
{
public:
        char const *query() const { return query_.c_str(); };
        dbixx_error(std::string const &error,std::string const &q=std::string()) :
                std::runtime_error(error),
                query_()
        {
        }
        ~dbixx_error() throw()
        {
        }
private:
        std::string query_;
};


class row 
{
        // non copyable
        row(row const &);
        row const &operator=(row const &);
public:
        row() { current=0; owner=false; res=NULL; };
        ~row();
        dbi_result get_dbi_result() { return res; };
        bool isempty();
        bool isnull(int inx);
        bool isnull(std::string const &id);
        bool fetch(int pos,short &value);
        bool fetch(int pos,unsigned short &value);
        bool fetch(int pos,int &value);
        bool fetch(int pos,unsigned &value);
        bool fetch(int pos,long  &value);
        bool fetch(int pos,unsigned long &value);
        bool fetch(int pos,long long &value);
        bool fetch(int pos,unsigned long long &value);
        bool fetch(int pos,float &value);
        bool fetch(int pos,double &value);
        bool fetch(int pos,long double &value);
        bool fetch(int pos,std::string &value);
        bool fetch(int pos,std::tm &value);
        bool operator[](std::string const & id) { return isnull(id); };
        bool operator[](int ind) { return isnull(ind); };
        template<typename T>
        row &operator>>(T &v) { current++; fetch(current,v); return *this; };
        unsigned int cols();

        template<typename T>
        T get(int col)
        {
                T v;
                if(!fetch(col,v)) {
                        throw dbixx_error("Null value fetch");
                }
                return v;
        }
private:
        template<typename T>
        bool ufetch(int post,T &v);
        template<typename T>
        bool sfetch(int post,T &v);

        dbi_result res;
        bool owner;
        int current;
        void check_set();

        void set(dbi_result &r);
        void reset();
        void assign(dbi_result &r);
        bool next();

        friend class session;
        friend class result;
};

class result
{
        result(result const &);
        result const &operator=(result const &);
public:
        dbi_result get_dbi_result() { return res; };
        result() : res(NULL) {};
        ~result();
        unsigned long long rows();
        unsigned int cols();
        bool next(row &r);
private:
        dbi_result res;
        void assign(dbi_result r);
        friend class session;
};


struct null {};
struct exec {};

template<typename T>
std::pair<T,bool> use(T ref, bool isnull=false)
{
        return std::pair<T,bool>(ref,isnull);
}

class session {
        // non copyable
        session(session const &);
        session const &operator=(session const &);
public:
        session();
        session(std::string const &backend_or_connection_string);
        ~session();
        void connect(std::string const &connection_string);
        void driver(std::string const &backend);
        std::string driver();
        void param(std::string const &par,std::string const &val);
        void param(std::string const &par,int);
        void connect();
        void reconnect();
        void close();
        
        dbi_conn get_dbi_conn() { return conn; };


        void query(std::string const &query);
        unsigned long long rowid(char const *seq=NULL);

        unsigned long long affected() { return affected_rows ;};

        void bind(std::string const &s,bool isnull=false);
        void bind(int v,bool isnull=false);
        void bind(unsigned v,bool isnull=false);
        void bind(long v,bool isnull=false);
        void bind(unsigned long v,bool isnull=false);
        void bind(long long int v,bool isnull=false);
        void bind(unsigned long long v,bool isnull=false);
        void bind(double v,bool isnull=false);
        void bind(long double v,bool isnull=false);
        void bind(std::tm const &time,bool isnull=false);
        void bind(null const &,bool isnull=true);

        void exec();

        void fetch(result &res);

        bool single(row &r);

        session &operator<<(std::string const &q) { query(q); return *this; };
        session &operator,(std::string const &v) { bind(v,false); return *this; };
        session &operator,(std::pair<std::string,bool> p) { bind(p.first,p.second); return *this; }
        session &operator,(char const *v) { bind(v,false); return *this; };
        session &operator,(std::tm const &v) { bind(v,false); return *this; };
        
        void operator,(dbixx::exec const &e) { exec(); };
        void operator,(result &res) { fetch(res); };
        bool operator,(row &r) { return single(r); };

        template<typename T>
        session &operator,(T v) { bind(v,false); return *this; };

        template<typename T>
        session &operator,(std::pair<T,bool> p) { bind(p.first,p.second); return *this; }
private:
        template<typename T>
        void do_bind(T v,bool);

        std::string query_in;
        unsigned pos_read;
        std::string escaped_query;
        unsigned pos_write;
        bool ready_for_input;
        bool complete;
        unsigned long long affected_rows;


        std::string backend;
        dbi_conn conn;
        std::map<std::string,std::string> string_params; 
        std::map<std::string,int> numeric_params; 
        void check_open();
        void error();
        void escape();
        void check_input();

};

class transaction {
        // non copyable
        transaction(transaction const &);
        transaction const &operator=(transaction const &);
public:
        transaction(session &s) : sql(s) { commited=false; begin(); }
        void commit();
        void rollback();
        ~transaction();
private:
        session &sql;
        bool commited;
        void begin();
};

}

#endif // _DBIXX_H_

---