This repository provides database-specific integrations for Eclipse JNoSQL.
The integrations build on the APIs and abstractions provided by:
This documentation focuses on what is specific to each database provider, such as installation, configuration, specialized APIs, converters, limitations, and provider-specific capabilities.
Key-Value databases store values associated with unique keys and are commonly used for fast lookups, caching, session state, and simple data models.
ArangoDB supports both Key-Value and Document APIs in this project. Its full installation, configuration, examples, and database-specific extensions are documented in the canonical ArangoDB Document section.
Couchbase supports both Key-Value and Document APIs in this project. Its full installation, configuration, examples, Template API, and repository support are documented in the canonical Couchbase Document section.
DynamoDB supports both Key-Value and Document APIs in this project. Its full installation, configuration, examples, capabilities, Template API, and repository support are documented in the canonical DynamoDB Document section.
Hazelcast is an open source in-memory data grid based on Java.
This driver provides support for the Key-Value NoSQL API.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-hazelcast</artifactId>
<version>1.2.0</version>
</dependency>This API provides the HazelcastConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The instance name uniquely identifying the hazelcast instance created by this configuration. This name is used in different scenarios, such as identifying the hazelcast instance when running multiple instances in the same JVM. |
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.hazelcast.host.1=localhost |
|
The database port |
|
The maximum number of ports allowed to use. |
|
Sets if a Hazelcast member is allowed to find a free port by incrementing the port number when it encounters an occupied port. |
|
Enables or disables the multicast discovery mechanism |
|
Enables or disables the Tcp/Ip join mechanism. |
This is an example using Hazelcast’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.hazelcast.communication.HazelcastKeyValueConfiguration
jnosql.keyvalue.database=heroesThe 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<HazelcastBucketManager> {
@Produces
public HazelcastBucketManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
HazelcastKeyValueConfiguration configuration = new HazelcastKeyValueConfiguration();
HazelcastBucketManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The HazelcastTemplate interface is a specialization of the KeyValueTemplate interface that allows execution of a Hazelcast query.
Collection<Person> people = template.query("active");
Collection<Person> people2 = template.query("age = :age", singletonMap("age", 10));
Collection<Person> people3 = template.query(Predicates.equal("name", "Poliana"));
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-infinispan</artifactId>
<version>1.2.0</version>
</dependency>This API provides the InfinispanConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.infinispan.host.1=HOST |
|
The Infinispan configuration path. E.g.: jnosql.infinispan.config=infinispan.xml |
This is an example using Infinispan’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.infinispan.communication.InfinispanKeyValueConfiguration
jnosql.keyvalue.database=heroes
jnosql.infinispan.config=infinispan.xml
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-memcached</artifactId>
<version>1.2.0</version>
</dependency>This API provides the MemcachedConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The daemon state of the IO thread (defaults to true). |
|
The maximum reconnect delay |
|
The protocol type net.spy.memcached.ConnectionFactoryBuilder.Protocol |
|
The locator type net.spy.memcached.ConnectionFactoryBuilder.Locator |
|
Custom wait time for the authentication on connect/reconnect. |
|
The maximum amount of time (in milliseconds) a client is willing to wait for space to become available in an output queue. |
|
The default operation timeout in milliseconds. |
|
The read buffer size. |
|
The default operation optimization is not desirable. |
|
The maximum timeout exception threshold. |
|
Enable the Nagle algorithm. |
|
The user’s userID |
|
The user’s password. |
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.memcached.host.1=localhost:11211 |
This is an example using Memcached’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.memcached.communication.MemcachedKeyValueConfiguration
jnosql.keyvalue.database=heroes
jnosql.memcached.host.1=localhost:11211Oracle NoSQL supports both Key-Value and Document APIs in this project. Its full installation, configuration, examples, Template API, and repository support are documented in the canonical Oracle NoSQL Document section.
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-redis</artifactId>
<version>1.2.0</version>
</dependency>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.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.redis.communication.RedisConfiguration
jnosql.keyvalue.database=heroesThis API provides enum classes to programmatically establish the credentials as:
-
RedisConfigurationsfor 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
-
RedisSentinelConfigurationsfor 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
-
RedisClusterConfigurationsfor 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
This API provides the RedisConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host |
|
The database port |
|
The redis timeout, the default value is 2000 milliseconds |
|
The password’s credential |
|
The redis database number |
|
The cluster client’s name. The default value is 0. |
|
The value for the maxTotal configuration attribute for pools created with this configuration instance. The default value is 1000. |
|
The value for the maxIdle configuration attribute for pools created with this configuration instance. The default value is 10. |
|
The value for the minIdle configuration attribute for pools created with this configuration instance. The default value is 1. |
|
The value for the maxWait configuration attribute for pools created with this configuration instance. The default value is 3000 milliseconds. |
|
The connection timeout in milliseconds configuration attribute for the jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the jedis client configuration with this configuration instance. |
|
The user configuration attribute for the jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the jedis client configuration with this configuration instance. |
This API provides the RedisSentinelConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration Property | Description |
|---|---|
|
The value for the sentinel HOST:PORT (separated by comma) configuration attribute for the jedis client configuration with this configuration instance. |
|
The value for the master name configuration attribute for the jedis client configuration with this configuration instance. |
|
The master client’s name, the default value is 0 |
|
The slave client’s name, the default value is 0 |
|
The master redis timeout, the default value is 2000 milliseconds |
|
The slave redis timeout, the default value is 2000 milliseconds |
|
The connection timeout in milliseconds configuration attribute for the master jedis client configuration created with this configuration instance. |
|
The connection timeout in milliseconds configuration attribute for the slave jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the master jedis client configuration with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The user configuration attribute for the master jedis client configuration with this configuration instance. |
|
The user configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The password configuration attribute for the master jedis client configuration with this configuration instance. |
|
The password configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the master jedis client configuration with this configuration instance. The default value is false. |
|
The ssl configuration attribute for the slave jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the master jedis client configuration with this configuration instance. |
|
The protocol configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the master jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info disabled configuration attribute for the slave jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the master jedis client configuration with this configuration instance. |
|
The clientset info configuration libname suffix attribute for the slave jedis client configuration with this configuration instance. |
This API provides the RedisClusterConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration Property | Description |
|---|---|
|
The value for the sentinel HOST:PORT (separated by comma) configuration attribute for the jedis client configuration with this configuration instance. |
|
The cluster client’s name. The default value is 0. |
|
The cluster redis timeout, the default value is 2000 milliseconds |
|
The connection timeout in milliseconds configuration attribute for the cluster jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The user configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The password configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the cluster jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the cluster jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the cluster jedis client configuration with this configuration instance. |
|
The value for the max attempts configuration attribute for the cluster jedis client configuration with this configuration instance. Default is 5. |
|
The value for the max total retries configuration attribute for the cluster jedis client configuration with this configuration instance. Default is 10000 milliseconds. |
The RedisBucketManagerFactory is a specialization of the BucketManagerFactory that enables ranking and counter feature.
@Inject
RedisBucketManagerFactory factory;
...
SortedSet game = factory.getSortedSet("game");
game.add("Otavio", 10);
game.add("Luiz", 20);
game.add("Ada", 30);
game.add(Ranking.of("Poliana", 40));
List<Ranking> ranking = game.getRanking();
Counter home = factory.getCounter("home");
Counter products = factory.getCounter("products");
home.increment();
products.increment();
products.increment(3L);Using the same principle of the API you can inject using the @KeyValueDatabase qualifier.
@Inject
@KeyValueDatabase("counter")
Counter counter;
@Inject
@KeyValueDatabase("game")
SortedSet game;
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-riak</artifactId>
<version>1.2.0</version>
</dependency>This API provides the RiakConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host |
This is an example using Riak’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.riak.communication.RiakKeyValueConfiguration
jnosql.keyvalue.database=heroes
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-valkey</artifactId>
<version>1.2.0</version>
</dependency>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.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.valkey.communication.ValkeyConfiguration
jnosql.keyvalue.database=heroesThis API provides enum classes to programmatically establish the credentials as:
-
ValkeyConfigurationsfor 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
-
ValkeySentinelConfigurationsfor 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
-
ValkeyClusterConfigurationsfor 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
This API provides the ValkeyConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host |
|
The database port |
|
The redis timeout, the default value is 2000 milliseconds |
|
The password’s credential |
|
The redis database number |
|
The cluster client’s name. The default value is 0. |
|
The value for the maxTotal configuration attribute for pools created with this configuration instance. The default value is 1000. |
|
The value for the maxIdle configuration attribute for pools created with this configuration instance. The default value is 10. |
|
The value for the minIdle configuration attribute for pools created with this configuration instance. The default value is 1. |
|
The value for the maxWait configuration attribute for pools created with this configuration instance. The default value is 3000 milliseconds. |
|
The connection timeout in milliseconds configuration attribute for the jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the jedis client configuration with this configuration instance. |
|
The user configuration attribute for the jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the jedis client configuration with this configuration instance. |
This API provides the ValkeySentinelConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration Property | Description |
|---|---|
|
The value for the sentinel HOST:PORT (separated by comma) configuration attribute for the jedis client configuration with this configuration instance. |
|
The value for the master name configuration attribute for the jedis client configuration with this configuration instance. |
|
The master client’s name, the default value is 0 |
|
The slave client’s name, the default value is 0 |
|
The master redis timeout, the default value is 2000 milliseconds |
|
The slave redis timeout, the default value is 2000 milliseconds |
|
The connection timeout in milliseconds configuration attribute for the master jedis client configuration created with this configuration instance. |
|
The connection timeout in milliseconds configuration attribute for the slave jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the master jedis client configuration with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The user configuration attribute for the master jedis client configuration with this configuration instance. |
|
The user configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The password configuration attribute for the master jedis client configuration with this configuration instance. |
|
The password configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the master jedis client configuration with this configuration instance. The default value is false. |
|
The ssl configuration attribute for the slave jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the master jedis client configuration with this configuration instance. |
|
The protocol configuration attribute for the slave jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the master jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info disabled configuration attribute for the slave jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the master jedis client configuration with this configuration instance. |
|
The clientset info configuration libname suffix attribute for the slave jedis client configuration with this configuration instance. |
This API provides the ValkeyClusterConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration Property | Description |
|---|---|
|
The value for the sentinel HOST:PORT (separated by comma) configuration attribute for the jedis client configuration with this configuration instance. |
|
The cluster client’s name. The default value is 0. |
|
The cluster redis timeout, the default value is 2000 milliseconds |
|
The connection timeout in milliseconds configuration attribute for the cluster jedis client configuration created with this configuration instance. |
|
The socket timeout in milliseconds configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The user configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The password configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The ssl configuration attribute for the cluster jedis client configuration with this configuration instance. The default value is false. |
|
The protocol configuration attribute for the cluster jedis client configuration with this configuration instance. |
|
The clientset info disabled configuration attribute for the cluster jedis client configuration with this configuration instance. The default value is false. |
|
The clientset info configuration libname suffix attribute for the cluster jedis client configuration with this configuration instance. |
|
The value for the max attempts configuration attribute for the cluster jedis client configuration with this configuration instance. Default is 5. |
|
The value for the max total retries configuration attribute for the cluster jedis client configuration with this configuration instance. Default is 10000 milliseconds. |
The ValkeyBucketManagerFactory is a specialization of the BucketManagerFactory that enables ranking and counter feature.
@Inject
ValkeyBucketManagerFactory factory;
...
SortedSet game = factory.getSortedSet("game");
game.add("Otavio", 10);
game.add("Luiz", 20);
game.add("Ada", 30);
game.add(Ranking.of("Poliana", 40));
List<Ranking> ranking = game.getRanking();
Counter home = factory.getCounter("home");
Counter products = factory.getCounter("products");
home.increment();
products.increment();
products.increment(3L);Using the same principle of the API you can inject using the @KeyValueDatabase qualifier.
@Inject
@KeyValueDatabase("counter")
Counter counter;
@Inject
@KeyValueDatabase("game")
SortedSet game;Column Family databases store related values in rows grouped into column families and are designed for distributed, scalable access to structured or sparsely populated records.
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-cassandra</artifactId>
<version>1.2.0</version>
</dependency>This API provides the CassandraConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The user’s userID. |
|
The user’s password |
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.cassandra.host.1=localhost |
|
The name of the application using the created session. |
|
The cassandra’s port |
|
The Cassandra CQL to execute when the configuration starts. It uses as a prefix. E.g.: jnosql.cassandra.query.1=<CQL> |
|
The datacenter that is considered "local" by the load balancing policy. |
This is an example using Cassandra with MicroProfile Config.
jnosql.column.provider=org.eclipse.jnosql.databases.cassandra.communication.CassandraConfiguration
jnosql.column.database=developers
jnosql.cassandra.query-1=<CQL-QUERY>
jnosql.cassandra.query.2=<CQL-QUERY-2>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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<CassandraColumnManager> {
@Produces
public CassandraColumnManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
CassandraConfiguration configuration = new CassandraConfiguration();
CassandraColumnManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The CassandraTemplate interface is a specialization of ColumnTemplate interface that allows using CQL.
@Inject
CassandraTemplate template;
...
template.save(person, ConsistencyLevel.ONE);The CassandraRepository interface is an extension of the Repository interface that allows execution of CQL and Consistency Level via the @CQL annotation.
@Repository
interface PersonRepository extends CassandraRepository<Person, String> {
@CQL("select * from Person")
List<Person> findAll();
@CQL("select * from Person where name = ?")
List<Person> findByName(String name);
@CQL("select * from Person where age = :age")
List<Person> findByAge(@Param("age") Integer age);
}-
TimestampConverter: That converts to/from java.util.Date
-
LocalDateConverter: That converts to/from com.datastax.driver.core.LocalDate
@Column
@Convert(value = TimestampConverter.class)
private LocalDateTime localDateTime;
@Column
@Convert(value = LocalDateConverter.class)
private Calendar calendar;The @Column contains a UDT attribute for mapping annotation that allows defining a field to be stored as a user-defined type in Cassandra.
@Entity
public class Person {
@Id("name")
private String name;
@Column
private Integer age;
@Column(udt="address")
private Address home;
}
ScyllaDB is a distributed, highly available database compatible with Apache Cassandra’s CQL protocol and designed for predictable, low-latency workloads.
This driver provides support for the Column Family NoSQL API using the ScyllaDB Java driver.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-scylladb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the ScyllaDBConfigurations class to programmatically establish the credentials.
You can also establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The user’s user ID. |
|
The user’s password. |
|
Database host. It is a prefix used to enumerate hosts. E.g.: jnosql.scylladb.host.1=localhost |
|
The name of the application using the created session. |
|
The ScyllaDB CQL port. |
|
The CQL to execute when the configuration starts. It is a prefix. E.g.: jnosql.scylladb.query.1=<CQL> |
|
The datacenter considered local by the load-balancing policy. |
This is an example using ScyllaDB with MicroProfile Config.
jnosql.column.provider=org.eclipse.jnosql.databases.scylladb.communication.ScyllaDBConfiguration
jnosql.column.database=developers
jnosql.scylladb.host.1=localhost
jnosql.scylladb.port=9042
jnosql.scylladb.query.1=<CQL-QUERY>
jnosql.scylladb.query.2=<CQL-QUERY-2>The configuration settings are the default behavior. To configure the manager programmatically, create an @Alternative class that implements Supplier<ScyllaDBColumnManager>.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<ScyllaDBColumnManager> {
@Produces
public ScyllaDBColumnManager get() {
Settings settings = Settings.builder()
.put(ScyllaDBConfigurations.HOST.get() + ".1", "localhost")
.put(ScyllaDBConfigurations.PORT.get(), 9042)
.build();
ScyllaDBConfiguration configuration = new ScyllaDBConfiguration();
ScyllaDBColumnManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The ScyllaDBTemplate interface specializes ColumnTemplate and supports CQL operations.
@Inject
ScyllaDBTemplate template;
template.save(person, ConsistencyLevel.ONE);The ScyllaDBRepository interface extends Repository and supports CQL queries and consistency levels through the @CQL annotation.
@Repository
interface PersonRepository extends ScyllaDBRepository<Person, String> {
@CQL("select * from Person")
List<Person> findAll();
@CQL("select * from Person where name = ?")
List<Person> findByName(String name);
@CQL("select * from Person where age = :age")
List<Person> findByAge(@Param("age") Integer age);
}The TimestampConverter converts values to and from java.util.Date.
@Column
@Convert(TimestampConverter.class)
private LocalDateTime localDateTime;
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-hbase</artifactId>
<version>1.2.0</version>
</dependency>This API provides the HbaseConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The Column family prefixes. E.g.: jnosql.hbase.family.1=<FAMILY> |
This is an example using HBase’s Column Family NoSQL API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.hbase.communication.HBaseColumnConfiguration
jnosql.column.database=heroesDocument databases store records as self-contained documents whose fields can be queried and evolved without requiring every record to share an identical structure.
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-arangodb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the ArangoDBConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host, where you need to put the port split by colons. E.g.: jnosql.jnosql.arangodb.host=localhost:8529 |
|
The user’s userID. |
|
The user’s password |
|
The connection and request timeout in milliseconds. |
|
The chunk size when Protocol is used. |
|
The true SSL will be used when connecting to an ArangoDB server. |
|
The com.arangodb.entity.LoadBalancingStrategy as String. |
|
The com.arangodb.Protocol as String |
|
The maximum number of connections the built-in connection pool will open per host. |
|
Set hosts split by comma |
This is an example using ArangoDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.arangodb.communication.ArangoDBDocumentConfiguration
jnosql.document.database=<DATABASE>
jnosql.arangodb.host=localhost:8529This is an example using ArangoDB’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.arangodb.communication.ArangoDBKeyValueConfiguration
jnosql.keyvalue.database=<DATABASE>
jnosql.arangodb.host=localhost:8529The 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<ArangoDBDocumentManager> {
@Produces
public ArangoDBDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
ArangoDBDocumentConfiguration configuration = new ArangoDBDocumentConfiguration();
ArangoDBDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The ArangoDBTemplate interface is a specialization of the DocumentTemplate interface that allows using both synchronous and asynchronous AQL.
@Inject
private ArangoDBTemplate template;
...
List<Person> people = template.aql("FOR p IN Person FILTER p.name = @name RETURN p", params);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:
@Repository
interface PersonRepository extends ArangoDBRepository<Person, String> {
@AQL("FOR p IN Person RETURN p")
List<Person> findAll();
@AQL("FOR p IN Person FILTER p.name = @name RETURN p")
List<Person> findByName(@Param("name") String name);
}The @AQL annotation is a mapping annotation that allows to define dynamic queries following ArangoDB Query Languange on ArangoDBRepository.
interface CarRepository extends ArangoDBRepository<Car, String> {
@AQL("FOR c IN Car RETURN c")
List<Car> findAll();
}For parameterized queries, use the @Param annotation for binding the target argument to the parameter informing the named parameter like the below example:
interface OrderRepository extends ArangoDBRepository<Order, String> {
@AQL("FOR o IN Order FILTER o.customer = @customer RETURN o")
List<Order> findByCustomer(@Param("customer") String customer);
}In ArangoDB, the _id field is a read-only, auto-generated value created by the database. It is a combination of the collection name and the _key field in the format <collection-name>/<_key>. The _id is automatically managed by the database, meaning any value set by the client will be ignored.
To map the _id and _key fields in your entities, you can use the @Id annotation and specify the _key field explicitly. This allows you to manage the _key value directly in your code while letting the database handle the _id generation.
For example:
@Entity
public class User {
@Id("_key")
private String key;
private String name;
}In this example, the _key field is annotated with @Id("_key"), allowing the application to control the _key value while the database auto-generates the corresponding _id field. This approach is useful for scenarios where you need to set or manage the _key value explicitly in your application logic.
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-couchbase</artifactId>
<version>1.2.0</version>
</dependency>This API provides the CouchbaseConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The host at the database. |
|
The user’s userID. |
|
The user’s password |
|
The scope to use at couchbase otherwise, it will use the default. |
|
couchbase collection split by a comma. At the start-up of a CouchbaseConfiguration, there is this option to check if these collections exist; if not, it will create using the default settings. |
|
A default couchbase collection. When it is not defined the default value comes from Bucket. |
|
A couchbase collection index. At the start-up of a {@link CouchbaseConfiguration}, it will read this property to check if the index does exist, if not it will create combined by scope and the database. |
This is an example using Couchbase’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.couchbase.communication.CouchbaseDocumentConfiguration
jnosql.document.database=heroes
jnosql.couchbase.host.1=localhost
jnosql.couchbase.user=root
jnosql.couchbase.password=123456This is an example using Couchbase’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.database=heroes
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.couchbase.communication.CouchbaseKeyValueConfiguration
jnosql.couchbase.host.1=localhost
jnosql.couchbase.user=root
jnosql.couchbase.password=123456The 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<CouchbaseDocumentManager> {
@Produces
public CouchbaseDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
CouchbaseDocumentConfiguration configuration = new CouchbaseDocumentConfiguration();
CouchbaseDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The CouchbaseTemplate interface is a specialization of the DocumentTemplate interface that allows using N1QL on both synchronous and asynchronous.
List<Person> people = template.n1qlQuery("select * from Person where name = $name", params);The CouchbaseRepository interface is an extension of the Repository interface that allows execution of N1QL via the @N1QL annotation.
@Repository
interface PersonRepository extends CouchbaseRepository<Person, String> {
@N1QL("select * from Person")
List<Person> findAll();
@N1QL("select * from Person where name = $name")
List<Person> findByName(@Param("name") String name);
}
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-couchdb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the CouchDBConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The port connection to a client connect. The default value is "5984" |
|
The max of connection that the couchdb client have. The default value is "20" |
|
The timeout in milliseconds used when requesting a connection. The default value is "1000". |
|
The socket timeout in milliseconds, which is the timeout for waiting for data or, put differently, a maximum period inactivity between two consecutive data packets). The default value is "10000". |
|
The current maximum response body size that will be cached. The value is "8192". |
|
The maximum number of cache entries the cache will retain. The default value is "1000". |
|
The host at the database. |
|
The username used for HTTP Basic authentication when connecting to CouchDB. |
|
The password used for HTTP Basic authentication when connecting to CouchDB. |
|
The token used for Bearer authentication (for example, a JWT). When set, the client sends |
|
If the request use a https or a http. |
|
Determines whether compressed entities should be decompressed automatically. |
This is an example using CouchDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.couchdb.communication.CouchDBDocumentConfiguration
jnosql.document.database=heroes
jnosql.couchdb.host=localhost
jnosql.couchdb.username=admin
jnosql.couchdb.password=password
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-dynamodb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the DynamoDBConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
DynamoDB’s URL |
|
Configure the region with which the application should communicate. |
|
Define the name of the profile that should be used by this credentials provider. |
|
The AWS access key, used to identify the user interacting with AWS. |
|
The AWS secret access key, used to authenticate the user interacting with AWS. |
This is an example using DynamoDB’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.dynamodb.communication.DynamoDBKeyValueConfiguration
jnosql.keyvalue.database=heroesHere’s an example using DynamoDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.dynamodb.communication.DynamoDBDocumentConfiguration
jnosql.document.database=heroesThe config settings are the default behavior; nevertheless, there is an option to do it programmatically. Create a class that implements the Supplier<DynamoDBDocumentManager> and then defines it as an @Alternative and the Priority.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<DynamoDBDocumentManager> {
@Produces
public DynamoDBDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
DynamoDBDocumentConfiguration configuration = new DynamoDBDocumentConfiguration();
DynamoDBDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The DynamoDBTemplate interface is a specialization of the DocumentTemplate interface that allows using PartiQL queries.
|
Warning
|
DynamoDB supports a limited subset of PartiQL. |
|
Note
|
This implementation doesn’t provide pagination on the queries. |
List<Person> people = template.partiQL("select * from Person where name = ? ", Person.class, params);The DynamoDBRepository interface is an extension of the Repository interface that allows execution of PartiQL via the @PartiQL annotation.
|
Warning
|
DynamoDB supports a limited subset of PartiQL. |
|
Note
|
This implementation doesn’t provide pagination on the queries. |
@Repository
interface PersonRepository extends DynamoDBRepository<Person, String> {
@PartiQL("select * from Person")
List<Person> findAll();
@PartiQL("select * from Person where name = ?")
List<Person> findByName(@Param("") String name);
}|
Important
|
It’s highly recommended to create the tables in a proper way, paying attention to the partition key and sort key, as well as the indexes. |
The DynamoDB implementation allows you to create tables on-the-fly, which can be useful for development and testing purposes. However, this feature should be used with caution in production environments, as it may lead to unexpected behavior or performance issues if not properly configured.
To create tables on-the-fly, you need to define the following properties:
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description | Default value |
|---|---|---|
|
If set to true, the implementation will create the tables on-the-fly when the application starts. This is useful for development and testing purposes, but should be used with caution in production environments. |
false |
|
The partition key field name for the table. This is used to define the primary key of the table. The |
_id |
|
The read capacity units for the table. This defines the number of strongly consistent reads per second that the table can support.The |
none |
|
The write capacity units for the table. This defines the number of strongly consistent writes per second that the table can support.The |
none |
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-elasticsearch</artifactId>
<version>1.2.0</version>
</dependency>This API provides the ElasticsearchConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.elasticsearch.host.1=172.17.0.2:1234 |
|
The user’s userID. |
|
The user’s password |
This is an example using Elasticsearch’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.elasticsearch.communication.ElasticsearchDocumentConfiguration
jnosql.document.database=developersThe 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<ElasticsearchDocumentManager> {
@Produces
public ElasticsearchDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
ElasticsearchDocumentConfiguration configuration = new ElasticsearchDocumentConfiguration();
ElasticsearchDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The ElasticsearchTemplate interface is a specialization of the DocumentTemplate interface that allows using a search engine on both synchronous and asynchronous.
@Inject
ElasticsearchTemplate template;
...
QueryBuilder queryBuilder = boolQuery().filter(termQuery("name", "Ada"));
List<Person> people = template.search(queryBuilder, "Person");
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-mongodb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the MongoDBDocumentConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host as prefix. E.g.: mongodb.host.1=localhost:27017 |
|
The user’s userID. |
|
MongoDB’s connection string |
|
The user’s password |
|
The source where the user is defined. |
|
Authentication mechanisms com.mongodb.AuthenticationMechanism |
|
Defines the logical name of the application connecting to MongoDB. |
This is an example using Mongodb’s Document API with MicroProfile Config.
jnosql.document.database=olympus
jnosql.mongodb.host=localhost:27017
jnosql.document.provider=org.eclipse.jnosql.databases.mongodb.communication.MongoDBDocumentConfigurationThe 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<MongoDBDocumentManager> {
@Produces
public MongoDBDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
MongoDBDocumentConfiguration configuration = new MongoDBDocumentConfiguration();
MongoDBDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}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.
@Inject
MongoDBTemplate template;
...
Bson filter = eq("name", "Poliana");
Stream<Person> stream = template.select(Person.class , filter);
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:
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-oracle-nosql</artifactId>
<version>1.2.0</version>
</dependency>The API offers the OracleNoSQLConfigurations class to programmatically set up credentials. It also supports configuration via the MicroProfile Config specification.
| Property Name | Description |
|---|---|
|
Hostname or IP address of the Oracle NoSQL database server. |
|
Username for Oracle NoSQL database authentication. |
|
Password for Oracle NoSQL database authentication. |
|
Desired throughput of read operations when creating tables with Eclipse JNoSQL. |
|
Desired throughput of write operations when creating tables with Eclipse JNoSQL. |
|
Maximum storage in gigabytes for tables created with Eclipse JNoSQL. |
|
Total waiting time in milliseconds when creating a table. |
|
Time between polling attempts in milliseconds when creating a table. |
|
Tenant ID for Oracle NoSQL database in a Cloud deployment. |
|
Fingerprint for authentication with Oracle NoSQL database in a Cloud deployment. |
|
Private key for authentication with Oracle NoSQL database in a Cloud deployment. |
|
Compartment name in Oracle Cloud Infrastructure. |
|
Namespace name in Oracle NoSQL on-premises. |
|
Specifies the profile name used to load session token in Oracle NoSQL cloud. |
|
Specifies the path of configuration file used to load session token in Oracle NoSQL cloud. |
|
Specifies the deployment type for Oracle NoSQL database. You can choose from the following options: - - - - - - |
Below are examples using Oracle NoSQL’s Document API and Key-Value API with MicroProfile Config.
Document API Example:
jnosql.document.provider=org.eclipse.jnosql.databases.oracle.communication.OracleDocumentConfiguration
jnosql.document.database=library
jnosql.oracle.nosql.host=http://localhost:8080Key-Value API Example:
jnosql.keyvalue.provider=org.eclipse.jnosql.databases.oracle.communication.OracleNoSQLKeyValueConfiguration
jnosql.keyvalue.database=library
jnosql.oracle.nosql.host=http://localhost:8080Although 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<OracleNoSQLDocumentManager> {
@Produces
public OracleNoSQLDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
OracleDocumentConfiguration configuration = new OracleDocumentConfiguration();
OracleDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The OracleNoSQLTemplate interface, an extension of the DocumentTemplate, enables synchronous SQL operations.
@Inject
private OracleNoSQLTemplate template;
...
List<Person> people = template.sql("select * from people where people.content.name =?", "Ada");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:
@Repository
interface PersonRepository extends OracleNoSQLRepository<Person, String> {
@SQL("select * from Person")
List<Person> findAll();
@SQL("select * from Person where name = ?")
List<Person> findByName(@Param("") String name);
}
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-orientdb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the OrientDBDocumentConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host. It can be pointing to remote database (e.g: |
|
The user’s userID. |
|
The user’s password |
|
The storage type com.orientechnologies.orient.core.db.ODatabaseType |
This is an example using OrientDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.orientdb.communication.OrientDBDocumentConfiguration
jnosql.document.database=heroes
jnosql.orientdb.host=remote:localhost:2424
jnosql.orientdb.user=root
jnosql.orientdb.password=rootpwd
jnosql.orientdb.storageType=plocalThe 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<OrientDBDocumentManager> {
@Produces
public OrientDBDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
OrientDBDocumentConfiguration configuration = new OrientDBDocumentConfiguration();
OrientDBDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}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.
@Inject
OrientDBTemplate template;
...
Stream<Person> stream = template.sql("select * from Person where name = ?", "Ada");
template.live("select from Person where name = ?", callBack, "Ada");The OrientDBCrudRepository interface is an extension of the Repository interface that allows execution of a SQL Query via the @SQL annotation.
@Repository
interface PersonRepository extends OrientDBCrudRepository<Person, String> {
@SQL("select * from Person")
List<Person> findAll();
@SQL("select * from Person where name = ?")
List<Person> findByName(String name);
@SQL("select * from Person where age = :age")
List<Person> findByAge(@Param("age") Integer age);
}
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-ravendb</artifactId>
<version>1.2.0</version>
</dependency>This API provides the RavenDBConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
The database host |
This is an example using RavenDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.ravendb.communication.RavenDBDocumentConfiguration
jnosql.document.database=heroes
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-solr</artifactId>
<version>1.2.0</version>
</dependency>This API provides the SolrDocumentConfigurations class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.
| Configuration property | Description |
|---|---|
|
Database’s host. E.g.: jnosql.solr.host=http://localhost:8983/solr/ |
|
The user’s userID. |
|
The user’s password |
|
Define if each operation Apache Solr will commit automatically, true by default. |
This is an example using Solr’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.databases.solr.communication.SolrDocumentConfiguration
jnosql.document.database=heroesThe 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.
@ApplicationScoped
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<SolrDocumentManager> {
@Produces
public SolrDocumentManager get() {
Settings settings = Settings.builder().put("credential", "value").build();
SolrDocumentConfiguration configuration = new SolrDocumentConfiguration();
SolrDocumentManagerFactory factory = configuration.apply(settings);
return factory.apply("database");
}
}The SolrTemplate interface is a specialization of the DocumentTemplate that allows execution of a Solr query.
@Inject
SolrTemplate template;
...
List<Person> people = template.solr("age:@age AND type:@type AND _entity:@entity", params);The SolrRepository interface is an extension of the Repository interface that allows using Solr query annotation that executes Solr query.
@Repository
interface PersonRepository extends SolrRepository<Person, String> {
@Solr("select * from Person")
List<Person> findAll();
@Solr("select * from Person where name = $name")
List<Person> findByName(@Param("name") String name);
}Time Series databases organize observations around timestamps and are optimized for ingestion, retention, and analysis of measurements over time.
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:
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-influxdb</artifactId>
<version>1.2.0</version>
</dependency>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.
| Configuration property | Description |
|---|---|
|
Base URL of the InfluxDB 3 server, such as |
|
Database token used for reads and writes. |
This is an example using InfluxDB’s Time Series API with MicroProfile Config.
jnosql.timeseries.provider=org.eclipse.jnosql.databases.influxdb.communication.InfluxDBTimeSeriesConfiguration
jnosql.timeseries.database=metrics
jnosql.influxdb.url=http://localhost:8181
jnosql.influxdb.token=${INFLUXDB_TOKEN}
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-iotdb</artifactId>
<version>1.2.0</version>
</dependency>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.
| Configuration property | Default | Description |
|---|---|---|
|
|
IoTDB DataNode host. |
|
|
IoTDB native RPC port. |
|
|
IoTDB user. |
|
|
IoTDB password. |
|
|
Maximum native Table Model session-pool size. |
|
|
Query timeout in milliseconds. |
|
|
Enables client redirection for an IoTDB cluster. Container-based tests disable it because the advertised internal address is not reachable through the mapped host port. |
This is an example using Apache IoTDB’s Time Series API with MicroProfile Config.
jnosql.timeseries.provider=org.eclipse.jnosql.databases.iotdb.communication.IoTDBTimeSeriesConfiguration
jnosql.timeseries.database=metrics
jnosql.iotdb.host=localhost
jnosql.iotdb.port=6667
jnosql.iotdb.username=root
jnosql.iotdb.password=root
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-questdb</artifactId>
<version>1.2.0</version>
</dependency>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.
| Configuration property | Description |
|---|---|
|
QuestDB Java client connection string. Use |
This is an example using QuestDB’s Time Series API with MicroProfile Config.
jnosql.timeseries.provider=org.eclipse.jnosql.databases.questdb.communication.QuestDBTimeSeriesConfiguration
jnosql.timeseries.database=qdb
jnosql.questdb.url=ws::addr=localhost:9000;Vector databases store embeddings and retrieve the entries closest to a query vector, and are commonly used for similarity search and semantic retrieval.
Qdrant is an open-source vector database. This driver integrates it with Jakarta NoSQL mapping, Template, the Eclipse JNoSQL VectorTemplate, and Jakarta Data repositories.
This driver provides support for the Vector NoSQL API.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-qdrant</artifactId>
<version>1.1.21-SNAPSHOT</version>
</dependency>Please note that you can establish properties using the MicroProfile Config specification (or system properties). The driver talks to Qdrant over gRPC and exposes the keys through the QdrantConfigurations enum.
| Configuration property | Description |
|---|---|
|
The database name used by the mapping layer. Required. |
|
The configuration class, |
|
The Qdrant host. Default: |
|
The Qdrant gRPC port. Default: |
|
Whether the connection uses TLS. Default: |
|
The API key used to authenticate. |
|
Timeout in milliseconds applied to each Qdrant call. When absent, the client default is used. |
|
The distance metric used when a collection is created (case-insensitive). Required to create collections. |
|
The vector dimension used when a collection is created. When absent, the dimension of the first inserted vector is used. |
This is an example using Qdrant’s Vector API with MicroProfile Config.
jnosql.vector.database=library
jnosql.vector.provider=org.eclipse.jnosql.databases.qdrant.communication.QdrantConfiguration
jnosql.qdrant.host=localhost
jnosql.qdrant.port=6334
jnosql.qdrant.collection.distance=COSINE
jnosql.qdrant.collection.vector.size=3Each entity maps to a Qdrant collection, which is created on the first insert when it does not exist yet.
QdrantDistance lists the supported metrics:
| Value | Useful when |
|---|---|
|
the relative direction/pattern matters more than the magnitude. |
|
the absolute distance between vectors matters. |
|
direction and magnitude both influence the similarity. |
|
differences across dimensions should accumulate independently. |
The distance is part of the collection configuration (jnosql.qdrant.collection.distance). It is not selected per VectorTemplate.search(…) query.
Milvus is an open-source vector database. This driver uses the Milvus V2 Java client and integrates it with Jakarta NoSQL mapping, Template, the Eclipse JNoSQL VectorTemplate, and Jakarta Data repositories.
This driver provides support for the Vector NoSQL API.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-milvus</artifactId>
<version>1.1.21-SNAPSHOT</version>
</dependency>You can establish properties using the MicroProfile Config specification (or system properties). The keys are exposed through the MilvusConfigurations enum.
| Configuration property | Description |
|---|---|
|
The Milvus database used by the mapping layer. It is created when it does not exist. Required. |
|
The configuration class, |
|
The Milvus host. Default: |
|
The Milvus gRPC port. Default: |
|
Whether the connection uses TLS. Default: |
|
The complete endpoint, e.g. |
|
The token ( |
|
Timeout in milliseconds applied to each call. When absent, the client default is used. |
|
The consistency level of collections and queries: |
|
The metric used when a collection is created (case-insensitive). Default: |
|
The vector dimension used when a collection is created. When absent, the dimension of the first inserted vector is used. |
|
The maximum length of text columns created in a collection (1 to 65535). Default: |
jnosql.vector.database=library
jnosql.vector.provider=org.eclipse.jnosql.databases.milvus.communication.MilvusConfiguration
jnosql.milvus.host=localhost
jnosql.milvus.port=19530
jnosql.milvus.collection.metric=COSINE
jnosql.milvus.collection.vector.size=3Each entity maps to a Milvus collection. The collection and its schema (primary key _id, scalar columns, the vector field and an AUTOINDEX index using the configured metric) are created from the first persisted entity. Later entities are validated against that schema: a different vector dimension, id type or column type fails with an IllegalArgumentException instead of silently changing the collection. Attributes that were not present in the first entity are stored in the collection’s dynamic field.
MilvusMetric lists the supported metrics:
| Value | Useful when |
|---|---|
|
the relative direction of the vectors matters more than their magnitude (text embeddings). |
|
the absolute distance between vectors matters. |
|
direction and magnitude both influence the similarity. |
The metric is part of the collection configuration (jnosql.milvus.collection.metric). It is not selected per VectorTemplate.search(…) query. The query threshold follows the metric: it is the exclusive minimum score for COSINE and INNER_PRODUCT, and the exclusive maximum distance for EUCLIDEAN.
Weaviate is an open-source vector database. This driver uses the official Weaviate Java client v6 (io.weaviate:client6, HTTP and gRPC) and integrates it with Jakarta NoSQL mapping, Template, the Eclipse JNoSQL VectorTemplate, and Jakarta Data repositories.
This driver provides support for the Vector NoSQL API.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-weaviate</artifactId>
<version>1.1.21-SNAPSHOT</version>
</dependency>You can establish properties using the MicroProfile Config specification (or system properties). The keys are exposed through the WeaviateConfigurations enum.
| Configuration property | Description |
|---|---|
|
The configuration class, |
|
A label for the mapping layer. Weaviate has no databases; collections are named after the entities. |
|
The Weaviate host. Default: |
|
The HTTP port. Default: |
|
The gRPC port, required by the v6 client. Default: |
|
Whether the connection uses TLS. Default: |
|
The API key used to authenticate. |
|
Timeout in seconds applied to the client. When absent, the client default is used. |
|
The distance used when a collection is created (case-insensitive): |
jnosql.vector.database=library
jnosql.vector.provider=org.eclipse.jnosql.databases.weaviate.communication.WeaviateConfiguration
jnosql.weaviate.host=localhost
jnosql.weaviate.http.port=8080
jnosql.weaviate.grpc.port=50051
jnosql.weaviate.collection.distance=COSINEThe distance is part of the collection configuration, not of the query. The query threshold follows the distance of the collection: for COSINE it is the minimum similarity, for DOT the minimum dot product, for EUCLIDEAN the maximum Euclidean distance, and for MANHATTAN and HAMMING the maximum distance.
-
Sorting,
LIKE,CONTAINS, range conditions on text and conditions on array properties throwUnsupportedOperationException; time to live is not supported. -
The JNoSQL
_idis kept in the_jnosql_idproperty; the Weaviate object UUID is the id when it is a UUID, or a name-based UUID derived from it otherwise. The namesid,_idand_additionalcannot be used as properties. -
A vector is returned only when no columns are projected or the vector column is requested.
-
Collection names must match
[A-Z][_0-9A-Za-z]*after capitalization.
Graph databases represent entities as vertices and their relationships as edges, enabling traversal and relationship-focused queries. Graph support is provided through the Apache TinkerPop integration layer and dedicated provider integrations; Apache TinkerPop is an abstraction and integration framework, not a database.
Jakarta NoSQL does not currently define an API for Graph databases; Eclipse JNoSQL provides a Graph template to explore the specific behavior of this NoSQL type.
Unlike the other NoSQL types, Eclipse JNoSQL does not offer a communication layer for Graph databases. Instead, it integrates with Apache Tinkerpop 3.x.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-tinkerpop</artifactId>
<version>1.2.0</version>
</dependency>Eclipse JNoSQL does not provide Apache Tinkerpop 3 dependency; check if the provider does. Otherwise, do it manually.
<dependency>
<groupId>org.apache.tinkerpop</groupId>
<artifactId>gremlin-core</artifactId>
<version>${tinkerpop.version}</version>
</dependency>
<dependency>
<groupId>org.apache.tinkerpop</groupId>
<artifactId>gremlin-groovy</artifactId>
<version>${tinkerpop.version}</version>
</dependency>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.
jnosql.graph.tinkerpop.provider=<CLASS-DRIVER>
jnosql.provider.host=<HOST>
jnosql.provider.user=<USER>
jnosql.provider.password=<PASSWORD>|
Tip
|
The jnosql.graph.provider property is necessary when you have more than one driver in the classpath. Otherwise, it will take the first one.
|
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.
@Alternative
@Priority(Interceptor.Priority.APPLICATION)
public class ManagerSupplier implements Supplier<Graph> {
@Produces
public Graph get() {
Graph graph = ...; // from a provider
return graph;
}
}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.
@Inject
@Database(value = DatabaseType.GRAPH, provider = "databaseA")
private GraphTemplate templateA;
@Inject
@Database(value = DatabaseType.GRAPH, provider = "databaseB")
private GraphTemplate templateB;
// producers methods
@Produces
@Database(value = DatabaseType.GRAPH, provider = "databaseA")
public Graph getManagerA() {
return manager;
}
@Produces
@Database(value = DatabaseType.GRAPH, provider = "databaseB")
public Graph getManagerB() {
return manager;
}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.
@Inject
TinkerpopTemplate template;
...
Category java = Category.of("Java");
Book effectiveJava = Book.of("Effective Java");
template.insert(java);
template.insert(effectiveJava);
EdgeEntity edge = template.edge(java, "is", software);
Stream<Book> books = template.getTraversalVertex()
.hasLabel("Category")
.has("name", "Java")
.in("is")
.hasLabel("Book")
.getResult();Apache TinkerPop is database agnostic. Thus, you can change the database in your application with no or minimal impact on source code.
ArangoDB also supports graph access through the Apache TinkerPop integration. Its canonical driver installation, configuration, and Document and Key-Value API documentation are in the ArangoDB Document section.
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.
<dependency>
<groupId>org.eclipse.jnosql.databases</groupId>
<artifactId>jnosql-neo4j</artifactId>
<version>1.2.0</version>
</dependency>This API provides the Neo4JDatabaseConfigurations class to programmatically establish the credentials. You can configure Neo4J properties using the MicroProfile Config specification.
| Configuration Property | Description |
|---|---|
|
The connection URI for the Neo4J database. Example: |
|
The username for authentication. |
|
The password for authentication. |
|
The target database name. |
The Neo4JTemplate interface extends GraphTemplate and allows for dynamic Cypher execution.
@Inject
private Neo4JTemplate template;
List<Person> people = template.cypherQuery("MATCH (p:Person) WHERE p.name = $name RETURN p", params);
var edge = template.edge(otavio, "FRIENDS_WITH", ada);The Neo4JRepository interface extends the NoSQLRepository interface and enables query execution using the @Cypher annotation.
@Repository
interface PersonRepository extends Neo4JRepository<Person, String> {
@Cypher("MATCH (p:Person) RETURN p")
List<Person> findAll();
@Cypher("MATCH (p:Person) WHERE p.name = $name RETURN p")
List<Person> findByName(@Param("name") String name);
}Having trouble with Eclipse JNoSQL databases? We’d love to help!
Please report any bugs, concerns or questions with Eclipse JNoSQL databases to https://github.com/eclipse/jnosql. Follow the instructions in the templates and remember to mention that the issue refers to JNoSQL databases.
We are very happy you are interested in helping us and there are plenty ways you can do so.
-
Open an Issue: Recommend improvements, changes and report bugs. Please, mention that the issue refers to the JNoSQL databases project.
-
Open a Pull Request: If you feel like you can even make changes to our source code and suggest them, just check out our contributing guide to learn about the development process, how to suggest bugfixes and improvements.
The integration tests on databases primarily integrate with the Testcontainers, requiring a more powerful computer.
Those tests are disabled by default; thus, if you want to run only the integration tests:
mvn test -Djnosql.test.integration=trueTo create integration tests on this project, we’re using EnabledIfSystemProperty from JUnit Jupiter, where the system property is: jnosql.test.integration, and we expected true to execute.
We, the IntegrationTest structure class, hold this content, considering using it on the new integration tests.
import static org.eclipse.jnosql.communication.driver.IntegrationTest.NAMED;
import static org.eclipse.jnosql.communication.driver.IntegrationTest.MATCHES;
@EnabledIfSystemProperty(named = NAMED, matches = MATCHES)
class IntegrationSampleTest {
}To perform the Jakarta NoSQL TCK you should activate the tck profile. This profile will download the TCK and run it.
mvn test -PtckTo run the Jakarta NoSQL TCK only in a specific module, you can use the -pl option, for example:
mvn test -Ptck -pl jnosql-mongodb|
Important
|
By default, activating the mvn test -Ptck -DskipTests |
The JNoSQL Database API implementations that support Jakarta NoSQL TCK execution already:
See Contributing a New Eclipse JNoSQL Database Driver for the driver requirements, package conventions, configuration classes, testing, manager suppliers, documentation, TCK guidance, and graph-provider notes.