git.sesse.net Git - freerainbowtables/blob - Server Applications/rsearchi/MySQL.cpp

   1 #include "stdafx.h"
   2 #include "MySQL.h"
   3 #include <sstream>
   4 #include <stdlib.h>
   5 #include <iostream>
   6 MySQL::MySQL(void)
   7 {
   8 }
   9 MySQL::MySQL(std::string Servername, std::string Username, std::string Password, std::string Database, int Port)
  10 {
  11         m_LastResult = NULL;
  12 #ifdef DEBUG
  13 //      logfile << "Connecting to database";
  14 #endif
  15         OpenDatabase(Servername, Username, Password, Database, Port);
  16 }
  17 MySQL::~MySQL(void)
  18 {
  19         if(m_LastResult != NULL)
  20         {
  21                 mysql_free_result(m_LastResult);
  22
  23         }
  24 #ifdef DEBUG
  25 //      logfile << "Shutting down database connection";
  26 #endif
  27         mysql_close(&m_DBHandle);
  28 }
  29
  30 void MySQL::OpenDatabase(std::string Servername, std::string Username, std::string Password, std::string Database, int Port)
  31 {
  32         mysql_init(&m_DBHandle);
  33         if(!mysql_real_connect(&m_DBHandle, Servername.c_str(), Username.c_str(), Password.c_str(), Database.c_str(), Port, NULL, 0))
  34         {
  35                 std::stringstream error;
  36                 error << "Could not connect to server: " << mysql_error(&m_DBHandle);
  37                 throw new MySQLException(error.str(), mysql_errno(&m_DBHandle));
  38         }
  39         m_Servername = Servername;
  40         m_Username = Username;
  41         m_Password = Password;
  42         m_Database = Database;
  43         m_Port = Port;
  44 }
  45
  46 void MySQL::Reconnect()
  47 {
  48         OpenDatabase(m_Servername, m_Username, m_Password, m_Database, m_Port);
  49 }
  50 void MySQL::Query(std::string SQLQuery)
  51 {
  52 #ifdef DEBUG
  53 //      logfile << SQLQuery;
  54 #endif
  55         try
  56         {
  57                 if(mysql_query(&m_DBHandle, SQLQuery.c_str()) != 0)
  58                 {
  59                         std::stringstream error;
  60                         error << "Error querying server: " << mysql_error(&m_DBHandle) << std::endl << "SQL: " << SQLQuery;
  61                         throw new MySQLException(error.str(), mysql_errno(&m_DBHandle));
  62                 }
  63         }
  64         catch(DatabaseException *ex)
  65         {
  66                 if(ex->getErrorCode() == CR_SERVER_LOST)
  67                 {
  68 //                      logfile << "Reconnecting to server" << std::endl;
  69                         Reconnect();
  70
  71                         Query(SQLQuery);
  72                 }
  73                 else throw ex;
  74         }
  75 }
  76
  77 uint64 MySQL::Select(std::string SQLQuery)
  78 {
  79 #ifdef DEBUG
  80         std::cout << "Doing query " << SQLQuery << std::endl;
  81 #endif
  82         Query(SQLQuery);
  83         if(m_LastResult != NULL) {
  84 #ifdef DEBUG
  85                 std::cout << "Freeing up previous result" << std::endl;
  86 #endif
  87                 mysql_free_result(m_LastResult);
  88         }
  89
  90 #ifdef DEBUG
  91                 std::cout << "Transferring result from database server" << std::endl;
  92 #endif
  93
  94         m_LastResult = mysql_store_result(&m_DBHandle);
  95         if(m_LastResult == NULL)
  96         {
  97                 std::stringstream szError;
  98                 szError << "Error while transferring result from database server: " << mysql_error(&m_DBHandle);
  99                 throw new MySQLException(szError.str(), mysql_errno(&m_DBHandle));
 100         }
 101 #ifdef DEBUG
 102         std::cout << "Result transferred OK" << std::endl;
 103 #endif
 104         return true;
 105 }
 106 int MySQL::SelectUnbuffered(std::string SQLQuery)
 107 {
 108         Query(SQLQuery);
 109         if(m_LastResult != NULL) {
 110 #ifdef DEBUG
 111         //      logfile << "Freeing up previous result";
 112 #endif
 113                 mysql_free_result(m_LastResult);
 114         }
 115 /*
 116 #ifdef DEBUG
 117                 logfile << "Transferring result from database server";
 118 #endif
 119                 */
 120         m_LastResult = mysql_use_result(&m_DBHandle);
 121         if(m_LastResult == NULL)
 122         {
 123                 std::stringstream szError;
 124                 szError << "Error while transferring result from database server: " << mysql_error(&m_DBHandle);
 125                 throw new MySQLException(szError.str(), mysql_errno(&m_DBHandle));
 126         }
 127 #ifdef DEBUG
 128 //      logfile << "Result transferred OK";
 129 #endif
 130         return mysql_num_rows(m_LastResult);
 131 }
 132
 133 int MySQL::Fetch()
 134 {
 135         if(m_LastResult == NULL)
 136                 return false;
 137 #ifdef DEBUG
 138         std::cout << "Fetching MySQL row" << std::endl;
 139 #endif
 140         m_Row = mysql_fetch_row(m_LastResult);
 141         if(m_Row == NULL)
 142         {
 143 #ifdef DEBUG
 144         std::cout << "row == NULL" << std::endl;
 145 #endif
 146
 147                 if(mysql_errno(&m_DBHandle) > 0)
 148                 {
 149                         std::stringstream szError;
 150                         szError << "Error while fetching row from database server: " << mysql_error(&m_DBHandle);
 151                         throw new MySQLException(szError.str(), mysql_errno(&m_DBHandle));
 152                 }
 153                 return false;
 154         }
 155         return true;
 156 }
 157
 158 const unsigned char* MySQL::GetText(int Column)
 159 {
 160         return (const unsigned char*)m_Row[Column];
 161 }
 162 int MySQL::GetInt(int Column)
 163 {
 164         if(m_Row[Column] == NULL)
 165         {
 166 #ifdef DEBUG
 167                 std::cout << "Returning NULL from MySQL::GetInt()";
 168 #endif
 169                 return 0;
 170         }
 171 /*
 172 #ifdef DEBUG
 173         std::stringstream log;
 174         log << "mysql atoi() " << Column << " " << m_Row[Column];
 175         logfile.AddLine(log.str());
 176 #endif
 177         */
 178         return atoi(m_Row[Column]);
 179 }
 180 __int64 MySQL::GetInt64(int Column)
 181 {
 182
 183         return _atoi64(m_Row[Column]);
 184 }
 185 __int64 MySQL::GetLastInsertID()
 186 {
 187         return (__int64)mysql_insert_id(&m_DBHandle);
 188 }
 189 __int64 MySQL::GetAffectedRows()
 190 {
 191         return (__int64)mysql_affected_rows(&m_DBHandle);
 192 }
 193 void MySQL::Escape(std::string &Data)
 194 {
 195         int tmpsize = Data.size() * 2 + 1;
 196         int usedsize;
 197         char tmp[8096];// = new char[tmpsize];
 198         memset(tmp, 0x00, sizeof(tmp));
 199         usedsize = mysql_real_escape_string(&m_DBHandle, tmp, Data.c_str(), Data.size());
 200         Data.assign(tmp, usedsize);
 201 //      delete tmp;
 202 }
 203