std::vector<UrlRecord> CloudSessionRecord_Impl::workerUrlRecords() const { UrlRecordVector result; // return UrlRecords for which this CloudSessionRecord is the parent and the id is not // equal to m_serverUrlRecordId. ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); std::stringstream ss; ss << "SELECT * FROM " << UrlRecord::databaseTableName(); ss << " WHERE parentDatabaseTableName=:parentDatabaseTableName AND "; ss << "parentRecordId=:parentRecordId"; if (m_serverUrlRecordId) { ss << " AND (NOT id=:id)"; } query.prepare(toQString(ss.str())); query.bindValue(":parentDatabaseTableName",toQString(databaseTableName())); query.bindValue(":parentRecordId",id()); if (m_serverUrlRecordId) { query.bindValue(":id",*m_serverUrlRecordId); } assertExec(query); while (query.next()) { UrlRecord workerUrlRecord(query,database); result.push_back(workerUrlRecord); } return result; }
std::vector<WorkflowRecord> ProblemRecord_Impl::workflowRecords() const { WorkflowRecordVector result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName() + " WHERE problemRecordId=:problemRecordId ORDER BY workflowIndex")); query.bindValue(":problemRecordId",id()); assertExec(query); OptionalInt previousIndex; bool resort(false); while (query.next()) { result.push_back(WorkflowRecord::factoryFromQuery(query, database).get()); int index = result.back().workflowIndex(); if (previousIndex) { if (index < previousIndex.get()) { resort = true; } } previousIndex = index; } if (resort) { WorkflowRecordWorkflowIndexLess comparator; std::sort(result.begin(),result.end(),comparator); } return result; }
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; }
MeasureRecord MeasureGroupRecord_Impl::getMeasureRecord(int measureVectorIndex) const { ProjectDatabase database = this->projectDatabase(); OptionalMeasureRecord candidate; QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() + " WHERE variableRecordId=:variableRecordId AND measureVectorIndex=:measureVectorIndex")); query.bindValue(":variableRecordId", this->id()); query.bindValue(":measureVectorIndex", measureVectorIndex); assertExec(query); if (query.first()) { candidate = MeasureRecord::factoryFromQuery(query,database).get(); } // check actual vector index. can get out of date during construction. if ((!candidate) || (!candidate->measureVectorIndex()) || (candidate->measureVectorIndex().get() != measureVectorIndex)) { // get all and look for index by hand for (const MeasureRecord& dpr : measureRecords(false)) { if (dpr.measureVectorIndex() && (dpr.measureVectorIndex().get() == measureVectorIndex)) { return dpr; } } } else { return *candidate; } LOG_AND_THROW("Invalid DiscretMeasure measureVectorIndex " << measureVectorIndex << " for MeasureGroup '" << name() << "'."); return MeasureRecord(std::shared_ptr<detail::MeasureRecord_Impl>(),database); }
unsigned MeasureGroupRecord_Impl::numMeasures(bool selectedMeasuresOnly) const { unsigned result = 0; ProjectDatabase database = this->projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); if (selectedMeasuresOnly){ query.prepare(toQString("SELECT COUNT(*) FROM " + MeasureRecord::databaseTableName() + " WHERE variableRecordId=:id AND isSelected=:isSelected")); query.bindValue(":id", this->id()); query.bindValue(":isSelected", true); }else{ query.prepare(toQString("SELECT COUNT(*) FROM " + MeasureRecord::databaseTableName() + " WHERE variableRecordId=:id")); query.bindValue(":id", this->id()); } assertExec(query); if (query.first()){ result = query.value(0).toUInt(); } return result; }
std::vector<FunctionRecord> OptimizationProblemRecord_Impl::objectiveRecords() const { FunctionRecordVector result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName() + " WHERE problemRecordId=:problemRecordId AND functionType=:functionType " + "ORDER BY functionVectorIndex")); query.bindValue(":problemRecordId", id()); query.bindValue(":functionType",FunctionType::Objective); assertExec(query); OptionalInt previousIndex; bool resort(false); while (query.next()) { result.push_back(FunctionRecord::factoryFromQuery(query, database).get()); int index = result.back().functionVectorIndex(); if (previousIndex) { if (index <= previousIndex.get()) { resort = true; // if functions are moved around, order in database itself can // get out of date (as compared to database + dirty records). } } previousIndex = index; } if (resort) { FunctionRecordFunctionVectorIndexLess comparator; std::sort(result.begin(),result.end(),comparator); } return result; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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; }
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<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; }
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; }
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<OSArgumentRecord> RubyMeasureRecord_Impl::osArgumentRecords() const { OSArgumentRecordVector result; ProjectDatabase database = projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + OSArgumentRecord::databaseTableName() + " WHERE rubyPerturbationRecordId=:rubyPerturbationId")); query.bindValue(":rubyPerturbationRecordId",id()); assertExec(query); while (query.next()) { result.push_back(OSArgumentRecord(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<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; }
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; }