DBBase.h

Go to the documentation of this file.

/*
 * DBBase.h
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef __DBBase
#define __DBBase

#include <string>
#include <exception>
#include <list>
#include <vector>
#include <functional>

#include <HSEPData/DBTypes.h>
#include <HSEPData/ErrorCode.h>
#include <HSEP/Array.h>
#include <HSEP/Dictionary.h>
#include <HSEP/HSEPObject.h>
#include <iostream>

using namespace HSEP;
using namespace std;

namespace HSEPData {

    class DBResultSet; // forward declaration

    struct DBMetadataField {
        string aColumnName;
        DBType aColumnType;
        string aColumnTypeName;

        DBMetadataField() {
            aColumnType = DBT_Null;
        }

        DBMetadataField(DBMetadataField& pReference) {
            aColumnName     = pReference.aColumnName;
            aColumnType     = pReference.aColumnType;
            aColumnTypeName = pReference.aColumnTypeName;
        }
    };

    typedef Array<DBMetadataField> DBMetadata;

    class CycleBase {
    public:
        virtual ~CycleBase() {}
        virtual bool execute(DBResultSet* pResultSetPtr,bool pIsFirst,bool pIsLast) = 0;
    }; // CycleBase class

    class NullCycle : public CycleBase {
    public:

        virtual ~NullCycle() {}
        virtual bool execute(DBResultSet* pResultSetPtr,bool pIsFirst,bool pIsLast) {
            return true;
        }

    }; // NullCycle

    class QueryUniqueCycle : public CycleBase {
        StringDictionary aResults;
    public:
        virtual ~QueryUniqueCycle() {
        }
        virtual bool execute(DBResultSet* pResultSetPtr,bool pIsFirst,bool pIsLast);

        string& getValueRef(string& pKeyRef);

        StringDictionary& getValuesRef() {
            return aResults;
        }

    }; // QueryUniqueCycle

    typedef function<bool (DBResultSet* pResultSetPtr, bool pIsFirst, bool pIsLast)> ExecuteFunctionType;

    class DBResultSet : public HSEPObject {
    public:
        DBResultSet() : HSEPObject("DBResultSet") {}
        virtual ~DBResultSet() {}

        virtual int forEach(CycleBase& pCycleRef) = 0;

        virtual int forEach(ExecuteFunctionType pFunction) = 0;

        virtual string getString(string& pNameRef) = 0;

        virtual string getString(const char* pName) {
            string vName(pName);
            return getString(vName);
        }

        virtual string getString(int     pPosition) = 0;

        virtual size_t size() = 0;

        virtual bool isLast() = 0;

        virtual void getMetadata    (DBMetadata& pMetadataRef) = 0;

        virtual void destroyMetadata(DBMetadata& pMetadataRef);

    }; // DBResultSet class

    class DBStatement : public HSEPObject {
    protected:
        virtual DBResultSet* executeQueryPtr() = 0;
        virtual DBResultSet* executeQueryPtr(DBParameters& ParametersRef) = 0;
    public:
        DBStatement() : HSEPObject("DBStatement") {
        }
        virtual ~DBStatement() {
        }

        int cycleQuery(CycleBase& pCycleRef);

        int cycleQuery(ExecuteFunctionType pFunction);

        int cycleQuery(DBParameters& pParametersRef, ExecuteFunctionType pFunction);

        int cycleQuery(DBParameters& pParametersRef, CycleBase& pCycleRef);

    }; // DBStatement class


    class DBEnvironment : public HSEPObject {
    protected:
        bool   aSynchronizes; /*< Defines if the session will synchronize its operations */
        string aSyncTo;       /*< The address where the destination database engine will wait for the data */
        string aSyncPath;     /*< The path where files with the "to synchronize operations will wait for its turn */
        int    aID;           /*< Internal ID to be used in a session pool */
    public:
        DBEnvironment() : HSEPObject("DBEnvironment") {
            // Normally won't synchronize or will work as part of a database pool.
            aSynchronizes = false;
            aID           = 0;
        }
        virtual ~DBEnvironment() {}

        virtual ErrorCode    connect(string& pConnectionStringRef,string& pUserRef, string& pPasswordRef) = 0;

        virtual DBStatement* createStatementPtr(string& pQueryRef) = 0;

        virtual ErrorCode    setSchema(string& pNewSchemaRef) = 0;

        bool synchronizes() const {
            return aSynchronizes;
        }

        void addSyncTo(string pSyncTo) {
            aSynchronizes = true;
            aSyncTo       = pSyncTo;
        }

        string& syncToRef() {
            return aSyncTo;
        }

        void addSyncPath(string pSyncPath) {
            aSyncPath = pSyncPath;
        }

        string& syncPathRef() {
            return aSyncPath;
        }

        void addID(int pNewID) {
            aID = pNewID;
        }

        int id() {
            return aID;
        }

    }; // DBEnvironment class

    typedef string (*WhatMethod)(string& pMessageRef, exception* pExceptPtr);

    class DBException : public exception {
        string aMessage;
    public:
        DBException(exception& pExceptionRef, WhatMethod pMethod);

        DBException(exception& pExceptionRef);
        virtual ~DBException() throw() { }
        virtual const char* what() const throw();

    }; // DBException class

} // HSEPData namespace

#endif // __DBBase