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