Relational Databases have been a blocker for systems incorporating a fully reactive stack since the inception of the Reactive Streams specification. The new Reactive Relational Database Connectivity (R2DBC) can be considered as a game-changer towards achieving efficiency and resiliency on persistence level. Being one of the early adopters, incorporating R2DBC on an ETL that is processing 5 billion flight tickets per year, I will compare it with the existing alternatives in the same space. We will go through the existing APIs, the current limitations, the new Spring 5.2 reactive transactions, and some of the most useful constructs and patterns that emerge from using R2DBC.

1. Going Reactive
with Relational
Databases
Ivaylo Pashov
20 Feb 2020

2. Reactive 101
What you might have missed so far

3. Architectural Shift
The Reactive Manifesto

4. Architectural Shift
Processor ProcessorPublisher

5. Internal Synchronous Processing
Processor

6. Internal ImplementationInternal Asynchronous Processing
Processor
2
1
3
5
4

7. Asynchronous
Programming
is Hard

8. Reactive Programming
Flux.interval(Duration.ofSeconds(1)).take(5)
.filter(i -> i % 3 != 0)
.map( i -> i * i )
.subscribe(System.out::println);
Subset of Asynchronous programming where availability of new
information (events) drives the logic forward
Declarative

9. Subscription
demand/cancel
Reactive Streams
SubscriberPublisher
subscribe
0 … * events
Error
Complete
publish

10. Transform Filter
?
Aggregate Combine

11. Reactive Streams - Backpressure
Slow
Operator
Operator
Slow
Operator
Operator
BackpressureBackpressure
Normal Scenario
High Load Scenario

12. Reactive Streams Landscape
Reactive
Streams
ClientsImpl

13. Blocking Web Stack
HTTP Server
Servlet API
Web Framework
Application
Persistence
Database
Blocking I/O
Blocking I/O

14. Blocking Web Stack
HTTP Server
Persistence
T
1
T
2
T
3
T
4
T
5
T
6
T
7
T
8
T
9
T
N
…
Thread Lifetime
1000 RPS  1 RPMS
Database
Blocking I/O
35 ms Blocking I/O
(queries)
5 ms Server Processing
~45 Threads

15. Blocking I/O

16. Non-Blocking Web Stack
HTTP Server
Servlet API 3.1
Web Framework
Application
Persistence
Tomcat, Jetty, Netty, Undertow
Database
Non-Blocking I/O
Non-Blocking I/O
Spring Web Flux, Vert.x, Micronaut, Quarkus
Spring Data + Elastic Search, Mongo DB,
Cassandra

17. Backpressure on Insert
@PostMapping(path="/cars", consumes = "application/stream+json")
public Mono<Void> loadCars(@RequestBody Flux<Car> cars) {
return repository.insert(cars).then();
}

18. Backpressure on Get
@GetMapping(path = "/cars", produces = "application/stream+json")
public Flux<Car> getCars() {
return this.repository.findCars();
}

19. R2DBC
Mind the Gap between
Reactive and Relational
Bridge

20. Overview
JDBC R2DBC
• Non-humane API
• Humane API
• Non-blocking
• Back-pressure
• Declarative
• Usually asynchronous
✓
✓
✓
✓
✓
✓
❌
❌
❌
❌
❌
✓

21. Stack
JDBC R2DBC
JDBC API
Driver
Database
Wire Protocol
Blocking I/O
Connection Pool
Client
R2DBC SPI
Reactive Driver
Database
Client
Wire Protocol
Non-Blocking I/O
R2DBC Pool

22. R2DBC – Connections
String url = "r2dbc:pool:postgresql://localhost:5432/test";
ConnectionFactory connectionFactory =
ConnectionFactories.get(url);
ConnectionFactory Connection

23. R2DBC – Query
Flux<String> mails = Mono.from(connectionFactory.create())
.flatMapMany(con ->
con.createStatement("SELECT email FROM account")
.execute()
)
.flatMap(result -> result
.map((row, metadata) -> row.get(0, String.class))
);
Statement
Connection
Result

24. R2DBC – Transactional Batch Insert
Mono<Void> inserted = Mono.from(connectionFactory.create())
.flatMap(con ->
Mono.from(con.beginTransaction())
.thenMany(
con.createStatement("INSERT INTO TEST VALUES($1)")
.bind("$1", "1").add()
.bind("$1", "2").add()
.bind("$1", "3").execute()
).then()
.delayUntil(r -> con.commitTransaction())
.onErrorResume(e -> Mono.from(con.rollbackTransaction())
.then(Mono.error(e))
)
);

