SQLite transaction and RxJava - android-sqlite

Question

There is how I save my data with RxJava:
override fun put(note: Note): Observable<Note> {
validateNote(note)
return Observable.just(note)
.doOnNext { dbKeeper.startTransaction() }
.doOnNext { storeHashtags(note) }
.doOnNext { storeImages(note) }
.flatMap { notesDataStore.put(notesMapper.transform(note)) }
.map { notesMapper.transform(it) }
.doOnNext { dbKeeper.setTransactionSuccessful() }
.doOnUnsubscribe { dbKeeper.endTransaction() }
}
And then I use this method like this:
notesManager.put(note)
.switchMap { notesManager.getHashtags() }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe {view.setHashtags(it) }
And doOnUnsubscribe never called as getHashtags() trying to SELECT from db that locked by startTransaction(). Deadlock, heh.
Okay. Let's replace doOnUnsubscribe(...) with doOnTerminate(...).
override fun put(note: Note): Observable<Note> {
validateNote(note)
return Observable.just(note)
.doOnNext { dbKeeper.startTransaction() }
.doOnNext { storeHashtags(note) }
.doOnNext { storeImages(note) }
.map { notesMapper.transform(note) }
.flatMap { notesDataStore.put(it) }
.map { notesMapper.transform(it) }
.doOnNext { dbKeeper.setTransactionSuccessful() }
.doOnTerminate { dbKeeper.endTransaction() }
}
But now transaction won't close if Observable will be interrupted by subscriber.unsubscribe().
What can you recommend to solve my situation?
Additional information:
I use one writableDb instance to write/read data.

Answer 1

I'd say this isn't a good fit for Rx; My recommendation would be to do the transaction using the usual try-finally (pardon the Java):
Observable<Note> put(Note note) {
return just(note)
.doOnNext(n -> {
validateNote(n);
dbKeeper.startTransaction();
try {
storeHashtags(n);
storeImages(n);
notesDataStore.put(notesMapper.transform(n));
dbKeeper.setTransactionSuccessful();
} finally {
dbKeeper.endTransaction();
}
});
}
Edit: Maybe this is more useful:
fun <T> withTransaction(sourceObservable: Observable<T>): Observable<T> {
val latch = AtomicInteger(1)
val maybeEndTransaction = Action0 {
if (latch.decrementAndGet() == 0) {
endTransaction()
}
}
return Observable.empty<T>()
.doOnCompleted { startTransaction() }
.mergeWith(sourceObservable)
.doOnNext { setTransactionSuccessful() }
.doOnTerminate(maybeEndTransaction)
.doOnUnsubscribe(maybeEndTransaction)
}
Use it like this:
override fun put(note: Note): Observable<Note> {
return Observable.just(note)
.doOnNext { validateNote(note) }
.doOnNext { storeHashtags(note) }
.doOnNext { storeImages(note) }
.flatMap { notesDataStore.put(notesMapper.transform(note)) }
.map { notesMapper.transform(it) }
.compose { withTransaction }
}
It will ensure that the transaction ends exactly once; just be careful that you don't switch threads within your original observable chain (unless your transaction amanger can handle that, or you modified your schedulers to associate new threads with existing transactions).