WebCore/platform/sql/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 "SQLiteDatabase.h"
  29
  30 #include "Logging.h"
  31 #include "SQLiteAuthorizer.h"
  32 #include "SQLiteStatement.h"
  33
  34 #include <sqlite3.h>
  35
  36 namespace WebCore {
  37
  38 const int SQLResultDone = SQLITE_DONE;
  39 const int SQLResultError = SQLITE_ERROR;
  40 const int SQLResultOk = SQLITE_OK;
  41 const int SQLResultRow = SQLITE_ROW;
  42 const int SQLResultSchema = SQLITE_SCHEMA;
  43 const int SQLResultFull = SQLITE_FULL;
  44
  45
  46 SQLiteDatabase::SQLiteDatabase()
  47     : m_db(0)
  48     , m_pageSize(-1)
  49     , m_transactionInProgress(false)
  50     , m_openingThread(0)
  51 {
  52 }
  53
  54 SQLiteDatabase::~SQLiteDatabase()
  55 {
  56     close();
  57 }
  58
  59 bool SQLiteDatabase::open(const String& filename)
  60 {
  61     close();
  62
  63     // SQLite expects a null terminator on its UTF-16 strings.
  64     String path = filename;
  65     m_lastError = sqlite3_open16(path.charactersWithNullTermination(), &m_db);
  66     if (m_lastError != SQLITE_OK) {
  67         LOG_ERROR("SQLite database failed to load from %s\nCause - %s", filename.ascii().data(),
  68             sqlite3_errmsg(m_db));
  69         sqlite3_close(m_db);
  70         m_db = 0;
  71         return false;
  72     }
  73
  74     if (isOpen())
  75         m_openingThread = currentThread();
  76
  77     if (!SQLiteStatement(*this, "PRAGMA temp_store = MEMORY;").executeCommand())
  78         LOG_ERROR("SQLite database could not set temp_store to memory");
  79
  80     return isOpen();
  81 }
  82
  83 void SQLiteDatabase::close()
  84 {
  85     if (m_db) {
  86         sqlite3_close(m_db);
  87         m_db = 0;
  88     }
  89
  90     m_openingThread = 0;
  91 }
  92
  93 void SQLiteDatabase::setFullsync(bool fsync)
  94 {
  95     if (fsync)
  96         executeCommand("PRAGMA fullfsync = 1;");
  97     else
  98         executeCommand("PRAGMA fullfsync = 0;");
  99 }
 100
 101 int64_t SQLiteDatabase::maximumSize()
 102 {
 103     MutexLocker locker(m_authorizerLock);
 104     enableAuthorizer(false);
 105
 106     SQLiteStatement statement(*this, "PRAGMA max_page_count");
 107     int64_t size = statement.getColumnInt64(0) * pageSize();
 108
 109     enableAuthorizer(true);
 110     return size;
 111 }
 112
 113 void SQLiteDatabase::setMaximumSize(int64_t size)
 114 {
 115     if (size < 0)
 116         size = 0;
 117
 118     int currentPageSize = pageSize();
 119
 120     ASSERT(currentPageSize);
 121     int64_t newMaxPageCount = currentPageSize ? size / currentPageSize : 0;
 122
 123     MutexLocker locker(m_authorizerLock);
 124     enableAuthorizer(false);
 125
 126     SQLiteStatement statement(*this, "PRAGMA max_page_count = " + String::number(newMaxPageCount));
 127     statement.prepare();
 128     if (statement.step() != SQLResultRow)
 129         LOG_ERROR("Failed to set maximum size of database to %lli bytes", size);
 130
 131     enableAuthorizer(true);
 132
 133 }
 134
 135 int SQLiteDatabase::pageSize()
 136 {
 137     // Since the page size of a database is locked in at creation and therefore cannot be dynamic,
 138     // we can cache the value for future use
 139     if (m_pageSize == -1) {
 140         MutexLocker locker(m_authorizerLock);
 141         enableAuthorizer(false);
 142
 143         SQLiteStatement statement(*this, "PRAGMA page_size");
 144         m_pageSize = statement.getColumnInt(0);
 145
 146         enableAuthorizer(true);
 147     }
 148
 149     return m_pageSize;
 150 }
 151
 152 void SQLiteDatabase::setSynchronous(SynchronousPragma sync)
 153 {
 154     executeCommand(String::format("PRAGMA synchronous = %i", sync));
 155 }
 156
 157 void SQLiteDatabase::setBusyTimeout(int ms)
 158 {
 159     if (m_db)
 160         sqlite3_busy_timeout(m_db, ms);
 161     else
 162         LOG(SQLDatabase, "BusyTimeout set on non-open database");
 163 }
 164
 165 void SQLiteDatabase::setBusyHandler(int(*handler)(void*, int))
 166 {
 167     if (m_db)
 168         sqlite3_busy_handler(m_db, handler, NULL);
 169     else
 170         LOG(SQLDatabase, "Busy handler set on non-open database");
 171 }
 172
 173 bool SQLiteDatabase::executeCommand(const String& sql)
 174 {
 175     return SQLiteStatement(*this, sql).executeCommand();
 176 }
 177
 178 bool SQLiteDatabase::returnsAtLeastOneResult(const String& sql)
 179 {
 180     return SQLiteStatement(*this, sql).returnsAtLeastOneResult();
 181 }
 182
 183 bool SQLiteDatabase::tableExists(const String& tablename)
 184 {
 185     if (!isOpen())
 186         return false;
 187
 188     String statement = "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '" + tablename + "';";
 189
 190     SQLiteStatement sql(*this, statement);
 191     sql.prepare();
 192     return sql.step() == SQLITE_ROW;
 193 }
 194
 195 void SQLiteDatabase::clearAllTables()
 196 {
 197     String query = "SELECT name FROM sqlite_master WHERE type='table';";
 198     Vector<String> tables;
 199     if (!SQLiteStatement(*this, query).returnTextResults(0, tables)) {
 200         LOG(SQLDatabase, "Unable to retrieve list of tables from database");
 201         return;
 202     }
 203
 204     for (Vector<String>::iterator table = tables.begin(); table != tables.end(); ++table ) {
 205         if (*table == "sqlite_sequence")
 206             continue;
 207         if (!executeCommand("DROP TABLE " + *table))
 208             LOG(SQLDatabase, "Unable to drop table %s", (*table).ascii().data());
 209     }
 210 }
 211
 212 void SQLiteDatabase::runVacuumCommand()
 213 {
 214     if (!executeCommand("VACUUM;"))
 215         LOG(SQLDatabase, "Unable to vacuum database - %s", lastErrorMsg());
 216 }
 217
 218 int64_t SQLiteDatabase::lastInsertRowID()
 219 {
 220     if (!m_db)
 221         return 0;
 222     return sqlite3_last_insert_rowid(m_db);
 223 }
 224
 225 int SQLiteDatabase::lastChanges()
 226 {
 227     if (!m_db)
 228         return 0;
 229     return sqlite3_changes(m_db);
 230 }
 231
 232 int SQLiteDatabase::lastError()
 233 {
 234     return m_db ? sqlite3_errcode(m_db) : SQLITE_ERROR;
 235 }
 236
 237 const char* SQLiteDatabase::lastErrorMsg()
 238 {
 239     return sqlite3_errmsg(m_db);
 240 }
 241
 242 int SQLiteDatabase::authorizerFunction(void* userData, int actionCode, const char* parameter1, const char* parameter2, const char* /*databaseName*/, const char* /*trigger_or_view*/)
 243 {
 244     SQLiteAuthorizer* auth = static_cast<SQLiteAuthorizer*>(userData);
 245     ASSERT(auth);
 246
 247     switch (actionCode) {
 248         case SQLITE_CREATE_INDEX:
 249             return auth->createIndex(parameter1, parameter2);
 250         case SQLITE_CREATE_TABLE:
 251             return auth->createTable(parameter1);
 252         case SQLITE_CREATE_TEMP_INDEX:
 253             return auth->createTempIndex(parameter1, parameter2);
 254         case SQLITE_CREATE_TEMP_TABLE:
 255             return auth->createTempTable(parameter1);
 256         case SQLITE_CREATE_TEMP_TRIGGER:
 257             return auth->createTempTrigger(parameter1, parameter2);
 258         case SQLITE_CREATE_TEMP_VIEW:
 259             return auth->createTempView(parameter1);
 260         case SQLITE_CREATE_TRIGGER:
 261             return auth->createTrigger(parameter1, parameter2);
 262         case SQLITE_CREATE_VIEW:
 263             return auth->createView(parameter1);
 264         case SQLITE_DELETE:
 265             return auth->allowDelete(parameter1);
 266         case SQLITE_DROP_INDEX:
 267             return auth->dropIndex(parameter1, parameter2);
 268         case SQLITE_DROP_TABLE:
 269             return auth->dropTable(parameter1);
 270         case SQLITE_DROP_TEMP_INDEX:
 271             return auth->dropTempIndex(parameter1, parameter2);
 272         case SQLITE_DROP_TEMP_TABLE:
 273             return auth->dropTempTable(parameter1);
 274         case SQLITE_DROP_TEMP_TRIGGER:
 275             return auth->dropTempTrigger(parameter1, parameter2);
 276         case SQLITE_DROP_TEMP_VIEW:
 277             return auth->dropTempView(parameter1);
 278         case SQLITE_DROP_TRIGGER:
 279             return auth->dropTrigger(parameter1, parameter2);
 280         case SQLITE_DROP_VIEW:
 281             return auth->dropView(parameter1);
 282         case SQLITE_INSERT:
 283             return auth->allowInsert(parameter1);
 284         case SQLITE_PRAGMA:
 285             return auth->allowPragma(parameter1, parameter2);
 286         case SQLITE_READ:
 287             return auth->allowRead(parameter1, parameter2);
 288         case SQLITE_SELECT:
 289             return auth->allowSelect();
 290         case SQLITE_TRANSACTION:
 291             return auth->allowTransaction();
 292         case SQLITE_UPDATE:
 293             return auth->allowUpdate(parameter1, parameter2);
 294         case SQLITE_ATTACH:
 295             return auth->allowAttach(parameter1);
 296         case SQLITE_DETACH:
 297             return auth->allowDetach(parameter1);
 298         case SQLITE_ALTER_TABLE:
 299             return auth->allowAlterTable(parameter1, parameter2);
 300         case SQLITE_REINDEX:
 301             return auth->allowReindex(parameter1);
 302 #if SQLITE_VERSION_NUMBER >= 3003013
 303         case SQLITE_ANALYZE:
 304             return auth->allowAnalyze(parameter1);
 305         case SQLITE_CREATE_VTABLE:
 306             return auth->createVTable(parameter1, parameter2);
 307         case SQLITE_DROP_VTABLE:
 308             return auth->dropVTable(parameter1, parameter2);
 309         case SQLITE_FUNCTION:
 310             return auth->allowFunction(parameter1);
 311 #endif
 312         default:
 313             ASSERT_NOT_REACHED();
 314             return SQLAuthDeny;
 315     }
 316 }
 317
 318 void SQLiteDatabase::setAuthorizer(PassRefPtr<SQLiteAuthorizer> auth)
 319 {
 320     if (!m_db) {
 321         LOG_ERROR("Attempt to set an authorizer on a non-open SQL database");
 322         ASSERT_NOT_REACHED();
 323         return;
 324     }
 325
 326     MutexLocker locker(m_authorizerLock);
 327
 328     m_authorizer = auth;
 329
 330     enableAuthorizer(true);
 331 }
 332
 333 void SQLiteDatabase::enableAuthorizer(bool enable)
 334 {
 335     if (m_authorizer && enable)
 336         sqlite3_set_authorizer(m_db, SQLiteDatabase::authorizerFunction, m_authorizer.get());
 337     else
 338         sqlite3_set_authorizer(m_db, NULL, 0);
 339 }
 340
 341 void SQLiteDatabase::lock()
 342 {
 343     m_lockingMutex.lock();
 344 }
 345
 346 void SQLiteDatabase::unlock()
 347 {
 348     m_lockingMutex.unlock();
 349 }
 350
 351 } // namespace WebCore