6 Different Data Formats Commonly Used in Data Analytics

Aadhitya Dev — Mon, 06 Oct 2025 14:19:46 +0000

In the world of data analytics, the choice of data format plays a crucial role in efficiency, storage, and processing. Different formats cater to various needs, from simple text-based exchanges to optimized binary storage for big data systems. In this article, we'll dive into six common data formats: CSV, SQL (relational tables), JSON, Parquet, XML, and Avro.

For each format, I'll explain it in simple terms and represent a small dataset using it. The dataset is a simple collection of student records:

Name: Alice, Register Number: 101, Subject: Math, Marks: 90
Name: Bob, Register Number: 102, Subject: Science, Marks: 85
Name: Charlie, Register Number: 103, Subject: English, Marks: 95

Let's explore each format one by one.

1. CSV (Comma Separated Values)

CSV is a straightforward text format where each row of data is a line, and values within the row are separated by commas (or other delimiters). It's like a basic spreadsheet without any fancy features. CSV is popular because it's easy to generate, read, and compatible with most tools, but it lacks built-in schema or data types, which can lead to parsing issues.

Here's our student dataset in CSV format:

2. SQL (Relational Table Format)

SQL represents data in relational tables, which are like grids with rows (records) and columns (fields). It's not a file format itself but a way to structure data in databases. Each table has a defined schema specifying data types, and you can query it using SQL language. It's great for structured data with relationships but requires a database system to manage.

Here's how our dataset would look as SQL statements to create and populate a table:

3. JSON (JavaScript Object Notation)

JSON is a flexible, text-based format that stores data as key-value pairs (objects) or lists (arrays). It's human-readable, supports nested structures, and is widely used in web services, APIs, and configuration files. JSON is self-describing but can be verbose for large datasets.

Our dataset as a JSON array of objects:

4. Parquet (Columnar Storage Format)

Parquet is a binary, columnar storage format designed for big data processing. Instead of storing data row by row, it groups values by column, which enables better compression and faster analytics queries (e.g., summing a single column without scanning everything). It's popular in systems like Hadoop and Spark.

Since Parquet is binary, it can't be shown as readable text. Below is a hexadecimal representation of the Parquet file for our dataset (generated using Python's PyArrow library):

5. XML (Extensible Markup Language)

XML is a text-based markup language that uses hierarchical tags to structure data. It's like a tree of elements, making it suitable for complex, nested data. XML is verbose and self-descriptive but less efficient for large volumes due to its size. It's common in enterprise systems and web services.

Our dataset in XML format:

6. Avro (Row-based Storage Format)

Avro is a compact, binary row-based format that includes the data schema within the file. This allows for schema evolution (changing structures over time) and efficient serialization. It's row-oriented, making it good for write-intensive workloads, and is commonly used in Apache Kafka and Hadoop ecosystems.

Avro being binary, here's the schema in JSON format, followed by a Python code snippet that would generate the binary file:

Code to generate the Avro file:

Conclusion

Each of these formats has its place in data analytics. Text-based ones like CSV, JSON, and XML are great for readability and interoperability, while binary formats like Parquet and Avro excel in performance and scalability for big data. Choose based on your use case—whether it's quick exports, complex queries, or efficient storage. If you're working in cloud environments, formats like Parquet often shine due to their compression and query optimization.

What’s your go-to data format? Let me know in the comments!
Happy coding!!

MongoDB Hands-On Practice: CRUD Operations with the MongoDB Node.js Driver

Aadhitya Dev — Sun, 07 Sep 2025 14:13:06 +0000

You've got data, and you've got MongoDB Atlas. Now what? The best way to learn is by doing. In this tutorial, we'll take a provided dataset of business reviews and use the MongoDB Node.js driver to perform essential Create, Read, Update, and Delete (CRUD) operations.

1. Prerequisites: Connect to Your Atlas Cluster

First, we need to connect our Node.js application to MongoDB Atlas.

1.Install the driver: npm install mongodb

2.Get your connection string from your Atlas cluster dashboard (under the "Connect" button).

3.Set up your connection: Create a database.js module.

_2. The Queries (Using the Node.js Driver)
_
A. Insert the Provided Records
We'll write a script to insert your 10 review documents.

B. Query to find top 5 businesses with highest average rating.
Since each document is a single review, we need to $group by the business to calculate the average. We'll group by both business_id and name to get a clear result.

Expected Output:

C. Query to count how many reviews contain the word “good”.
We'll use the $regex operator for a case-insensitive text search on the review field. The $count stage is perfect for this.

D. Query to get all reviews for a specific business ID.
This is a simple find query. We'll find all documents where business_id matches our target.

E. Update a review and delete a record.
Update a Review:
Let's find the review for "Tech Cafe" and update its rating and text.

F.Delete a Record:
Let's delete the review for "Burger Town".

_
Conclusion_

You've now successfully performed all the requested operations on your flat reviews collection! The key difference in this approach is that business information (like the name) is duplicated in each review, which is a common trade-off for read performance and simplicity.

Key MongoDB concepts we used:

insertMany(): For bulk inserting documents.
Aggregation Pipeline ($group, $sort, $limit, $count, $match): The powerhouse for complex data analysis and transformation.
$regex: For powerful pattern matching within string fields.
find(): The standard workhorse for querying documents.
updateOne() and deleteOne(): For modifying and removing documents.

This hands-on approach should give you the confidence to start building your own MongoDB-backed applications. Happy coding

DEV Community: Aadhitya Dev

6 Different Data Formats Commonly Used in Data Analytics

MongoDB Hands-On Practice: CRUD Operations with the MongoDB Node.js Driver