SSMRESULT CResourceFinder::startResourceFinder()
{
SSMRESULT res = SSM_E_FAIL;
OCStackResult ret = OC_STACK_ERROR;
std::ostringstream requestURI;
requestURI << OC_MULTICAST_DISCOVERY_URI << "?rt=SSManager.Sensor";
std::ostringstream multicastPresenceURI;
multicastPresenceURI << "coap://" << OC_MULTICAST_PREFIX;
ret = OC::OCPlatform::findResource("", requestURI.str(), OC_ALL,
std::bind(&CResourceFinder::onResourceFound, this, std::placeholders::_1));
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
ret = OC::OCPlatform::subscribePresence(m_multicastPresenceHandle, multicastPresenceURI.str(),
"SSManager.Sensor", OC_ALL, std::bind(&CResourceFinder::presenceHandler, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
res = SSM_S_OK;
CLEANUP:
return res;
}
SSMRESULT CSensingEngine::finalConstruct()
{
SSMRESULT res = SSM_S_OK;
SSM_CLEANUP_ASSERT(CreateGlobalInstance(OID_IContextRepository, (IBase **)&m_pContextRepository));
SSM_CLEANUP_ASSERT(CreateInstance(OID_IContextExecutor, (IBase **)&m_pContextExecutor)); //TEMP
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::finalConstruct()
{
SSMRESULT res = SSM_E_FAIL;
m_pSQLite3 = NULL;
m_mtxTriggerId.lock();
m_iTriggerId = 0;
m_mtxTriggerId.unlock();
SSM_CLEANUP_ASSERT(CreateInstance(OID_ITasker, (IBase **)&m_pTasker));
SSM_CLEANUP_ASSERT(initializeEngine());
CLEANUP:
return res;
}
/*
SSMRESULT CEvaluationEngine::DeleteModel(IN int modelId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
int lPos = 0;
int rPos = 0;
int width = 0;
IntVec dataIds;
sstream << "select lPos, rPos from [ModelRelation] where modelId = " << modelId << ";" << std::ends;
strSQL = sstream.str();
sstream.str("");
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
CHK_SQLITE(sqlite3_step(stmt), SQLITE_ROW);
lPos = sqlite3_column_int(stmt, 0);
rPos = sqlite3_column_int(stmt, 1);
width = rPos - lPos + 1;
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
sstream << "delete from [ModelRelation] where lPos between " << lPos << " and " << rPos <<
";update [ModelRelation] set rPos = rPos - " << width << " where rPos > " << rPos <<
";update [ModelRelation] set lPos = lPos - " << width << " where lPos > " << lPos << std::ends;
CHK_SSMRESULT(ExecuteSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "select dataId from [DataRelation] where modelId = " << modelId << ";" << std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
dataIds.push_back(sqlite3_column_int(stmt, 0));
}
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
for(std::vector<int>::iterator itor = dataIds.begin();
itor != dataIds.end(); ++itor)
{
CHK_SSMRESULT(DeleteModelData(modelId, *itor));
}
CLEANUP:
return res;
}
*/
SSMRESULT CEvaluationEngine::deleteModelData(IN int modelId, IN int dataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
int lPos = 0;
int rPos = 0;
int width = 0;
m_mtxDataRelation.lock();
sstream << "select lPos, rPos from [DataRelation] where modelId = " << modelId << " and dataId = "
<< dataId << ";" << std::ends;
strSQL = sstream.str();
sstream.str("");
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
CHK_SQLITE(sqlite3_step(stmt), SQLITE_ROW);
lPos = sqlite3_column_int(stmt, 0);
rPos = sqlite3_column_int(stmt, 1);
width = rPos - lPos + 1;
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
sstream << "delete from [DataRelation] where lPos between " << lPos << " and " << rPos << ";" <<
std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "update [DataRelation] set rPos = rPos - " << width << " where rPos > " << rPos << ";" <<
std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "update [DataRelation] set lPos = lPos - " << width << " where lPos > " << lPos << ";" <<
std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "delete from [ModelData" << modelId << "] where dataId = " << dataId << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
CLEANUP:
m_mtxDataRelation.unlock();
return res;
}
SSMRESULT CSoftSensorManager::stopCore()
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_ASSERT(m_pContextRepository->stopResourceFinder());
CLEANUP:
return res;
}
SSMRESULT CConditionedModel::getBaseContextModel(IContextModel **ppBaseContextModel)
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_ASSERT(m_pBaseModel->queryInterface(OID_IContextModel, (IBase **)ppBaseContextModel));
CLEANUP:
return res;
}
SSMRESULT StopSSMCore()
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_NULL_ASSERT(g_pSoftSensorManager);
SSM_CLEANUP_ASSERT(g_pSoftSensorManager->stopCore());
CLEANUP:
return res;
}
SSMRESULT CSoftSensorManager::createQueryEngine(OUT IQueryEngine **ppQueryEngine)
{
SSMRESULT res = SSM_E_FAIL;
IQueryEngineInternal *pQueryEngineInternal = NULL;
SSM_CLEANUP_ASSERT(CreateInstance(OID_IQueryEngineInternal, (IBase **)&pQueryEngineInternal));
*ppQueryEngine = (IQueryEngine *)pQueryEngineInternal;
CLEANUP:
return res;
}
SSMRESULT CreateQueryEngine(IQueryEngine **ppQueryEngine)
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_NULL_ASSERT(g_pSoftSensorManager);
SSM_CLEANUP_ASSERT(g_pSoftSensorManager->createQueryEngine(ppQueryEngine));
CLEANUP:
return res;
}
SSMRESULT CreateGlobalInstanceRepo()
{
SSMRESULT res = SSM_E_FAIL;
if (g_mtxGlobalInstance != NULL)
SSM_CLEANUP_ASSERT(SSM_E_OUTOFMEMORY);
if (g_globalInstance != NULL)
SSM_CLEANUP_ASSERT(SSM_E_OUTOFMEMORY);
g_mtxGlobalInstance = new CSimpleMutex();
SSM_CLEANUP_NULL_ASSERT(g_mtxGlobalInstance);
g_globalInstance = new std::map<OID, IBase *>();
SSM_CLEANUP_NULL_ASSERT(g_globalInstance);
SSM_CLEANUP_ASSERT(CreateGlobalInstance(OID_IThreadPool, (IBase **)&g_pThreadPool));
CLEANUP:
return res;
}
void CEvaluationEngine::terminateEngine()
{
SSMRESULT res = SSM_E_FAIL;
sqlite3 *pBackupFile = NULL;
sqlite3_backup *pBackup = NULL;
std::stringstream sstream;
//Remove all triggers on db side
m_mtxTriggerId.lock();
for (std::map<int, IEvaluationEngineEvent *>::iterator itor = m_mapTriggers.begin();
itor != m_mapTriggers.end(); ++itor)
{
sstream << "drop trigger WatchInsertModel" << itor->first << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "drop trigger WatchUpdateModel" << itor->first << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
}
m_mtxTriggerId.unlock();
if (strlen(LOCATION_SSM_DB_DUMP) > 0)
{
CHK_SQLITE(sqlite3_open(LOCATION_SSM_DB_DUMP, &pBackupFile), SQLITE_OK);
pBackup = sqlite3_backup_init(pBackupFile, "main", m_pSQLite3, "main");
CHK_SQLITE(sqlite3_errcode(pBackupFile), SQLITE_OK);
SSM_CLEANUP_NULL_ASSERT(pBackup);
CHK_SQLITE(sqlite3_backup_step(pBackup, -1), SQLITE_DONE);
CHK_SQLITE(sqlite3_backup_finish(pBackup), SQLITE_OK);
CHK_SQLITE(sqlite3_close(pBackupFile), SQLITE_OK);
}
CHK_SQLITE(sqlite3_close(m_pSQLite3), SQLITE_OK);
m_pSQLite3 = NULL;
res = SSM_S_OK;
CLEANUP:
return;
}
SSMRESULT InitializeSSMCore(std::string xmlDescription)
{
SSMRESULT res = SSM_E_FAIL;
if (g_pSoftSensorManager != NULL)
SSM_CLEANUP_ASSERT(SSM_E_INITIALIZED);
SSM_CLEANUP_ASSERT(CreateGlobalInstanceRepo());
SSM_CLEANUP_ASSERT(CreateInstance(OID_ISoftSensorManager, (IBase **)&g_pSoftSensorManager));
SSM_CLEANUP_ASSERT(g_pSoftSensorManager->initializeCore(xmlDescription));
CLEANUP:
if (res != SSM_S_OK &&
res != SSM_E_INITIALIZED)
{
SAFE_RELEASE(g_pSoftSensorManager);
DestroyGlobalInstanceRepo();
}
return res;
}
SSMRESULT TerminateSSMCore(bool factoryResetFlag)
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_NULL_ASSERT(g_pSoftSensorManager);
SSM_CLEANUP_ASSERT(g_pSoftSensorManager->terminateCore(factoryResetFlag));
CLEANUP:
SAFE_RELEASE(g_pSoftSensorManager);
DestroyGlobalInstanceRepo();
return res;
}
SSMRESULT CConditionedModel::activateTrigger(int *pTriggerId)
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_ASSERT(m_pEvaluationEngine->watchModelData(m_pBaseModel->getModelId(),
&m_watchCondition, this, &m_triggerId));
*pTriggerId = m_triggerId;
CLEANUP:
return res;
}
SSMRESULT CConditionedModel::finalConstruct()
{
SSMRESULT res = SSM_E_FAIL;
m_triggerId = -1;
m_pConditionedModelEvent = NULL;
SSM_CLEANUP_ASSERT(CreateGlobalInstance(OID_IEvaluationEngine, (IBase **)&m_pEvaluationEngine));
CLEANUP:
return res;
}
SSMRESULT DestroyGlobalInstanceRepo()
{
SSMRESULT res = SSM_E_FAIL;
SSM_CLEANUP_ASSERT(g_pThreadPool->destroyThreadPool());
SAFE_RELEASE(g_pThreadPool);
SAFE_DELETE(g_mtxGlobalInstance);
SAFE_DELETE(g_globalInstance);
CLEANUP:
return res;
}
void CResourceFinder::presenceHandler(OCStackResult result, const unsigned int nonce,
const std::string &hostAddress)
{
SSMRESULT res = SSM_E_FAIL;
OCStackResult ret = OC_STACK_ERROR;
intptr_t *pMessage = NULL;
std::ostringstream requestURI;
switch (result)
{
case OC_STACK_OK:
requestURI << "coap://" << hostAddress << "/oc/core?rt=SSManager.Sensor";
ret = OC::OCPlatform::findResource("", requestURI.str(), OC_ALL,
std::bind(&CResourceFinder::onResourceFound, this, std::placeholders::_1));
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
break;
case OC_STACK_PRESENCE_STOPPED:
if (m_mapResources.find(hostAddress) != m_mapResources.end())
{
while (!m_mapResources[hostAddress].empty())
{
pMessage = new intptr_t[2];
pMessage[0] = RESOURCE_DISCOVER_UNINSTALL_RESOURCE;
pMessage[1] = reinterpret_cast<intptr_t> (m_mapResourceHandler[m_mapResources[hostAddress].back()]);
m_mapResources[hostAddress].pop_back();
m_pTasker->addTask(this, pMessage);
}
m_mapResources.erase(hostAddress);
}
break;
case OC_STACK_PRESENCE_TIMEOUT:
break;
case OC_STACK_VIRTUAL_DO_NOT_HANDLE:
break;
default:
break;
}
CLEANUP:
;
}
SSMRESULT CEvaluationEngine::dropWatchModelData(IN int triggerId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
m_mtxDataRelation.lock();
sstream << "drop trigger WatchInsertModel" << triggerId << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "drop trigger WatchUpdateModel" << triggerId << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
m_mtxTriggerId.lock();
m_mapTriggers[triggerId]->release();
m_mapTriggers.erase(triggerId);
CLEANUP:
m_mtxTriggerId.unlock();
m_mtxDataRelation.unlock();
return res;
}
SSMRESULT CConditionedModel::deactivateTrigger()
{
SSMRESULT res = SSM_S_OK;
if (m_triggerId > -1)
{
SSM_CLEANUP_ASSERT(m_pEvaluationEngine->dropWatchModelData(m_triggerId));
}
m_triggerId = -1;
CLEANUP:
return res;
}
SSMRESULT CConditionedModel::getAffectedData(IntVec *pDataIds)
{
SSMRESULT res = SSM_E_FAIL;
m_mtxConditionedData.lock();
if (m_triggeredDataIds.size() > 0)
{
pDataIds->push_back(m_triggeredDataIds.front());
m_triggeredDataIds.pop_front();
SSM_CLEANUP_ASSERT(SSM_S_OK);
}
else
{
m_affectedDataIds.clear();
SSM_CLEANUP_ASSERT(m_pEvaluationEngine->getConditionedModelData(m_pBaseModel->getModelId(),
&m_watchCondition, &m_affectedDataIds));
*pDataIds = m_affectedDataIds;
}
CLEANUP:
m_mtxConditionedData.unlock();
return res;
}
SSMRESULT CResourceFinder::stopResourceFinder()
{
SSMRESULT res = SSM_E_FAIL;
OCStackResult ret = OC_STACK_ERROR;
ret = OC::OCPlatform::unsubscribePresence(m_multicastPresenceHandle);
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
m_multicastPresenceHandle = nullptr;
res = SSM_S_OK;
CLEANUP:
return res;
}
SSMRESULT CResourceFinder::finalConstruct()
{
SSMRESULT res = SSM_E_FAIL;
OC::PlatformConfig cfg(OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0,
OC::QualityOfService::LowQos);
SSM_CLEANUP_ASSERT(CreateGlobalInstance(OID_ITasker, (IBase **)&m_pTasker));
OC::OCPlatform::Configure(cfg);
m_pResourceFinderEvent = NULL;
m_multicastPresenceHandle = nullptr;
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::getParentDataId(IN int modelId, IN int dataId, IN int parentModelId,
OUT int *pParentDataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
sstream <<
"select parent.dataId from [DataRelation] as node, [DataRelation] as parent where parent.modelId="
<<
parentModelId << " and node.modelId=" << modelId << " and node.dataId=" <<
dataId << " and node.lPos between parent.lPos and parent.rPos;" << std::ends;
m_mtxDataRelation.lock();
SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), pParentDataId));
CLEANUP:
m_mtxDataRelation.unlock();
return res;
}
void CResourceFinder::onExecute(void *pArg)
{
SSMRESULT res = SSM_E_FAIL;
OCStackResult ret = OC_STACK_ERROR;
OC::QueryParamsMap queryParams;
OICResourceHandler *pResourceHandler = NULL;
intptr_t *pMessage = reinterpret_cast<intptr_t *>(pArg);
std::shared_ptr< OC::OCResource > *pResource = NULL;
OC::OCPlatform::OCPresenceHandle presenceHandle = NULL;
std::string resourceHostAddress = "";
std::string resourceFullPath = "";
switch (pMessage[0])
{
case RESOURCE_DISCOVER_REQUESTPROFILE:
pResource = (std::shared_ptr< OC::OCResource > *) pMessage[1];
pResourceHandler = new OICResourceHandler();
SSM_CLEANUP_ASSERT(pResourceHandler->initHandler(*pResource, this));
resourceFullPath = pResource->get()->host() + pResource->get()->uri();
resourceHostAddress = pResource->get()->host();
resourceHostAddress.erase(0, 7); // erase 'coap://'
m_mapResourceHandler[resourceFullPath] = pResourceHandler;
m_mapResources[resourceHostAddress].push_back(resourceFullPath);
ret = pResource->get()->get(queryParams, std::bind(&OICResourceHandler::onGetResourceProfile,
pResourceHandler, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
break;
case RESOURCE_DISCOVER_INSTALL_RESOURCE:
if (m_mapResourcePresenceHandles.find(((ISSMResource *)pMessage[1])->ip) ==
m_mapResourcePresenceHandles.end())
{
ret = OC::OCPlatform::subscribePresence(presenceHandle, ((ISSMResource *)pMessage[1])->ip,
"SSManager.Sensor", OC_ALL, std::bind(&CResourceFinder::presenceHandler, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
m_mapResourcePresenceHandles[((ISSMResource *)pMessage[1])->ip] = presenceHandle;
}
m_pResourceFinderEvent->onResourceFound((ISSMResource *)pMessage[1]);
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
break;
case RESOURCE_DISCOVER_UNINSTALL_RESOURCE:
m_pResourceFinderEvent->onResourceLost(&((OICResourceHandler *) pMessage[1])->m_SSMResource);
if (m_mapResourcePresenceHandles.find(((OICResourceHandler *)pMessage[1])->m_SSMResource.ip) !=
m_mapResourcePresenceHandles.end())
{
ret = OC::OCPlatform::unsubscribePresence(m_mapResourcePresenceHandles[((
OICResourceHandler *)pMessage[1])->m_SSMResource.ip]);
if (ret != OC_STACK_OK)
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
m_mapResourcePresenceHandles.erase(((OICResourceHandler *)pMessage[1])->m_SSMResource.ip);
}
delete m_mapResourceHandler[((OICResourceHandler *)pMessage[1])->m_SSMResource.name];
m_mapResourceHandler.erase(((OICResourceHandler *) pMessage[1])->m_SSMResource.name);
break;
}
CLEANUP:
;
}
SSMRESULT CEvaluationEngine::initializeEngine()
{
SSMRESULT res = SSM_E_FAIL;
sqlite3 *pBackupFile = NULL;
sqlite3_backup *pBackup = NULL;
const char *strCreate_ModelRelationTable =
"create table [ModelRelation]\
(\
modelId integer primary key autoincrement,\
modelName text NOT NULL,\
lPos int NOT NULL,\
rPos int NOT NULL\
);";
const char *strCreate_DataRelationTable =
"create table [DataRelation]\
(\
id integer primary key autoincrement,\
modelId int NOT NULL,\
lPos int NOT NULL,\
rPos int NOT NULL,\
dataId int NOT NULL\
);";
//Create rootModel
const char *strRootModel = "insert into [ModelRelation] values (null, 'root', 1, 2);";
const char *tblRoot =
"create table [ModelData1](dataId integer primary key autoincrement, name text);";
const char *rootData = "insert into [ModelData1] values (null, 'root');";
const char *rootRelation = "insert into [DataRelation] values (null, 1, 1, 2, 1);";
CHK_SQLITE(sqlite3_open_v2(LOCATION_SSM_DB, &m_pSQLite3,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL), SQLITE_OK);
CHK_SQLITE(sqlite3_create_function_v2(m_pSQLite3, "OnSQLTrigger", 3, SQLITE_UTF8, NULL,
onSQLTrigger, NULL, NULL, NULL),
SQLITE_OK);
if (strlen(LOCATION_SSM_DB_DUMP) > 0 &&
sqlite3_open_v2(LOCATION_SSM_DB_DUMP, &pBackupFile, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK)
{
pBackup = sqlite3_backup_init(m_pSQLite3, "main", pBackupFile, "main");
CHK_SQLITE(sqlite3_errcode(pBackupFile), SQLITE_OK);
SSM_CLEANUP_NULL_ASSERT(pBackup);
CHK_SQLITE(sqlite3_backup_step(pBackup, -1), SQLITE_DONE);
CHK_SQLITE(sqlite3_backup_finish(pBackup), SQLITE_OK);
CHK_SQLITE(sqlite3_close(pBackupFile), SQLITE_OK);
res = SSM_S_OK;
}
else
{
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strCreate_ModelRelationTable));
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strCreate_DataRelationTable));
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strRootModel));
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(tblRoot));
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(rootData));
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(rootRelation));
}
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::watchModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
IN IEvaluationEngineEvent *pEvaluationEngineEvent, OUT int *pTriggerId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::stringstream sstreamCondition;
for (ModelConditionVec::iterator itor = pModelConditions->begin();
itor != pModelConditions->end(); ++itor)
{
sstreamCondition << "NEW." << itor->modelProperty.propertyName;
switch (itor->predicate)
{
case ModelCondition::PREDICATE_EQ:
sstreamCondition << "=";
break;
case ModelCondition::PREDICATE_NEQ:
sstreamCondition << "!=";
break;
case ModelCondition::PREDICATE_GT:
sstreamCondition << ">";
break;
case ModelCondition::PREDICATE_LT:
sstreamCondition << "<";
break;
case ModelCondition::PREDICATE_GTE:
sstreamCondition << ">=";
break;
case ModelCondition::PREDICATE_LTE:
sstreamCondition << "<=";
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
switch (itor->modelProperty.propertyType)
{
case ModelProperty::TYPE_NUMERIC:
case ModelProperty::TYPE_INTEGER:
case ModelProperty::TYPE_REAL:
sstreamCondition << itor->modelProperty.propertyValue;
break;
case ModelProperty::TYPE_TEXT:
sstreamCondition << "'" << itor->modelProperty.propertyValue << "'";
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
if (itor < pModelConditions->end() - 1)
{
sstreamCondition << " and ";
}
}
sstreamCondition << std::ends;
m_mtxDataRelation.lock();
sstream << "CREATE TRIGGER WatchInsertModel" << m_iTriggerId << " AFTER INSERT ON [ModelData" <<
modelId << "] WHEN ";
sstream << sstreamCondition.str().c_str() << " BEGIN SELECT OnSQLTrigger(" <<
reinterpret_cast<intptr_t>(this) << ", " << m_iTriggerId << ", NEW.dataId); END;" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "CREATE TRIGGER WatchUpdateModel" << m_iTriggerId << " AFTER UPDATE ON [ModelData" <<
modelId << "] WHEN ";
sstream << sstreamCondition.str().c_str() << " BEGIN SELECT OnSQLTrigger(" <<
reinterpret_cast<intptr_t>(this) << ", " << m_iTriggerId << ", NEW.dataId); END;" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
m_mtxTriggerId.lock();
pEvaluationEngineEvent->addRef();
m_mapTriggers[m_iTriggerId] = pEvaluationEngineEvent;
*pTriggerId = m_iTriggerId++;
CLEANUP:
m_mtxTriggerId.unlock();
m_mtxDataRelation.unlock();
return res;
}
/*
SSMRESULT CEvaluationEngine::GetModelSchema(IN int modelId, OUT ModelPropertyVec *pModelProperties)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
std::string propertyType;
sstream << "pragma table_info('ModelData" << modelId << "');" << std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
ModelProperty modelData;
modelData.propertyName = (const char*)sqlite3_column_text(stmt, 1);
propertyType = (const char*)sqlite3_column_text(stmt, 2);
if(propertyType == "integer")
{
modelData.propertyType = ModelProperty::Type_INTEGER;
}
else if(propertyType == "int")
{
modelData.propertyType = ModelProperty::Type_INTEGER;
}
else if(propertyType == "real")
{
modelData.propertyType = ModelProperty::Type_REAL;
}
else if(propertyType == "text")
{
modelData.propertyType = ModelProperty::Type_TEXT;
}
else
{
modelData.propertyType = ModelProperty::Type_TEXT;
}
pModelProperties->push_back(modelData);
}
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
res = SSM_S_OK;
CLEANUP:
return res;
}
*/
SSMRESULT CEvaluationEngine::getConditionedModelData(IN int modelId,
IN ModelConditionVec *pModelConditions, OUT IntVec *pDataIds)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
sstream << "select dataId from [ModelData" << modelId <<
"] where CURRENT_TIMESTAMP < datetime( strftime('%s', lastTime) + lifetime, 'unixepoch') and ";
for (ModelConditionVec::iterator itor = pModelConditions->begin();
itor != pModelConditions->end(); ++itor)
{
sstream << itor->modelProperty.propertyName;
switch (itor->predicate)
{
case ModelCondition::PREDICATE_EQ:
sstream << "=";
break;
case ModelCondition::PREDICATE_NEQ:
sstream << "!=";
break;
case ModelCondition::PREDICATE_GT:
sstream << ">";
break;
case ModelCondition::PREDICATE_LT:
sstream << "<";
break;
case ModelCondition::PREDICATE_GTE:
sstream << ">=";
break;
case ModelCondition::PREDICATE_LTE:
sstream << "<=";
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
switch (itor->modelProperty.propertyType)
{
case ModelProperty::TYPE_NUMERIC:
case ModelProperty::TYPE_INTEGER:
case ModelProperty::TYPE_REAL:
sstream << itor->modelProperty.propertyValue;
break;
case ModelProperty::TYPE_TEXT:
sstream << "'" << itor->modelProperty.propertyValue << "'";
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
if (itor < pModelConditions->end() - 1)
{
sstream << " and ";
}
}
sstream << ";" << std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
while (sqlite3_step(stmt) == SQLITE_ROW)
{
pDataIds->push_back(sqlite3_column_int(stmt, 0));
}
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
res = SSM_S_OK;
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::createModel(IN int parentModelId, IN const char *newModelName,
IN ModelPropertyVec *pModelDescs, OUT int *pModelId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
int lPos = 0;
//Check if same name exists
sstream << "select modelId from [ModelRelation] where modelName='" << newModelName << "';" <<
std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
if (sqlite3_step(stmt) == SQLITE_ROW)
{
*pModelId = sqlite3_column_int(stmt, 0);
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
res = SSM_S_OK;
goto CLEANUP;
}
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
sstream.str("");
sstream << "select lPos from [ModelRelation] where modelId = '" << parentModelId << "';" <<
std::ends;
SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), &lPos));
sstream.str("");
sstream << "update [ModelRelation] set rPos = rPos + 2 where rPos > " << lPos << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "update [ModelRelation] set lPos = lPos + 2 where lPos > " << lPos << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "insert into [ModelRelation] values (null, '" << newModelName << "', " << lPos + 1 <<
", " << lPos + 2 <<
");" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
SSM_CLEANUP_ASSERT(executeSQL_IntReturn("select last_insert_rowid();", pModelId));
sstream << "create table [ModelData" << *pModelId <<
"](dataId integer primary key autoincrement, lastTime NOT NULL DEFAULT CURRENT_TIMESTAMP, lifetime integer NOT NULL DEFAULT 2147483647, available text DEFAULT 'true'";
for (ModelPropertyVec::iterator itor =
pModelDescs->begin(); itor != pModelDescs->end(); ++itor)
{
sstream << "," << itor->propertyName;
switch (itor->propertyType)
{
case ModelProperty::TYPE_NUMERIC:
sstream << " numeric";
break;
case ModelProperty::TYPE_INTEGER:
sstream << " integer";
break;
case ModelProperty::TYPE_REAL:
sstream << " real";
break;
case ModelProperty::TYPE_TEXT:
sstream << " text";
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
}
sstream << ");" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::updateModelData(IN int modelId, IN int dataId,
IN ModelPropertyVec *pModelValues)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
unsigned int i = 1;
sstream << "update [ModelData" << modelId << "] set lastTime=CURRENT_TIMESTAMP, ";
for (ModelPropertyVec::iterator itor = pModelValues->begin();
itor != pModelValues->end(); ++itor)
{
sstream << itor->propertyName << "=?";
if (itor < pModelValues->end() - 1)
{
sstream << ",";
}
}
sstream << " where dataId = " << dataId << ";" << std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
for (ModelPropertyVec::iterator itor = pModelValues->begin();
itor != pModelValues->end(); ++itor)
{
switch (itor->propertyType)
{
case ModelProperty::TYPE_NUMERIC:
case ModelProperty::TYPE_INTEGER:
CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);
break;
case ModelProperty::TYPE_REAL:
CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);
break;
case ModelProperty::TYPE_TEXT:
CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),
SQLITE_STATIC), SQLITE_OK);
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
i++;
}
CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
res = SSM_S_OK;
CLEANUP:
return res;
}
SSMRESULT CEvaluationEngine::addModelData(IN int modelId, IN int parentModelId, IN int parentDataId,
IN ModelPropertyVec *pModelValues, OUT int *pDataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
std::string strSQL;
sqlite3_stmt *stmt = NULL;
int lPos = 0;
unsigned int i;
sstream << "insert into [ModelData" << modelId << "] (";
for (ModelPropertyVec::iterator itor = pModelValues->begin();
itor != pModelValues->end(); ++itor)
{
sstream << itor->propertyName;
if (itor < pModelValues->end() - 1)
{
sstream << ",";
}
}
sstream << ") values (";
for (i = 0; i < pModelValues->size(); i++)
{
sstream << "?";
if (i < pModelValues->size() - 1)
{
sstream << ",";
}
}
sstream << ");" << std::ends;
strSQL = sstream.str();
CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
sstream.str("");
i = 1;
for (ModelPropertyVec::iterator itor = pModelValues->begin();
itor != pModelValues->end(); ++itor)
{
switch (itor->propertyType)
{
case ModelProperty::TYPE_NUMERIC:
case ModelProperty::TYPE_INTEGER:
CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);
break;
case ModelProperty::TYPE_REAL:
CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);
break;
case ModelProperty::TYPE_TEXT:
CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),
SQLITE_STATIC), SQLITE_OK);
break;
default:
SSM_CLEANUP_ASSERT(SSM_E_FAIL);
}
i++;
}
m_mtxDataRelation.lock();
CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);
CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
SSM_CLEANUP_ASSERT(executeSQL_IntReturn("select last_insert_rowid();", pDataId));
sstream << "select lPos from [DataRelation] where modelId = " << parentModelId << " and dataId = "
<< parentDataId << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), &lPos));
sstream.str("");
sstream << "update [DataRelation] set rPos = rPos + 2 where rPos > " << lPos << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "update [DataRelation] set lPos = lPos + 2 where lPos > " << lPos << ";" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
sstream.str("");
sstream << "insert into [DataRelation] values (null, " << modelId << ", " << lPos + 1 << ", " <<
lPos + 2 <<
", " << *pDataId << ");" << std::ends;
SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
CLEANUP:
m_mtxDataRelation.unlock();
return res;
}
