libs-gdl2/EOAccess/EODatabaseContext.m

/** 
   EODatabaseContext.m  <title>EODatabaseContext Class</title>

   Copyright (C) 2000-2002,2003,2004,2005 Free Software Foundation, Inc.

   Author: Mirko Viviani <mirko.viviani@gmail.com>
   Date: June 2000

   Author: Manuel Guesdon <mguesdon@orange-concept.com>
   Date: October 2000

   $Revision$
   $Date$

   <abstract></abstract>

   This file is part of the GNUstep Database Library.

   <license>
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.
   If not, write to the Free Software Foundation,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
   </license>
**/

#include "config.h"

RCS_ID("$Id$")

#ifdef GNUSTEP
#include <Foundation/NSArray.h>
#include <Foundation/NSDictionary.h>
#include <Foundation/NSString.h>
#include <Foundation/NSException.h>
#include <Foundation/NSValue.h>
#include <Foundation/NSZone.h>
#include <Foundation/NSNotification.h>
#include <Foundation/NSSet.h>
#include <Foundation/NSData.h>
#include <Foundation/NSKeyValueCoding.h>
#include <Foundation/NSDebug.h>
#else
#include <Foundation/Foundation.h>
#endif

#ifndef GNUSTEP
#include <GNUstepBase/GNUstep.h>
#include <GNUstepBase/NSDebug+GNUstepBase.h>
#include <GNUstepBase/NSObject+GNUstepBase.h>
#endif

#include <GNUstepBase/GSObjCRuntime.h>

#include <EOControl/EOFault.h>
#include <EOControl/EOEditingContext.h>
#include <EOControl/EOClassDescription.h>
#include <EOControl/EOGenericRecord.h>
#include <EOControl/EOQualifier.h>
#include <EOControl/EOKeyGlobalID.h>
#include <EOControl/EOFetchSpecification.h>
#include <EOControl/EOSortOrdering.h>
#include <EOControl/EOKeyValueCoding.h>
#include <EOControl/EOMutableKnownKeyDictionary.h>
#include <EOControl/EOCheapArray.h>
#include <EOControl/EONSAddOns.h>
#include <EOControl/EONull.h>
#include <EOControl/EODebug.h>

#include <EOAccess/EOAdaptor.h>
#include <EOAccess/EOAdaptorChannel.h>
#include <EOAccess/EOAdaptorContext.h>
#include <EOAccess/EOModel.h>
#include <EOAccess/EOModelGroup.h>
#include <EOAccess/EOEntity.h>
#include <EOAccess/EORelationship.h>
#include <EOAccess/EOAttribute.h>
#include <EOAccess/EOAttributePriv.h>
#include <EOAccess/EOStoredProcedure.h>
#include <EOAccess/EOJoin.h>

#include <EOAccess/EODatabase.h>
#include <EOAccess/EODatabaseContext.h>
#include <EOAccess/EODatabaseChannel.h>
#include <EOAccess/EODatabaseOperation.h>
#include <EOAccess/EOAccessFault.h>
#include <EOAccess/EOExpressionArray.h>
#include <EOAccess/EOSQLExpression.h>

#include "EOPrivate.h"
#include "EOEntityPriv.h"
#include "EOAccessFaultPriv.h"
#include "EODatabaseContextPriv.h"

#include <string.h>


#define _LOCK_BUFFER 128


NSString *EODatabaseChannelNeededNotification = @"EODatabaseChannelNeededNotification";

NSString *EODatabaseContextKey = @"EODatabaseContextKey";
NSString *EODatabaseOperationsKey = @"EODatabaseOperationsKey";
NSString *EOFailedDatabaseOperationKey = @"EOFailedDatabaseOperationKey";

NSString *EOCustomQueryExpressionHintKey = @"EOCustomQueryExpressionHintKey";
NSString *EOStoredProcedureNameHintKey = @"EOStoredProcedureNameHintKey";

static BOOL _useToManyCaching = YES;

@interface EODatabaseContext(EOObjectStoreSupportPrivate)
- (id) entityForGlobalID: (EOGlobalID *)globalID;
@end

@implementation EODatabaseContext

// Initializing instances

static Class _contextClass = Nil;

+ (void)initialize
{
  static BOOL initialized=NO;
  if (!initialized)
    {
      initialized=YES;

      GDL2_EOAccessPrivateInit();

      _contextClass = GDL2_EODatabaseContextClass;

      [[NSNotificationCenter defaultCenter]
        addObserver: self
        selector: @selector(_registerDatabaseContext:)
        name: EOCooperatingObjectStoreNeeded
        object: nil];
    }
}

+ (EODatabaseContext*)databaseContextWithDatabase: (EODatabase *)database
{
  return AUTORELEASE([[self alloc] initWithDatabase: database]);
}

+ (void)_registerDatabaseContext:(NSNotification *)notification
{
  EOObjectStoreCoordinator *coordinator = [notification object];
  EODatabaseContext *dbContext = nil;
  EOModel *model = nil;
  NSString *entityName = nil;
  id keyValue = nil;

  keyValue = [[notification userInfo] objectForKey: @"globalID"];

  if (keyValue == nil)
    keyValue = [[notification userInfo] objectForKey: @"fetchSpecification"];

  if (keyValue == nil)
    keyValue = [[notification userInfo] objectForKey: @"object"];

  if (keyValue)
    entityName = [keyValue entityName];

  if (entityName)
    model = [[[EOModelGroup defaultGroup] entityNamed:entityName] model];

  if (model == nil)
    NSLog(@"%@ -- %@ %@: No model for entity named %@",
	  NSStringFromSelector(_cmd), 
	  NSStringFromClass([self class]),
	  self,
	  entityName);

  dbContext = [EODatabaseContext databaseContextWithDatabase:
				   [EODatabase databaseWithModel: model]];

  [coordinator addCooperatingObjectStore:dbContext];
}

/*
 * this exists, see EOF 2.2 Release Notes
 * http://support.apple.com/kb/TA26740?viewlocale=en_US
 */

+ (void) _setUseToManyCaching:(BOOL) yn
{
  _useToManyCaching = yn;
}


- (void) registerForAdaptorContextNotifications: (EOAdaptorContext*)adaptorContext
{
  //OK
  [[NSNotificationCenter defaultCenter]
    addObserver: self
    selector: @selector(_beginTransaction)
    name: EOAdaptorContextBeginTransactionNotification
    object: adaptorContext];
  [[NSNotificationCenter defaultCenter]
    addObserver: self
    selector: @selector(_commitTransaction)
    name: EOAdaptorContextCommitTransactionNotification
    object: adaptorContext];

  [[NSNotificationCenter defaultCenter]
    addObserver: self
    selector: @selector(_rollbackTransaction)
    name: EOAdaptorContextRollbackTransactionNotification
    object: adaptorContext];
}

- (id) initWithDatabase: (EODatabase *)database
{
  if ((self = [self init]))
    {
      _adaptorContext = RETAIN([[database adaptor] createAdaptorContext]);

      if (_adaptorContext == nil)
        {
          NSLog(@"EODatabaseContext could not create adaptor context");
          AUTORELEASE(self);

          return nil;
        }
      _database = RETAIN(database);

      // Register this object into database
      [_database registerContext: self];
      [self setUpdateStrategy: EOUpdateWithOptimisticLocking];

      _uniqueStack = [NSMutableArray new];
      _deleteStack = [NSMutableArray new];
      _uniqueArrayStack = [NSMutableArray new];

      _registeredChannels = [NSMutableArray new];
      _batchFaultBuffer = [NSMutableDictionary new];
      _batchToManyFaultBuffer = [NSMutableDictionary new];
      _missingObjectGIDs = [NSMutableSet new];

      // We want to know when snapshots change in database
      [[NSNotificationCenter defaultCenter]
        addObserver: self
        selector: @selector(_snapshotsChangedInDatabase:)
        name: EOObjectsChangedInStoreNotification
        object: _database];

      // We want to know when objects change
      [[NSNotificationCenter defaultCenter]
        addObserver: self
        selector: @selector(_objectsChanged:)
        name: EOObjectsChangedInStoreNotification
        object: self];

      [self registerForAdaptorContextNotifications: _adaptorContext];

//???
/*NO      _snapshots = [NSMutableDictionary new];
      _toManySnapshots = [NSMutableDictionary new];
*/
      
//NO      _lock = [NSRecursiveLock new];
      
      
      /* //TODO ?
         transactionStackTop = NULL;
         transactionNestingLevel = 0;
         isKeepingSnapshots = YES;
         isUniquingObjects = [database uniquesObjects];
         [database contextDidInit:self];*/
    }



  return self;
}

/**
 * Convenience method to check if our delegate handles database exceptions 
 * or if we have to do it ourself.
 */

- (BOOL) _delegateHandledDatabaseException:(NSException *) exception
{
  if (_delegateRespondsTo.shouldHandleDatabaseException)
  {
    
    return ([_delegate databaseContext:self
         shouldHandleDatabaseException:exception] == NO);
    
  } 
  return NO;
}

- (void)_snapshotsChangedInDatabase: (NSNotification *)notification
{
  //OK EOObjectsChangedInStoreNotification EODatabase 


  if ([notification object] == _database)//??
    [[NSNotificationCenter defaultCenter]
      postNotificationName: [notification name]
      object: self
      userInfo: [notification userInfo]];//==> _objectsChanged
}


- (void)dealloc
{
  [[NSNotificationCenter defaultCenter] removeObserver: self];

  [_database unregisterContext: self];

  DESTROY(_adaptorContext);
  DESTROY(_database);

  if (_dbOperationsByGlobalID)
    {
      NSDebugMLog(@"MEMORY: dbOperationsByGlobalID count=%u",
		  NSCountMapTable(_dbOperationsByGlobalID));
      NSFreeMapTable(_dbOperationsByGlobalID);
      _dbOperationsByGlobalID = NULL;
    }
/*NO
  DESTROY(_snapshots);
  DESTROY(_toManySnapshots);
*/
  DESTROY(_uniqueStack);
  DESTROY(_deleteStack);
  DESTROY(_uniqueArrayStack);

  DESTROY(_registeredChannels);

  DESTROY(_batchFaultBuffer);
  DESTROY(_batchToManyFaultBuffer);
  DESTROY(_missingObjectGIDs);

  DESTROY(_lastEntity);

  if (_nonPrimaryKeyGenerators)
    {
      NSDebugMLog(@"MEMORY: nonPrimaryKeyGnerators count=%u",
		  NSCountHashTable(_nonPrimaryKeyGenerators));

      NSFreeHashTable(_nonPrimaryKeyGenerators);
      _nonPrimaryKeyGenerators = NULL;
    }

  if (_lockedObjects)
    {
      NSResetHashTable(_lockedObjects);
    }

  DESTROY(_lock);

  [super dealloc];
}

+ (EODatabaseContext *)registeredDatabaseContextForModel: (EOModel *)model
					  editingContext: (EOEditingContext *)editingContext
{
  EOObjectStoreCoordinator *edObjectStore;
  NSArray		   *cooperatingObjectStores;
  NSEnumerator	           *storeEnum;
  EOCooperatingObjectStore *coObjectStore;
  EODatabase		   *anDatabase;
  NSArray		   *models;
  EODatabaseContext        *dbContext = nil;



  if (model && editingContext)
    { 
      IMP enumNO=NULL; // nextObject
      edObjectStore = (EOObjectStoreCoordinator *)[editingContext rootObjectStore];
      cooperatingObjectStores = [edObjectStore cooperatingObjectStores];	// get all EODatabaseContexts

      storeEnum = [cooperatingObjectStores objectEnumerator];

      while ((coObjectStore = GDL2_NextObjectWithImpPtr(storeEnum,&enumNO)))
	{
	  if ([coObjectStore isKindOfClass: [EODatabaseContext class]])
	    {
	      anDatabase = [(EODatabaseContext *)coObjectStore database];

	      if (anDatabase && (models = [anDatabase models]))
		{
		  if ([models containsObject: model])
		    {
		      dbContext = (EODatabaseContext *)coObjectStore;
		      break;
		    }
		}
	    }
	}
      
      if (!dbContext) 
        {
          // no EODatabaseContext found, create a new one
          dbContext = [EODatabaseContext databaseContextWithDatabase:
					   [EODatabase databaseWithModel:
							 model]];

          if (dbContext)
            {
              [edObjectStore addCooperatingObjectStore: dbContext];
            }
	}
    }



  return dbContext;
}


+ (Class)contextClassToRegister
{
  NSEmitTODO();
  // TODO;
  return _contextClass;
}

+ (void)setContextClassToRegister: (Class)contextClass
{
  _contextClass = contextClass;
}

/** Returns YES if we have at least one busy channel **/
- (BOOL)hasBusyChannels
{
  BOOL busy = NO;
  NSUInteger count = 0;

  count = [_registeredChannels count];  

  if (count>0)
    {
      NSUInteger i = 0;
      IMP oaiIMP=[_registeredChannels methodForSelector: @selector(objectAtIndex:)];

      for (i = 0 ; !busy && i < count; i++)
        {
          EODatabaseChannel *channel = GDL2_ObjectAtIndexWithImp(_registeredChannels,oaiIMP,i);
          
          busy = [channel isFetchInProgress];
        }
    };

  return busy;
}

- (NSArray *)registeredChannels
{
  return _registeredChannels;
}

/*
 Adds channel to the pool of available channels used to service database requests. 
 Registered channels are retained by the receiver. 
 */

- (void)registerChannel: (EODatabaseChannel *)channel
{
//call channel databaseContext
//test if not exists  _registeredChannels indexOfObjectIdenticalTo:channel
  NSDebugLog(@"** REGISTER channel ** debug:%d ** total registered:%"PRIuPTR,
	     [[channel adaptorChannel] isDebugEnabled],
	     [_registeredChannels count] + 1);

  [_registeredChannels addObject:channel];
  [channel setDelegate: nil];
}

- (void)unregisterChannel: (EODatabaseChannel *)channel
{
  [_registeredChannels removeObjectIdenticalTo:channel];
}

/** returns a non busy channel if any, nil otherwise **/
-(EODatabaseChannel *)_availableChannelFromRegisteredChannels
{
  NSEnumerator *channelsEnum;
  EODatabaseChannel *channel = nil;
  IMP enumNO=NULL; // nextObject

  channelsEnum = [_registeredChannels objectEnumerator];

  while ((channel = GDL2_NextObjectWithImpPtr(channelsEnum,&enumNO)))
    {
      if ([channel isFetchInProgress] == NO)
        {
          return channel;
        }
      else
        {
//          NSDebugMLLog(@"EODatabaseContext",@"CHANNEL %p is busy",
//		       [channel nonretainedObjectValue]);
        }
    }

  return nil;
}

/** return a non busy channel **/
- (EODatabaseChannel *)availableChannel
{
  EODatabaseChannel *channel = nil;
  NSUInteger num = 2;

  while (!channel && num)
    {
      channel = [self _availableChannelFromRegisteredChannels];

      if (!channel)
        {
          //If not channel and last try: send a EODatabaseChannelNeededNotification notification before this last try
          if (--num)
            [[NSNotificationCenter defaultCenter]
              postNotificationName: EODatabaseChannelNeededNotification
              object: self];
        }
    }

  if ((!channel) && ([_registeredChannels count] < 1)) {
    channel = [EODatabaseChannel databaseChannelWithDatabaseContext: self];
    if (channel)
    {
      [self registerChannel:channel];
    }
    
  }

  return channel;
}

/** returns the database **/
- (EODatabase *)database
{
  return _database;
}

- (void) setCoordinator:(EOObjectStoreCoordinator *) newCoordinator
{
  [super setCoordinator: newCoordinator];

  // TODO: locking magic.
}


/** returns the adaptor context **/
- (EOAdaptorContext *)adaptorContext
{
  return _adaptorContext;
}

/** Set the update strategy to 'strategy'
May raise an exception if transaction has began or if you want pessimistic lock when there's already a snapshot recorded
**/
- (void)setUpdateStrategy: (EOUpdateStrategy)strategy
{
  if (_flags.beganTransaction)
    [NSException raise: NSInvalidArgumentException
                 format: @"%@ -- %@ 0x%x: transaction in progress", 
                 NSStringFromSelector(_cmd), 
                 NSStringFromClass([self class]),
                 self];

  //Can't set pessimistic locking where there's already snapshosts !
  if (strategy == EOUpdateWithPessimisticLocking
      && [[_database snapshots] count])
    [NSException raise: NSInvalidArgumentException
                 format: @"%@ -- %@ 0x%x: can't set EOUpdateWithPessimisticLocking when receive's EODatabase already has snapshots",
                 NSStringFromSelector(_cmd),
                 NSStringFromClass([self class]),
                 self];

  _updateStrategy = strategy;
}

/** Get the update strategy **/
- (EOUpdateStrategy)updateStrategy
{
  return _updateStrategy;
}

/** Get the delegate **/
- (id)delegate
{
  return _delegate;
}

/** Set the delegate **/
- (void)setDelegate:(id)delegate
{
  NSEnumerator *channelsEnum = [_registeredChannels objectEnumerator];
  EODatabaseChannel *channel = nil;
  IMP enumNO=NULL; // nextObject

  _delegate = delegate;

  _delegateRespondsTo.willRunLoginPanelToOpenDatabaseChannel = 
    [delegate respondsToSelector: @selector(databaseContext:willRunLoginPanelToOpenDatabaseChannel:)];
  _delegateRespondsTo.newPrimaryKey = 
    [delegate respondsToSelector: @selector(databaseContext:newPrimaryKeyForObject:entity:)];
  _delegateRespondsTo.willPerformAdaptorOperations = 
    [delegate respondsToSelector: @selector(databaseContext:willPerformAdaptorOperations:adaptorChannel:)];
  _delegateRespondsTo.shouldInvalidateObject = 
    [delegate respondsToSelector: @selector(databaseContext:shouldInvalidateObjectWithGlobalID:snapshot:)];
  _delegateRespondsTo.willOrderAdaptorOperations = 
    [delegate respondsToSelector: @selector(databaseContext:willOrderAdaptorOperationsFromDatabaseOperations:)];
  _delegateRespondsTo.shouldLockObject = 
    [delegate respondsToSelector: @selector(databaseContext:shouldLockObjectWithGlobalID:snapshot:)];
  _delegateRespondsTo.shouldRaiseForLockFailure = 
    [delegate respondsToSelector: @selector(databaseContext:shouldRaiseExceptionForLockFailure:)];
  _delegateRespondsTo.shouldFetchObjects = 
    [delegate respondsToSelector: @selector(databaseContext:shouldFetchObjectsWithFetchSpecification:editingContext:)];
  _delegateRespondsTo.didFetchObjects = 
    [delegate respondsToSelector: @selector(databaseContext:didFetchObjects:fetchSpecification:editingContext:)];
  _delegateRespondsTo.shouldFetchObjectFault = 
    [delegate respondsToSelector: @selector(databaseContext:shouldFetchObjectsWithFetchSpecification:editingContext:)];
  _delegateRespondsTo.shouldFetchArrayFault = 
    [delegate respondsToSelector: @selector(databaseContext:shouldFetchArrayFault:)];
  _delegateRespondsTo.shouldHandleDatabaseException = 
  [delegate respondsToSelector: @selector(databaseContext:shouldHandleDatabaseException:)];
  _delegateRespondsTo.databaseContextFailedToFetchObject =
  [delegate respondsToSelector: @selector(databaseContext:failedToFetchObject:globalID:)];


  while ((channel = GDL2_NextObjectWithImpPtr(channelsEnum,&enumNO)))
    [channel setDelegate: delegate];
}

- (void)handleDroppedConnection
{
  DESTROY(_adaptorContext);

  DESTROY(_registeredChannels);

  _adaptorContext = RETAIN([[[self database] adaptor] createAdaptorContext]);
  _registeredChannels = [NSMutableArray new];

}

- (NSArray *) missingObjectGlobalIDs
{
  return [_missingObjectGIDs allObjects];
}

@end


@implementation EODatabaseContext (EOObjectStoreSupport)

/** Return a fault for row 'row' **/
- (id)faultForRawRow: (NSDictionary *)row
	 entityNamed: (NSString *)entityName
      editingContext: (EOEditingContext *)context
{
  EOEntity *entity;
  EOGlobalID *gid;
  id object;



  entity = [_database entityNamed: entityName];
  gid = [entity globalIDForRow: row];

  object = [self faultForGlobalID: gid
		 editingContext: context];

  NSDebugMLLog(@"EODatabaseContext", @"object=%p of class (%@)",
	       object, [object class]);



  return object;
}

/** return entity corresponding to 'globalID' **/
- (id) entityForGlobalID: (EOGlobalID *)globalID
{
  NSString *entityName;

  entityName = [(EOKeyGlobalID *)globalID entityName];

  if ((_lastEntity) && (entityName == [_lastEntity name]))
  {
    return _lastEntity;
  }
  
  ASSIGN(_lastEntity, [_database entityNamed: entityName]);

  return _lastEntity;
}

/** Make object a fault **/
- (void) _turnToFault: (id)object
                  gid: (EOGlobalID *)globalID
       editingContext: (EOEditingContext *)context
           isComplete: (BOOL)isComplete
{
  //OK
  EOAccessFaultHandler *handler;






  NSAssert(globalID, @"No globalID");
  NSAssert1([globalID isKindOfClass: [EOKeyGlobalID class]],
	    @"globalID is not a EOKeyGlobalID but a %@",
	    [globalID class]);

  if ([(EOKeyGlobalID*)globalID areKeysAllNulls])
    NSWarnLog(@"All key of globalID %p (%@) are nulls",
              globalID,
              globalID);

  handler = [EOAccessFaultHandler
	      accessFaultHandlerWithGlobalID: (EOKeyGlobalID*)globalID
	      databaseContext: self
	      editingContext: context];


  NSDebugMLLog(@"EODatabaseContext", @"object->class_pointer=%p",
	       GSObjCClass(object));

  [EOFault makeObjectIntoFault: object
	   withHandler: handler];

  NSDebugMLLog(@"EODatabaseContext", @"object->class_pointer=%p",
	       GSObjCClass(object));

  [self _addBatchForGlobalID: (EOKeyGlobalID*)globalID
        fault: object];


  //TODO: use isComplete
}

/** Get a fault for 'globalID' **/
- (id)faultForGlobalID: (EOGlobalID *)globalID
	editingContext: (EOEditingContext *)context
{
  //Seems OK
  EOClassDescription *classDescription = nil;
  EOEntity *entity;
  id object = nil;
  BOOL isFinal;





  isFinal = [(EOKeyGlobalID *)globalID isFinal];
  entity = [self entityForGlobalID: globalID];

  NSAssert(entity, @"no entity");

  classDescription = [entity classDescriptionForInstances];



  object = [classDescription createInstanceWithEditingContext: context
			     globalID: globalID
			     zone: NULL];

  NSAssert1(object, @"No Object. classDescription=%@", classDescription);
/*mirko: NO
  NSDictionary *pk;
  NSEnumerator *pkEnum;
  NSString *pkKey;
  NSArray  *classPropertyNames;
classPropertyNames = [entity classPropertyNames];
  pk = [entity primaryKeyForGlobalID:(EOKeyGlobalID *)globalID];
  pkEnum = [pk keyEnumerator];
  while ((pkKey = [pkEnum nextObject]))
    {
      if ([classPropertyNames containsObject:pkKey] == YES)
	[obj takeStoredValue:[pk objectForKey:pkKey]
	     forKey:pkKey];
    }
*/


  if ([(EOKeyGlobalID *)globalID areKeysAllNulls])
    NSWarnLog(@"All key of globalID %p (%@) are nulls",
              globalID,
              globalID);

  [self _turnToFault: object
        gid: globalID
        editingContext: context
        isComplete: isFinal];//??
  


  EOEditingContext_recordObjectGlobalIDWithImpPtr(context,NULL,object,globalID);



  return object;
}

