Update multiple repositories doc

Author: JohannesRabauer

docs/modules/ROOT/pages/known-issues.adoc

@@ -32,24 +32,34 @@ The behavior can be configured through xref:configuration.adoc#context-close-shu
 
 == Multiple Repositories with related entities [[multi-repos-with-related-entities]]
 
-Users of SQL-Databases usually have a different understanding regarding relations between entities.
-They are handled and checked by the database.
+In SQL databases, relationships between entities are explicitly defined and enforced by the database system.
+This ensures that constraints, such as foreign keys, are consistently maintained.
 
-In the Java object graph we only have the relations defined by the user.
-This means that if a contained object has no variable that points to the containing object, it does not know anything about it, and we can only find this relation by searching through the whole object graph.
-
-An example: If an order instance contains several references to articles, there is almost no way to find the containing order of an article.
-Of course, we could search the whole object tree and then finally find the parent, but that would not be effective at all.
+In contrast, relationships in a Java object graph are solely defined by the developer.
+If an object within the graph does not maintain a reference back to its parent or containing object, it has no inherent knowledge of that relationship.
+Consequently, finding such a relationship requires searching the entire object graph, which can be highly inefficient.
 
 image::DependingClasses.svg[Example structure with orders and articles]
 
-Now what if we deleted a referenced article from the article repository?
+Example Scenario:
+Consider an *order object* that contains references to several *article objects*.
+In this case, determining which order contains a specific article is nearly impossible without traversing the entire object graph to locate it.
+This lack of direct reference contrasts sharply with the behavior of SQL databases.
+
+What Happens When an Article is Deleted?
 
--> in a sql database we would expect an exception to arise, because we shouldn't remove a referenced article.
+1. In an *SQL Database*: +
+Attempting to delete an article that is still referenced (e.g., by an order) would typically result in an exception. +
+The database enforces referential integrity, preventing the deletion of a referenced entity.
 
--> but in Spring-Data-Eclipse-Store we can easily remove this article, because the system doesn't know about any references to it.
-This results in the article getting removed, but the article actually still exists in the order.
-Furthermore, if we store the order again, the article will be existing in the article repository once more.
+2. In *{product-name}*: +
+Deleting an article from the article repository is allowed, even if it is still referenced elsewhere. +
+The system does not track or enforce such references.
+As a result:
 
-This is simply a very different behaviour from SQL databases and must be acknowledged.
+* The article is removed from the repository.
+* However, the order still retains its reference to the now-deleted article.
+* If the order is subsequently saved, the article is reintroduced into the repository.
 
+This behavior is fundamentally different from the strict relationship management seen in SQL databases.
+Developers must be aware of these differences to avoid unintended side effects in their applications.