Databases on foojay.io - Friends Of OpenJDK

One Database, Two Models: Building AI-Friendly Java Applications with MySQL JSON Duality Views

Sat, 26 Sep 2026 00:00:00 +0000

MySQL can now hand your application a complete JSON document, such as an order with its customer and line items, while the data stays in normal relational tables. You can even send the document back and MySQL updates the right rows. I built a small Java app to see how far that goes. Reading got much simpler. Writing works too, but it comes with a few sharp edges you should know about before you use it.

How I Built an AI Assistant for My Career with Java, Spring AI, and MongoDB

Tue, 15 Sep 2026 11:51:17 +0000

The best way to learn a technology is by putting it into practice in a real system.

A few months ago, I decided to build a virtual assistant that could answer questions about my career, help people learn more about my articles, videos, talks, and projects, and even schedule a call on my calendar.

At first, the idea was simple: give the assistant access to my content and let people ask questions about it. But as the project evolved, I realized that not every question should be handled in the same way. Some questions can be answered with a direct query to the database, while others benefit from semantic search. In other cases, the assistant may need to use a tool or execute multiple steps before reaching an answer.

Aggregation Optimization in MongoDB: Sorting With Indexes (Part 5)

Tue, 01 Sep 2026 14:07:36 +0000

And why MongoDB might be a better relational database than you ever realized.

Design reviewsare one-on-one meetings where MongoDB experts deliver advice on data modeling best practices and application design challenges. In this series, we are going to explore common real-life scenarios where design reviews helped developers achieve meaningful success with MongoDB.

In this series, we’ve described our steps to improve the performance of a slow running MongoDB aggregation pipeline. The pipeline was part of a fictional video streaming service application, mapping user profiles to the devices those users were using to access the service, and was based on a real use case I’d encountered during a recent design review.

NetBeans DataWrangler: Query, Convert, and Edit Data Analytics Files

Sun, 30 Aug 2026 10:25:43 +0000

Apache NetBeans DataWrangler brings the file formats of data analytics into Apache NetBeans 31: CSV, Apache Parquet, JSON and Excel, the formats exchanged with pandas, Spark, R, dbt, Power BI and Excel itself.

You can query, convert, inspect, edit and analyze them without leaving the IDE. They open as documents with their own views and you can query them with SQL, join, aggregate and pivot them, convert them between formats, load them into tables and export the results. The SQL editor is enhanced with code completion, documentation, error checking and quick fixes for analytical SQL.

DuckDB in Spring Batch: Replace In-Memory Java Loops with One SQL Statement

Tue, 11 Aug 2026 13:34:43 +0000

Spring Batch jobs usually follow the same pattern: an ItemReader streams rows, an ItemProcessor transforms each one, and an ItemWriter writes them out, chunk by chunk. A chunk-oriented step wires those three pieces together:

new StepBuilder("transform", jobRepository)
 .<Order, Summary>chunk(1_000, transactionManager)
 .reader(reader) // stream rows
 .processor(processor) // transform each row
 .writer(writer) // write the chunk
 .build();

The chunk-oriented processing model (Spring Batch reference).

That pattern works well for moving records between systems.

