# Mastering Hierarchical Data: Writing Recursive Queries in SQL

## Handling Hierarchical Data in SQL

Have you ever needed to represent a family tree, a manager-employee relationship, or a classification of living things in your database? If so, you have dealt with hierarchical data.

Hierarchical data is any data that can be organized in a parent-child relationship, such as a tree structure. Even genres of music can be represented this way, where the parent genre is broader, and the child genres are more specific.

In this article, we will explore how to handle hierarchical data in SQL and retrieve descendants from a parent.

## Definition and Examples of Hierarchical Data

Hierarchical data is a way of organizing data in a tree-like structure, where each node has only one parent, but can have multiple children. Each node, except the root node, has a parent, and each node can have one or more children.

For example, a family tree could be represented as a hierarchical data structure, where the root node is two parents and each child node is a family member. Similarly, a manager-employee relationship can also be represented as a hierarchical data structure, where the root node is the CEO, and each child node is an employee.

Another example of hierarchical data is a project with tasks. The project is the root node, and each task is a child node.

Additionally, classification of living things can also be represented as hierarchical data, where the root node is the kingdom, and each child node is the species.

### SQL Query: Retrieving Descendants from a Parent

Suppose we have a table that represents a parent-child relationship.

We want to retrieve all the descendants from a particular parent. To do that, we can use a Common Table Expression (CTE), with a recursive query.

### Defining the CTE

First, we define the CTE. A CTE allows us to define a temporary named result set that can be used within the entire scope of a single SQL statement.

In this case, we want to define a CTE that contains all the child nodes of a given parent.

``````WITH cte AS (
SELECT child_id, child_name, parent_id, 1 as level
FROM hierarchy
WHERE parent_id = @parent_id
UNION ALL
SELECT c.child_id, c.child_name, c.parent_id, level+1
FROM hierarchy c
JOIN cte p ON c.parent_id = p.child_id
)``````

In this CTE, we select the child_id, child_name, parent_id, and level of the nodes in the hierarchy table where the parent_id is equal to the parameter @parent_id. We also set the initial level to 1.

### Recursive Query

Next, we use a recursive query to traverse the hierarchy tree and retrieve all the descendants from the parent. We use UNION ALL to combine the results of the recursive query with the previous CTE.

``````SELECT child_id, child_name, parent_id, level
FROM cte
ORDER BY level, child_name``````

The recursive query selects the child_id, child_name, parent_id, and level of each child node that has a parent equal to the child_id of the previous CTE. It also increments the level by 1 for each subsequent level.

Finally, the query orders the results by level and child_name.

### Returning All Descendants

Now that we have defined our CTE and recursive query, we can retrieve all the descendants from a particular parent by passing the parent_id to the CTE.

``````WITH cte AS (
SELECT child_id, child_name, parent_id, 1 as level
FROM hierarchy
WHERE parent_id = @parent_id
UNION ALL
SELECT c.child_id, c.child_name, c.parent_id, level+1
FROM hierarchy c
JOIN cte p ON c.parent_id = p.child_id
)
SELECT child_id, child_name, parent_id, level
FROM cte
ORDER BY level, child_name``````

This query returns all the child nodes of the parent specified by the parameter @parent_id. The result includes the child_id, child_name, parent_id, and level of each node.

The result is ordered by level and child_name.

## Conclusion

Hierarchical data is a useful way of organizing data in a tree-like structure. SQL provides several techniques to handle hierarchical data, including CTEs and recursive queries.

Retrieving descendants from a parent is a common task when dealing with hierarchical data. By defining a CTE and using a recursive query, we can efficiently retrieve all the child nodes of a particular parent.

## Writing Recursive CTEs in Microsoft SQL Server

A Common Table Expression (CTE) is a powerful feature in SQL Server that allows us to define a temporary result set that can be used within a single SQL statement. Recursive CTEs are a special type of CTE that allows us to perform hierarchical queries, iterate over a result set, and perform calculations based on previous rows.

In this article, we will explore the syntax for writing recursive CTEs in Microsoft SQL Server and compare it with the syntax for hierarchical queries in Oracle.

### Difference in Syntax for Recursion in SQL Server

The syntax for recursive CTEs in Microsoft SQL Server is slightly different from the syntax used in Oracle. In SQL Server, we use the keyword RECURSIVE at the beginning of the CTE definition to indicate that it is a recursive CTE.

Here is the general syntax for a recursive CTE in SQL Server:

``````WITH RECURSIVE_CTE (column1, column2, ..., columnN) AS (
-- Base query
SELECT column1, column2, ..., columnN
FROM table
WHERE condition
UNION ALL
-- Recursive query
SELECT column1, column2, ..., columnN
FROM table
JOIN RECURSIVE_CTE ON
)``````

In the above syntax, we first define the column names for the result set of the CTE. Then, we write the base query that selects the initial set of rows for the CTE.

This is followed by the UNION ALL clause, which combines the result set of the base query with the result set of the recursive query. The recursive query joins the table with the CTE and performs calculations or filters the rows based on the previous rows in the CTE.

### Using Hierarchical Queries in Oracle

In Oracle, we use a hierarchical query to perform recursive queries over hierarchical data. The syntax for hierarchical queries is slightly different from the syntax used in SQL Server.

Here is the general syntax for a hierarchical query in Oracle:

``````SELECT column1, column2, ..., columnN
FROM table
CONNECT BY PRIOR column = parent_column``````

In this syntax, we start the query with the condition to select the initial set of rows for the hierarchy. Then, we use the CONNECT BY clause to define the parent-child relationship between the rows in the hierarchy.