/** Get an array fault for globalID for relationshipName **/
- (NSArray *)arrayFaultWithSourceGlobalID: (EOGlobalID *)globalID
			 relationshipName: (NSString *)relationshipName
			   editingContext: (EOEditingContext *)context
{
  //Seems OK
  NSArray *obj = nil;

  if (![globalID isKindOfClass: [EOKeyGlobalID class]])
    {
      [NSException raise: NSInvalidArgumentException
                   format: @"%@ -- %@ The globalID %@ must be an EOKeyGlobalID to be able to construct a fault",
                   NSStringFromSelector(_cmd), 
                   NSStringFromClass([self class]),
                   globalID];
    }
  else
    {
      EOAccessArrayFaultHandler *handler = nil;

      obj = [EOCheapCopyMutableArray array];
      handler = [EOAccessArrayFaultHandler
		  accessArrayFaultHandlerWithSourceGlobalID:
		    (EOKeyGlobalID*)globalID
		  relationshipName: relationshipName
		  databaseContext: self
		  editingContext: context];

      [EOFault makeObjectIntoFault: obj
               withHandler: handler];

      [self _addToManyBatchForSourceGlobalID: (EOKeyGlobalID *)globalID
            relationshipName: relationshipName
            fault: (EOFault*)obj];
    }

  return obj;
}

- (void)initializeObject: (id)object
            withGlobalID: (EOGlobalID *)globalID
          editingContext: (EOEditingContext *)context
{
  NSDictionary * snapDict = nil;
  EOEntity     * entity = nil;

  /*
   TODO use this stuff -- dw
  if (globalID == _currentGlobalID)
  {
    snapDict = _currentSnapshot;
    entity = _lastEntity;
  } else ...
  */  
  
  if ([globalID isTemporary])
  {
    return;
  }
  
  snapDict = [self snapshotForGlobalID:globalID];
  
  if ([(EOKeyGlobalID *)globalID isFinal])
  {
    entity = [self entityForGlobalID:globalID];
  } else {
    object = [context objectForGlobalID:globalID];
    if (!object)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: @"%s No object for gid %@ in %@", __PRETTY_FUNCTION__, globalID, context];      
    }
    entity = [_database entityForObject:object];
  }

  if (!snapDict)
  {
    [NSException raise: NSInternalInconsistencyException
                format: @"%s No snapshot for gid %@", __PRETTY_FUNCTION__, globalID];      
  } else {
    
    [self initializeObject: object
                       row: snapDict
                    entity: entity
            editingContext: context];
        
    [_database incrementSnapshotCountForGlobalID:globalID];
  }
  
}

- (void) _objectsChanged: (NSNotification*)notification
{
  /*object==self EOObjectsChangedInStoreNotification
   userInfo = {
   deleted = (List Of GlobalIDs); 
   inserted = (List Of GlobalIDs); 
   updated = (List Of GlobalIDs); 
   */
  
  if ([notification object] != self)
  {
    // not sure if that ever happens -- dw
    NSEmitTODO();
    [self notImplemented: _cmd]; //TODO
  }
  else
  {
    NSMutableArray * workArray = [NSMutableArray array];
    NSDictionary   * userInfo  = [notification userInfo];
    NSArray        * myObjects = nil;
    NSUInteger       i, count;
    
    if ((myObjects = [userInfo objectForKey: EOUpdatedKey])) 
    {
      [workArray addObjectsFromArray:myObjects];
    }
    
    if ((myObjects = [userInfo objectForKey: EOInsertedKey])) 
    {
      [workArray addObjectsFromArray:myObjects];
    }
    
    if ((myObjects = [userInfo objectForKey: EODeletedKey])) 
    {
      [workArray addObjectsFromArray:myObjects];
    }
    
    if ((myObjects = [userInfo objectForKey: EOInvalidatedKey])) 
    {
      [workArray addObjectsFromArray:myObjects];
    }
    
    count = [workArray count];
        
    if (count>0)
    {
      IMP oaiIMP=[workArray methodForSelector: @selector(objectAtIndex:)];
      
      for (i = 0; i < count; i++)
      {
        EOKeyGlobalID *gid=GDL2_ObjectAtIndexWithImp(workArray,oaiIMP,i);
        NSString *entityName;
        
        if ([gid isKindOfClass:[EOKeyGlobalID class]]) {
          entityName = [gid entityName];
          
          [_database invalidateResultCacheForEntityNamed: entityName];
        }
      }
    }
    
  }
}

- (void) _snapshotsChangedInDatabase: (NSNotification*)notification
{


/*
 userInfo = {
    deleted = (List Of GlobalIDs); 
    inserted = (List Of GlobalIDs); 
    updated = (List Of GlobalIDs); 
}}
*/

  if ([notification object] != self)
    {
      [[NSNotificationCenter defaultCenter]
	postNotificationName: EOObjectsChangedInStoreNotification
	object: self
	userInfo: [notification userInfo]];
//call _objectsChanged: and ObjectStoreCoordinator _objectsChangedInSubStore: 
    }


}

- (NSArray *)objectsForSourceGlobalID: (EOGlobalID *)globalID
		     relationshipName: (NSString *)name
		       editingContext: (EOEditingContext *)context
{
  //Near OK
  NSArray *objects = nil;
  id sourceObjectFault = nil;
  id relationshipValue = nil;
  NSArray *sourceSnapshot = nil;
  NSUInteger sourceSnapshotCount = 0;





  //First get the id from which we search the source object
  sourceObjectFault = [context faultForGlobalID: globalID
			       editingContext: context];

  NSDebugMLLog(@"EODatabaseContext", @"sourceObjectFault %p=%@",
	       sourceObjectFault, sourceObjectFault);

  // Get the fault value from source object


  relationshipValue = [sourceObjectFault storedValueForKey: name];

  NSDebugMLLog(@"EODatabaseContext", @"relationshipValue %p=%@",
	       relationshipValue, relationshipValue);

  //Try to see if there is a snapshot for the source object
  sourceSnapshot = [_database snapshotForSourceGlobalID: globalID
			      relationshipName: name];

  NSDebugMLLog(@"EODatabaseContext", @"sourceSnapshot %p (%@)=%@",
	       sourceSnapshot, [sourceSnapshot class],
	       sourceSnapshot);

  sourceSnapshotCount = [sourceSnapshot count];

  if (sourceSnapshotCount > 0)
    {
      EOGlobalID *snapGID = nil;
      id snapFault = nil;
      NSUInteger i;
      IMP addObjectIMP=NULL;
      IMP oaiIMP=NULL;

      [EOFault clearFault: relationshipValue];

      // Be carefull: Never call methodForSelector before clearing fault !
      addObjectIMP=[relationshipValue methodForSelector:@selector(addObject:)];
      oaiIMP=[sourceSnapshot methodForSelector: @selector(objectAtIndex:)];
          

      for (i = 0; i < sourceSnapshotCount; i++)
        {
          snapGID = GDL2_ObjectAtIndexWithImp(sourceSnapshot,oaiIMP,i);



          snapFault = [context faultForGlobalID: snapGID
			       editingContext: context]; 

          NSDebugMLLog(@"EODatabaseContext", @"snapFault=%@",
		       snapFault);

          GDL2_AddObjectWithImp(relationshipValue,addObjectIMP,snapFault);
        }

      objects = relationshipValue;
    }
  else
    {  
      EOEntity *entity;
      EORelationship *relationship;
      NSUInteger maxBatch = 0;
      BOOL isToManyToOne = NO;
      EOEntity *destinationEntity = nil;
      EOModel *destinationEntityModel = nil;
      NSArray *models = nil;
      EOQualifier *auxiliaryQualifier = nil;
      NSDictionary *contextSourceSnapshot = nil;
      id sourceObject = nil;
      EORelationship *inverseRelationship = nil;
      EOEntity *invRelEntity = nil;
      NSArray *invRelEntityClassProperties = nil;
      NSString *invRelName = nil;
      EOQualifier *qualifier = nil;
      EOFetchSpecification *fetchSpec = nil;

      // Get the source object entity
      entity = [self entityForGlobalID: globalID];

      NSDebugMLLog(@"EODatabaseContext", @"entity name=%@",
		   [entity name]);

      //Get the relationship named 'name'
      relationship = [entity relationshipNamed: name];

      NSDebugMLLog(@"EODatabaseContext", @"relationship=%@",
		   relationship);

      //Get the max number of fault to fetch
      maxBatch = [relationship numberOfToManyFaultsToBatchFetch];

      isToManyToOne = [relationship isToManyToOne];//NO

      if (isToManyToOne)
        {
          NSEmitTODO();
          [self notImplemented: _cmd]; //TODO if isToManyToOne
        }

      //Get the fault entity (aka relationsip destination entity)
      destinationEntity = [relationship destinationEntity];
      NSDebugMLLog(@"EODatabaseContext", @"destinationEntity name=%@",
		   [destinationEntity name]);

      //Get the destination entity model
      destinationEntityModel = [destinationEntity model];

      //and _database model to verify if the destinationEntityModel is in database models
      models = [_database models];

      if ([models indexOfObjectIdenticalTo: destinationEntityModel]
	  == NSNotFound)
        {
          NSEmitTODO();
          [self notImplemented: _cmd]; //TODO error
        }

      //Get the relationship qualifier if any
      auxiliaryQualifier = [relationship auxiliaryQualifier];//nil

      if (auxiliaryQualifier)
        {
          NSEmitTODO();
          [self notImplemented: _cmd]; //TODO if auxqualif
        }

      //??
      contextSourceSnapshot = EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,globalID);

      //NSEmitTODO();
      //TODO Why first asking for faultForGlobalID and now asking objectForGlobalID ??

      sourceObject = [context objectForGlobalID: globalID];

      
      inverseRelationship = [relationship inverseRelationship];
      NSDebugMLLog(@"EODatabaseContext", @"inverseRelationship=%@",
		   inverseRelationship);

      if (!inverseRelationship)
        {
          NSEmitTODO();
          //[self notImplemented: _cmd]; //TODO if !inverseRelationship
          inverseRelationship = [relationship hiddenInverseRelationship];
	  //VERIFY (don't know if this is the good way)
        }

      invRelEntity = [inverseRelationship entity];
      invRelEntityClassProperties = [invRelEntity classProperties];
      invRelName = [inverseRelationship name];




      qualifier = [EOKeyValueQualifier qualifierWithKey: invRelName
				       operatorSelector: @selector(isEqualTo:)
				       value: sourceObject];



      fetchSpec = [EOFetchSpecification fetchSpecification];

      [fetchSpec setQualifier: qualifier];
      [fetchSpec setEntityName: [destinationEntity name]];



      objects = [context objectsWithFetchSpecification: fetchSpec
			 editingContext: context];

      [self _registerSnapshot: objects
            forSourceGlobalID: globalID
            relationshipName: name
            editingContext: context];//OK
    }




  return objects;
}

- (void)_registerSnapshot: (NSArray*)snapshot
        forSourceGlobalID: (EOGlobalID*)globalID
         relationshipName: (NSString*)name
           editingContext: (EOEditingContext*)context
{
  //OK
  NSArray *gids;



  gids = [context resultsOfPerformingSelector: @selector(globalIDForObject:)
		  withEachObjectInArray: snapshot];

  [_database recordSnapshot: gids
             forSourceGlobalID: globalID
             relationshipName: name];


}

- (void)refaultObject: object
	 withGlobalID: (EOGlobalID *)globalID
       editingContext: (EOEditingContext *)context
{


  [EOObserverCenter suppressObserverNotification];

  NS_DURING
    {
      [object clearProperties];//OK
    }
  NS_HANDLER
    {
      [EOObserverCenter enableObserverNotification];



      [localException raise];
    }
  NS_ENDHANDLER;

  [EOObserverCenter enableObserverNotification];

  if ([(EOKeyGlobalID *)globalID areKeysAllNulls])
    NSWarnLog(@"All key of globalID %p (%@) are nulls",
              globalID,
              globalID);

  [self _turnToFault: object
        gid: globalID
        editingContext: context
        isComplete: YES]; //Why YES ?

  [self forgetSnapshotForGlobalID:globalID];


}

- (void)saveChangesInEditingContext: (EOEditingContext *)context
{
  //TODO: locks ?
  NSException *exception = nil;



  [self prepareForSaveWithCoordinator: nil
	editingContext: context];

  [self recordChangesInEditingContext];

  NS_DURING
    {                  
      [self performChanges];
    }
  NS_HANDLER
    {
      NSDebugMLog(@"EXCEPTION: %@", localException);
      exception = localException;
    }
  NS_ENDHANDLER;

  //I don't know if this is really the good place to catch exception and rollback...
  if (exception)
    {
      [self rollbackChanges];
      [exception raise];
    }
  else
    [self commitChanges];


}

- (void)_fetchRelationship: (EORelationship *)relationship
               withObjects: (NSArray *)objsArray
            editingContext: (EOEditingContext *)context
{
  NSMutableArray *qualArray = nil;
  NSEnumerator *objEnum = nil;
  NSEnumerator *relEnum = nil;
  NSDictionary *snapshot = nil;
  id obj = nil;
  id relObj = nil;



  if ([objsArray count] > 0)
    {
      IMP globalIDForObjectIMP=NULL;
      IMP enumNO=NULL; // nextObject

      qualArray = [NSMutableArray arrayWithCapacity: 5];

      if ([relationship isFlattened] == YES)
        {
          NSDebugMLLog(@"EODatabaseContext",
		       @"relationship %@ isFlattened", relationship);

          relEnum = [[relationship componentRelationships] objectEnumerator];
          enumNO=NULL;
          while ((relationship = GDL2_NextObjectWithImpPtr(relEnum,&enumNO)))
            {
              // TODO rebuild object array for relationship path
              
              [self _fetchRelationship: relationship
                    withObjects: objsArray
                    editingContext: context];
            }
        }
      
      objEnum = [objsArray objectEnumerator];
      enumNO=NULL;
      while ((obj = GDL2_NextObjectWithImpPtr(objEnum,&enumNO)))
        {
          EOGlobalID* gid=nil;
          relObj = [obj storedValueForKey: [relationship name]];
          gid = EOEditingContext_globalIDForObjectWithImpPtr(context,&globalIDForObjectIMP,relObj);
          snapshot = EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,gid);
          
          [qualArray addObject: [relationship
				  qualifierWithSourceRow: snapshot]];
        }
      
      [self objectsWithFetchSpecification:
              [EOFetchSpecification
                fetchSpecificationWithEntityName:
                  [[relationship destinationEntity] name]
                qualifier: [EOAndQualifier qualifierWithQualifierArray:
					     qualArray]
                sortOrderings: nil]
            editingContext: context];
    }


}

- (NSArray*) _fetchRawRowKeyPaths:(NSArray *) rawRowKeyPaths
               fetchSpecification: (EOFetchSpecification*) fetchSpecification
                           entity: (EOEntity *) entity
                   editingContext: (EOEditingContext *) context
{
  EOAdaptorChannel * adaptorChannel = [[self availableChannel] adaptorChannel];
  NSMutableArray   * results        =  [NSMutableArray array];
  NSUInteger         fetchLimit     = 0;
  NSUInteger         rowsFetched    = 0;
  NSUInteger         keyCount       = [rawRowKeyPaths count];
  id                 messageHandler = nil;   // used to prompt the user after the fetch limit is reached.
  NSString         * hintKey = nil;
  BOOL               continueFetch  = NO;
  NSUInteger         k;
  EOSQLExpression  * expression     = nil;
    
  NSMutableArray * attributesToFetch;
  if (keyCount == 0)
  {
    // this is an NSMutableArray
    attributesToFetch = (NSMutableArray *) [entity attributesToFetch];
  } else {
    // Populate an array with the attributes we need
    attributesToFetch =  [NSMutableArray arrayWithCapacity:keyCount];
    BOOL hasNonFlattenedAttributes = NO;
    
    for (k = 0; k < keyCount; k++)
    {
      NSString * keyName = [rawRowKeyPaths objectAtIndex:k];
      EOAttribute * attr = [entity attributeNamed:keyName];
      if (!attr)
      {
        attr = [EOAttribute attributeWithParent:entity
                                     definition:keyName];

      } else {
        if ((!hasNonFlattenedAttributes) && (![attr isFlattened]))
        {
          hasNonFlattenedAttributes = YES;
        }
      }
      [attributesToFetch addObject:attr];
    }
    
    if (!hasNonFlattenedAttributes)
    {
      // check if lastObject is enouth.
      // the reference however does only checks the lastObject.
      
      EOAttribute    * attr = [attributesToFetch lastObject];
      EORelationship * relationship;
      
      if ([attr isFlattened])
      {
        relationship = [[attr _definitionArray] objectAtIndex:0];
      } else {
        NSString * lastPath = [rawRowKeyPaths lastObject];
        NSString * relName = [[lastPath componentsSeparatedByString:@"."] objectAtIndex:0];
        relationship = [entity relationshipNamed:relName];
        
        if ([relationship isFlattened])
        {
          relationship = [[relationship _definitionArray] objectAtIndex:0];
        }
      }
      
      EOJoin      * join   = [[relationship joins] lastObject];
      EOAttribute * attr2  = [join sourceAttribute];
      
      [attributesToFetch addObject:attr2];
    }
    // our channel does not support this.
    //[adaptorChannel _setRawDictionaryInitializerForAttributes:attributesToFetch];
  }
  if ((hintKey = [[fetchSpecification hints] objectForKey:@"EOCustomQueryExpressionHintKey"]))
  {
    if ([hintKey isKindOfClass:[NSString class]])
    {
      expression = [[[_adaptorContext adaptor] expressionClass] expressionForString:hintKey];
    } else {
      NSLog(@"%s - %@ is not an NSString but a %@",__PRETTY_FUNCTION__, hintKey, NSStringFromClass([hintKey class]));
    }
  } else {
    EOQualifier * qualifier = [[fetchSpecification qualifier] schemaBasedQualifierWithRootEntity:entity];
    
    if (qualifier != [fetchSpecification qualifier])
    {
      [fetchSpecification setQualifier:qualifier];
    }
  }
  if (![adaptorChannel isOpen])
  {
    [adaptorChannel openChannel];
  }
  if (expression)
  {
    [adaptorChannel evaluateExpression:expression];
    [adaptorChannel setAttributesToFetch:attributesToFetch];
  } else {
    [adaptorChannel selectAttributes:attributesToFetch
                  fetchSpecification:fetchSpecification
                                lock:NO
                              entity:entity];
  }
  
  // 0 is no fetch limit
  fetchLimit = [fetchSpecification fetchLimit];
  // TODO: check if we need to check for protocol EOMessageHandlers
  if ((fetchLimit > 0) && (([fetchSpecification promptsAfterFetchLimit]) &&
                           ([context messageHandler])))
  {
    messageHandler = [context messageHandler];
  }  
  
  
  do {
    do {
      NSMutableDictionary * dict = [adaptorChannel fetchRowWithZone:NULL];
      if (!dict) {
        break;
      }
      [results addObject:dict];
      rowsFetched++;
    } while ((fetchLimit == 0) || (rowsFetched < fetchLimit));
    
    if (!messageHandler) {
      break;
    }
    
    continueFetch = [messageHandler editingContext:context
      shouldContinueFetchingWithCurrentObjectCount:rowsFetched
                                     originalLimit:fetchLimit
                                       objectStore:self];
    
  } while (continueFetch);
  
  [adaptorChannel cancelFetch];
  
  if (_delegate)
  {
    
    [_delegate databaseContext: self
               didFetchObjects: results
            fetchSpecification: fetchSpecification
                editingContext: context];
  }
  return results;
}

- (void) _populateCacheForFetchSpecification:(EOFetchSpecification *) eofetchspecification
                              editingContext:(EOEditingContext *)eoeditingcontext
{
  NSEmitTODO();
}

- (BOOL) _validateQualifierForEvaluationInMemory:(EOQualifier *) qualifier
                                          entity:(EOEntity *)entity

{
  NSEmitTODO();
  return NO;
}

// _objectsFromEntityCacheWithFetchSpecEditingContext
- (NSArray*) _objectsFromEntityCacheWithFetchSpec:(EOFetchSpecification*) fetchSpecification
                                   editingContext: (EOEditingContext *)context
{
  NSEmitTODO();
  return nil;
}

- (void) _performPrefetchForFetchSpecification:(EOFetchSpecification*) fetchSpecification
                                editingContext:(EOEditingContext *)context
                                       results:(NSArray*) results
                                      keyPaths:(NSArray*) prefetchingRelationshipKeyPaths
{
  NSEmitTODO();
  return;
}


- (NSArray *)objectsWithFetchSpecification: (EOFetchSpecification *)fetchSpecification
			                      editingContext: (EOEditingContext *)context
{ 
  id                 messageHandler = nil;
  EODatabaseChannel *channel = nil;
  NSMutableArray *array = nil;
  NSString *entityName = nil;
  EOEntity *entity = nil;
  NSArray* rawRowKeyPaths = nil;
  NSUInteger fetchLimit=0;
  NSArray   * prefetchingRelationshipKeyPaths = nil;
  NSUInteger         rowsFetched    = 0;
  BOOL               continueFetch  = NO;

  channel = [self _obtainOpenChannel];
  
  if (_flags.beganTransaction == NO
      && _updateStrategy == EOUpdateWithPessimisticLocking)
  {
    [_adaptorContext beginTransaction];
    
    _flags.beganTransaction = YES;
  }
  
  if (_delegateRespondsTo.shouldFetchObjects == YES)
  {
    array = (id)[_delegate databaseContext: self
  shouldFetchObjectsWithFetchSpecification: fetchSpecification
                            editingContext: context];
    if (array) {
      return array;
    }
  }
  
  entityName = [fetchSpecification entityName];
  entity = [_database entityNamed: entityName];
  
  if (!entity)
  {
    return [NSArray array];
  }
  
  if ([entity isAbstractEntity] && (![fetchSpecification isDeep]))
  {
    [NSException raise:NSInternalInconsistencyException
                format:@"A FetchSpecification for an abstract entity must be 'deep'! Entity: ",
     entityName];
  }
  
  rawRowKeyPaths = [fetchSpecification rawRowKeyPaths];
  if (rawRowKeyPaths)
  {
    NSArray * rawRows = [self _fetchRawRowKeyPaths:rawRowKeyPaths
                                fetchSpecification:fetchSpecification
                                            entity:entity
                                    editingContext:context];
    return rawRows;
  } 
  
  if ((!_flags.ignoreEntityCaching) && [entity cachesObjects])
  {
    [self _populateCacheForFetchSpecification:fetchSpecification
                               editingContext:context];
  }
  
  if (((!_flags.ignoreEntityCaching) && [entity cachesObjects]) && 
      ([fetchSpecification isDeep] && 
       [self _validateQualifierForEvaluationInMemory:[fetchSpecification qualifier]
                                              entity:entity]))
  {
    return [self _objectsFromEntityCacheWithFetchSpec:fetchSpecification
                                       editingContext:context];
  }
  
  array = [NSMutableArray arrayWithCapacity: 8];
  
  [channel selectObjectsWithFetchSpecification: fetchSpecification
                                editingContext: context];
  
  // 0 is no fetch limit. if there is no limit, it makes no sense to ask
  fetchLimit = [fetchSpecification fetchLimit];
  if ((fetchLimit > 0) && (([fetchSpecification promptsAfterFetchLimit]) &&
                           ([context messageHandler])))
  {
    messageHandler = [context messageHandler];
  }  
  
  do {
    do {
      id freshObj = [channel fetchObject];
      if (!freshObj) {
        break;
      }
      [array addObject:freshObj];
      rowsFetched++;
    } while ((fetchLimit == 0) || (rowsFetched < fetchLimit));
    
    if (!messageHandler) {
      break;
    }
    
    continueFetch = [messageHandler editingContext:context
      shouldContinueFetchingWithCurrentObjectCount:rowsFetched
                                     originalLimit:fetchLimit
                                       objectStore:self];
    
  } while (continueFetch);
  
  [channel cancelFetch];
  
  prefetchingRelationshipKeyPaths = [fetchSpecification prefetchingRelationshipKeyPaths];
  
  if ((prefetchingRelationshipKeyPaths) && ([prefetchingRelationshipKeyPaths count] > 0))
  {
    [self _performPrefetchForFetchSpecification:fetchSpecification
                                 editingContext:context
                                        results:array
                                       keyPaths:prefetchingRelationshipKeyPaths];
  }
  
  if (_delegateRespondsTo.didFetchObjects == YES)
    [_delegate databaseContext: self
               didFetchObjects: array
            fetchSpecification: fetchSpecification
                editingContext: context];
  
  [channel setCurrentEditingContext:nil];
  
  return array;
}

- (BOOL)isObjectLockedWithGlobalID: (EOGlobalID *)gid
		    editingContext: (EOEditingContext *)context
{
  return [self isObjectLockedWithGlobalID: gid];
}

