de615ca24eef04cc69bb93b27505cb39e95f5177
[WebKit-https.git] / WebCore / storage / SQLTransaction.cpp
1 /*
2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
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  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "SQLTransaction.h"
31
32 #if ENABLE(DATABASE)
33
34 #include "ChromeClient.h"
35 #include "Database.h"
36 #include "DatabaseAuthorizer.h"
37 #include "DatabaseDetails.h"
38 #include "ExceptionCode.h"
39 #include "Logging.h"
40 #include "Page.h"
41 #include "PlatformString.h"
42 #include "ScriptExecutionContext.h"
43 #include "Settings.h"
44 #include "SQLError.h"
45 #include "SQLiteTransaction.h"
46 #include "SQLResultSet.h"
47 #include "SQLStatement.h"
48 #include "SQLStatementCallback.h"
49 #include "SQLStatementErrorCallback.h"
50 #include "SQLTransactionClient.h"
51 #include "SQLTransactionCoordinator.h"
52 #include "SQLValue.h"
53
54 // There's no way of knowing exactly how much more space will be required when a statement hits the quota limit.
55 // For now, we'll arbitrarily choose currentQuota + 1mb.
56 // In the future we decide to track if a size increase wasn't enough, and ask for larger-and-larger increases until its enough.
57 static const int DefaultQuotaSizeIncrease = 1048576;
58
59 namespace WebCore {
60
61 PassRefPtr<SQLTransaction> SQLTransaction::create(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
62                                                   PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
63 {
64     return adoptRef(new SQLTransaction(db, callback, errorCallback, successCallback, wrapper, readOnly));
65 }
66
67 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
68                                PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
69     : m_nextStep(&SQLTransaction::acquireLock)
70     , m_executeSqlAllowed(false)
71     , m_database(db)
72     , m_wrapper(wrapper)
73     , m_callback(callback)
74     , m_successCallback(successCallback)
75     , m_errorCallback(errorCallback)
76     , m_shouldRetryCurrentStatement(false)
77     , m_modifiedDatabase(false)
78     , m_lockAcquired(false)
79     , m_readOnly(readOnly)
80 {
81     ASSERT(m_database);
82 }
83
84 SQLTransaction::~SQLTransaction()
85 {
86 }
87
88 void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
89 {
90     if (!m_executeSqlAllowed || m_database->stopped()) {
91         e = INVALID_STATE_ERR;
92         return;
93     }
94
95     bool readOnlyMode = m_readOnly;
96     if (!readOnlyMode) {
97         if (m_database->scriptExecutionContext()->isDatabaseReadOnly())
98             readOnlyMode = true;
99     }
100
101     RefPtr<SQLStatement> statement = SQLStatement::create(sqlStatement, arguments, callback, callbackError, readOnlyMode);
102
103     if (m_database->deleted())
104         statement->setDatabaseDeletedError();
105
106     if (!m_database->versionMatchesExpected())
107         statement->setVersionMismatchedError();
108
109     enqueueStatement(statement);
110 }
111
112 void SQLTransaction::enqueueStatement(PassRefPtr<SQLStatement> statement)
113 {
114     MutexLocker locker(m_statementMutex);
115     m_statementQueue.append(statement);
116 }
117
118 #ifndef NDEBUG
119 const char* SQLTransaction::debugStepName(SQLTransaction::TransactionStepMethod step)
120 {
121     if (step == &SQLTransaction::acquireLock)
122         return "acquireLock";
123     else if (step == &SQLTransaction::openTransactionAndPreflight)
124         return "openTransactionAndPreflight";
125     else if (step == &SQLTransaction::runStatements)
126         return "runStatements";
127     else if (step == &SQLTransaction::postflightAndCommit)
128         return "postflightAndCommit";
129     else if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
130         return "cleanupAfterTransactionErrorCallback";
131     else if (step == &SQLTransaction::deliverTransactionCallback)
132         return "deliverTransactionCallback";
133     else if (step == &SQLTransaction::deliverTransactionErrorCallback)
134         return "deliverTransactionErrorCallback";
135     else if (step == &SQLTransaction::deliverStatementCallback)
136         return "deliverStatementCallback";
137     else if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
138         return "deliverQuotaIncreaseCallback";
139     else if (step == &SQLTransaction::deliverSuccessCallback)
140         return "deliverSuccessCallback";
141     else if (step == &SQLTransaction::cleanupAfterSuccessCallback)
142         return "cleanupAfterSuccessCallback";
143     else
144         return "UNKNOWN";
145 }
146 #endif
147
148 void SQLTransaction::checkAndHandleClosedDatabase()
149 {
150     if (!m_database->stopped())
151         return;
152
153     // If the database was stopped, don't do anything and cancel queued work
154     LOG(StorageAPI, "Database was stopped - cancelling work for this transaction");
155     MutexLocker locker(m_statementMutex);
156     m_statementQueue.clear();
157     m_nextStep = 0;
158
159     // The current SQLite transaction should be stopped, as well
160     if (m_sqliteTransaction) {
161         m_sqliteTransaction->stop();
162         m_sqliteTransaction.clear();
163     }
164
165     if (m_lockAcquired)
166         m_database->transactionCoordinator()->releaseLock(this);
167 }
168
169
170 bool SQLTransaction::performNextStep()
171 {
172     LOG(StorageAPI, "Step %s\n", debugStepName(m_nextStep));
173
174     ASSERT(m_nextStep == &SQLTransaction::acquireLock ||
175            m_nextStep == &SQLTransaction::openTransactionAndPreflight ||
176            m_nextStep == &SQLTransaction::runStatements ||
177            m_nextStep == &SQLTransaction::postflightAndCommit ||
178            m_nextStep == &SQLTransaction::cleanupAfterSuccessCallback ||
179            m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
180
181     checkAndHandleClosedDatabase();
182
183     if (m_nextStep)
184         (this->*m_nextStep)();
185
186     // If there is no nextStep after performing the above step, the transaction is complete
187     return !m_nextStep;
188 }
189
190 void SQLTransaction::performPendingCallback()
191 {
192     LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
193
194     ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback ||
195            m_nextStep == &SQLTransaction::deliverTransactionErrorCallback ||
196            m_nextStep == &SQLTransaction::deliverStatementCallback ||
197            m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback ||
198            m_nextStep == &SQLTransaction::deliverSuccessCallback);
199
200     checkAndHandleClosedDatabase();
201
202     if (m_nextStep)
203         (this->*m_nextStep)();
204 }
205
206 void SQLTransaction::acquireLock()
207 {
208     m_database->transactionCoordinator()->acquireLock(this);
209 }
210
211 void SQLTransaction::lockAcquired()
212 {
213     m_lockAcquired = true;
214     m_nextStep = &SQLTransaction::openTransactionAndPreflight;
215     LOG(StorageAPI, "Scheduling openTransactionAndPreflight immediately for transaction %p\n", this);
216     m_database->scheduleTransactionStep(this, true);
217 }
218
219 void SQLTransaction::openTransactionAndPreflight()
220 {
221     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
222     ASSERT(m_lockAcquired);
223
224     LOG(StorageAPI, "Opening and preflighting transaction %p", this);
225
226     // If the database was deleted, jump to the error callback
227     if (m_database->deleted()) {
228         m_transactionError = SQLError::create(0, "unable to open a transaction, because the user deleted the database");
229         handleTransactionError(false);
230         return;
231     }
232
233     // Set the maximum usage for this transaction if this transactions is not read-only
234     if (!m_readOnly)
235         m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
236
237     ASSERT(!m_sqliteTransaction);
238     m_sqliteTransaction.set(new SQLiteTransaction(m_database->m_sqliteDatabase, m_readOnly));
239
240     m_database->m_databaseAuthorizer->disable();
241     m_sqliteTransaction->begin();
242     m_database->m_databaseAuthorizer->enable();
243
244     // Transaction Steps 1+2 - Open a transaction to the database, jumping to the error callback if that fails
245     if (!m_sqliteTransaction->inProgress()) {
246         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
247         m_sqliteTransaction.clear();
248         m_transactionError = SQLError::create(0, "unable to open a transaction to the database");
249         handleTransactionError(false);
250         return;
251     }
252
253     // Transaction Steps 3 - Peform preflight steps, jumping to the error callback if they fail
254     if (m_wrapper && !m_wrapper->performPreflight(this)) {
255         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
256         m_sqliteTransaction.clear();
257         m_transactionError = m_wrapper->sqlError();
258         if (!m_transactionError)
259             m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
260
261         handleTransactionError(false);
262         return;
263     }
264
265     // Transaction Step 4 - Invoke the transaction callback with the new SQLTransaction object
266     m_nextStep = &SQLTransaction::deliverTransactionCallback;
267     LOG(StorageAPI, "Scheduling deliverTransactionCallback for transaction %p\n", this);
268     m_database->scheduleTransactionCallback(this);
269 }
270
271 void SQLTransaction::deliverTransactionCallback()
272 {
273     bool shouldDeliverErrorCallback = false;
274
275     if (m_callback) {
276         m_executeSqlAllowed = true;
277         m_callback->handleEvent(this, shouldDeliverErrorCallback);
278         m_executeSqlAllowed = false;
279     } else
280         shouldDeliverErrorCallback = true;
281
282     // Transaction Step 5 - If the transaction callback was null or raised an exception, jump to the error callback
283     if (shouldDeliverErrorCallback) {
284         m_transactionError = SQLError::create(0, "the SQLTransactionCallback was null or threw an exception");
285         deliverTransactionErrorCallback();
286     } else
287         scheduleToRunStatements();
288 }
289
290 void SQLTransaction::scheduleToRunStatements()
291 {
292     m_nextStep = &SQLTransaction::runStatements;
293     LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
294     m_database->scheduleTransactionStep(this);
295 }
296
297 void SQLTransaction::runStatements()
298 {
299     ASSERT(m_lockAcquired);
300
301     // If there is a series of statements queued up that are all successful and have no associated
302     // SQLStatementCallback objects, then we can burn through the queue
303     do {
304         if (m_shouldRetryCurrentStatement) {
305             m_shouldRetryCurrentStatement = false;
306             // FIXME - Another place that needs fixing up after <rdar://problem/5628468> is addressed.
307             // See ::openTransactionAndPreflight() for discussion
308
309             // Reset the maximum size here, as it was increased to allow us to retry this statement.
310             // m_shouldRetryCurrentStatement is set to true only when a statement exceeds
311             // the quota, which can happen only in a read-write transaction. Therefore, there
312             // is no need to check here if the transaction is read-write.
313             m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
314         } else {
315             // If the current statement has already been run, failed due to quota constraints, and we're not retrying it,
316             // that means it ended in an error.  Handle it now
317             if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
318                 handleCurrentStatementError();
319                 break;
320             }
321
322             // Otherwise, advance to the next statement
323             getNextStatement();
324         }
325     } while (runCurrentStatement());
326
327     // If runCurrentStatement() returned false, that means either there was no current statement to run,
328     // or the current statement requires a callback to complete.  In the later case, it also scheduled
329     // the callback or performed any other additional work so we can return
330     if (!m_currentStatement)
331         postflightAndCommit();
332 }
333
334 void SQLTransaction::getNextStatement()
335 {
336     m_currentStatement = 0;
337
338     MutexLocker locker(m_statementMutex);
339     if (!m_statementQueue.isEmpty()) {
340         m_currentStatement = m_statementQueue.first();
341         m_statementQueue.removeFirst();
342     }
343 }
344
345 bool SQLTransaction::runCurrentStatement()
346 {
347     if (!m_currentStatement)
348         return false;
349
350     m_database->m_databaseAuthorizer->reset();
351
352     if (m_currentStatement->execute(m_database.get())) {
353         if (m_database->m_databaseAuthorizer->lastActionChangedDatabase()) {
354             // Flag this transaction as having changed the database for later delegate notification
355             m_modifiedDatabase = true;
356             // Also dirty the size of this database file for calculating quota usage
357             m_database->transactionClient()->didExecuteStatement(this);
358         }
359
360         if (m_currentStatement->hasStatementCallback()) {
361             m_nextStep = &SQLTransaction::deliverStatementCallback;
362             LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
363             m_database->scheduleTransactionCallback(this);
364             return false;
365         }
366         return true;
367     }
368
369     if (m_currentStatement->lastExecutionFailedDueToQuota()) {
370         m_nextStep = &SQLTransaction::deliverQuotaIncreaseCallback;
371         LOG(StorageAPI, "Scheduling deliverQuotaIncreaseCallback for transaction %p\n", this);
372         m_database->scheduleTransactionCallback(this);
373         return false;
374     }
375
376     handleCurrentStatementError();
377
378     return false;
379 }
380
381 void SQLTransaction::handleCurrentStatementError()
382 {
383     // Transaction Steps 6.error - Call the statement's error callback, but if there was no error callback,
384     // jump to the transaction error callback
385     if (m_currentStatement->hasStatementErrorCallback()) {
386         m_nextStep = &SQLTransaction::deliverStatementCallback;
387         LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
388         m_database->scheduleTransactionCallback(this);
389     } else {
390         m_transactionError = m_currentStatement->sqlError();
391         if (!m_transactionError)
392             m_transactionError = SQLError::create(1, "the statement failed to execute");
393         handleTransactionError(false);
394     }
395 }
396
397 void SQLTransaction::deliverStatementCallback()
398 {
399     ASSERT(m_currentStatement);
400
401     // Transaction Step 6.6 and 6.3(error) - If the statement callback went wrong, jump to the transaction error callback
402     // Otherwise, continue to loop through the statement queue
403     m_executeSqlAllowed = true;
404     bool result = m_currentStatement->performCallback(this);
405     m_executeSqlAllowed = false;
406
407     if (result) {
408         m_transactionError = SQLError::create(0, "the statement callback raised an exception or statement error callback did not return false");
409         handleTransactionError(true);
410     } else
411         scheduleToRunStatements();
412 }
413
414 void SQLTransaction::deliverQuotaIncreaseCallback()
415 {
416     ASSERT(m_currentStatement);
417     ASSERT(!m_shouldRetryCurrentStatement);
418
419     m_shouldRetryCurrentStatement = m_database->transactionClient()->didExceedQuota(this);
420
421     m_nextStep = &SQLTransaction::runStatements;
422     LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
423     m_database->scheduleTransactionStep(this);
424 }
425
426 void SQLTransaction::postflightAndCommit()
427 {
428     ASSERT(m_lockAcquired);
429
430     // Transaction Step 7 - Peform postflight steps, jumping to the error callback if they fail
431     if (m_wrapper && !m_wrapper->performPostflight(this)) {
432         m_transactionError = m_wrapper->sqlError();
433         if (!m_transactionError)
434             m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
435         handleTransactionError(false);
436         return;
437     }
438
439     // Transacton Step 8+9 - Commit the transaction, jumping to the error callback if that fails
440     ASSERT(m_sqliteTransaction);
441
442     m_database->m_databaseAuthorizer->disable();
443     m_sqliteTransaction->commit();
444     m_database->m_databaseAuthorizer->enable();
445
446     // If the commit failed, the transaction will still be marked as "in progress"
447     if (m_sqliteTransaction->inProgress()) {
448         m_transactionError = SQLError::create(0, "failed to commit the transaction");
449         handleTransactionError(false);
450         return;
451     }
452
453     // The commit was successful, notify the delegates if the transaction modified this database
454     if (m_modifiedDatabase)
455         m_database->transactionClient()->didCommitTransaction(this);
456
457     // Now release our unneeded callbacks, to break reference cycles.
458     m_callback = 0;
459     m_errorCallback = 0;
460
461     // Transaction Step 10 - Deliver success callback, if there is one
462     if (m_successCallback) {
463         m_nextStep = &SQLTransaction::deliverSuccessCallback;
464         LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
465         m_database->scheduleTransactionCallback(this);
466     } else
467         cleanupAfterSuccessCallback();
468 }
469
470 void SQLTransaction::deliverSuccessCallback()
471 {
472     // Transaction Step 10 - Deliver success callback
473     ASSERT(m_successCallback);
474     m_successCallback->handleEvent();
475
476     // Release the last callback to break reference cycle
477     m_successCallback = 0;
478
479     // Schedule a "post-success callback" step to return control to the database thread in case there
480     // are further transactions queued up for this Database
481     m_nextStep = &SQLTransaction::cleanupAfterSuccessCallback;
482     LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
483     m_database->scheduleTransactionStep(this);
484 }
485
486 void SQLTransaction::cleanupAfterSuccessCallback()
487 {
488     ASSERT(m_lockAcquired);
489
490     // Transaction Step 11 - End transaction steps
491     // There is no next step
492     LOG(StorageAPI, "Transaction %p is complete\n", this);
493     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
494     m_nextStep = 0;
495
496     // Release the lock on this database
497     m_database->transactionCoordinator()->releaseLock(this);
498 }
499
500 void SQLTransaction::handleTransactionError(bool inCallback)
501 {
502     if (m_errorCallback) {
503         if (inCallback)
504             deliverTransactionErrorCallback();
505         else {
506             m_nextStep = &SQLTransaction::deliverTransactionErrorCallback;
507             LOG(StorageAPI, "Scheduling deliverTransactionErrorCallback for transaction %p\n", this);
508             m_database->scheduleTransactionCallback(this);
509         }
510         return;
511     }
512
513     // No error callback, so fast-forward to:
514     // Transaction Step 12 - Rollback the transaction.
515     if (inCallback) {
516         m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
517         LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
518         m_database->scheduleTransactionStep(this);
519     } else {
520         cleanupAfterTransactionErrorCallback();
521     }
522 }
523
524 void SQLTransaction::deliverTransactionErrorCallback()
525 {
526     ASSERT(m_transactionError);
527
528     // Transaction Step 12 - If exists, invoke error callback with the last
529     // error to have occurred in this transaction.
530     if (m_errorCallback)
531         m_errorCallback->handleEvent(m_transactionError.get());
532
533     m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
534     LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
535     m_database->scheduleTransactionStep(this);
536 }
537
538 void SQLTransaction::cleanupAfterTransactionErrorCallback()
539 {
540     ASSERT(m_lockAcquired);
541
542     m_database->m_databaseAuthorizer->disable();
543     if (m_sqliteTransaction) {
544         // Transaction Step 12 - Rollback the transaction.
545         m_sqliteTransaction->rollback();
546
547         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
548         m_sqliteTransaction.clear();
549     }
550     m_database->m_databaseAuthorizer->enable();
551
552     // Transaction Step 12 - Any still-pending statements in the transaction are discarded.
553     {
554         MutexLocker locker(m_statementMutex);
555         m_statementQueue.clear();
556     }
557
558     // Transaction is complete!  There is no next step
559     LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
560     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
561     m_nextStep = 0;
562
563     // Now release our callbacks, to break reference cycles.
564     m_callback = 0;
565     m_errorCallback = 0;
566
567     // Now release the lock on this database
568     m_database->transactionCoordinator()->releaseLock(this);
569 }
570
571 } // namespace WebCore
572
573 #endif // ENABLE(DATABASE)