Eclipse JNoSQL

Eclipse JNoSQL is an open-source Java framework that simplifies integration with NoSQL databases through Jakarta EE standards. It implements Jakarta NoSQL and Jakarta Data and integrates with Jakarta Query, bringing together object mapping, repositories, templates, and expressive query capabilities for Java applications.

Jakarta NoSQL defines persistence and object mapping APIs, Jakarta Data provides repository-based data access, and Jakarta Query establishes a common object-oriented query language. Eclipse JNoSQL brings these complementary programming models together while respecting the capabilities of different NoSQL databases.

Eclipse JNoSQL supports six NoSQL database models: Key-Value, Document, Wide-Column, Graph, Time Series, and Vector. It offers common persistence abstractions and specialized APIs for database-model-specific capabilities.

The framework integrates with Jakarta CDI and MicroProfile Config and supports applications running in Java SE and compatible Jakarta EE environments.

Object Mapping with Jakarta NoSQL

Jakarta NoSQL provides annotations for mapping Java objects to NoSQL databases. Developers work with Java entities while Eclipse JNoSQL handles mapping through the configured database provider.

@Entity
public class Product {

    @Id
    private String id;

    @Column
    private String name;

    @Column
    private BigDecimal price;

    // Constructors and accessors
} 

Persistence with the Template API

Jakarta NoSQL defines the common Template interface, providing persistence operations independently of a specific NoSQL database model. Eclipse JNoSQL integrates templates with CDI, allowing applications to inject the configured persistence implementation.

@Inject
Template template;

Product product = new Product(
    "p-1", "Keyboard",
    new BigDecimal("49.90"));

template.insert(product);

Optional<Product> result =
    template.find(Product.class, "p-1"); 

Specialized Templates for NoSQL Database Models

While the common Template API provides shared persistence operations, Eclipse JNoSQL also offers specialized interfaces that expose the capabilities of each database model.

• KeyValueTemplate: Key-based access, storage, retrieval, and deletion.
• DocumentTemplate: Document persistence, filtering, and fluent queries.
• ColumnTemplate: Wide-Column persistence and queries adapted to column-oriented database structures.
• GraphTemplate: Graph entities, relationships, edges, and graph-oriented operations.
• TimeSeriesTemplate: Time-oriented persistence, temporal filtering, and time-based retrieval.
• VectorTemplate: Vector persistence, similarity search, and vector-oriented queries.

For example, an application can inject a specialized template when it needs document-specific operations:

@Inject
DocumentTemplate documentTemplate; 

This approach allows developers to start with common persistence abstractions and use specialized operations when required, without hiding the differences between database models. Availability of specialized capabilities depends on the selected JNoSQL version and provider.

Repositories with Jakarta Data

Jakarta Data provides a repository-oriented programming model. Developers declare interfaces, and Eclipse JNoSQL supplies their persistence implementations.

@Repository
public interface ProductRepository
    extends BasicRepository<Product, String> {

    List<Product> findByName(String name);
} 

Repositories integrate with CDI and provide declarative persistence operations without requiring developers to implement database-access boilerplate.

@Inject
ProductRepository repository;

repository.save(product);

Optional<Product> result =
    repository.findById("p-1"); 

Repository capabilities, including derived queries, depend on the selected database model and provider. Not every NoSQL database supports filtering by arbitrary entity attributes.

Querying with Jakarta Query

Jakarta Query defines a common object-oriented query language used across Jakarta persistence specifications. It enables developers to express queries over Java entities using consistent language constructs.

Jakarta Query defines a Core language for broad persistence compatibility, including NoSQL databases, and an Extended language for database systems supporting more advanced query capabilities.

Jakarta Data repositories can declare queries using the @Query annotation:

@Repository
public interface ProductRepository
    extends BasicRepository<Product, String> {

    @Query("WHERE price > :minimumPrice")
    List<Product> findExpensive(
        @Param("minimumPrice")
        BigDecimal minimumPrice);
} 

Eclipse JNoSQL aligns its querying capabilities with Jakarta Query while retaining database-specific query operations. Support for particular query constructs depends on the database integration and the JNoSQL release.

Goals

• Increase developer productivity through standardized Jakarta EE persistence APIs.
• Implement Jakarta NoSQL and Jakarta Data and integrate the query language defined by Jakarta Query.
• Provide rich object mapping integrated with Jakarta Contexts and Dependency Injection (CDI).
• Support Jakarta NoSQL templates and Jakarta Data repositories as complementary persistence approaches.
• Provide a common Template API alongside specialized templates for database-model-specific operations.
• Support Key-Value, Document, Wide-Column, Graph, Time Series, and Vector database models.
• Offer fluent Java query APIs, declarative queries, and expressive persistence operations while respecting database-specific capabilities.
• Enable polyglot persistence using common abstractions without sacrificing database-specific functionality.
• Support Java SE and Jakarta EE environments through CDI and externalized configuration.
• Promote portability, extensibility, and maintainability across NoSQL database providers.

Learn More

• Eclipse JNoSQL Website 
• Documentation 
• Source Code 
• Database Integrations 
• Java SE Examples