void OpenStudioAlgorithmRecord_Impl::saveRow(const std::shared_ptr<QSqlDatabase> &database) { QSqlQuery query(*database); this->makeUpdateByIdQuery<OpenStudioAlgorithmRecord>(query); this->bindValues(query); assertExec(query); }
void DakotaAlgorithmRecord_Impl::saveRow(const boost::shared_ptr<QSqlDatabase> &database) { QSqlQuery query(*database); this->makeUpdateByIdQuery<DakotaAlgorithmRecord>(query); this->bindValues(query); assertExec(query); }
void ProjectDatabaseRecord_Impl::saveRow(const std::shared_ptr<QSqlDatabase> &database) { QSqlQuery query(*database); this->makeUpdateByIdQuery<ProjectDatabaseRecord>(query); this->bindValues(query); assertExec(query); }
std::vector<VariableRecord> FunctionRecord_Impl::variableRecords() const { VariableRecordVector result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() + " WHERE functionRecordId=:functionRecordId ORDER BY variableVectorIndex")); query.bindValue(":functionRecordId",id()); assertExec(query); OptionalInt previousIndex; bool resort(false); while (query.next()) { result.push_back(VariableRecord::factoryFromQuery(query, database).get()); int index = result.back().variableVectorIndex(); if (previousIndex) { if (index <= previousIndex.get()) { resort = true; // if variables are changed around, order in database itself can // get out of date (as compared to database + dirty records). } } previousIndex = index; } if (resort) { VariableRecordVariableVectorIndexLess comparator; std::sort(result.begin(),result.end(),comparator); } return result; }
void OutputAttributeVariableRecord_Impl::saveRow(const boost::shared_ptr<QSqlDatabase> &database) { QSqlQuery query(*database); this->makeUpdateByIdQuery<OutputAttributeVariableRecord>(query); this->bindValues(query); assertExec(query); }
void ObjectRecord::createIndices(QSqlDatabase& qSqlDatabase, const std::string& databaseTableName) { // id is already indexed due to primary key modifier QSqlQuery query(qSqlDatabase); query.prepare(toQString("CREATE INDEX " + databaseTableName + "handleindex ON " + databaseTableName + " (handle)")); assertExec(query); }
std::vector<UrlRecord> UrlRecord::getUrlRecords(ProjectDatabase& database) { std::vector<UrlRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + UrlRecord::databaseTableName())); assertExec(query); while (query.next()) { result.push_back(UrlRecord(query, database)); } return result; }
std::vector<WorkflowRecord> WorkflowRecord::getWorkflowRecords(ProjectDatabase& projectDatabase) { std::vector<WorkflowRecord> result; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName())); assertExec(query); while (query.next()) { result.push_back(projectDatabase.getFromQuery<WorkflowRecord>(query)); } return result; }
std::vector<VagrantSessionRecord> VagrantSessionRecord::getVagrantSessionRecords(ProjectDatabase& database) { std::vector<VagrantSessionRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + CloudSessionRecord::databaseTableName() + " WHERE cloudSessionRecordType=:cloudSessionRecordType")); query.bindValue(":cloudSessionRecordType", CloudSessionRecordType::VagrantSessionRecord); assertExec(query); while (query.next()) { result.push_back(VagrantSessionRecord(query, database)); } return result; }
boost::optional<FunctionRecord> FunctionRecord::getFunctionRecord(int id, ProjectDatabase& database) { boost::optional<FunctionRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName() + " WHERE id=:id")); query.bindValue(":id",id); assertExec(query); if (query.first()) { result = FunctionRecord::factoryFromQuery(query, database); } return result; }
boost::optional<OpenStudioAlgorithmRecord> OpenStudioAlgorithmRecord::getOpenStudioAlgorithmRecord(int id, ProjectDatabase& database) { boost::optional<OpenStudioAlgorithmRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + AlgorithmRecord::databaseTableName() + " WHERE algorithmRecordType=:algorithmRecordType AND id=:id")); query.bindValue(":algorithmRecordType", AlgorithmRecordType::OpenStudioAlgorithmRecord); query.bindValue(":id",id); assertExec(query); if (query.first()) { result = OpenStudioAlgorithmRecord::factoryFromQuery(query, database); } return result; }
boost::optional<WorkflowRecord> WorkflowRecord::getWorkflowRecord(int id, ProjectDatabase& projectDatabase) { boost::optional<WorkflowRecord> result; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName() + " WHERE id=:id")); query.bindValue(":id", id); assertExec(query); if (query.first()) { result = projectDatabase.getFromQuery<WorkflowRecord>(query); } return result; }
boost::optional<VagrantSessionRecord> VagrantSessionRecord::getVagrantSessionRecord(int id, ProjectDatabase& database) { boost::optional<VagrantSessionRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + CloudSessionRecord::databaseTableName() + " WHERE cloudSessionRecordType=:cloudSessionRecordType AND id=:id")); query.bindValue(":cloudSessionRecordType", CloudSessionRecordType::VagrantSessionRecord); query.bindValue(":id",id); assertExec(query); if (query.first()) { result = VagrantSessionRecord(query, database); } return result; }
std::vector<AttributeRecord> InputVariableRecord_Impl::attributeRecords() const { AttributeRecordVector result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + AttributeRecord::databaseTableName() + " WHERE variableRecordId=:variableRecordId")); query.bindValue(":variableRecordId",id()); assertExec(query); while (query.next()) { result.push_back(database.getFromQuery<AttributeRecord>(query)); } return result; }
static boost::optional<T> getJoinRecord(int leftId, int rightId, ProjectDatabase projectDatabase) { boost::optional<T> result; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE leftId=:leftId AND rightId=:rightId")); query.bindValue(":leftId", leftId); query.bindValue(":rightId", rightId); assertExec(query); if(query.first()){ result = T(boost::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase); } return result; }
std::vector<CloudSettingsRecord> CloudSettingsRecord::getCloudSettingsRecords(ProjectDatabase& database) { std::vector<CloudSettingsRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + CloudSettingsRecord::databaseTableName())); assertExec(query); while (query.next()) { OptionalCloudSettingsRecord cloudSettingsRecord = CloudSettingsRecord::factoryFromQuery(query, database); if (cloudSettingsRecord) { result.push_back(*cloudSettingsRecord); } } return result; }
boost::optional<ActionClauseRecord> ActionClauseRecord::getActionClauseRecord(int id, ProjectDatabase& database) { boost::optional<ActionClauseRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + ClauseRecord::databaseTableName() + " WHERE id=:id AND clauseRecordType=:clauseRecordType")); query.bindValue(":id", id); query.bindValue(":clauseRecordType", ClauseRecordType::ActionClauseRecord); assertExec(query); if (query.first()) { result = factoryFromQuery(query, database); } return result; }
std::vector<VariableRecord> VariableRecord::getVariableRecords(ProjectDatabase& database) { std::vector<VariableRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName())); assertExec(query); while (query.next()) { boost::optional<VariableRecord> variable = factoryFromQuery(query, database); OS_ASSERT(variable); result.push_back(*variable); } return result; }
boost::optional<InputVariableRecord> InputVariableRecord::getInputVariableRecord(int id, ProjectDatabase& database) { boost::optional<InputVariableRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() + " WHERE variableRecordType=:variableRecordType AND id=:id")); query.bindValue(":variableRecordType", VariableRecordType::InputVariableRecord); query.bindValue(":id",id); assertExec(query); if (query.first()) { result = InputVariableRecord::factoryFromQuery(query, database); } return result; }
std::vector<FunctionRecord> FunctionRecord::getFunctionRecords(ProjectDatabase& database) { std::vector<FunctionRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName())); assertExec(query); while (query.next()) { OptionalFunctionRecord functionRecord = FunctionRecord::factoryFromQuery(query, database); if (functionRecord) { result.push_back(*functionRecord); } } return result; }
std::vector<RulesetRecord> RulesetRecord::getRulesetRecords(ProjectDatabase& database) { std::vector<RulesetRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + RulesetRecord::databaseTableName())); assertExec(query); while (query.next()) { boost::optional<RulesetRecord> rulesetRecord = factoryFromQuery(query, database); BOOST_ASSERT(rulesetRecord); result.push_back(*rulesetRecord); } return result; }
static std::vector<T> getJoinRecordsForLeftId(int leftId, ProjectDatabase projectDatabase) { std::vector<T> result; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE leftId=:leftId")); query.bindValue(":leftId", leftId); assertExec(query); while(query.next()){ T object(boost::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase); result.push_back(object); } return result; }
std::vector<FSUDaceAlgorithmRecord> FSUDaceAlgorithmRecord::getFSUDaceAlgorithmRecords(ProjectDatabase& database) { std::vector<FSUDaceAlgorithmRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + AlgorithmRecord::databaseTableName() + " WHERE algorithmRecordType=:algorithmRecordType AND " + "dakotaAlgorithmRecordType=:dakotaAlgorithmRecordType")); query.bindValue(":dakotaAlgorithmRecordType", DakotaAlgorithmRecordType::FSUDaceAlgorithmRecord); assertExec(query); while (query.next()) { result.push_back(FSUDaceAlgorithmRecord(query, database)); } return result; }
OSArgumentRecord RubyContinuousVariableRecord_Impl::osArgumentRecord() const { OptionalOSArgumentRecord result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + OSArgumentRecord::databaseTableName() + " WHERE rubyContinuousVariableRecordId=:rubyContinuousVariableRecordId" )); query.bindValue(":rubyContinuousVariableRecordId",id()); assertExec(query); if (query.first()) { result = OSArgumentRecord::factoryFromQuery(query, database); } OS_ASSERT(result); return *result; }
boost::optional<MeasureRecord> MeasureRecord::getMeasureRecord(int id, ProjectDatabase& database) { boost::optional<MeasureRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() + " WHERE id=:id")); query.bindValue(":id", id); assertExec(query); if(query.first()) { boost::optional<MeasureRecord> measure = factoryFromQuery(query, database); OS_ASSERT(measure); result = measure; } return result; }
static bool unlink(int leftId, int rightId, ProjectDatabase projectDatabase) { bool result = false; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE leftId=:leftId AND rightId=:rightId")); query.bindValue(":leftId", leftId); query.bindValue(":rightId", rightId); assertExec(query); if (query.first()){ T object(std::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase); result = projectDatabase.removeRecord(object); } return result; }
std::vector<DesignOfExperimentsRecord> DesignOfExperimentsRecord::getDesignOfExperimentsRecords(ProjectDatabase& database) { std::vector<DesignOfExperimentsRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + AlgorithmRecord::databaseTableName() + " WHERE algorithmRecordType=:algorithmRecordType AND " + "openStudioAlgorithmRecordType=:openStudioAlgorithmRecordType")); query.bindValue(":algorithmRecordType", AlgorithmRecordType::OpenStudioAlgorithmRecord); query.bindValue(":openStudioAlgorithmRecordType", OpenStudioAlgorithmRecordType::DesignOfExperimentsRecord); assertExec(query); while (query.next()) { result.push_back(DesignOfExperimentsRecord(query, database)); } return result; }
std::vector<DakotaAlgorithmRecord> DakotaAlgorithmRecord::getDakotaAlgorithmRecords(ProjectDatabase& database) { std::vector<DakotaAlgorithmRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + AlgorithmRecord::databaseTableName() + " WHERE algorithmRecordType=:algorithmRecordType")); query.bindValue(":algorithmRecordType", AlgorithmRecordType::DakotaAlgorithmRecord); assertExec(query); while (query.next()) { OptionalDakotaAlgorithmRecord dakotaAlgorithmRecord = DakotaAlgorithmRecord::factoryFromQuery(query, database); if (dakotaAlgorithmRecord) { result.push_back(*dakotaAlgorithmRecord); } } return result; }
boost::optional<T> getObjectRecordByName(const std::string& name) { boost::optional<T> result; QSqlQuery query(*(this->qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + T::ObjectRecordType::databaseTableName() + " WHERE name=:name")); query.bindValue(":name",toQString(name)); try { assertExec(query); if (query.first()) { result = this->template getFromQuery<T>(query); } } catch (const std::exception& e) { LOG(Error,"Unable to execute getObjectRecordByName query, because '" << e.what() << "'."); } return result; }
std::vector<InputVariableRecord> InputVariableRecord::getInputVariableRecords(ProjectDatabase& database) { std::vector<InputVariableRecord> result; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() + " WHERE variableRecordType=:variableRecordType")); query.bindValue(":variableRecordType", VariableRecordType::InputVariableRecord); assertExec(query); while (query.next()) { OptionalInputVariableRecord inputVariableRecord = InputVariableRecord::factoryFromQuery(query, database); if (inputVariableRecord) { result.push_back(*inputVariableRecord); } } return result; }