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;
}
