Java Library for High Speed Streaming Data

Copyright © 2018, Oracle and/or its affiliates. All rights reserved. |
San Francisco Java Users Group
A Java Library for High-Speed Streaming
Data into Your Database
Pablo Silberkasten, Software Development Manager, Oracle
Kuassi Mensah, Director Product Management, Oracle
OJDBC and OJVM Development
April 15, 2019
Confidential – Oracle Internal/Restricted/Highly Restricted

Safe Harbor Statement
The following is intended to outline our general product direction. It is intended for
information purposes only, and may not be incorporated into any contract. It is not a
commitment to deliver any material, code, or functionality, and should not be relied upon
in making purchasing decisions. The development, release, timing, and pricing of any
features or functionality described for Oracle’s products may change and remains at the
sole discretion of Oracle Corporation.
Confidential – Oracle Internal/Restricted/Highly Restricted

Program Agenda
Challenges when Streaming Data into the Database
Introducing the High Speed Streaming Library
API and Code Samples
Cloud Service Demo
1
2
3
4
Confidential – Oracle Internal/Restricted/Highly Restricted 3

• Scalability: handle thousands of concurrent clients streaming data into the
same table/database
• Responsiveness: minimal response time, asynchronous processing, with
non-blocking back-pressure
• Elasticity: responsiveness not being affected under varying workload
Common requirements for multiple concurrent agents streaming data
In these scenarios regular JDBC inserts will not scale

• Automatic Routing (payload dependent)
• High Availability
• Disaster Recover
• Planned Maintenance and changes in the database topology
• Database upgrades (use new features with no changes on the client)
Transparently exploit -with no changes in the client- features of the Database
Provide an abstraction layer with these features

Program Agenda
Cloud Service Demo
1
2
3
4

• Fastest insert method for Oracle
Database: through Direct Path
• RAC and Shard awareness (routing
capabilities): through native UCP
• Extremely simple to configure and use
• Streaming capability: unblockingly
receive data from a large group of
clients
Java library that allows users to stream data into the Oracle Database
UCP
Connection
Pool
Thin Driver Direct
Path
Core Library
Local Threads
processing
queues
(grouped
records) with
tagged
connections
queue2
queue1
Java Client
(Push
Publisher
API)
Java Client
(Flow
Publisher
API)
accept(byte[])
onNext(byte[])
request(n)

– Since 19c Thin Driver supports Direct Path Insert as part of the Oracle Connection
internal APIs (not JDBC standard)
– The library uses these APIs for loading bulk data faster in database.
– Direct Path skips SQL engine in server side writing data directly in database buffers.
– Direct Path loads stream in a table or in a partition with some intrinsic limitations:
• Triggers are not supported
• Referential integrity is not checked
• Partitioning columns come before any LOB
Fastest insert method for Oracle Database: through Direct Path

– Through UCP usage get the capability to recognize the sharding keys specified by the
users and allow them to connect to the specific shard and chunk
– Cache sharding-key ranges to the location of the shard to allow connection request
bypassing the GSM (shard director)
– Select an available connection in the pool just by providing sharding keys; this allows
the reuse of connections to various shards by using the cached routing topology
RAC and Shard awareness (routing capabilities): through native UCP

Extremely simple to configure and use
// Simple and intuitive constructor
FastIngestSuite fis = new FISBuilder()
.url(url)
.schema("scott")
.username("scott")
.password("tiger")
.executor(newScheduledThreadPool(2))
.bufferCapacity(bufferCapacity)
.bufferInterval(Duration.ofMillis(1000))
.transformer(bytes -> new Customer(bytes)) // Function<byte[], Record>
.table("customers")
.columns(new String[] { "ID", "NAME", "REGION" })
.build();
// Coming soon!: Record API (no need for transformer, table and/or column
@Record
@Table(name = “customers”)
class Costumer {
@Column(name = “ID”) private long id;
@Column(name = “NAME”) private String name;
@Column(name = “REGION”) private String region;
}

Program Agenda
Demo
1
2
3
4

Push Publisher - For Simple Usage
FastIngestSuite fis = FastIngestSuite.builder(). . . // Easy constructor
.transformer(bytes -> { // Lambda transformation
final Transformer.Record record = new Transformer.Record();
record.setColumnValue("payload", bytes);
record.setColumnValue("state_code", "CA");
return record;})
.table("fis_demo_nonsharded_sample")
.build();
PushPublisher<byte[]> pushPublisher = FastIngestSuite.pushPublisher(); // Factory builder
pushPublisher.subscribe(fis.subscriberByteArray());
// Ingest ad-hoc
pushPublisher.accept(new byte[] {'a', 'b'});
// Ingest using Consumer Functional Interface
List<byte[]> data = Arrays.asList(
new byte[] { 'a', 'b' }, new byte[] { 'a', 'c' }, new byte[] { 'b', 'c' });
data.stream()
.filter(p -> p[0] == 'b')
.forEach(pushPublisher::accept);

