Adventures in Machine Learning

Unlocking the Power of Data Storage: Relational Non-Relational and Cache Databases

Becoming a Data Engineer

Data engineering is a highly sought-after field in today’s world. With the exponential growth of data, there is a constant need for qualified professionals who can build efficient data pipelines to extract, transform, and load data.

In this article, we will discuss the roles and skills necessary to become a data engineer and the importance of Python in this field.

Roles and Skills of a Data Engineer

A data engineer is responsible for designing, building, and maintaining the infrastructure that supports data storage, processing, and analysis. Their primary role is to ensure that data is available, reliable, and accessible to all stakeholders.

A data engineer should have the following skills:

1. Data Modelling: A data engineer must be able to understand the domain and design data models that can handle large volumes of data efficiently.

2. Data Integration: A data engineer should be proficient in integrating data from various sources like databases, APIs, and unstructured data.

3. ETL: Extract, Transform, and Load (ETL) is a major function of a data engineer.

They should be able to extract data from multiple sources, transform the data into a format suitable for analysis, and load it into a new system. 4.

Data Quality: A data engineer should be able to ensure data quality by managing data quality controls, creating data quality reports, and planning for data quality improvement. 5.

Cloud Computing: Knowledge of cloud computing platforms such as Amazon Web Services (AWS) and Microsoft Azure is highly desirable as data engineering workloads are often run on these platforms.

Importance of Python for Data Engineers

Python is a high-level programming language used extensively in data analytics, data science, and data engineering. Python has become the go-to language for data engineers as it is easy to learn, has a large user community, and has a vast array of libraries and frameworks that can handle data processing.

Python is well-suited for the following data engineering tasks:

1. Data Preparation: Python has libraries like Pandas, Numpy, and Scipy that simplify data preparation tasks like cleaning, transforming, and merging.

2. ETL: Several Python libraries like Airflow, Luigi, and Bonobo make it easy to set up ETL workflows that can connect to a variety of data sources.

3. Data Integration: Python has libraries like Requests and Scrapy that help in extracting data from APIs, web pages, and other sources.

4. Data Visualization: Python has libraries like Matplotlib and Seaborn that allow data engineers to create intuitive and engaging visualizations.

Answering Data Engineer Interview Questions

In a data engineering interview, the interviewer is likely to ask a wide range of questions to assess your technical and analytical skills. Some of the common interview questions include:


What is data engineering, and why is it necessary? 2.

What are the differences between a data warehouse and a data lake? 3.

What are the advantages and disadvantages of using a non-relational database over a relational database? 4.

How do you handle data quality issues? 5.

What are the key features of a good ETL system?

Differences between Relational and Non-Relational Databases

Relational and non-relational databases are two types of database management systems that can store and organize data in different ways. While both types of databases have their own advantages and disadvantages, it is essential to understand the differences between them before deciding which one to use.

1. Data Structure: Relational databases store data in tables that have a predefined schema, while non-relational databases store data in a flexible schema that can vary from one document to another.

2. Scalability: Non-relational databases are more scalable than relational databases and can handle large volumes of unstructured data more efficiently.

3. Querying: Relational databases use SQL to query data, while non-relational databases use NoSQL.

SQL is good for simple queries, but complex queries may be difficult to write and execute. 4.

Complexity: Relational databases are complex to set up, whereas non-relational databases have a simpler setup process.


Becoming a data engineer requires a combination of technical, analytical, and communication skills. Python is an essential tool for data engineers as it simplifies data processing tasks.

In a data engineering interview, being familiar with the differences between relational and non-relational databases can give you an edge over other candidates.

Questions on Relational Databases

Relational databases have been used for decades and remain a popular way to store, organize and access structured data. In this section, we will cover the basics of relational databases and provide an example of SQLite and how to query data with SQL.

Explanation of Relational Databases

A relational database is made up of one or more tables that consist of rows and columns. A column represents a specific attribute of a data object, while each row represents a single data object.

The relationship between two tables is established by mapping data in one table to data in another table. The mapping is done by creating a unique identifier (primary key) for each row.

Relational databases are designed to enforce strict integrity constraints to maintain consistency. Specifically, each table in a database must have a primary key that uniquely identifies a row, and foreign keys that connect tables.

When data is entered into the database, the database management system (DBMS) validates data entered to ensure it conforms to established integrity constraints.

SQLite Example and Querying Data with SQL

SQLite is a free, open-source database that works on all platforms. It is a serverless, self-contained database engine that can be run in-process with the application.

SQLite supports a subset of the SQL language, which allows you to create, modify, and query data. To create a table in SQLite, the following SQL query can be used:

