int qtDatabase::nextRecord()
{
result->next();
QSqlRecord record = result->record();
if(record.isEmpty()) return -1;
return 0;
}
//start id="insert"
bool MetaDataTable::insert(const MetaDataValue &ft) {
using namespace DbUtils;
QSqlDatabase db = DbConnectionSettings::lastSaved();
QSqlRecord record = db.record(m_tableName);
if (record.isEmpty() && !createMetadataTable()) {
qDebug() << "unable to create metadata: "
<< db.lastError().text();
return false;
}
m_insertQuery.bindValue(":artist", ft.artist());
m_insertQuery.bindValue(":title", ft.trackTitle());
m_insertQuery.bindValue(":album", ft.albumTitle());
m_insertQuery.bindValue(":track", ft.trackNumber());
QTime t = ft.trackTime();
int secs = QTime().secsTo(t);
m_insertQuery.bindValue(":time", secs);
m_insertQuery.bindValue(":genre", ft.genre());
m_insertQuery.bindValue(":filename", ft.fileName());
int pref = ft.preference().intValue();
m_insertQuery.bindValue(":preference", pref);
m_insertQuery.bindValue(":comment", ft.comment());
bool retval = m_insertQuery.exec();
if (!retval) {
qDebug() << m_insertQuery.lastError().text()
<< m_insertQuery.lastQuery();
abort();
}
emit inserted(ft);
return retval;
}
void update(QSqlDatabase* db, Tag& tag) {
QSqlQuery q(*db);
QSqlRecord r;
if(!QItem::isExists(db, "tags", "guid", QString::fromStdString(tag.guid), r))
{
r = QItem::load(db, "tags", "name", QString::fromUtf8(tag.name.c_str()));
if(!r.isEmpty())
{
tag.name = QItem::resolveConflict(db, r, QString::fromStdString(tag.guid), DELETE_ITEM("tags", "guid", QString::fromStdString(tag.guid)), tag.name);
}
q.prepare(INSERT_TAG(tag.guid, tag.name, tag.parentGuid, tag.updateSequenceNum));
}
else if(r.value("updateSequenceNum").toInt() < tag.updateSequenceNum)
{
qDebug() << r.value("updateSequenceNum").toInt() << r;
// update tag
q.prepare(UPDATE_TAG(tag.guid, tag.name, tag.parentGuid, tag.updateSequenceNum));
}
else
return;
QItem::executeQuery(q);
}
bool QSqlRecordProto::isEmpty() const
{
QSqlRecord *item = qscriptvalue_cast<QSqlRecord*>(thisObject());
if (item)
return item->isEmpty();
return false;
}
bool PoitemTableModel::insertRowIntoTable(const QSqlRecord& record)
{
if (record.isEmpty())
return true;
bool isNull = true;
for (int i = 0; i < record.count(); i++)
{
if (i == record.indexOf("poitem_pohead_id") ||
(record.value(i).toString().isEmpty() &&
(i == record.indexOf("poitem_status") ||
i == record.indexOf("poitem_vend_item_descrip") ||
i == record.indexOf("poitem_vend_uom") ||
i == record.indexOf("poitem_vend_item_number") ||
i == record.indexOf("poitem_comments") )))
continue;
isNull &= record.isNull(i);
}
if (isNull)
return true;
QSqlRecord newRecord(record);
if (! validRow(newRecord))
return false;
return QSqlRelationalTableModel::insertRowIntoTable(newRecord);
}
/**
* @brief cwRegionLoadTask::readProtoBufferFromDatabase
* @return This reads the proto buffer from the database
*/
QByteArray cwRegionLoadTask::readProtoBufferFromDatabase(bool* okay)
{
cwSQLManager::Transaction transaction(&Database, cwSQLManager::ReadOnly);
QSqlQuery selectObjectData(Database);
QString queryStr =
QString("SELECT protoBuffer FROM ObjectData where id = 1");
bool couldPrepare = selectObjectData.prepare(queryStr);
if(!couldPrepare) {
qDebug() << "Couldn't prepare select Caving Region:" << selectObjectData.lastError().databaseText() << queryStr;
}
//Extract the data
selectObjectData.exec();
QSqlRecord record = selectObjectData.record();
if(record.isEmpty()) {
qDebug() << "Hmmmm, no caving regions to load from protoBuffer";
*okay = false;
return QByteArray();
}
//Get the first row
selectObjectData.next();
*okay = true;
QByteArray data = selectObjectData.value(0).toByteArray();
return data;
}
int XSqlQuery::count()
{
QSqlRecord rec = record();
if (!rec.isEmpty())
return rec.count();
else
return 0;
}
void Scrap::setItem(const QSqlRecord &record)
{
if(!record.isEmpty()){
ui->number_lineEdit->setText(record.value("number").toString());
ui->operator_lineEdit->setText(record.value("name").toString());
ui->type_lineEdit->setText(record.value("type").toString());
ui->manufacturer_lineEdit->setText(record.value("manufacturer").toString());
}
}
int
QcOfflineCacheDatabase::has_tile(const QcTileSpec & tile_spec)
{
QSqlRecord record = select_one(TILE, QStringList(OFFLINE_COUNT), tile_where_clause(tile_spec));
if (record.isEmpty())
return 0;
else
return record.value(0).toInt();
}
int XSqlQuery::count()
{
QSqlRecord record = driver()->record(*this);
if (!record.isEmpty())
return record.count();
else
return 0;
}
void SqlQueryModel::generateRoleNames(const QSqlRecord &rec)
{
roles.clear();
if (rec.isEmpty()) {
for( int i = 0; i < record().count(); i++)
roles.insert(Qt::UserRole + i + 1, record().fieldName(i).toLocal8Bit());
} else {
for( int i = 0; i < rec.count(); i++)
roles.insert(Qt::UserRole + i + 1, rec.fieldName(i).toLocal8Bit());
}
}
QVariant XSqlQuery::value(const QString & name) const
{
if (name.isEmpty())
return QVariant();
QSqlRecord r = driver()->record(*this);
if (!r.isEmpty())
return value(r.position(name));
return QVariant();
}
QSqlRecord GenericDAO::getRecord(const QString& where, const QVariantList& bindValues, DBMode dbMode) const
{
DBPair* dbPair = DBPool::getInstance()->getInstanceDBPair();
Q_ASSERT(dbPair);
QSqlRecord rec = getRecord(dbPair->getDabase(dbMode), where, bindValues);
if (!rec.isEmpty())
return rec;
return dbMode == Local ? getRecord(dbPair->getDabaseRemote(), where, bindValues) : QSqlRecord();
}
WineConfiguration WineConfigurationsModel::configurationFromRecord(const QSqlRecord & record) const
{
WineConfiguration c;
if ( record.isEmpty() ) return c;
c.setWinePrefix(record.value("wineprefix").toString());
WineInstallationsModel *m = qtwineApp->wineInstallationsModel();
c.setWineInstallation( m->installationById(record.value("wineinstallation").toInt()) );
return c;
}
bool PlayListDb::removeEntry(QString playList, int pid) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QString tn = tableName(playList);
QSqlRecord record = db.record(tn);
Q_ASSERT(!record.isEmpty());
QString queryString=QString("delete from %1 where pid=%2")
.arg(tn).arg(pid);
QSqlQuery q(queryString);
qDebug() << queryString;
return q.isActive();
}
/* ********************************************************************* */
void TargetsDialog::aliasChanged()
{
QSqlRecord record = currentRecord();
if (!record.isEmpty() && record.value("alias") != ui->aliasLineEdit->text()) {
record.setValue("alias", ui->aliasLineEdit->text());
tableModel->setRecord(lastRowNumberSelected, record);
if (!tableModel->submit()) {
qWarning() << "LogBook: could not update target. Error is: " << tableModel->lastError();
}
}
ui->targetsListView->setCurrentIndex(tableModel->index(lastRowNumberSelected, 1));
}
void BarlowsDataMapper::modelChanged()
{
QSqlRecord record = currentRecord();
if (!record.isEmpty() && record.value("model") != widget->modelLineEdit->text()) {
record.setValue("model", widget->modelLineEdit->text());
tableModel->setRecord(lastRowNumberSelected, record);
if (!tableModel->submit()) {
qWarning() << "LogBook: could not update barlow. Error is: " << tableModel->lastError();
}
}
widget->barlowsListView->setCurrentIndex(tableModel->index(lastRowNumberSelected, 1));
}
void AccountingForm::initialUpdate()
{
QSqlRecord latestTreat = m_treats->record(m_treats->rowCount() - 1);
if (latestTreat.isEmpty())
{
return;
}
QString lastDate = latestTreat.value("dateoftreat").toString();
QStringList splittedDate = lastDate.split("-");
QDate curDate(splittedDate[0].toInt(), splittedDate[1].toInt(), splittedDate[2].toInt());
m_dateEdit->setDate(curDate);
}
int qtDatabase::populateTable(PARAM *p, int id)
{
int x,y,xmax,ymax;
if(db == NULL)
{
pvStatusMessage(p,255,0,0,"ERROR: qtDatabase::populateTable() db==NULL");
return -1;
}
// set table dimension
xmax = result->record().count();
//ymax = result->size();
ymax = result->numRowsAffected();
pvSetNumRows(p,id,ymax);
pvSetNumCols(p,id,xmax);
// populate table
QSqlRecord record = result->record();
if(record.isEmpty())
{
pvStatusMessage(p,255,0,0,"ERROR: qtDatabase::populateTable() record is empty");
return -1;
}
for(x=0; x<xmax; x++)
{ // write name of fields
pvSetTableText(p, id, x, -1, (const char *) record.fieldName(x).toUtf8());
}
result->next();
for(y=0; y<ymax; y++)
{ // write fields
QSqlRecord record = result->record();
for(x=0; x<xmax; x++)
{
QSqlField f = record.field(x);
if(f.isValid())
{
QVariant v = f.value();
pvSetTableText(p, id, x, y, (const char *) v.toString().toUtf8());
}
else
{
pvSetTableText(p, id, x, y, "ERROR:");
}
}
result->next();
}
return 0;
}
QPointF ServerModel::getUiScenePos(QString id){
QSqlRecord rec = getRecordById(id);
QString s;
if(!rec.isEmpty()){
s = rec.value(UI_SCENE_POS).toString();
}
if( s.isEmpty() ){
s = "0.0,0.0";
}
QStringList ls = s.split(",");
return QPoint( ls[0].toFloat(), ls[1].toFloat() );
}
QString FieldConcatModel::displayStringForRecord(QSqlRecord& record) const
{
QString data;
if (!record.isEmpty()) {
data = QString("");
foreach (QString field, fields) {
QVariant value = record.value(field);
if (value.isValid() && value.toString() != "") {
if (data == "") {
data.append(value.toString());
} else {
data.append(seperator).append(value.toString());
}
}
}
void
QcOfflineCacheDatabase::delete_tile(const QcTileSpec & tile_spec)
{
QString where = tile_where_clause(tile_spec);
QSqlRecord record = select_one(TILE, QStringList(OFFLINE_COUNT), where);
if (!record.isEmpty()) {
int offline_count = record.value(0).toInt();
if (offline_count > 1) {
KeyValuePair kwargs;
kwargs.insert(OFFLINE_COUNT, offline_count -1);
update(TILE, kwargs, where);
}
else
delete_row(TILE, where);
}
}
bool PlayListDb::removeFile(QString playList, QString path) {
QSqlDatabase db = DbConnectionSettings::lastSaved();
QString tn = tableName(playList);
QSqlRecord record = db.record(tn);
Q_ASSERT(!record.isEmpty());
QString queryString=QString("delete from %1 where FileName=:fileName order by pid limit 1")
.arg(tn);
if (db.driverName() == "QSQLITE") {
queryString=QString("delete from %1 where FileName=:fileName").arg(tn);
}
QSqlQuery q;
q.prepare(queryString);
q.bindValue("fileName", path);
if (!q.exec()) {
qDebug() << q.lastError().text() << q.lastQuery();
return false;
}
return true;
}
const char *qtDatabase::recordFieldValue(PARAM *p, int x)
{
QSqlRecord record = result->record();
if(record.isEmpty())
{
pvStatusMessage(p,255,0,0,"ERROR: qtDatabase::recordFieldValue(%d) record is empty", x);
return "ERROR:";
}
QSqlField f = record.field(x);
if(f.isValid())
{
QVariant v = f.value();
return v.toString().toUtf8();
}
else
{
pvStatusMessage(p,255,0,0,"ERROR: qtDatabase::recordFieldValue(%d) field is invalid", x);
return "ERROR:";
}
}
void
QcOfflineCacheDatabase::insert_tile(const QcTileSpec & tile_spec)
{
QString where = tile_where_clause(tile_spec);
QSqlRecord record = select_one(TILE, QStringList(OFFLINE_COUNT), where);
if (record.isEmpty()) {
int map_level_id = get_map_level_id(tile_spec);
KeyValuePair kwargs;
kwargs.insert(MAP_LEVEL_ID, map_level_id);
kwargs.insert(ROW, tile_spec.x());
kwargs.insert(COLUMN, tile_spec.y());
kwargs.insert(OFFLINE_COUNT, 1);
insert(TILE, kwargs);
} else {
int offline_count = record.value(0).toInt();
KeyValuePair kwargs;
kwargs.insert(OFFLINE_COUNT, offline_count +1);
update(TILE, kwargs, where);
}
}
void TargetsDialog::targetTypeChanged(const QString &newValue)
{
QSqlRecord record = currentRecord();
QModelIndexList list1 = typeTableModel->match(typeTableModel->index(0, 0), Qt::DisplayRole, record.value("target_type_id"));
Qt::MatchFlags flags = Qt::MatchExactly | Qt::MatchWrap;
QModelIndexList list2 = typeTableModel->match(typeTableModel->index(0, 1), Qt::DisplayRole, newValue, 1, flags);
if (!record.isEmpty() && !list1.isEmpty() && !list2.isEmpty()) {
QSqlRecord typeRecord1 = typeTableModel->record(list1[0].row());
QSqlRecord typeRecord2 = typeTableModel->record(list2[0].row());
if (typeRecord1.value("target_type_id").toInt() != typeRecord2.value("target_type_id").toInt()) {
record.setValue("target_type_id", typeRecord2.value("target_type_id").toInt());
tableModel->setRecord(lastRowNumberSelected, record);
if (!tableModel->submit()) {
qWarning() << "LogBook: could not update target. Error is: " << tableModel->lastError();
}
}
}
ui->targetsListView->setCurrentIndex(tableModel->index(lastRowNumberSelected, 1));
}
void Allocations::itemSelected(const QModelIndex ¤t, const QModelIndex &previous)
{
ui->buttonBox->button(QDialogButtonBox::Save)->setEnabled(current.isValid());
if(isEditMode()) return;
if(current.isValid()){
if(items_model){
QSqlRecord record = items_model->record(current.row());
if(!record.isEmpty()){
ui->from_location_lineEdit->setText(record.value("location").toString());
ui->from_operator_lineEdit->setText(record.value("name").toString());
}
else{
//current_id = 0;
}
}
}
else{
ui->from_location_lineEdit->clear();
ui->from_operator_lineEdit->clear();
}
}
void GameInfoWidget::setGame(QModelIndex gameIndex, QString apiName)
{
m_slideshow->stop();
m_dbGameApi = ApiSelector::getUsedApi(); //verifying if the user switched to another api
m_currentIndex = gameIndex;
QModelIndex id = m_currentIndex.sibling(m_currentIndex.row(), 1);
QSqlRecord record = m_games.find(id.data().toInt(), apiName);
if(!record.isEmpty())
{
if(!record.value("remote_game_id").isNull())
{
getRemoteGameInfos(record.value("remote_game_id").toInt());
}
QString title = record.value("name").toString();
int playedTime = record.value("playedtime").toInt();
QString formatedTime = this->formatTimeToString(playedTime);
//int lastPlayedTime = record.value("lasttimeplayed").toInt();
int emulatorUsed = record.value("emulator_used").toInt();
if(emulatorUsed != -1) {
Emulators emulators;
Emulator emu = emulators.getEmulator(emulatorUsed);
QString message = QString("<b>" + tr("Emulator") + "</b>: " + emu.emulatorName());
m_emulatorUsedLabel->setText(message);
} else {
m_emulatorUsedLabel->setText("");
}
m_gameTitle->setText(title);
m_playedTime->setText("<b>Game time</b>: " + formatedTime);
m_playButton->show();
}
}
HistoryEntry HistoryManager::getEntry(const QSqlRecord &record)
{
if (record.isEmpty())
{
return HistoryEntry();
}
QPixmap pixmap;
pixmap.loadFromData(record.field(QLatin1String("icon")).value().toByteArray());
HistoryEntry historyEntry;
historyEntry.url.setScheme(record.field(QLatin1String("scheme")).value().toString());
historyEntry.url.setHost(record.field(QLatin1String("host")).value().toString());
historyEntry.url.setPath(record.field(QLatin1String("path")).value().toString());
historyEntry.title = record.field(QLatin1String("title")).value().toString();
historyEntry.time = QDateTime::fromTime_t(record.field(QLatin1String("time")).value().toInt(), Qt::LocalTime);
historyEntry.icon = QIcon(pixmap);
historyEntry.identifier = record.field(QLatin1String("id")).value().toLongLong();
historyEntry.visits = record.field(QLatin1String("visits")).value().toInt();
historyEntry.typed = record.field(QLatin1String("typed")).value().toBool();
return historyEntry;
}
QString CacheDatabase::getField(const QString &what, const QString &where, const QString &value)
{
// If same return
if(what == where)
return QString::null;
// Create model
QSqlTableModel* model = new QSqlTableModel;
// Set table
model->setTable(CacheTableName);
// Edit stategy
model->setEditStrategy(QSqlTableModel::OnManualSubmit);
// Set filter
model->setFilter(QString("%1='%2'").arg(where, value));
// Run selection
model->select();
// Get record
QSqlRecord record = model->record(0);
// If not empty
if(!record.isEmpty())
// Get value
return record.value(record.indexOf(what)).toString();
// Return result
return QString::null;
}
