"Useless" code in ClassMolder.delete

Reassigned to myself, added Thomas to CC.

The following comment from ClassMOlder.deleteExtend()

/**

• It method is called by delete to delete the extended object of the base
• type from the Persistence.
  *
  */

got me thinking a little bit more. Could it be that this is code intended to
work with polymorhism ? It would be absolutely brilliant if somebody working on
Castor years back could share his or her knowledge with us on this very subject.

Actually, just realised what the commented code fragment is about. Imagine a
hierarchy of ObjectA and ObjectB where ObjectB extends ObjectA. In the case
where we are trying to remove an instance of ObjectB, everything works fine. In
the case where we are trying to remove an instance of ObjectA, things do NOT
work at the moment and tangling table entries in the table to which ObjectB is
mapped are the result.

Imho, the commented calls to deleteExtend() need to be uncommented, i.e.
reactivated. But before even thinking about this, I'd appreciate any comments
(as always).

Actually, after some more thinking, it seems like deleteExtend() does not yield
the desired results, as it covers dependent objects only. Imho, one needs to
write code that deals with the extend hierarchy in both directions. At the
moment, only one direction (towards the base class of the hierarchy) is covered
completely.

I have come across this before myself, but I never took the time to understand
it. I think that this method should be made to work beyond only dependent
objects, but there may be a reason why it was left in this state. Maybe Thomas
knows.

I think Werner was right on what the code suppose to do, and why the code
doesn't work.

Great. Anybody willing (and able) to work with me on this ?

Well, well .. . Rather than looking for peers joining me on this, let me try
to get my head around the following question. With the above scenario, where we
have ObjectBs extending ObjectA, is the following statement correct?

"If we delete an instanec of ObjectA, we have to delete all instances of ObjectB
that share the same identity."

Opinions ?

Thomas, it seems like the code already tries to take care of DEPEND relations,
etc. when trying to delete an instance of ObjectB, as there is code that seems
to walk the complete object graph in terms of dependent objects.

My question is about the sequence of events when deleting an instance of ObjectB
as discussed above. Right now, the current code seems to want to ..

a) delete the instance of ObjectB (SQLEngine.delete())
b) delete the instance of ObjectA (SQLEngine.delete())
c) ???
d) ???

Can you please fill in c) and d) for me, using lines 2288 to 2315. It looks like
d) is about finding all classes that extend ObjectB (directly or indirectly),
and delete them as well. But what is d) about ?

And before I get the most essential question, hw come the calls to
deleteExtend() have been commented in the first place ? Is this for a particular
reason ?

I would need to inspect the code in detail, before I can
figure it out. Will come back to you soon, hopefully in
a day or two.

Werner, I notice that you added some logging for the case where the extendPath
contains the directly extending class. Did you make any progress on this?

Not really, as things are pretty complex. I'll have to look at some code to see
whether I have done anything at all, or just analysed current behaviour.

Based upon my work to add support for polymorphism, I think that this code really is not used at all, and hence should/could be removed.

Used to be BugZilla bug 1636.

Will prepare and commit a patch for removal of bespoke code when committing issue CASTOR-1018.

Patch as discussed above, basically removing ClassMolder.deleteExtend() and all (commented) references to it.

As deleteExtend() is never called I think we are on the save side to delete that code. Therefore go ahead and commit.