The PRIOR keyword is used to refer to the parent column in the hierarchy.

### Handling NULL Values in the Table

When working with hierarchical data, we may encounter situations where a parent row does not have any child rows. In this case, the result set may not include the missing parent row.

This problem can be addressed by using a LEFT JOIN instead of an INNER JOIN when joining the table with the recursive CTE.

### Explanation for Missing Parent in Result

#### Consider the following example where we have a table called employees with the following data:

``````employee_id | employee_name | manager_id
1           | Alice        | NULL
2           | Bob          | 1
3           | Charlie      | 2
4           | David        | 3``````

In this example, employee 1 is the CEO and has no manager. Employee 2 is managed by employee 1, employee 3 is managed by employee 2, and employee 4 is managed by employee 3.

Suppose we want to retrieve all the employees who report to the CEO. We can use a recursive CTE and an INNER JOIN to join the table with the CTE.

``````WITH RECURSIVE_CTE AS (
SELECT employee_id, employee_name, manager_id
FROM employees
WHERE employee_id = 1
UNION ALL
SELECT e.employee_id, e.employee_name, e.manager_id
FROM employees e
JOIN RECURSIVE_CTE r ON e.manager_id = r.employee_id
)
SELECT *
FROM RECURSIVE_CTE;``````

#### The result of this query is:

``````employee_id | employee_name | manager_id
2           | Bob          | 1
3           | Charlie      | 2
4           | David        | 3``````

In this result, the CEO with employee_id 1 is missing because he has no manager.

### Modifying the Query to Include NULL Values with LEFT JOIN

To include the missing parent row in the result, we can use a LEFT JOIN instead of an INNER JOIN. A LEFT JOIN returns all the rows from the left table, even if there are no matching rows in the right table.

``````WITH RECURSIVE_CTE AS (
SELECT employee_id, employee_name, manager_id
FROM employees
WHERE employee_id = 1
UNION ALL
SELECT e.employee_id, e.employee_name, e.manager_id
FROM employees e
LEFT JOIN RECURSIVE_CTE r ON e.manager_id = r.employee_id
)
SELECT *
FROM RECURSIVE_CTE;``````

#### The result of this query is:

``````employee_id | employee_name | manager_id
1           | Alice        | NULL
2           | Bob          | 1
3           | Charlie      | 2
4           | David        | 3``````

In this result, the CEO with employee_id 1 is included even though he has no manager. The LEFT JOIN ensures that all the rows from the employees table are included in the result, even if there are no matching rows in the recursive CTE.

## Conclusion

Recursive CTEs are a powerful feature in SQL Server that allows us to perform hierarchical queries and iterate over a result set. The syntax for recursive CTEs in SQL Server is different from the syntax for hierarchical queries in Oracle.

When working with hierarchical data, we may encounter situations where a parent row does not have any child rows. This problem can be addressed by using a LEFT JOIN instead of an INNER JOIN when joining the table with the recursive CTE.

## Conclusion and Further Learning

Hierarchical data and parent-child relationships are essential concepts in data modeling and data analysis. The ability to represent hierarchical data in a database and query it efficiently is a crucial skill in the data industry.

With the knowledge gained from this article, you can apply your proficiency in writing recursive queries to different data scenarios and practice writing CTEs to solve problems in data modeling and analysis.

### Understanding Hierarchical Data and Parent-Child Relationship

Hierarchical data is a data structure that represents a parent-child relationship, where each node has only one parent but can have multiple children. Hierarchical data can be used in various scenarios, such as family trees, organizational charts, computer directories, and classification of living things.

The parent-child relationship is a cornerstone of data modeling. Each child node in a hierarchical data structure has a foreign key to its parent node’s primary key.

This relationship is essential in maintaining data consistency and avoiding data anomalies.

### Applying Knowledge to Similar Scenarios

By understanding the concepts of hierarchical data and parent-child relationships, you can apply your proficiency in writing recursive queries to similar scenarios. For instance, you can use recursive queries to represent product categories, projects with tasks, customer orders with order details, or any other structure that has a hierarchical relationship.

In addition to applying your knowledge to similar scenarios, you can use recursive queries to solve practical problems in data modeling and data analysis. For example, you can use recursive queries to find all the descendants of a node, calculate the depth of a tree, or find the shortest path between two nodes in a network.

### Recommended Courses and Articles

One excellent course to consider is “Recursive Queries in SQL” by William Brewer on Pluralsight.

This course covers the fundamentals of recursive queries, including syntax, CTEs, and practical examples.

Another useful resource is Microsoft’s official documentation on CTEs and recursive queries.

This documentation provides a detailed explanation of the syntax, examples, and best practices for using CTEs and recursive queries.

Additionally, SQLShack has an article titled “Working with Hierarchical Data in SQL Server” that covers data modeling with hierarchical data, querying hierarchical data, and best practices for managing hierarchical data.

By taking courses and reading articles on recursive queries and CTEs, you can enhance your skills and become proficient in querying hierarchical data. With this proficiency, you can solve challenging data modeling and data analysis problems, and improve your value as a data professional.

In conclusion, Hierarchical data and parent-child relationships are crucial concepts in data modeling and data analysis. Understanding the principles of representing and querying hierarchical data in databases is a critical skill for effective data management.

Recursive queries and CTEs are powerful SQL tools for querying hierarchical data, and knowing how to use them can solve complex data analysis problems. With recommended courses and articles, you can improve your skills and proficiency in recursive queries and CTEs and become an expert in querying hierarchical data.

Overall, it is vital to understand the importance of hierarchical data and leverage the power of SQL tools to effectively manage and analyze it.