Maintaining cold observable semantics with a hot observable

Question

I have a requirement to read items from an external queue, and persist them to a JDBC store. The items must be processed one-by-one, and the next item must only be read from the external queue once the previous item has been successfully persisted. At any given time there may or may not be an item available to read, and if not the application must block until the next item is available.

In order to enforce the one-by-one semantics, I decided to use a cold Observable using the generate method:

return Observable.generate(emitter -> {
    final Future<Message> receivedFuture = ...;
    final Message message = receivedFuture.get();
    emitter.onNext(message);
});
    

This seems to work as expected for the receiving side.

In order to persist the data to the database, I decided to make use of the Vertx JDBCPool library.

messageObservable
    .flatMapSingle(message -> 
        jdbcPool.prepareQuery("...")
            .rxExecute(Tuple.of(...)) // produces a hot observable
    )

According to the Vertx docs, the JDBCPool RX methods all produce hot observables.

The problem here seems to be that the flatmap to the JDBCPool method causes the entire chain to become hot. This has the undesirable consequence that messages are read from the queue before the previous message was persisted.

In other words, instead of

Read message 1
Write message 1
Read message 2
Write message 2

I now get

Read message 1
Read message 2
Read message 3
Write message 1
Read message 4
Write message 2

The only solution I have at the moment is to do a very undesirable thing and put the JDBCPool query in its own chain:

messageObservable
    .flatMapSingle(message -> 
        Single.just(
            jdbcPool.prepareQuery("...")
                .rxExecute(Tuple.of(...))
                    .blockingWait()
    )

I want to know what if there is a way I can combine both the one-by-one semantics of a cold observable stream in combination with a hot observable operation, while keeping the chain intact.