Flow Publisher - A recap on Flow API
Provided by the library

Flow Publisher - Creating Custom Publishers
// Library user creates Publisher’s implementation
public class MyPublisher implements Publisher<byte[]> {
// This implementation has a reference to the threadpool where execution will take place
private final ExecutorService threadPool;
// This implementation has a reference to only one subscription (it could be more than one)
private Subscription subscription = null;
// Implementation must provide a subscribe behavior
@Override public void subscribe(Subscriber<? super byte[]> subscriber) {
subscription = new MySubscription(); // Subscription also provided by user
(fisSubscriber = subscriber).onSubscribe(subscription); // Execute subscriber’s onSubscribe
startPublishing(); // Optional, start publishing after subscription
. . .
// Sample publishing (like startPublishing)
private void startPublishing() {
threadPool.submit(() -> { // publishing executes on the Publisher’s threadppol
while (recordsCount > 0) {
fisSubscriber.onNext(byteArray); // <- onNext’s subscriber is where the data is sent
recordsCount--; // . . .

Flow Publisher - Using the Custom Publisher with the Library
// Create the publisher and subscribe to Library’s subscriber
MyPublisher myPublisher = new MyPublisher(threadPool, recordsCount);
flowPublisher.subscribe(fis.subscriberByteArray()); // Subscriber provided by the library (onNext –> ingest)
// Subscription provided by the user
private class MySubscription implements Subscription {
@Override public void request(long request) {
demand.addAndGet(request); // This is the mechanism for the Subscriber to signal unfulfilled demand
}
@Override public void cancel() {
isCancelled = true; // The subscriber signaling that it will stop receiving message
}
}

Flow Publisher - The Library is the Subscriber
public class FlowSubscriber<T> implements Flow.Subscriber<T> {
@Override public void onSubscribe(Subscription givenSubscription) { // It’s called from the Publisher
if (activeSubscription == null) {
isSubscribed = true;
activeSubscription = givenSubscription;
long request = fis.request(); // Check availability on the internal buffer
if (request > 0) {
activeSubscription.request(request); // Signal availability . . .
@Override public void onNext(T item) {
// Unblocking adding item to the buffer
// Ingestion will execute in the library's threadpool (which is the most important feature!)
fis.putRecord((byte[]) item);
// Calculate remaining capability and signal
long request = fis.request();
if (request > 0) {
activeSubscription.request(request);
} else {
// Buffer is full . . .
@Override public void onError(Throwable throwable) { // Provide error handling
@Override public void onComplete() { // Provide completion handling

Flow Publisher – Using SubmissionPublisher (java.base module/java.util.concurrent pck.)
// Use SubmissionPublisher provided by the JRE
// Default ForkJoinPool.commonPool();, DEFAULT_BUFFER_SIZE = 256;
SubmissionPublisher<byte[]> publisher = new SubmissionPublisher<>();
publisher.subscribe(fis.subscriberByteArray());
// User publisher’s built-in methods: submit, offer, status of Pubs vs Subs.
publisher.submit(new byte[] { 'a', 'b' });
// Graceful shutdown
publisher.close();
fis.close();
ForkJoinPool.commonPool().shutdown();
Flow Publisher – Ready for 3rd party implementations!
• RxJava
• Reactive4JavaFlow
• Future implementations!

Program Agenda
Demo
1
2
3
4
POC

Demo & Outcome
Oracle Database 19c running
on 1 Exalogic X4-2 compute
node*.
Table:
• Id
• Name
• Region
*Exalogic X4-2 compute node - Memory: 94.6GB - CPU 12 cores, 24 threads, 2 sockets, Intel Xeon Processor X5675 3.07GHz,
Collector running on 1
Exalogic X4-2 compute
node*.
• 4 threads for service I/O
• 8 threads for library
• 20s buffer limit
• 4gb buffer cap
JMeter (load simulator)
running on 1 Exalogic X4-2
compute node*.
• 10.000 concurrent threads
• 2’ start up time
• 0.25s between posts
• 120b payload
Rate: 40.000 rpc/second
Avg. response time: ~ 4-5ms

Java Library for High Speed Streaming Data

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Java Library for High Speed Streaming Data

Similar to Java Library for High Speed Streaming Data (20)

More from Oracle Developers

More from Oracle Developers (20)

Recently uploaded

Recently uploaded (20)

Java Library for High Speed Streaming Data