Oracle NoSQL Database: A Comprehensive Guide for Developers

About Oracle NoSQL Database

Oracle NoSQL Database is a robust solution offering a blend of SQL-like interfaces for working with NoSQL data models. This database system enables developers to handle various data types without impedance mismatch issues, including flat relational data, hierarchical typed data, and schema-less JSON data. Impedance mismatch occurs when differences between the database and the programming language models create data handling challenges. Still, Oracle NoSQL eliminates this by providing a seamless experience across multiple data structures.

Oracle NoSQL Database Cloud Service simplifies the development process, allowing developers to focus on building applications rather than managing infrastructure. It supports document, fixed schema, and key-value database models, providing low-latency response times, active-active regional replication, and elastic scalability. The service is designed to scale effortlessly with dynamic workloads, offering features such as:

• ACID transactions to ensure data integrity
• Serverless scaling for flexible capacity adjustments
• Security with comprehensive measures to protect data
• Pay-per-use pricing that supports both on-demand and provisioned capacity modes

This cloud service is fully compatible with the on-premises Oracle NoSQL Database, allowing developers to switch between cloud and local environments.

One of the standout features of Oracle NoSQL is its compatibility with SQL, allowing developers to use a familiar query language in a NoSQL context. It is a significant advantage, reducing the learning curve typically associated with NoSQL databases, which often require knowledge of specialized query languages. With Oracle NoSQL, developers can enjoy the flexibility of a NoSQL database without giving up the familiar, powerful querying capabilities of SQL.

Oracle NoSQL Database Cloud Service takes care of backend management, making it ideal for developers who need a solution that scales effortlessly while minimizing operational overhead. Key benefits include:

• Focus on application development: Developers can concentrate on building features without worrying about managing servers, storage, or software updates.
• Elastic scaling: The database dynamically scales to accommodate workload changes, ensuring that performance remains consistent as demand fluctuates.
• Provisioned resources: Users define the database’s throughput and storage requirements upfront, with the system automatically adjusting resources to meet these needs.

The NoSQL Database uses a tabular data model, allowing developers to structure data as required while retaining familiar constructs like rows and unique keys. This flexibility extends to supporting both single-row transactions and non-transactional scans, making it a versatile tool for a wide range of applications.

Oracle offers the NoSQL Database in three editions:

1. Community Edition (CE): Distributed under the Apache License 2.0, this edition is ideal for developers seeking an open-source, community-supported solution.
2. Enterprise Edition (EE): This version comes with commercial support from Oracle and is licensed under the Oracle Commercial License.
3. Basic Edition: A lighter, simpler version for developers looking for core NoSQL capabilities without enterprise-level features.

Developer Tools and Ecosystem

Oracle provides a variety of tools and SDKs to enhance the developer experience, including:

• JetBrains Plugin: A connector that allows developers to interact with Oracle NoSQL directly from JetBrains IDEs. You can explore the plugin here: Oracle NoSQL Database Connector.
• SDKs in Multiple Languages: Oracle offers Java, Python, Node.js, and .NET SDKs. You can explore the available SDKs on Oracle’s GitHub page.
• Java SE Support: Developers working in the Java ecosystem can benefit from Spring and Jakarta EE framework support, including integration with Jakarta NoSQL and Jakarta Data specifications via Eclipse JNoSQL.

Challenges

While Oracle NoSQL Database offers the significant advantage of SQL compatibility, it's important to note that it still operates within a NoSQL paradigm. It means that even though developers can use SQL-like queries, a deep understanding of NoSQL data structures and principles is still necessary to take full advantage of the system. Concepts like flexible schemas, document storage, and key-value operations require a shift in how data is modeled and queried compared to traditional relational databases. Developers from purely SQL environments will need to learn these NoSQL concepts to optimize their applications and use the flexibility offered by Oracle NoSQL.

Another consideration is the growing ecosystem surrounding Oracle NoSQL. While the platform rapidly expands and integrates into popular Java frameworks like Jakarta EE, Spring, and other developer tools, it is still relatively new compared to some established NoSQL databases. As a result, the availability of third-party tools, plugins, and community-driven resources is still catching up. Although Oracle's investment in the platform ensures ongoing solid support and growth, it may take time before the ecosystem reaches the maturity level of older NoSQL databases. Developers should be aware that, in some cases, additional custom development may be necessary to fill the gaps in tooling or integrations that are more readily available for other NoSQL systems.

Getting Started With Oracle NoSQL

To start working with Oracle NoSQL, developers can either use the cloud solution provided through Oracle Cloud or run the database locally via Docker. For local execution, the following Docker command can get you started:

docker run -d --name oracle-instance -p 8080:8080 ghcr.io/oracle/nosql:latest-ce

This command sets up an Oracle NoSQL instance on your local machine, making testing and developing applications easy without setting up complex infrastructure.

Oracle NoSQL integrates seamlessly with Jakarta Data and the Eclipse JNoSQL ecosystem. Below is an example of a Java application that demonstrates how to interact with Oracle NoSQL using a simple Beer entity:

@Entity
public class Beer {

    @Id
    private String id;

    @Column
    private String style;

    @Column
    private String hop;

    @Column
    private String malt;

    @Column
    private List<String> comments;

    @Column
    private List<Crew> crew;

    @Column
    private Map<String, Object> data;
}

The repository interface leverages Oracle NoSQL’s specialization to provide a familiar SQL-like querying experience:

@Repository
public interface BeerRepository extends OracleNoSQLRepository<Beer, String> {

    Set<Beer> findByStyle(String style);

    @Query("select * from Beer")
    Set<Beer> query();

    @Find
    @OrderBy("hop")
    CursoredPage<Beer> style(@By("style") String style, PageRequest pageRequest);

    @Query("From Beer where style = ?1")
    List<Beer> jpql(String style);
}

Running this application allows developers to interact with Oracle NoSQL, querying and persisting data using familiar Java constructs.

Conclusion

Oracle NoSQL Database offers a flexible, scalable solution for developers building modern applications that require high availability, low latency, and the ability to work with diverse data models. With features like SQL compatibility, managed cloud services, and extensive developer tools, Oracle NoSQL provides a comprehensive environment for both beginners and experienced developers alike. Whether deploying in the cloud or locally, Oracle NoSQL simplifies the development process, allowing developers to focus on building features and delivering value faster.

For more detailed guidance on working with Oracle NoSQL, visit Oracle’s GitHub page.