597ccdbf39e5e1fbdda0d8daa55cf610eaa95225
[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         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