void IDBObjectStoreBackendImpl::deleteInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBKey> key, PassRefPtr<IDBCallbacks> callbacks)
{
SQLiteStatement idQuery(objectStore->sqliteDatabase(), "SELECT id FROM ObjectStoreData " + whereClause(key.get()));
bool ok = idQuery.prepare() == SQLResultOk;
ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
bindWhereClause(idQuery, objectStore->id(), key.get());
if (idQuery.step() != SQLResultRow) {
callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::NOT_FOUND_ERR, "Key does not exist in the object store."));
return;
}
int64_t id = idQuery.getColumnInt64(0);
SQLiteStatement osQuery(objectStore->sqliteDatabase(), "DELETE FROM ObjectStoreData WHERE id = ?");
ok = osQuery.prepare() == SQLResultOk;
ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
osQuery.bindInt64(1, id);
ok = osQuery.step() == SQLResultDone;
ASSERT_UNUSED(ok, ok);
SQLiteStatement indexQuery(objectStore->sqliteDatabase(), "DELETE FROM IndexData WHERE objectStoreDataId = ?");
ok = indexQuery.prepare() == SQLResultOk;
ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
indexQuery.bindInt64(1, id);
ok = indexQuery.step() == SQLResultDone;
ASSERT_UNUSED(ok, ok);
callbacks->onSuccess();
}
double Soprano::Index::CLuceneIndex::getScore( const Soprano::Node& resource, lucene::search::Query* query )
{
QMutexLocker lock( &d->mutex );
clearError();
try {
// rewrite the query
lucene::index::Term queryTerm( idFieldName().data(), TString( d->getId( resource ) ).data() );
lucene::search::TermQuery idQuery( &queryTerm );
lucene::search::BooleanQuery combinedQuery;
combinedQuery.add( &idQuery, true, false );
combinedQuery.add( query, true, false );
// fetch the score when the URI matches the original query
lucene::search::TopDocs* docs = static_cast<lucene::search::Searchable*>( d->getIndexSearcher() )->_search( &combinedQuery, 0, 1 );
double r = -1.0;
if ( docs->totalHits > 0 ) {
#ifdef CL_VERSION_19_OR_GREATER
r = docs->scoreDocs[0].score;
#else
r = docs->scoreDocs[0]->score;
#endif
}
_CLDELETE( docs );
return r;
}
catch( CLuceneError& err ) {
qDebug() << "search failed: " << err.what();
setError( exceptionToError( err ) );
return 0.0;
}
}
bool UserDataAccess::storeKeyboardLayout(KeyboardLayout* keyboardLayout)
{
QSqlDatabase db = database();
if (!db.isOpen())
return false;
if (!db.transaction())
{
kWarning() << db.lastError().text();
raiseError(db.lastError());
return false;
}
QSqlQuery cleanUpKeyCharsQuery(db);
cleanUpKeyCharsQuery.prepare("DELETE FROM keyboard_layout_key_chars WHERE key_id IN (SELECT id FROM keyboard_layout_keys WHERE keyboard_layout_id = ?)");
cleanUpKeyCharsQuery.bindValue(0, keyboardLayout->id());
cleanUpKeyCharsQuery.exec();
if (cleanUpKeyCharsQuery.lastError().isValid())
{
kWarning() << cleanUpKeyCharsQuery.lastError().text();
raiseError(cleanUpKeyCharsQuery.lastError());
db.rollback();
return false;
}
QSqlQuery cleanUpKeysQuery(db);
cleanUpKeysQuery.prepare("DELETE FROM keyboard_layout_keys WHERE keyboard_layout_id = ?");
cleanUpKeysQuery.bindValue(0, keyboardLayout->id());
cleanUpKeysQuery.exec();
if (cleanUpKeysQuery.lastError().isValid())
{
kWarning() << cleanUpKeysQuery.lastError().text();
raiseError(cleanUpKeysQuery.lastError());
db.rollback();
return false;
}
QSqlQuery cleanUpKeyboardLayoutQuery(db);
cleanUpKeyboardLayoutQuery.prepare("DELETE FROM keyboard_layouts WHERE id = ?");
cleanUpKeyboardLayoutQuery.bindValue(0, keyboardLayout->id());
cleanUpKeyboardLayoutQuery.exec();
if (cleanUpKeyboardLayoutQuery.lastError().isValid())
{
kWarning() << cleanUpKeyboardLayoutQuery.lastError().text();
raiseError(cleanUpKeyboardLayoutQuery.lastError());
db.rollback();
return false;
}
QSqlQuery insertKeyboardLayoutQuery(db);
insertKeyboardLayoutQuery.prepare("INSERT INTO keyboard_layouts (id, title, name, width, height) VALUES (?, ?, ?, ?, ?)");
insertKeyboardLayoutQuery.bindValue(0, keyboardLayout->id());
insertKeyboardLayoutQuery.bindValue(1, keyboardLayout->title());
insertKeyboardLayoutQuery.bindValue(2, keyboardLayout->name());
insertKeyboardLayoutQuery.bindValue(3, keyboardLayout->width());
insertKeyboardLayoutQuery.bindValue(4, keyboardLayout->height());
insertKeyboardLayoutQuery.exec();
if (insertKeyboardLayoutQuery.lastError().isValid())
{
kWarning() << insertKeyboardLayoutQuery.lastError().text();
raiseError(insertKeyboardLayoutQuery.lastError());
db.rollback();
return false;
}
QSqlQuery insertKeyQuery(db);
QSqlQuery insertSpecialKeyQuery(db);
QSqlQuery insertKeyCharQuery(db);
QSqlQuery idQuery(db);
insertKeyQuery.prepare("INSERT INTO keyboard_layout_keys (keyboard_layout_id, left, top, width, height, type, finger_index, has_haptic_marker) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
insertKeyQuery.bindValue(0, keyboardLayout->id());
insertKeyQuery.bindValue(5, KeyId);
insertSpecialKeyQuery.prepare("INSERT INTO keyboard_layout_keys (keyboard_layout_id, left, top, width, height, type, special_key_type, modifier_id, label) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
insertSpecialKeyQuery.bindValue(0, keyboardLayout->id());
insertSpecialKeyQuery.bindValue(5, SpecialKeyId);
insertKeyCharQuery.prepare("INSERT INTO keyboard_layout_key_chars (key_id, position, character, modifier) VALUES (?, ?, ?, ?)");
idQuery.prepare("SELECT last_insert_rowid()");
for (int i = 0; i < keyboardLayout->keyCount(); i++)
{
AbstractKey* const abstractKey = keyboardLayout->key(i);
if (Key* const key = qobject_cast<Key*>(abstractKey))
{
insertKeyQuery.bindValue(1, key->left());
insertKeyQuery.bindValue(2, key->top());
insertKeyQuery.bindValue(3, key->width());
insertKeyQuery.bindValue(4, key->height());
insertKeyQuery.bindValue(6, key->fingerIndex());
insertKeyQuery.bindValue(7, key->hasHapticMarker());
insertKeyQuery.exec();
if (insertKeyQuery.lastError().isValid())
{
kWarning() << insertKeyQuery.lastError().text();
raiseError(insertKeyQuery.lastError());
db.rollback();
return false;
}
idQuery.exec();
if (idQuery.lastError().isValid())
{
kWarning() << idQuery.lastError().text();
raiseError(idQuery.lastError());
db.rollback();
return false;
}
idQuery.next();
const int keyId = idQuery.value(0).toInt();
insertKeyCharQuery.bindValue(0, keyId);
for (int j = 0; j < key->keyCharCount(); j++)
{
KeyChar * const keyChar = key->keyChar(j);
insertKeyCharQuery.bindValue(1, keyChar->position());
insertKeyCharQuery.bindValue(2, QString(keyChar->value()));
insertKeyCharQuery.bindValue(3, keyChar->modifier());
insertKeyCharQuery.exec();
if (insertKeyCharQuery.lastError().isValid())
{
kWarning() << insertKeyCharQuery.lastError().text();
raiseError(insertKeyCharQuery.lastError());
db.rollback();
return false;
}
}
}
if (SpecialKey* const specialKey = qobject_cast<SpecialKey*>(abstractKey))
{
insertSpecialKeyQuery.bindValue(1, specialKey->left());
insertSpecialKeyQuery.bindValue(2, specialKey->top());
insertSpecialKeyQuery.bindValue(3, specialKey->width());
insertSpecialKeyQuery.bindValue(4, specialKey->height());
insertSpecialKeyQuery.bindValue(6, specialKey->typeStr());
insertSpecialKeyQuery.bindValue(7, specialKey->modifierId());
insertSpecialKeyQuery.bindValue(8, specialKey->label());
insertSpecialKeyQuery.exec();
if (insertSpecialKeyQuery.lastError().isValid())
{
kWarning() << insertSpecialKeyQuery.lastError().text();
raiseError(insertSpecialKeyQuery.lastError());
db.rollback();
return false;
}
}
}
if(!db.commit())
{
kWarning() << db.lastError().text();
raiseError(db.lastError());
db.rollback();
return false;
}
return true;
}