- (void)lockObjectWithGlobalID: (EOGlobalID *)globalID
                editingContext: (EOEditingContext *)context
{
  EOKeyGlobalID *gid = (EOKeyGlobalID *)globalID;
  EOEntity *entity = nil;
  NSDictionary *snapshot;
  EOQualifier *qualifier = nil;
  EOFetchSpecification * fetchspec = nil;

  snapshot = [self snapshotForGlobalID:gid];
  
  if (!snapshot) {
    return;
  }
  
  // test if we should continue
  
  if (((_delegateRespondsTo.shouldLockObject == YES)) &&
      (([_delegate databaseContext:self
      shouldLockObjectWithGlobalID:gid
                          snapshot:snapshot] == NO))) {
	  return;
  }
  
  NS_DURING {
    NSArray * array = nil;
    
    entity = [_database entityNamed: [gid entityName]];
    qualifier = [entity qualifierForPrimaryKey:snapshot];
    
    fetchspec = [EOFetchSpecification fetchSpecificationWithEntityName:[entity name]
                                                             qualifier:qualifier
                                                         sortOrderings:nil];
    
    [fetchspec setLocksObjects:YES];

    array = [self objectsWithFetchSpecification:fetchspec
                                 editingContext:context];
    
    if ([array count] != 1) {
      [NSException raise:NSInternalInconsistencyException 
                  format:@"Failed to lock object with gid %@", gid];
    }


  } NS_HANDLER {
    if ((!_delegateRespondsTo.shouldRaiseForLockFailure) ||
        ([_delegate databaseContext:self shouldRaiseExceptionForLockFailure:localException])) {
      
      [localException raise];
    }
  } NS_ENDHANDLER;

}

- (void)invalidateAllObjects
{
  NSDictionary *snapshots;
  NSArray *gids;

  [_database invalidateResultCache];

  snapshots = [_database snapshots];
  gids = [snapshots allKeys];
  [self invalidateObjectsWithGlobalIDs: gids];

  [[NSNotificationCenter defaultCenter]
    postNotificationName: EOInvalidatedAllObjectsInStoreNotification
    object: self];
}

- (void)invalidateObjectsWithGlobalIDs: (NSArray *)globalIDs
{
  NSMutableArray *array = nil;
  NSEnumerator *enumerator;
  EOKeyGlobalID *gid;

  if (_delegateRespondsTo.shouldInvalidateObject == YES)
    {
      IMP enumNO=NULL; // nextObject
      array = [NSMutableArray array];
      enumerator = [globalIDs objectEnumerator];

      while ((gid = GDL2_NextObjectWithImpPtr(enumerator,&enumNO)))
	{
	  if ([_delegate databaseContext: self
			 shouldInvalidateObjectWithGlobalID: gid
			 snapshot: EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,gid)] == YES)
	    [array addObject: gid];
	}
    }

  [self forgetSnapshotsForGlobalIDs: ((id)array ? (id)array : globalIDs)];
}

@end


@implementation EODatabaseContext(EOCooperatingObjectStoreSupport)

- (BOOL)ownsGlobalID: (EOGlobalID *)globalID
{
  if ([globalID isKindOfClass: [EOKeyGlobalID class]] &&
      [_database entityNamed: [(EOKeyGlobalID*) globalID entityName]])
    return YES;

  return NO;
}

- (BOOL)ownsObject: (id)object
{
  if ([_database entityForObject: object])
    return YES;

  return NO;
}

- (BOOL)ownsEntityNamed: (NSString *)entityName
{
  if ([_database entityNamed: entityName])
    return YES;

  return NO;
}

- (BOOL)handlesFetchSpecification: (EOFetchSpecification *)fetchSpecification
{
  //OK
  if ([_database entityNamed: [fetchSpecification entityName]])
    return YES;
  else
    return NO;
}
/* //Mirko:
- (EODatabaseOperation *)_dbOperationWithObject:object
				       operator:(EODatabaseOperator)operator
{
  NSMapEnumerator gidEnum;
  EODatabaseOperation *op;
  EOGlobalID *gid;

  gidEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);
  while (NSNextMapEnumeratorPair(&gidEnum, (void **)&gid, (void **)&op))
    {
      if ([[op object] isEqual:object] == YES)
	{
	  if ([op databaseOperator] == operator)
	    return op;

	  return nil;
	}
    }

  return nil;
}

- (void)_setGlobalID:(EOGlobalID *)globalID
forDatabaseOperation:(EODatabaseOperation *)op
{
  EOGlobalID *oldGlobalID = [op globalID];

  [op _setGlobalID:globalID];

  NSMapInsert(_dbOperationsByGlobalID, globalID, op);
  NSMapRemove(_dbOperationsByGlobalID, oldGlobalID);
}

- (EODatabaseOperation *)_dbOperationWithGlobalID:(EOGlobalID *)globalID
					   object:object
					   entity:(EOEntity *)entity
					 operator:(EODatabaseOperator)operator
{
  EODatabaseOperation *op;
  NSMutableDictionary *newRow;
  NSMapEnumerator gidEnum;
  EOAttribute *attribute;
  EOGlobalID *gid;
  NSString *key;
  NSArray *classProperties;
  BOOL found = NO;
  int i, count;
  id val;

  gidEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);
  while (NSNextMapEnumeratorPair(&gidEnum, (void **)&gid, (void **)&op))
    {
      if ([[op object] isEqual:object] == YES)
	{
	  found = YES;
	  break;
	}
    }

  if (found == YES)
    return op;

  if (globalID == nil)
    globalID = AUTORELEASE([[EOTemporaryGlobalID alloc] init]);

  op = AUTORELEASE([[EODatabaseOperation alloc] initWithGlobalID:globalID
						object:object
						entity:entity]);

  [op setDatabaseOperator:operator];
  [op setDBSnapshot:EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,globalID)];

  newRow = [op newRow];

  classProperties = [entity classProperties];

  count = [classProperties count];
  if (count>0)
    {
      IMP oaiIMP=[classProperties methodForSelector: @selector(objectAtIndex:)];
          
      for (i = 0; i < count; i++)
        {
          attribute = GDL2_ObjectAtIndexWithImp(classProperties,oaiIMP,i);
          if ([attribute isKindOfClass:GDL2_EOAttributeClass] == NO)
            continue;
          
          key = [attribute name];
          
          if ([attribute isFlattened] == NO)
            {
              val = [object storedValueForKey:key];
              
              if (val == nil)
                val = GDL2_EONull;
              
              [newRow setObject:val forKey:key];
            }
        }
    };

  NSMapInsert(_dbOperationsByGlobalID, globalID, op);

  return op;
}

*/


// private
- (NSArray*) _batchNewPrimaryKeysWithEntity:(EOEntity *) eoentity 
                                      count:(NSUInteger) i
{
  NSArray * nsarray = nil;
  
  NS_DURING {
    nsarray = [[[self _obtainOpenChannel] adaptorChannel] primaryKeysForNewRowsWithEntity:eoentity
                                                                                    count:i];
  } NS_HANDLER {
    if ([self _delegateHandledDatabaseException:localException])
    {
      nsarray = [[[self _obtainOpenChannel] adaptorChannel] primaryKeysForNewRowsWithEntity:eoentity
                                                                                      count:i];
    } else {
      if ([[_database adaptor] isDroppedConnectionException:localException])
      {
        [_database handleDroppedConnection];
        nsarray = [[[self _obtainOpenChannel] adaptorChannel] primaryKeysForNewRowsWithEntity:eoentity
                                                                                        count:i];
      } else {
        [localException raise];
      }
    }
  } NS_ENDHANDLER;
  
  return nsarray;
}

// Prepares to save changes.  Obtains primary keys for any inserted objects
// in the EditingContext that are owned by this context.
- (void)prepareForSaveWithCoordinator: (EOObjectStoreCoordinator *)coordinator
                       editingContext: (EOEditingContext *)context
{
  NSArray *insertedObjects = nil;
  NSUInteger count = 0, idx = 0;
  NSMutableDictionary * rootDict = nil;
  
  NSAssert(context, @"No editing context");
  
  if (_flags.preparingForSave)
  {
    [NSException raise:NSInternalInconsistencyException
                format:@"%s %@ is currently saving for %@ so it cannot prepare to save for %@.",
     __PRETTY_FUNCTION__, self, _editingContext, context];
  }
  
  if (coordinator)
  {
    EOObjectStoreCoordinator * oldCoordinator = [self coordinator];
    if (!oldCoordinator)
    {
      [self setCoordinator:coordinator];
    } else {
      if (oldCoordinator != coordinator)
      {
        [NSException raise:NSInternalInconsistencyException
                    format:@"%s %@ already has an EOObjectStoreCoordinator. "
         @"The database context needs to be removed from the cooperating object stores "
         @"before it can be assigned to a different coordinator.",
         __PRETTY_FUNCTION__, self];        
      }
    }
  }
  
  _flags.willPrepareForSave = NO;
  _flags.preparingForSave = YES;
  _editingContext=context;//RETAIN ?
  
  if ([_missingObjectGIDs count] > 0)
  {
    NSArray    * updatedObjects = [_editingContext updatedObjects];
    NSUInteger   idx = [updatedObjects count];
    for (; idx > 0; idx--)
    {
      EOGlobalID * globalid = [_editingContext globalIDForObject:[updatedObjects objectAtIndex:idx-1]];
      if ([_missingObjectGIDs member:globalid] != nil)
      {
        [NSException raise:NSObjectNotAvailableException
                    format:@"%s Cannot save the object with globalID %@. "
         @"The row referenced by this globalID was missing from the database at the time a fetch was attempted. "
         @"Either it was removed from the database after this application got a pointer to it, or there is a "
         @"referential integrity problem with your database. To be notified when fetches fail, implement a "
         @"delegate on EODatabaseContext that responds to"
         @"databaseContext:failedToFetchObject:globalID:.",
         __PRETTY_FUNCTION__, globalid];                
      }
    }
  }
  
  // First, create dbOperation map if there's none
  if (!_dbOperationsByGlobalID)
    _dbOperationsByGlobalID = NSCreateMapTable(NSObjectMapKeyCallBacks, 
                                               NSObjectMapValueCallBacks,
                                               32);
  
  // Next, build list of Entity which need PK generator
  [self _buildPrimaryKeyGeneratorListForEditingContext: context];
  
  // Now get newly inserted objects
  // For each object, we will recordInsertForObject: and relay PK if it is !nil
  insertedObjects = [context insertedObjects];
  
  ASSIGN(_checkPropagatedPKs, [NSMutableArray array]);
  rootDict = [NSMutableDictionary dictionary];
  
  count = [insertedObjects count];
  if (count>0)
  {
    IMP oaiIMP=[insertedObjects methodForSelector: @selector(objectAtIndex:)];
    
    for (idx = 0; idx< count; idx++)
    {
      EOCustomObject * object = GDL2_ObjectAtIndexWithImp(insertedObjects,oaiIMP,idx);
      EOEntity       * entity = [_database entityForObject:object];
      
      if (!entity)
      {
        continue;
      }
      
      [self recordInsertForObject: object];
      
      if ([self _shouldGeneratePrimaryKeyForEntityName:[entity name]])
      {
        NSDictionary   * objectPK = nil;
        
        objectPK = [self _primaryKeyForObject: object
                               raiseException: NO];
        if (!objectPK)
        {
          NSString * rootName = [[entity rootParent] name];
          NSMutableArray * rootPKArray = [rootDict objectForKey:rootName];
          if (!rootPKArray)
          {
            rootPKArray = [NSMutableArray array];
            [rootDict setObject:rootPKArray 
                         forKey:rootName];
          }
          [rootPKArray addObject:object];
        } else {
          [[[self databaseOperationForObject: object] newRow] addEntriesFromDictionary:objectPK];
          
          [self relayPrimaryKey: objectPK
                         object: object
                         entity: entity];              
        }
      } else {
        [_checkPropagatedPKs addObject:object];
      }
    }
  }
  
  if ([rootDict count]) {
    NSEnumerator * keyEnumerator = [rootDict keyEnumerator];
    NSString     * key = nil;
    
    while ((key = [keyEnumerator nextObject]))
    {
      NSMutableArray * rootPKArray = [rootDict objectForKey:key];
      NSUInteger       keyCount = [rootPKArray count];
      NSUInteger       i = 0;
      NSArray * newPKs = [self _batchNewPrimaryKeysWithEntity:[_database entityNamed:key]
                                                        count:keyCount];
      
      if ((!newPKs) || ([newPKs count] != keyCount))
      {
        [NSException raise:NSInternalInconsistencyException
                    format:@"Adaptor %@ "
         @"failed to provide new primary keys for entity '%@'.",
         [_database adaptor], key];        
      }
      
      for (i=0; i < keyCount; i++) {
        NSDictionary   * newPKDict = [newPKs objectAtIndex:i];
        EOCustomObject * eo = [rootPKArray objectAtIndex:i];
        
        [[[self databaseOperationForObject: eo] newRow] addEntriesFromDictionary:newPKDict];
        
        [self relayPrimaryKey: newPKDict
                       object: eo
                       entity: [_database entityForObject:eo]];                            
      }
    }          
  }
}

// PRIVATE

- (void) _patchUpPK:(EODatabaseOperation *) op
{
  if (!op)
  {
    return;
  }
  
  if (([op databaseOperator] == EODatabaseInsertOperator))
  {
    NSMutableDictionary * newRowDict = [op newRow];
    EOEntity            * entity = [op entity];
    EOCustomObject      * eo = [op object];
    NSArray             * pkAttributes = [entity primaryKeyAttributeNames];
    BOOL                  isEONull = NO;
    NSUInteger            i = 0;
    NSUInteger            pkCount = [pkAttributes count];
    
    
    for (; i < pkCount; i++) {
      if (([newRowDict objectForKey:[pkAttributes objectAtIndex:i]] == GDL2_EONull))
      {
        isEONull = YES;
        break;
      }
    }
    
    if (isEONull)
    {
      NSArray    * relationships = [entity relationships];
      NSUInteger   relCount = [relationships count];
      
      for (i = 0; i < relCount; i++)
      {
        EORelationship * relationship = [relationships objectAtIndex:i];
        EORelationship * inverseRelationship = [relationship inverseRelationship];
        EOCustomObject * relEO = nil;
        
        if ((!inverseRelationship) || (![inverseRelationship propagatesPrimaryKey]))
        {
          continue;
        }
        
        relEO = [eo valueForKey:[relationship name]];
        
        if (relEO)
        {
          [self relayAttributesInRelationship:inverseRelationship
                                 sourceObject:relEO
                            destinationObject:eo];
        }
      }
      
    }
  }
}

- (void)recordChangesInEditingContext
{
  //_EOAssertSafeMultiThreadedAccess
  
  [self _assertValidStateWithSelector:
   @selector(recordChangesInEditingContext)];
  
  
  NSArray * insertedObjects = [_editingContext insertedObjects];
  NSArray * deletedObjects = [_editingContext deletedObjects];
  NSArray * newObjects = nil;
  
  NSUInteger i = 0;
  
  for (i = [deletedObjects count]; i > 0; i--)
  {
    EOCustomObject * eo = [deletedObjects objectAtIndex:i - 1];
    EOEntity       * eoentity = [_database entityForObject:eo];
    NSArray        * relationships = nil;
    NSUInteger       idx = 0;

    if (!eoentity)
    {
      continue;
    }
    
    relationships = [eoentity relationships];
    
    for (idx = [relationships count]; idx > 0; idx--)
    {
      NSDictionary   * currentCSnapDict = nil;
      EORelationship * relationship = [relationships objectAtIndex:idx-1];

      if (![relationship isToManyToOne])
      {
        continue;
      }
      currentCSnapDict = [self _currentCommittedSnapshotForObject:eo];

      if (currentCSnapDict)
      {
        NSArray * destinationObjects = [currentCSnapDict objectForKey:[relationship name]];
        if (((id)destinationObjects == GDL2_EONull)) {
          destinationObjects = nil;
        }
        [self nullifyAttributesInRelationship:relationship
                                 sourceObject:eo
                           destinationObjects:destinationObjects];
        
      }
    }
    
    [self recordDeleteForObject:eo];
  }
  
  newObjects = [[_editingContext updatedObjects] arrayByAddingObjectsFromArray:insertedObjects];
  for (i = [newObjects count]; i > 0; i--)
  {
    EOCustomObject * eo = [newObjects objectAtIndex:i-1];
    EOEntity       * eoentity = [_database entityForObject:eo];
    NSDictionary   * updatedEOSnap = nil;
    NSDictionary   * currentCSnapDict = nil;

    NSArray      * relationships = nil;
    NSDictionary * dbSnapshotDict = nil;
    NSUInteger     relCount = 0;
    NSUInteger     idx = 0;
    
    if (!eoentity)
    {
      continue;
    }
    
    [self recordUpdateForObject:eo
                        changes:nil];
    
    updatedEOSnap = [eo snapshot];

    if (!updatedEOSnap)
    {
      updatedEOSnap = [NSDictionary dictionary];
    }
    
    currentCSnapDict = [self _currentCommittedSnapshotForObject:eo];

    if (!currentCSnapDict)
    {
      currentCSnapDict = [NSDictionary dictionary];
    }
    if ([self _shouldGeneratePrimaryKeyForEntityName:[eoentity name]])
    {
      NSDictionary * primaryKeyDict = [self _primaryKeyForObject:eo];
      if (primaryKeyDict)
      {
        [[[self databaseOperationForObject:eo] newRow] addEntriesFromDictionary:primaryKeyDict];
      }
    }

    relationships = [eoentity relationships];
    relCount = [relationships count];

    for (idx = 0; idx < relCount; idx++)
    {
      EORelationship * relationship = nil;
      EORelationship * substRelationship = nil;
      NSArray        * classProperties = nil;
      id               updatedSnapValue = nil;
      id               currentSnapValue = nil;
      
      if (!dbSnapshotDict)
      {
        dbSnapshotDict = [[self databaseOperationForObject:eo] dbSnapshot];
      }

      relationship = [relationships objectAtIndex:idx];
      substRelationship = [relationship _substitutionRelationshipForRow:dbSnapshotDict];

      if (!substRelationship)
      {
        continue;
      }
      
      classProperties = [eoentity classProperties];

      if (([classProperties indexOfObject:substRelationship] == NSNotFound))
      {
        continue;
      }
      
      updatedSnapValue = [updatedEOSnap objectForKey:[substRelationship name]];

      if (updatedSnapValue == GDL2_EONull) 
      {
        updatedSnapValue = nil;
      }
      
      currentSnapValue = [currentCSnapDict objectForKey:[substRelationship name]];

      if (currentSnapValue == GDL2_EONull) 
      {
        currentSnapValue = nil;
      }
      
      if ([substRelationship isToMany])
      {
        NSArray        * updatedSnapValues = (NSArray*) updatedSnapValue;
        NSArray        * currentSnapValues = (NSArray*) currentSnapValue;
        NSMutableArray * snapsToUse        = nil;
        
        if (((updatedSnapValues == currentSnapValues)) || 
            ([currentSnapValues isEqualToArray:updatedSnapValues])) // TODO: check if isEqual is ok too.
        {
          continue;
        }
        
        if (!updatedSnapValues) {
          snapsToUse = (NSMutableArray*) currentSnapValues;
        } else {
          if (currentSnapValues) {
            snapsToUse = [NSMutableArray arrayWithArray:currentSnapValues];
            [snapsToUse removeObjectsInArray:updatedSnapValues];
          }
        }
        
        if ((_useToManyCaching && (snapsToUse)) && ([snapsToUse count] > 0))
        {
          EODatabaseOperation * updatedEoDbOp = [self databaseOperationForObject:eo];
          NSUInteger            valCount = [updatedSnapValues count];
          NSMutableArray      * globalids = [NSMutableArray arrayWithCapacity:valCount];
          NSUInteger            x = 0;
          
          for (; x < valCount; x++) {
            EOCustomObject * updatedEo = [updatedSnapValues objectAtIndex:x];
            EOGlobalID     * globalid = [_editingContext globalIDForObject:updatedEo];
            
            if ((!globalid) || ([globalid isTemporary]))
            {
              globalids = nil;
              break;
            }
            [globalids addObject:globalid];
          } 
          
          [updatedEoDbOp recordToManySnapshot:globalids
                             relationshipName:[relationship name]];
        }
        [self nullifyAttributesInRelationship:substRelationship
                                 sourceObject:eo
                           destinationObjects:snapsToUse];        
        continue;
      }
      if (updatedSnapValue != currentSnapValue)
      {
        [self nullifyAttributesInRelationship:substRelationship
                                 sourceObject:eo
                           destinationObjects:currentSnapValue];                
      }
    }
    
  } // for updated objs
    
  for (i = [newObjects count]; i > 0; i--)
  {
    EOCustomObject * updatedEO = [newObjects objectAtIndex:i-1];
    EOEntity       * updatedEntity = [_database entityForObject:updatedEO];
    NSDictionary   * updateSnapDict = nil;
    NSDictionary   * comSnapUpdatedEO = nil;
    NSArray        * updatedEntityRelationships = nil;
    NSDictionary   * updatedEntitySnapshot = nil;
    NSUInteger       updatedEntityRelCount = 0;
    NSUInteger       relIdx = 0;
    
    if (updatedEntity == nil)
    {
      continue;
    }

    [self recordUpdateForObject:updatedEO
                        changes:nil];

    updateSnapDict = [updatedEO snapshot];

    if (!updateSnapDict)
    {
      updateSnapDict = [NSDictionary dictionary];
    }

    comSnapUpdatedEO = [self _currentCommittedSnapshotForObject:updatedEO];

    if (!comSnapUpdatedEO)
    {
      comSnapUpdatedEO = [NSDictionary dictionary];
    }

    updatedEntityRelationships = [updatedEntity relationships];

    updatedEntityRelCount = [updatedEntityRelationships count];
    
    for (relIdx = 0; relIdx < updatedEntityRelCount; relIdx++)
    {
      EORelationship * updatedEntityRel = nil;
      EORelationship * substitutionRel = nil;
      id               updatedSnapValue = nil;
      id               currentSnapValue = nil;
      
      if (!updatedEntitySnapshot)
      {
        updatedEntitySnapshot = [[self databaseOperationForObject:updatedEO] dbSnapshot];
      }
      
      updatedEntityRel = [updatedEntityRelationships objectAtIndex:relIdx];
      substitutionRel = [updatedEntityRel _substitutionRelationshipForRow:updatedEntitySnapshot];
      
      if ((!substitutionRel) || ([[updatedEntity classProperties] indexOfObject:substitutionRel] == NSNotFound))
      {
        continue;
      }
      
      updatedSnapValue = [updateSnapDict objectForKey:[substitutionRel name]];

      if (updatedSnapValue == GDL2_EONull)
      {
        updatedSnapValue = nil;
      }
      
      currentSnapValue = [comSnapUpdatedEO objectForKey:[substitutionRel name]];

      if (currentSnapValue == GDL2_EONull)
      {
        currentSnapValue = nil;
      }
      
      if ([substitutionRel isToMany])
      {
        NSArray        * updatedSnapValues = (NSArray*) updatedSnapValue;
        NSArray        * currentSnapValues = (NSArray*) currentSnapValue;
        NSMutableArray * snaps = nil;

        if ((updatedSnapValues == currentSnapValues) || 
            [currentSnapValues isEqualToArray:updatedSnapValues])
        {
          continue;
        }

        if (!currentSnapValues) {
          snaps = (NSMutableArray*) updatedSnapValues;
        } else {
          snaps = [NSMutableArray arrayWithArray:updatedSnapValues];
          [snaps removeObjectsInArray:currentSnapValues];
        }
        
        if ((_useToManyCaching && (snaps)) && ([snaps count] > 0))
        {
          EODatabaseOperation * updatedEoDbOp = [self databaseOperationForObject:updatedEO];
          NSUInteger valCount = [updatedSnapValues count];
          NSUInteger y = 0;
          NSMutableArray * gidArray = [NSMutableArray arrayWithCapacity:valCount];

          for (; y < valCount; y++) 
          {
            EOGlobalID * gid = [_editingContext globalIDForObject:[updatedSnapValues objectAtIndex:y]];
            
            if ((!gid) || ([gid isTemporary]))
            {
              gidArray = nil;
              break;
            }
            [gidArray addObject:gid];
          }
          
          [updatedEoDbOp recordToManySnapshot:gidArray
                             relationshipName:[updatedEntityRel name]];

        }
        [self relayAttributesInRelationship:substitutionRel
                               sourceObject:updatedEO
                         destinationObjects:snaps];
        continue;
      }
      if (updatedSnapValue != currentSnapValue)
      {
        [self relayAttributesInRelationship:substitutionRel
                               sourceObject:updatedEO
                          destinationObject:updatedSnapValue];
      }
    }
    
  }
  
  if (_checkPropagatedPKs)
  {
    NSUInteger pkCount = [_checkPropagatedPKs count];
    
    for (i = 0; i < pkCount; i++)
    {
      EOCustomObject * eo = [_checkPropagatedPKs objectAtIndex:i];
      [self _patchUpPK:[self databaseOperationForObject:eo]];
    }
    
  }
  _checkPropagatedPKs = nil;
}


