src/third_party/WebKit/Source/modules/webdatabase/sqlite/SQLiteDatabase.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "modules/webdatabase/sqlite/SQLiteDatabase.h"
  29
  30 #include <sqlite3.h>
  31 #include "platform/Logging.h"
  32 #include "modules/webdatabase/sqlite/SQLiteFileSystem.h"
  33 #include "modules/webdatabase/sqlite/SQLiteStatement.h"
  34 #include "modules/webdatabase/DatabaseAuthorizer.h"
  35
  36 namespace blink {
  37
  38 const int SQLResultDone = SQLITE_DONE;
  39 const int SQLResultOk = SQLITE_OK;
  40 const int SQLResultRow = SQLITE_ROW;
  41 const int SQLResultFull = SQLITE_FULL;
  42 const int SQLResultInterrupt = SQLITE_INTERRUPT;
  43 const int SQLResultConstraint = SQLITE_CONSTRAINT;
  44
  45 static const char notOpenErrorMessage[] = "database is not open";
  46
  47 SQLiteDatabase::SQLiteDatabase()
  48     : m_db(0)
  49     , m_pageSize(-1)
  50     , m_transactionInProgress(false)
  51     , m_sharable(false)
  52     , m_openingThread(0)
  53     , m_openError(SQLITE_ERROR)
  54     , m_openErrorMessage()
  55     , m_lastChangesCount(0)
  56 {
  57 }
  58
  59 SQLiteDatabase::~SQLiteDatabase()
  60 {
  61     close();
  62 }
  63
  64 bool SQLiteDatabase::open(const String& filename, bool forWebSQLDatabase)
  65 {
  66     close();
  67
  68     m_openError = SQLiteFileSystem::openDatabase(filename, &m_db, forWebSQLDatabase);
  69     if (m_openError != SQLITE_OK) {
  70         m_openErrorMessage = m_db ? sqlite3_errmsg(m_db) : "sqlite_open returned null";
  71         WTF_LOG_ERROR("SQLite database failed to load from %s\nCause - %s", filename.ascii().data(),
  72             m_openErrorMessage.data());
  73         sqlite3_close(m_db);
  74         m_db = 0;
  75         return false;
  76     }
  77
  78     m_openError = sqlite3_extended_result_codes(m_db, 1);
  79     if (m_openError != SQLITE_OK) {
  80         m_openErrorMessage = sqlite3_errmsg(m_db);
  81         WTF_LOG_ERROR("SQLite database error when enabling extended errors - %s", m_openErrorMessage.data());
  82         sqlite3_close(m_db);
  83         m_db = 0;
  84         return false;
  85     }
  86
  87     if (isOpen())
  88         m_openingThread = currentThread();
  89     else
  90         m_openErrorMessage = "sqlite_open returned null";
  91
  92     if (!SQLiteStatement(*this, "PRAGMA temp_store = MEMORY;").executeCommand())
  93         WTF_LOG_ERROR("SQLite database could not set temp_store to memory");
  94
  95     return isOpen();
  96 }
  97
  98 void SQLiteDatabase::close()
  99 {
 100     if (m_db) {
 101         // FIXME: This is being called on the main thread during JS GC. <rdar://problem/5739818>
 102         // ASSERT(currentThread() == m_openingThread);
 103         sqlite3* db = m_db;
 104         {
 105             MutexLocker locker(m_databaseClosingMutex);
 106             m_db = 0;
 107         }
 108         sqlite3_close(db);
 109     }
 110
 111     m_openingThread = 0;
 112     m_openError = SQLITE_ERROR;
 113     m_openErrorMessage = CString();
 114 }
 115
 116 void SQLiteDatabase::setMaximumSize(int64_t size)
 117 {
 118     if (size < 0)
 119         size = 0;
 120
 121     int currentPageSize = pageSize();
 122
 123     ASSERT(currentPageSize || !m_db);
 124     int64_t newMaxPageCount = currentPageSize ? size / currentPageSize : 0;
 125
 126     MutexLocker locker(m_authorizerLock);
 127     enableAuthorizer(false);
 128
 129     SQLiteStatement statement(*this, "PRAGMA max_page_count = " + String::number(newMaxPageCount));
 130     statement.prepare();
 131     if (statement.step() != SQLResultRow)
 132 #if OS(WIN)
 133         WTF_LOG_ERROR("Failed to set maximum size of database to %I64i bytes", static_cast<long long>(size));
 134 #else
 135         WTF_LOG_ERROR("Failed to set maximum size of database to %lli bytes", static_cast<long long>(size));
 136 #endif
 137
 138     enableAuthorizer(true);
 139
 140 }
 141
 142 int SQLiteDatabase::pageSize()
 143 {
 144     // Since the page size of a database is locked in at creation and therefore cannot be dynamic,
 145     // we can cache the value for future use
 146     if (m_pageSize == -1) {
 147         MutexLocker locker(m_authorizerLock);
 148         enableAuthorizer(false);
 149
 150         SQLiteStatement statement(*this, "PRAGMA page_size");
 151         m_pageSize = statement.getColumnInt(0);
 152
 153         enableAuthorizer(true);
 154     }
 155
 156     return m_pageSize;
 157 }
 158
 159 int64_t SQLiteDatabase::freeSpaceSize()
 160 {
 161     int64_t freelistCount = 0;
 162
 163     {
 164         MutexLocker locker(m_authorizerLock);
 165         enableAuthorizer(false);
 166         // Note: freelist_count was added in SQLite 3.4.1.
 167         SQLiteStatement statement(*this, "PRAGMA freelist_count");
 168         freelistCount = statement.getColumnInt64(0);
 169         enableAuthorizer(true);
 170     }
 171
 172     return freelistCount * pageSize();
 173 }
 174
 175 int64_t SQLiteDatabase::totalSize()
 176 {
 177     int64_t pageCount = 0;
 178
 179     {
 180         MutexLocker locker(m_authorizerLock);
 181         enableAuthorizer(false);
 182         SQLiteStatement statement(*this, "PRAGMA page_count");
 183         pageCount = statement.getColumnInt64(0);
 184         enableAuthorizer(true);
 185     }
 186
 187     return pageCount * pageSize();
 188 }
 189
 190 void SQLiteDatabase::setBusyTimeout(int ms)
 191 {
 192     if (m_db)
 193         sqlite3_busy_timeout(m_db, ms);
 194     else
 195         WTF_LOG(SQLDatabase, "BusyTimeout set on non-open database");
 196 }
 197
 198 bool SQLiteDatabase::executeCommand(const String& sql)
 199 {
 200     return SQLiteStatement(*this, sql).executeCommand();
 201 }
 202
 203 bool SQLiteDatabase::tableExists(const String& tablename)
 204 {
 205     if (!isOpen())
 206         return false;
 207
 208     String statement = "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '" + tablename + "';";
 209
 210     SQLiteStatement sql(*this, statement);
 211     sql.prepare();
 212     return sql.step() == SQLITE_ROW;
 213 }
 214
 215 int SQLiteDatabase::runVacuumCommand()
 216 {
 217     if (!executeCommand("VACUUM;"))
 218         WTF_LOG(SQLDatabase, "Unable to vacuum database - %s", lastErrorMsg());
 219     return lastError();
 220 }
 221
 222 int SQLiteDatabase::runIncrementalVacuumCommand()
 223 {
 224     MutexLocker locker(m_authorizerLock);
 225     enableAuthorizer(false);
 226
 227     if (!executeCommand("PRAGMA incremental_vacuum"))
 228         WTF_LOG(SQLDatabase, "Unable to run incremental vacuum - %s", lastErrorMsg());
 229
 230     enableAuthorizer(true);
 231     return lastError();
 232 }
 233
 234 int64_t SQLiteDatabase::lastInsertRowID()
 235 {
 236     if (!m_db)
 237         return 0;
 238     return sqlite3_last_insert_rowid(m_db);
 239 }
 240
 241 void SQLiteDatabase::updateLastChangesCount()
 242 {
 243     if (!m_db)
 244         return;
 245
 246     m_lastChangesCount = sqlite3_total_changes(m_db);
 247 }
 248
 249 int SQLiteDatabase::lastChanges()
 250 {
 251     if (!m_db)
 252         return 0;
 253
 254     return sqlite3_total_changes(m_db) - m_lastChangesCount;
 255 }
 256
 257 int SQLiteDatabase::lastError()
 258 {
 259     return m_db ? sqlite3_errcode(m_db) : m_openError;
 260 }
 261
 262 const char* SQLiteDatabase::lastErrorMsg()
 263 {
 264     if (m_db)
 265         return sqlite3_errmsg(m_db);
 266     return m_openErrorMessage.isNull() ? notOpenErrorMessage : m_openErrorMessage.data();
 267 }
 268
 269 int SQLiteDatabase::authorizerFunction(void* userData, int actionCode, const char* parameter1, const char* parameter2, const char* /*databaseName*/, const char* /*trigger_or_view*/)
 270 {
 271     DatabaseAuthorizer* auth = static_cast<DatabaseAuthorizer*>(userData);
 272     ASSERT(auth);
 273
 274     switch (actionCode) {
 275         case SQLITE_CREATE_INDEX:
 276             return auth->createIndex(parameter1, parameter2);
 277         case SQLITE_CREATE_TABLE:
 278             return auth->createTable(parameter1);
 279         case SQLITE_CREATE_TEMP_INDEX:
 280             return auth->createTempIndex(parameter1, parameter2);
 281         case SQLITE_CREATE_TEMP_TABLE:
 282             return auth->createTempTable(parameter1);
 283         case SQLITE_CREATE_TEMP_TRIGGER:
 284             return auth->createTempTrigger(parameter1, parameter2);
 285         case SQLITE_CREATE_TEMP_VIEW:
 286             return auth->createTempView(parameter1);
 287         case SQLITE_CREATE_TRIGGER:
 288             return auth->createTrigger(parameter1, parameter2);
 289         case SQLITE_CREATE_VIEW:
 290             return auth->createView(parameter1);
 291         case SQLITE_DELETE:
 292             return auth->allowDelete(parameter1);
 293         case SQLITE_DROP_INDEX:
 294             return auth->dropIndex(parameter1, parameter2);
 295         case SQLITE_DROP_TABLE:
 296             return auth->dropTable(parameter1);
 297         case SQLITE_DROP_TEMP_INDEX:
 298             return auth->dropTempIndex(parameter1, parameter2);
 299         case SQLITE_DROP_TEMP_TABLE:
 300             return auth->dropTempTable(parameter1);
 301         case SQLITE_DROP_TEMP_TRIGGER:
 302             return auth->dropTempTrigger(parameter1, parameter2);
 303         case SQLITE_DROP_TEMP_VIEW:
 304             return auth->dropTempView(parameter1);
 305         case SQLITE_DROP_TRIGGER:
 306             return auth->dropTrigger(parameter1, parameter2);
 307         case SQLITE_DROP_VIEW:
 308             return auth->dropView(parameter1);
 309         case SQLITE_INSERT:
 310             return auth->allowInsert(parameter1);
 311         case SQLITE_PRAGMA:
 312             return auth->allowPragma(parameter1, parameter2);
 313         case SQLITE_READ:
 314             return auth->allowRead(parameter1, parameter2);
 315         case SQLITE_SELECT:
 316             return auth->allowSelect();
 317         case SQLITE_TRANSACTION:
 318             return auth->allowTransaction();
 319         case SQLITE_UPDATE:
 320             return auth->allowUpdate(parameter1, parameter2);
 321         case SQLITE_ATTACH:
 322             return auth->allowAttach(parameter1);
 323         case SQLITE_DETACH:
 324             return auth->allowDetach(parameter1);
 325         case SQLITE_ALTER_TABLE:
 326             return auth->allowAlterTable(parameter1, parameter2);
 327         case SQLITE_REINDEX:
 328             return auth->allowReindex(parameter1);
 329 #if SQLITE_VERSION_NUMBER >= 3003013
 330         case SQLITE_ANALYZE:
 331             return auth->allowAnalyze(parameter1);
 332         case SQLITE_CREATE_VTABLE:
 333             return auth->createVTable(parameter1, parameter2);
 334         case SQLITE_DROP_VTABLE:
 335             return auth->dropVTable(parameter1, parameter2);
 336         case SQLITE_FUNCTION:
 337             return auth->allowFunction(parameter2);
 338 #endif
 339         default:
 340             ASSERT_NOT_REACHED();
 341             return SQLAuthDeny;
 342     }
 343 }
 344
 345 void SQLiteDatabase::setAuthorizer(DatabaseAuthorizer* auth)
 346 {
 347     if (!m_db) {
 348         WTF_LOG_ERROR("Attempt to set an authorizer on a non-open SQL database");
 349         ASSERT_NOT_REACHED();
 350         return;
 351     }
 352
 353     MutexLocker locker(m_authorizerLock);
 354
 355     m_authorizer = auth;
 356
 357     enableAuthorizer(true);
 358 }
 359
 360 void SQLiteDatabase::enableAuthorizer(bool enable)
 361 {
 362     if (m_authorizer && enable)
 363         sqlite3_set_authorizer(m_db, SQLiteDatabase::authorizerFunction, m_authorizer.get());
 364     else
 365         sqlite3_set_authorizer(m_db, NULL, 0);
 366 }
 367
 368 bool SQLiteDatabase::isAutoCommitOn() const
 369 {
 370     return sqlite3_get_autocommit(m_db);
 371 }
 372
 373 bool SQLiteDatabase::turnOnIncrementalAutoVacuum()
 374 {
 375     SQLiteStatement statement(*this, "PRAGMA auto_vacuum");
 376     int autoVacuumMode = statement.getColumnInt(0);
 377     int error = lastError();
 378
 379     // Check if we got an error while trying to get the value of the auto_vacuum flag.
 380     // If we got a SQLITE_BUSY error, then there's probably another transaction in
 381     // progress on this database. In this case, keep the current value of the
 382     // auto_vacuum flag and try to set it to INCREMENTAL the next time we open this
 383     // database. If the error is not SQLITE_BUSY, then we probably ran into a more
 384     // serious problem and should return false (to log an error message).
 385     if (error != SQLITE_ROW)
 386         return false;
 387
 388     switch (autoVacuumMode) {
 389     case AutoVacuumIncremental:
 390         return true;
 391     case AutoVacuumFull:
 392         return executeCommand("PRAGMA auto_vacuum = 2");
 393     case AutoVacuumNone:
 394     default:
 395         if (!executeCommand("PRAGMA auto_vacuum = 2"))
 396             return false;
 397         runVacuumCommand();
 398         error = lastError();
 399         return (error == SQLITE_OK);
 400     }
 401 }
 402
 403 void SQLiteDatabase::trace(Visitor* visitor)
 404 {
 405     visitor->trace(m_authorizer);
 406 }
 407
 408 } // namespace blink