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