/** Contructs a list of EODatabaseOperations for all changes in the EOEditingContext
that are owned by this context.  Forward any relationship changes discovered
but not owned by this context to the coordinator.
**/
- (void)recordUpdateForObject: (id)object
                      changes: (NSDictionary *)changes
{
  EODatabaseOperation *dbOpe = nil;
  
  NSAssert(object, @"No object");
  
  [self _assertValidStateWithSelector:
   @selector(recordUpdateForObject:changes:)];
  
  dbOpe = [self databaseOperationForObject: object];
    
  if (dbOpe) {
    [dbOpe setDatabaseOperator:EODatabaseUpdateOperator];
    if ((changes) && ([changes count]))
    {
      [[dbOpe newRow] addEntriesFromDictionary: changes];
    }
  } else {
    [[self coordinator] forwardUpdateForObject:object
                                       changes:changes];
  }
}

-(void)recordInsertForObject: (id)object
{
  NSDictionary *snapshot = nil;
  EODatabaseOperation *dbOpe = nil;

  dbOpe = [self databaseOperationForObject: object];
  [dbOpe setDatabaseOperator: EODatabaseInsertOperator];

  snapshot = [dbOpe dbSnapshot];

  if ([snapshot count] != 0)
  {
    [NSException raise:NSInternalInconsistencyException
                format:@"%s found a snapshot for EO with Global ID: %@ that has been inserted into %@."
     @"Cannot insert an object that is already in the database",
     __PRETTY_FUNCTION__, [dbOpe globalID], _editingContext];
  }

}

- (void) recordDeleteForObject: (id)object
{
  NSDictionary *snapshot = nil;
  EODatabaseOperation *dbOpe = nil;
  
  dbOpe = [self databaseOperationForObject: object];
  
  [dbOpe setDatabaseOperator: EODatabaseDeleteOperator];
  
  snapshot = [dbOpe dbSnapshot];
  
  if (([snapshot count] == 0))
  {
    [NSException raise:NSInternalInconsistencyException
                format:@"%s failed to find a snapshot for EO with Global ID: %@ that has been deleted from %@."
     @"Cannot delete an object that has not been fetched from the database",
     __PRETTY_FUNCTION__, [dbOpe globalID], _editingContext];
  }
}

/** Constructs EOAdaptorOperations for all EODatabaseOperations constructed in
during recordChangesInEditingContext and recordUpdateForObject:changes:.
Performs the EOAdaptorOperations on an available adaptor channel.
If the save is OK, updates the snapshots in the EODatabaseContext to reflect
the new state of the server.
Raises an exception is the adaptor is unable to perform the operations.
**/
- (void)performChanges
{
  NSMapEnumerator dbOpeEnum;
  EOGlobalID *gid = nil;
  EODatabaseOperation *dbOpe = nil;
  NSArray *orderedAdaptorOperations = nil;



  NSDebugMLLog(@"EODatabaseContext",
	       @"self=%p preparingForSave=%d beganTransaction=%d",
	       self,
	       (int)_flags.preparingForSave,
	       (int)_flags.beganTransaction);

  [self _assertValidStateWithSelector: @selector(performChanges)];

  dbOpeEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);

  while (NSNextMapEnumeratorPair(&dbOpeEnum, (void **)&gid, (void **)&dbOpe))
  {

    
    //REVOIR
    if ([dbOpe databaseOperator] == EODatabaseNothingOperator)
    {
      NSDebugMLLog(@"EODatabaseContext", @"Db Ope %@ for Nothing !!!",
                   dbOpe);
    }
    else
    {
      [self _verifyNoChangesToReadonlyEntity: dbOpe];
      //MIRKO snapshot = [op dbSnapshot];
      [self createAdaptorOperationsForDatabaseOperation: dbOpe];
    }
  }
  // avoid leaks! -- dw
  NSEndMapTableEnumeration(&dbOpeEnum);
  
  NSDebugMLLog(@"EODatabaseContext", @"orderedAdaptorOperations A=%@",
	       orderedAdaptorOperations);

  orderedAdaptorOperations = [self orderAdaptorOperations];

  NSDebugMLLog(@"EODatabaseContext", @"orderedAdaptorOperations B=%@",
	       orderedAdaptorOperations);
  NSDebugMLLog(@"EODatabaseContext",
	       @"self=%p preparingForSave=%d beganTransaction=%d",
	       self,
	       (int)_flags.preparingForSave,
	       (int)_flags.beganTransaction);

  if ([orderedAdaptorOperations count] > 0)
    {
      EOAdaptorChannel *adaptorChannel = nil;
      EODatabaseChannel *dbChannel = [self _obtainOpenChannel];

      NSDebugMLLog(@"EODatabaseContext",
		   @"self=%p preparingForSave=%d beganTransaction=%d",
		   self,
		   (int)_flags.preparingForSave,
		   (int)_flags.beganTransaction);                   

      if (_flags.beganTransaction == NO)//MIRKO
	{
          NSDebugMLLog(@"EODatabaseContext",
		       @"self=%p [_adaptorContext transactionNestingLevel]=%d",
		       self,
		       (int)[_adaptorContext transactionNestingLevel]);

          if ([_adaptorContext transactionNestingLevel] == 0) //??
            [_adaptorContext  beginTransaction];

          NSDebugMLLog(@"EODatabaseContext",
		       @"BEGAN TRANSACTION FLAG==>YES");

	  _flags.beganTransaction = YES;
        }

      adaptorChannel = [dbChannel adaptorChannel];

      if (_delegateRespondsTo.willPerformAdaptorOperations == YES)
	orderedAdaptorOperations = [_delegate databaseContext: self
                                              willPerformAdaptorOperations:
						orderedAdaptorOperations
                                              adaptorChannel: adaptorChannel];
      NS_DURING
        {
          NSDebugMLLog(@"EODatabaseContext",
		       @"performAdaptorOperations:");
          NSDebugMLLog(@"EODatabaseContext",
		       @"self=%p preparingForSave=%d beganTransaction=%d",
		       self,
		       (int)_flags.preparingForSave,
		       (int)_flags.beganTransaction);

          [adaptorChannel performAdaptorOperations: orderedAdaptorOperations];

          NSDebugMLLog(@"EODatabaseContext",
		       @"self=%p preparingForSave=%d beganTransaction=%d",
		       self,
		       (int)_flags.preparingForSave,
		       (int)_flags.beganTransaction);
          NSDebugMLLog(@"EODatabaseContext",
		       @"after performAdaptorOperations:");
        }
      NS_HANDLER
	{
          NSDebugMLLog(@"EODatabaseContext",
		       @"Exception in performAdaptorOperations:%@",
		       localException);
          [localException raise];
          //MIRKO
          //TODO
          /*
            NSException *exp;
            NSMutableDictionary *userInfo;
            EOAdaptorOperation *adaptorOp;

            userInfo = [NSMutableDictionary dictionaryWithCapacity:10];
            [userInfo addEntriesFromDictionary:[localException userInfo]];
            [userInfo setObject:self forKey:EODatabaseContextKey];
            [userInfo setObject:dbOps
            forKey:EODatabaseOperationsKey];

            adaptorOp = [userInfo objectForKey:EOFailedAdaptorOperationKey];

            dbEnum = [dbOps objectEnumerator];
            while ((op = [dbEnum nextObject]))
	    if ([[op adaptorOperations] containsObject:adaptorOp] == YES)
            {
            [userInfo setObject:op
            forKey:EOFailedDatabaseOperationKey];
            break;
            }

            exp = [NSException exceptionWithName:EOGeneralDatabaseException
            reason:[NSString stringWithFormat:
            @"%@ -- %@ 0x%x: failed with exception name:%@ reason:\"%@\"", 
            NSStringFromSelector(_cmd),
            NSStringFromClass([self class]),
            self, [localException name],
            [localException reason]]
            userInfo:userInfo];

            [exp raise];
          */
	}
      NS_ENDHANDLER;
    
//This is not done by mirko:
      NSDebugMLLog(@"EODatabaseContext",
		   @"self=%p preparingForSave=%d beganTransaction=%d",
		   self,
		   (int)_flags.preparingForSave,
		   (int)_flags.beganTransaction);
      NSDebugMLLog(@"EODatabaseContext",
		   @"self=%p _uniqueStack %p=%@",
		   self, _uniqueStack, _uniqueStack);

      dbOpeEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);

      while (NSNextMapEnumeratorPair(&dbOpeEnum, (void **)&gid,
				     (void **)&dbOpe))
        {
          EODatabaseOperator databaseOperator = EODatabaseNothingOperator;

          //call dbOpe adaptorOperations ?
          if ([dbOpe databaseOperator] == EODatabaseNothingOperator)
            {
              NSDebugMLLog(@"EODatabaseContext",
			   @"Db Ope %@ for Nothing !!!", dbOpe);
            }
          else
            {
              EOEntity *entity = nil;
              NSArray *dbSnapshotKeys = nil;
              NSMutableDictionary *newRow = nil;
              NSDictionary *values = nil;
              id object = nil;
              NSArray *adaptorOpe = nil;



              object = [dbOpe object];
              adaptorOpe = [dbOpe adaptorOperations];
              databaseOperator = [dbOpe databaseOperator];
              entity = [dbOpe entity];
              dbSnapshotKeys = [entity dbSnapshotKeys];

              NSDebugMLLog(@"EODatabaseContext", @"dbSnapshotKeys=%@",
			   dbSnapshotKeys);

              newRow = [dbOpe newRow];


              values = [newRow dictionaryWithValuesForKeys: dbSnapshotKeys];
              //if update: forgetSnapshotForGlobalID:

              [self recordSnapshot: values
                    forGlobalID: gid];

              if (databaseOperator == EODatabaseUpdateOperator) //OK for update //Do it forInsert too //TODO
                {
                  NSDictionary *toManySnapshots = [dbOpe toManySnapshots];

                  if (toManySnapshots)
                    {
                      NSDebugMLog(@"toManySnapshots=%@", toManySnapshots);
                      NSEmitTODO();

                      //TODONOW [self notImplemented: _cmd]; //TODO
                    }
                }
            }
        }
      // avoid leaks! -- dw
      NSEndMapTableEnumeration(&dbOpeEnum);
    }


}

- (void) commitChanges
{
  NSMapEnumerator dbOpeEnum;
  EOGlobalID *gid = nil;
  EODatabaseOperation *dbOpe = nil;  
  NSMutableArray *deletedObjects = [NSMutableArray array];
  NSMutableArray *insertedObjects = [NSMutableArray array];
  NSMutableArray *updatedObjects = [NSMutableArray array];
  NSMutableDictionary *gidChangedUserInfo = nil;
  NSMutableDictionary *gidChangedUserInfo2 = nil;
  
  [self _assertValidStateWithSelector: @selector(commitChanges)];
  
  // before we send new changes to the database,
  // make sure we have commited everything
  
  NS_DURING {
    if ([_adaptorContext hasOpenTransaction]) {
      [_adaptorContext commitTransaction];
      _flags.beganTransaction = NO;
    }
  } NS_HANDLER {
    [self rollbackChanges];
    [localException raise];
    
  } NS_ENDHANDLER;
  // useToManyCaching ?
  
  [EOObserverCenter suppressObserverNotification];
  dbOpeEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);
  
  NS_DURING {
    while (NSNextMapEnumeratorPair(&dbOpeEnum, (void **)&gid,
                                   (void **)&dbOpe))
    {
      EODatabaseOperator databaseOperator = EODatabaseNothingOperator;
      EOGlobalID *dbOpeGID = nil;
      EOGlobalID *newGID = nil;
      EOEntity *entity = nil;
      NSDictionary *newRowValues = nil;
      NSMutableDictionary *newRow = [dbOpe newRow];

      databaseOperator = [dbOpe databaseOperator];
      entity = [dbOpe entity];
      
      
      if ([gid isTemporary] || ([[dbOpe primaryKeyDiffs] count] > 0))
      {
        newGID = [entity globalIDForRow: newRow
                                isFinal: YES];
        if (!gidChangedUserInfo)
        {
          gidChangedUserInfo = [NSMutableDictionary dictionary];
        }
        [gidChangedUserInfo setObject: newGID
                               forKey: gid];
      }
      
      switch (databaseOperator)
      {
        case EODatabaseInsertOperator:
          
          newRowValues = [newRow dictionaryWithValuesForKeys:[entity classPropertyAttributeNames]];
          break;
          
        case EODatabaseUpdateOperator:
          newRowValues = [dbOpe rowDiffsForAttributes: [entity _classPropertyAttributes]];
//          NSLog(@"%s %d _classPropertyAttributes %@",__PRETTY_FUNCTION__, __LINE__, [entity _classPropertyAttributes] );
//          NSLog(@"%s %d newRowValues %@",__PRETTY_FUNCTION__, __LINE__, newRowValues );
          break;
        default: 
          break;
      }
      id object = [dbOpe object];
      if (object)
      {
        if ((newRowValues) && ([newRowValues count] > 0))
        {
          [object takeStoredValuesFromDictionary:newRowValues];
        }
        if (databaseOperator == EODatabaseInsertOperator)
        {
          [_database incrementSnapshotCountForGlobalID:dbOpeGID];
        }
      }
    } // while
  } NS_HANDLER {
    [EOObserverCenter enableObserverNotification];
    NSEndMapTableEnumeration(&dbOpeEnum);
    [localException raise];
  } NS_ENDHANDLER;
  
  [EOObserverCenter enableObserverNotification];
  NSEndMapTableEnumeration(&dbOpeEnum);

  if (gidChangedUserInfo)
  {    
    [[NSNotificationCenter defaultCenter] postNotificationName: EOGlobalIDChangedNotification
                                                        object: self
                                                      userInfo: gidChangedUserInfo];
  }

  dbOpeEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);
  gidChangedUserInfo2 = [NSMutableDictionary dictionary];
  
  while (NSNextMapEnumeratorPair(&dbOpeEnum, (void **)&gid,
                                 (void **)&dbOpe)) {
    EOGlobalID *dbOpeGID = nil;
    
    dbOpeGID = [dbOpe globalID]; 
    
    switch ([dbOpe databaseOperator])
    {
      case EODatabaseInsertOperator:
      {
        id newObj = nil;
        if (gidChangedUserInfo) {
          newObj = [gidChangedUserInfo objectForKey:dbOpeGID];
        }
        
        [insertedObjects addObject: (newObj == nil ? dbOpeGID : newObj)];
      } 
        break;
        
      case EODatabaseDeleteOperator:
        [deletedObjects addObject: dbOpeGID];
        break;
        
      case EODatabaseUpdateOperator: /* 2 */
        [updatedObjects addObject: dbOpeGID];
        break;
        
      case EODatabaseNothingOperator:
        break;
    }
  } 
  NSEndMapTableEnumeration(&dbOpeEnum);

  [gidChangedUserInfo2 setObject:deletedObjects
                          forKey:EODeletedKey];
  
  [gidChangedUserInfo2 setObject:insertedObjects
                          forKey:EOInsertedKey];
  
  [gidChangedUserInfo2 setObject:updatedObjects
                          forKey:EOUpdatedKey];
  
  [self _cleanUpAfterSave];
  
  [[NSNotificationCenter defaultCenter]
   postNotificationName: @"EOObjectsChangedInStoreNotification"
   object: _database
   userInfo: gidChangedUserInfo2];
}

- (void)rollbackChanges
{ // TODO
//adaptorcontext transactionNestingLevel
//if 0 ? _cleanUpAfterSave


  if (_flags.beganTransaction == YES)
    {
      [_adaptorContext rollbackTransaction];

      _flags.beganTransaction = NO;
      _flags.preparingForSave = NO;

      if (_lockedObjects)
	{
	  NSResetHashTable(_lockedObjects);
	}

      NSResetMapTable(_dbOperationsByGlobalID);
/* //TODO
      [_snapshots removeAllObjects];
      [_toManySnapshots removeAllObjects];
*/
    }


}

- (NSDictionary *)valuesForKeys: (NSArray *)keys
                         object: (id)object
{
  EOEntity *entity;
  EODatabaseOperation *dbOpe;
  NSDictionary *newRow;
  NSDictionary *values = nil;
  
  if (!_isNilOrEONull(object))
  {
    entity = [_database entityForObject: object];
    
    NSAssert1(entity, @"No entity for object %@", object);
    
    
    dbOpe = [self databaseOperationForObject: object];
    newRow = [dbOpe newRow];
    values = [newRow dictionaryWithValuesForKeys: keys];
  }
  else
  {
    values = [NSDictionary dictionary];
  }
  
  return values;
}

-(void)nullifyAttributesInRelationship: (EORelationship*)relationship
                          sourceObject: (id)sourceObject
                     destinationObject: (id)destinationObject
{
  EODatabaseOperation *sourceDBOpe = nil;





  NSDebugMLLog(@"EODatabaseContext", @"destinationObject=%@",
	       destinationObject);

  if (destinationObject)
    {
      //Get SourceObject database operation
      sourceDBOpe = [self databaseOperationForObject: sourceObject]; //TODO: useIt



      if ([relationship isToManyToOne])
        {
          NSEmitTODO();
          [self notImplemented: _cmd]; //TODO
        }
      else
        {
          // Key a dictionary of two array: destinationKeys and sourceKeys
          NSDictionary *sourceToDestinationKeyMap =
	    [relationship _sourceToDestinationKeyMap]; //{destinationKeys = (customerCode); sourceKeys = (code); }
          BOOL foreignKeyInDestination = [relationship foreignKeyInDestination];

          NSDebugMLLog(@"EODatabaseContext", @"sourceToDestinationKeyMap=%@",
		       sourceToDestinationKeyMap);
          NSDebugMLLog(@"EODatabaseContext", @"foreignKeyInDestination=%d",
		       foreignKeyInDestination);

          if (foreignKeyInDestination)
            {
              NSArray *destinationKeys = [sourceToDestinationKeyMap
					   objectForKey: @"destinationKeys"];//(customerCode) 
              int i, destinationKeysCount = [destinationKeys count];
              NSMutableDictionary *changes = [NSMutableDictionary dictionaryWithCapacity: destinationKeysCount];

              if (destinationKeysCount>0)
                {
                  IMP oaiIMP=[destinationKeys methodForSelector: @selector(objectAtIndex:)];

                  for (i = 0 ;i < destinationKeysCount; i++)
                    {
                      id destinationKey = GDL2_ObjectAtIndexWithImp(destinationKeys,oaiIMP,i);
                      
                      [changes setObject: GDL2_EONull
                               forKey: destinationKey];
                    }
                }

              NSAssert1(destinationObject, 
                        @"No destinationObject for call of recordUpdateForObject:changes: changes: %@",
                        changes);

              [self recordUpdateForObject: destinationObject
                    changes: changes];
            }
          else
            {
              //Do nothing ?
              NSEmitTODO();
              //[self notImplemented: _cmd]; //TODO
            }
        }
    }
}


// private 

-(NSDictionary*) _primaryKeyForIntermediateRowFromSourceObject:(EOCustomObject*) srcObject
                                                  relationship:(EORelationship *) relationship
                                             destinationObject:(EOCustomObject *)destObject
{
	NSMutableDictionary * pkDict = nil;
	NSMutableDictionary * pkDict1 = nil;
  NSDictionary        * leftSideKeyDict = [relationship _leftSideKeyMap];
  EODatabaseOperation * op = [self databaseOperationForObject:srcObject];
  NSArray             * nsarray = [leftSideKeyDict objectForKey:@"sourceKeys"];
  
  pkDict = [NSMutableDictionary dictionaryWithDictionary:[op newRow]
                                                    keys:nsarray];
  
  if ([pkDict containsAnyNullObject])
  {
    NSDictionary * dict = [[self _entityForObject:srcObject] primaryKeyForGlobalID:(EOKeyGlobalID*)[op globalID]];

    pkDict = [NSMutableDictionary dictionaryWithDictionary:dict
                                                      keys:nsarray];
  }
  
  [pkDict translateFromKeys:nsarray
                     toKeys:(NSArray*) [leftSideKeyDict objectForKey:@"destinationKeys"]];
  
  leftSideKeyDict = [relationship _rightSideKeyMap];
  
  op = [self databaseOperationForObject:destObject];
  nsarray = (NSArray*)[leftSideKeyDict objectForKey:@"destinationKeys"];
  
  pkDict1 = [NSMutableDictionary dictionaryWithDictionary:[op newRow]
                                                     keys:nsarray];
  
  if ([pkDict1 containsAnyNullObject])
  {
    NSDictionary * destKeyDict = [[self _entityForObject:destObject] 
                                  primaryKeyForGlobalID:(EOKeyGlobalID*)[op globalID]];
    
    pkDict1 = [NSMutableDictionary dictionaryWithDictionary:destKeyDict
                                                       keys:nsarray];
  }
  [pkDict1 translateFromKeys:nsarray
                      toKeys:(NSArray*)[leftSideKeyDict objectForKey:@"sourceKeys"]];

  [pkDict addEntriesFromDictionary:pkDict1];
  
  return pkDict;
}

// private 

- (EODatabaseOperation*) _databaseOperationForIntermediateRowFromSourceObject:(EOCustomObject*) srcObject
                                                                 relationship:(EORelationship *) relationship
                                                            destinationObject:(EOCustomObject *)destObject
{
  EOEntity            * intermediateEntity = nil;
  NSDictionary        * pkDict = nil;
  EOGlobalID          * gid = nil;
  EODatabaseOperation * op = nil;
  
  pkDict = [self _primaryKeyForIntermediateRowFromSourceObject:srcObject
                                                  relationship:relationship
                                             destinationObject:destObject];
  
  intermediateEntity = [relationship intermediateEntity];
  
  gid = [intermediateEntity globalIDForRow:pkDict];
  
  if (!gid)
  {
    
    [NSException raise:NSInternalInconsistencyException
                format:@"A valid global ID could not be obtained for entity named '"
     @"%@' relationship named '%@' primary key dictionary %@.",
     [intermediateEntity name], [relationship name], pkDict];
  }
  
  op = [self databaseOperationForGlobalID:gid];
  
  if (!op)
  {
    op = [EODatabaseOperation databaseOperationWithGlobalID: gid
                                                     object: nil
                                                     entity: intermediateEntity];
    
    [op setDBSnapshot:pkDict];
    [op setNewRow:[NSMutableDictionary dictionaryWithDictionary:pkDict]];
    
    [self recordDatabaseOperation:op];
  }
  return op;
}

// private 
- (void) _recordDeleteForIntermediateRowFromSourceObject:(EOCustomObject*) sourceObject
                                            relationship:(EORelationship*) relationship
                                       destinationObject:(EOCustomObject*) destinationObject
{
  EODatabaseOperation * op;
  
  op = [self _databaseOperationForIntermediateRowFromSourceObject:sourceObject
                                                     relationship:relationship
                                                destinationObject:destinationObject];
  
  [op setDatabaseOperator:EODatabaseDeleteOperator];
}

- (void)nullifyAttributesInRelationship: (EORelationship*)relationship
                           sourceObject: (id)sourceObject
                     destinationObjects: (NSArray*)destinationObjects
{
  EODatabaseOperation * dbOpe = nil;

  if (!destinationObjects)
  {
    return;
  }
  
  dbOpe = [self databaseOperationForObject:sourceObject];
  
  if ([relationship isToManyToOne])
  {
    [self _recordDeleteForIntermediateRowFromSourceObject: sourceObject
                                             relationship:relationship
                                        destinationObject:(id)destinationObjects];
     
  } else {
    NSDictionary * mappingDict = [relationship _sourceToDestinationKeyMap];
    if ([relationship foreignKeyInDestination])
    {
      NSArray * destinationKeys = [mappingDict objectForKey:@"destinationKeys"];

      [self recordUpdateForObject:destinationObjects
                          changes:[NSDictionary dictionaryWithNullValuesForKeys:destinationKeys]];
    } else
    {
      NSArray * sourceKeys = [mappingDict objectForKey:@"sourceKeys"];
      
      [[dbOpe newRow] addEntriesFromDictionary:
       [NSDictionary dictionaryWithNullValuesForKeys:sourceKeys]];
    }
  }

}

