Use std::call_once instead of AtomicallyInitializedStatic in DatabaseBackendBase
[WebKit-https.git] / Source / WebCore / Modules / webdatabase / DatabaseBackendBase.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  * Copyright (C) 2013 Apple Inc. All rights reserved.
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  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "DatabaseBackendBase.h"
32
33 #if ENABLE(SQL_DATABASE)
34
35 #include "DatabaseAuthorizer.h"
36 #include "DatabaseBackendContext.h"
37 #include "DatabaseBase.h"
38 #include "DatabaseContext.h"
39 #include "DatabaseManager.h"
40 #include "DatabaseTracker.h"
41 #include "ExceptionCode.h"
42 #include "Logging.h"
43 #include "SQLiteStatement.h"
44 #include "SQLiteTransaction.h"
45 #include "SecurityOrigin.h"
46 #include <wtf/HashMap.h>
47 #include <wtf/HashSet.h>
48 #include <wtf/NeverDestroyed.h>
49 #include <wtf/PassRefPtr.h>
50 #include <wtf/RefPtr.h>
51 #include <wtf/StdLibExtras.h>
52 #include <wtf/text/CString.h>
53 #include <wtf/text/StringHash.h>
54
55 #if PLATFORM(IOS)
56 #include "SQLiteDatabaseTracker.h"
57 #endif
58
59 // Registering "opened" databases with the DatabaseTracker
60 // =======================================================
61 // The DatabaseTracker maintains a list of databases that have been
62 // "opened" so that the client can call interrupt or delete on every database
63 // associated with a DatabaseBackendContext.
64 //
65 // We will only call DatabaseTracker::addOpenDatabase() to add the database
66 // to the tracker as opened when we've succeeded in opening the database,
67 // and will set m_opened to true. Similarly, we only call
68 // DatabaseTracker::removeOpenDatabase() to remove the database from the
69 // tracker when we set m_opened to false in closeDatabase(). This sets up
70 // a simple symmetry between open and close operations, and a direct
71 // correlation to adding and removing databases from the tracker's list,
72 // thus ensuring that we have a correct list for the interrupt and
73 // delete operations to work on.
74 //
75 // The only databases instances not tracked by the tracker's open database
76 // list are the ones that have not been added yet, or the ones that we
77 // attempted an open on but failed to. Such instances only exist in the
78 // DatabaseServer's factory methods for creating database backends.
79 //
80 // The factory methods will either call openAndVerifyVersion() or
81 // performOpenAndVerify(). These methods will add the newly instantiated
82 // database backend if they succeed in opening the requested database.
83 // In the case of failure to open the database, the factory methods will
84 // simply discard the newly instantiated database backend when they return.
85 // The ref counting mechanims will automatically destruct the un-added
86 // (and un-returned) databases instances.
87
88 namespace WebCore {
89
90 static const char versionKey[] = "WebKitDatabaseVersionKey";
91 static const char infoTableName[] = "__WebKitDatabaseInfoTable__";
92
93 static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
94 {
95     return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
96 }
97
98 static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
99 {
100     SQLiteStatement statement(db, query);
101     int result = statement.prepare();
102
103     if (result != SQLResultOk) {
104         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
105         return false;
106     }
107
108     result = statement.step();
109     if (result == SQLResultRow) {
110         resultString = statement.getColumnText(0);
111         return true;
112     }
113     if (result == SQLResultDone) {
114         resultString = String();
115         return true;
116     }
117
118     LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
119     return false;
120 }
121
122 static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
123 {
124     SQLiteStatement statement(db, query);
125     int result = statement.prepare();
126
127     if (result != SQLResultOk) {
128         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
129         return false;
130     }
131
132     statement.bindText(1, value);
133
134     result = statement.step();
135     if (result != SQLResultDone) {
136         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
137         return false;
138     }
139
140     return true;
141 }
142
143 // FIXME: move all guid-related functions to a DatabaseVersionTracker class.
144 static std::mutex& guidMutex()
145 {
146     static std::once_flag onceFlag;
147     static std::mutex* mutex;
148
149     std::call_once(onceFlag, []{
150         mutex = std::make_unique<std::mutex>().release();
151     });
152
153     return *mutex;
154 }
155
156 typedef HashMap<DatabaseGuid, String> GuidVersionMap;
157 static GuidVersionMap& guidToVersionMap()
158 {
159     // Ensure the the mutex is locked.
160     ASSERT(!guidMutex().try_lock());
161
162     static NeverDestroyed<GuidVersionMap> map;
163     return map;
164 }
165
166 // NOTE: Caller must lock guidMutex().
167 static inline void updateGuidVersionMap(DatabaseGuid guid, String newVersion)
168 {
169     // Ensure the the mutex is locked.
170     ASSERT(!guidMutex().try_lock());
171
172     // Note: It is not safe to put an empty string into the guidToVersionMap() map.
173     // That's because the map is cross-thread, but empty strings are per-thread.
174     // The copy() function makes a version of the string you can use on the current
175     // thread, but we need a string we can keep in a cross-thread data structure.
176     // FIXME: This is a quite-awkward restriction to have to program with.
177
178     // Map null string to empty string (see comment above).
179     guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.isolatedCopy());
180 }
181
182 typedef HashMap<DatabaseGuid, std::unique_ptr<HashSet<DatabaseBackendBase*>>> GuidDatabaseMap;
183
184 static GuidDatabaseMap& guidToDatabaseMap()
185 {
186     // Ensure the the mutex is locked.
187     ASSERT(!guidMutex().try_lock());
188
189     static NeverDestroyed<GuidDatabaseMap> map;
190     return map;
191 }
192
193 static DatabaseGuid guidForOriginAndName(const String& origin, const String& name)
194 {
195     // Ensure the the mutex is locked.
196     ASSERT(!guidMutex().try_lock());
197
198     String stringID = origin + "/" + name;
199
200     typedef HashMap<String, int> IDGuidMap;
201     static NeverDestroyed<HashMap<String, int>> map;
202     DatabaseGuid guid = map.get().get(stringID);
203     if (!guid) {
204         static int currentNewGUID = 1;
205         guid = currentNewGUID++;
206         map.get().set(stringID, guid);
207     }
208
209     return guid;
210 }
211
212 // static
213 const char* DatabaseBackendBase::databaseInfoTableName()
214 {
215     return infoTableName;
216 }
217
218 #if !LOG_DISABLED || !ERROR_DISABLED
219 String DatabaseBackendBase::databaseDebugName() const
220 {
221     return m_contextThreadSecurityOrigin->toString() + "::" + m_name;
222 }
223 #endif
224
225 DatabaseBackendBase::DatabaseBackendBase(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name,
226     const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
227     : m_databaseContext(databaseContext)
228     , m_name(name.isolatedCopy())
229     , m_expectedVersion(expectedVersion.isolatedCopy())
230     , m_displayName(displayName.isolatedCopy())
231     , m_estimatedSize(estimatedSize)
232     , m_opened(false)
233     , m_new(false)
234     , m_isSyncDatabase(databaseType == DatabaseType::Sync)
235 {
236     m_contextThreadSecurityOrigin = m_databaseContext->securityOrigin()->isolatedCopy();
237
238     m_databaseAuthorizer = DatabaseAuthorizer::create(infoTableName);
239
240     if (m_name.isNull())
241         m_name = emptyString();
242
243     {
244         std::lock_guard<std::mutex> locker(guidMutex());
245
246         m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
247         std::unique_ptr<HashSet<DatabaseBackendBase*>>& hashSet = guidToDatabaseMap().add(m_guid, nullptr).iterator->value;
248         if (!hashSet)
249             hashSet = std::make_unique<HashSet<DatabaseBackendBase*>>();
250         hashSet->add(this);
251     }
252
253     m_filename = DatabaseManager::manager().fullPathForDatabase(securityOrigin(), m_name);
254 }
255
256 DatabaseBackendBase::~DatabaseBackendBase()
257 {
258     // SQLite is "multi-thread safe", but each database handle can only be used
259     // on a single thread at a time.
260     //
261     // For DatabaseBackend, we open the SQLite database on the DatabaseThread,
262     // and hence we should also close it on that same thread. This means that the
263     // SQLite database need to be closed by another mechanism (see
264     // DatabaseContext::stopDatabases()). By the time we get here, the SQLite
265     // database should have already been closed.
266
267     ASSERT(!m_opened);
268 }
269
270 void DatabaseBackendBase::closeDatabase()
271 {
272     if (!m_opened)
273         return;
274
275     m_sqliteDatabase.close();
276     m_opened = false;
277     // See comment at the top this file regarding calling removeOpenDatabase().
278     DatabaseTracker::tracker().removeOpenDatabase(this);
279     {
280         std::lock_guard<std::mutex> locker(guidMutex());
281
282         auto it = guidToDatabaseMap().find(m_guid);
283         ASSERT(it != guidToDatabaseMap().end());
284         ASSERT(it->value);
285         ASSERT(it->value->contains(this));
286         it->value->remove(this);
287         if (it->value->isEmpty()) {
288             guidToDatabaseMap().remove(it);
289             guidToVersionMap().remove(m_guid);
290         }
291     }
292 }
293
294 String DatabaseBackendBase::version() const
295 {
296     // Note: In multi-process browsers the cached value may be accurate, but we cannot read the
297     // actual version from the database without potentially inducing a deadlock.
298     // FIXME: Add an async version getter to the DatabaseAPI.
299     return getCachedVersion();
300 }
301
302 class DoneCreatingDatabaseOnExitCaller {
303 public:
304     DoneCreatingDatabaseOnExitCaller(DatabaseBackendBase* database)
305         : m_database(database)
306         , m_openSucceeded(false)
307     {
308     }
309     ~DoneCreatingDatabaseOnExitCaller()
310     {
311         DatabaseTracker::tracker().doneCreatingDatabase(m_database);
312     }
313
314     void setOpenSucceeded() { m_openSucceeded = true; }
315
316 private:
317     DatabaseBackendBase* m_database;
318     bool m_openSucceeded;
319 };
320
321 bool DatabaseBackendBase::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
322 {
323     DoneCreatingDatabaseOnExitCaller onExitCaller(this);
324     ASSERT(errorMessage.isEmpty());
325     ASSERT(error == DatabaseError::None); // Better not have any errors already.
326     error = DatabaseError::InvalidDatabaseState; // Presumed failure. We'll clear it if we succeed below.
327
328     const int maxSqliteBusyWaitTime = 30000;
329
330 #if PLATFORM(IOS)
331     {
332         // Make sure we wait till the background removal of the empty database files finished before trying to open any database.
333         MutexLocker locker(DatabaseTracker::openDatabaseMutex());
334     }
335     SQLiteTransactionInProgressAutoCounter transactionCounter;
336 #endif
337
338     if (!m_sqliteDatabase.open(m_filename, true)) {
339         errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
340         return false;
341     }
342     if (!m_sqliteDatabase.turnOnIncrementalAutoVacuum())
343         LOG_ERROR("Unable to turn on incremental auto-vacuum (%d %s)", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
344
345     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
346
347     String currentVersion;
348     {
349         std::lock_guard<std::mutex> locker(guidMutex());
350
351         auto entry = guidToVersionMap().find(m_guid);
352         if (entry != guidToVersionMap().end()) {
353             // Map null string to empty string (see updateGuidVersionMap()).
354             currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
355             LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
356         } else {
357             LOG(StorageAPI, "No cached version for guid %i", m_guid);
358
359             SQLiteTransaction transaction(m_sqliteDatabase);
360             transaction.begin();
361             if (!transaction.inProgress()) {
362                 errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
363                 m_sqliteDatabase.close();
364                 return false;
365             }
366
367             String tableName(infoTableName);
368             if (!m_sqliteDatabase.tableExists(tableName)) {
369                 m_new = true;
370
371                 if (!m_sqliteDatabase.executeCommand("CREATE TABLE " + tableName + " (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {
372                     errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
373                     transaction.rollback();
374                     m_sqliteDatabase.close();
375                     return false;
376                 }
377             } else if (!getVersionFromDatabase(currentVersion, false)) {
378                 errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
379                 transaction.rollback();
380                 m_sqliteDatabase.close();
381                 return false;
382             }
383
384             if (currentVersion.length()) {
385                 LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
386             } else if (!m_new || shouldSetVersionInNewDatabase) {
387                 LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
388                 if (!setVersionInDatabase(m_expectedVersion, false)) {
389                     errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
390                     transaction.rollback();
391                     m_sqliteDatabase.close();
392                     return false;
393                 }
394                 currentVersion = m_expectedVersion;
395             }
396             updateGuidVersionMap(m_guid, currentVersion);
397             transaction.commit();
398         }
399     }
400
401     if (currentVersion.isNull()) {
402         LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
403         currentVersion = "";
404     }
405
406     // If the expected version isn't the empty string, ensure that the current database version we have matches that version. Otherwise, set an exception.
407     // If the expected version is the empty string, then we always return with whatever version of the database we have.
408     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
409         errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
410         m_sqliteDatabase.close();
411         return false;
412     }
413
414     ASSERT(m_databaseAuthorizer);
415     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
416
417     // See comment at the top this file regarding calling addOpenDatabase().
418     DatabaseTracker::tracker().addOpenDatabase(this);
419     m_opened = true;
420
421     // Declare success:
422     error = DatabaseError::None; // Clear the presumed error from above.
423     onExitCaller.setOpenSucceeded();
424
425     if (m_new && !shouldSetVersionInNewDatabase)
426         m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
427     return true;
428 }
429
430 SecurityOrigin* DatabaseBackendBase::securityOrigin() const
431 {
432     return m_contextThreadSecurityOrigin.get();
433 }
434
435 String DatabaseBackendBase::stringIdentifier() const
436 {
437     // Return a deep copy for ref counting thread safety
438     return m_name.isolatedCopy();
439 }
440
441 String DatabaseBackendBase::displayName() const
442 {
443     // Return a deep copy for ref counting thread safety
444     return m_displayName.isolatedCopy();
445 }
446
447 unsigned long DatabaseBackendBase::estimatedSize() const
448 {
449     return m_estimatedSize;
450 }
451
452 String DatabaseBackendBase::fileName() const
453 {
454     // Return a deep copy for ref counting thread safety
455     return m_filename.isolatedCopy();
456 }
457
458 DatabaseDetails DatabaseBackendBase::details() const
459 {
460     return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0);
461 }
462
463 bool DatabaseBackendBase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
464 {
465     String query(String("SELECT value FROM ") + infoTableName +  " WHERE key = '" + versionKey + "';");
466
467     m_databaseAuthorizer->disable();
468
469     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
470     if (result) {
471         if (shouldCacheVersion)
472             setCachedVersion(version);
473     } else
474         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
475
476     m_databaseAuthorizer->enable();
477
478     return result;
479 }
480
481 bool DatabaseBackendBase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
482 {
483     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
484     // clause in the CREATE statement (see Database::performOpenAndVerify()).
485     String query(String("INSERT INTO ") + infoTableName +  " (key, value) VALUES ('" + versionKey + "', ?);");
486
487     m_databaseAuthorizer->disable();
488
489     bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
490     if (result) {
491         if (shouldCacheVersion)
492             setCachedVersion(version);
493     } else
494         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
495
496     m_databaseAuthorizer->enable();
497
498     return result;
499 }
500
501 void DatabaseBackendBase::setExpectedVersion(const String& version)
502 {
503     m_expectedVersion = version.isolatedCopy();
504 }
505
506 String DatabaseBackendBase::getCachedVersion() const
507 {
508     std::lock_guard<std::mutex> locker(guidMutex());
509
510     return guidToVersionMap().get(m_guid).isolatedCopy();
511 }
512
513 void DatabaseBackendBase::setCachedVersion(const String& actualVersion)
514 {
515     // Update the in memory database version map.
516     std::lock_guard<std::mutex> locker(guidMutex());
517
518     updateGuidVersionMap(m_guid, actualVersion);
519 }
520
521 bool DatabaseBackendBase::getActualVersionForTransaction(String &actualVersion)
522 {
523     ASSERT(m_sqliteDatabase.transactionInProgress());
524     // Note: In multi-process browsers the cached value may be inaccurate.
525     // So we retrieve the value from the database and update the cached value here.
526     return getVersionFromDatabase(actualVersion, true);
527 }
528
529 void DatabaseBackendBase::disableAuthorizer()
530 {
531     ASSERT(m_databaseAuthorizer);
532     m_databaseAuthorizer->disable();
533 }
534
535 void DatabaseBackendBase::enableAuthorizer()
536 {
537     ASSERT(m_databaseAuthorizer);
538     m_databaseAuthorizer->enable();
539 }
540
541 void DatabaseBackendBase::setAuthorizerReadOnly()
542 {
543     ASSERT(m_databaseAuthorizer);
544     m_databaseAuthorizer->setReadOnly();
545 }
546
547 void DatabaseBackendBase::setAuthorizerPermissions(int permissions)
548 {
549     ASSERT(m_databaseAuthorizer);
550     m_databaseAuthorizer->setPermissions(permissions);
551 }
552
553 bool DatabaseBackendBase::lastActionChangedDatabase()
554 {
555     ASSERT(m_databaseAuthorizer);
556     return m_databaseAuthorizer->lastActionChangedDatabase();
557 }
558
559 bool DatabaseBackendBase::lastActionWasInsert()
560 {
561     ASSERT(m_databaseAuthorizer);
562     return m_databaseAuthorizer->lastActionWasInsert();
563 }
564
565 void DatabaseBackendBase::resetDeletes()
566 {
567     ASSERT(m_databaseAuthorizer);
568     m_databaseAuthorizer->resetDeletes();
569 }
570
571 bool DatabaseBackendBase::hadDeletes()
572 {
573     ASSERT(m_databaseAuthorizer);
574     return m_databaseAuthorizer->hadDeletes();
575 }
576
577 void DatabaseBackendBase::resetAuthorizer()
578 {
579     if (m_databaseAuthorizer)
580         m_databaseAuthorizer->reset();
581 }
582
583 unsigned long long DatabaseBackendBase::maximumSize() const
584 {
585     return DatabaseTracker::tracker().getMaxSizeForDatabase(this);
586 }
587
588 void DatabaseBackendBase::incrementalVacuumIfNeeded()
589 {
590 #if PLATFORM(IOS)
591     SQLiteTransactionInProgressAutoCounter transactionCounter;
592 #endif
593     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
594     int64_t totalSize = m_sqliteDatabase.totalSize();
595     if (totalSize <= 10 * freeSpaceSize) {
596         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
597         if (result != SQLResultOk)
598             m_frontend->logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
599     }
600 }
601
602 void DatabaseBackendBase::interrupt()
603 {
604     m_sqliteDatabase.interrupt();
605 }
606
607 bool DatabaseBackendBase::isInterrupted()
608 {
609     MutexLocker locker(m_sqliteDatabase.databaseMutex());
610     return m_sqliteDatabase.isInterrupted();
611 }
612
613 } // namespace WebCore
614
615 #endif // ENABLE(SQL_DATABASE)