void InputVariableRecord::constructRelatedRecords(const analysis::InputVariable& inputVariable) { AttributeVector attributes, dbAttributes; InputVariableRecord copyOfThis(getImpl<detail::InputVariableRecord_Impl>()); if (analysis::OptionalUncertaintyDescription dbUDesc = uncertaintyDescription()) { dbAttributes = dbUDesc->cast<analysis::GenericUncertaintyDescription>().attributes(); } if (analysis::OptionalUncertaintyDescription udesc = inputVariable.uncertaintyDescription()) { attributes = udesc->cast<analysis::GenericUncertaintyDescription>().attributes(); } for (const Attribute& attribute : attributes) { // find in dbOptions auto dbIt = std::find_if(dbAttributes.begin(),dbAttributes.end(), std::bind(uuidsEqual<Attribute,Attribute>,std::placeholders::_1,attribute)); // if not there, or if different versionUUID, save it if ((dbIt == dbAttributes.end()) || (attribute.versionUUID() != dbIt->versionUUID())) { AttributeRecord udescAttributeRecord(attribute,copyOfThis); } // if there, erase from dbOptions if (dbIt != dbAttributes.end()) { dbAttributes.erase(dbIt); } } // any attributes left in dbAttributes should be removed from the database ProjectDatabase database = projectDatabase(); for (const Attribute& toRemove : dbAttributes) { AttributeRecord dbUDescAttributeRecord = database.getObjectRecordByHandle<AttributeRecord>(toRemove.uuid()).get(); database.removeRecord(dbUDescAttributeRecord); } }
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; }
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<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; }
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; }
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); }
TEST_F(ProjectFixture, AttributeRecord_ManyAnnualEndUses) { ProjectDatabase database = getCleanDatabase("AttributeRecord_ManyAnnualEndUses"); for (unsigned i = 0; i < 10; ++i){ EndUses endUses; endUses.addEndUse(25.0, EndUseFuelType::Gas, EndUseCategoryType::Heating); endUses.addEndUse(2.0, EndUseFuelType::Electricity, EndUseCategoryType::Cooling); endUses.addEndUse(1.0, EndUseFuelType::Electricity, EndUseCategoryType::InteriorLights); endUses.addEndUse(10.0, EndUseFuelType::Electricity, EndUseCategoryType::Fans, "Fan Energy"); endUses.addEndUse(10.0, EndUseFuelType::Water, EndUseCategoryType::Humidifier); std::stringstream ss; ss << "model " << i; FileReferenceRecord model(FileReference(toPath("./in.osm")),database); AttributeRecord attributeRecord(endUses.attribute(), model); ASSERT_TRUE(model.getAttributeRecord(EndUses::attributeName())); EXPECT_TRUE(endUses.attribute() == model.getAttributeRecord(EndUses::attributeName()).get().attribute()); } database.save(); }
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; }
void ProjectDatabaseRecord_Impl::updatePathData(const openstudio::path& originalBase, const openstudio::path& newBase) { // don't use arguments -- go to the source ProjectDatabase database = projectDatabase(); setName(toString(database.path())); setRunManagerDBPath(completeAndNormalize(database.runManager().dbPath())); }
ProjectDatabaseRecord_Impl::ProjectDatabaseRecord_Impl(const std::string& version, const openstudio::path& runManagerDBPath, const ProjectDatabase& projectDatabase) : ObjectRecord_Impl(projectDatabase, toString(projectDatabase.path()), toString(projectDatabase.path().filename()), ""), m_version(version), m_runManagerDBPath(completeAndNormalize(runManagerDBPath)) { }
void ProjectDatabaseRecord::updatePathData(ProjectDatabase database, const openstudio::path& originalBase, const openstudio::path& newBase) { bool didStartTransaction = database.startTransaction(); ProjectDatabaseRecord record = getProjectDatabaseRecord(database); record.getImpl<detail::ProjectDatabaseRecord_Impl>()->updatePathData(originalBase,newBase); if (didStartTransaction) { bool test = database.commitTransaction(); OS_ASSERT(test); } }
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; }
// Test not yet to scale re: data points. TEST_F(ProjectFixture,Profile_SaveAnalysis) { Analysis analysis = getAnalysisToRun(100,500); // time the process of saving to database ptime start = microsec_clock::local_time(); ProjectDatabase db = getCleanDatabase(toPath("./SaveAnalysis")); ASSERT_TRUE(db.startTransaction()); AnalysisRecord record(analysis,db); db.save(); ASSERT_TRUE(db.commitTransaction()); time_duration saveTime = microsec_clock::local_time() - start; std::cout << "Time: " << to_simple_string(saveTime) << std::endl; }
// Test not yet to scale re: data points. TEST_F(ProjectFixture,Profile_ClearAnalysisResults) { ProjectDatabase db = getPopulatedDatabase(100,500,true,toPath("./ClearAnalysisResults")); // mimic code in AnalysisDriver to avoid adding AnalysisDriver as a dependency // time the process of retrieving response function data ptime start = microsec_clock::local_time(); db.unloadUnusedCleanRecords(); ASSERT_TRUE(db.startTransaction()); DataPointRecordVector dataPointRecords = DataPointRecord::getDataPointRecords(db); EXPECT_EQ(500u,dataPointRecords.size()); BOOST_FOREACH(project::DataPointRecord& dataPointRecord,dataPointRecords) { // in AnalysisDriver, removes DataPoint directories, but they don't exist here db.removeRecord(dataPointRecord); }
openstudio::runmanager::Workflow WorkflowRecord_Impl::workflow() const { ProjectDatabase projectDatabase = this->projectDatabase(); openstudio::runmanager::Workflow result; openstudio::runmanager::RunManager runManager = projectDatabase.runManager(); try { result = runManager.loadWorkflow(m_runManagerWorkflowKey); result.setUUID(handle()); } catch (...) { LOG(Error,"Unable to load workflow from RunManager using key " << m_runManagerWorkflowKey << ". Returning empty Workflow."); } 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; }
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; }
TEST_F(ProjectFixture, AttributeRecord_AttributeTypes) { ProjectDatabase database = getCleanDatabase("AttributeRecord_AttributeTypes"); FileReferenceRecord model(FileReference(toPath("./in.osm")),database); EXPECT_EQ(static_cast<unsigned>(0), AttributeRecord::getAttributeRecords(database).size()); EXPECT_EQ(static_cast<unsigned>(0), model.attributeRecords().size()); // make attributes Attribute boolAttribute("bool", true); Attribute unsignedAttribute("unsigned", 2u); Attribute intAttribute("int", -1); Attribute doubleAttribute("double", 1.23, std::string("m")); Attribute stringAttribute("string", "hello"); // because of tracking by UUID, have to make separate child attributes AttributeVector childAttributes; childAttributes.push_back(Attribute("bool", true)); childAttributes.push_back(Attribute("bool", true)); Attribute vectorAttribute("vector", childAttributes); // create AttributeRecords AttributeRecord boolAttributeRecord(boolAttribute, model); AttributeRecord unsignedAttributeRecord(unsignedAttribute, model); AttributeRecord intAttributeRecord(intAttribute, model); AttributeRecord doubleAttributeRecord(doubleAttribute, model); AttributeRecord stringAttributeRecord(stringAttribute, model); AttributeRecord vectorAttributeRecord(vectorAttribute, model); ASSERT_TRUE(model.getAttributeRecord("bool")); EXPECT_TRUE(boolAttribute == model.getAttributeRecord("bool").get().attribute()); ASSERT_TRUE(model.getAttributeRecord("unsigned")); EXPECT_TRUE(unsignedAttribute == model.getAttributeRecord("unsigned").get().attribute()); ASSERT_TRUE(model.getAttributeRecord("int")); EXPECT_TRUE(intAttribute == model.getAttributeRecord("int").get().attribute()); ASSERT_TRUE(model.getAttributeRecord("double")); EXPECT_TRUE(doubleAttribute == model.getAttributeRecord("double").get().attribute()); ASSERT_TRUE(model.getAttributeRecord("string")); EXPECT_TRUE(stringAttribute == model.getAttributeRecord("string").get().attribute()); ASSERT_TRUE(model.getAttributeRecord("vector")); EXPECT_TRUE(vectorAttribute == model.getAttributeRecord("vector").get().attribute()); EXPECT_EQ(static_cast<unsigned>(6), AttributeRecord::getAttributeRecords(database).size()); EXPECT_EQ(static_cast<unsigned>(6), model.attributeRecords().size()); database.save(); }
static bool unlinkLeft(int leftId, ProjectDatabase projectDatabase) { bool result = false; std::vector<T> toRemove; 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); toRemove.push_back(object); } BOOST_FOREACH(T object, toRemove){ result = projectDatabase.removeRecord(object); }
std::vector<MeasureRecord> MeasureGroupRecord_Impl::measureRecords(bool selectedMeasuresOnly) const { std::vector<MeasureRecord> result; ProjectDatabase database = this->projectDatabase(); QSqlQuery query(*(database.qSqlDatabase())); if (selectedMeasuresOnly){ query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() + " WHERE variableRecordId=:id AND isSelected=:isSelected ORDER BY measureVectorIndex")); query.bindValue(":id", this->id()); query.bindValue(":isSelected", true); }else{ query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() + " WHERE variableRecordId=:id ORDER BY measureVectorIndex")); query.bindValue(":id", this->id()); } assertExec(query); OptionalInt previousIndex; bool resort(false); while (query.next()){ boost::optional<MeasureRecord> measure = MeasureRecord::factoryFromQuery(query, database); OS_ASSERT(measure); result.push_back(*measure); OptionalInt index = result.back().measureVectorIndex(); if (previousIndex && index) { if (index.get() <= previousIndex.get()) { resort = true; } } if (index) { previousIndex = index; } } if (resort) { MeasureRecordMeasureVectorIndexLess comparator; std::sort(result.begin(),result.end(),comparator); } return result; }
void MeasureGroupRecord::constructMeasureRecords(const analysis::MeasureGroup& measureGroup) { MeasureGroupRecord copyOfThis(getImpl<detail::MeasureGroupRecord_Impl>()); ProjectDatabase database = copyOfThis.projectDatabase(); bool isNew = database.isNewRecord(copyOfThis); int i = 0; std::vector<UUID> measureUUIDs; for (const Measure& measure : measureGroup.measures(false)) { measureUUIDs.push_back(measure.uuid()); if (measure.isDirty() || isNew) { MeasureRecord newMeasureRecord = MeasureRecord::factoryFromMeasure(measure,copyOfThis,i); } ++i; } if (!isNew) { removeMeasureRecords(measureUUIDs,database); } }
TEST_F(ProjectFixture, ProblemRecord_RubyContinuousVariables) { // Create a database containing a ProblemRecord with a chain of // RubyContinuousVariables that reference the same RubyMeasure analysis::Problem problem("Contains Linked RubyContinuousVariables"); // Measure with two RubyContinuousVariables analysis::RubyMeasure wwrScript(openstudio::toPath(rubyLibDir()) / openstudio::toPath("openstudio/sketchup_plugin/user_scripts/Alter or Add Model Elements/Set_Window_to_Wall_Ratio.rb"), FileReferenceType::OSM, FileReferenceType::OSM, true); ruleset::OSArgument arg = ruleset::OSArgument::makeDoubleArgument("wwr"); analysis::RubyContinuousVariable wwr("Window to Wall Ratio",arg,wwrScript); wwr.setMinimum(0.15); wwr.setMaximum(0.60); problem.push(wwr); arg = ruleset::OSArgument::makeDoubleArgument("offset"); analysis::RubyContinuousVariable offset("Window Offset from Floor",arg,wwrScript); offset.setMinimum(0.5); offset.setMaximum(2.0); problem.push(offset); EXPECT_EQ(wwr.measure(), offset.measure()); // Project Database ProjectDatabase database = getCleanDatabase("ProblemRecord_RubyContinuousVariables"); // Problem Record ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database); database.save(); // Deserialize the problem and verify that the deserialized RubyMeasures are // all equal. problemRecord = ProblemRecord::getProblemRecords(database)[0]; problem = problemRecord.problem(); ASSERT_EQ(2u,problem.variables().size()); ASSERT_TRUE(problem.variables()[0].optionalCast<RubyContinuousVariable>()); ASSERT_TRUE(problem.variables()[1].optionalCast<RubyContinuousVariable>()); EXPECT_EQ(problem.variables()[0].cast<RubyContinuousVariable>().measure(), problem.variables()[1].cast<RubyContinuousVariable>().measure()); }
static bool unlinkRight(int rightId, ProjectDatabase projectDatabase) { bool result = false; std::vector<T> toRemove; QSqlQuery query(*(projectDatabase.qSqlDatabase())); query.prepare(toQString("SELECT * FROM " + T::databaseTableName() + " WHERE rightId=:rightId")); query.bindValue(":rightId", rightId); assertExec(query); while(query.next()){ T object(std::shared_ptr<typename T::ImplType>(new typename T::ImplType(query, projectDatabase)), projectDatabase); toRemove.push_back(object); } for (T object : toRemove){ result = projectDatabase.removeRecord(object); } 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; }
TEST_F(ProjectFixture,CloudSessionRecord_VagrantPopulated) { std::string id; UUID uuid, versionUUID; { ProjectDatabase database = getCleanDatabase("CloudSessionRecord_VagrantPopulated"); VagrantSession session(toString(createUUID()), Url("http://localhost:8080"), UrlVector(1u,Url("http://localhost:8081"))); id = session.sessionId(); uuid = session.uuid(); versionUUID = session.versionUUID(); CloudSessionRecord record = CloudSessionRecord::factoryFromCloudSession(session,database); database.save(); EXPECT_EQ(1u,CloudSessionRecord::getCloudSessionRecords(database).size()); } { ProjectDatabase database = getExistingDatabase("CloudSessionRecord_VagrantPopulated"); EXPECT_EQ(1u,CloudSessionRecord::getCloudSessionRecords(database).size()); ASSERT_FALSE(CloudSessionRecord::getCloudSessionRecords(database).empty()); CloudSessionRecord record = CloudSessionRecord::getCloudSessionRecords(database)[0]; CloudSession session = record.cloudSession(); ASSERT_TRUE(session.optionalCast<VagrantSession>()); VagrantSession vagrantSession = session.cast<VagrantSession>(); EXPECT_EQ(uuid,vagrantSession.uuid()); EXPECT_EQ(versionUUID,vagrantSession.versionUUID()); EXPECT_EQ("VagrantProvider",vagrantSession.cloudProviderType()); EXPECT_EQ(id,vagrantSession.sessionId()); ASSERT_TRUE(vagrantSession.serverUrl()); EXPECT_EQ(Url("http://localhost:8080"),vagrantSession.serverUrl().get()); ASSERT_EQ(1u,vagrantSession.workerUrls().size()); EXPECT_EQ(Url("http://localhost:8081"),vagrantSession.workerUrls()[0]); } }
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<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; }
void CloudSessionRecord::constructRelatedRecords(const CloudSession& cloudSession, ProjectDatabase& database) { CloudSessionRecord copyOfThis(getImpl<detail::CloudSessionRecord_Impl>()); bool isNew = database.isNewRecord(copyOfThis); if (!isNew) { getImpl<detail::CloudSessionRecord_Impl>()->revertToLastRecordIds(); } if (isNew || (getImpl<detail::CloudSessionRecord_Impl>()->lastUuidLast() != cloudSession.versionUUID())) { // remove any existing UrlRecords that have this object as its parent ObjectRecordVector childUrls = children(); for (ObjectRecord& childUrl : childUrls) { database.removeRecord(childUrl); } // create new UrlRecords OptionalAWSSession awsSession = cloudSession.optionalCast<AWSSession>(); if (OptionalUrl serverUrl = cloudSession.serverUrl()) { UrlRecord serverRecord(*serverUrl,copyOfThis); if (awsSession) { serverRecord.setName(awsSession->serverId()); } getImpl<detail::CloudSessionRecord_Impl>()->setServerUrlRecordId(serverRecord.id()); } StringVector workerIds; if (awsSession) { workerIds = awsSession->workerIds(); } unsigned index(0); for (const Url& workerUrl : cloudSession.workerUrls()) { UrlRecord workerRecord(workerUrl,copyOfThis); if (index < workerIds.size()) { workerRecord.setName(workerIds[index]); } ++index; } } }