- (void)relayAttributesInRelationship: (EORelationship*)relationship
			 sourceObject: (id)sourceObject
		   destinationObjects: (NSArray*)destinationObjects
{
  int destinationObjectsCount = 0;

  destinationObjectsCount = [destinationObjects count];

  if (destinationObjectsCount > 0)
    {
      int i;
      IMP oaiIMP=[destinationObjects methodForSelector: @selector(objectAtIndex:)];

      for (i = 0; i < destinationObjectsCount; i++)
        {
          id object = GDL2_ObjectAtIndexWithImp(destinationObjects,oaiIMP,i);

          [self relayAttributesInRelationship: (EORelationship*)relationship
                                 sourceObject: (id)sourceObject
                            destinationObject: object];
        }
    }


}

- (NSDictionary*)relayAttributesInRelationship: (EORelationship*)relationship
                                  sourceObject: (id)sourceObject
			     destinationObject: (id)destinationObject
{
  //OK
  NSMutableDictionary *relayedValues = nil;
  EODatabaseOperation *sourceDBOpe = nil;




  NSDebugMLLog(@"EODatabaseContext", @"sourceObject %p=%@ (class=%@)",
	       sourceObject, sourceObject, [sourceObject class]);
  NSDebugMLLog(@"EODatabaseContext", @"destinationObject %p=%@ (class=%@)",
	       destinationObject, destinationObject,
	       [destinationObject class]);

  //Get SourceObject database operation
  sourceDBOpe = [self databaseOperationForObject: sourceObject];



  if ([sourceDBOpe databaseOperator] == EODatabaseNothingOperator)
    {
      NSDebugMLLog(@"EODatabaseContext", @"Db Ope %@ for Nothing !!!", 
		   sourceDBOpe);
    }

  if ([relationship isToManyToOne])
    {
      NSEmitTODO();
      [self notImplemented: _cmd]; //TODO
    }
  else
    {
      // Key a dictionary of two array: destinationKeys and sourceKeys
      NSDictionary *sourceToDestinationKeyMap = [relationship _sourceToDestinationKeyMap];//{destinationKeys = (customerCode); sourceKeys = (code); } 
      NSArray *destinationKeys = [sourceToDestinationKeyMap
				   objectForKey: @"destinationKeys"];//(customerCode) 
      NSArray *sourceKeys = [sourceToDestinationKeyMap
			      objectForKey: @"sourceKeys"];//(code)
      NSMutableDictionary *sourceNewRow = [sourceDBOpe newRow];//OK in foreignKeyInDestination
      BOOL foreignKeyInDestination = [relationship foreignKeyInDestination];
      int i, count;


      NSDebugMLLog(@"EODatabaseContext", @"sourceToDestinationKeyMap=%@",
		   sourceToDestinationKeyMap);
      NSDebugMLLog(@"EODatabaseContext", @"destinationKeys=%@", 
		   destinationKeys);


      NSDebugMLLog(@"EODatabaseContext", @"foreignKeyInDestination=%s",
		   (foreignKeyInDestination ? "YES" : "NO"));

      NSAssert([destinationKeys count] == [sourceKeys count],
               @"destination keys count!=source keys count");

      if (foreignKeyInDestination || [relationship propagatesPrimaryKey])
        {
          IMP srcObjectAIndexIMP=[sourceKeys methodForSelector: @selector(objectAtIndex:)];
          IMP dstObjectAIndexIMP=[destinationKeys methodForSelector: @selector(objectAtIndex:)];

          relayedValues = AUTORELEASE([[sourceNewRow dictionaryWithValuesForKeys: sourceKeys]
			     mutableCopy]);// {code = 0; }
          NSDebugMLLog(@"EODatabaseContext", @"relayedValues=%@",
		       relayedValues);

          count = [relayedValues count];

          for (i = 0; i < count; i++)
            {
              NSString *sourceKey = GDL2_ObjectAtIndexWithImp(sourceKeys,srcObjectAIndexIMP,i);
              NSString *destKey = GDL2_ObjectAtIndexWithImp(destinationKeys,dstObjectAIndexIMP,i);
              id sourceValue = [relayedValues objectForKey: sourceKey];

	
	
	      NSDebugMLLog(@"EODatabaseContext", @"sourceValue=%@",
			   sourceValue);

	      [relayedValues removeObjectForKey: sourceKey];
	      [relayedValues setObject: sourceValue
			     forKey: destKey];
            }

          NSDebugMLLog(@"EODatabaseContext", @"relayedValues=%@",
		       relayedValues);

          NSAssert1(destinationObject, 
                    @"No destinationObject for call of "
		    @"recordUpdateForObject:changes: relayedValues: %@",
                    relayedValues);

          [self recordUpdateForObject: destinationObject
                changes: relayedValues];
        }
      else
        {
          //Verify !!
          NSDictionary *destinationValues;
          IMP srcObjectAIndexIMP=[sourceKeys methodForSelector: @selector(objectAtIndex:)];
          IMP dstObjectAIndexIMP=[destinationKeys methodForSelector: @selector(objectAtIndex:)];

          //Now take destinationKeys values
          destinationValues = [self valuesForKeys: destinationKeys
                                           object: destinationObject];

          NSDebugMLLog(@"EODatabaseContext", @"destinationValues=%@",
		       destinationValues);
          //And put these values for source keys in the return object (sourceValues)

          count = [destinationKeys count];
          relayedValues = (NSMutableDictionary*)[NSMutableDictionary dictionary];

          NSDebugMLLog(@"EODatabaseContext", @"relayedValues=%@",
		       relayedValues);

          for (i = 0; i < count; i++)
            {
              NSString *sourceKey = GDL2_ObjectAtIndexWithImp(sourceKeys,srcObjectAIndexIMP,i);
              NSString *destinationKey = GDL2_ObjectAtIndexWithImp(destinationKeys,dstObjectAIndexIMP,i);
              id destinationValue = [destinationValues
				      objectForKey: destinationKey];

              NSDebugMLLog(@"EODatabaseContext", @"destinationKey=%@",
			   destinationKey);

              NSDebugMLLog(@"EODatabaseContext",
			   @"destinationValue=%@", destinationValue);

              if (!_isNilOrEONull(destinationValue))//?? or always
                [relayedValues setObject: destinationValue
                               forKey: sourceKey];
            }
          //Put these values in source object database ope new row
          NSDebugMLLog(@"EODatabaseContext", @"relayedValues=%@",
		       relayedValues);

          [sourceNewRow takeValuesFromDictionary: relayedValues];
        }
    }

  if ([sourceDBOpe databaseOperator] == EODatabaseNothingOperator)
    {
      NSDebugMLLog(@"EODatabaseContext",
		   @"Db Ope %@ for Nothing !!!", sourceDBOpe);
    }



  return relayedValues;
//Mirko Code:
/*
		      NSMutableArray *keys;
		      NSDictionary *values;
		      EOGlobalID *relationshipGID;
		      id objectTo;

		      objectTo = [object storedValueForKey:name];
		      relationshipGID = [_editingContext
					  globalIDForObject:objectTo];
		      if ([self ownsObject:objectTo] == YES)
			{
			  for (h=0; h<count; h++)
			    {
			      join = [joins objectAtIndex:h];

			      value = [objectTo
					storedValueForKey:
					  [[join destinationAttribute] name]];

			      if (value == nil)
				value = GDL2_EONull;

			      [row setObject:value
				   forKey:[[join sourceAttribute] name]];
			    }
#if 0
			  inverse = [property inverseRelationship];
			  if (inverse)
			    {
			      toManySnapshot = AUTORELEASE([[self snapshotForSourceGlobalID:gid
						       relationshipName:[inverse name]]
						  mutableCopy]);
			      if (toManySnapshot == nil)
				toManySnapshot = [NSMutableArray array];

			      [toManySnapshot addObject:gid];

			      [op recordToManySnapshot:toManySnapshot
				  relationshipName:name];
			    }
#endif
			}
		      else
			{
			  keys = [NSMutableArray arrayWithCapacity:count];

			  for (h=0; h<count; h++)
			    {
			      join = [joins objectAtIndex:h];
			      [keys addObject:[[join destinationAttribute]
						name]];
			    }

			  values = [_coordinator valuesForKeys:keys
						 object:objectTo];

			  for (h=0; h<count; h++)
			    {
			      join = [joins objectAtIndex:h];

			      value = [values
					objectForKey:
					  [[join destinationAttribute] name]];

			      if (value == nil)
				value = GDL2_EONull;

			      [row setObject:value
				   forKey:[[join sourceAttribute] name]];
			    }
			}
*/

};

- (void)recordDatabaseOperation: (EODatabaseOperation*)databaseOpe
{
  //OK
  EOGlobalID *gid = nil;



  NSAssert(databaseOpe, @"No database operation");


  NSDebugMLLog(@"EODatabaseContext", @"_dbOperationsByGlobalID=%p",
	       _dbOperationsByGlobalID);

  if (_dbOperationsByGlobalID)
    {
//
      NSDebugMLLog(@"EODatabaseContext", @"_dbOperationsByGlobalID=%@",
		   NSStringFromMapTable(_dbOperationsByGlobalID));

      /*
        // doesn't do this so some db operation are not recorded (when selecting objects)
        if (!_dbOperationsByGlobalID)
        _dbOperationsByGlobalID = NSCreateMapTable(NSObjectMapKeyCallBacks, 
        NSObjectMapValueCallBacks,
        32);
      */
      gid = [databaseOpe globalID];



      NSMapInsert(_dbOperationsByGlobalID, gid, databaseOpe);
      NSDebugMLLog(@"EODatabaseContext",
		   @"_dbOperationsByGlobalID=%p",
		   _dbOperationsByGlobalID);
      NSDebugMLLog(@"EODatabaseContext", @"_dbOperationsByGlobalID=%@",
		   NSStringFromMapTable(_dbOperationsByGlobalID));
    }
  else
    {
      NSDebugMLLog(@"EODatabaseContext",
		   @"No _dbOperationsByGlobalID");
    }


}

- (EODatabaseOperation*)databaseOperationForGlobalID: (EOGlobalID*)gid
{
  //OK
  EODatabaseOperation *dbOpe = nil;



  NSDebugMLLog(@"EODatabaseContext", @"_dbOperationsByGlobalID=%p",
	       _dbOperationsByGlobalID);

  if (_dbOperationsByGlobalID)
    {
//
      NSDebugMLLog(@"EODatabaseContext", @"_dbOperationsByGlobalID=%@",
		   NSStringFromMapTable(_dbOperationsByGlobalID));

      dbOpe = (EODatabaseOperation*)NSMapGet(_dbOperationsByGlobalID,
					     (const void*)gid);


    }



  return dbOpe;
}

- (EODatabaseOperation*)databaseOperationForObject: (id)object
{
   //OK
   EODatabaseOperation *databaseOpe = nil;
   EOGlobalID *gid = nil;

   NS_DURING // for trace purpose
     {


       if ([object isKindOfClass: [EOGenericRecord class]])
	 NSDebugMLLog(@"EODatabaseContext", @"dictionary=%@ ",
		      [object debugDictionaryDescription]);

       gid = EODatabaseContext_globalIDForObjectWithImpPtr(self,NULL,object);


       databaseOpe = [self databaseOperationForGlobalID: gid]; //OK


       if (!databaseOpe)//OK
         {
           NSDictionary *snapshot = nil;
           NSArray *classPropertyNames = nil;
           NSArray *dbSnapshotKeys = nil;
           int i = 0;
           int propNamesCount = 0;
           int snapKeyCount = 0;
           NSMutableDictionary *row = nil;
           NSMutableDictionary *newRow = nil;
           EOEntity *entity = nil;
           NSArray *primaryKeyAttributes = nil;

           entity = [_database entityForObject: object]; //OK
           NSDebugMLLog(@"EODatabaseContext", @"entity name=%@",
			[entity name]);

           primaryKeyAttributes = [entity primaryKeyAttributes]; //OK

           NSDebugMLLog(@"EODatabaseContext",
			@"primaryKeyAttributes=%@",
			primaryKeyAttributes);

           databaseOpe = [EODatabaseOperation
			   databaseOperationWithGlobalID: gid
			   object: object
			   entity: entity]; //OK

           NSDebugMLLog(@"EODatabaseContext",
			@"CREATED databaseOpe=%@\nfor object %p %@",
			databaseOpe, object, object);

           snapshot = EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,gid);//OK
           NSDebugMLLog(@"EODatabaseContext", @"snapshot %p=%@",
			snapshot, snapshot);

           if (!snapshot)
             snapshot = [NSDictionary dictionary];

           [databaseOpe setDBSnapshot: snapshot];
           NSDebugMLLog(@"EODatabaseContext",@"object=%p databaseOpe=%@",
			object,databaseOpe);

           classPropertyNames = [entity classPropertyNames]; //OK  (code, a3code, numcode, toLabel)
           NSDebugMLLog(@"EODatabaseContext",
			@"classPropertyNames=%@", classPropertyNames);

           propNamesCount = [classPropertyNames count];
           NSDebugMLLog(@"EODatabaseContext", @"propNamesCount=%d",
			(int)propNamesCount);

           //TODO: rewrite code: don't use temporary "row"
           row = (NSMutableDictionary*)[NSMutableDictionary dictionary];
           NSDebugMLLog(@"EODatabaseContext",@"object %p (class %@)=%@ ",
			object,[object class],object);

           /*if ([object isKindOfClass: [EOGenericRecord class]])
	     NSDebugMLLog(@"EODatabaseContext", @"dictionary=%@ ",
	     [object debugDictionaryDescription]);*/
           if (propNamesCount>0)
             {
               IMP oaiIMP=[classPropertyNames methodForSelector: @selector(objectAtIndex:)];

               for (i = 0; i < propNamesCount; i++)
                 {
                   id value = nil;
                   NSString *key = GDL2_ObjectAtIndexWithImp(classPropertyNames,oaiIMP,i);
                   

                   
                   /*NO !! 
                     if ([attribute isKindOfClass:[EOAttribute class]] == NO)
                     continue;
                     // if ([attribute isFlattened] == NO)
                     */
                   value = [object storedValueForKey: key]; //OK
                   NSDebugMLLog(@"EODatabaseContext", @"key=%@ value=%@",
                                key, value);
                   
                   if (!value)
                     {
                       value = GDL2_EONull;
                       
                       [[[entity attributeNamed: key] validateValue: &value]
                         raise];
                     }
                   
                   NSDebugMLLog(@"EODatabaseContext", @"key=%@ value=%@",
                                key, value);
                   
                   [row setObject: value
                        forKey: key];
                 }
             };

           newRow = [[NSMutableDictionary alloc]
		       initWithDictionary: snapshot
		       copyItems: NO];



           dbSnapshotKeys = [entity dbSnapshotKeys]; //OK (numcode, code, a3code)
           NSDebugMLLog(@"EODatabaseContext", @"dbSnapshotKeys=%@",
			dbSnapshotKeys);

           snapKeyCount = [dbSnapshotKeys count];

           if (snapKeyCount>0)
             {
               IMP oaiIMP=[dbSnapshotKeys methodForSelector: @selector(objectAtIndex:)];
               for (i = 0; i < snapKeyCount; i++)
                 {
                   id key = GDL2_ObjectAtIndexWithImp(dbSnapshotKeys,oaiIMP,i);
                   id value = [row objectForKey: key]; //Really this key ?
                   
                   NSDebugMLLog(@"EODatabaseContext", @"key=%@ value=%@",
                                key, value);
                   
                   //               NSAssert1(value,@"No value for %@",key);
                   
                   if (value)
                     [newRow setObject: value
                             forKey: key];
                 }
             };



           [databaseOpe setNewRow: newRow];
           [self recordDatabaseOperation: databaseOpe];
           RELEASE(newRow);
         }
    }
  NS_HANDLER
    {

      [localException raise];
    }
  NS_ENDHANDLER;



  return databaseOpe;
}

- (void)relayPrimaryKey: (NSDictionary*)pk
           sourceObject: (id)sourceObject
             destObject: (id)destObject
           relationship: (EORelationship*)relationship
{
  //OK
  NSDictionary *relayedAttributes = nil;
  EOEntity *destEntity = nil;
  NSArray *destAttributes = nil;
  NSArray *destAttributeNames = nil;
  NSDictionary *keyValues = nil;
  NSArray *values = nil;
  int i, count;
  BOOL nullPKValues = YES;
  
  
  
  NSAssert3(destObject, 
            @"No destinationObject. pk=%@ relationship=%@ sourceObject=%@",
            pk,relationship,sourceObject);
  
  destAttributes = [relationship destinationAttributes];
  
  
  destAttributeNames = [destAttributes resultsOfPerformingSelector:
                        @selector(name)];
  
  keyValues = [self valuesForKeys: destAttributeNames
                           object: destObject];
  
  
  values = [keyValues allValues];
  
  
  //Now test if null values
  count = [values count];
  
  if (count>0)
  {
    IMP oaiIMP=[values methodForSelector: @selector(objectAtIndex:)];
    
    for (i = 0; nullPKValues && i < count; i++)
      nullPKValues = _isNilOrEONull(GDL2_ObjectAtIndexWithImp(values,oaiIMP,i));
  };
  
  if (nullPKValues)
  {
    relayedAttributes = [self relayAttributesInRelationship: relationship
                                               sourceObject: sourceObject
                                          destinationObject: destObject];
    
    destEntity = [relationship destinationEntity];
    
    [self relayPrimaryKey: relayedAttributes
                   object: destObject
                   entity: destEntity];
  }
  
  
}

- (void)relayPrimaryKey: (NSDictionary*)pk
		 object: (id)object
		 entity: (EOEntity*)entity
{
  //TODO check
  NSArray *relationships = nil;
  NSArray *classPropertyNames = nil;
  EODatabaseOperation *dbOpe = nil;
  NSDictionary *dbSnapshot = nil;
  int i, count=0;
  
  relationships = [entity relationships]; //OK
  classPropertyNames = [entity classPropertyNames];
  dbOpe = [self databaseOperationForObject: object];
  
  if (!dbOpe) {
    dbSnapshot = [NSDictionary dictionary];
  } else {
    dbSnapshot = [dbOpe dbSnapshot];
  }
  
  if (relationships) {
    count = [relationships count];
  }
  
  if (count>0)
  {
    IMP oaiIMP=[relationships methodForSelector: @selector(objectAtIndex:)];
    
    for (i = 0; i < count; i++)
    {
      EORelationship *relationship = GDL2_ObjectAtIndexWithImp(relationships,oaiIMP,i);
      EORelationship *substRelationship = nil;
      NSString       *relName;
      id              storedValue;
      id value = nil;
      id snapshot = nil;
      id comSnapshotValue = nil;
      
      substRelationship = [relationship _substitutionRelationshipForRow: dbSnapshot];
      
      if (!substRelationship) {
        continue;
      }
      
      relName = [substRelationship name];
      
      if ((![substRelationship propagatesPrimaryKey]) || 
          (![classPropertyNames containsObject:relName]))
      {
        continue;
      }
      
      storedValue = [object storedValueForKey:relName];
      if (!storedValue)
      {
        continue;
      }
      
      snapshot = [self _currentCommittedSnapshotForObject: object];                  
      comSnapshotValue = [snapshot objectForKey:relName];
      
      // or use == ?
      if ([storedValue isEqual:comSnapshotValue])
      {
        continue;
      }
      
      if ([substRelationship isToMany])
      {
        // or use == ?
        if ([comSnapshotValue isEqual: (NSArray*)storedValue] == NO)
        {
#warning check!!
          NSArray * storedValueArray = (NSArray*)storedValue;
          NSUInteger x;
          for (x = [storedValueArray count]; x > 0; x--)
          {            
            [self relayPrimaryKey: pk
                     sourceObject: object
                       destObject: [storedValueArray objectAtIndex:x-1]
                     relationship: substRelationship];
            
          }
          
        }
      }
      else
      {
        
        
        // 1:1 relationships may be optional so we may have no value here
        [self relayPrimaryKey: pk
                 sourceObject: object
                   destObject: value
                 relationship: substRelationship]; //this one ??
      }
    }
    
  }
}

- (void) createAdaptorOperationsForDatabaseOperation: (EODatabaseOperation*)dbOpe
                                          attributes: (NSArray*)attributes
{
  EOEntity           * entity = nil;
  EODatabaseOperator   dbOperator = EODatabaseNothingOperator;
  NSDictionary       * changedValues = nil;
  
  NSAssert(dbOpe, @"No operation");
  
  entity     = [dbOpe entity]; //OK
  dbOperator = [dbOpe databaseOperator]; //OK
  EOAdaptorOperation * lockOperation = nil;
  NSDictionary       * dbSnapshot = nil;

  EOQualifier *lockingQualifier = nil;
    
  switch (dbOperator)
  {
    case EODatabaseNothingOperator:
      break;
    case EODatabaseInsertOperator:
    {
      EOAdaptorOperation * insertOp = nil;
      EOStoredProcedure  * insertProc = nil;
      NSDictionary       * writeAttrValues = nil;

      changedValues = [dbOpe newRow];
      writeAttrValues = [self valuesToWriteForAttributes:attributes
                                                  entity:entity
                                           changedValues:changedValues];
      if ([writeAttrValues count] < 1)
      {
        break;
      }
      
      insertOp = [EOAdaptorOperation adaptorOperationWithEntity:entity];
      insertProc = [entity storedProcedureForOperation:EOInsertProcedureOperation];
      
      if (insertProc)
      {
        [insertOp setAdaptorOperator:EOAdaptorStoredProcedureOperator];
        [insertOp setStoredProcedure:insertProc];
      } else
      {
        [insertOp setAdaptorOperator:EOAdaptorInsertOperator];
      }
      [insertOp setChangedValues:writeAttrValues];
      [dbOpe addAdaptorOperation:insertOp];
      
      break;
    }
    case EODatabaseUpdateOperator:
    {
      NSArray            * lockNonQualAttrs = nil;
      NSArray            * pkAttributes = nil;
      NSArray            * lockingAttributes = nil;
      NSUInteger           changeCount, lockNonQualCount, lockAttrCount;
      
      changedValues = [dbOpe rowDiffsForAttributes:attributes];
      lockNonQualAttrs = [self lockingNonQualifiableAttributes:attributes];
      lockingAttributes = [self lockingAttributesForAttributes:attributes
                                                        entity:entity];
      
      changeCount = [changedValues count];
      lockNonQualCount = [lockNonQualAttrs count];
      lockAttrCount = [lockingAttributes count];
      
      // test if we have anything to do
      
      if (((changeCount == 0)) && ((lockNonQualCount == 0)) && ((lockAttrCount == 0))) {
        return;
      }
      
      pkAttributes = [self primaryKeyAttributesForAttributes:attributes
                                                      entity:entity];
      
      dbSnapshot = [dbOpe dbSnapshot];

      lockingQualifier = [self qualifierForLockingAttributes:lockingAttributes
                                        primaryKeyAttributes:pkAttributes
                                                      entity:entity
                                                    snapshot:dbSnapshot];
      
      if (((changeCount == 0)) || (lockNonQualCount > 0))
      {
        lockOperation = [EOAdaptorOperation adaptorOperationWithEntity:entity];
        [lockOperation setAdaptorOperator:EOAdaptorLockOperator];
        [lockOperation setQualifier:lockingQualifier];
        [lockOperation setChangedValues:dbSnapshot];
        
        if (lockNonQualCount > 0)
        {
          [lockOperation setAttributes:lockNonQualAttrs];
        } else {
          [lockOperation setAttributes:pkAttributes];
        }
        [dbOpe addAdaptorOperation:lockOperation];
      }
      if (changeCount > 0)
      {
        NSDictionary * writeAttrValues = nil;
        
        writeAttrValues = [self valuesToWriteForAttributes:attributes
                                                    entity:entity
                                             changedValues:changedValues];
        if ([writeAttrValues count] > 0)
        {
          EOAdaptorOperation * updateOperation = nil;
          
          updateOperation = [EOAdaptorOperation adaptorOperationWithEntity:entity];
          [updateOperation setAdaptorOperator:EOAdaptorUpdateOperator];
          [updateOperation setChangedValues:writeAttrValues];
          [updateOperation setQualifier:lockingQualifier];
          [dbOpe addAdaptorOperation:updateOperation];
        }
      }
      
    }
      break;
    case EODatabaseDeleteOperator: 
    {
      NSArray            * pkAttributes = nil;
      NSArray            * lockingAttributes = nil;
      NSArray            * lockNonQualAttrs = nil;
      EOAdaptorOperation * deleteOp = nil;
      EOStoredProcedure  * deleteProc = nil;
      
      pkAttributes = [self primaryKeyAttributesForAttributes:attributes
                                                      entity:entity];
      
      lockingAttributes = [self lockingAttributesForAttributes:attributes
                                                        entity:entity];
      
      dbSnapshot = [dbOpe dbSnapshot];
      
      lockingQualifier = [self qualifierForLockingAttributes:lockingAttributes
                                        primaryKeyAttributes:pkAttributes
                                                      entity:entity
                                                    snapshot:dbSnapshot];
      
      lockNonQualAttrs = [self lockingNonQualifiableAttributes:attributes];
      
      if ([lockNonQualAttrs count] > 0)
      {
        lockOperation = [EOAdaptorOperation adaptorOperationWithEntity:entity];
        [lockOperation setAdaptorOperator:EOAdaptorLockOperator]; /* 0  in EOF */
        [lockOperation setQualifier:lockingQualifier];
        [lockOperation setAttributes:lockNonQualAttrs];
        [lockOperation setChangedValues:dbSnapshot];
        [dbOpe addAdaptorOperation:lockOperation];
      }
      
      deleteOp = [EOAdaptorOperation adaptorOperationWithEntity:entity];
      deleteProc = [entity storedProcedureForOperation:EODeleteProcedureOperation];
      
      if (deleteProc)
      {
        [deleteOp setAdaptorOperator:EOAdaptorStoredProcedureOperator]; /* 4 */
        [deleteOp setStoredProcedure:deleteProc];
        [deleteOp setChangedValues:dbSnapshot];
      } else {
        [deleteOp setAdaptorOperator:EOAdaptorDeleteOperator]; /* 3 */
        [deleteOp setQualifier:lockingQualifier];
      }
      [dbOpe addAdaptorOperation:deleteOp];
      
    }
      break;
  }
  
}

