void OpenStudioAlgorithmRecord_Impl::saveRow(const std::shared_ptr<QSqlDatabase> &database)
 {
   QSqlQuery query(*database);
   this->makeUpdateByIdQuery<OpenStudioAlgorithmRecord>(query);
   this->bindValues(query);
   assertExec(query);
 }
Exemplo n.º 2
0
 void DakotaAlgorithmRecord_Impl::saveRow(const boost::shared_ptr<QSqlDatabase> &database)
 {
   QSqlQuery query(*database);
   this->makeUpdateByIdQuery<DakotaAlgorithmRecord>(query);
   this->bindValues(query);
   assertExec(query);
 }
Exemplo n.º 3
0
 void ProjectDatabaseRecord_Impl::saveRow(const std::shared_ptr<QSqlDatabase> &database)
 {
   QSqlQuery query(*database);
   this->makeUpdateByIdQuery<ProjectDatabaseRecord>(query);
   this->bindValues(query);
   assertExec(query);
 }
Exemplo n.º 4
0
  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);
 }
Exemplo n.º 6
0
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);
}
Exemplo n.º 7
0
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;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 10
0
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;
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
0
  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;
  }
Exemplo n.º 15
0
      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;
      }
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
0
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;
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
0
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;
}
Exemplo n.º 20
0
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;
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
      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;
      }
Exemplo n.º 23
0
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;
  }
Exemplo n.º 25
0
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;
}
Exemplo n.º 26
0
  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;
}
Exemplo n.º 28
0
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;
}
Exemplo n.º 29
0
  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;
  }
Exemplo n.º 30
0
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;
}