DiscreteVariableRecord_Impl::DiscreteVariableRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : InputVariableRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(DiscreteVariableRecord::ColumnsType::discreteVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_discreteVariableRecordType = DiscreteVariableRecordType(value.toInt());
  }
Example #2
0
void ActionClauseRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase)
{
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    ClauseRecord_Impl::setLastValues(query, projectDatabase);

    QVariant value;
    value = query.value(ClauseRecordColumns::actionClauseRecordType);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    m_lastActionClauseRecordType = ActionClauseRecordType(value.toInt());
}
  CloudSettingsRecord_Impl::CloudSettingsRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : ObjectRecord_Impl(database, query)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(CloudSettingsRecord::ColumnsType::cloudSettingsRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_cloudSettingsRecordType = CloudSettingsRecordType(value.toInt());
  }
void OutputVariableRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    VariableRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(OutputVariableRecord::ColumnsType::outputVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastOutputVariableRecordType = OutputVariableRecordType(value.toInt());
}
  void DDACEAlgorithmRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    DakotaAlgorithmRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(DDACEAlgorithmRecord::ColumnsType::ddaceAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastAlgorithmType = analysis::DDACEAlgorithmType(value.toInt());
  }
  void OutputAttributeVariableRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    OutputVariableRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(OutputAttributeVariableRecord::ColumnsType::attributeName);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastAttributeName = value.toString().toStdString();
  }
  RubyContinuousVariableRecord_Impl::RubyContinuousVariableRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : ContinuousVariableRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(RubyContinuousVariableRecord::ColumnsType::rubyPerturbationRecordId);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_rubyMeasureRecordId = value.toInt();
  }
  void CloudSettingsRecord_Impl::setLastValues(const QSqlQuery& query, ProjectDatabase& projectDatabase) {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    ObjectRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(CloudSettingsRecord::ColumnsType::cloudSettingsRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastCloudSettingsRecordType = CloudSettingsRecordType(value.toInt());
  }
  ModelObjectFilterRelationshipRecord_Impl::ModelObjectFilterRelationshipRecord_Impl(const QSqlQuery& query, ProjectDatabase& database)
    : ModelObjectFilterClauseRecord_Impl(query, database)
  {
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(ModelObjectFilterRelationshipRecord::ColumnsType::relationshipName);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    m_relationshipName = value.toString().toStdString();
  }
Example #10
0
QVariant DBProxy::execQuery(const QString &queryString, QSqlQuery *argQuery )
{
    if( dodawanie && mBladDodawaniaRekordu )
        return 0;

    QSqlQuery *query = argQuery;
    if( !query )
        query = new QSqlQuery( db );

    if( !query->exec( queryString ) ) {
        emit log( query->lastError().text() );

        if( dodawanie ) {
            mBladDodawaniaRekordu = true;
            emit bladDodawaniaRekordu();    // czy przekazywac cos?
        }

        if( query->isSelect() )
            return false;

        return 0;
    }

    if( query->isSelect() ) {
        if( !argQuery )
            delete query;

        return true;

    } else {
        unsigned int id = query->lastInsertId().toUInt();

        if( !argQuery )
            delete query;

        return id;
    }
}
  ParameterStudyAlgorithmRecord_Impl::ParameterStudyAlgorithmRecord_Impl(const QSqlQuery& query,
                                                                         ProjectDatabase& database)
    : DakotaAlgorithmRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(ParameterStudyAlgorithmRecord::ColumnsType::parameterStudyAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_algorithmType = analysis::ParameterStudyAlgorithmType(value.toInt());
  }
  OutputAttributeVariableRecord_Impl::OutputAttributeVariableRecord_Impl(
      const QSqlQuery& query, ProjectDatabase& database)
    : OutputVariableRecord_Impl(query, database)
  {
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(OutputAttributeVariableRecord::ColumnsType::attributeName);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    m_attributeName = value.toString().toStdString();
  }
bool SQLiteKeyValueStore::retrieve(const QByteArray &key, QByteArray *valueOutput, QString *error)
{
    if (!_db.isOpen())
    {
        if (error)
            *error = "Database is not open/ready";
        return false;
    }

    if (!valueOutput)
    {
        if (error)
            *error = "Invalid null parameter";
        return false;
    }

    QSqlQuery query;
    if (!query.prepare("SELECT value FROM keyValueStore WHERE key == :key;"))
    {
        if (error)
            *error = "Failed to prepare query";
        return false;
    }

    query.bindValue(":key",QVariant(key));

    if (!query.exec())
    {
        if (error)
            *error = "Failed to retrieve key. SQL error:" + query.lastError().text();
        return false;
    }

    if (!query.isSelect() || !query.isActive())
    {
        if (error)
            *error = "Query error";
        return false;
    }

    if (!query.next())
    {
        if (error)
            *error = "No such key";
        return false;
    }

    *valueOutput = query.value(0).toByteArray();
    return true;
}
  OpenStudioAlgorithmRecord_Impl::OpenStudioAlgorithmRecord_Impl(const QSqlQuery& query, 
                                                                 ProjectDatabase& database)
    : AlgorithmRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(OpenStudioAlgorithmRecord::ColumnsType::openStudioAlgorithmRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_openStudioAlgorithmRecordType = OpenStudioAlgorithmRecordType(value.toInt());
  }
  DesignOfExperimentsRecord_Impl::DesignOfExperimentsRecord_Impl(const QSqlQuery& query, 
                                                                 ProjectDatabase& database)
    : OpenStudioAlgorithmRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(AlgorithmRecordColumns::designOfExperimentsType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_designOfExperimentsType = analysis::DesignOfExperimentsType(value.toInt());
  }
  bool RubyContinuousVariableRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = ContinuousVariableRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(RubyContinuousVariableRecord::ColumnsType::rubyPerturbationRecordId);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_rubyMeasureRecordId == value.toInt());

    return result;
  }
  bool ModelObjectFilterRelationshipRecord_Impl::compareValues(const QSqlQuery& query) const {
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    bool result = ModelObjectFilterClauseRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(ModelObjectFilterRelationshipRecord::ColumnsType::relationshipName);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_relationshipName == value.toString().toStdString());

    return result;
  }
  bool DDACEAlgorithmRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = DakotaAlgorithmRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(DDACEAlgorithmRecord::ColumnsType::ddaceAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_algorithmType == analysis::DDACEAlgorithmType(value.toInt()));

    return result;
  }
  bool DesignOfExperimentsRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = OpenStudioAlgorithmRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(AlgorithmRecordColumns::designOfExperimentsType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_designOfExperimentsType == analysis::DesignOfExperimentsType(value.toInt()));

    return result;
  }
  bool OutputAttributeVariableRecord_Impl::compareValues(const QSqlQuery& query) const {
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    bool result = OutputVariableRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(OutputAttributeVariableRecord::ColumnsType::attributeName);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_attributeName == value.toString().toStdString());

    return result;
  }
  bool CloudSettingsRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = ObjectRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(CloudSettingsRecord::ColumnsType::cloudSettingsRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_cloudSettingsRecordType == CloudSettingsRecordType(value.toInt()));

    return result;
  }
  bool OutputVariableRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = VariableRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(OutputVariableRecord::ColumnsType::outputVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_outputVariableRecordType == OutputVariableRecordType(value.toInt()));

    return result;
  }
