protected void writeRevision(InternalCDORevision revision, OMMonitor monitor) { Async async = null; monitor.begin(10); try { try { async = monitor.forkAsync(); if (revision.isResourceNode()) { checkDuplicateResources(revision); } } finally { if (async != null) { async.stop(); } } // TODO removal of previous version implies query, this should be optimized long start = System.currentTimeMillis(); CDOID id = revision.getID(); DB4OStore.removeRevision(getObjectContainer(), id); DB4ORevision primitiveRevision = DB4ORevision.getDB4ORevision(revision); writeObject(primitiveRevision, monitor); long end = System.currentTimeMillis(); OM.LOG.debug("Writing revision " + id + " took: " + (end - start) + " milliseconds"); } finally { monitor.done(); } }
protected void reviseOldRevisions(InternalCDORevision[] newRevisions) { if (TRACER.isEnabled()) { TRACER.format("reviseOldRevisions: {0}", Arrays.asList(newRevisions)); // $NON-NLS-1$ } try { if (reviseOldRevisionsStatement == null) { String sql = index.objects.sqlReviseOldRevisions(); reviseOldRevisionsStatement = connection.prepareStatement(sql); } for (int i = 0; i < newRevisions.length; i++) { InternalCDORevision revision = newRevisions[i]; int column = 0; long revised = revision.getTimeStamp() - 1; reviseOldRevisionsStatement.setLong(++column, revised); CDOID oid = revision.getID(); index.setCDOID(reviseOldRevisionsStatement, ++column, oid); if (supportingBranches) { int branchID = revision.getBranch().getID(); reviseOldRevisionsStatement.setInt(++column, branchID); } int version = Math.abs(revision.getVersion()) - 1; reviseOldRevisionsStatement.setInt(++column, version); execute(reviseOldRevisionsStatement); } } catch (SQLException ex) { throw new DBException(ex); } }
public void cdoInternalPostDetach(boolean remote) { if (remote) { setInstanceContainer(null, eContainerFeatureID()); setInstanceResource(null); return; } // This loop adjusts the opposite wrapper objects to support dangling references. See // Bugzilla_251263_Test InternalCDORevision revision = cdoRevision(); for (EReference reference : classInfo.getAllPersistentReferences()) { if (!reference.isContainer() && classInfo.hasPersistentOpposite(reference)) { if (reference.isMany()) { EReference oppositeReference = reference.getEOpposite(); int size = revision.size(reference); for (int i = 0; i < size; i++) { EObject object = (EObject) getValueFromRevision(reference, i); adjustPersistentOppositeReference(this, object, oppositeReference); } } else { EObject oppositeObject = (EObject) instance.eGet(reference); if (oppositeObject != null) { EReference oppositeReference = reference.getEOpposite(); adjustPersistentOppositeReference(this, oppositeObject, oppositeReference); } } } } }
/** * CDO persists the isUnset state of an eObject in the database. The indicator for this is that * the feature is null in the revision (see CDOStore.isSet()). When committing a legacy object all * values in the instance for native attributes are set with the java default values. So, these * values will be stored in the revision and CDO cannot distinguish whether the feature is set or * not. This method must ensure that the value will be set to null if the feature is not set. */ public void cdoInternalPreCommit() { // We have to set this here because the CDOLegacyAdapter will not be notified when the instance // is the target of a // single-directional containment reference. // If the container is not an legacy Object the system will get no information instanceToRevisionContainment(); InternalCDORevision revision = cdoRevision(); for (EStructuralFeature feature : classInfo.getAllPersistentFeatures()) { if (feature.isUnsettable()) { if (!isSetInstanceValue(instance, feature)) { if (feature.isMany()) { @SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>) instance.eGet(feature); clearEList(list); } else { revision.set(feature, EStore.NO_INDEX, null); } } else if (instance.eGet(feature) == null) { // Must be single-valued! revision.set(feature, EStore.NO_INDEX, CDORevisionData.NIL); } } } }
protected ObjyObject createObject(InternalCDORevision revision) { long startTime = System.nanoTime(); ooId nearObject = null; EClass eClass = revision.getEClass(); if (TRACER_DEBUG.isEnabled()) { TRACER_DEBUG.trace("Creating new object for revision: " + revision + " - eClass: " + eClass); } if (revision.isResourceNode()) { String resourceName = (String) revision.data().get(EresourcePackage.eINSTANCE.getCDOResourceNode_Name(), 0); // The resourcelist is in the ConfigDB, but each resource is in a resource // container in the repo database, except the first root (ID == resourceID). // if (revision.getID() == revision.getResourceID()) // Check with Eike! if (resourceName == null) // root. { nearObject = objySession.getResourceList(repositoryName).ooId(); } else { ObjyScope objyScope = new ObjyScope(repositoryName, resourceName /* ObjyDb.RESOURCELIST_CONT_NAME */); nearObject = objyScope.getScopeContOid(); } } else { nearObject = getNearObject(revision); } if (nearObject == null) { // we have to put it somewhere. // call the global placement manager. nearObject = objySession .getObjectManager() .getGlobalPlacementManager() .getNearObject(null, null, revision.getEClass()); } ObjyObject objyObject = objySession.getObjectManager().newObject(eClass, nearObject); // // if it's a resource, collect it. // if (revision.isResourceNode()) // { // // Add resource to the list // ObjyResourceList resourceList = objySession.getResourceList(); // // // before we update the data into the object we need to check // // if it's a resource and we're trying to add a duplicate. // // TODO - do we need to check for Folder and resouce, or is the isResourceNode() // // check is enough?!!! // if (revision.isResourceFolder() || revision.isResource()) // { // // this call will throw exception if we have a duplicate resource we trying to add. // resourceList.checkDuplicateResources(revision); // } // SmartLock.lock(objyObject); // resourceList.add(objyObject); // } ObjyObject.createObjectTime += System.nanoTime() - startTime; ObjyObject.createObjectCount++; return objyObject; }
public CDOPermission cdoPermission() { InternalCDORevision revision = cdoRevision(true); if (revision == null) { return CDOPermission.WRITE; } return revision.getPermission(); }
@Override public void set(Object target, Object value, SessionFactoryImplementor factory) throws HibernateException { InternalCDORevision revision = (InternalCDORevision) target; revision.setVersion(((Number) value).intValue()); if (!isVirtualProperty()) { super.set(target, value, factory); } }
protected void writeRevisionDelta( InternalCDORevisionDelta revisionDelta, CDOBranch branch, long created) { CDOID id = revisionDelta.getID(); InternalCDORevision revision = DB4ORevision.getCDORevision(getStore(), DB4OStore.getRevision(getObjectContainer(), id)); InternalCDORevision newRevision = revision.copy(); newRevision.adjustForCommit(branch, created); revisionDelta.apply(newRevision); writeRevision(newRevision, new Monitor()); }
/** * This method retrieves the value from the feature at the given index. It retrieves the value * either from the views's store or the internal pre-registration Map. * * @param feature the feature to retrieve the value from * @param index the given index of the object in the feature * @return the value from the feature at the given index */ private Object getValueFromRevision(EStructuralFeature feature, int index) { InternalCDORevision revision = cdoRevision(); Object object = revision.get(feature, index); if (object == null) { return null; } if (object instanceof CDOElementProxy) { // Resolve proxy CDOElementProxy proxy = (CDOElementProxy) object; object = viewAndState .view .getSession() .resolveElementProxy(revision, feature, index, proxy.getIndex()); } if (object instanceof CDOLegacyWrapper) { return ((CDOLegacyWrapper) object).cdoInternalInstance(); } CDOType type = CDOModelUtil.getType(feature.getEType()); object = viewAndState.view.getStore().convertToEMF(instance, revision, feature, index, object); if (type == CDOType.OBJECT) { if (object instanceof CDOID) { CDOID id = (CDOID) object; if (id.isNull()) { return null; } object = getRegisteredWrapper(id); if (object != null) { return ((CDOLegacyWrapper) object).cdoInternalInstance(); } if (id.isExternal()) { object = viewAndState .view .getResourceSet() .getEObject(URI.createURI(id.toURIFragment()), true); } else { object = viewAndState.view.getObject(id); } if (object instanceof CDOObjectWrapper) { return ((CDOObjectWrapper) object).cdoInternalInstance(); } } } return object; }
/** TODO See {@link CDOObjectMerger}!!! */ public static void changeObject(CDOObject object, CDORevisionDelta revisionDelta) { readObject(object); InternalCDORevision revision = (InternalCDORevision) object.cdoRevision().copy(); ((InternalCDORevisionDelta) revisionDelta).setVersion(revision.getVersion()); CDORevisionMerger merger = new CDORevisionMerger(); merger.merge(revision, revisionDelta); ((InternalCDOObject) object).cdoInternalSetRevision(revision); ((InternalCDOObject) object).cdoInternalSetState(CDOState.DIRTY); ((InternalCDOObject) object).cdoInternalPostLoad(); }
/** @since 2.0 */ public synchronized void merge(InternalCDOObject object, CDORevisionDelta delta) { InternalCDORevision oldRevision = object.cdoRevision(); InternalCDORevision revision = oldRevision.copy(); object.cdoInternalSetRevision(revision); // NEW object should stay that state. if (object.cdoState() != CDOState.NEW) { object.cdoInternalSetState(CDOState.DIRTY); } merge(revision, delta); object.cdoInternalPostLoad(); }
/** @since 4.0 */ protected void revisionToInstanceResource() { InternalCDORevision revision = cdoRevision(); if (revision != null) { CDOID resourceID = revision.getResourceID(); if (!CDOIDUtil.isNull(resourceID)) { InternalEObject resource = getEObjectFromPotentialID(viewAndState.view, null, resourceID); setInstanceResource((Resource.Internal) resource); if (resource != null) { viewAndState.view.registerObject((InternalCDOObject) resource); } } } }
/** * * This function might be called recursively throw the call to createAndAddToMapping() to create * all the container objects and or resources needed to cluster the rest of the new objects... */ protected ooId getNearObject(InternalCDORevision revision) { ooId nearObject = null; // find the new object which is either a container or a resource. Object id = revision.getContainerID(); if (id instanceof CDOID && (CDOID) id != CDOID.NULL) { nearObject = getOidFromCDOID((CDOID) id); } else { // use the resource... CDOID resourceId = revision.getResourceID(); nearObject = getOidFromCDOID(resourceId); } return nearObject; }
private ObjyObject createObjectAndAddToMapping(InternalCDORevision revision) { ObjyObject objyObject = createObject(revision); CDOID newID = OBJYCDOIDUtil.getCDOID(objyObject.ooId()); // nearObject = objyObject.ooId(); if (TRACER_DEBUG.isEnabled()) { TRACER_DEBUG.trace("Adding object to mapping from " + revision.getID() + " to " + newID); } commitContext.addIDMapping(revision.getID(), newID); // keep a track of this mapping. idMapper.put(revision.getID(), newID); newObjyObjectsMap.put(newID, objyObject); return objyObject; }
protected void instanceToRevision() { InternalCDORevision revision = cdoRevision(); if (TRACER.isEnabled()) { TRACER.format( "Transfering instance to revision: {0} --> {1}", instance, revision); // $NON-NLS-1$ } // Handle containment instanceToRevisionContainment(); // Handle values for (EStructuralFeature feature : classInfo.getAllPersistentFeatures()) { instanceToRevisionFeature(feature); } revision.setUnchunked(); }
public ObjyPlacementManagerLocal( ObjectivityStore objyStore, ObjySession objySession, InternalCommitContext commitContext, Map<CDOID, ObjyObject> newObjyObjectsMap) { repositoryName = objyStore.getRepository().getName(); this.objySession = objySession; this.commitContext = commitContext; // first put them in a map for easy lookup and processing.... newObjectsMap = CDOIDUtil.createMap(); for (InternalCDORevision revision : commitContext.getNewObjects()) { newObjectsMap.put(revision.getID(), revision); } idMapper = CDOIDUtil.createMap(); this.newObjyObjectsMap = newObjyObjectsMap; }
@Override public void set(Object target, Object value, SessionFactoryImplementor factory) throws HibernateException { // Do some checking if (value instanceof HibernateMoveableListWrapper) { super.set(target, ((HibernateMoveableListWrapper) value).getDelegate(), factory); return; } if (!(value instanceof PersistentCollection)) { throw new IllegalArgumentException( "Value is not a PersistentCollection but a " + value.getClass().getName()); // $NON-NLS-1$ } if (!(value instanceof List<?>)) { throw new IllegalArgumentException( "Value is not a list but a " + value.getClass().getName()); // $NON-NLS-1$ } // Only set it in the listholder PersistableListHolder.getInstance() .putListMapping(target, getEStructuralFeature(), (PersistentCollection) value); // check if deep inside the persistentlist there is not already a delegate which is a // hibernatemoveable list // which contains the list which should really be set in the cdorevision // persistentlist, hibernatemoveablelistwrapper, real list, if so then the real list should be // set final InternalCDORevision revision = (InternalCDORevision) target; final Object currentValue = revision.getValue(getEStructuralFeature()); if (currentValue == null || !(currentValue instanceof List<?>)) { @SuppressWarnings("unchecked") List<Object> valueList = (List<Object>) value; final WrappedHibernateList whl = new WrappedHibernateList(revision, getEStructuralFeature()); whl.setDelegate(valueList); super.set(target, whl, factory); } }
public void processRevision(InternalCDORevision revision) { // the revision could've been processed in case if it's a container // object and we reached it while processing another revision. if (isIdProcessed(revision.getID())) { return; } // create the object and add it to mapping, this will recursively call // other object creation as needed, based on the default clustering of // having each object is stored with its container. try { createObjectAndAddToMapping(revision); } catch (com.objy.db.ObjyRuntimeException ex) { ex.printStackTrace(); } }
protected void instanceToRevisionContainment() { InternalCDORevision revision = cdoRevision(); CDOResource resource = (CDOResource) getInstanceResource(instance); revision.setResourceID(resource == null ? CDOID.NULL : resource.cdoID()); InternalEObject eContainer = getInstanceContainer(instance); if (eContainer == null) { revision.setContainerID(CDOID.NULL); revision.setContainingFeatureID(0); } else { CDOObject cdoContainer = FSMUtil.adapt(eContainer, viewAndState.view); revision.setContainerID(cdoContainer); revision.setContainingFeatureID(getInstanceContainerFeatureID(instance)); } }
/** @since 4.0 */ protected void revisionToInstanceContainer() { InternalCDORevision revision = cdoRevision(); CDOPermission permission = revision.getPermission(); if (permission != CDOPermission.WRITE) { revision.setPermission(CDOPermission.WRITE); } try { Object containerID = revision.getContainerID(); InternalEObject container = getEObjectFromPotentialID(viewAndState.view, null, containerID); EObject oldContainer = instance.eContainer(); if (oldContainer != container) { setInstanceContainer(container, revision.getContainingFeatureID()); } } finally { if (permission != CDOPermission.WRITE) { revision.setPermission(permission); } } }
/** @since 3.0 */ protected void revisionToInstanceFeature(EStructuralFeature feature) { if (feature.isUnsettable() && !viewAndState.view.getStore().isSet(this, feature)) { // Clarify if this is sufficient for bidirectional references instance.eUnset(feature); return; } if (feature.isMany()) { if (TRACER.isEnabled()) { TRACER.format( "State of Object (" + this + "/" + instance + ") is : " + viewAndState.state); // $NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } if (viewAndState.state == CDOState.CLEAN || viewAndState.state == CDOState.PROXY || viewAndState.state == CDOState.NEW || viewAndState.state == CDOState.DIRTY) { InternalCDORevision revision = cdoRevision(); int size = revision.size(feature); @SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>) instance.eGet(feature); clearEList(list); for (int i = 0; i < size; i++) { Object object = getValueFromRevision(feature, i); if (TRACER.isEnabled()) { TRACER.format( "Adding " + object + " to feature " + feature + "in instance " + instance); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } // Disable notifications from value during the // invalidation in case of // eInverseAdd/eInverseRemove boolean eDeliver = false; if (object instanceof Notifier) { Notifier notifier = (Notifier) object; eDeliver = notifier.eDeliver(); if (eDeliver) { notifier.eSetDeliver(false); } } list.basicAdd(object, null); if (object instanceof Notifier && eDeliver) { Notifier notifier = (Notifier) object; notifier.eSetDeliver(eDeliver); } } } } else { // !feature.isMany() Object object = getValueFromRevision(feature, 0); if (feature instanceof EAttribute) { if (TRACER.isEnabled()) { TRACER.format( "Setting attribute value " + object + " to feature " + feature + " in instance " + instance); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } // Just fake it for the store :( if (feature.isUnsettable() && object.equals(CDORevisionData.NIL)) { eSet(feature, null); } else { if (object != null) { eSet(feature, object); } else { // TODO Unset for features with non-null default values would not lead to null values. // Probably CDORevisionData.NIL has to be used, but that impacts all IStores. Deferred // ;-( eUnset(feature); } } } else { // EReferences if (TRACER.isEnabled()) { TRACER.format( "Adding object " + object + " to feature " + feature + " in instance " + instance); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } // Disable notifications from value during the // invalidation in case of // eInverseAdd/eInverseRemove boolean eDeliver = false; if (object instanceof Notifier) { Notifier notifier = (Notifier) object; eDeliver = notifier.eDeliver(); if (eDeliver) { notifier.eSetDeliver(false); } } EObject oldContainerOfValue = null; boolean eDeliverForOldContainerOfValue = false; if (object instanceof InternalEObject) { InternalEObject eObject = (InternalEObject) object; oldContainerOfValue = eObject.eInternalContainer(); if (oldContainerOfValue != null) { eDeliverForOldContainerOfValue = oldContainerOfValue.eDeliver(); if (eDeliverForOldContainerOfValue) { oldContainerOfValue.eSetDeliver(false); } } } int featureID = instance.eClass().getFeatureID(feature); Class<? extends Object> baseClass = object == null ? null : object.getClass(); EStructuralFeature.Internal internalFeature = (EStructuralFeature.Internal) feature; EReference oppositeReference = internalFeature.getEOpposite(); if (oppositeReference != null) { if (object != null && object != instance.eGet(feature)) { // If you have a containment reference but the container is not set, but the object is // attached to a // resource // do not set the feature to null. Otherwise the object will be removed from the // container which is the // resource instead of the original container. As a result the object will be detached. // See // MapTest.testEObjectToEObjectValueContainedMap for more information if (object != instance.eContainer() || !oppositeReference.isContainment()) { instance.eInverseAdd((InternalEObject) object, featureID, baseClass, null); } if (!classInfo.hasPersistentOpposite(internalFeature)) { adjustTransientOppositeReference( instance, (InternalEObject) object, oppositeReference); } } } else { if (object != CDORevisionData.NIL) { EReference reference = (EReference) feature; if (reference.isContainment()) { if (object != null) { // Calling eSet it not the optimal approach, but currently there is no other way to // set the value here. // To avoid attaching already processed (clean) objects a check was introduced to // CDOResourceImpl.attached(EObject). // If we find a way to avoid the call of eSet and if we are able to only set the // feature value directly // this check can be removed from CDOResourceImpl. See also Bug 352204. instance.eSet(feature, object); } else { instance.eSet(feature, null); } } else { instance.eSet(feature, object); } } else { instance.eSet(feature, null); } } if (object instanceof Notifier && eDeliver) { Notifier notifier = (Notifier) object; notifier.eSetDeliver(eDeliver); } if (oldContainerOfValue != null && eDeliverForOldContainerOfValue) { oldContainerOfValue.eSetDeliver(eDeliverForOldContainerOfValue); } if (TRACER.isEnabled()) { TRACER.format( "Added object " + object + " to feature " + feature + " in instance " + instance); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } } } }
public void addObjects(InternalCDORevision[] newRevisions, long[] pointers) { if (TRACER.isEnabled()) { TRACER.format( "addObjects: {0}, {1}", Arrays.asList(newRevisions), Arrays.asList(pointers)); // $NON-NLS-1$ } try { if (addObjectStatement == null) { String sql = index.objects.sqlAddRevision(); addObjectStatement = connection.prepareStatement(sql); } for (int i = 0; i < newRevisions.length; i++) { InternalCDORevision revision = newRevisions[i]; long pointer = pointers[i]; boolean detached = revision instanceof DetachedCDORevision; int column = 0; CDOID oid = revision.getID(); index.setCDOID(addObjectStatement, ++column, oid); if (supportingBranches) { int branchID = revision.getBranch().getID(); addObjectStatement.setInt(++column, branchID); } if (supportingAudits) { long time = revision.getTimeStamp(); addObjectStatement.setLong(++column, time); long revised = revision.getRevised(); addObjectStatement.setLong(++column, revised); int version = revision.getVersion(); if (detached) { version = -version; } addObjectStatement.setInt(++column, version); } int cid = getStore().getMetaID(revision.getEClass()); addObjectStatement.setInt(++column, cid); CDOID containerID = detached ? CDOID.NULL : (CDOID) revision.getContainerID(); index.setCDOID(addObjectStatement, ++column, containerID); if (!detached && revision.isResourceNode()) { String name = (String) revision.data().get(EresourcePackage.Literals.CDO_RESOURCE_NODE__NAME, 0); if (name == null) { name = CDOURIUtil.SEGMENT_SEPARATOR; } addObjectStatement.setString(++column, name); } else { addObjectStatement.setNull(++column, DBType.VARCHAR.getCode()); } addObjectStatement.setLong(++column, pointer); execute(addObjectStatement); } } catch (SQLException ex) { throw new DBException(ex); } }
protected void revisionToInstance() { synchronized (recursionCounter) { if (underConstruction) { // Return if revisionToInstance was called before to avoid doubled calls return; } underConstruction = true; InternalCDORevision revision = cdoRevision(); if (TRACER.isEnabled()) { TRACER.format( "Transfering revision to instance: {0} --> {1}", revision, instance); // $NON-NLS-1$ } boolean deliver = instance.eDeliver(); if (deliver) { instance.eSetDeliver(false); } Counter counter = recursionCounter.get(); if (counter == null) { counter = new Counter(); recursionCounter.set(counter); } InternalCDOResource resource = null; boolean bypassPermissionChecks = revision.bypassPermissionChecks(true); try { registerWrapper(this); counter.increment(); viewAndState.view.registerObject(this); revisionToInstanceResource(); revisionToInstanceContainer(); Resource eResource = instance.eResource(); if (eResource instanceof InternalCDOResource) { resource = (InternalCDOResource) eResource; resource.cdoInternalLoading(instance); } for (EStructuralFeature feature : classInfo.getAllPersistentFeatures()) { revisionToInstanceFeature(feature); } } catch (RuntimeException ex) { OM.LOG.error(ex); throw ex; } catch (Exception ex) { OM.LOG.error(ex); throw new CDOException(ex); } finally { try { revision.bypassPermissionChecks(bypassPermissionChecks); if (resource != null) { resource.cdoInternalLoadingDone(instance); } if (deliver) { instance.eSetDeliver(true); } } finally { if (counter.decrement() == 0) { recursionCounter.remove(); } unregisterWrapper(this); underConstruction = false; } } } }