/var/home/joerg/c/CDB/include/CDB.h

Go to the documentation of this file.

#ifndef _CDB_H
#define _CDB_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#include "sysdep.h"
#endif

#include <cdbstring.h>

#include <iostream>
#include <string>
#include <list>

#define CDB_VERSION_MAJOR 0

#define CDB_VERSION_MINOR 2

#define CDB_VERSION_RELEASE 0

#define V_TO_NUM(maj, min, rel) (maj * 10000 + min * 100 + rel)

#define CDB_VERSION_NUMBER V_TO_NUM(CDB_VERSION_MAJOR, CDB_VERSION_MINOR, CDB_VERSION_RELEASE)

#define CDB_DEFAULT_RUNTIME_VERSION_CHECK \
        { \
                int ma, mi, re; \
                get_cdb_runtime_version(&ma, &mi, &re); \
                if ( CDB_VERSION_NUMBER != V_TO_NUM(ma, mi, re) ) { \
                        std::cerr << "WARNING: CDB-Api version difference, compiled: "; \
                        std::cerr << CDB_VERSION_MAJOR << "." << CDB_VERSION_MINOR; \
                        std::cerr << "." << CDB_VERSION_RELEASE << std::endl; \
                        std::cerr << "                                      runtime: "; \
                        std::cerr << ma << "." << mi << "." << re << std::endl; \
                } \
        }

#if defined(HAVE_UINT64_T) && defined(HAVE_INT64_T)
#ifdef HAVE_STDINT_H
#include<stdint.h>
#endif

#ifdef HAVE_INTTYPES_H
#include<inttypes.h>
#endif
#else
typedef unsigned long long int uint64_t;
typedef long long int int64_t;
#endif

#define CDB_OPT_DONT_CLOSE_HANDLE 1

#include <time.h>
#include "cdb_driver_symbol.h"

typedef enum { E_NULL_DUMMY } CDB_NULL_T;
#define CDB_NULL (CDB_NULL_T(E_NULL_DUMMY))

extern "C" void get_cdb_runtime_version(int *ma, int *mi, int *re);

typedef class CDBdatetime {
public:
        CDBdatetime() {
                year = month = day = hour = minute = second = msecond = 0;
        }
        CDBdatetime(const CDBdatetime &c) {
                operator=(c);
        }
        CDBdatetime(const struct tm &t) {
                operator=(t);
        }
        CDBdatetime(time_t t) {
                operator=(t);
        }
        inline CDBdatetime &operator=(const CDBdatetime &c) {
                year = c.year;
                month = c.month;
                day = c.day;
                hour = c.hour;
                minute = c.minute;
                second = c.second;
                msecond = c.msecond;
                return *this;
        }
        inline CDBdatetime &operator=(const struct tm &t) {
                year = t.tm_year+1900;
                month = t.tm_mon+1;
                day = t.tm_mday;
                hour = t.tm_hour;
                minute = t.tm_min;
                second = t.tm_sec;
                msecond = 0;
                return *this;
        }
        inline CDBdatetime &operator=(time_t t) {
                struct tm *bdt = localtime(&t);
                return operator=(*bdt);
        }
        int operator==(const CDBdatetime &c) {
                return (year == c.year && month == c.month && day == c.day && hour == c.hour && minute == c.minute && second == c.second &&msecond == c.msecond);
        }
        
        static CDBdatetime now() {
                time_t _time = time(NULL);
                struct tm *bdt = localtime(&_time);
                return CDBdatetime(*bdt);
        }

        inline time_t mktime(struct tm *pb = NULL) {
                struct tm _pb;
                if ( pb == NULL ) {
                        pb = &_pb;
                }
                pb->tm_year = year-1900;
                pb->tm_mon = month-1;
                pb->tm_mday = day;
                pb->tm_hour = hour;
                pb->tm_min = minute;
                pb->tm_sec = second;
                return ::mktime( pb );
        }

        int year, month, day, hour, minute, second, msecond;
} Tdatetime;

typedef class CDBdate{
public:
        CDBdate() {
                year = month = day = 0;
        }
        CDBdate(const CDBdate &c) {
                operator=(c);
        }
        CDBdate(const struct tm &t) {
                operator=(t);
        }
        CDBdate &operator=(const CDBdate &c) {
                year = c.year;
                month = c.month;
                day = c.day;
                return *this;
        }
        CDBdate&operator=(const struct tm &t) {
                year = t.tm_year;
                month = t.tm_mon;
                day = t.tm_mday;
                return *this;
        }
        int operator==(const CDBdate &c) {
                return (year == c.year && month == c.month && day == c.day);
        }
        
        static CDBdate now() {
                time_t _time;
                struct tm *bdt = localtime(&_time);
                return CDBdate(*bdt);
        }
        int year, month, day;
} Tdate;