void ui_new_compra_orden::init_lineEdit_proveedorNombre()
{
    vector<QString > select, from;
    vector<pair<QString, QString > > where, joins;
    QString str_from;
    QString extra;
    QSqlQuery query;


    // Completer para proveedor
    // SELECT
    select.push_back("pj.razon_social");
    // FROM
    str_from = QString(TABLE_NAME_E_PERSONA_JURIDICA)+" AS pj ";
    str_from += "INNER JOIN ";
    str_from += QString(TABLE_NAME_E_PROVEEDOR)+" AS p ";
    str_from += "ON pj.pk_ruc=p.pk_ruc ORDER BY pj.razon_social";
    from.push_back(str_from);
    query = SYSTEM->getSelectQuery(select, from, where, joins,extra);

    //query.exec("SELECT pj.razon_social FROM e_persona_juridica pj INNER JOIN e_proveedor p ON pj.pk_ruc=p.pk_ruc ORDER BY pj.razon_social");
    QStringList list;

    if(query.isSelect())
    {
        while(query.next())
        {
            list<<query.value(0).toString();
            //ui->lineEdit_transportistaNombre->insert(query.value(0).toString()+"  ");
        }

    }



    QStringListModel * model0 = new QStringListModel(this);
    model0->setStringList(list);
    //QSortFilterProxyModel *proxyModel0 = new QSortFilterProxyModel(this);
    //proxyModel0->setSourceModel(model0);
    QCompleter * c0 = new QCompleter(this);
    c0->setModelSorting(QCompleter::CaseInsensitivelySortedModel);
    c0->setCaseSensitivity(Qt::CaseInsensitive);
    c0->setWrapAround(false);
    c0->setModel(model0);

    ui->lineEdit_proveedorNombre->setCompleter(c0);
    connect(c0, SIGNAL(activated(QString)), this, SLOT(on_lineEdit_proveedorNombre_activated(QString)));
}
Example #24
0
void DataOutputWidget::showQueryResultSets(QSqlQuery &query)
{
  /// TODO: loop resultsets if > 1
  /// NOTE from Qt Documentation:
  /// When one of the statements is a non-select statement a count of affected rows
  /// may be available instead of a result set.

  if (!query.isSelect() || query.lastError().isValid())
    return;

  m_model->setQuery(query);

  resizeColumnsToContents();

  raise();
}
  ProjectDatabaseRecord_Impl::ProjectDatabaseRecord_Impl(const QSqlQuery& query, const ProjectDatabase& projectDatabase)
    : ObjectRecord_Impl(projectDatabase, query)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;
    value = query.value(ProjectDatabaseRecordColumns::version);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_version = value.toString().toStdString();

    value = query.value(ProjectDatabaseRecordColumns::runManagerDBPath);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_runManagerDBPath = toPath(value.toString());
  }
  ModelObjectFilterAttributeRecord_Impl::ModelObjectFilterAttributeRecord_Impl(const QSqlQuery& query, const ProjectDatabase& projectDatabase)
    : ModelObjectFilterClauseRecord_Impl(query, projectDatabase)
  {
    BOOST_ASSERT(query.isValid());
    BOOST_ASSERT(query.isActive());
    BOOST_ASSERT(query.isSelect());

    QVariant value;
    value = query.value(ClauseRecordColumns::modelObjectFilterAttributeRecordType);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    m_modelObjectFilterAttributeRecordType = ModelObjectFilterAttributeRecordType(value.toInt());
    
    value = query.value(ClauseRecordColumns::attributeName);
    BOOST_ASSERT(value.isValid() && !value.isNull());
    m_attributeName = value.toString().toStdString();
  }
  bool ContinuousVariableRecord_Impl::compareValues(const QSqlQuery& query) const {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = InputVariableRecord_Impl::compareValues(query);

    QVariant value;

    value = query.value(ContinuousVariableRecord::ColumnsType::continuousVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_continuousVariableRecordType == ContinuousVariableRecordType(value.toInt()));

    value = query.value(ContinuousVariableRecord::ColumnsType::minimum);
    if (value.isValid() && !value.isNull()) {
      result = result && m_minimum && equal(*m_minimum,value.toDouble());
    }
    else {
      result = result && !m_minimum;
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::maximum);
    if (value.isValid() && !value.isNull()) {
      result = result && m_maximum && equal(*m_maximum,value.toDouble());
    }
    else {
      result = result && !m_maximum;
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::increment);
    if (value.isValid() && !value.isNull()) {
      result = result && m_increment && equal(*m_increment,value.toDouble());
    }
    else {
      result = result && !m_increment;
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::nSteps);
    if (value.isValid() && !value.isNull()) {
      result = result && m_nSteps && (*m_nSteps == value.toInt());
    }
    else {
      result = result && !m_nSteps;
    }

    return result;
  }
  void ContinuousVariableRecord_Impl::setLastValues(const QSqlQuery& query,
                                                    ProjectDatabase& projectDatabase)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    InputVariableRecord_Impl::setLastValues(query,projectDatabase);

    QVariant value;

    value = query.value(ContinuousVariableRecord::ColumnsType::continuousVariableRecordType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_lastContinuousVariableRecordType = ContinuousVariableRecordType(value.toInt());

    value = query.value(ContinuousVariableRecord::ColumnsType::minimum);
    if (value.isValid() && !value.isNull()) {
      m_lastMinimum = value.toDouble();
    }
    else {
      m_lastMinimum.reset();
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::maximum);
    if (value.isValid() && !value.isNull()) {
      m_lastMaximum = value.toDouble();
    }
    else {
      m_lastMaximum.reset();
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::increment);
    if (value.isValid() && !value.isNull()) {
      m_lastIncrement = value.toDouble();
    }
    else {
      m_lastIncrement.reset();
    }

    value = query.value(ContinuousVariableRecord::ColumnsType::nSteps);
    if (value.isValid() && !value.isNull()) {
      m_lastNSteps = value.toInt();
    }
    else {
      m_lastNSteps.reset();
    }
  }
