1 /******************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 ******************************************************************/
20 #include "EvaluationEngine.h"
22 #define CHK_SQLITE(val, cond) {SSM_CLEANUP_COND_ASSERT(val, cond, sqlite3_errmsg(m_pSQLite3));}
24 SSMRESULT CEvaluationEngine::finalConstruct()
26 SSMRESULT res = SSM_E_FAIL;
30 m_mtxTriggerId.lock();
32 m_mtxTriggerId.unlock();
34 SSM_CLEANUP_ASSERT(CreateInstance(OID_ITasker, (IBase **)&m_pTasker));
35 SSM_CLEANUP_ASSERT(initializeEngine());
41 void CEvaluationEngine::finalRelease()
46 SSMRESULT CEvaluationEngine::executeSQL_NoReturn(std::string strSQL)
48 SSMRESULT res = SSM_E_FAIL;
49 sqlite3_stmt *stmt = NULL;
51 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
52 CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);
53 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
60 SSMRESULT CEvaluationEngine::executeSQL_IntReturn(std::string strSQL, int *pResult)
62 SSMRESULT res = SSM_E_FAIL;
63 sqlite3_stmt *stmt = NULL;
65 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
66 CHK_SQLITE(sqlite3_step(stmt), SQLITE_ROW);
67 *pResult = sqlite3_column_int(stmt, 0);
68 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
75 void CEvaluationEngine::onSQLTrigger(sqlite3_context *context, int argc,
78 CEvaluationEngine *pEvaluationEngine = (CEvaluationEngine *)sqlite3_value_int64(argv[0]);
80 pEvaluationEngine->onWatcherTriggered(sqlite3_value_int(argv[1]), sqlite3_value_int(argv[2]));
83 void CEvaluationEngine::onExecute(void *pArg)
85 std::map<int, IEvaluationEngineEvent *>::iterator itor;
86 intptr_t *pData = (intptr_t *)pArg;
88 m_mtxTriggerId.lock();
89 itor = m_mapTriggers.find(pData[0]);
90 if (itor != m_mapTriggers.end())
92 IEvaluationEngineEvent *pEvent = itor->second;
93 pEvent->onWatchModelData(pData[0], pData[1]);
95 m_mtxTriggerId.unlock();
98 void CEvaluationEngine::onTerminate(void *pArg)
100 intptr_t *pData = (intptr_t *)pArg;
101 SAFE_ARRAY_DELETE(pData);
104 SSMRESULT CEvaluationEngine::onWatcherTriggered(int triggerId, int dataId)
106 intptr_t *pData = new intptr_t[2];
107 pData[0] = triggerId;
109 m_pTasker->addTask(this, (void *)pData);
113 SSMRESULT CEvaluationEngine::initializeEngine()
115 SSMRESULT res = SSM_E_FAIL;
116 sqlite3 *pBackupFile = NULL;
117 sqlite3_backup *pBackup = NULL;
119 const char *strCreate_ModelRelationTable =
120 "create table [ModelRelation]\
122 modelId integer primary key autoincrement,\
123 modelName text NOT NULL,\
128 const char *strCreate_DataRelationTable =
129 "create table [DataRelation]\
131 id integer primary key autoincrement,\
132 modelId int NOT NULL,\
139 const char *strRootModel = "insert into [ModelRelation] values (null, 'root', 1, 2);";
141 const char *tblRoot =
142 "create table [ModelData1](dataId integer primary key autoincrement, name text);";
144 const char *rootData = "insert into [ModelData1] values (null, 'root');";
146 const char *rootRelation = "insert into [DataRelation] values (null, 1, 1, 2, 1);";
148 CHK_SQLITE(sqlite3_open_v2(LOCATION_SSM_DB, &m_pSQLite3,
149 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL), SQLITE_OK);
151 CHK_SQLITE(sqlite3_create_function_v2(m_pSQLite3, "OnSQLTrigger", 3, SQLITE_UTF8, NULL,
152 onSQLTrigger, NULL, NULL, NULL),
155 if (strlen(LOCATION_SSM_DB_DUMP) > 0 &&
156 sqlite3_open_v2(LOCATION_SSM_DB_DUMP, &pBackupFile, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK)
158 pBackup = sqlite3_backup_init(m_pSQLite3, "main", pBackupFile, "main");
159 CHK_SQLITE(sqlite3_errcode(pBackupFile), SQLITE_OK);
160 SSM_CLEANUP_NULL_ASSERT(pBackup);
161 CHK_SQLITE(sqlite3_backup_step(pBackup, -1), SQLITE_DONE);
162 CHK_SQLITE(sqlite3_backup_finish(pBackup), SQLITE_OK);
163 CHK_SQLITE(sqlite3_close(pBackupFile), SQLITE_OK);
168 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strCreate_ModelRelationTable));
169 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strCreate_DataRelationTable));
171 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(strRootModel));
172 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(tblRoot));
173 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(rootData));
174 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(rootRelation));
181 void CEvaluationEngine::terminateEngine()
183 SSMRESULT res = SSM_E_FAIL;
184 sqlite3 *pBackupFile = NULL;
185 sqlite3_backup *pBackup = NULL;
186 std::stringstream sstream;
188 //Remove all triggers on db side
189 m_mtxTriggerId.lock();
190 for (std::map<int, IEvaluationEngineEvent *>::iterator itor = m_mapTriggers.begin();
191 itor != m_mapTriggers.end(); ++itor)
193 sstream << "drop trigger WatchInsertModel" << itor->first << ";" << std::ends;
194 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
197 sstream << "drop trigger WatchUpdateModel" << itor->first << ";" << std::ends;
198 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
202 if (strlen(LOCATION_SSM_DB_DUMP) > 0)
204 CHK_SQLITE(sqlite3_open(LOCATION_SSM_DB_DUMP, &pBackupFile), SQLITE_OK);
205 pBackup = sqlite3_backup_init(pBackupFile, "main", m_pSQLite3, "main");
206 CHK_SQLITE(sqlite3_errcode(pBackupFile), SQLITE_OK);
207 SSM_CLEANUP_NULL_ASSERT(pBackup);
208 CHK_SQLITE(sqlite3_backup_step(pBackup, -1), SQLITE_DONE);
209 CHK_SQLITE(sqlite3_backup_finish(pBackup), SQLITE_OK);
210 CHK_SQLITE(sqlite3_close(pBackupFile), SQLITE_OK);
213 CHK_SQLITE(sqlite3_close(m_pSQLite3), SQLITE_OK);
220 m_mtxTriggerId.unlock();
224 SSMRESULT CEvaluationEngine::createModel(int parentModelId, const char *newModelName,
225 ModelPropertyVec *pModelDescs, int *pModelId)
227 SSMRESULT res = SSM_E_FAIL;
228 std::stringstream sstream;
230 sqlite3_stmt *stmt = NULL;
233 //Check if same name exists
234 sstream << "select modelId from [ModelRelation] where modelName='" << newModelName << "';" <<
236 strSQL = sstream.str();
237 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
238 if (sqlite3_step(stmt) == SQLITE_ROW)
240 *pModelId = sqlite3_column_int(stmt, 0);
241 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
245 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
248 sstream << "select lPos from [ModelRelation] where modelId = '" << parentModelId << "';" <<
250 SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), &lPos));
253 sstream << "update [ModelRelation] set rPos = rPos + 2 where rPos > " << lPos << ";" << std::ends;
254 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
257 sstream << "update [ModelRelation] set lPos = lPos + 2 where lPos > " << lPos << ";" << std::ends;
258 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
261 sstream << "insert into [ModelRelation] values (null, '" << newModelName << "', " << lPos + 1 <<
264 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
267 SSM_CLEANUP_ASSERT(executeSQL_IntReturn("select last_insert_rowid();", pModelId));
269 sstream << "create table [ModelData" << *pModelId <<
270 "](dataId integer primary key autoincrement, lastTime NOT NULL DEFAULT CURRENT_TIMESTAMP, lifetime integer NOT NULL DEFAULT 2147483647, available text DEFAULT 'true'";
272 for (ModelPropertyVec::iterator itor =
273 pModelDescs->begin(); itor != pModelDescs->end(); ++itor)
275 sstream << "," << itor->propertyName;
276 switch (itor->propertyType)
278 case ModelProperty::TYPE_NUMERIC:
279 sstream << " numeric";
282 case ModelProperty::TYPE_INTEGER:
283 sstream << " integer";
286 case ModelProperty::TYPE_REAL:
290 case ModelProperty::TYPE_TEXT:
295 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
299 sstream << ");" << std::ends;
301 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
307 SSMRESULT CEvaluationEngine::addModelData(int modelId, int parentModelId, int parentDataId,
308 ModelPropertyVec *pModelValues, int *pDataId)
310 SSMRESULT res = SSM_E_FAIL;
311 std::stringstream sstream;
313 sqlite3_stmt *stmt = NULL;
317 sstream << "insert into [ModelData" << modelId << "] (";
319 for (ModelPropertyVec::iterator itor = pModelValues->begin();
320 itor != pModelValues->end(); ++itor)
322 sstream << itor->propertyName;
324 if (itor < pModelValues->end() - 1)
330 sstream << ") values (";
332 for (i = 0; i < pModelValues->size(); i++)
336 if (i < pModelValues->size() - 1)
342 sstream << ");" << std::ends;
344 strSQL = sstream.str();
345 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
349 for (ModelPropertyVec::iterator itor = pModelValues->begin();
350 itor != pModelValues->end(); ++itor)
352 switch (itor->propertyType)
354 case ModelProperty::TYPE_NUMERIC:
355 case ModelProperty::TYPE_INTEGER:
356 CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);
359 case ModelProperty::TYPE_REAL:
360 CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);
363 case ModelProperty::TYPE_TEXT:
364 CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),
365 SQLITE_STATIC), SQLITE_OK);
369 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
375 m_mtxDataRelation.lock();
377 CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);
379 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
381 SSM_CLEANUP_ASSERT(executeSQL_IntReturn("select last_insert_rowid();", pDataId));
383 sstream << "select lPos from [DataRelation] where modelId = " << parentModelId << " and dataId = "
384 << parentDataId << ";" << std::ends;
385 SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), &lPos));
388 sstream << "update [DataRelation] set rPos = rPos + 2 where rPos > " << lPos << ";" << std::ends;
389 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
392 sstream << "update [DataRelation] set lPos = lPos + 2 where lPos > " << lPos << ";" << std::ends;
393 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
396 sstream << "insert into [DataRelation] values (null, " << modelId << ", " << lPos + 1 << ", " <<
398 ", " << *pDataId << ");" << std::ends;
399 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
402 m_mtxDataRelation.unlock();
406 SSMRESULT CEvaluationEngine::updateModelData(int modelId, int dataId,
407 ModelPropertyVec *pModelValues)
409 SSMRESULT res = SSM_E_FAIL;
410 std::stringstream sstream;
412 sqlite3_stmt *stmt = NULL;
415 sstream << "update [ModelData" << modelId << "] set lastTime=CURRENT_TIMESTAMP, ";
417 for (ModelPropertyVec::iterator itor = pModelValues->begin();
418 itor != pModelValues->end(); ++itor)
420 sstream << itor->propertyName << "=?";
422 if (itor < pModelValues->end() - 1)
428 sstream << " where dataId = " << dataId << ";" << std::ends;
430 strSQL = sstream.str();
431 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
433 for (ModelPropertyVec::iterator itor = pModelValues->begin();
434 itor != pModelValues->end(); ++itor)
436 switch (itor->propertyType)
438 case ModelProperty::TYPE_NUMERIC:
439 case ModelProperty::TYPE_INTEGER:
440 CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);
443 case ModelProperty::TYPE_REAL:
444 CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);
447 case ModelProperty::TYPE_TEXT:
448 CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),
449 SQLITE_STATIC), SQLITE_OK);
453 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
459 CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);
461 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
469 SSMRESULT CEvaluationEngine::DeleteModel(int modelId)
471 SSMRESULT res = SSM_E_FAIL;
472 std::stringstream sstream;
474 sqlite3_stmt *stmt = NULL;
480 sstream << "select lPos, rPos from [ModelRelation] where modelId = " << modelId << ";" << std::ends;
482 strSQL = sstream.str();
484 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
485 CHK_SQLITE(sqlite3_step(stmt), SQLITE_ROW);
486 lPos = sqlite3_column_int(stmt, 0);
487 rPos = sqlite3_column_int(stmt, 1);
488 width = rPos - lPos + 1;
489 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
491 sstream << "delete from [ModelRelation] where lPos between " << lPos << " and " << rPos <<
492 ";update [ModelRelation] set rPos = rPos - " << width << " where rPos > " << rPos <<
493 ";update [ModelRelation] set lPos = lPos - " << width << " where lPos > " << lPos << std::ends;
494 CHK_SSMRESULT(ExecuteSQL_NoReturn(sstream.str()));
497 sstream << "select dataId from [DataRelation] where modelId = " << modelId << ";" << std::ends;
498 strSQL = sstream.str();
499 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
500 while(sqlite3_step(stmt) == SQLITE_ROW)
502 dataIds.push_back(sqlite3_column_int(stmt, 0));
504 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
506 for(std::vector<int>::iterator itor = dataIds.begin();
507 itor != dataIds.end(); ++itor)
509 CHK_SSMRESULT(DeleteModelData(modelId, *itor));
516 SSMRESULT CEvaluationEngine::deleteModelData(int modelId, int dataId)
518 SSMRESULT res = SSM_E_FAIL;
519 std::stringstream sstream;
521 sqlite3_stmt *stmt = NULL;
526 m_mtxDataRelation.lock();
528 sstream << "select lPos, rPos from [DataRelation] where modelId = " << modelId << " and dataId = "
529 << dataId << ";" << std::ends;
531 strSQL = sstream.str();
533 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
534 CHK_SQLITE(sqlite3_step(stmt), SQLITE_ROW);
535 lPos = sqlite3_column_int(stmt, 0);
536 rPos = sqlite3_column_int(stmt, 1);
537 width = rPos - lPos + 1;
538 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
540 sstream << "delete from [DataRelation] where lPos between " << lPos << " and " << rPos << ";" <<
542 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
545 sstream << "update [DataRelation] set rPos = rPos - " << width << " where rPos > " << rPos << ";" <<
547 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
550 sstream << "update [DataRelation] set lPos = lPos - " << width << " where lPos > " << lPos << ";" <<
552 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
555 sstream << "delete from [ModelData" << modelId << "] where dataId = " << dataId << ";" << std::ends;
556 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
559 m_mtxDataRelation.unlock();
563 SSMRESULT CEvaluationEngine::getModelDataSet(int modelId, int startIndex, int count,
564 std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex)
566 SSMRESULT res = SSM_E_FAIL;
567 std::stringstream sstream;
570 sqlite3_stmt *stmt = NULL;
571 const char *textData = NULL;
573 sstream << "select * from [ModelData" << modelId << "] where dataId > " << startIndex << " limit "
574 << count << ";" << std::ends;
576 strSQL = sstream.str();
577 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
580 while (sqlite3_step(stmt) == SQLITE_ROW)
582 ModelPropertyVec modelProperties;
584 columnCount = sqlite3_column_count(stmt);
585 for (int i = 0; i < columnCount; i++)
587 ModelProperty modelData;
588 switch (sqlite3_column_type(stmt, i))
591 modelData.propertyType = ModelProperty::TYPE_INTEGER;
593 sstream << sqlite3_column_int(stmt, i) << std::ends;
594 modelData.propertyValue = sstream.str();
598 modelData.propertyType = ModelProperty::TYPE_REAL;
600 sstream << sqlite3_column_double(stmt, i) << std::ends;
601 modelData.propertyValue = sstream.str();
606 modelData.propertyType = ModelProperty::TYPE_TEXT;
607 textData = (const char *)sqlite3_column_text(stmt, i);
608 if (textData != NULL)
610 modelData.propertyValue = textData;
615 modelData.propertyType = ModelProperty::TYPE_TEXT;
616 textData = (const char *)sqlite3_column_text(stmt, i);
617 if (textData != NULL)
619 modelData.propertyValue = textData;
623 modelProperties.push_back(modelData);
626 pDataSet->push_back(modelProperties);
627 *pLastIndex = sqlite3_column_int(stmt, 0);
630 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
638 SSMRESULT CEvaluationEngine::getModelData(int modelId, int dataId,
639 ModelPropertyVec *pModelProperties)
641 SSMRESULT res = SSM_E_FAIL;
642 std::stringstream sstream;
645 sqlite3_stmt *stmt = NULL;
646 const char *textData = NULL;
648 sstream << "select * from [ModelData" << modelId << "] where dataId=" << dataId << ";" << std::ends;
650 strSQL = sstream.str();
651 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
653 while (sqlite3_step(stmt) == SQLITE_ROW)
655 columnCount = sqlite3_column_count(stmt);
656 for (int i = 0; i < columnCount; i++)
658 ModelProperty modelData;
659 switch (sqlite3_column_type(stmt, i))
662 modelData.propertyType = ModelProperty::TYPE_INTEGER;
664 sstream << sqlite3_column_int(stmt, i) << std::ends;
665 modelData.propertyValue = sstream.str();
669 modelData.propertyType = ModelProperty::TYPE_REAL;
671 sstream << sqlite3_column_double(stmt, i) << std::ends;
672 modelData.propertyValue = sstream.str();
677 modelData.propertyType = ModelProperty::TYPE_TEXT;
678 textData = (const char *)sqlite3_column_text(stmt, i);
679 if (textData != NULL)
681 modelData.propertyValue = textData;
686 modelData.propertyType = ModelProperty::TYPE_TEXT;
687 textData = (const char *)sqlite3_column_text(stmt, i);
688 if (textData != NULL)
690 modelData.propertyValue = textData;
694 pModelProperties->push_back(modelData);
698 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
705 SSMRESULT CEvaluationEngine::GetModelSchema(int modelId, ModelPropertyVec *pModelProperties)
707 SSMRESULT res = SSM_E_FAIL;
708 std::stringstream sstream;
710 sqlite3_stmt *stmt = NULL;
711 std::string propertyType;
713 sstream << "pragma table_info('ModelData" << modelId << "');" << std::ends;
715 strSQL = sstream.str();
716 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
718 while(sqlite3_step(stmt) == SQLITE_ROW)
720 ModelProperty modelData;
721 modelData.propertyName = (const char*)sqlite3_column_text(stmt, 1);
722 propertyType = (const char*)sqlite3_column_text(stmt, 2);
724 if(propertyType == "integer")
726 modelData.propertyType = ModelProperty::Type_INTEGER;
728 else if(propertyType == "int")
730 modelData.propertyType = ModelProperty::Type_INTEGER;
732 else if(propertyType == "real")
734 modelData.propertyType = ModelProperty::Type_REAL;
736 else if(propertyType == "text")
738 modelData.propertyType = ModelProperty::Type_TEXT;
742 modelData.propertyType = ModelProperty::Type_TEXT;
744 pModelProperties->push_back(modelData);
747 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
754 SSMRESULT CEvaluationEngine::getConditionedModelData(int modelId,
755 ModelConditionVec *pModelConditions, IntVec *pDataIds)
757 SSMRESULT res = SSM_E_FAIL;
758 std::stringstream sstream;
760 sqlite3_stmt *stmt = NULL;
762 sstream << "select dataId from [ModelData" << modelId <<
763 "] where CURRENT_TIMESTAMP < datetime( strftime('%s', lastTime) + lifetime, 'unixepoch') and ";
765 for (ModelConditionVec::iterator itor = pModelConditions->begin();
766 itor != pModelConditions->end(); ++itor)
768 sstream << itor->modelProperty.propertyName;
769 switch (itor->predicate)
771 case ModelCondition::PREDICATE_EQ:
775 case ModelCondition::PREDICATE_NEQ:
779 case ModelCondition::PREDICATE_GT:
783 case ModelCondition::PREDICATE_LT:
787 case ModelCondition::PREDICATE_GTE:
791 case ModelCondition::PREDICATE_LTE:
796 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
799 switch (itor->modelProperty.propertyType)
801 case ModelProperty::TYPE_NUMERIC:
802 case ModelProperty::TYPE_INTEGER:
803 case ModelProperty::TYPE_REAL:
804 sstream << itor->modelProperty.propertyValue;
807 case ModelProperty::TYPE_TEXT:
808 sstream << "'" << itor->modelProperty.propertyValue << "'";
812 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
815 if (itor < pModelConditions->end() - 1)
821 sstream << ";" << std::ends;
823 strSQL = sstream.str();
824 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
826 while (sqlite3_step(stmt) == SQLITE_ROW)
828 pDataIds->push_back(sqlite3_column_int(stmt, 0));
831 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
839 SSMRESULT CEvaluationEngine::watchModelData(int modelId, ModelConditionVec *pModelConditions,
840 IEvaluationEngineEvent *pEvaluationEngineEvent, int *pTriggerId)
842 SSMRESULT res = SSM_E_FAIL;
843 std::stringstream sstream;
844 std::stringstream sstreamCondition;
846 for (ModelConditionVec::iterator itor = pModelConditions->begin();
847 itor != pModelConditions->end(); ++itor)
849 sstreamCondition << "NEW." << itor->modelProperty.propertyName;
850 switch (itor->predicate)
852 case ModelCondition::PREDICATE_EQ:
853 sstreamCondition << "=";
856 case ModelCondition::PREDICATE_NEQ:
857 sstreamCondition << "!=";
860 case ModelCondition::PREDICATE_GT:
861 sstreamCondition << ">";
864 case ModelCondition::PREDICATE_LT:
865 sstreamCondition << "<";
868 case ModelCondition::PREDICATE_GTE:
869 sstreamCondition << ">=";
872 case ModelCondition::PREDICATE_LTE:
873 sstreamCondition << "<=";
877 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
880 switch (itor->modelProperty.propertyType)
882 case ModelProperty::TYPE_NUMERIC:
883 case ModelProperty::TYPE_INTEGER:
884 case ModelProperty::TYPE_REAL:
885 sstreamCondition << itor->modelProperty.propertyValue;
888 case ModelProperty::TYPE_TEXT:
889 sstreamCondition << "'" << itor->modelProperty.propertyValue << "'";
893 SSM_CLEANUP_ASSERT(SSM_E_FAIL);
896 if (itor < pModelConditions->end() - 1)
898 sstreamCondition << " and ";
902 sstreamCondition << std::ends;
904 m_mtxDataRelation.lock();
906 sstream << "CREATE TRIGGER WatchInsertModel" << m_iTriggerId << " AFTER INSERT ON [ModelData" <<
907 modelId << "] WHEN ";
908 sstream << sstreamCondition.str().c_str() << " BEGIN SELECT OnSQLTrigger(" <<
909 reinterpret_cast<intptr_t>(this) << ", " << m_iTriggerId << ", NEW.dataId); END;" << std::ends;
910 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
913 sstream << "CREATE TRIGGER WatchUpdateModel" << m_iTriggerId << " AFTER UPDATE ON [ModelData" <<
914 modelId << "] WHEN ";
915 sstream << sstreamCondition.str().c_str() << " BEGIN SELECT OnSQLTrigger(" <<
916 reinterpret_cast<intptr_t>(this) << ", " << m_iTriggerId << ", NEW.dataId); END;" << std::ends;
917 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
919 m_mtxTriggerId.lock();
920 pEvaluationEngineEvent->addRef();
921 m_mapTriggers[m_iTriggerId] = pEvaluationEngineEvent;
922 *pTriggerId = m_iTriggerId++;
925 m_mtxTriggerId.unlock();
926 m_mtxDataRelation.unlock();
930 SSMRESULT CEvaluationEngine::dropWatchModelData(int triggerId)
932 SSMRESULT res = SSM_E_FAIL;
933 std::stringstream sstream;
935 m_mtxDataRelation.lock();
937 sstream << "drop trigger WatchInsertModel" << triggerId << ";" << std::ends;
938 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
941 sstream << "drop trigger WatchUpdateModel" << triggerId << ";" << std::ends;
942 SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));
944 m_mtxTriggerId.lock();
945 m_mapTriggers[triggerId]->release();
946 m_mapTriggers.erase(triggerId);
949 m_mtxTriggerId.unlock();
950 m_mtxDataRelation.unlock();
954 SSMRESULT CEvaluationEngine::getParentDataId(int modelId, int dataId, int parentModelId,
957 SSMRESULT res = SSM_E_FAIL;
958 std::stringstream sstream;
961 "select parent.dataId from [DataRelation] as node, [DataRelation] as parent where parent.modelId="
963 parentModelId << " and node.modelId=" << modelId << " and node.dataId=" <<
964 dataId << " and node.lPos between parent.lPos and parent.rPos;" << std::ends;
966 m_mtxDataRelation.lock();
967 SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), pParentDataId));
970 m_mtxDataRelation.unlock();
974 SSMRESULT CEvaluationEngine::getChildDataId(int modelId, int dataId, int ChildModelId,
975 IntVec *pChildDataIds)
977 SSMRESULT res = SSM_E_FAIL;
978 std::stringstream sstream;
980 sqlite3_stmt *stmt = NULL;
983 "select child.dataId from [DataRelation] as node, [DataRelation] as child where child.modelId=" <<
984 ChildModelId << " and node.modelId=" << modelId << " and node.dataId=" <<
985 dataId << " and child.lPos between node.lPos and node.rPos order by child.dataId;" << std::ends;
987 strSQL = sstream.str();
990 m_mtxDataRelation.lock();
991 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
993 while (sqlite3_step(stmt) == SQLITE_ROW)
995 pChildDataIds->push_back(sqlite3_column_int(stmt, 0));
998 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
1002 m_mtxDataRelation.unlock();
1006 SSMRESULT CEvaluationEngine::GetPathToRoot(int currentModelId, IntVec *pPath)
1008 SSMRESULT res = SSM_E_FAIL;
1009 std::stringstream sstream;
1011 sqlite3_stmt *stmt = NULL;
1013 sstream << "select parent.modelId from [ModelRelation] as node, [ModelRelation] as parent where " <<
1014 "node.lPos between parent.lPos and parent.rPos and node.modelId = " << currentModelId << " order by node.lPos;" << std::ends;
1016 strSQL = sstream.str();
1018 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
1020 while(sqlite3_step(stmt) == SQLITE_ROW)
1022 pPath->push_back(sqlite3_column_int(stmt, 0));
1025 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
1032 SSMRESULT CEvaluationEngine::GetModelId(const char *modelName, int *pModelId)
1034 SSMRESULT res = SSM_E_FAIL;
1035 std::stringstream sstream;
1037 sstream << "select modelId from [ModelRelation] where modelName = '" << modelName << "';" << std::ends;
1039 CHK_SSMRESULT(ExecuteSQL_IntReturn(sstream.str(), pModelId));
1045 SSMRESULT CEvaluationEngine::GetModelHierarchy(int rootModelId, StringVec *pPath)
1047 SSMRESULT res = SSM_E_FAIL;
1048 std::stringstream sstream;
1050 sqlite3_stmt *stmt = NULL;
1051 StringVec lastModels;
1055 sstream << "select node.modelName, (COUNT(parent.modelName) - (sub_tree.depth + 1)) as depth from [ModelRelation] as node, "\
1056 "[ModelRelation] as parent, [ModelRelation] as sub_parent, (select node.modelName, (count(parent.modelName) - 1) as depth from "\
1057 "[ModelRelation] as node, [ModelRelation] as parent where node.lPos between parent.lPos and parent.rPos and node.modelId = " << rootModelId <<
1058 " group by node.lPos, node.modelName) as sub_tree where node.lPos between parent.lPos and parent.rPos and node.lPos between "<<
1059 "sub_parent.lPos and sub_parent.rPos and sub_parent.modelName = sub_tree.modelName group by node.lPos, node.modelName, sub_tree.depth " <<
1060 "order by node.lPos;" << std::ends;
1062 strSQL = sstream.str();
1064 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
1066 while(sqlite3_step(stmt) == SQLITE_ROW)
1068 currIndex = sqlite3_column_int(stmt, 1);
1070 if(currIndex < lastIndex)
1073 for(int i=0; i < lastIndex - currIndex + 1; i++)
1075 lastModels.pop_back();
1079 lastModels.push_back((const char*)sqlite3_column_text(stmt, 0));
1081 for(StringVec::iterator itor = lastModels.begin();
1082 itor != lastModels.end(); ++itor)
1086 if(itor < lastModels.end() - 1)
1092 sstream << std::ends;
1094 pPath->push_back(sstream.str());
1098 lastIndex = currIndex;
1101 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);
1108 SSMRESULT CEvaluationEngine::GetDataHierarchy(int rootModelId, int dataId, StringVec *pPath)
1110 SSMRESULT res = SSM_E_FAIL;
1111 std::stringstream sstream;
1113 sqlite3_stmt *stmt = NULL;
1115 sstream << "select [ModelRelation].modelName, node.dataId, (COUNT(parent.modelId) - (sub_tree.depth + 1)) as depth "\
1116 "from [ModelRelation], [DataRelation] as node, [DataRelation] as parent, [DataRelation] as sub_parent, "\
1117 "(select node.modelId, (count(parent.modelId) - 1) as depth from [DataRelation] as node, [DataRelation] as parent "\
1118 "where node.lPos between parent.lPos and parent.rPos and node.modelId = " << rootModelId <<
1119 " and node.dataId = " << dataId << " group by node.lPos, node.modelId) as sub_tree "\
1120 "where node.lPos between parent.lPos and parent.rPos and node.lPos between sub_parent.lPos and sub_parent.rPos and "\
1121 "sub_parent.modelId = sub_tree.modelId and [ModelRelation].modelId = node.modelId "\
1122 "group by node.lPos, [ModelRelation].modelName, node.dataId, sub_tree.depth order by node.lPos;" << std::ends;
1124 strSQL = sstream.str();
1126 CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);
1128 while(sqlite3_step(stmt) == SQLITE_ROW)
1130 sstream << sqlite3_column_text(stmt, 0) << " " << sqlite3_column_int(stmt, 1) << " " << sqlite3_column_int(stmt, 2) << std::ends;
1131 pPath->push_back(sstream.str());
1135 CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);