SQLStatementBackend.cpp [plain text]
#include "config.h"
#include "SQLStatementBackend.h"
#include "DatabaseBackend.h"
#include "Logging.h"
#include "SQLError.h"
#include "SQLResultSet.h"
#include "SQLStatement.h"
#include "SQLStatementCallback.h"
#include "SQLStatementErrorCallback.h"
#include "SQLValue.h"
#include "SQLiteDatabase.h"
#include "SQLiteStatement.h"
#include <wtf/text/CString.h>
namespace WebCore {
Ref<SQLStatementBackend> SQLStatementBackend::create(std::unique_ptr<SQLStatement> frontend,
const String& statement, const Vector<SQLValue>& arguments, int permissions)
{
return adoptRef(*new SQLStatementBackend(WTF::move(frontend), statement, arguments, permissions));
}
SQLStatementBackend::SQLStatementBackend(std::unique_ptr<SQLStatement> frontend,
const String& statement, const Vector<SQLValue>& arguments, int permissions)
: m_frontend(WTF::move(frontend))
, m_statement(statement.isolatedCopy())
, m_arguments(arguments)
, m_hasCallback(m_frontend->hasCallback())
, m_hasErrorCallback(m_frontend->hasErrorCallback())
, m_permissions(permissions)
{
m_frontend->setBackend(this);
}
SQLStatementBackend::~SQLStatementBackend()
{
}
SQLStatement* SQLStatementBackend::frontend()
{
return m_frontend.get();
}
PassRefPtr<SQLError> SQLStatementBackend::sqlError() const
{
return m_error;
}
PassRefPtr<SQLResultSet> SQLStatementBackend::sqlResultSet() const
{
return m_resultSet;
}
bool SQLStatementBackend::execute(DatabaseBackend& db)
{
ASSERT(!m_resultSet);
clearFailureDueToQuota();
if (m_error)
return false;
db.setAuthorizerPermissions(m_permissions);
SQLiteDatabase& database = db.sqliteDatabase();
SQLiteStatement statement(database, m_statement);
int result = statement.prepare();
if (result != SQLITE_OK) {
LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database.lastErrorMsg());
if (result == SQLITE_INTERRUPT)
m_error = SQLError::create(SQLError::DATABASE_ERR, "could not prepare statement", result, "interrupted");
else
m_error = SQLError::create(SQLError::SYNTAX_ERR, "could not prepare statement", result, database.lastErrorMsg());
return false;
}
if (statement.bindParameterCount() != m_arguments.size()) {
LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
m_error = SQLError::create(db.isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
return false;
}
for (unsigned i = 0; i < m_arguments.size(); ++i) {
result = statement.bindValue(i + 1, m_arguments[i]);
if (result == SQLITE_FULL) {
setFailureDueToQuota();
return false;
}
if (result != SQLITE_OK) {
LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
m_error = SQLError::create(SQLError::DATABASE_ERR, "could not bind value", result, database.lastErrorMsg());
return false;
}
}
RefPtr<SQLResultSet> resultSet = SQLResultSet::create();
result = statement.step();
switch (result) {
case SQLITE_ROW: {
int columnCount = statement.columnCount();
SQLResultSetRowList* rows = resultSet->rows();
for (int i = 0; i < columnCount; i++)
rows->addColumn(statement.getColumnName(i));
do {
for (int i = 0; i < columnCount; i++)
rows->addResult(statement.getColumnValue(i));
result = statement.step();
} while (result == SQLITE_ROW);
if (result != SQLITE_DONE) {
m_error = SQLError::create(SQLError::DATABASE_ERR, "could not iterate results", result, database.lastErrorMsg());
return false;
}
break;
}
case SQLITE_DONE: {
if (db.lastActionWasInsert())
resultSet->setInsertId(database.lastInsertRowID());
break;
}
case SQLITE_FULL:
setFailureDueToQuota();
return false;
case SQLITE_CONSTRAINT:
m_error = SQLError::create(SQLError::CONSTRAINT_ERR, "could not execute statement due to a constaint failure", result, database.lastErrorMsg());
return false;
default:
m_error = SQLError::create(SQLError::DATABASE_ERR, "could not execute statement", result, database.lastErrorMsg());
return false;
}
resultSet->setRowsAffected(database.lastChanges());
m_resultSet = resultSet;
return true;
}
void SQLStatementBackend::setDatabaseDeletedError()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(SQLError::UNKNOWN_ERR, "unable to execute statement, because the user deleted the database");
}
void SQLStatementBackend::setVersionMismatchedError()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(SQLError::VERSION_ERR, "current version of the database and `oldVersion` argument do not match");
}
void SQLStatementBackend::setFailureDueToQuota()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(SQLError::QUOTA_ERR, "there was not enough remaining storage space, or the storage quota was reached and the user declined to allow more space");
}
void SQLStatementBackend::clearFailureDueToQuota()
{
if (lastExecutionFailedDueToQuota())
m_error = nullptr;
}
bool SQLStatementBackend::lastExecutionFailedDueToQuota() const
{
return m_error && m_error->code() == SQLError::QUOTA_ERR;
}
}