Example #29
0
  bool ObjectRecord_Impl::compareValues(const QSqlQuery& query) const
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    bool result = true;

    result = result && Record_Impl::compareValues(query);
    if (!result) return result;

    QVariant value;

    value = query.value(ObjectRecordColumns::name);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_name == value.toString().toStdString());
    if (!result) return result;

    value = query.value(ObjectRecordColumns::displayName);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_displayName == value.toString().toStdString());
    if (!result) return result;

    value = query.value(ObjectRecordColumns::description);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_description == value.toString().toStdString());
    if (!result) return result;

    value = query.value(ObjectRecordColumns::timestampCreate);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_timestampCreate == DateTime(value.toString().toStdString()));
    if (!result) return result;

    value = query.value(ObjectRecordColumns::timestampLast);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_timestampLast == DateTime(value.toString().toStdString()));
    if (!result) return result;

    value = query.value(ObjectRecordColumns::uuidLast);
    OS_ASSERT(value.isValid() && !value.isNull());
    result = result && (m_uuidLast == toUUID(value.toString().toStdString()));

    return result;
  }
  FSUDaceAlgorithmRecord_Impl::FSUDaceAlgorithmRecord_Impl(const QSqlQuery& query,
                                                           ProjectDatabase& database)
    : DakotaAlgorithmRecord_Impl(query, database)
  {
    OS_ASSERT(query.isValid());
    OS_ASSERT(query.isActive());
    OS_ASSERT(query.isSelect());

    QVariant value;

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceAlgorithmType);
    OS_ASSERT(value.isValid() && !value.isNull());
    m_algorithmType = analysis::FSUDaceAlgorithmType(value.toInt());

    value = query.value(FSUDaceAlgorithmRecord::ColumnsType::fsudaceTrialType);
    if (value.isValid() && !value.isNull()) {
      m_trialType = analysis::FSUDaceCvtTrialType(value.toInt());
    }
  }