DbProcedures.cpp

Go to the documentation of this file.

// TestDLL.cpp : Defines the exported functions for the DLL application.

#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 "DbConnectionFactory.h"
#include "DbProcedures.h"
#include "DbStream.h"

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

namespace SraData
{
    void DbProcedures::clearCharQuality(int pInCharId, int pInQualityId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL clear_char_quality(?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInQualityId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::clearCharSpell(int pInCharId, int pInSpellId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL clear_char_spell(?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInSpellId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::createCharacter(int pInRaceId, int* pOutId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL create_character(?,@param1)"));
        pstmt->setInt(1,pInRaceId);
            
        pstmt->execute();
            
        {
            std::auto_ptr< sql::ResultSet > res;
            std::auto_ptr< sql::Statement > stmt;
            stmt.reset(connection->createStatement());
            res.reset(stmt->executeQuery("SELECT @param1 from dual"));
            res->next();
            *pOutId = res->getInt(1);
        }
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::createGearItem(int pInGearId, int pInOwnerCharId, int pInRating, int* pOutGearItemId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL create_gear_item(?,?,?,@param3)"));
        pstmt->setInt(1,pInGearId);
        pstmt->setInt(2,pInOwnerCharId);
        pstmt->setInt(3,pInRating);
            
        pstmt->execute();
            
        {
            std::auto_ptr< sql::ResultSet > res;
            std::auto_ptr< sql::Statement > stmt;
            stmt.reset(connection->createStatement());
            res.reset(stmt->executeQuery("SELECT @param3 from dual"));
            res->next();
            *pOutGearItemId = res->getInt(1);
        }
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::createPlayer(const std::string& pInLogin, const std::string& pInPassword, int* pOutId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL create_player(?,?,@param2)"));
        pstmt->setString(1,pInLogin);
        pstmt->setString(2,pInPassword);
            
        pstmt->execute();
            
        {
            std::auto_ptr< sql::ResultSet > res;
            std::auto_ptr< sql::Statement > stmt;
            stmt.reset(connection->createStatement());
            res.reset(stmt->executeQuery("SELECT @param2 from dual"));
            res->next();
            *pOutId = res->getInt(1);
        }
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::createPlayerCharacter(int pInRaceId, int pInPlayerId, int* pOutPcId, int* pOutCharId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL create_player_character(?,?,@param2,@param3)"));
        pstmt->setInt(1,pInRaceId);
        pstmt->setInt(2,pInPlayerId);
            
        pstmt->execute();
            
        {
            std::auto_ptr< sql::ResultSet > res;
            std::auto_ptr< sql::Statement > stmt;
            stmt.reset(connection->createStatement());
            res.reset(stmt->executeQuery("SELECT @param2 from dual"));
            res->next();
            *pOutPcId = res->getInt(1);
        }
            
        {
            std::auto_ptr< sql::ResultSet > res;
            std::auto_ptr< sql::Statement > stmt;
            stmt.reset(connection->createStatement());
            res.reset(stmt->executeQuery("SELECT @param3 from dual"));
            res->next();
            *pOutCharId = res->getInt(1);
        }
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::deleteGearItem(int pInGearItemId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL delete_gear_item(?)"));
        pstmt->setInt(1,pInGearItemId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::getChar(int pInCharId, bool* isMale, int* raceId, int* agility, int* body, int* reaction, int* strength, int* charisma, int* intuition, int* logic, int* willpower, int* edge, int* edgeBurnt, int* magic, int* resonance, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *isMale = stream->getBool(1);
        *raceId = stream->getInt(2);
        *agility = stream->getInt(3);
        *body = stream->getInt(4);
        *reaction = stream->getInt(5);
        *strength = stream->getInt(6);
        *charisma = stream->getInt(7);
        *intuition = stream->getInt(8);
        *logic = stream->getInt(9);
        *willpower = stream->getInt(10);
        *edge = stream->getInt(11);
        *edgeBurnt = stream->getInt(12);
        *magic = stream->getInt(13);
        *resonance = stream->getInt(14);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharActiveSkills(int pInCharId, int* activeSkillId, int* rating, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_active_skills(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *activeSkillId = stream->getInt(1);
        *rating = stream->getInt(2);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharAdeptPwrs(int pInCharId, int* adeptPowerId, int* rating, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_adept_pwrs(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *adeptPowerId = stream->getInt(1);
        *rating = stream->getInt(2);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharDmg(int pInCharId, int* stunDmgTaken, int* physicalDmgTaken, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_dmg(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *stunDmgTaken = stream->getInt(1);
        *physicalDmgTaken = stream->getInt(2);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharGear(int pInCharId, int* gearId, int* location, int* rating, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_gear(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *gearId = stream->getInt(1);
        *location = stream->getInt(2);
        *rating = stream->getInt(3);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharKnowSkills(int pInCharId, int* knowledgeSkillId, int* rating, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_know_skills(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *knowledgeSkillId = stream->getInt(1);
        *rating = stream->getInt(2);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharQualities(int pInCharId, int* qualityId, int* rating, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_qualities(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *qualityId = stream->getInt(1);
        *rating = stream->getInt(2);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getCharSpells(int pInCharId, int* spellId, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_char_spells(%d)",pInCharId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *spellId = stream->getInt(1);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getPcZone(int pInPcId, int* currentZoneId, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_pc_zone(%d)",pInPcId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *currentZoneId = stream->getInt(1);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::getPlayerCharacters(int pInPlayerId, int* ID, int* queryId)
    {
        DbStream* stream;
        if(*queryId == DbStream::InitStreamId)
            stream = DbStream::StartStream(formatString("CALL get_player_characters(%d)",pInPlayerId));
        else
            stream = DbStream::RetrieveStream(queryId);
        if(stream == NULL)
            return;
        *ID = stream->getInt(1);
        if(!DbStream::CheckHasMoreRows(stream, queryId))
            *queryId = DbStream::InitStreamId;
    }
        
    void DbProcedures::setCharActiveSkill(int pInCharId, int pInSkillId, int pInRating)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_active_skill(?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInSkillId);
        pstmt->setInt(3,pInRating);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharAdeptPwr(int pInCharId, int pInPwrId, int pInRating)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_adept_pwr(?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInPwrId);
        pstmt->setInt(3,pInRating);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharDmg(int pInCharId, int pInStunDmg, int pInPhysDmg)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_dmg(?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInStunDmg);
        pstmt->setInt(3,pInPhysDmg);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharKnowSkill(int pInCharId, int pInSkillId, int pInRating)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_know_skill(?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInSkillId);
        pstmt->setInt(3,pInRating);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharMentAttr(int pInCharId, int pInCharisma, int pInIntuition, int pInLogic, int pInWillpower)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_ment_attr(?,?,?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInCharisma);
        pstmt->setInt(3,pInIntuition);
        pstmt->setInt(4,pInLogic);
        pstmt->setInt(5,pInWillpower);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharPhysAttr(int pInCharId, int pInAgility, int pInBody, int pInReaction, int pInStrength)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_phys_attr(?,?,?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInAgility);
        pstmt->setInt(3,pInBody);
        pstmt->setInt(4,pInReaction);
        pstmt->setInt(5,pInStrength);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharQuality(int pInCharId, int pInQualityId, int pInRating)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_quality(?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInQualityId);
        pstmt->setInt(3,pInRating);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharSpecAttr(int pInCharId, int pInEdge, int pInEdgeBurnt, int pInMagic, int pInResonance)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_spec_attr(?,?,?,?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInEdge);
        pstmt->setInt(3,pInEdgeBurnt);
        pstmt->setInt(4,pInMagic);
        pstmt->setInt(5,pInResonance);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setCharSpell(int pInCharId, int pInSpellId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_char_spell(?,?)"));
        pstmt->setInt(1,pInCharId);
        pstmt->setInt(2,pInSpellId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setGearItemOwner(int pInGearId, int pInOwnerCharId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_gear_item_owner(?,?)"));
        pstmt->setInt(1,pInGearId);
        pstmt->setInt(2,pInOwnerCharId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setPcZone(int pInPcId, int pInZoneId)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_pc_zone(?,?)"));
        pstmt->setInt(1,pInPcId);
        pstmt->setInt(2,pInZoneId);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
        
    void DbProcedures::setPlayerNickname(int pInPlayerId, const std::string& pInNickname)
    {
        sql::Connection* connection = SraData::DbConnectionFactory::GetSingleton().getConnection();
        std::auto_ptr<sql::PreparedStatement> pstmt;
        pstmt.reset(connection->prepareStatement("CALL set_player_nickname(?,?)"));
        pstmt->setInt(1,pInPlayerId);
        pstmt->setString(2,pInNickname);
            
        pstmt->execute();
            
        SraData::DbConnectionFactory::GetSingleton().recycleConnection(connection);
    }
}