forked from mozilla/gecko-dev
-
Notifications
You must be signed in to change notification settings - Fork 2
/
mozStorageAsyncStatementExecution.cpp
651 lines (543 loc) · 19.5 KB
/
mozStorageAsyncStatementExecution.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsAutoPtr.h"
#include "sqlite3.h"
#include "mozIStorageStatementCallback.h"
#include "mozStorageBindingParams.h"
#include "mozStorageHelper.h"
#include "mozStorageResultSet.h"
#include "mozStorageRow.h"
#include "mozStorageConnection.h"
#include "mozStorageError.h"
#include "mozStoragePrivateHelpers.h"
#include "mozStorageStatementData.h"
#include "mozStorageAsyncStatementExecution.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Telemetry.h"
namespace mozilla {
namespace storage {
/**
* The following constants help batch rows into result sets.
* MAX_MILLISECONDS_BETWEEN_RESULTS was chosen because any user-based task that
* takes less than 200 milliseconds is considered to feel instantaneous to end
* users. MAX_ROWS_PER_RESULT was arbitrarily chosen to reduce the number of
* dispatches to calling thread, while also providing reasonably-sized sets of
* data for consumers. Both of these constants are used because we assume that
* consumers are trying to avoid blocking their execution thread for long
* periods of time, and dispatching many small events to the calling thread will
* end up blocking it.
*/
#define MAX_MILLISECONDS_BETWEEN_RESULTS 75
#define MAX_ROWS_PER_RESULT 15
////////////////////////////////////////////////////////////////////////////////
//// Local Classes
namespace {
typedef AsyncExecuteStatements::ExecutionState ExecutionState;
typedef AsyncExecuteStatements::StatementDataArray StatementDataArray;
/**
* Notifies a callback with a result set.
*/
class CallbackResultNotifier : public nsRunnable
{
public:
CallbackResultNotifier(mozIStorageStatementCallback *aCallback,
mozIStorageResultSet *aResults,
AsyncExecuteStatements *aEventStatus) :
mCallback(aCallback)
, mResults(aResults)
, mEventStatus(aEventStatus)
{
}
NS_IMETHOD Run()
{
NS_ASSERTION(mCallback, "Trying to notify about results without a callback!");
if (mEventStatus->shouldNotify()) {
// Hold a strong reference to the callback while notifying it, so that if
// it spins the event loop, the callback won't be released and freed out
// from under us.
nsCOMPtr<mozIStorageStatementCallback> callback =
do_QueryInterface(mCallback);
(void)mCallback->HandleResult(mResults);
}
return NS_OK;
}
private:
mozIStorageStatementCallback *mCallback;
nsCOMPtr<mozIStorageResultSet> mResults;
RefPtr<AsyncExecuteStatements> mEventStatus;
};
/**
* Notifies the calling thread that an error has occurred.
*/
class ErrorNotifier : public nsRunnable
{
public:
ErrorNotifier(mozIStorageStatementCallback *aCallback,
mozIStorageError *aErrorObj,
AsyncExecuteStatements *aEventStatus) :
mCallback(aCallback)
, mErrorObj(aErrorObj)
, mEventStatus(aEventStatus)
{
}
NS_IMETHOD Run()
{
if (mEventStatus->shouldNotify() && mCallback) {
// Hold a strong reference to the callback while notifying it, so that if
// it spins the event loop, the callback won't be released and freed out
// from under us.
nsCOMPtr<mozIStorageStatementCallback> callback =
do_QueryInterface(mCallback);
(void)mCallback->HandleError(mErrorObj);
}
return NS_OK;
}
private:
mozIStorageStatementCallback *mCallback;
nsCOMPtr<mozIStorageError> mErrorObj;
RefPtr<AsyncExecuteStatements> mEventStatus;
};
/**
* Notifies the calling thread that the statement has finished executing. Takes
* ownership of the StatementData so it is released on the proper thread.
*/
class CompletionNotifier : public nsRunnable
{
public:
/**
* This takes ownership of the callback and the StatementData. They are
* released on the thread this is dispatched to (which should always be the
* calling thread).
*/
CompletionNotifier(mozIStorageStatementCallback *aCallback,
ExecutionState aReason)
: mCallback(aCallback)
, mReason(aReason)
{
}
NS_IMETHOD Run()
{
if (mCallback) {
(void)mCallback->HandleCompletion(mReason);
NS_RELEASE(mCallback);
}
return NS_OK;
}
private:
mozIStorageStatementCallback *mCallback;
ExecutionState mReason;
};
} // namespace
////////////////////////////////////////////////////////////////////////////////
//// AsyncExecuteStatements
/* static */
nsresult
AsyncExecuteStatements::execute(StatementDataArray &aStatements,
Connection *aConnection,
sqlite3 *aNativeConnection,
mozIStorageStatementCallback *aCallback,
mozIStoragePendingStatement **_stmt)
{
// Create our event to run in the background
RefPtr<AsyncExecuteStatements> event =
new AsyncExecuteStatements(aStatements, aConnection, aNativeConnection,
aCallback);
NS_ENSURE_TRUE(event, NS_ERROR_OUT_OF_MEMORY);
// Dispatch it to the background
nsIEventTarget *target = aConnection->getAsyncExecutionTarget();
// If we don't have a valid target, this is a bug somewhere else. In the past,
// this assert found cases where a Run method would schedule a new statement
// without checking if asyncClose had been called. The caller must prevent
// that from happening or, if the work is not critical, just avoid creating
// the new statement during shutdown. See bug 718449 for an example.
MOZ_ASSERT(target);
if (!target) {
return NS_ERROR_NOT_AVAILABLE;
}
nsresult rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
NS_ENSURE_SUCCESS(rv, rv);
// Return it as the pending statement object and track it.
event.forget(_stmt);
return NS_OK;
}
AsyncExecuteStatements::AsyncExecuteStatements(StatementDataArray &aStatements,
Connection *aConnection,
sqlite3 *aNativeConnection,
mozIStorageStatementCallback *aCallback)
: mConnection(aConnection)
, mNativeConnection(aNativeConnection)
, mHasTransaction(false)
, mCallback(aCallback)
, mCallingThread(::do_GetCurrentThread())
, mMaxWait(TimeDuration::FromMilliseconds(MAX_MILLISECONDS_BETWEEN_RESULTS))
, mIntervalStart(TimeStamp::Now())
, mState(PENDING)
, mCancelRequested(false)
, mMutex(aConnection->sharedAsyncExecutionMutex)
, mDBMutex(aConnection->sharedDBMutex)
, mRequestStartDate(TimeStamp::Now())
{
(void)mStatements.SwapElements(aStatements);
NS_ASSERTION(mStatements.Length(), "We weren't given any statements!");
NS_IF_ADDREF(mCallback);
}
AsyncExecuteStatements::~AsyncExecuteStatements()
{
MOZ_ASSERT(!mHasTransaction, "There should be no transaction at this point");
}
bool
AsyncExecuteStatements::shouldNotify()
{
#ifdef DEBUG
mMutex.AssertNotCurrentThreadOwns();
bool onCallingThread = false;
(void)mCallingThread->IsOnCurrentThread(&onCallingThread);
NS_ASSERTION(onCallingThread, "runEvent not running on the calling thread!");
#endif
// We do not need to acquire mMutex here because it can only ever be written
// to on the calling thread, and the only thread that can call us is the
// calling thread, so we know that our access is serialized.
return !mCancelRequested;
}
bool
AsyncExecuteStatements::bindExecuteAndProcessStatement(StatementData &aData,
bool aLastStatement)
{
mMutex.AssertNotCurrentThreadOwns();
sqlite3_stmt *aStatement = nullptr;
// This cannot fail; we are only called if it's available.
(void)aData.getSqliteStatement(&aStatement);
NS_ASSERTION(aStatement, "You broke the code; do not call here like that!");
BindingParamsArray *paramsArray(aData);
// Iterate through all of our parameters, bind them, and execute.
bool continueProcessing = true;
BindingParamsArray::iterator itr = paramsArray->begin();
BindingParamsArray::iterator end = paramsArray->end();
while (itr != end && continueProcessing) {
// Bind the data to our statement.
nsCOMPtr<IStorageBindingParamsInternal> bindingInternal =
do_QueryInterface(*itr);
nsCOMPtr<mozIStorageError> error = bindingInternal->bind(aStatement);
if (error) {
// Set our error state.
mState = ERROR;
// And notify.
(void)notifyError(error);
return false;
}
// Advance our iterator, execute, and then process the statement.
itr++;
bool lastStatement = aLastStatement && itr == end;
continueProcessing = executeAndProcessStatement(aStatement, lastStatement);
// Always reset our statement.
(void)::sqlite3_reset(aStatement);
}
return continueProcessing;
}
bool
AsyncExecuteStatements::executeAndProcessStatement(sqlite3_stmt *aStatement,
bool aLastStatement)
{
mMutex.AssertNotCurrentThreadOwns();
// Execute our statement
bool hasResults;
do {
hasResults = executeStatement(aStatement);
// If we had an error, bail.
if (mState == ERROR)
return false;
// If we have been canceled, there is no point in going on...
{
MutexAutoLock lockedScope(mMutex);
if (mCancelRequested) {
mState = CANCELED;
return false;
}
}
// Build our result set and notify if we got anything back and have a
// callback to notify.
if (mCallback && hasResults &&
NS_FAILED(buildAndNotifyResults(aStatement))) {
// We had an error notifying, so we notify on error and stop processing.
mState = ERROR;
// Notify, and stop processing statements.
(void)notifyError(mozIStorageError::ERROR,
"An error occurred while notifying about results");
return false;
}
} while (hasResults);
#ifndef MOZ_STORAGE_SORTWARNING_SQL_DUMP
if (MOZ_LOG_TEST(gStorageLog, LogLevel::Warning))
#endif
{
// Check to make sure that this statement was smart about what it did.
checkAndLogStatementPerformance(aStatement);
}
// If we are done, we need to set our state accordingly while we still hold
// our mutex. We would have already returned if we were canceled or had
// an error at this point.
if (aLastStatement)
mState = COMPLETED;
return true;
}
bool
AsyncExecuteStatements::executeStatement(sqlite3_stmt *aStatement)
{
mMutex.AssertNotCurrentThreadOwns();
Telemetry::AutoTimer<Telemetry::MOZ_STORAGE_ASYNC_REQUESTS_MS> finallySendExecutionDuration(mRequestStartDate);
while (true) {
// lock the sqlite mutex so sqlite3_errmsg cannot change
SQLiteMutexAutoLock lockedScope(mDBMutex);
int rc = mConnection->stepStatement(mNativeConnection, aStatement);
// Stop if we have no more results.
if (rc == SQLITE_DONE)
{
Telemetry::Accumulate(Telemetry::MOZ_STORAGE_ASYNC_REQUESTS_SUCCESS, true);
return false;
}
// If we got results, we can return now.
if (rc == SQLITE_ROW)
{
Telemetry::Accumulate(Telemetry::MOZ_STORAGE_ASYNC_REQUESTS_SUCCESS, true);
return true;
}
// Some errors are not fatal, and we can handle them and continue.
if (rc == SQLITE_BUSY) {
// Don't hold the lock while we call outside our module.
SQLiteMutexAutoUnlock unlockedScope(mDBMutex);
// Yield, and try again
(void)::PR_Sleep(PR_INTERVAL_NO_WAIT);
continue;
}
// Set an error state.
mState = ERROR;
Telemetry::Accumulate(Telemetry::MOZ_STORAGE_ASYNC_REQUESTS_SUCCESS, false);
// Construct the error message before giving up the mutex (which we cannot
// hold during the call to notifyError).
nsCOMPtr<mozIStorageError> errorObj(
new Error(rc, ::sqlite3_errmsg(mNativeConnection))
);
// We cannot hold the DB mutex while calling notifyError.
SQLiteMutexAutoUnlock unlockedScope(mDBMutex);
(void)notifyError(errorObj);
// Finally, indicate that we should stop processing.
return false;
}
}
nsresult
AsyncExecuteStatements::buildAndNotifyResults(sqlite3_stmt *aStatement)
{
NS_ASSERTION(mCallback, "Trying to dispatch results without a callback!");
mMutex.AssertNotCurrentThreadOwns();
// Build result object if we need it.
if (!mResultSet)
mResultSet = new ResultSet();
NS_ENSURE_TRUE(mResultSet, NS_ERROR_OUT_OF_MEMORY);
RefPtr<Row> row(new Row());
NS_ENSURE_TRUE(row, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = row->initialize(aStatement);
NS_ENSURE_SUCCESS(rv, rv);
rv = mResultSet->add(row);
NS_ENSURE_SUCCESS(rv, rv);
// If we have hit our maximum number of allowed results, or if we have hit
// the maximum amount of time we want to wait for results, notify the
// calling thread about it.
TimeStamp now = TimeStamp::Now();
TimeDuration delta = now - mIntervalStart;
if (mResultSet->rows() >= MAX_ROWS_PER_RESULT || delta > mMaxWait) {
// Notify the caller
rv = notifyResults();
if (NS_FAILED(rv))
return NS_OK; // we'll try again with the next result
// Reset our start time
mIntervalStart = now;
}
return NS_OK;
}
nsresult
AsyncExecuteStatements::notifyComplete()
{
mMutex.AssertNotCurrentThreadOwns();
NS_ASSERTION(mState != PENDING,
"Still in a pending state when calling Complete!");
// Reset our statements before we try to commit or rollback. If we are
// canceling and have statements that think they have pending work, the
// rollback will fail.
for (uint32_t i = 0; i < mStatements.Length(); i++)
mStatements[i].reset();
// Release references to the statement data as soon as possible. If this
// is the last reference, statements will be finalized immediately on the
// async thread, hence avoiding several bounces between threads and possible
// race conditions with AsyncClose().
mStatements.Clear();
// Handle our transaction, if we have one
if (mHasTransaction) {
if (mState == COMPLETED) {
nsresult rv = mConnection->commitTransactionInternal(mNativeConnection);
if (NS_FAILED(rv)) {
mState = ERROR;
(void)notifyError(mozIStorageError::ERROR,
"Transaction failed to commit");
}
}
else {
DebugOnly<nsresult> rv =
mConnection->rollbackTransactionInternal(mNativeConnection);
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Transaction failed to rollback");
}
mHasTransaction = false;
}
// Always generate a completion notification; it is what guarantees that our
// destruction does not happen here on the async thread.
RefPtr<CompletionNotifier> completionEvent =
new CompletionNotifier(mCallback, mState);
// We no longer own mCallback (the CompletionNotifier takes ownership).
mCallback = nullptr;
(void)mCallingThread->Dispatch(completionEvent, NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
AsyncExecuteStatements::notifyError(int32_t aErrorCode,
const char *aMessage)
{
mMutex.AssertNotCurrentThreadOwns();
mDBMutex.assertNotCurrentThreadOwns();
if (!mCallback)
return NS_OK;
nsCOMPtr<mozIStorageError> errorObj(new Error(aErrorCode, aMessage));
NS_ENSURE_TRUE(errorObj, NS_ERROR_OUT_OF_MEMORY);
return notifyError(errorObj);
}
nsresult
AsyncExecuteStatements::notifyError(mozIStorageError *aError)
{
mMutex.AssertNotCurrentThreadOwns();
mDBMutex.assertNotCurrentThreadOwns();
if (!mCallback)
return NS_OK;
RefPtr<ErrorNotifier> notifier =
new ErrorNotifier(mCallback, aError, this);
NS_ENSURE_TRUE(notifier, NS_ERROR_OUT_OF_MEMORY);
return mCallingThread->Dispatch(notifier, NS_DISPATCH_NORMAL);
}
nsresult
AsyncExecuteStatements::notifyResults()
{
mMutex.AssertNotCurrentThreadOwns();
NS_ASSERTION(mCallback, "notifyResults called without a callback!");
RefPtr<CallbackResultNotifier> notifier =
new CallbackResultNotifier(mCallback, mResultSet, this);
NS_ENSURE_TRUE(notifier, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = mCallingThread->Dispatch(notifier, NS_DISPATCH_NORMAL);
if (NS_SUCCEEDED(rv))
mResultSet = nullptr; // we no longer own it on success
return rv;
}
NS_IMPL_ISUPPORTS(
AsyncExecuteStatements,
nsIRunnable,
mozIStoragePendingStatement
)
bool
AsyncExecuteStatements::statementsNeedTransaction()
{
// If there is more than one write statement, run in a transaction.
// Additionally, if we have only one statement but it needs a transaction, due
// to multiple BindingParams, we will wrap it in one.
for (uint32_t i = 0, transactionsCount = 0; i < mStatements.Length(); ++i) {
transactionsCount += mStatements[i].needsTransaction();
if (transactionsCount > 1) {
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
//// mozIStoragePendingStatement
NS_IMETHODIMP
AsyncExecuteStatements::Cancel()
{
#ifdef DEBUG
bool onCallingThread = false;
(void)mCallingThread->IsOnCurrentThread(&onCallingThread);
NS_ASSERTION(onCallingThread, "Not canceling from the calling thread!");
#endif
// If we have already canceled, we have an error, but always indicate that
// we are trying to cancel.
NS_ENSURE_FALSE(mCancelRequested, NS_ERROR_UNEXPECTED);
{
MutexAutoLock lockedScope(mMutex);
// We need to indicate that we want to try and cancel now.
mCancelRequested = true;
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
//// nsIRunnable
NS_IMETHODIMP
AsyncExecuteStatements::Run()
{
MOZ_ASSERT(!mConnection->isClosed());
// Do not run if we have been canceled.
{
MutexAutoLock lockedScope(mMutex);
if (mCancelRequested)
mState = CANCELED;
}
if (mState == CANCELED)
return notifyComplete();
if (statementsNeedTransaction() && mConnection->getAutocommit()) {
if (NS_SUCCEEDED(mConnection->beginTransactionInternal(mNativeConnection,
mozIStorageConnection::TRANSACTION_IMMEDIATE))) {
mHasTransaction = true;
}
#ifdef DEBUG
else {
NS_WARNING("Unable to create a transaction for async execution.");
}
#endif
}
// Execute each statement, giving the callback results if it returns any.
for (uint32_t i = 0; i < mStatements.Length(); i++) {
bool finished = (i == (mStatements.Length() - 1));
sqlite3_stmt *stmt;
{ // lock the sqlite mutex so sqlite3_errmsg cannot change
SQLiteMutexAutoLock lockedScope(mDBMutex);
int rc = mStatements[i].getSqliteStatement(&stmt);
if (rc != SQLITE_OK) {
// Set our error state.
mState = ERROR;
// Build the error object; can't call notifyError with the lock held
nsCOMPtr<mozIStorageError> errorObj(
new Error(rc, ::sqlite3_errmsg(mNativeConnection))
);
{
// We cannot hold the DB mutex and call notifyError.
SQLiteMutexAutoUnlock unlockedScope(mDBMutex);
(void)notifyError(errorObj);
}
break;
}
}
// If we have parameters to bind, bind them, execute, and process.
if (mStatements[i].hasParametersToBeBound()) {
if (!bindExecuteAndProcessStatement(mStatements[i], finished))
break;
}
// Otherwise, just execute and process the statement.
else if (!executeAndProcessStatement(stmt, finished)) {
break;
}
}
// If we still have results that we haven't notified about, take care of
// them now.
if (mResultSet)
(void)notifyResults();
// Notify about completion
return notifyComplete();
}
} // namespace storage
} // namespace mozilla