Eclipse JNoSQL databases

Hazelcast is an open source in-memory data grid based on Java.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the HazelcastConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Hazelcast’s Key-Value API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<HazelcastBucketManager> and then defines it as an @Alternative and the Priority.

The HazelcastTemplate interface is a specialization of the KeyValueTemplate interface that allows execution of a Hazelcast query.

Infinispan is a distributed in-memory key/value data store with optional schema, available under the Apache License 2.0.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the InfinispanConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Infinispan’s Key-Value API with MicroProfile Config.

Memcached is a general-purpose distributed memory caching system. It is often used to speed up dynamic database-driven websites by caching data and objects in RAM to reduce the number of times an external data source (such as a database or API) must be read. Memcached is free and open-source software, licensed under the Revised BSD license. Memcached runs on Unix-like operating systems (at least Linux and OS X) and on Microsoft Windows.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the MemcachedConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Memcached’s Document API with MicroProfile Config.

Redis is a software project that implements data structure servers. It is open-source, networked, in-memory, and stores keys with optional durability.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This is an example using Redis’s Key-Value API with MicroProfile Config. Please note that you can establish properties using the MicroProfile Config specification.

This API provides enum classes to programmatically establish the credentials as:

• RedisConfigurations for single node configuration

  # Single Node Configuration
  
  # by default the host is localhost
  jnosql.redis.host=localhost
  # by default the port is 6379
  jnosql.redis.port=6379
  # if you have user
  jnosql.redis.user=youruser
  # if you have password
  jnosql.redis.password=yourpassword

• RedisSentinelConfigurations for sentinel configuration

  # Sentinel Configuration
  jnosql.redis.sentinel.hosts=host1:26379,host2:26379
  
  jnosql.redis.sentinel.master.name=masterName
  jnosql.redis.sentinel.master.user=masterUser
  jnosql.redis.sentinel.master.password=masterPassword
  #jnosql.redis.sentinel.master.ssl=false
  #jnosql.redis.sentinel.master.timeout=2000
  #jnosql.redis.sentinel.master.connection.timeout=2000
  #jnosql.redis.sentinel.master.socket.timeout=2000
  
  jnosql.redis.sentinel.slave.user=slaveUser
  jnosql.redis.sentinel.slave.password=slavePassword
  #jnosql.redis.sentinel.slave.ssl=false
  #jnosql.redis.sentinel.slave.timeout=2000
  #jnosql.redis.sentinel.slave.connection.timeout=2000
  #jnosql.redis.sentinel.slave.socket.timeout=2000

• RedisClusterConfigurations for cluster configuration

  # Cluster Configuration
  
  jnosql.redis.cluster.hosts=host1:6379,host2:6379
  jnosql.redis.cluster.user=clusterUser
  jnosql.redis.cluster.password=clusterPassword
  jnosql.redis.cluster.client.name=clusterClientName
  jnosql.redis.cluster.max.attempts=5
  jnosql.redis.cluster.max.total.retries.duration=10000
  #jnosql.redis.cluster.ssl=false
  #jnosql.redis.cluster.timeout=2000
  #jnosql.redis.cluster.connection.timeout=2000
  #jnosql.redis.cluster.socket.timeout=2000

Riak (pronounced "ree-ack") is a distributed NoSQL key-value data store that offers high availability, fault tolerance, operational simplicity, and scalability. In addition to the open-source version, it comes in a supported enterprise version and a cloud storage version.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the RiakConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Riak’s Key-Value API with MicroProfile Config.

Valkey is a software project that implements data structure servers. It is open-source, networked, in-memory, and stores keys with optional durability.

This driver provides support for the Key-Value NoSQL API.

You can use either the Maven or Gradle dependencies:

This is an example using Valkey’s Key-Value API with MicroProfile Config. Please note that you can establish properties using the MicroProfile Config specification.

This API provides enum classes to programmatically establish the credentials as:

• ValkeyConfigurations for single node configuration

  # Single Node Configuration
  
  # by default the host is localhost
  jnosql.valkey.host=localhost
  # by default the port is 6379
  jnosql.valkey.port=6379
  # if you have user
  jnosql.valkey.user=youruser
  # if you have password
  jnosql.valkey.password=yourpassword