- (void) createAdaptorOperationsForDatabaseOperation: (EODatabaseOperation*)dbOpe
{
  //OK for Update - Test for others
  NSArray *attributesToSave = nil;
  NSMutableArray *attributes = nil;
  NSUInteger count=0;
  EODatabaseOperator dbOperator = EODatabaseNothingOperator;
  EOEntity *entity = [dbOpe entity];
  NSDictionary *rowDiffs = nil;

  [self processSnapshotForDatabaseOperation: dbOpe];
  dbOperator = [dbOpe databaseOperator];

  if (dbOperator == EODatabaseUpdateOperator)
  {
    rowDiffs = [dbOpe rowDiffs];
    if ((!rowDiffs) || (([rowDiffs count] == 0))) 
    {
      return;
    }
  }
  
  attributesToSave = [entity _attributesToSave];
  attributes = [NSMutableArray array];

  count = [attributesToSave count];
  if (count>0)
    {
      int i=0;
      IMP attributesAddObjectIMP=[attributes methodForSelector:@selector(addObject:)];
      IMP attributesToSaveObjectAtIndexIMP=[attributesToSave methodForSelector:@selector(objectAtIndex:)];

      for (i = 0; i < count; i++)
        {
          EOAttribute *attribute = 
            GDL2_ObjectAtIndexWithImp(attributesToSave,attributesToSaveObjectAtIndexIMP,i);


          
          if (![attribute isFlattened] && ![attribute isDerived]) //VERIFY
            {
              GDL2_AddObjectWithImp(attributes,attributesAddObjectIMP,attribute);
              
              if ([rowDiffs objectForKey: [attribute name]]
                  && [attribute isReadOnly])
                {
                  NSEmitTODO();
                  [self notImplemented: _cmd]; //TODO: excption ???
                }
            }
        }
    };




  [self createAdaptorOperationsForDatabaseOperation: dbOpe
        attributes: attributes];
}

static NSComparisonResult 
compareUsingEntityNames(id left, id right, void* vpSortOrders)
{
  NSArray            * sortOrders = (NSArray *)vpSortOrders;
  EOAdaptorOperation * leftOp = (EOAdaptorOperation*) left;
  EOAdaptorOperation * rightOp = (EOAdaptorOperation*) right;
  NSString           * leftName = [[leftOp entity] name];
  NSString           * rightName = [[rightOp entity] name];
  NSUInteger           leftIndex;
  NSUInteger           rightIndex;
    
  leftIndex = [sortOrders indexOfObject:leftName];
  rightIndex = [sortOrders indexOfObject:rightName];
  
  if (leftIndex < rightIndex) {
    return NSOrderedAscending;
  }
  if (leftIndex > rightIndex) {
    return NSOrderedDescending;
  } else {
    EOAdaptorOperator leftOperator = [leftOp adaptorOperator];
    EOAdaptorOperator rightOperator = [rightOp adaptorOperator];
    
    if (leftOperator < rightOperator) {
      return NSOrderedAscending;
    }
    if (leftOperator > rightOperator) {
      return NSOrderedDescending;
    }      
  }

  return NSOrderedSame;
}

- (NSArray*) orderAdaptorOperations
{
  NSMutableArray      * orderedAdaptorOpe = nil;
  
  if (_delegateRespondsTo.willOrderAdaptorOperations == YES) {
    orderedAdaptorOpe = (NSMutableArray*) [_delegate databaseContext: self
                    willOrderAdaptorOperationsFromDatabaseOperations:
                                           NSAllMapTableValues(_dbOperationsByGlobalID)];
    
  } else {
    NSMutableArray      * entities = [NSMutableArray array];
//    NSMutableArray      * adaptorOperations = [NSMutableArray array];
    NSMapEnumerator       dbOpeEnum;
    EOGlobalID          * gid = nil;
    EODatabaseOperation * dbOpe = nil;
    NSArray             * entityNameOrderingArray = nil;
//    NSHashTable         * entitiesHashTable = NSCreateHashTable(NSNonOwnedPointerHashCallBacks,32);
    
    orderedAdaptorOpe = (NSMutableArray*)[NSMutableArray array];
    
    dbOpeEnum = NSEnumerateMapTable(_dbOperationsByGlobalID);
    
    while (NSNextMapEnumeratorPair(&dbOpeEnum, (void **)&gid,
                                   (void **)&dbOpe))
    {
      NSArray *dbOpeAdaptorOperations = [dbOpe adaptorOperations];
      NSUInteger operCount = 0;
      NSUInteger idx = 0;
      
      if (dbOpeAdaptorOperations)
      {
        [orderedAdaptorOpe addObjectsFromArray:dbOpeAdaptorOperations];
        operCount = [dbOpeAdaptorOperations count];
      }      
      
      
      while (idx < operCount) 
      {
        EOEntity * entity = [[dbOpeAdaptorOperations objectAtIndex:idx] entity];
        if (([entities indexOfObject:entity] == NSNotFound))
        {
          [entities addObject:entity];
        }
        idx++;
      }
      
    }
    NSEndMapTableEnumeration(&dbOpeEnum);
    
    entityNameOrderingArray = [self entityNameOrderingArrayForEntities:entities];
    
    [orderedAdaptorOpe sortUsingFunction:compareUsingEntityNames
                                 context:entityNameOrderingArray];
  }
  
  return orderedAdaptorOpe;
}

- (NSArray*) entitiesOnWhichThisEntityDepends: (EOEntity*)entity
{
  NSMutableArray *entities = nil;
  NSArray *relationships = nil;
  int count;



  relationships = [entity relationships];
  count = [relationships count];

  if (count>0)
    {
      IMP oaiIMP=[relationships methodForSelector: @selector(objectAtIndex:)];
      int i=0;

      for (i = 0; i < count; i++)
        {
          EORelationship *relationship = GDL2_ObjectAtIndexWithImp(relationships,oaiIMP,i);
          

          
          if (![relationship isToMany]) //If to many: do nothing
            {
              if ([relationship isFlattened])
                {
                  //TODO VERIFY
                  EOExpressionArray *definitionArray=[relationship _definitionArray];
                  EORelationship *firstRelationship=[definitionArray objectAtIndex:0];
                  EOEntity *firstDefEntity=[firstRelationship destinationEntity];
                  NSArray *defDependEntities=[self
                                               entitiesOnWhichThisEntityDepends:firstDefEntity];
                  if ([defDependEntities count]>0)
                    {
                      if (!entities)
                        entities = [NSMutableArray array];
                      
                      [entities addObjectsFromArray: defDependEntities];
                    };
                }
              else
                {
                  //Here ??
                  EOEntity *destinationEntity = [relationship destinationEntity];
                  EORelationship *inverseRelationship = [relationship
                                                          anyInverseRelationship];
                  
                  if ([inverseRelationship isToMany])
                    {
                      //Do nothing ?
                    }
                  else
                    {
                      if ([inverseRelationship propagatesPrimaryKey])
                        {
                          //OK
                          if (!entities)
                            entities = [NSMutableArray array];
                          
                          [entities addObject: destinationEntity];
                        }
                      else
                        {
                          if ([inverseRelationship ownsDestination])
                            {
                              NSEmitTODO();
                              [self notImplemented: _cmd]; //TODO
                            }
                        }
                    }
                }
            }
        }
    }



  return entities;
}

/* this is private. it seems other implementations are doing much more
 * than this.
 */

- (NSArray*)entityNameOrderingArrayForEntities: (NSArray*)entities
{
  //TODO
  NSMutableArray *ordering = [NSMutableArray array];
  NSMutableSet *orderedEntities = [NSMutableSet set];
  /*EODatabase *database = [self database];
    NSArray *models = [database models];*/
  NSMutableDictionary *dependsDict = [NSMutableDictionary dictionary];
  int count = [entities count];

  //TODO NSArray* originalOrdering=...
  /*TODO for each mdoel:
    userInfo (ret nil)
  */

  if (count>0)
    {
      IMP oaiIMP=[entities methodForSelector: @selector(objectAtIndex:)];
      int i=0;

      for (i = 0; i < count; i++)
        {
          //OK
          EOEntity *entity=GDL2_ObjectAtIndexWithImp(entities,oaiIMP,i);
          NSArray *dependsEntities = [self
                                       entitiesOnWhichThisEntityDepends: entity];
          
          if ([dependsEntities count])
            [dependsDict setObject: dependsEntities
                         forKey: [entity name]];
        }
      
      ordering = [NSMutableArray array];
      for (i = 0; i < count; i++)
        {
          EOEntity *entity=GDL2_ObjectAtIndexWithImp(entities,oaiIMP,i);
          [self insertEntity: entity
                intoOrderingArray: ordering
                withDependencies: dependsDict
                processingSet: orderedEntities];
        }
    }
  //TODO
  /*
    model userInfo //ret nil
   setUserInfo: {EOEntityOrdering = ordering; }
  */

  return ordering;
}

- (BOOL) isValidQualifierTypeForAttribute: (EOAttribute*)attribute
{
  //OK
  BOOL isValid = NO;
  EOEntity *entity = nil;
  EOModel *model = nil;
  EODatabase *database = nil;
  EOAdaptor *adaptor = nil;
  NSString *externalType = nil;

  entity = [attribute entity];

  NSAssert1(entity, @"No entity for attribute %@", attribute);

  model = [entity model];
  database = [self database];
  adaptor = [database adaptor];
  externalType = [attribute externalType];
  isValid = [adaptor isValidQualifierType: externalType
		     model: model];

  return isValid;
}

- (NSArray*) lockingNonQualifiableAttributes: (NSArray*)attributes
{
  NSMutableArray * lockingAttrs = nil;
  NSArray        * attributesUsedForLocking = nil;
  NSUInteger       i = [attributes count];
  
  for (; i > 0; i--)
  {
    EOAttribute * attr = [attributes objectAtIndex:i-1];
    
    if (!attributesUsedForLocking)
    {
      attributesUsedForLocking = [[attr entity] attributesUsedForLocking];
    }
    
    if ([self isValidQualifierTypeForAttribute:attr] || 
        (![attributesUsedForLocking containsObject:attr]))
    {
      continue;
    }
    
    if (!lockingAttrs)
    {
      lockingAttrs = [NSMutableArray array];
    }
    [lockingAttrs addObject:attr];
  }
  
  if (!lockingAttrs) {
    lockingAttrs = [NSArray array];
  }
  
  return lockingAttrs;
}


- (NSArray*) lockingAttributesForAttributes: (NSArray*)attributes
                                     entity: (EOEntity*)entity
{
  //TODO
  NSArray *retAttributes = nil;
  int count = 0;
  NSArray *attributesUsedForLocking = nil;



  attributesUsedForLocking = [entity attributesUsedForLocking];
  count = [attributes count];

  if (count>0)
    {
      IMP oaiIMP=[attributes methodForSelector: @selector(objectAtIndex:)];
      int i=0;

      for (i = 0; i < count; i++)
        {
          id attribute = GDL2_ObjectAtIndexWithImp(attributes,oaiIMP,i);
          //do this on 1st only
          BOOL isFlattened = [attribute isFlattened];
          
          if (isFlattened)
            { 
              NSEmitTODO();
              [self notImplemented: _cmd]; //TODO
            }
          else
            {
              NSArray *rootAttributesUsedForLocking = [entity rootAttributesUsedForLocking];
              
              retAttributes = rootAttributesUsedForLocking;
            }
        }
    };



  return retAttributes; //TODO
}

- (NSArray*) primaryKeyAttributesForAttributes: (NSArray*)attributes
                                        entity: (EOEntity*)entity
{
  //TODO
  NSArray *retAttributes = nil;
  int count = 0;


//TODO

  count = [attributes count];

  if (count>0)
    {
      IMP oaiIMP=[attributes methodForSelector: @selector(objectAtIndex:)];
      int i=0;

      for (i = 0; i < count; i++)
        {
          id attribute = GDL2_ObjectAtIndexWithImp(attributes,oaiIMP,i);
          BOOL isFlattened = [attribute isFlattened];
          
          //call isFlattened on 1st only
          if (isFlattened)
            { 
              NSEmitTODO();
          [self notImplemented: _cmd]; //TODO
            }
          else
            {
              NSArray *primaryKeyAttributes = [entity primaryKeyAttributes];

              retAttributes = primaryKeyAttributes;
            }
        }
    };



  return retAttributes;
}

- (EOQualifier*) qualifierForLockingAttributes: (NSArray*)attributes
                          primaryKeyAttributes: (NSArray*)primaryKeyAttributes
                                        entity: (EOEntity*)entity
                                      snapshot: (NSDictionary*)snapshot
{
  //OK
  EOQualifier *qualifier = nil;
  NSMutableArray *qualifiers = nil;
  int which;
  
  //First use primaryKeyAttributes, next use attributes
  for (which = 0; which < 2; which++)
  {
    NSArray *array = (which == 0 ? primaryKeyAttributes : attributes);
    NSUInteger i,count = [array count];
    
    for (i = 0; i < count; i++)
    {
      EOAttribute *attribute = [array objectAtIndex: i];
      
      if (which == 0 || ![primaryKeyAttributes containsObject: attribute])// Test if we haven't already processed it
	    {
	      if (![self isValidQualifierTypeForAttribute: attribute])
        {
          NSLog(@"Invalid externalType for attribute '%@' of entity named '%@' - model '%@'",
                [attribute name], [[attribute entity] name],
                [[[attribute entity] model] name]);
          NSEmitTODO();
          [self notImplemented: _cmd]; //TODO
        }
	      else
        {
          NSString *attributeName = nil;
          NSString *snapName = nil;
          id value = nil;
          EOQualifier *aQualifier = nil;
          
          attributeName = [attribute name];
          NSAssert1(attributeName, @"no attribute name for attribute %@", attribute);
          
          snapName = [entity snapshotKeyForAttributeName: attributeName];
          NSAssert2(snapName, @"no snapName for attribute %@ in entity %@",
                    attributeName, [entity name]);
          
          value = [snapshot objectForKey:snapName];
          
          NSAssert4(value != nil,
                    @"no value for snapshotKey '%@' in snapshot (address=%p) %@ for entity %@",
                    snapName, snapshot, snapshot, [entity name]);
          
          aQualifier 
          = [EOKeyValueQualifier qualifierWithKey: attributeName
                                 operatorSelector: @selector(isEqualTo:)
                                            value: value];
          
          if (!qualifiers)
            qualifiers = [NSMutableArray array];
          
          [qualifiers addObject: aQualifier];
        }
      }
    }
  }
  
  if ([qualifiers count] == 1)
  {
    qualifier = [qualifiers objectAtIndex: 0];
  }
  else
  {
    qualifier = [EOAndQualifier qualifierWithQualifierArray: qualifiers];
  }
  
  return qualifier;
}

- (void) insertEntity: (EOEntity*)entity
    intoOrderingArray: (NSMutableArray*)orderingArray
     withDependencies: (NSDictionary*)dependencies
        processingSet: (NSMutableSet*)processingSet
{
  NSString * entityName = [entity name];
  
  if ((([orderingArray indexOfObject:entityName] == NSNotFound)) && 
      (![processingSet containsObject:entityName]))
  {
    NSUInteger   depCount = 0;
    NSUInteger   idx = 0;
    NSArray    * dependenciesForEntity = [dependencies objectForKey:entityName];
    
    [processingSet addObject:entityName];
    
    if (dependenciesForEntity) {
      depCount = [dependenciesForEntity count];
    }
    
    for (; idx < depCount; idx++)
    {
      [self insertEntity:[dependenciesForEntity objectAtIndex:idx]
       intoOrderingArray:orderingArray
        withDependencies:dependencies
           processingSet:processingSet];
    }
    
    [orderingArray addObject:entityName];
  }
}

- (void) processSnapshotForDatabaseOperation: (EODatabaseOperation*)dbOpe
{
  //Near OK
  EOAdaptor *adaptor = [_database adaptor];//OK
  EOEntity *entity = [dbOpe entity];//OK
  NSMutableDictionary *newRow = nil;
  NSDictionary *dbSnapshot = nil;
  NSEnumerator *attrNameEnum = nil;
  id attrName = nil;
  IMP enumNO=NULL; // nextObject
  
  newRow = [dbOpe newRow]; //OK{a3code = Q77; code = Q7; numcode = 007; } //ALLOK

  dbSnapshot = [dbOpe dbSnapshot];
    
  // we need to make sure that we do not change an array while enumering it.
  attrNameEnum = [[NSArray arrayWithArray:[newRow allKeys]] objectEnumerator];
  enumNO=NULL;
  while ((attrName = GDL2_NextObjectWithImpPtr(attrNameEnum,&enumNO)))
  {
    EOAttribute *attribute = [entity attributeNamed: attrName];
    id newRowValue = nil;
    id dbSnapshotValue = nil;
    
    newRowValue = [newRow objectForKey:attrName];
    
    
    dbSnapshotValue = [dbSnapshot objectForKey: attrName];
    
    if (dbSnapshotValue && (![newRowValue isEqual: dbSnapshotValue]))
    {
      id adaptorValue = [adaptor fetchedValueForValue: newRowValue
                                            attribute: attribute];
      
      if ((!adaptorValue) || ((adaptorValue != dbSnapshotValue) && (![adaptorValue isEqual:dbSnapshotValue])))
      {
        if (!adaptorValue)
        {
          adaptorValue = GDL2_EONull;
        }
        [newRow setObject:adaptorValue
                   forKey:attrName];
      }
    }
  }
  
}


- (NSDictionary*) valuesToWriteForAttributes: (NSArray*)attributes
                                      entity: (EOEntity*)entity
                               changedValues: (NSDictionary*)changedValues
{
  //NEAR OK
  NSMutableDictionary *valuesToWrite = [NSMutableDictionary dictionary];
  BOOL isReadOnlyEntity = NO;

  isReadOnlyEntity = [entity isReadOnly];

  NSDebugMLLog(@"EODatabaseContext", @"isReadOnlyEntity=%s",
	       (isReadOnlyEntity ? "YES" : "NO"));

  if (isReadOnlyEntity)
    {
      NSEmitTODO();
      [self notImplemented: _cmd]; //TODO
    }
  else
    {
      int count = [attributes count];
      if (count>0)
        {
          IMP oaiIMP=[attributes methodForSelector: @selector(objectAtIndex:)];
          int i=0;

          for (i = 0; i < count; i++)
            {
              EOAttribute *attribute = GDL2_ObjectAtIndexWithImp(attributes,oaiIMP,i);
              BOOL isReadOnly = [attribute isReadOnly];
              

              NSDebugMLLog(@"EODatabaseContext", @"isReadOnly=%s",
                           (isReadOnly ? "YES" : "NO"));
              
              if (isReadOnly)
                {
                  NSEmitTODO();
                  NSDebugMLog(@"attribute=%@", attribute);
                  [self notImplemented: _cmd]; //TODO
                }
              else
                {
                  NSString *attrName = [attribute name];
                  NSString *snapName = nil;
                  id value = nil;
                  

                  
                  snapName = [entity snapshotKeyForAttributeName: attrName];

                  
                  value = [changedValues objectForKey: snapName];

                  
                  if (value)
                    [valuesToWrite setObject: value
                                   forKey: attrName];
                }
            }
        }
    }





  return valuesToWrite;
}

@end


@implementation EODatabaseContext(EOBatchFaulting)

- (void)batchFetchRelationship: (EORelationship *)relationship
	      forSourceObjects: (NSArray *)objects
		editingContext: (EOEditingContext *)editingContext
{ // TODO
  NSMutableArray *qualifierArray, *valuesArray, *toManySnapshotArray;
  NSMutableDictionary *values;
  NSArray *array;
  NSEnumerator *objsEnum, *joinsEnum, *keyEnum;
  NSString *key;
  EOFetchSpecification *fetch;
  EOQualifier *qualifier;
  EOFault *fault;
  EOJoin *join;
  BOOL equal;
  int i, count;
  id object;
  NSString* relationshipName = nil;
  IMP globalIDForObjectIMP=NULL;
  IMP toManySnapArrayObjectAtIndexIMP=NULL;
  IMP objsEnumNO=NULL;
  IMP objectsOAI=NULL;

  qualifierArray = AUTORELEASE([GDL2_alloc(NSMutableArray) init]);
  valuesArray = AUTORELEASE([GDL2_alloc(NSMutableArray) init]);
  toManySnapshotArray = AUTORELEASE([GDL2_alloc(NSMutableArray) init]);
  toManySnapArrayObjectAtIndexIMP=[toManySnapshotArray methodForSelector: @selector(objectAtIndex:)];
  relationshipName = [relationship name];

  objsEnum = [objects objectEnumerator];
  objsEnumNO=NULL;
  while ((object = GDL2_NextObjectWithImpPtr(objsEnum,&objsEnumNO)))
    {
      IMP joinsEnumNO=NO;
      values 
	= AUTORELEASE([GDL2_alloc(NSMutableDictionary) initWithCapacity: 4]);

      fault = [object valueForKey: relationshipName];
      [EOFault clearFault: fault];

      joinsEnum = [[relationship joins] objectEnumerator];
      while ((join = GDL2_NextObjectWithImpPtr(joinsEnum,&joinsEnumNO)))
	{
	  [values setObject: [object valueForKey: [[join sourceAttribute] name]]
		  forKey: [[join destinationAttribute] name]];
	}

      [valuesArray addObject: values];
      [toManySnapshotArray addObject:
			     AUTORELEASE([GDL2_alloc(NSMutableArray) init])];

      [qualifierArray addObject: [EOQualifier qualifierToMatchAllValues:
						values]];
    }

  if ([qualifierArray count] == 1)
    qualifier = [qualifierArray objectAtIndex: 0];
  else
    qualifier = [EOOrQualifier qualifierWithQualifierArray: qualifierArray];

  fetch = [EOFetchSpecification fetchSpecificationWithEntityName:
				  [[relationship destinationEntity] name]
				qualifier: qualifier
				sortOrderings: nil];

  array = [self objectsWithFetchSpecification: fetch
		editingContext: editingContext];

  count = [valuesArray count];

  if (count>0)
    {
      IMP oaiIMP=[valuesArray methodForSelector: @selector(objectAtIndex:)];

      objsEnum = [array objectEnumerator];
      objsEnumNO=NULL;
      while ((object = GDL2_NextObjectWithImpPtr(objsEnum,&objsEnumNO)))
        {
          IMP objectVFK=NULL; // valueForKey:
          for (i = 0; i < count; i++)
            {
              IMP keyEnumNO=NULL; // nextObject
              IMP valuesOFK=NULL; // objectForKey:
              equal = YES;
              values = GDL2_ObjectAtIndexWithImp(valuesArray,oaiIMP,i);

              keyEnum = [values keyEnumerator];
              while ((key = GDL2_NextObjectWithImpPtr(keyEnum,&keyEnumNO)))
                {
                  if ([GDL2_ValueForKeyWithImpPtr(object,&objectVFK,key)
                        isEqual: GDL2_ObjectForKeyWithImpPtr(values,&valuesOFK,key)] == NO)
                    {
                      equal = NO;
                      break;
                    }
                }
              
              if (equal == YES)
                {
                  EOGlobalID* gid = nil;
                  id snapshot = GDL2_ObjectAtIndexWithImp(toManySnapshotArray,toManySnapArrayObjectAtIndexIMP,i);
                  
                  [[GDL2_ObjectAtIndexWithImpPtr(objects,&objectsOAI,i) valueForKey: relationshipName]
                    addObject: object];
                  
                  gid=EOEditingContext_globalIDForObjectWithImpPtr(editingContext,&globalIDForObjectIMP,object);
                  
                  [snapshot addObject: gid];
                  
                  break;
                }
            }
	}
    }

//==> see _registerSnapshot:forSourceGlobalID:relationshipName:editingContext:

  if (count>0)
    {
      for (i = 0; i < count; i++)
        {
          id snapshot = GDL2_ObjectAtIndexWithImp(toManySnapshotArray,toManySnapArrayObjectAtIndexIMP,i);
          EOGlobalID* gid=EOEditingContext_globalIDForObjectWithImpPtr(editingContext,
                                                                       &globalIDForObjectIMP,
                                                                       GDL2_ObjectAtIndexWithImpPtr(objects,&objectsOAI,i));
          [_database recordSnapshot: snapshot
                     forSourceGlobalID: gid
                     relationshipName: relationshipName];
        };
    }

}

