Re: vertical inheritance joins
Hi Andrus, On 03/06/2007, at 7:12 PM, Andrus Adamchik wrote: On Jun 1, 2007, at 3:24 PM, Lachlan Deck wrote: On 01/06/2007, at 7:32 PM, Andrus Adamchik wrote: With this in mind we do not need an inheritance ObjRelationship, but we may use a DbRelationship to store join semantics (anybody mentioned that already??). Well the original suggestion I made was for superRelationship="nameOfRelationship" ...> to allow for specifically specifying vertical inheritance (which would have the effect of not listing this relationship along with those returned from objEntity.getRelationships() but via objEntity.getSuperRelationship(). This is what I was trying to avoid - introducing relationships with special behavior. Okay. It'd be perhaps less obvious what type of inheritance was in play in the modeller but then again perhaps a simple dynamic label could display something to the same effect along with the below validation. Are you suggesting that you'd prefer superRelationship="nameOfRelationship" ...> No, as DbEntities (tables) do not have inheritance among themselves. It would be more of superDbRelationship="nameOfDBRelationship" ...>, but I do believe that this can be made implicit, as arguably there can be only one DbRelationship between the primary keys of two tables. E.g: SuperOE -> DB1 SubOE1 -> DB2 SubOE2 -> DB3 In this case Cayenne can easily figure out the name of DB2->DB1 and DB3->DB1 relationships based on relationship semantics. Okay great. I suppose there'd need to be validation to that effect to ensure that such relations exist when choosing a different DbEntity from the parent entity. Another nice side effect of it is that such relationship is not a part of the object model (ObjRelationship would've been an object property). So there is nothing artificial about such mapping, and no new concepts are needed in Cayenne to map it. Can you clarify this a bit more. See above - I don't want to redefine what ObjRelationship is. The difference between Cayenne and EOF is that Cayenne splits DB and Java mapping in two separate layers of metadata. EOF allows to mark a relationship as "not included in the object model", while Cayenne allows to map the DB relationship without mapping corresponding ObjRelationship, essentially achieving the same thing in a different way. Thanks. Just a slight mind-shift ;-) with regards, -- Lachlan Deck
Re: vertical inheritance joins
Hi Lachlan, On Jun 1, 2007, at 3:24 PM, Lachlan Deck wrote: On 01/06/2007, at 7:32 PM, Andrus Adamchik wrote: With this in mind we do not need an inheritance ObjRelationship, but we may use a DbRelationship to store join semantics (anybody mentioned that already??). Well the original suggestion I made was for superRelationship="nameOfRelationship" ...> to allow for specifically specifying vertical inheritance (which would have the effect of not listing this relationship along with those returned from objEntity.getRelationships() but via objEntity.getSuperRelationship(). This is what I was trying to avoid - introducing relationships with special behavior. Are you suggesting that you'd prefer superRelationship="nameOfRelationship" ...> No, as DbEntities (tables) do not have inheritance among themselves. It would be more of superDbRelationship="nameOfDBRelationship" ...>, but I do believe that this can be made implicit, as arguably there can be only one DbRelationship between the primary keys of two tables. E.g: SuperOE -> DB1 SubOE1 -> DB2 SubOE2 -> DB3 In this case Cayenne can easily figure out the name of DB2->DB1 and DB3->DB1 relationships based on relationship semantics. Another nice side effect of it is that such relationship is not a part of the object model (ObjRelationship would've been an object property). So there is nothing artificial about such mapping, and no new concepts are needed in Cayenne to map it. Can you clarify this a bit more. See above - I don't want to redefine what ObjRelationship is. The difference between Cayenne and EOF is that Cayenne splits DB and Java mapping in two separate layers of metadata. EOF allows to mark a relationship as "not included in the object model", while Cayenne allows to map the DB relationship without mapping corresponding ObjRelationship, essentially achieving the same thing in a different way. Andrus
Re: vertical inheritance joins
On 01/06/2007, at 7:32 PM, Andrus Adamchik wrote: With this in mind we do not need an inheritance ObjRelationship, but we may use a DbRelationship to store join semantics (anybody mentioned that already??). Well the original suggestion I made was for superRelationship="nameOfRelationship" ...> to allow for specifically specifying vertical inheritance (which would have the effect of not listing this relationship along with those returned from objEntity.getRelationships() but via objEntity.getSuperRelationship(). Are you suggesting that you'd prefer superRelationship="nameOfRelationship" ...> or just figuring out the relationship by finding the one that happens to map to the parent as a toOne? The nice thing I thought about having a superRelationship definition in the modeler is that you can then make your inheritance choice in one place and it's clear of the choice. i.e., the above would just require an additional popup next to the popup for which DbEntity an ObjEntity maps to to choose a relationship. Otherwise perhaps it wouldn't be as clear whether such a relationship exists. The other option I considered initially was having superRelationship as a boolean flag with validation to ensure there was an accompanying relationship called 'super' but thought this unnecessarily restrictive in the end. Another nice side effect of it is that such relationship is not a part of the object model (ObjRelationship would've been an object property). So there is nothing artificial about such mapping, and no new concepts are needed in Cayenne to map it. Can you clarify this a bit more. Thanks. with regards, -- Lachlan Deck
Re: vertical inheritance joins
This was a long thread, and I may have missed some points already made. Let me try to summarize this discussion and add my comments to it. There are two aspects of the "vertical inheritance relationship": 1. Specifying the join semantics for non-trivial PK-to-PK mapping (such as compound keys). 2. Specifying delete rules. I am with Ari on (1) - it is in the Cayenne philosophy to map things explicitly, so that various weird legacy schemas can still be mapped. I am with Craig on (2) - if a user expects to delete a record from a subclass table without deleting a record in a superclass table, this situation should not be mapped as inheritance, as it breaks the ORM model at a fundamental level (an object is deleted, but some of its properties still remain persistent - BAD). With this in mind we do not need an inheritance ObjRelationship, but we may use a DbRelationship to store join semantics (anybody mentioned that already??). Another nice side effect of it is that such relationship is not a part of the object model (ObjRelationship would've been an object property). So there is nothing artificial about such mapping, and no new concepts are needed in Cayenne to map it. Andrus
