/** * Adds an object to the current list of entities to be created. * * @param object the object to be created * @param op the object provider */ public synchronized void addToCreateList(SObject object, ObjectProvider op) { if (createObjectList == null) { createObjectList = new LinkedHashMap<ObjectProvider, SObject>(); pcToSObject = new IdentityHashMap<Object, SObject>(); } createObjectList.put(op, object); pcToSObject.put(op.getObject(), object); }
/** * Adds an object to the current list of entities to be created. * * @param object the object to be created * @param op the object provider */ public synchronized void addToCreateList(SObject object, ObjectProvider op) { if (createObjectList == null) { createObjectList = new LinkedHashMap<ObjectProvider, SObject>(); pcToSObject = new IdentityHashMap<Object, SObject>(); } createObjectList.put(op, object); pcToSObject.put(op.getObject(), object); }
/** * Accessor for whether a field is loaded for the object managed by the StateManager * @param sm StateManager * @param fieldNumber Number of the field * @return Whether it is loaded */ public boolean isLoaded(ObjectProvider sm, int fieldNumber) { return sm.isLoaded(sm.getObject(), fieldNumber); }
/** * Hook for the StateManager to notify us that an object is outdated (no longer valid). * The most common case is that the state of the PC becomes HOLLOW. This is especially important for * object databases employing implicit storing from the main memory to the database (like DB4O). * @param sm StateManager of object */ public void notifyObjectIsOutdated(ObjectProvider sm) { ObjectContainer cont = (ObjectContainer)getConnection(sm.getExecutionContext()).getConnection(); deactivateObject(cont, sm.getObject()); }
final Object newOwner = op.getObject();
Key parentKey = EntityUtils.getKeyForObject(ownerOP.getObject(), ownerOP.getExecutionContext()); KeyRegistry.getKeyRegistry(ownerOP.getExecutionContext()).registerParentKeyForOwnedObject(element, parentKey); while (elementIter.hasNext()) { Object element = elementIter.next(); updateElementFk(ownerOP, element, ownerOP.getObject(), startAt); startAt++;
list.add(sm.getObject()); currentDeleteThreads.put(Thread.currentThread().getName(), list); list.add(sm.getObject()); long datastoreVersion = cont.ext().getObjectInfo(sm.getObject()).getVersion(); if (datastoreVersion > 0) sm.toPrintableID(), sm.getInternalObjectId())); cont.delete(sm.getObject()); if (NucleusLogger.DATASTORE_PERSIST.isDebugEnabled())
public void fetchFields(ObjectProvider esm) { // Find the (element) table storing the FK back to the owner JavaTypeMapping externalFKMapping = elementTable.getExternalMapping(ownerMemberMetaData, MappingConsumer.MAPPING_TYPE_EXTERNAL_FK); if (externalFKMapping != null) { // The element has an external FK mapping so set the value it needs to use in the INSERT esm.setAssociatedValue(externalFKMapping, op.getObject()); } if (relationType == Relation.ONE_TO_MANY_BI) { // TODO Move this into RelationshipManager // Managed Relations : 1-N bidir, so make sure owner is correct at persist Object currentOwner = esm.provideField(getFieldNumberInElementForBidirectional(esm)); if (currentOwner == null) { // No owner, so correct it NucleusLogger.PERSISTENCE.info(LOCALISER.msg("056037", op.toPrintableID(), ownerMemberMetaData.getFullFieldName(), StringUtils.toJVMIDString(esm.getObject()))); esm.replaceFieldMakeDirty(getFieldNumberInElementForBidirectional(esm), newOwner); } else if (currentOwner != newOwner && op.getReferencedPC() == null) { // Owner of the element is neither this container and not being attached // Inconsistent owner, so throw exception throw new NucleusUserException(LOCALISER.msg("056038", op.toPrintableID(), ownerMemberMetaData.getFullFieldName(), StringUtils.toJVMIDString(esm.getObject()), StringUtils.toJVMIDString(currentOwner))); } } }
parentKey = KeyRegistry.getKeyRegistry(ec).getParentKeyForOwnedObject(op.getObject()); ObjectProvider ownerOP = op.getExecutionContext().getObjectProviderOfOwnerForAttachingObject(op.getObject()); if (ownerOP != null) { Object parentPojo = ownerOP.getObject(); ObjectProvider mergeOP = ec.findObjectProvider(parentPojo); if (mergeOP != null) {
if (!cont.ext().isActive(sm.getObject())) Object obj = sm.getObject(); int[] dirtyFieldNumbers = sm.getDirtyFieldNumbers(); if (dirtyFieldNumbers != null && dirtyFieldNumbers.length > 0) long version = cont.ext().getObjectInfo(sm.getObject()).getVersion(); sm.setTransactionalVersion(Long.valueOf(version));
DatastoreClass dc = storeMgr.getDatastoreClass(op.getObject().getClass().getName(), clr); DependentDeleteRequest req = new DependentDeleteRequest(dc, op.getClassMetaData(), clr); Set relatedObjectsToDelete = req.execute(op, entity);
/** * Method to make sure that the Entity has its parentKey assigned. * Will update the Entity of this StoreFieldManager as necessary for the parent key. * Returns the assigned parent PK (when we have a "gae.parent-pk" field/property in this class). * @return The parent key if the pojo class has a parent property. Note that a return value of {@code null} * does not mean that an entity group was not established, it just means the pojo doesn't have a distinct * field for the parent. */ Object establishEntityGroup() { Key parentKey = datastoreEntity.getParent(); if (parentKey == null) { KeyRegistry keyReg = KeyRegistry.getKeyRegistry(ec); if (keyReg.isUnowned(getObjectProvider().getObject())) { return null; } parentKey = EntityUtils.getParentKey(datastoreEntity, getObjectProvider()); if (parentKey != null) { datastoreEntity = EntityUtils.recreateEntityWithParent(parentKey, datastoreEntity); } } AbstractMemberMetaData parentPkMmd = ((DatastoreManager)getStoreManager()).getMetaDataForParentPK(getClassMetaData()); if (parentKey != null && parentPkMmd != null) { return parentPkMmd.getType().equals(Key.class) ? parentKey : KeyFactory.keyToString(parentKey); } return null; }
isStored = cont.ext().isStored(sm.getObject()); isStored = cont.ext().isStored(sm.getObject()); Class pcClass = clr.classForName(cmd.getFullClassName(), id.getClass().getClassLoader()); ObjectProvider referenceSM = ObjectProviderFactory.newForHollow(ec, pcClass, id); Object referenceObject = referenceSM.getObject();
private void updateOneToOneBidirectionalOwnerObjectForField( ObjectProvider op, AbstractMemberMetaData fmd, Entity owningEntity) { MappedStoreManager storeMgr = (MappedStoreManager) op.getExecutionContext().getStoreManager(); ExecutionContext ec = op.getExecutionContext(); ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData[] relatedMmds = fmd.getRelatedMemberMetaData(clr); String fullClassName = ((AbstractClassMetaData) relatedMmds[0].getParent()).getFullClassName(); DatastoreClass refTable = storeMgr.getDatastoreClass(fullClassName, clr); JavaTypeMapping refMapping = refTable.getMemberMapping(fmd.getMappedBy()); if (refMapping.isNullable()) { // Null out the relationship to the object being deleted. refMapping.setObject(ec, owningEntity, new int[1], op.getObject()); // TODO If the object being deleted is this objects parent, do we delete this? // TODO(maxr): Do I need to manually request an update now? } }
public Object set(ObjectProvider op, int index, Object element, boolean allowCascadeDelete) { // Get current element at this position Object obj = get(op, index); if (MetaDataUtils.isOwnedRelation(ownerMemberMetaData, storeMgr)) { // Register the parent key for the element when owned Key parentKey = EntityUtils.getKeyForObject(op.getObject(), op.getExecutionContext()); KeyRegistry.getKeyRegistry(op.getExecutionContext()).registerParentKeyForOwnedObject(element, parentKey); } // Make sure the element going to this position is persisted (and give it its index) validateElementForWriting(op, element, index); // TODO Allow for a user setting position x as element1 and then setting element2 (that used to be there) to position y // At the moment we just delete the previous element if (ownerMemberMetaData.getCollection().isDependentElement() && allowCascadeDelete && obj != null) { op.getExecutionContext().deleteObjectInternal(obj); } return obj; }
DatastoreClass dc = storeMgr.getDatastoreClass(op.getObject().getClass().getName(), clr); FetchMappingConsumer consumer = new FetchMappingConsumer(op.getClassMetaData()); dc.provideMappingsForMembers(consumer, fmds, true);
if (Relation.isBidirectional(relationType) && oldOwner != op.getObject() && oldOwner != null) {
Key parentKey = EntityUtils.getKeyForObject(op.getObject(), op.getExecutionContext()); KeyRegistry.getKeyRegistry(op.getExecutionContext()).registerParentKeyForOwnedObject(element, parentKey); final Object newOwner = op.getObject(); ExecutionContext ec = op.getExecutionContext(); boolean inserted = validateElementForWriting(ec, element, new FieldValues() {