• ValkeySentinelConfigurations for sentinel configuration

  # Sentinel Configuration
  jnosql.valkey.sentinel.hosts=host1:26379,host2:26379
  
  jnosql.valkey.sentinel.master.name=masterName
  jnosql.valkey.sentinel.master.user=masterUser
  jnosql.valkey.sentinel.master.password=masterPassword
  #jnosql.valkey.sentinel.master.ssl=false
  #jnosql.valkey.sentinel.master.timeout=2000
  #jnosql.valkey.sentinel.master.connection.timeout=2000
  #jnosql.valkey.sentinel.master.socket.timeout=2000
  
  jnosql.valkey.sentinel.slave.user=slaveUser
  jnosql.valkey.sentinel.slave.password=slavePassword
  #jnosql.valkey.sentinel.slave.ssl=false
  #jnosql.valkey.sentinel.slave.timeout=2000
  #jnosql.valkey.sentinel.slave.connection.timeout=2000
  #jnosql.valkey.sentinel.slave.socket.timeout=2000

• ValkeyClusterConfigurations for cluster configuration

  # Cluster Configuration
  
  jnosql.valkey.cluster.hosts=host1:6379,host2:6379
  jnosql.valkey.cluster.user=clusterUser
  jnosql.valkey.cluster.password=clusterPassword
  jnosql.valkey.cluster.client.name=clusterClientName
  jnosql.valkey.cluster.max.attempts=5
  jnosql.valkey.cluster.max.total.retries.duration=10000
  #jnosql.valkey.cluster.ssl=false
  #jnosql.valkey.cluster.timeout=2000
  #jnosql.valkey.cluster.connection.timeout=2000
  #jnosql.valkey.cluster.socket.timeout=2000

Apache Cassandra is a free and open-source distributed database management system designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure.

This driver provides support for the Column Family NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the CassandraConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Cassandra with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<CassandraColumnManager> and then defines it as an @Alternative and the Priority.

The CassandraTemplate interface is a specialization of ColumnTemplate interface that allows using CQL.

The CassandraRepository interface is an extension of the Repository interface that allows execution of CQL and Consistency Level via the @CQL annotation.

HBase is an open source, non-relational, distributed database modeled after Google’s BigTable and is written in Java.

This driver provides support for the Column Family NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the HbaseConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using HBase’s Column Family NoSQL API with MicroProfile Config.

ArangoDB is a native multi-model database with flexible data models for documents, graphs, and key-values. Build high performance applications using a convenient SQL-like query language or JavaScript extensions.

This API offers support for Document and Key-Value types. The Graph is possible through Apache TinkerPop.

You can use either the Maven or Gradle dependencies:

This API provides the ArangoDBConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using ArangoDB’s Document API with MicroProfile Config.

This is an example using ArangoDB’s Key-Value API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<ArangoDBDocumentManager> and then defines it as an @Alternative and the Priority.

The ArangoDBTemplate interface is a specialization of the DocumentTemplate interface that allows using both synchronous and asynchronous AQL.

The ArangoDBRepository interface is an extension of the Repository interface that allows execution of AQL via the @AQL annotation. Also, it’s possible to combine with @Param annotation to execute parameterized AQL queries:

The Couchbase driver provides an API integration between Java and the database through a standard communication level.

This driver has support for two NoSQL API types: Document and Key-Value.

You can use either the Maven or Gradle dependencies:

This API provides the CouchbaseConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Couchbase’s Document API with MicroProfile Config.

This is an example using Couchbase’s Key-Value API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<CouchbaseDocumentManager> and then defines it as an @Alternative and the Priority.

The CouchbaseTemplate interface is a specialization of the DocumentTemplate interface that allows using N1QL on both synchronous and asynchronous.

The CouchbaseRepository interface is an extension of the Repository interface that allows execution of N1QL via the @N1QL annotation.

The CouchDB driver provides an API integration between Java and the database through a standard communication level.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the CouchDBConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using CouchDB’s Document API with MicroProfile Config.

