SQLTransactionBackendSync.cpp [plain text]
#include "config.h"
#include "SQLTransactionBackendSync.h"
#if ENABLE(SQL_DATABASE)
#include "DatabaseAuthorizer.h"
#include "DatabaseBackendContext.h"
#include "DatabaseSync.h"
#include "SQLException.h"
#include "SQLResultSet.h"
#include "SQLStatementSync.h"
#include "SQLTransactionClient.h"
#include "SQLTransactionSync.h"
#include "SQLTransactionSyncCallback.h"
#include "SQLValue.h"
#include "SQLiteTransaction.h"
#include "ScriptExecutionContext.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
SQLTransactionBackendSync::SQLTransactionBackendSync(DatabaseSync* db, PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly)
: m_database(db)
, m_callback(callback)
, m_readOnly(readOnly)
, m_hasVersionMismatch(false)
, m_modifiedDatabase(false)
, m_transactionClient(std::make_unique<SQLTransactionClient>())
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
}
SQLTransactionBackendSync::~SQLTransactionBackendSync()
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
if (m_sqliteTransaction && m_sqliteTransaction->inProgress())
rollback();
}
PassRefPtr<SQLResultSet> SQLTransactionBackendSync::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, ExceptionCode& ec)
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
m_database->setLastErrorMessage("");
if (!m_database->opened()) {
m_database->setLastErrorMessage("cannot executeSQL because the database is not open");
ec = SQLException::UNKNOWN_ERR;
return 0;
}
if (m_hasVersionMismatch) {
m_database->setLastErrorMessage("cannot executeSQL because there is a version mismatch");
ec = SQLException::VERSION_ERR;
return 0;
}
if (sqlStatement.isEmpty())
return 0;
int permissions = DatabaseAuthorizer::ReadWriteMask;
if (!m_database->databaseContext()->allowDatabaseAccess())
permissions |= DatabaseAuthorizer::NoAccessMask;
else if (m_readOnly)
permissions |= DatabaseAuthorizer::ReadOnlyMask;
SQLStatementSync statement(sqlStatement, arguments, permissions);
m_database->resetAuthorizer();
bool retryStatement = true;
RefPtr<SQLResultSet> resultSet;
while (retryStatement) {
retryStatement = false;
resultSet = statement.execute(m_database.get(), ec);
if (!resultSet) {
if (m_sqliteTransaction->wasRolledBackBySqlite())
return 0;
if (ec == SQLException::QUOTA_ERR) {
if (m_transactionClient->didExceedQuota(database())) {
ec = 0;
retryStatement = true;
} else {
m_database->setLastErrorMessage("there was not enough remaining storage space");
return 0;
}
}
}
}
if (m_database->lastActionChangedDatabase())
m_modifiedDatabase = true;
return resultSet.release();
}
ExceptionCode SQLTransactionBackendSync::begin()
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
if (!m_database->opened()) {
m_database->setLastErrorMessage("cannot begin transaction because the database is not open");
return SQLException::UNKNOWN_ERR;
}
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
if (!m_readOnly)
m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
ASSERT(!m_sqliteTransaction);
m_sqliteTransaction = std::make_unique<SQLiteTransaction>(m_database->sqliteDatabase(), m_readOnly);
m_database->resetDeletes();
m_database->disableAuthorizer();
m_sqliteTransaction->begin();
m_database->enableAuthorizer();
if (!m_sqliteTransaction->inProgress()) {
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
m_database->setLastErrorMessage("unable to begin transaction",
m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
m_sqliteTransaction = nullptr;
return SQLException::DATABASE_ERR;
}
String actualVersion;
if (!m_database->getActualVersionForTransaction(actualVersion)) {
m_database->setLastErrorMessage("unable to read version",
m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
rollback();
return SQLException::DATABASE_ERR;
}
m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
return 0;
}
ExceptionCode SQLTransactionBackendSync::execute()
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
if (!m_database->opened() || (m_callback && !m_callback->handleEvent(SQLTransactionSync::from(this)))) {
if (m_database->lastErrorMessage().isEmpty())
m_database->setLastErrorMessage("failed to execute transaction callback");
m_callback = 0;
return SQLException::UNKNOWN_ERR;
}
m_callback = 0;
return 0;
}
ExceptionCode SQLTransactionBackendSync::commit()
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
if (!m_database->opened()) {
m_database->setLastErrorMessage("unable to commit transaction because the database is not open.");
return SQLException::UNKNOWN_ERR;
}
ASSERT(m_sqliteTransaction);
m_database->disableAuthorizer();
m_sqliteTransaction->commit();
m_database->enableAuthorizer();
if (m_sqliteTransaction->inProgress()) {
m_database->setLastErrorMessage("unable to commit transaction",
m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
return SQLException::DATABASE_ERR;
}
m_sqliteTransaction = nullptr;
if (m_database->hadDeletes())
m_database->incrementalVacuumIfNeeded();
if (m_modifiedDatabase)
m_transactionClient->didCommitWriteTransaction(database());
return 0;
}
void SQLTransactionBackendSync::rollback()
{
ASSERT(m_database->scriptExecutionContext()->isContextThread());
m_database->disableAuthorizer();
if (m_sqliteTransaction) {
m_sqliteTransaction->rollback();
m_sqliteTransaction = nullptr;
}
m_database->enableAuthorizer();
ASSERT(!m_database->sqliteDatabase().transactionInProgress());
}
}
#endif // ENABLE(SQL_DATABASE)