#include "config.h"
#include "SQLStatement.h"
#if ENABLE(DATABASE)
#include "Database.h"
#include "DatabaseAuthorizer.h"
#include "Logging.h"
#include "SQLError.h"
#include "SQLiteDatabase.h"
#include "SQLiteStatement.h"
#include "SQLResultSet.h"
#include "SQLStatementCallback.h"
#include "SQLStatementErrorCallback.h"
#include "SQLTransaction.h"
#include "SQLValue.h"
namespace WebCore {
PassRefPtr<SQLStatement> SQLStatement::create(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback, bool readOnly)
{
return adoptRef(new SQLStatement(statement, arguments, callback, errorCallback, readOnly));
}
SQLStatement::SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback, bool readOnly)
: m_statement(statement.copy())
, m_arguments(arguments)
, m_statementCallback(callback)
, m_statementErrorCallback(errorCallback)
, m_readOnly(readOnly)
{
}
bool SQLStatement::execute(Database* db)
{
ASSERT(!m_resultSet);
clearFailureDueToQuota();
if (m_error)
return false;
if (m_readOnly)
db->setAuthorizerReadOnly();
SQLiteDatabase* database = &db->m_sqliteDatabase;
SQLiteStatement statement(*database, m_statement);
int result = statement.prepare();
if (result != SQLResultOk) {
LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database->lastErrorMsg());
m_error = SQLError::create(1, 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(1, "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 == SQLResultFull) {
setFailureDueToQuota();
return false;
}
if (result != SQLResultOk) {
LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
m_error = SQLError::create(1, database->lastErrorMsg());
return false;
}
}
RefPtr<SQLResultSet> resultSet = SQLResultSet::create();
result = statement.step();
if (result == SQLResultRow) {
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 == SQLResultRow);
if (result != SQLResultDone) {
m_error = SQLError::create(1, database->lastErrorMsg());
return false;
}
} else if (result == SQLResultDone) {
if (db->m_databaseAuthorizer->lastActionWasInsert())
resultSet->setInsertId(database->lastInsertRowID());
} else if (result == SQLResultFull) {
setFailureDueToQuota();
return false;
} else {
m_error = SQLError::create(1, database->lastErrorMsg());
return false;
}
resultSet->setRowsAffected(database->lastChanges());
m_resultSet = resultSet;
return true;
}
void SQLStatement::setDatabaseDeletedError()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(0, "unable to execute statement, because the user deleted the database");
}
void SQLStatement::setVersionMismatchedError()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(2, "current version of the database and `oldVersion` argument do not match");
}
bool SQLStatement::performCallback(SQLTransaction* transaction)
{
ASSERT(transaction);
bool callbackError = false;
if (m_error) {
ASSERT(m_statementErrorCallback);
callbackError = m_statementErrorCallback->handleEvent(transaction, m_error.get());
} else if (m_statementCallback)
m_statementCallback->handleEvent(transaction, m_resultSet.get(), callbackError);
m_statementCallback = 0;
m_statementErrorCallback = 0;
return callbackError;
}
void SQLStatement::setFailureDueToQuota()
{
ASSERT(!m_error && !m_resultSet);
m_error = SQLError::create(4, "there was not enough remaining storage space, or the storage quota was reached and the user declined to allow more space");
}
void SQLStatement::clearFailureDueToQuota()
{
if (lastExecutionFailedDueToQuota())
m_error = 0;
}
bool SQLStatement::lastExecutionFailedDueToQuota() const
{
return m_error && m_error->code() == 4;
}
}
#endif // ENABLE(DATABASE)