Amazon DynamoDB is a fully managed, serverless, key-value and document NoSQL database designed to run high-performance applications at any scale. DynamoDB offers built-in security, continuous backups, automated multi-Region replication, in-memory caching, and data import and export tools.

This driver has support for two NoSQL API types: Key-Value and Document.

You can use either the Maven or Gradle dependencies:

This API provides the DynamoDBConfigurations class to programmatically establish the credentials.

Please note that you can establish properties using the MicroProfile Config specification.

The DynamoDBTemplate interface is a specialization of the DocumentTemplate interface that allows using PartiQL queries.

The DynamoDBRepository interface is an extension of the Repository interface that allows execution of PartiQL via the @PartiQL annotation.

Elasticsearch is a search engine based on Lucene. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. Elasticsearch is developed in Java and is released as open source under the terms of the Apache License. Elasticsearch is the most popular enterprise search engine followed by Apache Solr, also based on Lucene.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the ElasticsearchConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Elasticsearch’s Document API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<ElasticsearchDocumentManager> and then defines it as an @Alternative and the Priority.

The ElasticsearchTemplate interface is a specialization of the DocumentTemplate interface that allows using a search engine on both synchronous and asynchronous.

MongoDB is a free and open-source cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with schemas.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the MongoDBDocumentConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Mongodb’s Document API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<MongoDBDocumentManager> and then defines it as an @Alternative and the Priority.

The MongoDBTemplate interface is a specialization of the DocumentTemplate interface that allows MongoDB particular behavior such as delete and select elements using a Bson implementation and aggreate query.

Oracle NoSQL Database is a versatile multi-model database offering flexible data models for documents, graphs, and key-value pairs. It empowers developers to build high-performance applications using a user-friendly SQL-like query language or JavaScript extensions.

This API provides support for Document and Key-Value data types.

You can include Oracle NoSQL as a dependency using either Maven or Gradle:

The API offers the OracleNoSQLConfigurations class to programmatically set up credentials. It also supports configuration via the MicroProfile Config specification.

Below are examples using Oracle NoSQL’s Document API and Key-Value API with MicroProfile Config.

Document API Example:

Key-Value API Example:

Although these are the default configuration settings, you have the option to configure them programmatically. Create a class that implements Supplier<OracleNoSQLDocumentManager>, annotate it with @Alternative, and set the priority using @Priority.

The OracleNoSQLTemplate interface, an extension of the DocumentTemplate, enables synchronous SQL operations.

The OracleNoSQLRepository interface extends the Repository interface and allows executing SQL queries using the @SQL annotation. You can also combine it with the @Param annotation for parameterized SQL queries:

OrientDB is an open source NoSQL database management system written in Java. It is a multi-model database, supporting graph, document, key/value, and object models, but the relationships are managed as in graph databases with direct connections between records. It supports schema-less, schema-full and schema-mixed modes. It has a strong security profiling system based on users and roles and supports querying with Gremlin along with SQL extended for graph traversal.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the OrientDBDocumentConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using OrientDB’s Document API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<OrientDBDocumentManager> and then defines it as an @Alternative and the Priority.

The OrientDBTemplate interface is a specialization of the DocumentTemplate interface that allows execution of a SQL query and live query on both synchronous and asynchronous.

The OrientDBCrudRepository interface is an extension of the Repository interface that allows execution of a SQL Query via the @SQL annotation.

RavenDB is a fully Transactional Open Source NoSQL Document Database. Easy to use, rapidly scalable, offers high availability, and takes your Business into the Next Generation of Data Performance.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the RavenDBConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using RavenDB’s Document API with MicroProfile Config.

Solr is an open-source enterprise-search platform, written in Java, from the Apache Lucene project. Its major features include full-text search, hit highlighting, faceted search, real-time indexing, dynamic clustering, database integration, NoSQL features and rich document (e.g., Word, PDF) handling. Providing distributed search and index replication, Solr is designed for scalability and fault tolerance. Solr is widely used for enterprise search and analytics use cases and has an active development community and regular releases.

This driver provides support for the Document NoSQL API.

You can use either the Maven or Gradle dependencies:

This API provides the SolrDocumentConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Solr’s Document API with MicroProfile Config.

The config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<SolrDocumentManager> and then defines it as an @Alternative and the Priority.