Embedding DuckDB in a Maven App (and Using It for Things That Aren't Databases)

Thu, 06 Aug 2026 08:46:28 +0000

DuckDB is described as “SQLite for analytics,” which is true: it’s an in-process database engine that runs inside your application, with no server to install or manage. What’s less obvious from that description is that you can get value out of it without ever creating a database at all. Because it can query CSV, JSON, and Parquet files directly — local or over HTTP — it works perfectly well as an embedded data-crunching library that happens to speak SQL.

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

Aggregation Optimization in MongoDB: Unnecessary Unwinds (Part 2)

Thu, 25 Jun 2026 10:01:00 +0000

And why MongoDB might be a better relational database than you ever realized.

This article was written by Graeme Robinson. Find him on LinkedIn.

In Part 1 of this series, we described a use case based on a recent design review I conducted with a team at a MongoDB customer. The team in question was new to MongoDB, and the approach they had taken to both modeling their data and then subsequently querying it was very “RDBMS-like.” As a result, query performance was significantly slower than their SLA called for.

BoxLang 1.14.0: Query Transformers - Take Full Control of Your Query Results

Wed, 24 Jun 2026 10:46:13 +0000

BoxLang 1.14.0 ships a lot of exciting features – Dynamic Sets, Ranges, Inner Classes, JSONPath navigation – but one quietly powerful addition will change the way you think about every database call in your application: Query Transformers, and this is just the start, we have plans for a whole lot more cool query features.

If you have ever executed a query and then immediately written a loop to reshape the result into what you actually needed, this feature is for you.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 2: Conversational Memory

Wed, 10 Jun 2026 19:23:46 +0000

This is the second article in a three-part series. Part 1 covered the RAG foundation — loading runbooks into a vector store and wiring them to a language model. Part 3 will introduce stateful workflow checkpointing with pause and resume.

The Problem with Stateless Chat

In the first part of the series, we successfully created a chat interface where an operator can ask questions and receive answers based on the actual content of the runbooks they have uploaded and embedded in the system. For example, they can ask in the chat, “What should I check when my server’s CPU usage exceeds 80%?” and the assistant retrieves the relevant sections from the various runbooks and assembles a coherent and concrete response.

Exploring MongoT

Thu, 28 May 2026 21:02:49 +0000

Let’s explore this fascinating and awesome Java project from MongoDB - MongoT!

You can check out the source code here:

git clone https://github.com/mongodb/mongot

MongoT is a wrapper around the amazing Java search engine: Lucene.

Lucene is a powerful search toolkit built around an inverted token index structure that enables advanced text search capabilities, including ranked results, autocomplete, synonyms, fuzzy matching, highlighting, and faceting — all with high performance regardless of dataset size. Unlike MongoDB’s native query engine, it can efficiently search across multiple indexes simultaneously by intersecting lists of ordinal document IDs in parallel, using optimization techniques like skip-lists, ordinal compression, and document frequency ordering. It also supports indexing of various field types (integers, dates, keywords, etc.) and has expanded into vector search, enabling semantic similarity search by meaning rather than exact text matching.

Implementing Soft Deletes in Java

Thu, 21 May 2026 10:09:00 +0000

What are soft deletes?

Usually, when deleting documents from a database, the entry is permanently gone and can not be recovered or accessed again.

Sometimes data needs to be made unavailable for regular access without actually being removed from a database. A common example is a user deleting their account on a platform, but retention policies require you to keep all data related to that user for a certain period of time. At the same time, no data regarding that user is accessible on the platform. A soft delete is a treatment for a piece of data that ensures it is ignored by your application while actually still being stored in the database.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 1: RAG Foundation

Thu, 07 May 2026 19:22:11 +0000

This is the first article in a three-part series. Part 2 covers short-term and long-term memory; Part 3 introduces stateful workflow checkpointing with pause/resume.

The problem

It’s 2 a.m. Suddenly, an alert pops up indicating abnormal CPU usage on the payment services. The on-call engineer opens their laptop, logs into the monitoring dashboards, and begins the hunt. One by one, he searches the runbooks on Confluence, checks the Slack chats, and opens the GitHub wikis and documents shared during the design phase. By the time he finds any useful information, ten minutes have already passed.

UCanAccess: The Modern Pure-Java Bridge to Microsoft Access

Wed, 06 May 2026 08:44:00 +0000

Microsoft Access databases are everywhere. Decades of .mdb and .accdb files silently power spreadsheets, small business applications, and legacy data stores across organizations of all sizes. Yet for Java developers, connecting to these files has historically meant wrestling with native Windows libraries, ODBC bridges, and platform-specific hacks.

UCanAccess puts an end to that. It is an open-source, pure-Java JDBC driver that lets you read and write Microsoft Access databases (.mdb and .accdb) just like any other SQL database — no native drivers, no Windows dependency, no friction.

When Should You Use a Cache With MongoDB?

Tue, 05 May 2026 15:23:30 +0000

From time to time, I’ll run a design review for an application being migrated from a relational database onto MongoDB, where the customer shares an architectural diagram showing a caching layer (typically Redis) sitting between the app server and MongoDB.

I like to keep the architecture as simple as possible—after all, each layer brings its own complexity and management costs—so I’ll ask why the caching layer is there. Of course, the answer is always that it’s there to speed up data access. This reveals a misunderstanding of both the reason why caching layers were created and what MongoDB provides.

Large-Scale ETL Pipeline Architecture

Fri, 01 May 2026 19:23:04 +0000

Modern data-driven systems. ETL pipelines are no longer simply scheduled background processes that run silently overnight, one after another. They are the backbone of real-time analytics, powering operational dashboards and recommendation systems. They enable machine learning workflows.

This evolution, while creating enormous benefits, has—with the increase in data volume and the decrease in latency tolerance—called into question the traditional sequential ETL approach. A bottleneck for the speed is now required.

Building a Personalized Content Delivery System

Thu, 23 Apr 2026 15:10:45 +0000

Recommendation engines have a reputation for requiring specialized ML infrastructure: matrix factorization pipelines, training jobs, and model serving layers. That is one way to do it, but not the only way. If your data already lives in MongoDB and your application runs on Spring Boot, you can build a practical recommendation system using tools you already have. MongoDB aggregation pipelines handle the scoring math server-side, and Atlas Vector Search adds semantic matching without a separate vector database.

Distributed Cache Invalidation Patterns

Tue, 21 Apr 2026 13:52:03 +0000

Caching is one of the most powerful tools developers have at their disposal for optimizing application performance. Caching systems can significantly reduce latency and reduce the load on databases or external systems by storing frequently accessed data as close as possible to the application layer. The result? Improved responsiveness and overall system usability.

In small monolithic applications, cache management is usually very simple. A service retrieves data from a database, stores it in memory, and fulfills subsequent requests by retrieving the data directly from the cache. When the data changes, the cache key is invalidated or updated.

CQRS in Java: Separating Reads and Writes Cleanly

Thu, 16 Apr 2026 20:25:28 +0000

What you’ll learn

How the MongoDB Spring repository can be used to abstract MongoDB operations
Separating Reads and Writes in your application
How separating these can make schema design changes easier
Why you should avoid save() and saveAll() functions in Spring

The Command Query Responsibility Segregation (CQRS) pattern is a design method that segregates data access into separate services for reading and writing data. This allows a higher level of maintainability in your applications, especially if the schema or requirements change frequently. This pattern was originally developed with separate read and write sources in mind. However, implementing CQRS for a single data source is an effective way to abstract data from the application and make maintenance easier in the future. In this blog, we will use Spring Boot with MongoDB in order to create a CQRS pattern-based application.

Building a Kotlin App with Spring Boot and MongoDB Search

Thu, 09 Apr 2026 15:21:05 +0000

One of my favorite activities is traveling and exploring the world. You know that feeling of discovering a new place and thinking, “How have I not been here before?” It’s with that sensation that I’m always motivated to seek out new places to discover. Often, when searching for a place to stay, we’re not entirely sure what we’re looking for or what experiences we’d like to have. For example, we might want to rent a room in a city with a view of a castle. Finding something like that can seem difficult, right? However, there is a way to search for information accurately using MongoDB Search.

Manage HTTP Sessions with Spring Session MongoDB

Tue, 07 Apr 2026 15:19:10 +0000

Spring Session MongoDB is a library that enables Spring applications to store and manage HTTP session data in MongoDB rather than relying on container-specific session storage. In traditional deployments, session state is often tied to a single application instance, which makes scaling across multiple servers difficult. By integrating Spring Session with MongoDB, session data can be persisted beyond application restarts and shared across instances in a cluster, enabling scalable distributed applications with minimal configuration.

Java Faceted Full-Text Search API Using MongoDB Atlas Search

Thu, 02 Apr 2026 16:27:30 +0000

This is going to be a fun, practical tutorial demonstrating how to build a Java faceted full-text search API (like the ones powering sites like Amazon)!

We’ll use an interesting dataset which showcases how you can effectively pair machine learning/AI-generated data with more traditional search to produce fast, cheap, repeatable, and intuitive search engines.

TL;DR: If you (like me!) are less about words and more about code, you can jump straight in. Check it out and run it locally like this:

MongoDB Search Score Breakdown

Tue, 31 Mar 2026 15:05:08 +0000

Full-text search powers all of our digital lives — googling for this and that; asking Siri where to find a tasty, nearby dinner; shopping at Amazon; and so on. We receive relevant results, often even in spite of our typos, voice transcription mistakes, or vaguely formed queries. We have grown accustomed to expecting the best results for our searching intentions, right there, at the top.

But now it’s your turn, dear developer, to build the same satisfying user experience into your Atlas-powered application.

Modeling One-to-Many Relationships in Java with MongoDB

Thu, 26 Mar 2026 15:50:30 +0000

In a relational database, modeling a one-to-many relationship is straightforward: you create two tables and connect them with a foreign key. When you need the data together, you write a JOIN. In MongoDB, you have a choice, and that choice has a direct impact on your application’s performance, scalability, and maintainability.

Consider a common scenario: a BlogPost that has many Comment objects. In Java, this is a natural List<Comment> field on the post. But when it comes time to persist that relationship in MongoDB, you need to decide how to store it. Should the comments live inside the blog post document? Or should they sit in their own collection, connected by references?

Clean Architecture with Spring Boot and MongoDB

Tue, 24 Mar 2026 16:43:14 +0000

Most Spring Boot tutorials tightly wire everything together. Controllers call services, services call repositories, and MongoDB annotations like @Document and @Field sit right next to your business logic. It works until you need to swap the database, test logic in isolation, or reuse domain rules in a different context.

Clean Architecture enforces one rule: source code dependencies always point inward. Your business logic never imports Spring or MongoDB classes. The database becomes a pluggable detail at the outermost layer, something you can replace without rewriting core application code.

Building Reactive Data Streams with Project Reactor

Thu, 19 Mar 2026 15:13:31 +0000

Creating Non-Blocking Streaming Endpoints for High-Throughput Applications

There are problems that only occur in production. Or rather, we only notice them in production.

We have created an application that exposes clean APIs, according to all standards. You have modeled the domain elegantly and efficiently: all load tests show reassuring data. CPU usage is reasonable, to say the least. However, there is a problem: when traffic exceeds a threshold, the system slows down. Response time latency becomes inconsistent; threads stack up on top of each other. Response times increase unpredictably, and application customers begin to complain about this situation.

Language Learning Flashcard System - Part 1

Tue, 17 Mar 2026 16:39:58 +0000

My native language is Spanish. I’ve been learning (and butchering) English my whole life. But at some point, I felt confident with English and wanted to learn Japanese. Big mistake. This is a totally different beast: three writing systems (Hiragana ひらがな, Katakana カタカナ and Kanji 漢字), a completely different grammar, no relation whatsoever with European languages… I needed help. And tools to learn. And one of them is Space Repetition System based apps.

Atlas Online Archive: Efficiently Manage the Data Lifecycle

Thu, 12 Mar 2026 14:55:00 +0000

Problem statement

In the production environment, in a MongoDB Atlas database, a collection contains massive amounts of data stored, including aged and current data. However, aged data is not frequently accessed through applications, and the data piles up daily in the collection, leading to performance degradation and cost consumption. This results in needing to upgrade the cluster tier size to maintain sufficient resources according to workload, as it would be difficult to continue with the existing tier size.

Role-Based Access Control in Java Applications

Thu, 05 Mar 2026 20:31:49 +0000

We often work with Java applications where security begins and ends with authentication. The JWT token is validated, Spring Security is integrated, and an identity provider is added, thinking that this type of configuration is sufficiently secure.

The real problem is that authentication only answers one question: who are you? In real applications, we also have to answer another question, which is often more complex and more dangerous to get wrong: what are you allowed to do?

Data Enrichment in MongoDB

Tue, 03 Mar 2026 16:10:36 +0000

In a recent design review, a customer was enriching new data as it came in. As the enrichment process was fairly complex, they ran into some issues with concurrency. To solve this, they decided that data should go into a staging collection rather than the main collection that held the data. This did nothing to help with concurrency issues and actually created more work on the database side of things when enrichment was complete.