@end

@implementation EODatabaseContext (EODatabaseContextPrivate)

- (void) _fireArrayFault: (id)object
{
  //OK ??
  BOOL fetchIt = YES;





  if (_delegateRespondsTo.shouldFetchObjectFault == YES)
    fetchIt = [_delegate databaseContext: self
                         shouldFetchObjectFault: object];

  if (fetchIt)
    {
      /*Class targetClass = Nil;
	void *extraData = NULL;*/
      EOAccessArrayFaultHandler *handler = (EOAccessArrayFaultHandler *)[EOFault handlerForFault:object];
      EOEditingContext *context = [handler editingContext];
      NSString *relationshipName= [handler relationshipName];
      EOKeyGlobalID *gid = [handler sourceGlobalID];
      NSArray *objects = nil;

      NSDebugMLLog(@"EODatabaseContext", @"relationshipName=%@",
		   relationshipName);


      objects = [context objectsForSourceGlobalID: gid
			 relationshipName: relationshipName
			 editingContext: context];

      if (_isFault(object))
        [EOFault clearFault: object]; //??
      /* in clearFault 
         [handler faultWillFire:object];
         targetClass=[handler targetClass];
         extraData=[handler extraData];
         RELEASE(handler);
      */
      NSDebugMLLog(@"EODatabaseContext",
		   @"NEAR FINISHED 1 object count=%d %p %@",
		   [object count],
		   object,
		   object);
      NSDebugMLLog(@"EODatabaseContext",
		   @"NEAR FINISHED 1 objects count=%d %p %@",
		   [objects count],
		   objects,
		   objects);

      if (objects != object)
        {
          //No, not needed      [object removeObjectsInArray:objects];//Because some objects may be here. We don't want duplicate. It's a hack because I don't see why there's objects in object !
          NSDebugMLLog(@"EODatabaseContext",
		       @"NEAR FINISHED 1 object count=%d %p %@",
		       [object count],
		       object,
		       object);

          [object addObjectsFromArray: objects];

          NSDebugMLLog(@"EODatabaseContext",
		       @"NEAR FINISHED 2 object count=%d %@",
		       [object count],
		       object);
        }
    }
  //END!
/*
}

- (void)_batchToMany:(id)fault
	 withHandler:(EOAccessArrayFaultHandler *)handler
{
*/

/*
  EOAccessArrayFaultHandler *usedHandler, *firstHandler, *lastHandler;
  EOAccessArrayFaultHandler *bufHandler;
  NSMutableDictionary *batchBuffer;
  EOEditingContext *context;
  NSMutableArray *objects;
  EOKeyGlobalID *gid;
  EOEntity *entity;
  EORelationship *relationship;
  unsigned int maxBatch;
  BOOL batch = YES, changeBatch = NO;


  gid = [handler sourceGlobalID];//OK
  context = [handler editingContext];//OK

  entity = [_database entityNamed:[gid entityName]];//-done
  relationship = [entity relationshipNamed:[handler relationshipName]];//-done
  maxBatch = [relationship numberOfToManyFaultsToBatchFetch];//-done

  batchBuffer = [_batchToManyFaultBuffer objectForKey:[entity name]];
  bufHandler = [batchBuffer objectForKey:[relationship name]];

  objects = [NSMutableArray array];

  [objects addObject:[context objectForGlobalID:gid]];//-done

  firstHandler = lastHandler = nil;
  usedHandler = handler;

  if (bufHandler && [bufHandler isEqual:usedHandler] == YES)
    changeBatch = YES;

  if (maxBatch > 1)
    {
      maxBatch--;

      while (maxBatch--)
	{
	  if (lastHandler == nil)
	    {
	      usedHandler = (EOAccessArrayFaultHandler *)[usedHandler
							   previous];

	      if (usedHandler)
		firstHandler = usedHandler;
	      else
		lastHandler = usedHandler = (EOAccessArrayFaultHandler *)
		  [handler next];
	    }
	  else
	    {
	      usedHandler = (EOAccessArrayFaultHandler *)[lastHandler next];

	      if (usedHandler)
		lastHandler = usedHandler;
	    }

	  if (usedHandler == nil)
	    break;

	  if (bufHandler && [bufHandler isEqual:usedHandler] == YES)
	    changeBatch = YES;

	  [objects addObject:[context objectForGlobalID:[usedHandler
							  sourceGlobalID]]];
	}
    }

  if (firstHandler == nil)
    firstHandler = handler;
  if (lastHandler == nil)
    lastHandler = handler;

  usedHandler = (id)[firstHandler previous];
  bufHandler = (id)[lastHandler next];
  if (usedHandler)
    [usedHandler _linkNext:bufHandler];

  usedHandler = bufHandler;
  if (usedHandler)
    {
      [usedHandler _linkPrev:[firstHandler previous]];
      if (bufHandler == nil)
	bufHandler = usedHandler;
    }

  if (changeBatch == YES)
    {
      if (bufHandler)
	[batchBuffer setObject:bufHandler
		     forKey:[relationship name]];
      else
	[batchBuffer removeObjectForKey:[relationship name]];
    }

  [self batchFetchRelationship:relationship
	forSourceObjects:objects
	editingContext:context];
*/


}

- (void) _fireFault: (id)object
{
  //TODO
  BOOL fetchIt = YES;//MIRKO
  EOGlobalID *gid;
  
  
  
  //MIRKO
  NSDebugMLLog(@"EODatabaseContext",@"Fire Fault: object %p of class %@",
               object,[object class]);
  
  if (_delegateRespondsTo.shouldFetchObjectFault == YES)
  {
    fetchIt = [_delegate databaseContext: self
                  shouldFetchObjectFault: object];
  }
  
  if (fetchIt)
  {
    EOAccessFaultHandler *handler;
    EOEditingContext *context;
    NSDictionary *snapshot;
    EOEntity *entity = nil;
    NSString *entityName = nil;
    
    handler = (EOAccessFaultHandler *)[EOFault handlerForFault: object];
    context = [handler editingContext];
    gid = [handler globalID];
    snapshot = EODatabaseContext_snapshotForGlobalIDWithImpPtr(self,NULL,gid); //nil
    
    if (snapshot)
    {
      //TODO _fireFault snapshot
      NSEmitTODO();
      //          [self notImplemented: _cmd]; //TODO
    }
    
    entity = [self entityForGlobalID: gid];
    entityName = [entity name];
    
    if ([entity cachesObjects])
    {
      //TODO _fireFault [entity cachesObjects]
      NSEmitTODO();
      [self notImplemented: _cmd]; //TODO
    }
    
    //??? generation # EOAccessGenericFaultHandler//ret 2
    {
      EOAccessFaultHandler *previousHandler;
      EOAccessFaultHandler *nextHandler;
      EOFetchSpecification *fetchSpecif;
      NSArray *objects;
      EOQualifier *qualifier;
      /*int maxNumberOfInstancesToBatchFetch =
       [entity maxNumberOfInstancesToBatchFetch];
       NSDictionary *snapshot = [self snapshotForGlobalID: gid];*///nil //TODO use it !
      NSDictionary *pk = [entity primaryKeyForGlobalID: (EOKeyGlobalID *)gid];
      EOQualifier *pkQualifier = [entity qualifierForPrimaryKey: pk];
      NSMutableArray *qualifiers = [NSMutableArray array];
      
      [qualifiers addObject: pkQualifier];
      
      previousHandler = (EOAccessFaultHandler *)[handler previous];
      nextHandler = (EOAccessFaultHandler *)[handler next]; //nil
      
      fetchSpecif = AUTORELEASE([EOFetchSpecification new]);
      [fetchSpecif setEntityName: entityName];
      
      qualifier = [EOOrQualifier qualifierWithQualifierArray: qualifiers];
      
      [fetchSpecif setQualifier: qualifier];
      
      objects = [self objectsWithFetchSpecification: fetchSpecif
                                     editingContext: context];
      
      NSDebugMLLog(@"EODatabaseContext", @"objects %p=%@ class=%@",
                   objects, objects, [objects class]);
    }
  }
  
  if (_isFault(object)) {
    [EOFault clearFault: object];
    
    if ((!_delegate) || (!_delegateRespondsTo.databaseContextFailedToFetchObject) ||
        (![_delegate databaseContext:self
                 failedToFetchObject:object
                            globalID:gid]))
    {
      [_missingObjectGIDs addObject:gid];
    }
  }
  
}

/*
- (void)_batchToOne:(id)fault
	withHandler:(EOAccessFaultHandler *)handler
{
  EOAccessFaultHandler *usedHandler, *firstHandler, *lastHandler;
  EOAccessFaultHandler *bufHandler;
  EOFetchSpecification *fetch;
  EOEditingContext *context;
  EOKeyGlobalID *gid;
  EOQualifier *qualifier;
  EOEntity *entity;
  NSMutableArray *qualifierArray;
  BOOL batch = YES, changeBatch = NO;
  unsigned int maxBatch;

  if (_delegateRespondsTo.shouldFetchObjectFault == YES)//-done
    batch = [_delegate databaseContext:self
		       shouldFetchObjectFault:fault];//-done

  if (batch == NO)//-done
    return;//-done

  gid = [handler globalID];//-done
  context = [handler editingContext];//-done

  entity = [_database entityNamed:[gid entityName]];//-done
  maxBatch = [entity maxNumberOfInstancesToBatchFetch];//-done

  bufHandler = [_batchFaultBuffer objectForKey:[entity name]];

  firstHandler = lastHandler = nil;
  usedHandler = handler;

  if (bufHandler && [bufHandler isEqual:usedHandler] == YES)
    changeBatch = YES;

  if (maxBatch <= 1)
    {
      qualifier = [entity qualifierForPrimaryKey:
			    [entity primaryKeyForGlobalID:gid]];
    }
  else
    {
      qualifierArray = [NSMutableArray array];

      [qualifierArray addObject:
			[entity qualifierForPrimaryKey:
				  [entity primaryKeyForGlobalID:gid]]];

      maxBatch--;

      while (maxBatch--)
	{
	  if (lastHandler == nil)
	    {
	      usedHandler = (EOAccessFaultHandler *)[usedHandler previous];

	      if (usedHandler)
		firstHandler = usedHandler;
	      else
		lastHandler = usedHandler = (EOAccessFaultHandler *)[handler
								      next];
	    }
	  else
	    {
	      usedHandler = (EOAccessFaultHandler *)[lastHandler next];

	      if (usedHandler)
		lastHandler = usedHandler;
	    }

	  if (usedHandler == nil)
	    break;

	  if (changeBatch == NO &&
	     bufHandler && [bufHandler isEqual:usedHandler] == YES)
	    changeBatch = YES;

	  [qualifierArray addObject:
			    [entity qualifierForPrimaryKey:
				      [entity primaryKeyForGlobalID:
						[usedHandler globalID]]]];
	}

      qualifier = AUTORELEASE([[EOOrQualifier alloc]
		     initWithQualifierArray:qualifierArray]);
    }

  if (firstHandler == nil)
    firstHandler = handler;
  if (lastHandler == nil)
    lastHandler = handler;

  usedHandler = (id)[firstHandler previous];
  bufHandler = (id)[lastHandler next];
  if (usedHandler)
    [usedHandler _linkNext:bufHandler];

  usedHandler = bufHandler;
  if (usedHandler)
    {
      [usedHandler _linkPrev:[firstHandler previous]];
      if (bufHandler == nil)
	bufHandler = usedHandler;
    }

  if (changeBatch == YES)
    {
      if (bufHandler)
	[_batchFaultBuffer setObject:bufHandler
			   forKey:[entity name]];
      else
	[_batchFaultBuffer removeObjectForKey:[entity name]];
    }

  fetch = [EOFetchSpecification fetchSpecificationWithEntityName:[entity name]
				qualifier:qualifier
				sortOrderings:nil];//-done

  [context objectsWithFetchSpecification:fetch];//-done
}*/


// Clear all the faults for the relationship pointed by the source objects and
// make sure to perform only a single, efficient, fetch (two fetches if the
// relationship is many to many).

- (void)_addBatchForGlobalID: (EOKeyGlobalID *)globalID
		       fault: (EOFault *)fault
{





  if (fault)
    {
      EOAccessGenericFaultHandler *handler = nil;
      NSString *entityName = [globalID entityName];



      handler = [_batchFaultBuffer objectForKey: entityName];



      if (handler)
        {
          [(EOAccessGenericFaultHandler *)
	    [EOFault handlerForFault: fault]
	             linkAfter: handler
	             usingGeneration: [handler generation]];
        }
      else
        {
          handler = (EOAccessGenericFaultHandler *)[EOFault handlerForFault:
							      fault];

          NSAssert1(handler, @"No handler for fault:%@", fault);

          [_batchFaultBuffer setObject: handler
                             forKey: entityName];
        }
    }


}

- (void)_removeBatchForGlobalID: (EOKeyGlobalID *)globalID
			  fault: (EOFault *)fault
{
  EOAccessGenericFaultHandler *handler, *prevHandler, *nextHandler;
  NSString *entityName = [globalID entityName];

  handler = (EOAccessGenericFaultHandler *)[EOFault handlerForFault: fault];

  prevHandler = [handler previous];
  nextHandler = [handler next];

  if (prevHandler)
    [prevHandler _linkNext: nextHandler];
  if (nextHandler)
    [nextHandler _linkPrev: prevHandler];

  if ([_batchFaultBuffer objectForKey: entityName] == handler)
    {
      if (prevHandler)
	[_batchFaultBuffer setObject: prevHandler
			   forKey: entityName];
      else if (nextHandler)
	[_batchFaultBuffer setObject: nextHandler
			   forKey: entityName];
      else
	[_batchFaultBuffer removeObjectForKey: entityName];
    }
}

- (void)_addToManyBatchForSourceGlobalID: (EOKeyGlobalID *)globalID
			relationshipName: (NSString *)relationshipName
				   fault: (EOFault *)fault
{
  if (fault)
    {
      NSMutableDictionary *buf;
      EOAccessGenericFaultHandler *handler;
      NSString *entityName = [globalID entityName];

      buf = [_batchToManyFaultBuffer objectForKey: entityName];

      if (buf == nil)
        {
          buf = [NSMutableDictionary dictionaryWithCapacity: 8];
          [_batchToManyFaultBuffer setObject: buf
                                   forKey: entityName];
        }
      
      handler = [buf objectForKey: relationshipName];

      if (handler)
        {
          [(EOAccessGenericFaultHandler *)
	    [EOFault handlerForFault: fault]
	             linkAfter: handler
	             usingGeneration: [handler generation]];
        }
      else
        [buf setObject: [EOFault handlerForFault: fault]
             forKey: relationshipName];
    }
}

@end


@implementation EODatabaseContext (EODatabaseSnapshotting)

- (void)recordSnapshot: (NSDictionary *)snapshot
	   forGlobalID: (EOGlobalID *)gid
{


  NSDebugMLLog(@"EODatabaseContext", @"self=%p database=%p",
	       self, _database);
  NSDebugMLLog(@"EODatabaseContext", @"self=%p _uniqueStack %p=%@",
	       self, _uniqueStack, _uniqueStack);

  if ([_uniqueStack count] > 0)
    {
      NSMutableDictionary *snapshots = [_uniqueStack lastObject];

      [snapshots setObject: snapshot
                 forKey: gid];
    }
  else
    {
      NSEmitTODO();
      NSWarnLog(@"_uniqueStack is empty. May be there's no runing transaction !");

      [self notImplemented: _cmd]; //TODO
    }

  NSDebugMLLog(@"EODatabaseContext", @"self=%p _uniqueStack %p=%@",
	       self, _uniqueStack, _uniqueStack);


}

- (NSDictionary *)snapshotForGlobalID: (EOGlobalID *)gid
{
  return [self snapshotForGlobalID: gid
	       after: EODistantPastTimeInterval];
}

- (NSDictionary *)snapshotForGlobalID: (EOGlobalID *)gid
                                after: (NSTimeInterval)ti
{
  //OK
  NSDictionary *snapshot = nil;



  NSDebugMLLog(@"EODatabaseContext", @"self=%p database=%p",
	       self, _database);


  snapshot = [self localSnapshotForGlobalID: gid];

  if (!snapshot)
    {
      NSAssert(_database, @"No database");
      snapshot = [_database snapshotForGlobalID: gid
			    after: ti];
    }

  NSDebugMLLog(@"EODatabaseContext", @"snapshot for gid %@: %p %@",
	       gid, snapshot, snapshot);



  return snapshot;
}

- (void)recordSnapshot: (NSArray *)gids
     forSourceGlobalID: (EOGlobalID *)gid
      relationshipName: (NSString *)name
{


  NSEmitTODO();

  [self notImplemented: _cmd]; //TODO
/*
  NSMutableDictionary *toMany = [_toManySnapshots objectForKey:gid];

  if (toMany == nil)
    {
      toMany = [NSMutableDictionary dictionaryWithCapacity:16];
      [_toManySnapshots setObject:toMany
			forKey:gid];
    }

  [toMany setObject:gids
          forKey:name];
*/


}

- (NSArray *)snapshotForSourceGlobalID: (EOGlobalID *)gid
		      relationshipName: (NSString *)name
{
  NSArray *snapshot = nil;


  NSEmitTODO();

  [self notImplemented: _cmd]; //TODO
/*

  snapshot = [[_toManySnapshots objectForKey:gid] objectForKey:name];
  if (!snapshot)
    snapshot=[_database snapshotForSourceGlobalID:gid
                        relationshipName:name];
*/



  return snapshot;
}

- (NSDictionary *)localSnapshotForGlobalID: (EOGlobalID *)gid
{
  //OK
  NSDictionary *snapshot = nil;
  int snapshotsDictCount = 0;



  NSDebugMLLog(@"EODatabaseContext", @"self=%p database=%p",
	       self, _database);

  snapshotsDictCount = [_uniqueStack count];

  if (snapshotsDictCount>0)
    {
      int i = 0;
      IMP oaiIMP=[_uniqueStack methodForSelector: @selector(objectAtIndex:)];

      for (i = 0; !snapshot && i < snapshotsDictCount; i++)
        {
          NSDictionary *snapshots = GDL2_ObjectAtIndexWithImp(_uniqueStack,oaiIMP,i);
          snapshot = [snapshots objectForKey: gid];
        }
    };

  NSDebugMLLog(@"EODatabaseContext", @"snapshot for gid %@: %p %@",
	       gid, snapshot, snapshot);



  return snapshot;
}

- (NSArray *)localSnapshotForSourceGlobalID: (EOGlobalID *)gid
			   relationshipName: (NSString *)name
{
  NSArray *snapshot = nil;

  //TODO

  NSEmitTODO();

  [self notImplemented: _cmd]; //TODO
/*
  return [[_toManySnapshots objectForKey:gid] objectForKey:name];
*/



  return snapshot;
}

- (void)forgetSnapshotForGlobalID: (EOGlobalID *)gid
{
  //TODO-VERIFY deleteStack


  NSDebugMLLog(@"EODatabaseContext",
	       @"self=%p database=%p [_uniqueStack count]=%d",
	       self, _database,[_uniqueStack count]);

  if ([_uniqueStack count] > 0)
    {
      NSMutableDictionary *uniqueSS = [_uniqueStack lastObject];
      NSMutableDictionary *uniqArSS = [_uniqueArrayStack lastObject];
      NSMutableSet        *deleteSS = [_deleteStack lastObject];

      [deleteSS addObject: gid];
      [uniqueSS removeObjectForKey: gid];
      [uniqArSS removeObjectForKey: gid];
    }


}

- (void)forgetSnapshotsForGlobalIDs: (NSArray *)gids
{
  unsigned i, j, n, m;
  NSMutableDictionary *snapshots;
  NSMutableSet *deleteGIDs;
  EOGlobalID *gid;


  n = [_uniqueStack count];
  if (n>0)
    {
      IMP oaiIMP=[_uniqueStack methodForSelector: @selector(objectAtIndex:)];

      for (i=0; i<n; i++)
        {
          snapshots = GDL2_ObjectAtIndexWithImp(_uniqueStack,oaiIMP,i);
          [snapshots removeObjectsForKeys: gids];
        }
    };

  n = [_uniqueArrayStack count];
  if (n>0)
    {
      IMP oaiIMP
	= [_uniqueArrayStack methodForSelector: @selector(objectAtIndex:)];

      for (i=0; i<n; i++)
        {
          snapshots = GDL2_ObjectAtIndexWithImp(_uniqueArrayStack,oaiIMP,i);
          [snapshots removeObjectsForKeys: gids];
        }
    };

  n = [_deleteStack count];
  if (n>0)
    {
      IMP oaiIMP=[_deleteStack methodForSelector: @selector(objectAtIndex:)];
      IMP oaiIMP2=[gids methodForSelector: @selector(objectAtIndex:)];

      m = [gids count];
      for (i=0; i<n; i++)
        {
          deleteGIDs = GDL2_ObjectAtIndexWithImp(_deleteStack,oaiIMP,i);
	  for (j=0; j<m; j++)
	    {
	      gid = GDL2_ObjectAtIndexWithImp(gids, oaiIMP2, j);
	      [deleteGIDs removeObject: gid];
	    }
        }
    }

  [_database forgetSnapshotsForGlobalIDs: gids];

}

- (void)recordSnapshots: (NSDictionary *)snapshots
{


  NSEmitTODO();
  [self notImplemented: _cmd]; //TODO
/*
  [_snapshots addEntriesFromDictionary:snapshots];
*/


}

