Understanding JSON Data Model Simplified 101

Are you beginning to work with NoSQL or Document Databases? If that’s the case, then it will be good to have a brief knowledge of JSON Modeling. Because shifting from Relational Databases to schema-less Databases allows you to build more flexible applications and handle even semi-structured data.

Like in the Relational data model, you need to design the schema and analyze the data requirements before going live. Similarly, JSON Modeling will help you organize data with ease. With the high demand for fast query performance, storing data in JSON format is best suited for this.

In this article, you will learn about JSON Modeling and how it differs from Relational tables. Also, you will go through the JSON data model process, and rules to follow while converting from Relational data to documents. And, at last, we will cover an example JSON data model example in Java.

What is JSON?

JSON (JavaScript Object Notation) is a lightweight and open standard file format that uses human-readable text for storing and transporting data. It’s a data-interchange format that transmits data objects that contains key-value pairs and arrays to store data. It’s easy for machines to parse and generate. JSON is based on a subset of the JavaScript programming language and was originally designed as an alternative to XML. Also, it’s a language-independent format which means it supports every kind of language, framework, and library.

JSON is a widely-used text notation/format used for structured data. The key application of JSON is exchanging data among web clients and web servers. JSON media type is application/json and file extension is .json. JavaScript offers a global JSON Object that can streamline your JSON conversions and allow you to use this format easily. With JSONPath expressions, you can perform advanced querying on JSON data, enabling precise data extraction for use in applications and analysis.

Basic JSON Syntax

Rules:

• <KEY>:<VALUE> Data is in key/value pairs.
• Data is separated by commas.
• Objects are enclosed in curly braces ({}).
• Arrays are enclosed in square brackets ([]).

{"employees":[
  { "firstName":"John", "lastName":"Doe" },
  { "firstName":"Anna", "lastName":"Smith" },
  { "firstName":"Peter", "lastName":"Jones" }
]}

In JSON, values must be one of the following data types:

• a string
• a number
• an object
• an array
• a boolean
• null

JSON Modeling for Document Databases

JSON Modeling bind controls to JavaScript object data which is generally specified in JSON format. It’s a client-side model and does not support mechanisms that involve server-side paging or loading. JSON Modeling doesn’t support any for sending data back to the server. 

JSON Modeling has a data model for document Databases consisting of a structured hierarchy. A document in the JSON data model may contain embedded documents as data. In JSON Modeling each document with data represent the attributes of an entity. Documents are organized into collections that are equivalent to tables in Relational Databases. 

Here is an example of JSON Modeling for better understanding, conversion from Relational table to JSON format is shown below:

Data Table:

Number	Date	Customer	Price	Quantity
SO43659	2011-05-31T00:00:00	AW29825	59.99	1
SO43661	2011-06-01T00:00:00	AW73565	24.99	3

SQL Query:

SELECT 
    Number AS [Order.Number], 
    Date AS [Order.Date],
    Customer AS AccountNumber,
    Price AS 'Item.UnitPrice', 
    Quantity AS 'Item.Qty'
FROM SalesOrder
FOR JSON PATH, ROOT('Orders')

Resulting JSON Output:

{
    "Orders": [
        {
            "Order": {
                "Number": "SO43659",
                "Date": "2011-05-31T00:00:00"
            },
            "AccountNumber": "AW29825",
            "Item": {
                "Price": 59.99,
                "Quantity": 1
            }
        },
        {
            "Order": {
                "Number": "SO43661",
                "Date": "2011-06-01T00:00:00"
            },
            "AccountNumber": "AW73565",
            "Item": {
                "Price": 24.99,
                "Quantity": 3
            }
        }
    ]
}

Normalization vs Denormalization

Normalization is the best approach to dealing with relational databases to maintain data and avoid redundancy. However, when it comes to non-relational Databases or NoSQL, denormalization is the best approach. It is just the opposite of Normalization. Here, all related data for an entity is compressed into a single document in the NoSQL Database. 

Aspect	Normalized	Denormalized
Data Structure	Multiple related tables (e.g., Books, Authors)	Single table with nested data (e.g., combined Book and Author)
Redundancy	Minimal redundancy	Higher redundancy
Flexibility	High flexibility for updates	Less flexibility requires updating multiple entries
Performance	Slower for complex queries (joins required)	Faster for simple queries (no joins needed)
Data Integrity	Maintained via primary/foreign keys	Lower integrity, no enforced relationships
Use Case	Ideal for transactional systems	Ideal for fast, read-heavy applications

JSON Modeling Process

In this section, you will learn how to perform JSON Modeling in NoSQL Databases using an example. It’s a good practice to start with Entity-Relationship modeling to define the entities, relationships, and attributes for the application. 

Entities are the main objects, Attributes are properties of the objects and Relationships are connections between Entities. This can be one-to-one, one-to-many, many-to-many, etc. Let’s take the example of social media applications. The E-R diagram for social media applications is shown below. 

In the above diagram, the Entities are User, Post, and Comment. Relationships are user makes a post, a post has comments, and a post belongs to a category. The Relational model of this example is shown below.

Here, users are stored in the user table. The posted URL is stored in the Post table with a foreign key to the user that posted it, and a foreign key to the category for the post. Comments about a post are stored in the comments table with a foreign key to the post and a foreign key to the user that commented.

Now, you have to just Denormalize this diagram and you will get a JSON data model.

Rules for JSON Modeling

Some rules to follow when performing JSON Modeling or converting Relational tables to JSON models.

• If the Relationship is one-to-one or one-to-many then store related data as nested objects.
• If the Relationship is many-to-one or many-to-many then store related data as separate documents.
• If data reads are mostly parent fields then store children as a separate document. 
• If data reads are mostly parent + child reads then store children as nested objects.
• If data writes are mostly either parent or child then store children as separate documents.
• If data writes are mostly either parent and child both then store children as nested objects.

Example of JSON Modeling Using Java

In this section, you will go through an example of a Java class that will act as a JSON Model in the application. Let’s take an example of Yelp sample data fetched from the API in JSON format.

{
  "businesses": [
    {
      "id": "yelp-tropisueno",
      "name" : "Tropisueno",
      "display_phone": "+1-415-908-3801",
      "image_url": "http://s3-media2.ak.yelpcdn.com/bphoto/7DIHu8a0AHhw-BffrDIxPA/ms.jpg",
      ...
    }
  ]
}

Now as this data contains 4 attributes – id, name, phone, and image URL. Now if you have to generate a data model for this data in Java. Then it would look like as shown below.

public class Business {
	private String id;
	private String name;
	private String phone;
	private String imageUrl;

	public String getName() {
		return this.name;
	}

	public String getPhone() {
		return this.phone;
	}

	public String getImageUrl() {
		return this.imageUrl;
	}
}

Conclusion 

In this article, you learned about Data Modeling and the basic syntax of JSON. Then you read about JSON Modeling, how it is different from Relational Database, and how it delivers better query performance over relational tables. You also went through the process of JSON Modeling and an example of how to code JSON data models in Java.

Companies need to analyze their business data stored in multiple data sources. Data needs to be loaded to the Data Warehouse to get a holistic view of the data. Hevo Data is a No-code Data Pipeline solution that helps to transfer data from 150+ data sources to desired Data Warehouse. It fully automates the process of transforming and transferring data to a destination without writing a single line of code.

Want to take Hevo for a spin? Sign Up here for a 14-day free trial and experience the feature-rich Hevo. Share your experience learning about JSON modeling in the comments section below!

FAQ on JSON Data Model