//-------------------------------------------------------------------------------------
bool Dbmgr::initDB()
{
ScriptDefModule* pModule = EntityDef::findScriptModule(DBUtil::accountScriptName());
if(pModule == NULL)
{
ERROR_MSG(fmt::format("Dbmgr::initDB(): not found account script[{}]!\n",
DBUtil::accountScriptName()));
return false;
}
if(!DBUtil::initialize())
{
ERROR_MSG("Dbmgr::initDB(): can't initialize dbinterface!\n");
return false;
}
DBInterface* pDBInterface = DBUtil::createInterface();
if(pDBInterface == NULL)
{
ERROR_MSG("Dbmgr::initDB(): can't create dbinterface!\n");
return false;
}
bool ret = DBUtil::initInterface(pDBInterface);
pDBInterface->detach();
SAFE_RELEASE(pDBInterface);
if(!ret)
return false;
return ret;
}
//-------------------------------------------------------------------------------------
bool Dbmgr::initDB()
{
if(!DBUtil::initialize())
{
ERROR_MSG("Dbmgr::initDB: can't initialize dbinterface!\n");
return false;
}
DBInterface* pDBInterface = DBUtil::createInterface();
if(pDBInterface == NULL)
{
ERROR_MSG("Dbmgr::initDB: can't create dbinterface!\n");
return false;
}
bool ret = DBUtil::initInterface(pDBInterface);
if(ret)
{
ret = pDBInterface->checkEnvironment();
}
pDBInterface->detach();
SAFE_RELEASE(pDBInterface);
if(!ret)
return false;
return ret;
}
//-------------------------------------------------------------------------------------
DBInterface* DBUtil::createInterface(const std::string& name, bool showinfo)
{
DBInterfaceInfo* pDBInfo = g_kbeSrvConfig.dbInterface(name);
if (!pDBInfo)
{
ERROR_MSG(fmt::format("DBUtil::createInterface: not found dbInterface({})\n",
name));
return NULL;
}
DBInterface* dbinterface = NULL;
if (strcmp(pDBInfo->db_type, "mysql") == 0)
{
dbinterface = new DBInterfaceMysql(name.c_str(), pDBInfo->db_unicodeString_characterSet, pDBInfo->db_unicodeString_collation);
}
else if (strcmp(pDBInfo->db_type, "redis") == 0)
{
dbinterface = new DBInterfaceRedis(name.c_str());
}
if(dbinterface == NULL)
{
ERROR_MSG(fmt::format("DBUtil::createInterface: create db_interface error! type={}\n",
pDBInfo->db_type));
return NULL;
}
kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", pDBInfo->db_type);
dbinterface->db_port_ = pDBInfo->db_port;
kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", pDBInfo->db_ip);
kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", pDBInfo->db_username);
dbinterface->db_numConnections_ = pDBInfo->db_numConnections;
kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", pDBInfo->db_password);
if (!dbinterface->attach(pDBInfo->db_name))
{
ERROR_MSG(fmt::format("DBUtil::createInterface: attach to database failed!\n\tdbinterface={0:p}\n\targs={1}\n",
(void*)&dbinterface, dbinterface->c_str()));
delete dbinterface;
return NULL;
}
else
{
if(showinfo)
{
INFO_MSG(fmt::format("DBUtil::createInterface[{0:p}]: {1}\n", (void*)&dbinterface,
dbinterface->c_str()));
}
}
return dbinterface;
}
void KeywordManager::CreateProjectSupplyTable()
{
DBInterface db;
if(db.OpenSupplyConnection("127.0.0.1","onsystems", "ebertsux37", "gnutella_raw_supply"))
{
for(UINT i=0; i<v_project_keywords.size(); i++)
{
CString project_supply_table = v_project_keywords[i].m_project_name.c_str();
db.CreateProjectSupplyTable(project_supply_table);
}
db.CloseSupplyConnection();
}
}
//-------------------------------------------------------------------------------------
DBInterface* DBUtil::createInterface(bool showinfo)
{
ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr();
DBInterface* dbinterface = NULL;
if(strcmp(dbcfg.db_type, "mysql") == 0)
{
dbinterface = new DBInterfaceMysql(dbcfg.db_unicodeString_characterSet, dbcfg.db_unicodeString_collation);
}
else if(strcmp(dbcfg.db_type, "redis") == 0)
{
dbinterface = new DBInterfaceRedis();
}
if(dbinterface == NULL)
{
ERROR_MSG(fmt::format("DBUtil::createInterface: create db_interface error! type={}\n",
dbcfg.db_type));
return NULL;
}
kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", dbcfg.db_type);
dbinterface->db_port_ = dbcfg.db_port;
kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", dbcfg.db_ip);
kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", dbcfg.db_username);
dbinterface->db_numConnections_ = dbcfg.db_numConnections;
kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", dbcfg.db_password);
if(!dbinterface->attach(DBUtil::dbname()))
{
ERROR_MSG(fmt::format("DBUtil::createInterface: attach to database failed!\n\tdbinterface={0:p}\n\targs={1}\n",
(void*)&dbinterface, dbinterface->c_str()));
delete dbinterface;
return NULL;
}
else
{
if(showinfo)
{
INFO_MSG(fmt::format("DBUtil::createInterface[{0:p}]: {1}\n", (void*)&dbinterface,
dbinterface->c_str()));
}
}
return dbinterface;
}
void TorrentCreator::WriteHashToDatabase(void)
{
TRACE( "Start updating bt_generator_maininfo database\n" );
CTime currentTime = CTime::GetCurrentTime();
m_pIPData->SetCreationTime( (time_t)currentTime.GetTime() );
DBInterface db;
string torrentfilename = m_pIPData->GetTorrentFileName();
db.OpenConnection(IP_BITTORRENT_DATABASE, "onsystems", "ebertsux37", "bittorrent_data");
char aQuery[1024];
sprintf( aQuery, "UPDATE bt_generator_maininfo SET info_hash = '%s', generate='F', creation_date = %s WHERE auto_torrent_id = %u",
GetHashString(m_pIPData->GetInfohash()).c_str(), currentTime.Format( "%Y%m%d%H%M%S" ), m_pIPData->GetTorrentID() );
int ret = db.executeQuery(aQuery);
TRACE( "Done updating bt_generator_maininfo database\n" );
}
bool InitGameDB()
{
DBInterface* db = new SQLiteInterface();
if(!db->Open("gametest.db"))
return false;
// account--accountid|username||password
if(!db->CreateTable("create table if not exists account(accountid INTEGER primary key AUTOINCREMENT, username TEXT UNIQUE, password TEXT)"))
return false;
// role--roleid|rolename|accountid|money|exp|level
if(!db->CreateTable("create table if not exists role(roleid INTEGER primary key AUTOINCREMENT, rolename TEXT UNIQUE, accountid INTERGER, money INTERGER ,exp INTERGER, level INTERGER)"))
return false;
db->Close();
delete db;
return true;
}
//-------------------------------------------------------------------------------------
DBInterface* DBUtil::createInterface(bool showinfo)
{
ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr();
DBInterface* dbinterface = NULL;
if(strcmp(dbcfg.db_type, "mysql") == 0)
{
dbinterface = new DBInterfaceMysql;
}
kbe_snprintf(dbinterface->db_type_, MAX_BUF, "%s", dbcfg.db_type);
dbinterface->db_port_ = dbcfg.db_port;
kbe_snprintf(dbinterface->db_ip_, MAX_IP, "%s", dbcfg.db_ip);
kbe_snprintf(dbinterface->db_username_, MAX_BUF, "%s", dbcfg.db_username);
kbe_snprintf(dbinterface->db_password_, MAX_BUF, "%s", dbcfg.db_password);
dbinterface->db_numConnections_ = dbcfg.db_numConnections;
if(dbinterface == NULL)
{
ERROR_MSG("DBUtil::createInterface: can't create dbinterface!\n");
return NULL;
}
if(!dbinterface->attach(DBUtil::dbname()))
{
ERROR_MSG("DBUtil::createInterface: can't attach to database!\n\tdbinterface=%p\n\targs=%s",
&dbinterface, dbinterface->c_str());
delete dbinterface;
return NULL;
}
else
{
if(showinfo)
{
INFO_MSG("DBUtil::createInterface[%p]: %s\n", &dbinterface, dbinterface->c_str());
}
}
return dbinterface;
}
//-------------------------------------------------------------------------------------
bool Dbmgr::initDB()
{
if(!DBUtil::initialize())
{
ERROR_MSG("Dbmgr::initDB: can't initialize dbinterface!\n");
return false;
}
ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr();
DBInterface* pDBInterface = DBUtil::createInterface();
if(pDBInterface == NULL)
{
ERROR_MSG("Dbmgr::initDB: can't create dbinterface!\n");
return false;
}
bool ret = DBUtil::initInterface(pDBInterface);
if(ret)
{
ret = pDBInterface->checkEnvironment();
}
pDBInterface->detach();
SAFE_RELEASE(pDBInterface);
if(!ret)
return false;
if(!dbThreadPool_.isInitialize())
{
ret = dbThreadPool_.createThreadPool(dbcfg.db_numConnections,
dbcfg.db_numConnections, dbcfg.db_numConnections);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
DBInterface* pInterface = new SqliteInterface();
pInterface->Open("..\\test");
DBTable table;
int Col_Content = table.GetColumnIdx("Content");
if (Col_Content == -1)
{
printf("Invalid Column Name\n");
return false;
}
pInterface->ExecuteSql("select * from test", table);
// for (;;)
// {
//
// }
printf("I am here, waiting for u\n");
return 0;
}
//-------------------------------------------------------------------------------------
bool Dbmgr::initDB()
{
ScriptDefModule* pModule = EntityDef::findScriptModule(DBUtil::accountScriptName());
if(pModule == NULL)
{
ERROR_MSG(fmt::format("Dbmgr::initDB(): not found account script[{}]!\n",
DBUtil::accountScriptName()));
return false;
}
ENGINE_COMPONENT_INFO& dbcfg = g_kbeSrvConfig.getDBMgr();
if (dbcfg.dbInterfaceInfos.size() == 0)
{
ERROR_MSG(fmt::format("DBUtil::initialize: not found dbInterface! (kbengine_defs.xml->dbmgr->databaseInterfaces)\n"));
return false;
}
if (!DBUtil::initialize())
{
ERROR_MSG("Dbmgr::initDB(): can't initialize dbInterface!\n");
return false;
}
bool hasDefaultInterface = false;
std::vector<DBInterfaceInfo>::iterator dbinfo_iter = dbcfg.dbInterfaceInfos.begin();
for (; dbinfo_iter != dbcfg.dbInterfaceInfos.end(); ++dbinfo_iter)
{
Buffered_DBTasks buffered_DBTasks;
bufferedDBTasksMaps_.insert(std::make_pair((*dbinfo_iter).name, buffered_DBTasks));
BUFFERED_DBTASKS_MAP::iterator buffered_DBTasks_iter = bufferedDBTasksMaps_.find((*dbinfo_iter).name);
buffered_DBTasks_iter->second.dbInterfaceName((*dbinfo_iter).name);
}
for (dbinfo_iter = dbcfg.dbInterfaceInfos.begin(); dbinfo_iter != dbcfg.dbInterfaceInfos.end(); ++dbinfo_iter)
{
DBInterface* pDBInterface = DBUtil::createInterface((*dbinfo_iter).name);
if(pDBInterface == NULL)
{
ERROR_MSG("Dbmgr::initDB(): can't create dbInterface!\n");
return false;
}
bool ret = DBUtil::initInterface(pDBInterface);
pDBInterface->detach();
SAFE_RELEASE(pDBInterface);
if(!ret)
return false;
if (std::string("default") == (*dbinfo_iter).name)
hasDefaultInterface = true;
}
if (!hasDefaultInterface)
{
ERROR_MSG("Dbmgr::initDB(): \"default\" dbInterface was not found! (kbengine_defs.xml->dbmgr->databaseInterfaces)\n");
return false;
}
return true;
}