25. R2DBC Adoption
Clients
• Spring Data R2DBC
• R2DBC Client
• jOOQ (initial support)
Drivers
• Google Cloud Spanner
• H2
• PostgreSQL
• Microsoft SQL Server
• MySQL
• SAP Hana
• Oracle coming soon -> OJDBC with
Reactive Extensions

26. Alternatives
• Vert.x Reactive SQL Client
• jasync SQL
• ADBA (discontinued)
• Hibernate RX (experimental, limited features)

27. Upcoming Features
• Stored Procedures
• ExtendTransaction Support
• Event Provider

28. Spring Data
R2DBC
The Humane API

29. Persistence Stacks – Spring Perspective
JDBC API (Blocking)
Hibernate/EclipseLink
R2DBC SPI (Reactive)
Spring Data R2DBC
Spring Data JPA
Dialect
JPA
Dialect

30. JPA Provider Features
• Advanced Object Relational Mapping
• Schema Generation andValidation
• 2 Levels of Caching
• Lazy Loading
• Deferred Flushing and Dirty Checks
• Batching

31. What Queries
Would Be
Executed?

32. Spring Data JDBC
Persistence Stacks – Spring Perspective
JDBC API (Blocking) R2DBC SPI (Reactive)
Spring Data R2DBC
Spring Data Relational Spring Data Relational
JdbcAggregateTemplate
Repositories
DatabaseClient
Reactive Repositories

33. Spring Data RDBC Models
@Data
@Table("movies")
public class Movie {
@Id
private Long id;
private String title;
private String summary;
private LocalDate releasedAt;
}

34. Spring Data RDBC Repositories
@Repository
public interface MovieRepository
extends ReactiveCrudRepository<Movie, Long> {
@Query("SELECT * FROM movies WHERE title = :title")
Mono<Movie> findByTitle(String title);
@Modifying
@Query("DELETE FROM movies WHERE title = :title")
Mono<Integer> deleteByTitle(String title);
}

35. Spring Data RDBC DatabaseClient
private Mono<Movie> findMovie(long movieId) {
return databaseClient.execute(
"SELECT * FROM movies WHERE id = :movieId")
.bind("movieId", movieId)
.as(Movie.class)
.fetch()
.one();
}

36. How About
Relations?

37. Relations and Entity Graph

38. Relations – Tables vs. Entities
1 N M 1
∞1
1
∞
N M
1
N
1
1
M
1
M
1
N
1
11
1
K
L
1
1
∞
1
∞
1
K
L1
1
1

39. Microservices and Bounded Context

40. Aggregates

41. Entities Lifecycle
1 N M 1
∞1
1
∞
N M
1
N
1
1
M
1
M
1
N
1
11
1
K
L
1
1
∞
1
∞
1
K
L1
1
1

42. Entities Lifecycle
N M
1
M
1
N
1
11
1
K
L
1
1
∞
1
∞

43. Microservices and Bounded Context

44. Aggregates in Spring Data (JDBC) RDBC
@Table("movies")
public class Movie {
@Id
private Long id;
…
private Plot plot;
private Set<Role> cast;
}
One-to-One  Embedded Object
Bounded
One-to-Many  Embedded Collection
STILL NOT SUPPORTED
EXISTING WORKAROUNDS

45. Aggregates in Spring Data (JDBC) RDBC
@Table("movies")
public class Movie {
@Id
private Long id;
…
private Director director;
private Set<Actor> cast;
}
Many-to-One De-normalize
 OR
Many-to-Many Soft reference
NOT ALLOWED

46. Reactive Transactions Spring 5.2 Way
@Transactional
public Mono<Movie> insert(Movie movie) {
return repository.save(movie);
}
private final TransactionalOperator transactionalOperator;
public Mono<Movie> insert(Movie movie) {
return repository.save(movie)
.as(transactionalOperator::transactional);
}

47. Limitations
• Derived Query Methods
• Embedded Objects
• Collections of arbitrary Objects
• Versioning and Optimistic Locking
• Paging and Sorting Repositories
• Batching

48. N + 1 Query Problem
/
1 1 1 1 1
1 1 1 1 2
1 1 1 1 3
1 1 1 1 4
1 1 1 1 5
1 1 1 2 6
1 1 1 2 7
1 1 1 2 8
1 1 1 2 9
Single Query with a Fetch Join:
10 (roots) * 5 * 5 * 5 * 5 = 6250 rows
Join in Parallel:
10 + 10 * (5 * 5 * 5 * 5) = 210 rows

49. Query in Parallel
Fetch Actors
<<R2DBC>>
Fetch Movie
<<R2DBC>>
Get Rating
<<HTTP>>
Get Biography
<<HTTP>>

50. Q/A
Thank You for Your Attention!