The SolrTemplate interface is a specialization of the DocumentTemplate that allows execution of a Solr query.

The SolrRepository interface is an extension of the Repository interface that allows using Solr query annotation that executes Solr query.

InfluxDB is a time-series database optimized for timestamped metrics, events, monitoring, and IoT data.

The Eclipse JNoSQL InfluxDB driver connects the Time Series Mapping API to InfluxDB 3. Applications can use TimeSeriesTemplate and Jakarta Data repositories while keeping InfluxDB connection and data-model details in the driver.

Add the driver to the application. It already includes the JNoSQL Time Series Mapping API:

The driver uses the official InfluxDB 3 Java client and translates JNoSQL queries to parameterized SQL.

Create an InfluxDB 3 database and a database token with read and write access.

This API provides the InfluxDBTimeSeriesConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using InfluxDB’s Time Series API with MicroProfile Config.

Apache IoTDB is a time-series database designed for IoT data management and analysis.

The Eclipse JNoSQL IoTDB driver connects the Time Series Mapping API to IoTDB’s native Table Model API without vendor-specific entity annotations.

The driver uses the official org.apache.iotdb:iotdb-session:2.0.11 client and requires Java 21 or newer.

Create the IoTDB database before starting the application. Tables and columns are created automatically during native tablet ingestion when the server’s enable_auto_create_schema setting is enabled.

This API provides the IoTDBTimeSeriesConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using Apache IoTDB’s Time Series API with MicroProfile Config.

QuestDB is a high-performance time-series database with native ingestion and SQL querying.

The Eclipse JNoSQL QuestDB driver uses the standard Time Series Mapping API and does not require vendor-specific annotations.

The driver uses only QuestDB’s official Java client. Both ingestion and SQL queries run over QWP; no PostgreSQL or JDBC driver is required.

QuestDB has one logical database per server. jnosql.timeseries.database is retained as the JNoSQL manager name, while each entity name maps to a QuestDB table.

This API provides the QuestDBTimeSeriesConfigurations class to programmatically establish the credentials. Please note that you can establish properties using the MicroProfile Config specification.

This is an example using QuestDB’s Time Series API with MicroProfile Config.

Currently, the Jakarta NoSQL doesn’t define an API for Graph database types but Eclipse JNoSQL provides a Graph template to explore the specific behavior of this NoSQL type.

Eclipse JNoSQL offers a mapping implementation for Graph NoSQL types:

Despite the other three NoSQL types, Eclipse JNoSQL API does not offer a communication layer for Graph NoSQL types. Instead, it integrates with Apache Tinkerpop 3.x.

Eclipse JNoSQL does not provide Apache Tinkerpop 3 dependency; check if the provider does. Otherwise, do it manually.

You can define the database settings using the MicroProfile Config specification, so you can add properties and overwrite it in the environment following the Twelve-Factor App.

These configuration settings are the default behavior. Nevertheless, there is an option to programmatically configure these settings. Create a class that implements the Supplier<Graph>, then define it using the @Alternative and @Priority annotations.

You can work with several graph database instances through CDI qualifier. To identify each database instance, make a Graph visible for CDI by putting the @Produces and the @Database annotations in the method.

The TinkerpopTemplate extends the Eclipse JNoSQL Graph template with Apache TinkerPop traversal operations. The following example uses the provider-independent traversal API exposed by the integration.

Apache TinkerPop is database agnostic. Thus, you can change the database in your application with no or minimal impact on source code.

Neo4J is a highly scalable, native graph database designed to manage complex relationships in data. It enables developers to build applications that leverage the power of graph traversal, pattern matching, and high-performance querying using the Cypher query language.

This API provides support for Graph database operations, including entity persistence, query execution via Cypher, and relationship traversal.

You can use either the Maven or Gradle dependencies:

This API provides the Neo4JDatabaseConfigurations class to programmatically establish the credentials. You can configure Neo4J properties using the MicroProfile Config specification.

The Neo4JTemplate interface extends GraphTemplate and allows for dynamic Cypher execution.

The Neo4JRepository interface extends the NoSQLRepository interface and enables query execution using the @Cypher annotation.