typedef class CDBtime {
public:
        CDBtime() {
                hour = minute = second = msecond = 0;
        }
        CDBtime(const CDBtime &c) {
                operator=(c);
        }
        CDBtime(const struct tm &t) {
                operator=(t);
        }
        CDBtime &operator=(const CDBtime &c) {
                hour = c.hour;
                minute = c.minute;
                second = c.second;
                msecond = c.msecond;
                return *this;
        }
        CDBtime &operator=(const struct tm &t) {
                hour = t.tm_hour;
                minute = t.tm_min;
                second = t.tm_sec;
                msecond = 0;
                return *this;
        }
        int operator==(const CDBtime &c) {
                return (hour == c.hour && minute == c.minute && second == c.second &&msecond == c.msecond);
        }
        
        static CDBtime now() {
                time_t _time;
                struct tm *bdt = localtime(&_time);
                return CDBtime(*bdt);
        }
        int hour, minute, second, msecond;
} Ttime;

class CDB {
public:
        CDB();
        CDB(CDB& c);
        CDB(const CDBstring &driver_name);
        virtual ~CDB();

        int load(const CDBstring &driver_name);

        int load_static(driver_func_t func);
        
        CDBstring get_driver_name();
        
        int last_error();
        
        CDBstring error_msg();

        inline Tptr connect(const CDBstring& conn_str) {
                if ( !handle ) return NULL;
                return (*syms->connect)(conn_str.c_str());
        }
        inline int getcdbopts() {
                if ( !handle ) return -1;
                return (*syms->getcdbopts)();
        }
        inline void setopt(Tptr conn, int opt) {
                if ( !handle ) return;
                (*syms->setopt)(conn, opt);
        }
        inline int status(Tptr conn) {
                if ( !handle ) return -1;
                return (*syms->status)(conn);
        }
        inline void disconnect(Tptr conn) {
                if ( !handle ) return;
                (*syms->disconnect)(conn);
        }
        inline CDBstring error(Tptr conn) {
                if ( !handle ) return "";
                return (*syms->error)(conn);
        }
        inline int read_integer(Tptr res, int row, int col, int *p) {
                if ( !handle ) return 0;
                return (*syms->read_integer)(res, row, col, p);
        }
        inline int read_long_integer(Tptr res, int row, int col, int64_t *p) {
                if ( !handle ) return 0;
                return (*syms->read_long_integer)(res, row, col, p);
        }
        inline int read_double(Tptr res, int row, int col, double *d_ptr) {
                if ( !handle ) return 0;
                return (*syms->read_double)(res, row, col, d_ptr);
        }
        inline CDBstring read_string(Tptr res, int row, int col) {
                if ( !handle ) return "";
                return (*syms->read_string)(res, row, col);
        }
        inline int read_isnull(Tptr res, int row, int col) {
                if ( !handle ) return 0;
                return (*syms->read_isnull)(res, row, col);
        }
        inline int read_date(Tptr res, int row, int col, int *year, int *mon, int *day) {
                if ( !handle ) return 0;
                return (*syms->read_date)(res, row, col, year, mon, day);
        }
        inline int read_time(Tptr res, int row, int col, int *hour, int *min, int *sec) {
                if ( !handle ) return 0;
                return (*syms->read_time)(res, row, col, hour, min, sec);
        }
        inline int read_datetime(Tptr res, int row, int col, int *year, int *mon, int *day, int *hour, int *min, int *sec) {
                if ( !handle ) return 0;
                return (*syms->read_datetime)(res, row, col, year, mon, day, hour, min, sec);
        }
        inline int count_rows(Tptr res) {
                if ( !handle ) return -1;
                return (*syms->count_rows)(res);
        }
        inline int count_cols(Tptr res) {
                if ( !handle ) return -1;
                return (*syms->count_cols)(res);
        }
        inline int open_query(Tptr db, Tptr* res, const CDBstring& str_sql) {
                if ( !handle ) return -1;
                return (*syms->open_query)(db,  res, str_sql.c_str());
        }
        inline int exec_query(Tptr db, Tptr* res, const CDBstring& str_sql) {
                if ( !handle ) return -1;
                return (*syms->exec_query)(db,  res, str_sql.c_str());
        }
        inline void close_query(Tptr res) {
                if ( !handle ) return;
                (*syms->close_query)(res);
                return;
        }
        inline CDBstring sqlerr(Tptr res) {
                if ( !handle ) return "";
                return (*syms->sqlerr)(res);
        }
        inline int search_col(Tptr res, const CDBstring& fn) {
                if ( !handle ) return -1;
                return (*syms->search_col)(res, fn.c_str());
        }
        inline CDBstring version()
        {
                if ( !handle ) return "no version";
                return syms->version;
        }

/*      inline int get_next_bind_var(Tptr res, char *name, size_t name_size, tvartype *type, size_t *len) {
                if ( !handle ) return -1;
                return (*syms->get_next_bind_var)(res, name, name_size, type, len);
        }*/

