Implementing Cascading Deletes in a Relational Data Structure

This challenge focuses on simulating the behavior of cascading deletes, a common feature in relational databases. You'll implement a system where deleting a parent record automatically removes all associated child records, maintaining data integrity. This is crucial for preventing orphaned data and ensuring a clean, consistent dataset.

Problem Description

You are tasked with creating a Python class that simulates a simple relational data structure capable of handling cascading deletes. Imagine you have two types of "objects": Parent and Child. A Parent object can have multiple Child objects associated with it. When a Parent object is deleted, all its associated Child objects must also be automatically deleted.

Key Requirements:

1. Data Storage: You'll need a way to store Parent objects and their associated Child objects. A dictionary or a list of dictionaries can be used to represent this.
2. Parent-Child Relationship: Establish a clear link between Parent objects and their Child objects. Each Child should know which Parent it belongs to.
3. Cascading Delete Functionality: Implement a method that, when called on a Parent object, removes the Parent and all its associated Child objects from your data storage.
4. Handling Non-Existent Parents: The delete operation should gracefully handle attempts to delete a Parent that doesn't exist.

Expected Behavior:

• When a Parent is added, it should be stored.
• When a Child is added, it should be associated with a specific Parent and stored.
• When a Parent is deleted, the Parent record itself and all Child records linked to it should be removed.
• After a cascading delete, attempting to access the deleted Parent or its former Child objects should indicate they no longer exist.

Edge Cases to Consider:

• Deleting a Parent that has no Child objects.
• Attempting to delete a Parent that has already been deleted.
• Adding Child objects to a Parent that has already been deleted (this scenario might depend on how strict your data model is; for this challenge, assume children can be added to existing parents, and the cascading delete handles removal).

Examples

Example 1:

Initial State:
Parents: {}
Children: {}

1. Add Parent P1
2. Add Parent P2
3. Add Child C1 associated with P1
4. Add Child C2 associated with P1
5. Add Child C3 associated with P2

Delete Parent P1

Output:
Parents: { 'P2': <Parent object P2> }
Children: { 'C3': <Child object C3> }

Explanation:
Initially, we have empty storage.
After adding parents and children, P1 has C1 and C2, P2 has C3.
When P1 is deleted, P1 itself is removed, and its associated children C1 and C2 are also removed. P2 and C3 remain unaffected.

Example 2:

Initial State:
Parents: {}
Children: {}

1. Add Parent P1
2. Add Child C1 associated with P1

Delete Parent P1

Output:
Parents: {}
Children: {}

Explanation:
P1 is added, then C1 is added associated with P1.
When P1 is deleted, P1 is removed, and its only associated child, C1, is also removed.

Example 3:

Initial State:
Parents: {}
Children: {}

1. Add Parent P1
2. Add Child C1 associated with P1

Delete Parent P99 (non-existent)

Output:
Parents: { 'P1': <Parent object P1> }
Children: { 'C1': <Child object C1> }

Explanation:
P1 and its child C1 exist.
Attempting to delete a non-existent parent (P99) has no effect on the existing data.

Constraints

• The number of parents and children can range from 0 to 1000.
• Parent and Child identifiers (names/keys) will be unique strings.
• The implementation should be efficient, with delete operations typically completing in O(k) time, where k is the number of child objects associated with the parent being deleted.
• The data structures used should be standard Python collections (dictionaries, lists).

Notes

Consider how you will represent the relationships between parents and children. You might want to store a list of child IDs within each parent object, or store the parent ID within each child object, or both.

When implementing the delete functionality, ensure that you correctly identify and remove both the parent and all its associated children from your storage mechanisms. Think about how to avoid issues like trying to access deleted objects.