KDbSqlResult* SqlitePreparedStatement::execute( KDbPreparedStatement::Type type, const KDbField::List& selectFieldList, KDbFieldList* insertFieldList, const KDbPreparedStatementParameters& parameters, bool *resultOwned) { Q_UNUSED(insertFieldList); Q_UNUSED(resultOwned); if (!m_sqlResult->prepared_st) { return nullptr; } int par = 1; // par.index counted from 1 KDbField::ListIterator itFields(selectFieldList.constBegin()); for (QList<QVariant>::ConstIterator it = parameters.constBegin(); itFields != selectFieldList.constEnd(); it += (it == parameters.constEnd() ? 0 : 1), ++itFields, par++) { if (!bindValue(*itFields, it == parameters.constEnd() ? QVariant() : *it, par)) return nullptr; } //real execution const int res = sqlite3_step(m_sqlResult->prepared_st); if (type == KDbPreparedStatement::InsertStatement) { const bool ok = res == SQLITE_DONE; if (ok) { m_result = KDbResult(); } else { m_result.setServerErrorCode(res); storeResult(&m_result); sqliteWarning() << m_result << QString::fromLatin1(sqlite3_sql(m_sqlResult->prepared_st)); } (void)sqlite3_reset(m_sqlResult->prepared_st); return m_sqlResult.data(); } else if (type == KDbPreparedStatement::SelectStatement) { //! @todo fetch result const bool ok = res == SQLITE_ROW; storeResult(&m_result); if (ok) { m_result = KDbResult(); } else { m_result.setServerErrorCode(res); storeResult(&m_result); sqliteWarning() << m_result << QString::fromLatin1(sqlite3_sql(m_sqlResult->prepared_st)); } (void)sqlite3_reset(m_sqlResult->prepared_st); return m_sqlResult.data(); } return nullptr; }
bool SqliteCursor::drv_open(const KDbEscapedString& sql) { //! @todo decode if (! d->data) { // this may as example be the case if SqliteConnection::drv_useDatabase() // wasn't called before. Normaly sqlite_compile/sqlite3_prepare // should handle it, but it crashes in in sqlite3SafetyOn at util.c:786 sqliteWarning() << "SqliteCursor::drv_open(): Database handle undefined."; return false; } int res = sqlite3_prepare( d->data, /* Database handle */ sql.constData(), /* SQL statement, UTF-8 encoded */ sql.length(), /* Length of zSql in bytes. */ &d->prepared_st_handle, /* OUT: Statement handle */ 0/*const char **pzTail*/ /* OUT: Pointer to unused portion of zSql */ ); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(); return false; } if (isBuffered()) { //! @todo manage size dynamically d->records.resize(128); } return true; }
void __fastcall TfrmResultEnterEdit::bbtnAddResultClick(TObject *Sender) { //Сохранить результат storeResult(); //Обновить таблицу участников changeCompetitorSearchTableState(); lbledtCompetitorSurname->SetFocus(); }
bool SqliteCursor::drv_close() { int res = sqlite3_finalize(d->prepared_st_handle); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(); return false; } return true; }
bool MysqlCursor::drv_open(const KDbEscapedString& sql) { if (mysql_real_query(d->mysql, sql.constData(), sql.length()) == 0) { if (mysql_errno(d->mysql) == 0) { //! @todo Add option somewhere so we can use more optimal mysql_num_rows(). //! In this case mysql_num_rows() does not work however. d->mysqlres = mysql_store_result(d->mysql); m_fieldCount = mysql_num_fields(d->mysqlres); m_fieldsToStoreInRecord = m_fieldCount; d->numRows = mysql_num_rows(d->mysqlres); m_records_in_buf = d->numRows; m_buffering_completed = true; return true; } } storeResult(); return false; }
SEXP readBGEN2List(BGenFile* bin) { // Rprintf("vcfColumn.size() = %u\n", FLAG_vcfColumn.size()); // Rprintf("vcfInfo.size() = %u\n", FLAG_infoTag.size()); // Rprintf("vcfIndv.size() = %u\n", FLAG_indvTag.size()); // also append sample names at the end // 7: chrom, pos, varId, rsId, alleles, isPhased, prob, sampleId int retListLen = 8; if (retListLen == 0) { return R_NilValue; } int numAllocated = 0; // record how many times we allocate (using PROTECT in R); SEXP ret; PROTECT(ret = allocVector(VECSXP, retListLen)); numAllocated++; // store results std::vector<std::string> idVec; std::vector<std::string> chrom; std::vector<int> pos; std::vector<std::string> varId; std::vector<std::string> rsId; std::vector<std::string> alleles; // std::vector<std::vector<bool> > missing; std::vector<bool> isPhased; std::vector<std::vector<double> > prob; // prob[variant][each_sample * (prob1, prob2, ...)] // std::map<std::string, std::vector<std::string> > infoMap; // std::map<std::string, std::vector<std::string> > indvMap; /// int nRow = 0; // # of positions that will be outputed // get effective sample names const int N = bin->getNumSample(); std::vector<std::string> sm = bin->getSampleIdentifier(); // all sample names std::vector<std::string>& names = idVec; if (!sm.size()) { char buf[1024]; for (int i = 0; i < N; ++i) { sprintf(buf, "sample_%d", i); sm.push_back(buf); } } const size_t sampleSize = bin->getNumEffectiveSample(); for (size_t i = 0; i != sampleSize; ++i) { names.push_back(sm[bin->getEffectiveIndex(i)]); } // real working part int nRecord = 0; const int numProbValues = 3; // if multi-allelic/multi-haploid, this value can be different int maxProbValues = -1; while (bin->readRecord()) { // REprintf("read a record\n"); const BGenVariant& var = bin->getVariant(); const size_t sampleSize = bin->getNumEffectiveSample(); // store results here nRecord++; chrom.push_back(var.chrom); pos.push_back(var.pos); varId.push_back(var.varid); rsId.push_back(var.rsid); alleles.push_back(toString(var.alleles, ",")); isPhased.push_back(var.isPhased); prob.resize(nRecord); std::vector<double>& p = prob[nRecord - 1]; p.reserve(sampleSize * numProbValues); for (size_t i = 0; i != sampleSize; ++i) { int beg = var.index[bin->getEffectiveIndex(i)]; int end = var.index[bin->getEffectiveIndex(i) + 1]; if (end - beg > maxProbValues) { maxProbValues = end - beg; } for (int j = 0; j < numProbValues; ++j) { if (j < numProbValues) { p.push_back(var.prob[beg + j]); } else { p.push_back(-9); } } // REprintf("beg = %d, end = %d, prob[%d][%d] len = %d\n", beg,end, // nRecord - 1, i, p[i].size()); } // Rprintf("Done add indv\n"); } // end while if (maxProbValues > numProbValues) { REprintf("some sample has more than %d > %d probabilities per variant!\n", maxProbValues, numProbValues); } // pass value back to R (see Manual Chapter 5) std::vector<std::string> listNames; int retListIdx = 0; storeResult(chrom, ret, retListIdx++); storeResult(pos, ret, retListIdx++); storeResult(varId, ret, retListIdx++); storeResult(rsId, ret, retListIdx++); storeResult(alleles, ret, retListIdx++); storeResult(isPhased, ret, retListIdx++); storeResult(prob, ret, retListIdx); for (size_t i = 0; i != prob.size(); ++i) { SEXP s = VECTOR_ELT(VECTOR_ELT(ret, retListIdx), i); setDim(numProbValues, sampleSize, s); } retListIdx++; listNames.push_back("chrom"); listNames.push_back("pos"); listNames.push_back("varid"); listNames.push_back("rsid"); listNames.push_back("alleles"); listNames.push_back("isPhased"); listNames.push_back("probability"); // store sample ids // Rprintf("set sample id"); listNames.push_back("sampleId"); storeResult(idVec, ret, retListIdx++); // Rprintf("set list names\n"); SEXP sListNames; PROTECT(sListNames = allocVector(STRSXP, listNames.size())); numAllocated++; for (unsigned int i = 0; i != listNames.size(); ++i) { SET_STRING_ELT(sListNames, i, mkChar(listNames[i].c_str())); } setAttrib(ret, R_NamesSymbol, sListNames); // finish up UNPROTECT(numAllocated); // Rprintf("Unprotected: %d\n", (retListLen + 1)); return (ret); }
bool SqlitePreparedStatement::bindValue(KDbField *field, const QVariant& value, int par) { if (value.isNull()) { //no value to bind or the value is null: bind NULL int res = sqlite3_bind_null(m_sqlResult->prepared_st, par); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } return true; } if (field->isTextType()) { //! @todo optimize: make a static copy so SQLITE_STATIC can be used const QByteArray utf8String(value.toString().toUtf8()); int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, utf8String.constData(), utf8String.length(), SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } return true; } switch (field->type()) { case KDbField::Byte: case KDbField::ShortInteger: case KDbField::Integer: { //! @todo what about unsigned > INT_MAX ? bool ok; const int intValue = value.toInt(&ok); if (ok) { int res = sqlite3_bind_int(m_sqlResult->prepared_st, par, intValue); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } } else { int res = sqlite3_bind_null(m_sqlResult->prepared_st, par); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } } break; } case KDbField::Float: case KDbField::Double: { int res = sqlite3_bind_double(m_sqlResult->prepared_st, par, value.toDouble()); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } case KDbField::BigInteger: { //! @todo what about unsigned > LLONG_MAX ? bool ok; const qint64 int64Value = value.toLongLong(&ok); if (ok) { int res = sqlite3_bind_int64(m_sqlResult->prepared_st, par, int64Value); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } } else { int res = sqlite3_bind_null(m_sqlResult->prepared_st, par); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } } break; } case KDbField::Boolean: { int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, value.toBool() ? "1" : "0", 1, SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } case KDbField::Time: { int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, qPrintable(value.toTime().toString(Qt::ISODate)), QLatin1String("HH:MM:SS").size(), SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } case KDbField::Date: { int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, qPrintable(value.toDate().toString(Qt::ISODate)), QLatin1String("YYYY-MM-DD").size(), SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } case KDbField::DateTime: { int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, qPrintable(value.toDateTime().toString(Qt::ISODate)), QLatin1String("YYYY-MM-DDTHH:MM:SS").size(), SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } case KDbField::BLOB: { const QByteArray byteArray(value.toByteArray()); int res = sqlite3_bind_blob(m_sqlResult->prepared_st, par, byteArray.constData(), byteArray.size(), SQLITE_TRANSIENT /*??*/); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } break; } default: { sqliteWarning() << "unsupported field type:" << field->type() << "- NULL value bound to column #" << par; int res = sqlite3_bind_null(m_sqlResult->prepared_st, par); if (res != SQLITE_OK) { m_result.setServerErrorCode(res); storeResult(&m_result); return false; } } } //switch return true; }
//bool xBaseConnectionInternal::db_connect(QCString host, QCString user, // QCString password, unsigned short int port, QString socket) bool xBaseConnectionInternal::db_connect(const Predicate::ConnectionData& data) { // we have to migrate the xbase source database into a .kexi file // xbase source database directory will be in connectiondata // we can choose a KTemporaryFile for the destination .kexi file KexiMigration::MigrateManager xBase2KexiMigrateManager; // create a temporary .kexi file KTemporaryFile temporaryKexiFile; temporaryKexiFile.setSuffix( ".kexi" ); temporaryKexiFile.setAutoRemove( false ); if ( !temporaryKexiFile.open() ) { PreDrvDbg<<"Couldn't create .kexi file for exporting from xBase to .kexi"; return false; } tempDatabase = temporaryKexiFile.fileName(); Predicate::ConnectionData* kexiConnectionData = 0; kexiConnectionData = new Predicate::ConnectionData(); // set destination file name here. kexiConnectionData->driverName = Predicate::defaultFileBasedDriverName(); kexiConnectionData->setFileName( tempDatabase ); PreDrvDbg << "Current file name: " << tempDatabase; QString sourceDriverName = "xbase"; // get the source migration driver KexiMigration::KexiMigrate* sourceDriver = 0; sourceDriver = xBase2KexiMigrateManager.driver( sourceDriverName ); if(!sourceDriver || xBase2KexiMigrateManager.error()) { PreDrvDbg << "Import migrate driver error..."; return false; } KexiMigration::Data* md = new KexiMigration::Data(); md->keepData = true; md->destination = new KexiProjectData(*kexiConnectionData, tempDatabase); // Setup XBase connection data from input connection data passed //! TODO Check sanity of this md->source = new Predicate::ConnectionData(data); md->sourceName = ""; sourceDriver->setData(md); if ( !sourceDriver->performImport() ) { PreDrvDbg<<"Import failed"; return false; } // finished transferring xBase database into .kexi file // Get a driver to the destination database if ( internalDriver ) internalConn = internalDriver->createConnection(*kexiConnectionData); else return false; if (!internalConn || internalDriver->error()) { internalDriver->debugError(); return false; } if (!internalConn->connect()) { internalConn->debugError(); storeResult(); return false; } if (!internalConn->useDatabase(tempDatabase)) { internalConn->debugError(); storeResult(); return false; } // store mapping from xbase directory to .kexi file name for future use // Note: When a directory is specified ( as has to be done for xBase ), fileName() // will give directory name with an additional forward slash. dbPath() won't do so. // Need some more maintainable solution. dbMap[data.fileName()] = tempDatabase; return true; }