CREATE TABLE employees (

employee_id INT PRIMARY KEY,

first_name VARCHAR(200),

last_name VARCHAR(200),

hire_date DATE,

job_title VARCHAR(200),

manager_id INT,

salary DECIMAL(10,2)


This query creates an “employees” table with columns for “employee_id”, “first_name”, “last_name”, “hire_date”, “job_title”, “manager_id”, and “salary”. The column employee_id is set as the primary key.

To insert data into the table, we can use the following SQL query:

INSERT INTO employees (employee_id, first_name, last_name, hire_date, job_title, manager_id, salary)

VALUES (1, ‘John’, ‘Doe’, ‘2022-01-01’, ‘Engineer’, 101, 85000.00);

This query inserts a new employee into the employees table with the specified attributes. To query data from the table, we can use the following SQL query:

SELECT * FROM employees WHERE job_title=’Engineer’;

This query selects all employees who have a “job_title” of “Engineer”.

The results will be displayed in tabular form.

Questions on Non-Relational Databases

Unlike relational databases that use tables to organize data, non-relational databases use unstructured data models to store data in documents, graphs, or key-value pairs. In this section, we will discuss the basics of non-relational databases and provide an example of MongoDB and how to query data with MongoDB.

Explanation of Non-Relational Databases

Non-relational databases are designed to handle data that does not conform to a strict schema. The data in non-relational databases is often denormalized, meaning that redundant data is stored within the same document as the primary data.

Non-relational databases are more scalable than relational databases, with the ability to store and handle large volumes of unstructured data. This makes non-relational databases ideal for modern web applications and data-intensive systems.

Non-relational databases use a range of data models to store data, such as documents, graphs, and key-value stores. The document model is the most widely used in non-relational databases, which stores data in a hierarchical model similar to a file system.

In this model, each document contains multiple fields, each holding a value, including other documents or arrays.

MongoDB Example and Querying Data with MongoDB

MongoDB is a popular non-relational database that uses the document model to store data. To illustrate how to query data from MongoDB, we will use an example with a collection of “customer” documents.

To create a document, we can use the following JSON structure:


“_id”: 1,

“first_name”: “John”,

“last_name”: “Doe”,

“email”: “[email protected]”,

“address”: {

“street”: “123 Main St”,

“city”: “Anytown”,

“state”: “CA”,

“zip”: “12345”


“orders”: [


“order_id”: 10001,

“items”: [


“product_id”: 1,

“quantity”: 2



“product_id”: 2,

“quantity”: 1





“order_id”: 10002,

“items”: [


“product_id”: 3,

“quantity”: 3






This document includes several fields, including “_id”, “first_name”, “last_name”, “email”, “address”, and “orders”. To query data from this collection, we can use the following command:

db.customers.find({ “”: “Anytown” })

This query finds all customers who live in the city “Anytown”.

The results will be displayed in JSON format.


In conclusion, relational and non-relational databases provide different ways to store, organize, and access structured and unstructured data. While relational databases are still the most widely used form of data storage, non-relational databases are gaining popularity due to their flexibility, scalability, and capacity to handle large volumes of unstructured data.

Understanding the key concepts and differences between these two database types is essential for data professionals looking to work with modern applications and data-intensive systems.

Questions on Cache Databases

Cache databases, also known as in-memory databases, store frequently accessed data in a cache layer between the application and the primary data storage system. In this section, we will discuss the basics of cache databases and provide an example of Redis and how to use cache databases.

Explanation of Cache Databases

Cache databases work by storing frequently accessed data in a memory cache layer, which sits between the application and the primary data storage system. This in-memory data store provides faster access to data compared to disk-based storage as it doesn’t have to fetch data from disk every time it is requested.

This makes cache databases ideal for applications that require fast read and write performance, such as real-time data analytics, e-commerce, and gaming. Cache databases use a variety of cache replacement algorithms to manage the data stored in the cache layer.

These algorithms determine which data is evicted from the cache when the memory limit is reached. Examples of cache replacement algorithms include least recently used (LRU), least frequently used (LFU), and random replacement.

When a cache miss occurs, that is, the cache does not have access to the data requested, the data is fetched from the primary storage system and added to the cache for faster access in the future.

Redis Example and How to Use Cache Databases

Redis is a popular open-source in-memory data structure store that supports various data structures such as strings, hashes, lists, sets, and sorted sets. Redis can also be used as a cache database, staging area, message broker, or pub/sub system.

Let’s explore a simple example of how Redis is used as a cache database. To use Redis as a cache, we should first install Redis on a local machine using a package manager such as apt-get or brew.

Once installed, we can connect to Redis using the Redis command-line interface (CLI). The following examples show how to use Redis to store and retrieve data using the CLI.

To set a value, use the SET command followed by the key and value:

> SET mykey somevalue

To retrieve a value, use the GET command followed by the key:

> GET mykey

If the key is not in Redis cache, the GET command returns a null value. To add an expiration time to a value, use the EXPIRE command followed by the key and time to live (TTL) in seconds:

> EXPIRE mykey 60

This command sets a TTL of 60 seconds to key “mykey.” Once the TTL is reached, the key is evicted from the cache.

Redis also supports cache invalidation capabilities, which allow us to remove individual keys or groups of keys when data is updated or deleted. This ensures that data in the cache is always up-to-date with the primary data storage system.


In today’s fast-paced world, speed is of the essence. Data professionals must be able to provide fast and reliable access to data for their applications to run efficiently.

In-memory cache databases have become an essential tool in modern application development, providing fast read and write performance and reducing the load on primary data storage systems. Understanding the basics of cache databases, including how they work, their benefits, and their use cases, is essential for data professionals looking to build robust and responsive applications.

Redis is an excellent example of the possibilities cache databases offer, showcasing the flexibility and convenience of an in-memory data structure store. By leveraging the power of cache databases like Redis, organizations can unlock faster and more efficient data processing, delivering a better experience for end-users.

In this article, we have discussed the fundamental concepts of data storage and covered the three main types of databases: relational, non-relational, and cache. We have explained the key differences between relational and non-relational databases, and the benefits of in-memory cache databases.

Python is a critical tool for data engineers in processing data, and we have provided examples of SQLite and MongoDB to help readers understand how these databases are used. Redis was used as an example of an in-memory cache database, and we explained how it is used to store frequently accessed data.

As the importance of data only grows, data professionals must understand the different types of databases available and how they can be used to enhance the performance and efficiency of applications. The article concludes by emphasizing that this understanding is vital for building successful data-driven applications.

Popular Posts