DbStream.cpp

Go to the documentation of this file.

#include "stdafx.h"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <map>
#include <memory>

#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/resultset.h>
#include <cppconn/statement.h>
#include <cppconn/prepared_statement.h>

#include "ManagedDictionary.h"
#include "DbConnectionFactory.h"
#include "DbStream.h"

//http://dev.mysql.com/doc/refman/5.1/en/connector-net-tutorials-stored-routines-statements.html

namespace SraData
{
    //This managed dictionary is set into auto-collection mode, meaning all streams are deleted when the Streams collection is destroyed
    //While this will only be called at the end of the program, this should prevent possible resource leakage in the MySQL server
    ManagedDictionary<int, DbStream> DbStream::_Streams(true);
    int DbStream::_SerialNumber = 1;

    int DbStream::GetStreamId()
    {
        if(_SerialNumber != InitStreamId)
            return _SerialNumber++;
        else
            return ++_SerialNumber;
    }

    //protected instance methods

    bool DbStream::checkHasMoreRows()
    {
        //normally, next returns true if there is another row
        return _result->next();
    }

    DbStream* DbStream::StartStream(const std::string& query)
    {
        //create a new instance
        DbStream* newInstance = new DbStream();

        //execute the query
        //if it returns true, then there are rows in it and we can proceed with using it
        if(newInstance->execute(query))
        {
            //assign an ID to it, add it ot the collection, and return it
            return newInstance;
        }
        else
        {
            //if there are no rows, then we must immediately destroy it and return InitStreamId
            delete newInstance;
            return NULL;
        }
    }

    DbStream* DbStream::RetrieveStream(int* id)
    {
        //the ID may not be valid, in that case we must check it
        //if it isn't in there, then we reset the stream ID
        //and return NULL
        DbStream* stream = _Streams.getSafe(*id);
        if(stream == NULL)
            *id = InitStreamId;

        return stream;
    }

    bool DbStream::CheckHasMoreRows(DbStream* stream, int* newId)
    {
        //if the stream has more rows in it, then we must return true and ensure a valid ID
        if(stream->checkHasMoreRows())
        {
            //if this is the first row and we have more rows, then save it in the 
            if(stream->_firstRowFlag)
            {
                *newId = GetStreamId();
                stream->_id = *newId;
                _Streams[*newId] = stream;
            }

            stream->_firstRowFlag = false;
            return true;
        }
        else
        {
            _Streams.remove(stream->_id);
            delete stream;
            return false;
        }
    }

    DbStream::DbStream() : _firstRowFlag(true)
    {
        _connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        _stmt.reset(_connection->createStatement());
    }

    DbStream::~DbStream()
    {
        //have to do this for the API
        while(_stmt->getMoreResults()) { }
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(_connection);
    }

    bool DbStream::execute(const std::string& query)
    {
        _stmt->execute(query);
        _result.reset(_stmt->getResultSet());
        return _result->next();
    }

    int DbStream::getInt(int index)
    {
        return _result->getInt(index);
    }

    bool DbStream::getBool(int index)
    {
        return _result->getBoolean(index);
    }
}