This source file includes following definitions.
- create
- m_permissions
- trace
- frontend
- sqlError
- sqlResultSet
- execute
- setVersionMismatchedError
- setFailureDueToQuota
- clearFailureDueToQuota
- lastExecutionFailedDueToQuota
#include "config.h"
#include "modules/webdatabase/SQLStatementBackend.h"
#include "platform/Logging.h"
#include "modules/webdatabase/sqlite/SQLiteDatabase.h"
#include "modules/webdatabase/sqlite/SQLiteStatement.h"
#include "modules/webdatabase/AbstractSQLStatement.h"
#include "modules/webdatabase/DatabaseBackend.h"
#include "modules/webdatabase/SQLError.h"
#include "wtf/text/CString.h"
namespace WebCore {
PassRefPtrWillBeRawPtr<SQLStatementBackend> SQLStatementBackend::create(PassOwnPtr<AbstractSQLStatement> frontend,
const String& statement, const Vector<SQLValue>& arguments, int permissions)
{
return adoptRefWillBeNoop(new SQLStatementBackend(frontend, statement, arguments, permissions));
}
SQLStatementBackend::SQLStatementBackend(PassOwnPtr<AbstractSQLStatement> frontend,
const String& statement, const Vector<SQLValue>& arguments, int permissions)
: m_frontend(frontend)
, m_statement(statement.isolatedCopy())
, m_arguments(arguments)
, m_hasCallback(m_frontend->hasCallback())
, m_hasErrorCallback(m_frontend->hasErrorCallback())
, m_resultSet(SQLResultSet::create())
, m_permissions(permissions)
{
m_frontend->setBackend(this);
}
void SQLStatementBackend::trace(Visitor* visitor)
{
visitor->trace(m_resultSet);
}
AbstractSQLStatement* SQLStatementBackend::frontend()
{
return m_frontend.get();
}
SQLErrorData* SQLStatementBackend::sqlError() const
{
return m_error.get();
}
SQLResultSet* SQLStatementBackend::sqlResultSet() const
{
return m_resultSet->isValid() ? m_resultSet.get() : 0;
}
bool SQLStatementBackend::execute(DatabaseBackend* db)
{
ASSERT(!m_resultSet->isValid());
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 != SQLResultOk) {
WTF_LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database->lastErrorMsg());
if (result == SQLResultInterrupt)
m_error = SQLErrorData::create(SQLError::DATABASE_ERR, "could not prepare statement", result, "interrupted");
else
m_error = SQLErrorData::create(SQLError::SYNTAX_ERR, "could not prepare statement", result, database->lastErrorMsg());
db->reportExecuteStatementResult(1, m_error->code(), result);
return false;
}
if (statement.bindParameterCount() != m_arguments.size()) {
WTF_LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
m_error = SQLErrorData::create(db->isInterrupted() ? SQLError::DATABASE_ERR : SQLError::SYNTAX_ERR, "number of '?'s in statement string does not match argument count");
db->reportExecuteStatementResult(2, m_error->code(), 0);
return false;
}
for (unsigned i = 0; i < m_arguments.size(); ++i) {
result = statement.bindValue(i + 1, m_arguments[i]);
if (result == SQLResultFull) {
setFailureDueToQuota(db);
return false;
}
if (result != SQLResultOk) {
WTF_LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
db->reportExecuteStatementResult(3, SQLError::DATABASE_ERR, result);
m_error = SQLErrorData::create(SQLError::DATABASE_ERR, "could not bind value", result, database->lastErrorMsg());
return false;
}
}
result = statement.step();
if (result == SQLResultRow) {
int columnCount = statement.columnCount();
SQLResultSetRowList* rows = m_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 == SQLResultRow);
if (result != SQLResultDone) {
db->reportExecuteStatementResult(4, SQLError::DATABASE_ERR, result);
m_error = SQLErrorData::create(SQLError::DATABASE_ERR, "could not iterate results", result, database->lastErrorMsg());
return false;
}
} else if (result == SQLResultDone) {
if (db->lastActionWasInsert())
m_resultSet->setInsertId(database->lastInsertRowID());
} else if (result == SQLResultFull) {
setFailureDueToQuota(db);
return false;
} else if (result == SQLResultConstraint) {
db->reportExecuteStatementResult(6, SQLError::CONSTRAINT_ERR, result);
m_error = SQLErrorData::create(SQLError::CONSTRAINT_ERR, "could not execute statement due to a constaint failure", result, database->lastErrorMsg());
return false;
} else {
db->reportExecuteStatementResult(5, SQLError::DATABASE_ERR, result);
m_error = SQLErrorData::create(SQLError::DATABASE_ERR, "could not execute statement", result, database->lastErrorMsg());
return false;
}
m_resultSet->setRowsAffected(database->lastChanges());
db->reportExecuteStatementResult(0, -1, 0);
return true;
}
void SQLStatementBackend::setVersionMismatchedError(DatabaseBackend* database)
{
ASSERT(!m_error && !m_resultSet->isValid());
database->reportExecuteStatementResult(7, SQLError::VERSION_ERR, 0);
m_error = SQLErrorData::create(SQLError::VERSION_ERR, "current version of the database and `oldVersion` argument do not match");
}
void SQLStatementBackend::setFailureDueToQuota(DatabaseBackend* database)
{
ASSERT(!m_error && !m_resultSet->isValid());
database->reportExecuteStatementResult(8, SQLError::QUOTA_ERR, 0);
m_error = SQLErrorData::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;
}
}