QueryRunner.cpp

Go to the documentation of this file.

/*
 * QueryRunner.cpp
 *
 *  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/>.
 */

#include <HSEPData/QueryRunner.h>
#include <HSEPData/DBStatementCatalog.h>
#include <HSEP/TimeTool.h>
#include <iostream>
#include <fstream>

using namespace std;

namespace HSEPData {

    ErrorCode QueryRunner::prepareStatement(
        DBStatement*& pStatement,
        string& pStatementName
    ) {
        ErrorCode vResult = EC::NotCatalogedError;

        if (nullptr == pStatement) {

            try {
                pStatement = aEnvironment->createStatementPtr(
                    DBStatementCatalog::aInstance->getStatementRef(pStatementName)
                );
                if (!pStatement) {
                    vResult = EC::NoStatementCreated;
                    setLastError(aEnvironment->lastErrorRef());
                }
                else {
                    vResult = EC::OK;
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }

        return vResult;

    } // QueryRunner::prepareStatement


    void QueryRunner::storeData(string& pDestination, string& pStatementName) {

        if (pStatementName.substr(0,5) == "SYNC-") {

            string& vSyncPath = aEnvironment->syncPathRef();
            string  vEpochStr;

            TimeTool::epoch(vEpochStr);

            vEpochStr += "-" + to_string(aEnvironment->id()) + "-" + pStatementName;
            string vSeparator = "";
            if (vSyncPath.back()!='/') {
                vSeparator = "/";
            }

            string vFileName = vSyncPath + vSeparator + vEpochStr;

            fstream vFile(vFileName.c_str(),ios::out);
            vFile.close();

            vFileName += "-flag";
            fstream vFlag(vFileName.c_str(),ios::out);
            vFlag.close();

        }

    } // QueryRunner::storeData

    void QueryRunner::storeData(string& pDestination, string& pStatementName, DBParameters& pParametersRef) {

        if (pStatementName.substr(0,5) == "SYNC-") {

            string& vSyncPath = aEnvironment->syncPathRef();
            string  vEpochStr;

            TimeTool::epoch(vEpochStr);

            vEpochStr += "-" + to_string(aEnvironment->id()) + "-" + pStatementName;
            string vSeparator = "";
            if (vSyncPath.back()!='/') {
                vSeparator = "/";
            }

            string vFileName = vSyncPath + vSeparator + vEpochStr;

            fstream vFile(vFileName.c_str(),ios::out);

            for (DBParameter vParameter : pParametersRef) {
                vFile << vParameter.first << "=" << vParameter.second << endl;
            }
            vFile.close();

            vFileName += "-flag";
            fstream vFlag(vFileName.c_str(),ios::out);
            vFlag.close();

        }

    } // QueryRunner::storeData

    QueryRunner::QueryRunner(
        string pDBType
    ) : HSEPObject("QueryRunner") {
        setInvalid();

        try {
            aDBType      = pDBType;
            aEnvironment = DB::aInstance->getEnvironmentPtr(pDBType);

            if (aEnvironment) {
                setValid();
            }

        } catch (DBException &e) {
            setLastError(e.what());
            cout << "Error " << lastErrorRef() << endl;

        }

        //cout << "QR constructor leave" << endl;

    } // QueryRunner constructor

    QueryRunner::~QueryRunner() {
        if (valid()) {
            DB::aInstance->releaseEnvironment(aDBType,aEnvironment);
        }
    } // QueryRunner destructor

    ErrorCode QueryRunner::execute(
           string        pStatementName,
           DBParameters& pParametersRef,
           CycleBase&    pCycleRunnerRef
       ) {
        ErrorCode vResult = EC::NotCatalogedError;

        if (valid()) {

            try {
                DBStatement* vStatement = nullptr;

                vResult = prepareStatement(vStatement,pStatementName);

                if (nullptr != vStatement) {

                    if (EC::OK == vResult) {
                        int vQty = vStatement->cycleQuery(pParametersRef,pCycleRunnerRef);

                        if (-1 == vQty) {
                            setLastError(vStatement->lastErrorRef());
                        }
                        else {
                            if (0 == vQty) {
                                setLastError("No data found");
                                vResult = EC::NoDataFound;
                            }
                            else {
                                vResult = EC::OK;
                            }
                            if (aEnvironment->synchronizes()) {
                                storeData(aEnvironment->syncToRef(),pStatementName,pParametersRef);
                            }
                        }
                        delete vStatement;
                    }
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }
        else {
            setLastError("Invalid Query Runner");
        }
        return vResult;

    } // QueryRunner::execute


    ErrorCode QueryRunner::execute(
           string        pStatementName,
           DBParameters& pParametersRef
       ) {
        ErrorCode vResult = EC::NotCatalogedError;
        NullCycle vCycle;

        if (valid()) {

            try {
                DBStatement* vStatement = nullptr;

                vResult = prepareStatement(vStatement,pStatementName);

                if (nullptr != vStatement) {
                    if (EC::OK == vResult) {
                        int vQty = vStatement->cycleQuery(pParametersRef,vCycle);

                        if (-1 == vQty) {
                            setLastError(vStatement->lastErrorRef());
                        }
                        else {
                            if (0 == vQty) {
                                vResult = EC::NoDataFound;
                                setLastError("No data found");
                            }
                            else {
                                vResult = EC::OK;
                            }
                            if (aEnvironment->synchronizes()) {
                                storeData(aEnvironment->syncToRef(),pStatementName,pParametersRef);
                            }
                        }
                        delete vStatement;
                    }
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }
        else {
            setLastError("Invalid Query Runner");
        }
        return vResult;

    } // QueryRunner::execute



    ErrorCode QueryRunner::execute(
           string                       pStatementName,
           CycleBase&                   pCycleRunnerRef
       ) {
        ErrorCode vResult = EC::NotCatalogedError;

        if (valid()) {

            try {
                DBStatement* vStatement = nullptr;
                vResult = prepareStatement(vStatement,pStatementName);

                if (nullptr != vStatement) {
                    if (EC::OK == vResult) {
                        if (-1 == vStatement->cycleQuery(pCycleRunnerRef)) {
                            setLastError(vStatement->lastErrorRef());
                        }
                        else {
                            vResult = EC::OK;
                            if (aEnvironment->synchronizes()) {
                                storeData(aEnvironment->syncToRef(),pStatementName);
                            }
                        }
                        delete vStatement;
                    }
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }
        else {
            setLastError("Invalid Query Runner");
        }
        return vResult;

    } // QueryRunner::execute


    ErrorCode QueryRunner::execute(
           string              pStatementName,
           DBParameters&       pParametersRef,
        ExecuteFunctionType pFunction
       ) {
        ErrorCode vResult = EC::NotCatalogedError;

        if (valid()) {

            try {
                DBStatement* vStatement = nullptr;

                vResult = prepareStatement(vStatement,pStatementName);

                if (nullptr != vStatement) {
                    if (EC::OK == vResult) {
                        int vQty = vStatement->cycleQuery(pParametersRef,pFunction);

                        if (-1 == vQty) {
                            setLastError(vStatement->lastErrorRef());
                        }
                        else {
                            if (0 == vQty) {
                                vResult = EC::NoDataFound;
                            }
                            else {
                                vResult = EC::OK;
                            }
                            if (aEnvironment->synchronizes()) {
                                storeData(aEnvironment->syncToRef(),pStatementName,pParametersRef);
                            }
                        }
                        delete vStatement;
                    }
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }
        else {
            setLastError("Invalid Query Runner");
        }
        return vResult;

    } // QueryRunner::execute

    ErrorCode QueryRunner::execute(
        string              pStatementName,
        ExecuteFunctionType pFunction
    ) {
        ErrorCode vResult = EC::NotCatalogedError;

        if (valid()) {

            try {
                DBStatement* vStatement = nullptr;
                vResult = prepareStatement(vStatement,pStatementName);

                if (nullptr != vStatement) {
                    if (EC::OK == vResult) {

                        if (-1 == vStatement->cycleQuery(pFunction)) {
                            setLastError(vStatement->lastErrorRef());
                        }
                        else {
                            vResult = EC::OK;
                            if (aEnvironment->synchronizes()) {
                                storeData(aEnvironment->syncToRef(),pStatementName);
                            }
                        }
                        delete vStatement;
                    }
                }
            }
            catch (DBException &e) {
                setLastError(e.what());
            }
        }
        else {
            setLastError("Invalid Query Runner");
        }
        return vResult;

    } // QueryRunner::execute

} // HSEPData namespace