JetstreamOne-Platine

Jetstream.one

Java In-Memory Database. Persisting plain Java objects. No more mapping needed,
no more query language, up to 1,000 times faster than any SQL database.
Develop impressiv  real-time business apps.
blur-1853262
Do you have complex data structure, lots queries and time-consuming joins? Is your database already stretched to it's limit? Or are you just dreaming about a high-speed business application? Jetstream.one is exactly what you need.

Develop impressive fast
Realtime Business Apps

jetstramOne_logo_yellow_whiteBackground_300

Why Jetstream.one ?

Jetstream.one is an Open Source Java database management system which enables you to persist plain Java objects. In order to do this, Jetstream.one streams your Java objects exactly as they are existing in the memory to the file storage. Jetstream.one is the only DBMS that dispenses completely with any object mapping. This means that Jetstream.one does not convert your objects to be persisted to an artificial structure or format, such as relations, JSON, XML, etc. This alone accelerates database apps enormously.

 

Up to 1,000 times faster than SQL databases !


 
Furthermore, Jetstream.one enables you to make the most of your memory by pre-loading large part of your data directly in the main memory. Thus, you can access and query your data in-memory in a elegant and powerful way by using Java 8 streams. As a consequence the average access time for your queries is only a few microseconds, which is up to 1,000 times faster than any SQL database. Jetstream.one enables you to develop high-speed applications which will make your users happy and shocking your competitors. Because of that, Jetstream.one is a manager's dream.
 
Jetstream.one is a developers dream as well. Jetstream.one developers have to create and maintain just only one data model, nothing but a plain Java object model. You do not have to adjust your objects making them compatible with a different database structure. You not even have to care for entity object lifecycle as with JPA. This reduces the complexity radically, eliminates a huge potential error source completely, simplyfies and accelerates your entire database development process and reduces your costs for implementing and maintaining enormously.

Persisting Plain
Java Objects

Jetstream.one enables you to persist any Java object exactly like it is existing in the memory, without mapping to any other structure or format. Jetstream.one streams the entire object graph or only parts of it directly to the file storage.
 
When you start your app, Jetstream.one enables you to pre-load large part of your object graph directly into the memory by using lazy-loading. Therefore, data accesses with Jetstream.one are enormously fast, which makes your application becomming a real-time solution.
coffee-beans-335631

No More Monolithic


Database Server.

Easy to embed, Simple To Deploy, no administration. Perfect for Embedded, Cloud & Microservices.
 
Jetstream.one runs within your application layer as a light-weight part of your application. You only have include a 12 MB JAR file to use it. Thus, Jetstream.one is predestinated for embedded, cloud and microservices usage.
Monolithic-Server-DB
InMemory

In-Memory Power

Jetstream.one ensures automatically by using lazy-loading that all needed data are available in main memory. You can also take control at any time. You can pre-load part of your data or even the entire object graph in case enough memory is available. Queries are executed in memory in microseconds. Up to 1,000 times faster than SQL queries. With Jetstream.one you are prepared best for smaller business apps as well as for big data.

No More
Query Language.

You can write all of your Queries with
Java 8 Streams.
 
With Jetstream one you don't have to learn another query language or API. Jetstream.one ensures automatically that all needed data are available in main memory. This allows you to execute queries directly in memory in microseconds by using Java 8 streams.
List<Integer> transactionsIds =
   transactions.stream()
               .filter(t -> t.getType() == Transaction.GROCERY)
               .sorted(comparing(Transaction::getValue).reversed())
               .map(Transaction::getId)
               .collect(toList());

Jetstream.one
Architecture

JetstreamArchitecture
Jetstream_Schaubilder

Object-Relational Mapping

sandTime

No More Mapping

Java objects and relational databases are incompatible. This problem is called obect-relational impedance mismatch and well known since more than 40 years.

JPA is trying to solve that problem by mapping Java objects to relational database tables. But OR-mapping is very expensive. It takes lots computing time and brakes your application. Caches are strongly needed to compensate the loss of time. Thus OR-mapping is basically a huge potential source of error and it increases the complexity for the developer tremendously.

What's about No-SQL? Mapping Java objects to other artificial formats like XML, JSON, key-value couples etc. is pretty much the same overhead and moreover it is needed not at all.
screen-1839500

Developers' Dream

Developing and supporting only 1 data model - your Java object model. No JPA needed. No more query language to learn. Reduces the complexity of database development with Java tremendously.
For the very first time, the entire database application is just Java.
What is a Java developer working with preferably?
Database tables, JSON, XML, key-value stores? We as Java developers love objects, right?
Why do we destroy our objects just to persist them, if we actually do not have to?
Why don't we persist our objects just as they are, instead of making life unnecessarily difficult using artificial formats and sophisticated mappings? This is exactly what Jetstream.one does.

 

Thomas Muenz
Chief Developer & Inventor of Jetstream.one
Services
 
Features
 
Community