khanat-opennel-code/code/ryzom/server/src/server_share/mysql_wrapper.h

410 lines
9.7 KiB
C
Raw Normal View History

2011-08-02 13:18:50 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef MYSQL_WRAPPER_H
#define MYSQL_WRAPPER_H
#include "nel/misc/types_nl.h"
#include <memory>
#include "nel/misc/debug.h"
#include "nel/misc/common.h"
#include "nel/misc/md5.h"
#include "nel/net/service.h"
#include "nel/net/module_common.h"
#include "game_share/utils.h"
#ifdef NL_OS_WINDOWS
# include <windows.h>
#endif
#include <mysql.h>
#include <time.h>
#include "game_share/r2_basic_types.h" // for TSessionId
namespace MSW
{
class CStoreResult;
class CUseResult;
class CConnection;
/// Utility function to encode a date
std::string encodeDate(NLMISC::TTime date);
/** escape string using 'mysql_real_escape_string' and return a the escaped string.
* Note that the function is internally optimized to quickly build the return string
* with very little overhead.
*/
const std::string &escapeString(const std::string &str, CConnection &dbCnx);
class CConnection
{
friend const std::string &escapeString(const std::string &str, CConnection &dbCnx);
/// Connection info
std::string _ConnHostName;
std::string _ConnUserName;
std::string _ConnPassword;
std::string _ConnDefaultDatabase;
/// The mysql connection context
MYSQL *_MysqlContext;
/// Flag for connection open
bool _Connected;
typedef std::map<mysql_option, const char*> TOptions;
/// A list of pair name/value of connection option
TOptions _Options;
/// Internale connect method (this one do the job)
bool _connect();
public:
CConnection()
: _MysqlContext(NULL),
_Connected(false)
{
}
~CConnection()
{
if (_Connected)
mysql_close(_MysqlContext);
}
void addOption(mysql_option option, const char *value);
void clearOption(mysql_option option);
bool connect(const std::string &hostName, const std::string &userName, const std::string &password, const std::string &defaultDatabase);
bool connect(const NLNET::TParsedCommandLine &databaseInfo);
void closeConn();
bool query(const std::string &queryString);
uint32 getLastGeneratedId()
{
return uint32(mysql_insert_id(_MysqlContext));
}
uint32 getAffectedRows()
{
return uint32(mysql_affected_rows(_MysqlContext));
}
std::auto_ptr<CStoreResult> storeResult();
std::auto_ptr<CUseResult> useResult();
};
// base class contains method to extract info from a fetched row
class CResultBase
{
protected:
MYSQL_ROW _CurrentRow;
unsigned long *_FieldLength;
MYSQL_RES *_Result;
CResultBase(MYSQL_RES *result)
: _CurrentRow(NULL),
_FieldLength(NULL),
_Result(result)
{
}
public:
~CResultBase()
{
mysql_free_result(_Result);
}
/// return the number of fields in the result set
uint32 getNumFields()
{
return mysql_num_fields(_Result);
}
const char *getRawField(uint32 fieldIndex)
{
nlassert(_CurrentRow != NULL);
nlassert(fieldIndex < getNumFields());
static const char *emptyString = "";
char *ret = _CurrentRow[fieldIndex];
return ret != NULL ? ret : emptyString;
}
void getField(uint32 fieldIndex, std::string &value)
{
value = getRawField(fieldIndex);
}
void getField(uint32 fieldIndex, bool &value)
{
const char *str = getRawField(fieldIndex);
if (str[0] == '1')
value = true;
else if (str[0] == '0')
value = false;
else
value = NLMISC::nlstricmp(str, "true") == 0;
}
void getField(uint32 fieldIndex, uint8 &value)
{
const char *str = getRawField(fieldIndex);
value = uint8(strtoul(str, NULL, 10));
}
void getField(uint32 fieldIndex, uint32 &value)
{
const char *str = getRawField(fieldIndex);
value = uint32(strtoul(str, NULL, 10));
}
void getField(uint32 fieldIndex, sint8 &value)
{
NLMISC::fromString(std::string(getRawField(fieldIndex)), value);
}
void getField(uint32 fieldIndex, sint32 &value)
{
NLMISC::fromString(std::string(getRawField(fieldIndex)), value);
}
void getField(uint32 fieldIndex, TSessionId &value)
{
sint32 val;
NLMISC::fromString(std::string(getRawField(fieldIndex)), val);
value =TSessionId(val);
}
void getField(uint32 fieldIndex, std::vector<uint8> &value)
{
const char *data = getRawField(fieldIndex);
long size = _FieldLength[fieldIndex];
std::vector<uint8> vec(data, data+size);
value.swap(vec);
}
void getMD5Field(uint32 fieldIndex, NLMISC::CHashKeyMD5 &hashKey)
{
const char *data = getRawField(fieldIndex);
long size = _FieldLength[fieldIndex];
hashKey.fromString(data);
}
void getDateField(uint32 fieldIndex, uint32 &time);
};
class CUseResult : public CResultBase
{
friend class CConnection;
CUseResult(MYSQL_RES *result)
: CResultBase(result)
{
}
public:
/// Advance to next row in the result set, return true is there is a row
bool fetchRow()
{
_CurrentRow = mysql_fetch_row(_Result);
if (_CurrentRow == NULL)
return false;
_FieldLength = mysql_fetch_lengths(_Result);
nlassert(_FieldLength != NULL);
return true;
}
};
class CStoreResult : public CResultBase
{
friend class CConnection;
CStoreResult(MYSQL_RES *result)
: CResultBase(result)
{
}
public:
/// Return the number of row in the result set
uint32 getNumRows()
{
return uint32(mysql_num_rows(_Result));
}
/// Advance to next row in the result set
void fetchRow()
{
_CurrentRow = mysql_fetch_row(_Result);
nlassert(_CurrentRow != NULL);
_FieldLength = mysql_fetch_lengths(_Result);
nlassert(_FieldLength != NULL);
}
};
} // namespace MSW
//NeL simple Object Persistence Engine
namespace NOPE
{
enum TObjectState
{
/// This is a temporary allocated, not persisted object instance
os_transient,
/// This is a persistent object, unmodified since it was loaded
os_clean,
/// This is a persistent object, modified in transient space that need to be saved to db
os_dirty,
/// This is removed object, it should no more be used as it have been removed from db
os_removed,
/// This is a persistent object, unmodified but that lie in the object cache.
os_released,
// a tag counter MUST BE LAST
os_nb_state,
};
const uint32 INVALID_OBJECT_ID = 0;
extern bool AllowedTransition [os_nb_state][os_nb_state];
enum TCacheCmd
{
cc_update,
cc_clear,
cc_dump,
cc_instance_count,
};
typedef uint32 (*TCacheCmdFunc)(TCacheCmd cmd);
class CPersistentCache :
public NLNET::IServiceUpdatable,
public NLMISC::ICommandsHandler
{
NLMISC_SAFE_SINGLETON_DECL(CPersistentCache);
typedef std::set<TCacheCmdFunc> TUpdateFuncs;
TUpdateFuncs _UpdateFuncs;
CPersistentCache()
{
NLMISC::CCommandRegistry::getInstance().registerNamedCommandHandler(this, "CPersistentCache");
}
// virtual const std::string &getCommandHandlerClassName() const
// {
// static string name("CPersistentCache");
// return name;
// }
virtual const std::string &getCommandHandlerName() const
{
static std::string name("sqlObjectCache");
return name;
}
public:
void registerCache(TCacheCmdFunc functionPtr)
{
_UpdateFuncs.insert(functionPtr);
}
void serviceLoopUpdate()
{
H_AUTO(CPersistentCache_serviceLoopUpdate);
TUpdateFuncs::iterator first(_UpdateFuncs.begin()), last(_UpdateFuncs.end());
for (; first != last; ++first)
{
TCacheCmdFunc f = *first;
f(cc_update);
}
}
// delete any unreference object in the cache
void clearCache()
{
TUpdateFuncs::iterator first(_UpdateFuncs.begin()), last(_UpdateFuncs.end());
for (; first != last; ++first)
{
TCacheCmdFunc f = *first;
f(cc_clear);
}
}
/// Return the grand total of instance in memory (including in use and in cache objects)
uint32 getInstanceCount()
{
uint32 total = 0;
TUpdateFuncs::iterator first(_UpdateFuncs.begin()), last(_UpdateFuncs.end());
for (; first != last; ++first)
{
TCacheCmdFunc f = *first;
total += f(cc_instance_count);
}
return total;
}
NLMISC_COMMAND_HANDLER_TABLE_BEGIN(CPersistentCache)
NLMISC_COMMAND_HANDLER_ADD(CPersistentCache, clearCache, "remove any unreferenced cached object from memory", "no params")
NLMISC_COMMAND_HANDLER_ADD(CPersistentCache, dump, "dump cache status", "no params")
NLMISC_COMMAND_HANDLER_TABLE_END
NLMISC_CLASS_COMMAND_DECL(dump)
{
log.displayNL("Dumping SQL cache for %u class :", _UpdateFuncs.size());
// redirect all logs to log
NLMISC::CNLSmartLogOverride logRedirector(&log);
TUpdateFuncs::iterator first(_UpdateFuncs.begin()), last(_UpdateFuncs.end());
for (; first != last; ++first)
{
TCacheCmdFunc f = *first;
f(cc_dump);
}
return true;
}
NLMISC_CLASS_COMMAND_DECL(clearCache)
{
// hop
clearCache();
return true;
}
};
} // namespace NOPE
#endif // MYSQL_WRAPPER_H