Hazelcast JSON Predicates with Example: Querying JSON Data in Hazelcast

Overview

In distributed systems and modern applications, JSON has become the go-to format for data interchange due to its flexibility and simplicity. Hazelcast, a leading in-memory data grid, supports handling JSON data through the HazelcastJsonValue class. When working with large-scale JSON data stored in Hazelcast’s distributed IMap, you often need to perform queries to filter and retrieve data based on specific criteria. This is where Hazelcast Json Predicates with Example come into play.

In this article, we’ll provide a detailed overview of how to use HazelcastJsonValue with predicates to query JSON data, with real-world examples to demonstrate the power and flexibility of this feature.

Before exploring Hazelcast JSON Predicates with Example, also visit:

• Understanding Hazelcast Predicate Functions: A Comprehensive Guide
• Using SQL Predicates in Hazelcast: An In-depth Example

What is HazelcastJsonValue?

HazelcastJsonValue is a class in Hazelcast designed to handle JSON-formatted strings. It allows developers to store and query JSON objects in a Hazelcast IMap just like any other data type. Since JSON is often hierarchical, HazelcastJsonValue can store nested data structures, which can then be queried using Hazelcast’s powerful predicate capabilities.

Setting Up Your Environment

Before diving into the example, make sure you have Hazelcast set up in your project. You can include the Hazelcast library in your Maven pom.xml:

<dependency>
    <groupId>com.hazelcast</groupId>
    <artifactId>hazelcast</artifactId>
    <version>5.5.0</version> <!-- Replace with the latest version -->
</dependency>

Example Scenario

In Hazelcast JSON Predicates with Example, imagine we’re building an application that manages user information stored as JSON objects. Each user has attributes like name and status. Our goal is to filter out filter the employee using different filter criteria.

Here’s how to store a JSON object in Hazelcast using HazelcastJsonValue:

// Create Hazelcast instance
HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();

// Get a map to store HazelcastJsonValue
IMap<String, HazelcastJsonValue> employeeMap = hazelcastInstance.getMap("employeeMap");

// Add some example JSON values
employeeMap.put("101", new HazelcastJsonValue("{\"empId\":\"101\", \"name\":\"Messi\", \"age\":33, \"salary\":40000, \"address\":{\"country\":\"Argentina\", \"zip\":\"6544321\"}}"));
employeeMap.put("102", new HazelcastJsonValue("{\"empId\":\"102\", \"name\":\"Rohit\", \"age\":37, \"salary\":10000, \"address\":{\"country\":\"India\", \"zip\":\"567971\"}}"));
employeeMap.put("103", new HazelcastJsonValue("{\"empId\":\"103\", \"name\":\"Ronaldo\", \"age\":39, \"salary\":20000, \"address\":{\"country\":\"Portugal\", \"zip\":\"543212\"}}"));

In this Hazelcast JSON Predicates with Example, we’re storing a JSON object that represents a person with nested fields such as name, age, and address. Now, let’s explore how to query this data using predicates.

Querying HazelcastJsonValue with Predicates

HazelcastJsonValue supports a wide range of predicates for querying fields within a JSON object. These predicates allow you to filter data based on conditions such as equality, comparison, and pattern matching, even across nested fields.

Let’s break down some of the most commonly used predicates and how to apply them to JSON data stored in Hazelcast.

Basic Predicate Example: Equality Check

To query a JSON field in HazelcastJsonValue, you can use Hazelcast’s Predicates.sql() or Predicates.equals() method, which allows for SQL-like syntax. For example, to retrieve all entries where the name field is Ronaldo:

// Query the map using the predicate
Collection<HazelcastJsonValue> results = players.values(Predicates.equal("name", "Ronaldo"));

//OR also it can be written like this
Collection<HazelcastJsonValue> results = players.values(Predicates.sql("name = 'Ronaldo'"));

This will return all JSON objects from the players Map where the name is Ronaldo.

Example: Querying Nested Fields

In Hazelcast JSON Predicates with Example, one of the key advantages of HazelcastJsonValue is its ability to query nested fields. JSON objects often contain nested structures, and Hazelcast allows you to access these fields using dot notation.

For Hazelcast JSON Predicates with Example, let’s say you want to retrieve all entries where the city field inside the nested address object is London:

Collection<HazelcastJsonValue> results = players.values(Predicates.equal("address.country", "Argentina"));

//OR also it can be written like this
Collection<HazelcastJsonValue> resultd = players.values(Predicates.sql("address.country = 'Argentina'"));

This query will return all entries where the country within the address is Argentina.

Example: Range Queries with JSON Predicates

Hazelcast supports range queries, allowing you to filter results based on numeric values. To query all JSON objects where the age is greater than 25:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("age > 25"));

Similarly, you can use the BETWEEN operator to define a range:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("age BETWEEN 20 AND 30"));

This will fetch all entries where the age field falls between 20 and 30.

Combining Multiple Predicates

Hazelcast allows you to combine multiple predicates using logical operators like AND, OR, and NOT. This enables more complex queries when filtering JSON data.

For instance, if you want to query all entries where the name is Messi and the country is Argentina:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("name = 'Messi' AND address.country= 'Argentina'"));

This query ensures both conditions are satisfied.

Pattern Matching with LIKE

Hazelcast provides support for pattern matching with the LIKE operator, which is useful when you need to perform searches based on partial matches or patterns. For example, to query all entries where the name starts with the letter Ro:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("name LIKE 'Ro%'"));

This will return all entries where the name begins with Ro.

Using IN Predicate

The IN predicate is helpful when you need to match a field against a list of values. For instance, to query all entries where the age is either 33, 37, or 39:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("age IN (33, 37, 39)"));

This query will return all JSON objects where the age field matches one of the specified values.

Handling NULL Values

Hazelcast also supports NULL handling in JSON queries. If you want to find all entries where a field is NULL, you can use the IS NULL predicate:

Collection<HazelcastJsonValue> results = players.values(Predicates.sql("address.zip IS NULL"));

This query retrieves all entries where the zip field in the nested address object is NULL.

Indexing for Better Performance

When dealing with large amounts of JSON data, performance can become a concern. Hazelcast provides indexing capabilities to enhance query performance by allowing you to create indexes on frequently queried fields.

For instance, if you frequently query the age field, you can create a sorted index:

players.addIndex(IndexType.SORTED, "age");

By adding an index, Hazelcast optimizes query performance by reducing the time needed to search through the data.

Combining HazelcastJsonValue with Other Hazelcast Features

In addition to querying JSON data using predicates, HazelcastJsonValue can be combined with other Hazelcast features such as Entry Processors and MapStore to enable advanced data processing and persistence.

For example, you can use Entry Processors to modify JSON objects directly within the map based on specific conditions, or use MapStore to persist JSON objects to an external database while leveraging Hazelcast’s in-memory performance.

Conclusion

Hazelcast JSON Predicates offer a powerful and flexible way to query and filter JSON data in distributed environments. Whether you’re working with simple fields or nested structures, Hazelcast provides SQL-like querying capabilities that make it easy to retrieve the data you need. By combining predicates with features like indexing and logical operators, developers can efficiently manage and query large-scale JSON data.

With the growing use of JSON in modern applications, mastering Hazelcast’s JSON querying capabilities is essential for building scalable, high-performance systems.

The sample code available over the github.