The Eclipse JNoSQL Communications API is a collection of implementations from the Jakarta NoSQL specification.
In the NoSQL communication layer, you can make an analogy with JDBC.
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>arangodb-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.ArangoDBConfigurations
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.communication.arangodb.document.ArangoDBDocumentConfiguration
jnosql.document.database=heroes
This is an example using ArangoDB’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.database=heroes
jnosql.keyvalue.provider=org.eclipse.jnosql.communication.arangodb.keyvalue.ArangoDBKeyValueConfiguration
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.
You can use either the Maven or Gradle dependencies:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>cassandra-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.CassandraConfigurations
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.communication.cassandra.column.CassandraConfiguration
jnosql.column.database=developers
jnosql.cassandra.query-1=<CQL-QUERY>
jnosql.cassandra.query.2=<CQL-QUERY-2>
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>couchbase-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.CouchbaseConfigurations
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.communication.couchbase.document.CouchbaseDocumentConfiguration
jnosql.document.database=heroes
jnosql.couchbase.host.1=localhost
jnosql.couchbase.user=root
jnosql.couchbase.password=123456
This is an example using Couchbase’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.database=heroes
jnosql.keyvalue.provider=org.eclipse.jnosql.communication.couchbase.keyvalue.CouchbaseKeyValueConfiguration
jnosql.couchbase.host.1=localhost
jnosql.couchbase.user=root
jnosql.couchbase.password=123456
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>couchdb-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.CouchDBConfigurations
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 user’s userID. |
|
The user’s password |
|
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.communication.couchdb.document.CouchDBDocumentConfiguration
jnosql.document.database=heroes
jnosql.couchdb.host=localhost
jnosql.couchdb.username=admin
jnosql.couchdb.password=password
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>elasticsearch-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.ElasticsearchConfigurations
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.communication.elasticsearch.document.ElasticsearchDocumentConfiguration
jnosql.document.database=developers
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>hazelcast-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.HazelcastConfigurations
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.communication.hazelcast.keyvalue.HazelcastKeyValueConfiguration
jnosql.keyvalue.database=heroes
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>hbase-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.HbaseConfigurations
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.communication.hbase.column.HBaseColumnConfiguration
jnosql.column.database=heroes
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>infinispan-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.InfinispanConfigurations
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.communication.infinispan.keyvalue.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.
You can use either the Maven or Gradle dependencies:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>memcached-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.MemcachedConfigurations
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. |
`jnosql.memcached.timeout |
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 Document API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.communication.memcached.keyvalue.MemcachedKeyValueConfiguration
jnosql.keyvalue.database=heroes
jnosql.memcached.host.1=localhost:11211
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>mongodb-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.MongoDBDocumentConfigurations
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 |
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.communication.mongodb.document.MongoDBDocumentConfiguration
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>orientdb-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.OrientDBDocumentConfigurations
Configuration property | Description |
---|---|
|
The database host |
|
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.communication.orientdb.document.OrientDBDocumentConfiguration
jnosql.document.database=heroes
jnosql.orientdb.host=localhost:27017
jnosql.orientdb.user=root
jnosql.orientdb.password=rootpwd
jnosql.orientdb.storageType=plocal
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>ravendb-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.RavenDBConfigurations
Configuration property | Description |
---|---|
|
The database host |
This is an example using RavenDB’s Document API with MicroProfile Config.
jnosql.document.provider=org.eclipse.jnosql.communication.ravendb.document.RavenDBDocumentConfiguration
jnosql.document.database=heroes
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>redis-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.RedisConfigurations
Configuration property | Description |
---|---|
|
The database host |
|
The database port |
|
The redis timeout, the default value 2000 on milliseconds |
|
The user’s password |
|
The redis database number, the default value is 0 |
|
The client’s name |
|
The value for the maxTotal configuration attribute for pools created with this configuration instance, the default value 1000. |
|
The value for the maxIdle configuration attribute for pools created with this configuration instance, the default value 10. |
|
The value for the minIdle configuration attribute for pools created with this configuration instance, the default value 1. |
|
The value for the maxWait configuration attribute for pools created with this configuration instance, the default value 3000. |
This is an example using Redis’s Key-Value API with MicroProfile Config.
jnosql.keyvalue.provider=org.eclipse.jnosql.communication.redis.keyvalue.RedisConfiguration
jnosql.keyvalue.database=heroes
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:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>redis-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.RiakConfigurations
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.communication.riak.keyvalue.RiakKeyValueConfiguration
jnosql.keyvalue.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.
You can use either the Maven or Gradle dependencies:
<dependency>
<groupId>org.eclipse.jnosql.communication</groupId>
<artifactId>solr-driver</artifactId>
<version>1.0.0-b4</version>
</dependency>
This API provides the
class to programmatically establish the credentials.
Please note that you can establish properties using the MicroProfile Config specification.SolrDocumentConfigurations
Configuration property | Description |
---|---|
|
Database’s host. It is a prefix to enumerate hosts. E.g.: jnosql.solr.host.1=HOST |
|
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.communication.solr.document.SolrDocumentConfiguration
jnosql.document.database=heroes
As an open-source project, you’re free to create any driver, and you’re welcome to join and participate in the process. To add a new driver, we have a few requirements:
-
Run Java 11 and Java 17
-
Include the documentation driver in the README file.
-
Cover the driver with tests and preferences with TestContainer.
-
Please pay attention to the documentation. This includes JavaDoc
-
Include a class to represent and contain the properties.
-
A nomenclature is the <DATABASE>Configurations, e.g., CassandraConfigurations, MongoDBConfigurations
-
Eclipse JNoSQL uses Apache Tinkerpop for Graph API. Using this API gives support to over twenty fives databases.