- (void)recordToManySnapshots: (NSDictionary *)snapshots
{

  //OK

  if ([_uniqueArrayStack count] > 0)
    {
      NSMutableDictionary *toManySnapshots = [_uniqueArrayStack lastObject];
      NSArray *keys = [snapshots allKeys];
      int count = [keys count];

      if (count>0)
        {
          IMP oaiIMP=[keys methodForSelector: @selector(objectAtIndex:)];
          int i = 0;

          for (i = 0; i < count; i++)
            {
              id key = GDL2_ObjectAtIndexWithImp(keys,oaiIMP,i);
              NSDictionary *snapshotsDict = [snapshots objectForKey: key];
              NSMutableDictionary *currentSnapshotsDict =
                [toManySnapshots objectForKey: key];
              
              if (!currentSnapshotsDict)
                {
                  currentSnapshotsDict = (NSMutableDictionary *)[NSMutableDictionary
                                                                  dictionary];
                  [toManySnapshots setObject: currentSnapshotsDict
                                   forKey: key];
                }
              
              [currentSnapshotsDict addEntriesFromDictionary: snapshotsDict];
            }
        };
    }


}

- (void)registerLockedObjectWithGlobalID: (EOGlobalID *)globalID
{


  if (!_lockedObjects)
    {
      _lockedObjects 
	= NSCreateHashTable(NSNonOwnedPointerHashCallBacks, _LOCK_BUFFER);
    }

  NSHashInsert(_lockedObjects, globalID);


}

- (BOOL)isObjectLockedWithGlobalID: (EOGlobalID *)globalID
{
  BOOL result;



  result = (_lockedObjects && NSHashGet(_lockedObjects, globalID) != nil);



  return result;
}

- (void)initializeObject: (id)object
                     row: (NSDictionary*)row
                  entity: (EOEntity*)entity
          editingContext: (EOEditingContext*)context
{
  //really near ok
  NSArray *relationships = nil;
  NSArray *classPropertyAttributeNames = nil;
  NSUInteger count = 0;
  IMP rowObjectForKeyIMP=NULL;
  
  classPropertyAttributeNames = [entity classPropertyAttributeNames];
  count = [classPropertyAttributeNames count];
  
  //row is usuallly a EOMutableKnownKeyDictionary so will use EOMKKD_objectForKeyWithImpPtr
  
  if (count>0)
  {
    NSUInteger i=0;
    IMP oaiIMP=[classPropertyAttributeNames methodForSelector:@selector(objectAtIndex:)];
    
    NSAssert(!_isFault(object),
             @"Object is a fault. call -methodForSelector: on it is a bad idea");
    
    for (i = 0; i < count; i++)
    {
      id key = GDL2_ObjectAtIndexWithImp(classPropertyAttributeNames,oaiIMP,i);
      id value = nil;
      
      
      value = EOMKKD_objectForKeyWithImpPtr(row,&rowObjectForKeyIMP,key);
      
      if (value == GDL2_EONull)
        value = nil;
            
      [object takeStoredValue:value
                       forKey:key];
    }
  };
  
  relationships = [entity _relationshipsToFaultForRow: row];
  
  
  
  count = [relationships count];
  
  if (count>0)
  {
    NSUInteger i=0;
    IMP oaiIMP=[relationships methodForSelector:@selector(objectAtIndex:)];
    
    NSAssert(!_isFault(object),
             @"Object is a fault. call -methodForSelector: on it is a bad idea");
    
    
    for (i = 0; i < count; i++)
    {
      id relObject = nil;
      EORelationship *relationship = GDL2_ObjectAtIndexWithImp(relationships,oaiIMP,i);
      NSString *relName = [relationship name];
      
      
      if ([relationship isToMany])
      {
        EOGlobalID *gid = [entity globalIDForRow: row];
        
        relObject = [self arrayFaultWithSourceGlobalID: gid
                                      relationshipName: relName
                                        editingContext: context];
      }
      else if ([relationship isFlattened])
      {
        // to one flattened relationship like aRelationship.anotherRelationship...
        
        // I don't know how to handle this case.... May be we shouldn't treat this as real property ??
        NSEmitTODO();
        relObject = nil;          
      }
      else
      {          
        EOMutableKnownKeyDictionary *foreignKeyForSourceRow = nil;
                
        foreignKeyForSourceRow = [relationship _foreignKeyForSourceRow: row];
                
        if (![foreignKeyForSourceRow
              containsObjectsNotIdenticalTo: GDL2_EONull])
        {
          NSEmitTODO();//TODO: what to do if rel is mandatory ?
          relObject = nil;
        }
        else
        {
          EOEntity *destinationEntity = [relationship destinationEntity];
          EOGlobalID *relRowGid = [destinationEntity
                                   globalIDForRow: foreignKeyForSourceRow];
          
          
          
          if ([(EOKeyGlobalID*)relRowGid areKeysAllNulls])
            NSWarnLog(@"All key of relRowGid %p (%@) are nulls",
                      relRowGid,
                      relRowGid);
          
          relObject = [context faultForGlobalID: relRowGid
                                 editingContext: context];
          
          NSDebugMLLog(@"EODatabaseContext", @"relObject=%p (%@)",
                       relObject, [relObject class]);
          //end
          /*
           NSArray *joins = [(EORelationship *)prop joins];
           EOJoin *join;
           NSMutableDictionary *row;
           EOGlobalID *faultGID;
           int h, count;
           id value, realValue = nil;
           
           row = [NSMutableDictionary dictionaryWithCapacity:4];
           
           count = [joins count];
           for (h=0; h<count; h++)
           {
           join = [joins objectAtIndex:h];
           
           value = [snapshot objectForKey:[[join sourceAttribute]
           name]];
           if (value == null)
           realValue = nil;
           else
           realValue = value;
           
           [[prop validateValue:&realValue] raise];
           
           [row setObject:value
		       forKey:[[join destinationAttribute]
           name]];
           }
           
           if (realValue || [prop isMandatory] == YES)
           {
           faultGID = [[(EORelationship *)prop destinationEntity]
           globalIDForRow:row];
           
           fault = [context objectForGlobalID:faultGID];
           
           if (fault == nil)
           fault = [context faultForGlobalID:faultGID
           editingContext:context];
           }
           else
           fault = nil;
           
           */
        }
      }
      
      [object takeStoredValue:relObject
                       forKey:relName];
    }
  };
  
  
}

- (void)forgetAllLocks
{
  if (_lockedObjects)
    {
      NSResetHashTable(_lockedObjects);
    }
}

- (void)forgetLocksForObjectsWithGlobalIDs: (NSArray *)gids
{
  if (_lockedObjects)
    {
      unsigned n;
      EOGlobalID *gid;

      n = [gids count];

      if (n>0)
        {
          IMP oaiIMP=[gids methodForSelector: @selector(objectAtIndex:)];
          unsigned i = 0;

          for (i=0; i<n; i++)
            {
              gid = GDL2_ObjectAtIndexWithImp(gids,oaiIMP,i);
              NSHashRemove(_lockedObjects, gid);
            }
        };
    }
}

- (void)_rollbackTransaction
{


  if ([_uniqueStack count] > 0)
    {
      [self forgetAllLocks];

      [_uniqueStack removeLastObject];
      [_uniqueArrayStack removeLastObject];
      [_deleteStack removeLastObject];
    }


}

- (void)_commitTransaction
{
  
  if ([_uniqueStack count] > 0)
  {
    NSMutableDictionary *snapshotsDict = [_uniqueStack lastObject];
    NSMutableDictionary *toManySnapshotsDict = [_uniqueArrayStack lastObject];
    NSMutableSet *deleteSnapshotsSet = [_deleteStack lastObject];
    NSEnumerator *deletedGIDEnum = [deleteSnapshotsSet objectEnumerator];
    EOGlobalID *gid;
    
    while ((gid = [deletedGIDEnum nextObject]))
    {
      [_database forgetSnapshotForGlobalID: gid];
    }
    
    [_database recordSnapshots: snapshotsDict];
    [_database recordToManySnapshots: toManySnapshotsDict];
    
    [self forgetAllLocks];
    
    [_uniqueStack removeLastObject];
    [_uniqueArrayStack removeLastObject];
    [_deleteStack removeLastObject];
  }
  
}

- (void) _beginTransaction
{
  [_uniqueStack addObject: [NSMutableDictionary dictionary]];
  [_uniqueArrayStack addObject: [NSMutableDictionary dictionary]];
  [_deleteStack addObject: [NSMutableSet set]];
}

- (EODatabaseChannel*) _obtainOpenChannel
{
  EODatabaseChannel *channel = [self availableChannel];

  if (![self _openChannelWithLoginPanel: channel])
    {
      NSEmitTODO();
      [self notImplemented: _cmd];//TODO
    }

  return channel;
}

- (BOOL) _openChannelWithLoginPanel: (EODatabaseChannel*)databaseChannel
{
  // veridy: LoginPanel ???
  EOAdaptorChannel *adaptorChannel = [databaseChannel adaptorChannel];

  if (![adaptorChannel isOpen]) //??
    {
      [adaptorChannel openChannel];
    }

  return [adaptorChannel isOpen];
}

- (void) _forceDisconnect
{ // TODO
  NSEmitTODO();
  [self notImplemented: _cmd];
}

@end


@implementation EODatabaseContext(EOMultiThreaded)

- (void)lock
{
  [_lock lock];
}

- (void)unlock
{
  [_lock unlock];
}

@end

@implementation EODatabaseContext (EODatabaseContextPrivate2)

- (void) _verifyNoChangesToReadonlyEntity: (EODatabaseOperation*)dbOpe
{
  //TODO
  EOEntity *entity = nil;



  entity = [dbOpe entity];



  if ([entity isReadOnly])
    {
      //?? exception I presume
    }
  else
    {
      [dbOpe databaseOperator]; //SoWhat
    }


}

- (void) _cleanUpAfterSave
{
  // TODO -- dw
  //EODatabase * eodatabase = [self database];

  _coordinator = nil; //realesae ?
  _editingContext = nil; //realesae ?

  if (_dbOperationsByGlobalID)
    {
      //Really free it because we don't want to record some db ope (select for exemple).
      NSFreeMapTable(_dbOperationsByGlobalID);
      _dbOperationsByGlobalID = NULL;
    }

  _flags.beganTransaction = NO;
  _flags.willPrepareForSave = NO;
  _flags.preparingForSave = NO;
  
  // TODO -- dw
//  if (eodatabase != nil)
//  {
//    [eodatabase _clearLastRecords];
//  }
  
}

- (EOGlobalID*)_globalIDForObject: (id)object
{
  EOEditingContext *objectEditingContext = nil;
  EOGlobalID *gid = nil;


  NSAssert(object, @"No object");

  NSDebugMLLog(@"EODatabaseContext",@"object=%p of class %@",
	       object,[object class]);
  NSDebugMLLog(@"EODatabaseContext", @"_editingContext=%p",
	       _editingContext);

  objectEditingContext = [object editingContext];
  NSAssert2(objectEditingContext, @"No editing context for object %p: %@", 
            object,object);

  gid=EOEditingContext_globalIDForObjectWithImpPtr(objectEditingContext,
                                                   NULL,
                                                   object);


  if (!gid)
    {
      NSEmitTODO();
      NSLog(@"TODO: no GID in EODatabaseContext _globalIDForObject:");
      //TODO exception ? ==> RollbackCh
    }



  return gid;
}

- (NSDictionary*)_primaryKeyForObject: (id)object
{
  //Ayers: Review
  return [self _primaryKeyForObject: object
               raiseException: YES];
}

- (NSDictionary*)_primaryKeyForObject: (id)object
                       raiseException: (BOOL)raiseException
{
  NSDictionary *pk = nil;
  EOEntity *entity = nil;
  NSArray *pkNames = nil;
  NSDictionary *pk2 = nil;
  
  NSAssert(!_isNilOrEONull(object), @"No object");
  
  entity = [_database entityForObject: object];
  
  EOGlobalID *gid = EODatabaseContext_globalIDForObjectWithImpPtr(self,NULL,object);
  
  pk = [entity primaryKeyForGlobalID: (EOKeyGlobalID*)gid]; //OK
  
  pkNames = [entity primaryKeyAttributeNames];
  
  pk2 = [self valuesForKeys: pkNames
                     object: object];
  
  if ([pk2 count] > 0) 
  {
    if (pk)
    {
      //merge pk2 into pk
      NSEnumerator *pk2Enum = [pk2 keyEnumerator];
      IMP pk2EnumNO=NULL; // nextObject
      NSMutableDictionary *realPK;
      
      realPK = [NSMutableDictionary dictionaryWithDictionary: pk];
      id key = nil;
      
      while ((key = GDL2_NextObjectWithImpPtr(pk2Enum,&pk2EnumNO)))
      {
        id value = [pk2 objectForKey: key];
        
        if (((value) && (value != GDL2_EONull)) &&
            (([value isKindOfClass:[NSNumber class]] == NO) || ([value intValue] != 0)))
        {
          [realPK setObject: value
                     forKey: key];
        }
      }
      
      pk = realPK;
    }
    else
      pk=pk2;
  }
  
  if (([entity isPrimaryKeyValidInObject: pk] == NO)) {
    pk = nil;
  }    
  
  // no PK? Ask the delegate to make one for us.
  if (pk == nil)
  {      
    if (_delegateRespondsTo.newPrimaryKey == YES)
      pk = [_delegate databaseContext: self
               newPrimaryKeyForObject: object
                               entity: entity];
  }
  
  // still no PK?
  if (pk == nil)
  {
    EOAdaptorChannel *channel = nil;
    EOStoredProcedure *nextPKProcedure = nil;
    
    nextPKProcedure = [entity storedProcedureForOperation:
                       EONextPrimaryKeyProcedureOperation];
    
    if (nextPKProcedure) 
    {      
      NS_DURING {
        
        channel = [[self _obtainOpenChannel] adaptorChannel];
        
        [channel executeStoredProcedure:nextPKProcedure
                             withValues:nil];
        
        pk = [channel returnValuesForLastStoredProcedureInvocation];
        
      } NS_HANDLER {
        // if the delegate took care about the exception
        // or we lost connection, try it again.
        if (([self _delegateHandledDatabaseException:localException]) ||
            ([[_database adaptor] isDroppedConnectionException:localException]))
        {
          channel = [[self _obtainOpenChannel] adaptorChannel];
          
          [channel executeStoredProcedure:nextPKProcedure
                               withValues:nil];
          
          pk = [channel returnValuesForLastStoredProcedureInvocation];
        } else {
          [localException raise];
        }
      }
    } NS_ENDHANDLER;
  }
  
  if (pk)
  {
    pk = [entity primaryKeyForRow:pk];
  }
  
  if (!pk) {
    EOAttribute * pkAttr = nil;
    NSArray     * pkAttributes = [entity primaryKeyAttributes];
    
    if ((pkAttributes) && ([pkAttributes count] == 1)) {
      pkAttr = [pkAttributes objectAtIndex: 0];
    }          
    if ((pkAttr) && (([pkAttr adaptorValueType] == EOAdaptorBytesType) && 
                     ([pkAttr width] == 24)))
    {
      unsigned char bytes[24];
      id            byteValue = nil;
      
      memset(&bytes, 0, sizeof(bytes));
      
      [EOTemporaryGlobalID assignGloballyUniqueBytes:&bytes[0]];
      
      byteValue = [pkAttr newValueForBytes: &bytes
                                    length:sizeof(bytes)];
      pk = [NSDictionary dictionaryWithObject:byteValue
                                       forKey:[pkAttr name]];
    }          
  }
  
  if (!pk) {
    EOAdaptorChannel *channel = nil;
    
    NS_DURING {
      channel = [[self _obtainOpenChannel] adaptorChannel];
      
      pk = [channel primaryKeyForNewRowWithEntity:entity];
      
    } NS_HANDLER {
      // if the delegate took care about the exception
      // or we lost connection, try it again.
      if (([self _delegateHandledDatabaseException:localException]) ||
          ([[_database adaptor] isDroppedConnectionException:localException]))
      {
        channel = [[self _obtainOpenChannel] adaptorChannel];
        
        pk = [channel primaryKeyForNewRowWithEntity:entity];
        
      } else {
        [localException raise];
      }
    } NS_ENDHANDLER;
  }
  // TODO: The reference does not raise here I suppose -- dw.
  //    if (!pk) {
  //      [NSException raise: NSInvalidArgumentException
  //                  format: @"%@ -- %@ 0x%x: cannot generate primary key for object '%@'",
  //       NSStringFromSelector(_cmd),
  //       NSStringFromClass([self class]),
  //       self, object];
  //    }
  
  
  return pk;
}

- (BOOL) _shouldGeneratePrimaryKeyForEntityName: (NSString*)entityName
{
  //OK
  BOOL shouldGeneratePK = YES;



  if (_nonPrimaryKeyGenerators)
    shouldGeneratePK = !NSHashGet(_nonPrimaryKeyGenerators, entityName);

  NSDebugMLLog(@"EODatabaseContext", @"shouldGeneratePK for %@: %s",
	       entityName,
	       (shouldGeneratePK ? "YES" : "NO"));
  NSAssert(![entityName isEqualToString: @"Country"]
	   || shouldGeneratePK, @"MGVALID: Failed");
  return shouldGeneratePK;
}

// private
- (EOEntity*) _entityForObject:(EOCustomObject*) eo
{
  EOEntity                 * entity = nil;
  EOObjectStoreCoordinator * coordinator = nil;
  NSArray                  * cooperatingObjectStores = nil;
  NSUInteger                 i = 0;
  NSUInteger                 count = 0;
  
  if (!eo)
  {
    [NSException raise: NSInvalidArgumentException
                format: @"%s -- Enterprise object cannot be nil", __PRETTY_FUNCTION__];    
  }
  
  entity = [_database entityForObject:eo];

  if (entity)
  {
    return entity;
  }
  
  coordinator = [self coordinator];
  if (!coordinator)
  {
    [NSException raise: NSInternalInconsistencyException
                format: @"%s -- Object store coordinator cannot be nil", __PRETTY_FUNCTION__];    
  }
  
  cooperatingObjectStores = [coordinator cooperatingObjectStores];

  count = [cooperatingObjectStores count];
  
  for (i = 0; i < count; i++)
  {
    id store = [cooperatingObjectStores objectAtIndex:i];
    if (!([store isKindOfClass:[EODatabaseContext class]]))
    {
      continue;
    }
    entity = [[(EODatabaseContext*)store database] entityForObject:eo];
    if (entity)
    {
      return entity;
    }
  }
  [NSException raise: NSInternalInconsistencyException
              format: @"%s -- Unable to find entity for object %@", __PRETTY_FUNCTION__, eo];
  // no warnings pls.
  return nil;
}

- (void)_buildPrimaryKeyGeneratorListForEditingContext: (EOEditingContext*)context
{
  NSArray *objects[3];
  NSHashTable *processedEntities = NULL;
  NSMutableArray *entityToProcess = nil;
  NSUInteger which;



  if (_nonPrimaryKeyGenerators)
    {
      NSResetHashTable(_nonPrimaryKeyGenerators);
    }

  processedEntities = NSCreateHashTable(NSObjectHashCallBacks, 32);

  objects[0] = [context updatedObjects];
  objects[1] = [context insertedObjects];
  objects[2] = [context deletedObjects];

  for (which = 0; which < 3; which++)
    {
      NSUInteger count = [objects[which] count];

      if (count>0)
        {
          IMP oaiIMP=[objects[which] methodForSelector: @selector(objectAtIndex:)];
          NSUInteger i = 0;
          
          for (i = 0; i < count; i++)
            {
              id object = GDL2_ObjectAtIndexWithImp(objects[which],oaiIMP,i);
              EOEntity *entity = [_database entityForObject: object];
              
              NSDebugMLLog(@"EODatabaseContext",
                           @"add entity to process: %@", [entity name]);
              
              if (entityToProcess)
                [entityToProcess addObject: entity];
              else
                entityToProcess = [NSMutableArray arrayWithObject: entity];
            }
        };
    }
  
  while ([entityToProcess count])
    {
      EOEntity *entity = [entityToProcess lastObject];



      [entityToProcess removeLastObject];

      if (!NSHashInsertIfAbsent(processedEntities, entity)) //Already processed ?
        {
          NSArray *relationships = [entity relationships];
          NSUInteger relationshipsCount = [relationships count];

          if (relationshipsCount>0)
            {
              IMP relObjectAtIndexIMP=[relationships methodForSelector: @selector(objectAtIndex:)];
              NSUInteger iRelationship = 0;
          
              for (iRelationship = 0;
                   iRelationship < relationshipsCount;
                   iRelationship++)
                {
                  EORelationship *relationship = GDL2_ObjectAtIndexWithImp(relationships,relObjectAtIndexIMP,iRelationship);
                  NSDebugMLLog(@"EODatabaseContext", 
                               @"test entity: %@ relationship=%@",
                               [entity name],
                               relationship);
                  
                  if ([relationship propagatesPrimaryKey])
                    {
                      EOEntity *destinationEntity = [relationship
                                                      destinationEntity];
                      NSDebugMLLog(@"EODatabaseContext", 
                                   @"test entity: %@ destinationEntity=%@",
                                   [entity name],
                                   [destinationEntity name]);
                      
                      if (destinationEntity)
                        {
                          NSArray *destAttrs;
                          NSArray *pkAttrs;
                          NSUInteger count;
                          BOOL destPK = NO;
                          
                          destAttrs = [relationship destinationAttributes];
                          pkAttrs = [destinationEntity primaryKeyAttributes];
                          count = [destAttrs count];

                          if (count>0)
                            {
                              IMP destAttrsObjectAtIndexIMP=[relationships methodForSelector: @selector(objectAtIndex:)];
                              NSUInteger i=0;
                              for (i = 0; i < count; i++)
                                {
                                  if ([pkAttrs containsObject:
                                                 GDL2_ObjectAtIndexWithImp(destAttrs,destAttrsObjectAtIndexIMP,i)])
                                    destPK = YES;
                                }
                            };
                          if (destPK)
                            {
                              NSDebugMLLog(@"EODatabaseContext",
                                           @"destination entity: %@ "
                                           @"No PK generation [Rel = %@]",
                                           [destinationEntity name],
                                           [relationship name]);
                              
                              if (!_nonPrimaryKeyGenerators)
                                _nonPrimaryKeyGenerators = NSCreateHashTable(NSObjectHashCallBacks, 32);
                              
                              NSHashInsertIfAbsent(_nonPrimaryKeyGenerators, [destinationEntity name]);
                              [entityToProcess addObject: destinationEntity];
                            }
                        }
                    }
                }
            }
        }
    }

  NSDebugMLLog(@"EODatabaseContext",
	       @"_nonPrimaryKeyGenerators=%@",
	       NSStringFromHashTable(_nonPrimaryKeyGenerators));
  


  NSFreeHashTable(processedEntities);
}

/** Returns a dictionary containing a snapshot of object that reflects its committed values (last values putted in the database; i.e. values before changes were made on the object).
It is updated after commiting new values.
If the object has been just inserted, the dictionary is empty.
**/
- (NSDictionary*)_currentCommittedSnapshotForObject: (id)object
{
  NSDictionary *snapshot = nil;
  EOGlobalID *gid = nil;
  EODatabaseOperation *dbOpe = nil;
  EODatabaseOperator dbOperator = (EODatabaseOperator)0;



  gid = EOEditingContext_globalIDForObjectWithImpPtr(_editingContext,NULL,object);
  dbOpe = [self databaseOperationForGlobalID: gid]; //I'm not sure. Retrieve it directly ?
  dbOperator = [dbOpe databaseOperator];

  switch (dbOperator)
    {
    case EODatabaseUpdateOperator:
      snapshot = [_editingContext committedSnapshotForObject: object];//OK
      break;

    case EODatabaseInsertOperator:
      snapshot = [NSDictionary dictionary];
      break;

//TODO
/*  else 
    snapshot=XX;//TODO
*/
    case EODatabaseDeleteOperator:
      break;

    case EODatabaseNothingOperator:
      break;
    }

  return snapshot;
}

- (void) _assertValidStateWithSelector: (SEL)sel
{
  if ((!_flags.preparingForSave) && (!_flags.willPrepareForSave))
  {
    [NSException raise: NSInternalInconsistencyException
                format: @"_assertValidStateWithSelector:%s %s is in invalid state, "
                         "call prepareForSaveWithCoordinator: before calling this method.",
     sel_getName(sel),
     object_getClassName(self)];
    
  }
}

- (id) _addDatabaseContextStateToException: (id)param0
{
  NSEmitTODO();
  return [self notImplemented: _cmd]; //TODO
}

- (id) _databaseContextState
{
  NSEmitTODO();
  return [self notImplemented: _cmd]; //TODO
}

@end