        inline int bv_set_unfilled(Tptr res) {
                if ( !handle ) return -1;
                return (*syms->bv_set_unfilled)(res);
        }

        inline int bv_get_count(Tptr res) {
                if ( !handle ) return -1;
                return (*syms->bv_get_count)(res);
        }

        inline char bv_get_filled(Tptr res, int pos) {
                if ( !handle ) return (unsigned char)-1;
                return (*syms->bv_get_filled)(res, pos);
        }

        inline char bv_finished(Tptr res) {
                if ( !handle ) return (unsigned char)-1;
                return (*syms->bv_finished)(res);
        }
        
        inline int bv_get_pos_by_name(Tptr res, const CDBstring& pos, int *res_vec, int *res_vec_size) {
                if ( !handle ) return -1;
                return (*syms->bv_get_pos_by_name)(res, pos.c_str(), res_vec, res_vec_size);
        }

        inline int bv_bind_by_pos(Tptr res, int pos, tvartype type, Tptr data) {
                if ( !handle ) return -1;
                return (*syms->bv_bind_by_pos)(res, pos, type, data);
        }

        inline int process(Tptr res) {
                if ( !handle ) return -1;
                return (*syms->process)(res);
        }

        inline driver_func_t get_static_func() {
                return mstatic_func;
        }
private:
        CDBstring mdriver_name, merror_msg;
        void *handle;
        int mlast_error;
        driver_func_t mstatic_func;

        driver_symbols_t *syms;
};

class CDBconnection {
public:
        CDBconnection(CDBconnection& c);
        
        CDBconnection(CDB* tDB);

        CDBconnection(CDB* tDB, const CDBstring& conn_str);

        virtual ~CDBconnection();

        Tptr getConn();

        CDB *getDB();

        int Connect(const CDBstring& conn_str);

        void Disconnect();

        int Status();

        CDBstring Error();

        void setopt(int opt);

private:
        Tptr mConn;
        CDB *mDB;
};

/* Forward declaration */
class CDBquery;

class CDBfield {
public:
        CDBquery *mQ;
        int row,col;

        CDBfield();
        CDBfield(const CDBfield &c);

        const char* string();

        CDBstring ustr();

        Tdate date();
        Ttime time();
        Tdatetime datetime();
        int isnull();
        int integer();
        int64_t long_integer();
        double floating();

        CDBfield& operator=(const CDBfield& c);
};

class CDBrow {
public:
        CDBquery *mQ;
        int row;

        CDBrow();
        CDBrow(const CDBrow& c);
        CDBrow(CDBquery *Q, int trow = 0);

        CDBrow& operator=(const CDBrow& c);
        CDBfield operator[](int i);
        CDBfield operator[](const CDBstring& fn);
};

class CDBquery {
public:
        CDBconnection *mDB;
        Tptr mres;

        CDBquery();
        CDBquery(CDBconnection* c);
        ~CDBquery();

        int open(const CDBstring& str_sql);

        int exec(const CDBstring& str_sql);

        int process();

        int bind(int pos, int data);
        int bind(int pos, int64_t data);
        int bind(int pos, float data);
        int bind(int pos, double data);
        int bind(int pos, const CDBstring& data);
        int bind(int pos, const Tdatetime &data);
        int bind(int pos, const Tdate &data);
        int bind(int pos, const Ttime &data);

        int bind(const CDBstring &name, int data);
        int bind(const CDBstring &name, int16_t data);
        int bind(const CDBstring &name, float data);
        int bind(const CDBstring &name, double data);
        int bind(const CDBstring &name, const CDBstring& data);
        int bind(const CDBstring &name, const Tdatetime &data);
        int bind(const CDBstring &name, const Tdate &data);
        int bind(const CDBstring &name, const Ttime &data);

        int bind_count();
        int bind_reset();
        bool bind_filled(int pos);
        bool bind_finished();
        int bind_get_pos_by_name(const CDBstring& name, int *res, int *res_size);
        int bind_to_next();

        void close();

        CDBstring sqlerr();

        int rows();
        int cols();

        CDBrow operator[](int i);

        CDBquery &operator<<(int i);

        CDBquery &operator<<(int64_t i);

        CDBquery &operator<<(float f);

        CDBquery &operator<<(double f);

        CDBquery &operator<<(const CDBstring& s);

        CDBquery &operator<<(const Tdate &d);

        CDBquery &operator<<(const Ttime &t);

        CDBquery &operator<<(const Tdatetime &dt);

        CDBquery &operator<<(const CDB_NULL_T &n);

        CDBquery &operator<<(CDBrow r);

        char *getBuffer(int size);
private:
        char opened;
        std::list<char*> mBuffVec;
};

class CEXquery {
public:
        CEXquery() {
                mcaller = NULL;
        }
        CEXquery(CDBquery *c) {
                mcaller  = c;
        }
        CDBquery *caller() {
                return mcaller;
        }
private:
        CDBquery *mcaller;
};

#endif

---