Bug in GlorpSession>>#isNew:

Jochaim,

What is the bottom line here, why do you want to change this method.

Dis you encounter primary key duplicate errors ?

Regards,

@+Maarten,

> "jtuchel" <[hidden email]> |

Hi Joachim,

Personally I consider objects to be new only when their primarykey = nil, so I don't approach the problem the way you do.

However I certainly know about the delete, and register problem which asks for different behaviour if an object is or is not in cache, and lets be honest it'll drive you nuts.

In order to adress this I now use two methods which have proven to be reliable (registerExisting: and deleteExisting: ) source code below.

I use them to register any object which has a known primary key and for all deletes.

I only use the classic register: for "new" Objects with a primaryKey which is nil.

It has proven reliable to the point where I can delete > 10000 Objects spanning 16 different tables in a single unitOfWork.

This reliability does however come with a philosophy and some cost.

You only read the root Object of your model (and never something else).

You'll ban refresh (which like readings, brakes the identity relationships of proxies).

You never assign an Object to a variable except for the root object of your model (you can use parameters, arrays or valueHolders but no assignments).

You'll use count on every registration to find out wheter the Object should be added in cache.

If all of the above is ok for you, you can end up with a very reliable model.

Hope this helps.

Regards,

@+Maarten,

registerExisting: anObject

            "Register an existing object which complies to full identity. First Check wheter the object exist on the database by counting, if it no longer exist set its primary key to nil and register.

            If it does exist on the database check whether its in cache, if not adds it to the cache to avoids any primarykey error."

            anObject class = Proxy

                       ifTrue: [self registerExistingFrom: anObject getValue]

                       ifFalse: [self registerExistingFrom: anObject]

registerExistingFrom: anObject

            "Register an existing object which complies to full identity. First Check wheter the object exist on the database by counting, if it no longer exist set its primary key to nil and register.

            If it does exist on the databe check wheter its in cache, if not adds it to the cache to avoids any primarykey error. "

            | aCounter primKeys fields queryCount |

            anObject isNil

                       ifFalse:

                                   [fields := (self descriptorFor: anObject) primaryTable primaryKeyFields.

                                   primKeys := OrderedCollection new.

                                   "Check wheter primarykeys are not nil "

                                   (self descriptorFor: anObject) primaryKeyMappings

                                               do: [:eachField | primKeys add: eachField attribute name].

                                   ((primKeys collect: [:each | anObject perform: each]) includes: nil)

                                               ifFalse:

                                                          [fields size = 1

                                                                      ifTrue:

                                                                                  [queryCount := Glorp.Query count: anObject class

                                                                                                                     where: [:each | (each perform: primKeys first) = (anObject perform: primKeys first)]]

                                                                      ifFalse:

                                                                                  [queryCount := Glorp.Query count: anObject class

                                                                                                                     where: [:each | (each perform: primKeys first) = (anObject perform: primKeys first)].

                                                                                  2 to: fields size

                                                                                             do:

                                                                                                         [:n |

                                                                                                         queryCount := queryCount

                                                                                                                                            AND: [:each | (each perform: (primKeys at: n)) = (anObject perform: (primKeys at: n))]]].

                                                          aCounter := self execute: queryCount.

                                                          aCounter = 1

                                                                      ifTrue:

                                                                                  [((self cacheFor: anObject)

                                                                                             includesKey: ((self descriptorFor: anObject) primaryKeyFor: anObject)

                                                                                             withClass: anObject class)

                                                                                                         ifFalse:

                                                                                                                     [(self cacheFor: anObject)

                                                                                                                                at: ((self descriptorFor: anObject) primaryKeyFor: anObject)

                                                                                                                                ifAbsentPut: [anObject]]]

                                                                      ifFalse:

                                                                                  ["Primary key has a valid number"

                                                                                  aCounter = 0

                                                                                             ifFalse: [self error: ' no multiple instances with the same primary keys']]]].

            ^self register: anObject

deleteExisting: anObject

            "Get the real object, instantiating if necessary"

            | realObject |

            realObject := anObject glorpRealObject.

            self hasUnitOfWork

                       ifTrue: [currentUnitOfWork delete: realObject]

                       ifFalse: [self inUnitOfWorkDo: [currentUnitOfWork delete: realObject]].

            "Next Added

            Works also with multiple keys - presented as an Array"

            (self cacheFor: anObject)

                       removeKey: ((self descriptorFor: anObject) primaryKeyFor: realObject)

                       ifAbsent:

                                   [Transcript

                                               show: 'Glorp Delete was not in Cache';

                                               cr]

> "jtuchel" <[hidden email]> |