path: root/plugins/org.eclipse.emf.cdo.server.objectivity/src/org/eclipse/emf/cdo/server/internal/objectivity/ObjectivityStoreAccessor.java

/*
 * Copyright (c) 2010-2013, 2015 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Simon McDuff - initial API and implementation
 *    Ibrahim Sallam - code refactoring for CDO 3.0
 */
package org.eclipse.emf.cdo.server.internal.objectivity;

import org.eclipse.emf.cdo.common.branch.CDOBranch;
import org.eclipse.emf.cdo.common.branch.CDOBranchHandler;
import org.eclipse.emf.cdo.common.branch.CDOBranchManager;
import org.eclipse.emf.cdo.common.branch.CDOBranchPoint;
import org.eclipse.emf.cdo.common.branch.CDOBranchVersion;
import org.eclipse.emf.cdo.common.commit.CDOCommitInfo;
import org.eclipse.emf.cdo.common.commit.CDOCommitInfoHandler;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.id.CDOIDExternal;
import org.eclipse.emf.cdo.common.id.CDOIDUtil;
import org.eclipse.emf.cdo.common.lob.CDOLobHandler;
import org.eclipse.emf.cdo.common.lock.IDurableLockingManager.LockArea.Handler;
import org.eclipse.emf.cdo.common.model.CDOPackageRegistry;
import org.eclipse.emf.cdo.common.model.EMFUtil;
import org.eclipse.emf.cdo.common.protocol.CDODataInput;
import org.eclipse.emf.cdo.common.protocol.CDODataOutput;
import org.eclipse.emf.cdo.common.revision.CDORevision;
import org.eclipse.emf.cdo.common.revision.CDORevisionCacheAdder;
import org.eclipse.emf.cdo.common.revision.CDORevisionHandler;
import org.eclipse.emf.cdo.common.revision.CDORevisionManager;
import org.eclipse.emf.cdo.common.util.CDOCommonUtil;
import org.eclipse.emf.cdo.server.IQueryHandler;
import org.eclipse.emf.cdo.server.IRepository;
import org.eclipse.emf.cdo.server.ISession;
import org.eclipse.emf.cdo.server.IStoreAccessor.DurableLocking;
import org.eclipse.emf.cdo.server.ITransaction;
import org.eclipse.emf.cdo.server.internal.objectivity.bundle.OM;
import org.eclipse.emf.cdo.server.internal.objectivity.clustering.ObjyPlacementManagerLocal;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjyCommitInfoHandler;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjyObject;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjyObjectManager;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjyPackageHandler;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjySchema;
import org.eclipse.emf.cdo.server.internal.objectivity.db.ObjySession;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyBase;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyBranch;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyBranchManager;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyCommitInfo;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyLockAreaManager;
import org.eclipse.emf.cdo.server.internal.objectivity.schema.ObjyResourceList;
import org.eclipse.emf.cdo.server.internal.objectivity.utils.OBJYCDOIDUtil;
import org.eclipse.emf.cdo.server.internal.objectivity.utils.SmartLock;
import org.eclipse.emf.cdo.server.objectivity.IObjectivityStoreAccessor;
import org.eclipse.emf.cdo.server.objectivity.IObjectivityStoreChunkReader;
import org.eclipse.emf.cdo.spi.common.branch.InternalCDOBranch;
import org.eclipse.emf.cdo.spi.common.branch.InternalCDOBranchManager;
import org.eclipse.emf.cdo.spi.common.commit.CDOChangeSetSegment;
import org.eclipse.emf.cdo.spi.common.commit.InternalCDOCommitInfoManager;
import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageUnit;
import org.eclipse.emf.cdo.spi.common.revision.DetachedCDORevision;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevision;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionDelta;
import org.eclipse.emf.cdo.spi.common.revision.InternalCDORevisionManager;
import org.eclipse.emf.cdo.spi.server.InternalCommitContext;
import org.eclipse.emf.cdo.spi.server.InternalRepository;
import org.eclipse.emf.cdo.spi.server.InternalSessionManager;
import org.eclipse.emf.cdo.spi.server.StoreAccessor;

import org.eclipse.net4j.util.ObjectUtil;
import org.eclipse.net4j.util.collection.Pair;
import org.eclipse.net4j.util.concurrent.IRWLockManager.LockType;
import org.eclipse.net4j.util.om.monitor.OMMonitor;
import org.eclipse.net4j.util.om.monitor.OMMonitor.Async;
import org.eclipse.net4j.util.om.trace.ContextTracer;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.ResourceSet;

import com.objy.db.LockNotGrantedException;
import com.objy.db.app.oo;
import com.objy.db.app.ooId;
import com.objy.db.app.ooObj;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;

/**
 * @author Simon McDuff
 * @author Ibrahim Sallam
 */
public class ObjectivityStoreAccessor extends StoreAccessor implements IObjectivityStoreAccessor, DurableLocking
{
  private static final ContextTracer TRACER_DEBUG = new ContextTracer(OM.DEBUG, ObjectivityStoreAccessor.class);

  private static final ContextTracer TRACER_INFO = new ContextTracer(OM.INFO, ObjectivityStoreAccessor.class);

  protected ObjySession objySession = null;

  // protected ObjyObjectManager objectManager = null;

  protected boolean isRead = false;

  protected int sessionID = 0; // used to tag the Objy session in the session pool

  boolean zipped = true; // TODO - might make this configurable...

  private Map<CDOID, ObjyObject> newObjyObjectsMap = CDOIDUtil.createMap();

  private long readRevisionTime = 0;

  private int readRevisionCount = 0;

  protected ObjectivityStoreAccessor(ObjectivityStore store, ISession cdoSession)
  {
    super(store, cdoSession);

    // for debugging...
    // session.getProtocol();
    // org.eclipse.emf.cdo.net4j.CDOSession.Options.getProtocol()
    // [12:42:23 PM] Eike Stepper says: org.eclipse.net4j.signal.ISignalProtocol.setTimeout(long)
    // [12:42:43 PM] Eike Stepper says: commit is different
    // if (cdoSession != null && cdoSession.getProtocol().getSession() instanceof org.eclipse.emf.cdo.net4j.CDOSession)
    // {
    // CDOCommonSession commonSession = cdoSession.getProtocol().getSession();
    // org.eclipse.emf.cdo.net4j.CDOSession tempSession = (org.eclipse.emf.cdo.net4j.CDOSession)commonSession;
    // tempSession.options().setCommitTimeout(60000);
    // }
    // [12:42:45 PM] Eike Stepper says: org.eclipse.emf.cdo.net4j.CDOSession.Options.setCommitTimeout(int)
    // org.eclipse.emf.cdo.net4j.CDOSession.Options.setProgressInterval(int)

    /* I believe this is a read session */
    isRead = true;
    if (cdoSession != null)
    {
      sessionID = cdoSession.getSessionID();
    }
  }

  public ObjectivityStoreAccessor(ObjectivityStore store, ITransaction transaction)
  {
    super(store, transaction);

    // for debugging...
    // if (transaction != null && transaction.getSession().getProtocol().getSession() instanceof
    // org.eclipse.emf.cdo.net4j.CDOSession)
    // {
    // CDOCommonSession commonSession = transaction.getSession().getProtocol().getSession();
    // org.eclipse.emf.cdo.net4j.CDOSession cdoSession = (org.eclipse.emf.cdo.net4j.CDOSession)commonSession;
    // cdoSession.options().setCommitTimeout(60000);
    // }
    /* I believe this is a write session */
    if (transaction != null)
    {
      sessionID = transaction.getSession().getSessionID();
    }
  }

  @Override
  protected void detachObjects(CDOID[] detachedObjects, CDOBranch branch, long timeStamp, OMMonitor monitor)
  {
    ensureSessionBegin();

    // System.out.println(">>>>IS:<<< detachObjects() " + this + " - objy session: " + objySession.toString());
    // objySession.addToLog("IS:>>>", "detachObjects - begin");

    try
    {
      monitor.begin(detachedObjects.length);
      // Find all Objy containers to lock as one unit.
      Set<ooId> containerToLocks = new HashSet<ooId>();
      for (CDOID id : detachedObjects)
      {
        ooId containerID = OBJYCDOIDUtil.getContainerId(id);
        containerToLocks.add(containerID);
      }
      objySession.lockContainers(containerToLocks);

      InternalCDORevisionManager revisionManager = getStore().getRepository().getRevisionManager();

      long tStart = System.currentTimeMillis();
      for (CDOID id : detachedObjects)
      {

        InternalCDORevision revision = revisionManager.getRevision(id, branch.getHead(), CDORevision.UNCHUNKED,
            CDORevision.DEPTH_NONE, true);
        int version = ObjectUtil.equals(branch, revision.getBranch()) ? revision.getVersion()
            : CDOBranchVersion.FIRST_VERSION;

        detachObject(id, version, branch, timeStamp);
      }
      // objySession.addToLog("IS:>>>", "detachObjects - end");
      long tDiff = System.currentTimeMillis() - tStart;
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("detach objects: " + detachedObjects.length + " - time: " + tDiff);
      }

    }
    finally
    {
      monitor.done();
    }

    // System.out.println(">>>>IS:<<< detachObjects() DONE " + this + " - objy session: " + objySession.toString());
  }

  /***
   * @param CDOID
   * @param version
   * @param branch
   * @param timeStamp
   */
  private void detachObject(CDOID id, int version, CDOBranch branch, long timeStamp)
  {
    // ensureSessionBegin();

    ObjyObject objyObject = getObject(id);

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.trace("Detaching id " + id + " - OID: " + objyObject.ooId().getStoreString() + " verions: " + version
          + " in Branch: " + branch.getID() + " and timeStamp: " + timeStamp);
    }

    if (getStore().isRequiredToSupportAudits())
    {
      if (version > CDOBranchVersion.FIRST_VERSION)
      {
        // pick the proper version of that branch to revise it. Otherwise, the detached version will
        // be in a different branch.
        ObjyObject objyRevision = objyObject.getRevisionByVersion(version, branch.getID(),
            objySession.getObjectManager());
        if (objyRevision.getVersion() < 0)
        {
          TRACER_DEBUG.trace("... OBJ is already detached...");
        }
        objyRevision.setRevisedTime(timeStamp - 1);
      }
      objyObject.detach(version, branch, timeStamp);
    }
    else
    {
      objyObject.setVersion(-version);
      objyObject.delete(this, objySession.getObjectManager());
    }

    // // we'll need to find it's containing object/resource and remove it from there.
    // // TODO - do we need to deal with dependent objects, i.e. delete them as well,
    // // is there a notion of delete propagate?
    // if (ObjySchema.isResource(getStore(), objyObject.objyClass()))
    // {
    // ObjyResourceList resourceList = objySession.getResourceList(getRepositoryName());
    // resourceList.remove(objyObject);
    // }
    objySession.getObjectManager().remove(objyObject); // removed it from the cache.
  }

  @Override
  protected void doActivate() throws Exception
  {
    // System.out.println(">>>>IS:<<<< StoreAccessor.doActivate() " + this);
    // getObjySession();
  }

  public ObjySession getObjySession()
  {
    int currSessionID = sessionID;

    if (!isReader())
    {
      // The only reason we do this is because there was a switching of context in the middle
      // of a transaction, and we want to ensure that we continue with the proper session that
      // is holding the data.
      ITransaction cdoTrx = getTransaction();
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG
        .trace("getObjySession() - context's transaction: " + (cdoTrx == null ? "null" : cdoTrx.toString()));
      }
      if (cdoTrx != null)
      {
        sessionID = cdoTrx.getSession().getSessionID();
      }
    }

    if (objySession != null && currSessionID == sessionID)
    {
      return objySession;
    }

    // get a session name.
    String sessionName = "Session_" + sessionID;

    if (objySession != null)
    {
      objySession.returnSessionToPool();
    }
    if (isReader())
    {
      objySession = getStore().getConnection().getReadSessionFromPool(sessionName + "_" + getRepositoryName());
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("  getObjySession from read pool, session: " + objySession.toString() + " - isOpen: "
            + objySession.isOpen() + " - sessionName:" + objySession.getName());
      }
    }
    else
    {
      objySession = getStore().getConnection().getWriteSessionFromPool(sessionName + "_" + getRepositoryName());
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("  getObjySession from write pool, session: " + objySession.toString() + " - isOpen: "
            + objySession.isOpen() + " - sessionName:" + objySession.getName());
      }
    }

    if (!objySession.isOpen())
    {
      objySession.setMrowMode(oo.MROW);
      objySession.setWaitOption(45000);
      objySession.setAllowUnregisterableTypes(true);
      if (isRead)
      {
        objySession.setOpenMode(oo.openReadOnly);
      }
      else
      {
        objySession.setOpenMode(oo.openReadWrite);
      }
      objySession.begin();
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("     calling session.begin() for " + objySession.toString() + " - isRead: " + isRead);
      }
    }
    else
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("     session " + objySession.toString() + " already open.");
      }
    }

    return objySession;
  }

  private void returnObjySession()
  {
    // System.out.println(">>>>IS:<<<< Returning to pool, session: " + objySession + " - name: " +
    // objySession.getName());
    ensureSessionJoin();
    // testDetachWithoutRevision_CheckMainBranch() is crashing because objySession is null.
    // TBD: verify this case!!!
    if (objySession == null)
    {
      return;
    }

    if (objySession.isOpen())
    {
      // System.out.println(">>>>IS:<<<< commiting session: " + objySession + " - name: " + objySession.getName());
      objySession.commit(); // IS: we might need to abort instead.
    }
    objySession.returnSessionToPool();
    objySession = null;
  }

  @Override
  protected void doDeactivate() throws Exception
  {
    // System.out.println(">>>>IS:<<< StoreAccessor.doDeactivate() " + this);
    returnObjySession();
  }

  @Override
  protected void doPassivate() throws Exception
  {
    // System.out.println(">>>>IS:<<<< StoreAccessor.doPassivate() " + this);
    returnObjySession();
  }

  @Override
  protected void doUnpassivate() throws Exception
  {
    // System.out.println(">>>>IS:<<<< StoreAccessor.doUnpassivate() " + this);
    // IS: don't call this now, in case we don't have a context.
    // getObjySession();
  }

  // @Override
  // protected void setContext(Object context)
  // {
  // super.setContext(context);
  // System.out.println(">>>>IS:<<<< StoreAccessor.setContext() " + this + " - context: " + context.toString());
  // }

  @Override
  protected void doRollback(CommitContext commitContext)
  {
    try
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("Rollback session " + objySession);
      }
      // the rollback could be coming from another thread.
      ensureSessionJoin();
      if (objySession.isOpen())
      {
        objySession.abort();
        if (TRACER_DEBUG.isEnabled())
        {
          TRACER_DEBUG.trace("OBJY: session aborted - Session: " + objySession + " - open:" + objySession.isOpen());
        }
      }
    }
    catch (RuntimeException exception)
    {
      TRACER_INFO.trace(exception.getMessage(), exception);
      exception.printStackTrace();
      throw exception;
    }
  }

  @Override
  protected void writeRevisionDeltas(InternalCDORevisionDelta[] revisionDeltas, CDOBranch branch, long created,
      OMMonitor monitor)
  {
    // System.out.println(">>>>IS:<<< writeRevisionDeltas() " + this + " - objy session: " + objySession.toString());
    long start = System.nanoTime();
    ensureSessionBegin();

    try
    {
      monitor.begin(revisionDeltas.length);
      // Find all Objy containers to lock as one unit.
      Set<ooId> containerToLocks = new HashSet<ooId>();
      for (InternalCDORevisionDelta delta : revisionDeltas)
      {
        ooId containerID = OBJYCDOIDUtil.getContainerId(delta.getID());
        containerToLocks.add(containerID);
      }
      objySession.lockContainers(containerToLocks);

      for (InternalCDORevisionDelta revisionDelta : revisionDeltas)
      {
        writeRevisionDelta(revisionDelta, branch, created);
      }
    }
    finally
    {
      monitor.done();
    }
    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.trace(
          " writeRevisionDeltas: " + revisionDeltas.length + " - time: " + (System.nanoTime() - start) / 1000000.0);
    }
  }

  /**
   * Called for each revision delta.
   *
   * @param delta
   * @param created
   * @param branch
   */
  // private void writeRevisionDelta2(InternalCDORevisionDelta delta, CDOBranch branch, long created)
  // {
  // // ensureSessionBegin();
  //
  // int deltaVersion = delta.getVersion();
  // int newVersion = CDOBranchVersion.FIRST_VERSION;
  //
  // ObjyObject objyObject = getObject(delta.getID());
  // if (TRACER_DEBUG.isEnabled())
  // {
  // TRACER_DEBUG.format("writingRevisionDelta getting Object: {0}, v:{1} - BranchId:{2}", objyObject.ooId()
  // .getStoreString(), deltaVersion, delta.getBranch().getID());
  // }
  // ObjyObject objyOriginalRevision = objyObject.getRevisionByVersion(deltaVersion, delta.getBranch().getID(),
  // objySession.getObjectManager());
  //
  // if (branch.getID() == delta.getBranch().getID())
  // {
  // // Same branch, increase version
  // newVersion = deltaVersion + 1;
  // }
  //
  // if (TRACER_DEBUG.isEnabled())
  // {
  // TRACER_DEBUG.format("Writing revision delta: {0}, v:{1} - OID:{2}, v:{3} - BranchId:{4}", delta, deltaVersion,
  // objyObject.ooId().getStoreString(), objyOriginalRevision.getVersion(), objyOriginalRevision.getBranchId());
  // TRACER_DEBUG.format("... delta branch ID: {0} - revision branch ID: {1}", branch.getID(),
  // objyOriginalRevision.getBranchId());
  // }
  // // System.out.println(">>>IS: Delta Writing: " + delta.getID() + " - oid: " + objyObject.ooId().getStoreString());
  // // System.out.println("\t - old version : " + delta.getVersion());
  // // System.out.println("\t - created : " + created);
  // // System.out.println("\t - delta.branch: " + delta.getBranch().toString());
  // // System.out.println("\t - branch : " + branch.toString());
  // // System.out.println("\t - branch TS : " + branch.getPoint(created).getTimeStamp());
  // // System.out.println("\t - delta : " + delta.toString());
  // // for debugging...
  //
  // if (objyOriginalRevision.getVersion() != deltaVersion)
  // {
  // throw new RuntimeException("ObjecitivityStoreAccessor : Dirty write");
  // }
  //
  // ObjyObject objyNewRevision = null;
  //
  // if (getStore().isRequiredToSupportAudits())
  // {
  // // newObjyRevision = objySession.getObjectManager().copyRevision(this, objyRevision);
  // // objyRevision.setRevisedBranchId(branch.getID();
  // // InternalCDORevision originalRevision = getStore().getRepository().getRevisionManager()
  // // .getRevisionByVersion(delta.getID(), delta, 0, true);
  // InternalCDORevision originalRevision = getStore().getRepository().getRevisionManager()
  // .getRevisionByVersion(delta.getID(), delta.getBranch().getVersion(deltaVersion), 0, true);
  //
  // // 100917-IS: KISS - InternalCDORevision newRevision = originalRevision.copy();
  //
  // // 100917-IS: KISS - newRevision.setVersion(deltaVersion + 1);
  // // 100917-IS: KISS - newRevision.setBranchPoint(delta.getBranch().getPoint(created));
  // // 100917-IS: KISS - newObjyRevision = objySession.getObjectManager().newObject(newRevision.getEClass(),
  // // objyRevision.ooId());
  // // 100917-IS: KISS - objyNewRevision.update(this, newRevision);
  //
  // // create a new object, fill it with the original revision data, then
  // // modify the creation and the branch ID accordingly.
  // objyNewRevision = objySession.getObjectManager().newObject(originalRevision.getEClass(),
  // objyOriginalRevision.ooId());
  // objyNewRevision.update(this, originalRevision);
  // objyNewRevision.setBranchId(delta.getBranch().getID());
  // // the following are done at the end.
  // // objyNewRevision.setVersion(deltaVersion + 1);
  // // objyNewRevision.setCreationTime(created);
  //
  // objyObject.addToRevisions(objyNewRevision);
  //
  // if (getStore().isRequiredToSupportBranches() /* && branch.getID() != CDOBranch.MAIN_BRANCH_ID */)
  // {
  // // add the newObjyRevision to the proper branch.
  // ObjyBranch objyBranch = objySession.getBranchManager(getRepositoryName()).getBranch(branch.getID());
  // ooObj anObj = ooObj.create_ooObj(objyNewRevision.ooId());
  // objyBranch.addRevision(anObj);
  // }
  // if (newVersion > CDORevision.FIRST_VERSION)
  // {
  // // revise the original revision last, otherwise we can end up with the revised date in the new revision.
  // objyOriginalRevision.setRevisedTime(branch.getPoint(created).getTimeStamp() - 1);
  // }
  // }
  // else
  // {
  // objyNewRevision = objyOriginalRevision;
  // }
  //
  // ObjectivityFeatureDeltaWriter visitor = new ObjectivityFeatureDeltaWriter(objyNewRevision);
  //
  // delta.accept(visitor);
  //
  // objyNewRevision.setCreationTime(branch.getPoint(created).getTimeStamp());
  // objyNewRevision.setVersion(newVersion); // TODO - verify with Eike if this is true!!!
  // }

  /**
   * Called for each revision delta.
   *
   * @param delta
   * @param created
   * @param branch
   */
  private void writeRevisionDelta(InternalCDORevisionDelta delta, CDOBranch branch, long created)
  {
    // ensureSessionBegin();

    int deltaVersion = delta.getVersion();
    int newVersion = CDOBranchVersion.FIRST_VERSION;

    ObjyObject objyObject = getObject(delta.getID());
    TRACER_DEBUG.format("writingRevisionDelta getting Object: {0}, v:{1} - BranchId:{2}",
        objyObject.ooId().getStoreString(), deltaVersion, delta.getBranch().getID());
    ObjyObject objyOriginalRevision = objyObject.getRevisionByVersion(deltaVersion, delta.getBranch().getID(),
        objySession.getObjectManager());

    if (branch.getID() == delta.getBranch().getID())
    {
      // Same branch, increase version
      newVersion = deltaVersion + 1;
    }

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("Writing revision delta: {0}, v:{1} - OID:{2}, v:{3} - BranchId:{4}", delta, deltaVersion,
          objyObject.ooId().getStoreString(), objyOriginalRevision.getVersion(), objyOriginalRevision.getBranchId());
      TRACER_DEBUG.format("... delta branch ID: {0} - revision branch ID: {1}", branch.getID(),
          objyOriginalRevision.getBranchId());
    }
    // System.out.println(">>>IS: Delta Writing: " + delta.getID() + " - oid: " + objyObject.ooId().getStoreString());
    // System.out.println("\t - old version : " + delta.getVersion());
    // System.out.println("\t - created : " + created);
    // System.out.println("\t - delta.branch: " + delta.getBranch().toString());
    // System.out.println("\t - branch : " + branch.toString());
    // System.out.println("\t - branch TS : " + branch.getPoint(created).getTimeStamp());
    // System.out.println("\t - delta : " + delta.toString());
    // for debugging...

    if (objyOriginalRevision.getVersion() != deltaVersion)
    {
      throw new RuntimeException("ObjecitivityStoreAccessor : Dirty write");
    }

    ObjyObject objyNewRevision = null;

    if (getStore().isRequiredToSupportAudits())
    {

      ObjyObject objyObjectCopy = objySession.getObjectManager().copyRevision(this, objyOriginalRevision);
      TRACER_DEBUG.format("  created new object:{0} by copying object:{1} - v:{2} - newBranch:{3}",
          objyObjectCopy.ooId().getStoreString(), objyOriginalRevision.ooId().getStoreString(),
          objyOriginalRevision.getVersion(), branch.getID());

      // // newObjyRevision = objySession.getObjectManager().copyRevision(this, objyRevision);
      // // objyRevision.setRevisedBranchId(branch.getID();
      // InternalCDORevision originalRevision = getStore().getRepository().getRevisionManager()
      // .getRevisionByVersion(delta.getID(), delta, CDORevision.UNCHUNKED, true);
      //
      // // 100917-IS: KISS - InternalCDORevision newRevision = originalRevision.copy();
      //
      // // 100917-IS: KISS - newRevision.setVersion(deltaVersion + 1);
      // // 100917-IS: KISS - newRevision.setBranchPoint(delta.getBranch().getPoint(created));
      // // 100917-IS: KISS - objyNewRevision = objySession.getObjectManager().newObject(newRevision.getEClass(),
      // // objyOriginalRevision.ooId());
      // // 100917-IS: KISS - objyNewRevision.update(this, newRevision);
      //
      // // create a new object, fill it with the original revision data, then
      // // modify the creation and the branch ID accordingly.
      // objyNewRevision = objySession.getObjectManager().newObject(originalRevision.getEClass(),
      // objyOriginalRevision.ooId());
      // objyNewRevision.update(this, originalRevision);
      objyNewRevision = objyObjectCopy;
      objyNewRevision.setBranchId(branch.getID());
      // the following are done at the end.
      // objyNewRevision.setVersion(deltaVersion + 1);
      // objyNewRevision.setCreationTime(created);

      objyObject.addToRevisions(objyNewRevision);

      if (getStore().isRequiredToSupportBranches() /* && branch.getID() != CDOBranch.MAIN_BRANCH_ID */)
      {
        // add the newObjyRevision to the proper branch.
        ObjyBranch objyBranch = objySession.getBranchManager(getRepositoryName()).getBranch(branch.getID());
        ooObj anObj = ooObj.create_ooObj(objyNewRevision.ooId());
        objyBranch.addRevision(anObj);
      }
      // revise the original revision last, otherwise we can end up with the revised date in the new revision.
      // IS: it seems that in CDO 4.0 we don't need to do that anymore!!
      if (newVersion > CDORevision.FIRST_VERSION)
      {
        objyOriginalRevision.setRevisedTime(branch.getPoint(created).getTimeStamp() - 1);
      }
    }
    else
    {
      objyNewRevision = objyOriginalRevision;
    }

    ObjectivityFeatureDeltaWriter visitor = new ObjectivityFeatureDeltaWriter(objyNewRevision);

    delta.accept(visitor);

    objyNewRevision.setCreationTime(branch.getPoint(created).getTimeStamp());
    objyNewRevision.setVersion(newVersion); // TODO - verify with Eike if this is true!!!
  }

  @Override
  public ObjectivityStore getStore()
  {
    return (ObjectivityStore)super.getStore();
  }

  /**
   * It seems that it will be called for both new objects and dirty objects.
   */
  @Override
  protected void writeRevisions(InternalCDORevision[] revisions, CDOBranch branch, OMMonitor monitor)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      ObjyObjectManager.getObjectTime = 0;
      ObjyObjectManager.updateObjectTime = 0;
      ObjyObjectManager.resourceCheckAndUpdateTime = 0;
    }
    long start = System.nanoTime();
    ensureSessionBegin();
    // objySession.addToLog("IS:>>>", "writeRevisions - begin");
    try
    {
      monitor.begin(revisions.length);
      // Find all Objy containers to lock as one unit.
      Set<ooId> containersToLock = new HashSet<ooId>();
      for (InternalCDORevision revision : revisions)
      {
        ooId containerID = OBJYCDOIDUtil.getContainerId(revision.getID());
        containersToLock.add(containerID);
      }
      // containersToLock.add(objySession.getBranchManager(getRepositoryName()).getContainer().getOid());
      // lockContainers(containersToLock);
      // long tStart = System.currentTimeMillis();
      for (InternalCDORevision revision : revisions)
      {
        writeRevision(revision, monitor.fork());
      }
      // long tDiff = System.currentTimeMillis() - tStart;
      // System.out.println(">>> IS: writing revisions: " + revisions.length + " - time: " + tDiff);
    }
    finally
    {
      newObjyObjectsMap.clear();
      monitor.done();
    }
    // objySession.addToLog("IS:>>>", "writeRevisions - end");
    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG
      .trace(" writeRevisions: " + revisions.length + " - time: " + (System.nanoTime() - start) / 1000000.0);
      // TRACER_DEBUG.trace(" getObjectTime: " + ObjyObjectManager.getObjectTime / 1000000.0);
      // TRACER_DEBUG.trace(" updateObjectTime: " + ObjyObjectManager.updateObjectTime / 1000000.0);
      // TRACER_DEBUG.trace(" resourceCheckAndUpdateTime: " + ObjyObjectManager.resourceCheckAndUpdateTime /
      // 1000000.0);
      // ObjyObjectManager.getObjectTime = 0;
      // ObjyObjectManager.updateObjectTime = 0;
      // ObjyObjectManager.resourceCheckAndUpdateTime = 0;
    }

  }

  /**
   * return an ObjyObject that represent the CDOID base.
   */
  public ObjyObject getObject(CDOID id)
  {
    ObjyObject objyObject = objySession.getObjectManager().getObject(id);
    // make sure we get the base one and not any cached version.
    return objyObject.getBaseObject();
  }

  /*****
   * Use this code for heart beat. Async async = null; try { monitor.begin(getListMappings().size() + 1); async =
   * monitor.forkAsync(); reviseObject(accessor, id, timeStamp); } finally { async.stop(); monitor.done(); } [10:07:02
   * AM] Eike Stepper: that one takes care that the heartbeat goes on [10:07:13 AM] Eike Stepper: for indefinite time
   */

  private void writeRevision(InternalCDORevision revision, OMMonitor monitor)
  {
    Async async = null;

    try
    {
      monitor.begin(1000); // IS: experimental.
      async = monitor.forkAsync();

      // EClass eClass = revision.getEClass();
      long __start = System.nanoTime();
      // ObjyObject objyObject = getObject(revision.getID());
      ObjyObject objyObject = newObjyObjectsMap.get(revision.getID());
      if (objyObject == null)
      {
        objyObject = getObject(revision.getID()); // we shouldn't need to come here.
      }
      ObjyObjectManager.getObjectTime += System.nanoTime() - __start;

      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("Writing revision: {0} - OID: {1}", revision, objyObject.ooId().getStoreString()); //$NON-NLS-1$
      }

      // System.out.println(">>>IS: Writing: " + revision.getID() + " - oid: " + objyObject.ooId().getStoreString());
      // System.out.println("\t - version : " + revision.getVersion());
      // System.out.println("\t - timestamp : " + revision.getTimeStamp());
      // System.out.println("\t - revised : " + revision.getRevised());
      // System.out.println("\t - resourceId : " + revision.getResourceID());
      // System.out.println("\t - containerId: " + revision.getContainerID());
      // System.out.println("\t - branch : " + revision.getBranch().toString());
      // System.out.println("\t - revision : " + revision.toString());

      ObjyObject newObjyRevision = objyObject;

      if (revision.getVersion() > CDOBranchVersion.FIRST_VERSION) // we're updating other versions...
      {
        // TRACER_DEBUG.format("...Updating other revisions using writeRevision()...");
        ObjyObject oldObjyRevision = objyObject.getRevisionByVersion(revision.getVersion() - 1,
            revision.getBranch().getID(), objySession.getObjectManager());

        if (oldObjyRevision == null)
        {
          new IllegalStateException("Revision with version: " + (revision.getVersion() - 1) + " is not in the store."); //$NON-NLS-1$
        }
        if (getStore().isRequiredToSupportAudits())
        {
          // if we allow versioning, then create a new one here.
          // IS: I'm not sure if we'll be called here we always go to the writeRevisionDelta call.
          newObjyRevision = objySession.getObjectManager().newObject(revision.getEClass(), oldObjyRevision.ooId());
          objyObject.addToRevisions(newObjyRevision);

        }
        else
        {
          newObjyRevision = oldObjyRevision;
        }
      }

      if (getStore().isRequiredToSupportBranches())
      {
        // add the newObjyRevision to the proper branch.
        ObjyBranch objyBranch = objySession.getBranchManager(getRepositoryName())
            .getBranch(revision.getBranch().getID());
        ooObj anObj = ooObj.create_ooObj(newObjyRevision.ooId());
        try
        {
          objyBranch.addRevision(anObj);
        }
        catch (LockNotGrantedException ex)
        {
          ex.printStackTrace();
        }
      }

      __start = System.nanoTime();
      newObjyRevision.update(this, revision);
      ObjyObjectManager.updateObjectTime += System.nanoTime() - __start;

      // if it's a resource, collect it.
      if (revision.isResourceNode())
      {
        __start = System.nanoTime();
        // TODO - this is temp solution to lock the common resource list
        // Add resource to the list
        ObjyResourceList resourceList = objySession.getResourceList(getRepositoryName());
        ooObj anObj = (ooObj)objySession.getFD().objectFrom(resourceList.ooId());
        SmartLock.lock(anObj.getContainer());

        // 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(this, revision);
        }
        SmartLock.lock(newObjyRevision);
        try
        {
          resourceList.add(newObjyRevision);
        }
        catch (LockNotGrantedException ex)
        {
          ex.printStackTrace();
        }
        ObjyObjectManager.resourceCheckAndUpdateTime += System.nanoTime() - __start;
      }
    }
    finally
    {
      async.stop();
      monitor.done();
    }
  }

  @Override
  protected void doCommit(OMMonitor monitor)
  {
    // System.out.println(">>>>IS:<<< doCommit() " + this + " - objy session: " + objySession.toString());

    long start = System.currentTimeMillis();
    Async async = null;
    monitor.begin();

    try
    {
      try
      {
        async = monitor.forkAsync();
        // The commit request might come from a different thread.
        ensureSessionJoin();

        if (TRACER_DEBUG.isEnabled())
        {
          TRACER_DEBUG.trace("Committing ..." + objySession + " nc:" + objySession.nestCount());
        }
        if (objySession.isOpen() == true)
        {
          objySession.commit();
        }
        else
        {
          TRACER_DEBUG.trace("Error: calling objySession.commit() without having an open trx.");
        }

        if (TRACER_DEBUG.isEnabled())
        {
          TRACER_DEBUG.trace("Committed");
        }
      }
      finally
      {
        if (async != null)
        {
          async.stop();
        }
      }
    }
    catch (RuntimeException exception)
    {
      TRACER_INFO.trace(exception.getMessage(), exception);
      exception.printStackTrace();
      throw exception;
    }
    finally
    {
      monitor.done();
    }

    // 100920 - IS: for debugging
    if (TRACER_DEBUG.isEnabled())
    {
      // TRACER_DEBUG.trace("doCommit() - new objects created: " + ObjyObjectManager.newObjCount + " - Internal: "
      // + ObjyObjectManager.newInternalObjCount);
      // ObjyObjectManager.newObjCount = 0;
      // ObjyObjectManager.newInternalObjCount = 0;
      TRACER_DEBUG.trace(" readRvisions: " + readRevisionCount + " - time: " + readRevisionTime / 1000000.0);
      TRACER_DEBUG.trace(" fetchCount: " + ObjyObject.fetchCount + " - updateCount: " + ObjyObject.updateCount);
      TRACER_DEBUG.trace("\t commit time: " + (System.currentTimeMillis() - start));
      readRevisionTime = 0;
      readRevisionCount = 0;
      ObjyObject.fetchCount = 0;
      ObjyObject.updateCount = 0;
    }
    // System.out.println("IS:>>> ObjyObject.ctor(): count " + ObjyObject.count + " - totalTime: " + ObjyObject.tDiff);
    // for (ooId oid : ObjyObject.oids)
    // {
    // System.out.println("<" + oid.getStoreString() + "> ");
    // }
    // System.out.println();
    // ObjyObject.count = 0;
    // ObjyObject.tDiff = 0;
    // ObjyObject.oids.clear();
  }

  public IObjectivityStoreChunkReader createChunkReader(InternalCDORevision revision, EStructuralFeature feature)
  {
    return new ObjectivityStoreChunkReader(this, revision, feature);
  }

  public EPackage[] loadPackageUnit(InternalCDOPackageUnit packageUnit)
  {
    // using the packageUnit.getID() we'll read the object from the FD and get the bytes.
    byte[] bytes = null;

    ensureSessionBegin();

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("loadPackageUnit for: {0}", packageUnit.getID()); //$NON-NLS-1$
    }

    ObjyPackageHandler objyPackageHandler = getStore().getPackageHandler();

    bytes = objyPackageHandler.readPackageBytes(packageUnit);

    EPackage ePackage = createEPackage(packageUnit, bytes);

    return EMFUtil.getAllPackages(ePackage);
  }

  private EPackage createEPackage(InternalCDOPackageUnit packageUnit, byte[] bytes)
  {
    ResourceSet resourceSet = EMFUtil.newEcoreResourceSet(getPackageRegistry());
    return EMFUtil.createEPackage(packageUnit.getID(), bytes, zipped, resourceSet, false);
  }

  private CDOPackageRegistry getPackageRegistry()
  {
    return getStore().getRepository().getPackageRegistry();
  }

  /**
   * TODO - 1) make sure that we return the root resource when we asked for "null" pathPrefix. 2) Create the "null"
   * resource folder if it doesn't exist, perhaps when we initialize the store.
   */
  public void queryResources(QueryResourcesContext context)
  {
    ensureSessionBegin();

    String pathPrefix = context.getName();
    boolean exactMatch = context.exactMatch();

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format(
          "queryResources() for : " + (pathPrefix == null ? "NULL" : pathPrefix) + " - exactMatch: " + exactMatch);
    }
    ObjyResourceList resourceList = objySession.getResourceList(getRepositoryName());
    int size = resourceList.size();
    if (size == 0) // nothing yet.
    {
      CDOID resourceID = OBJYCDOIDUtil.getCDOID(null);
      context.addResource(resourceID);
    }

    // TBD: We need to verify the folderID as well!!
    // CDOID folderID = org.eclipse.emf.cdo.common.id.CDOIDUtil.isNull(context.getFolderID()) ? null : context
    // .getFolderID();
    for (int i = 0; i < size; i++)
    {
      ObjyObject resource = resourceList.getResource(i);
      if (resource != null)
      {
        ObjyObject resourceRevision = resource;
        // get the proper revision of the resource (might need to refactor this code, see readRevision())
        if (getStore().isRequiredToSupportBranches())
        {
          try
          {
            resourceRevision = resource.getRevision(context.getTimeStamp(), context.getBranch().getID(),
                objySession.getObjectManager());
          }
          catch (RuntimeException ex)
          {
            ex.printStackTrace();
          }

        }
        else if (getStore().isRequiredToSupportAudits())
        {
          try
          {
            resourceRevision = resource.getRevision(context.getTimeStamp(), CDOBranch.MAIN_BRANCH_ID,
                objySession.getObjectManager());
          }
          catch (RuntimeException ex)
          {
            ex.printStackTrace();
          }
        }

        if (resourceRevision == null || resourceRevision.getVersion() < 0)
        {
          continue;
        }

        String resourceName = ObjyResourceList.getResourceName(resourceRevision);
        CDOID resourceID = OBJYCDOIDUtil.getCDOID(resource.ooId());
        if (exactMatch && pathPrefix != null && pathPrefix.equals(resourceName)
            || pathPrefix == null && resourceName == null)
        {
          if (!context.addResource(resourceID))
          {
            if (TRACER_DEBUG.isEnabled())
            {
              TRACER_DEBUG.format("   queryResources(1.1) got: " + resource.ooId().getStoreString() + " - version: "
                  + resource.getVersion());
            }
            // No more results allowed
            break; // don't continue
          }
        }
        else if (!exactMatch && resourceName != null)
        {
          if (resourceName.startsWith(pathPrefix))
          {
            context.addResource(resourceID);
            if (TRACER_DEBUG.isEnabled())
            {
              TRACER_DEBUG.format("   queryResources(1.2) got: " + resource.ooId().getStoreString() + " - version: "
                  + resource.getVersion());
            }
          }
        }
        /***
         * TODO - verify if we need this code, originally from the old impl. CDOID lookupFolderID = (CDOID)
         * objectManager.getEContainer(resource); if (ObjectUtil.equals(lookupFolderID, folderID)) { boolean match =
         * exactMatch || pathPrefix == null; if (match) { CDOID resourceID = CDOIDUtil.getCDOID(resource.ooId()); if
         * (!context.addResource(resourceID)) { break; } } }
         ***/
      }
    }

  }

  public void queryXRefs(QueryXRefsContext context)
  {
    ensureSessionBegin();

    Set<CDOID> targetIDs = context.getTargetObjects().keySet();
    Map<EClass, List<EReference>> sourceCandidates = context.getSourceCandidates();

    // get the context branch.
    CDOBranch branch = context.getBranch();
    ObjyBranchManager branchManager = objySession.getBranchManager(getRepositoryName());
    ObjyBranch objyBranch = branchManager.getBranch(branch.getID());

    // iterate over all revision in a branch.
    ObjyObject objyObject = null;
    SortedSet<?> revisions = objyBranch.getRevisions();
    for (Object anObj : revisions)
    {
      // the ooObj we get from revisions is the correct one for that branch.
      objyObject = objySession.getObjectManager().getObject(((ooObj)anObj).getOid());

      // InternalCDORevision revision = getRevision(list, context);
      // if (revision == null || revision instanceof SyntheticCDORevision)
      // {
      // continue;
      // }
      //
      EClass eClass = ObjySchema.getEClass(getStore(), objyObject.objyClass());
      CDOID sourceID = objyObject.getRevisionId();

      List<EReference> eReferences = sourceCandidates.get(eClass);
      if (eReferences != null)
      {
        for (EReference eReference : eReferences)
        {
          if (eReference.isMany())
          {
            List<Object> results = objyObject.fetchList(this, eReference, 0, CDORevision.UNCHUNKED);
            if (results != null)
            {
              try
              {
                int index = 0;
                for (Object id : results)
                {
                  if (!queryXRefs(context, targetIDs, (CDOID)id, sourceID, eReference, index++))
                  {
                    return;
                  }
                }
              }
              catch (Exception ex)
              {
                ex.printStackTrace();
              }
            }
          }
          else
          {
            Object value = objyObject.get(eReference);
            CDOID id = (CDOID)value;
            if (!queryXRefs(context, targetIDs, id, sourceID, eReference, 0))
            {
              return;
            }
          }
        }
      }
    }
  }

  private boolean queryXRefs(QueryXRefsContext context, Set<CDOID> targetIDs, CDOID targetID, CDOID sourceID,
      EReference sourceReference, int index)
  {
    for (CDOID id : targetIDs)
    {
      if (id.equals(targetID))
      {
        if (!context.addXRef(targetID, sourceID, sourceReference, index))
        {
          // No more results allowed
          return false;
        }
      }
    }

    return true;
  }

  /**
   * Read all package units from the store. It's the opposite of writePackageUnits
   */
  public Collection<InternalCDOPackageUnit> readPackageUnits()
  {

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("readPackageUnits()"); //$NON-NLS-1$
    }

    ensureSessionBegin();

    ObjyPackageHandler objyPackageHandler = getStore().getPackageHandler();

    Collection<InternalCDOPackageUnit> packageUnits = objyPackageHandler.readPackageUnits();

    return packageUnits;
  }

  /**
   *
   */
  public InternalCDORevision readRevision(CDOID id, CDOBranchPoint branchPoint, int listChunk,
      CDORevisionCacheAdder cache)
  {
    long __start = System.nanoTime();
    ensureSessionBegin();

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("RR - Read rev for: {0}, TS:{1}", id, branchPoint.getTimeStamp()); //$NON-NLS-1$
    }

    // we shouldn't be doing this!!!
    if (id instanceof CDOIDExternal)
    {
      // 100917 - IS: This must be a bug in CDO, it's throwing a CDOIDExternal at us
      // we'll return null.
      // TRACER_DEBUG.format("objy can't read revision for CDOID: {0}, it's external.", id.toString());
      TRACER_DEBUG.trace("objy can't read revision for external CDOID: " + id.toString());
      return null;
    }

    // we might have a proxy object!!!!

    ObjyObject objyObject = getObject(id);

    if (objyObject == null)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("RR - objyObject is NULL 4 ID:" + id); //$NON-NLS-1$
      }
      return null;
    }
    // else
    // {
    // TRACER_DEBUG.format("RR - objyObject is ID:" + id + ", :" + objyObject.ooId().getStoreString()); //$NON-NLS-1$
    // }

    InternalCDORevision revision = createRevision(objyObject, id);
    revision.setBranchPoint(branchPoint);

    ObjyObject objyRevision = objyObject;

    if (getStore().isRequiredToSupportBranches())
    {
      try
      {
        objyRevision = objyObject.getRevision(branchPoint.getTimeStamp(), branchPoint.getBranch().getID(),
            objySession.getObjectManager());
        if (objyRevision == null)
        {
          TRACER_DEBUG.format("RR - branches ID:{0}, OB:{1}, BPB:{2}, BPTS:{3}", id, objyObject.getBranchId(), //$NON-NLS-1$
              branchPoint.getBranch().getID(), branchPoint.getTimeStamp());
        }
      }
      catch (RuntimeException ex)
      {
        ex.printStackTrace();
      }
    }
    else if (getStore().isRequiredToSupportAudits())
    {
      try
      {
        objyRevision = objyObject.getRevision(branchPoint.getTimeStamp(), CDOBranch.MAIN_BRANCH_ID,
            objySession.getObjectManager());
        if (objyRevision == null)
        {
          TRACER_DEBUG.format("RR - audit ID:{0}, OB:{1}, BPB:{2}, BPTS:{3}", id, objyObject.getBranchId(), //$NON-NLS-1$
              branchPoint.getBranch().getID(), branchPoint.getTimeStamp());
        }
      }
      catch (RuntimeException ex)
      {
        ex.printStackTrace();
      }

    }

    if (objyRevision == null)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("RR - objyRevision is NULL 4 ID:" + id); //$NON-NLS-1$
      }
      return null;
    }

    // check the version
    if (objyRevision.getVersion() < 0)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("RR - ...revision for: {0} - OID: {1} is detached.", id, //$NON-NLS-1$
            objyObject.ooId().getStoreString());
      }
      EClass eClass = ObjySchema.getEClass(getStore(), objyObject.objyClass());
      return new DetachedCDORevision(eClass, id, branchPoint.getBranch(), -objyRevision.getVersion(),
          objyRevision.getCreationTime());
    }

    CDOBranchPoint branchPoint2 = revision.getBranch().getPoint(objyRevision.getCreationTime());
    revision.setBranchPoint(branchPoint2);

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("RR - Fetching revision details for: {0} - OID:{1}", id, //$NON-NLS-1$
          objyRevision.ooId().getStoreString());
    }

    boolean ok = objyRevision.fetch(this, revision, listChunk);

    if (!ok)
    {
      TRACER_DEBUG.format("RR - Fetch rev failed 4: {0}, :{1}", id, objyRevision.ooId().getStoreString()); //$NON-NLS-1$
    }

    readRevisionTime += System.nanoTime() - __start;
    readRevisionCount++;

    return ok ? revision : null;
  }

  /**
   *
   */
  public InternalCDORevision readRevisionByVersion(CDOID id, CDOBranchVersion branchVersion, int listChunk,
      CDORevisionCacheAdder cache)
  {
    long __start = System.nanoTime();
    ensureSessionBegin();

    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("RRBV - Read rev 4: {0}, ver: {1}", id, branchVersion.getVersion()); //$NON-NLS-1$
    }

    // we might have a proxy object!!!!

    ObjyObject objyObject = getObject(id);
    if (objyObject == null)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("RRBV - objyObject is NULL for ID: " + id); //$NON-NLS-1$
      }
      return null;
    }

    // {
    // TRACER_DEBUG.format("RRBV - objyObject 4 ID: " + id + ", :" + objyObject.ooId().getStoreString()); //$NON-NLS-1$
    // }

    ObjyObject objyRevision = null;
    objyRevision = objyObject.getRevisionByVersion(branchVersion.getVersion(), branchVersion.getBranch().getID(),
        objySession.getObjectManager());
    // if (getStore().isRequiredToSupportAudits())
    // {
    // objyRevision = objyObject.getRevisionByVersion(branchVersion.getVersion());
    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("Reading revision by version {0} for: {1} - OID: {2}", branchVersion.getVersion(), id, //$NON-NLS-1$
          objyObject.ooId().getStoreString());
    }

    // }
    // else
    // {
    // objyRevision = objyObject.getLastRevision();
    //
    // if (TRACER_DEBUG.isEnabled())
    // {
    // TRACER_DEBUG.format(
    // "(None-Audit) Reading revision by version for: {0} - OID: {1}", id, objyObject.ooId().getStoreString());
    // //$NON-NLS-1$
    // }
    // }

    if (objyRevision == null)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.format("RRBV - objyRevision is NULL for ID: ", id); //$NON-NLS-1$
      }
      return null;
    }

    InternalCDORevision revision = createRevision(objyRevision, id);

    revision.setVersion(branchVersion.getVersion());
    revision.setBranchPoint(branchVersion.getBranch().getHead());

    // TODO - clean up the following 3 lines...
    // InternalCDOBranchManager branchManager = getStore().getRepository().getBranchManager();
    // CDOBranch mainBranch = branchManager.getBranch(CDOBranch.MAIN_BRANCH_ID);
    // //revision.setBranchPoint(CDOBranchUtil.createBranchPoint(mainBranch, 0));
    // revision.setBranchPoint(mainBranch.getHead());

    boolean ok = objyRevision.fetch(this, revision, listChunk);

    if (ok && objyRevision.getVersion() != branchVersion.getVersion())
    {
      throw new IllegalStateException("Can only retrieve current version " + revision.getVersion() + " for " + //$NON-NLS-1$ //$NON-NLS-2$
          id + " - version requested was " + branchVersion + "."); //$NON-NLS-1$ //$NON-NLS-2$
    }

    // if (!ok)
    // {
    // TRACER_DEBUG.format("RRBV - Fetch rev failed 4: {0}, :", id, objyRevision.ooId().getStoreString()); //$NON-NLS-1$
    // }

    readRevisionTime += System.nanoTime() - __start;
    readRevisionCount++;

    return ok ? revision : null;
  }

  public void writePackageUnits(InternalCDOPackageUnit[] packageUnits, OMMonitor monitor)
  {
    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.format("writePackageUnits()"); //$NON-NLS-1$
    }

    ensureSessionBegin();

    ObjyPackageHandler objyPackageHandler = getStore().getPackageHandler();
    CDOPackageRegistry packageRegistry = getStore().getRepository().getPackageRegistry();

    for (InternalCDOPackageUnit packageUnit : packageUnits)
    {
      objyPackageHandler.writePackages(packageRegistry, packageUnit, monitor/* .fork() */);
    }
  }

  private InternalCDORevision createRevision(ObjyObject objyObject, CDOID id)
  {
    EClass eClass = ObjySchema.getEClass(getStore(), objyObject.objyClass());

    if (eClass == null)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("OBJY: Can't find eClass for id:" + id);
      }
      return null;
    }

    return getStore().createRevision(eClass, id);
  }

  private String getRepositoryName()
  {
    return getStore().getRepository().getName();
  }

  /***
   * For us, this function creates the skeleton objects in Objectivity, to be able to get the new ooId and pass it to
   * the commitContext. The objects data will be updated in the call to writeRevision().
   */
  @Override
  public void addIDMappings(InternalCommitContext commitContext, OMMonitor monitor)
  {
    long __start = System.nanoTime();
    ensureSessionBegin();
    if (commitContext.getNewObjects().length > 0)
    {
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("creating " + commitContext.getNewObjects().length + " new objects and assigning new IDs");
      }
      InternalCDORevision[] newObjects = commitContext.getNewObjects();
      try
      {
        monitor.begin(newObjects.length);

        ObjyPlacementManagerLocal placementManager = new ObjyPlacementManagerLocal(getStore(), objySession,
            commitContext, newObjyObjectsMap);

        // iterate over the list and skip the ones we already have created.
        for (InternalCDORevision revision : newObjects)
        {
          try
          {
            placementManager.processRevision(revision);
          }
          catch (com.objy.db.ObjyRuntimeException ex)
          {
            System.out
                .println(">>>>IS: Exception<<<< Session: " + objySession + " open status: " + objySession.isOpen());
            ex.printStackTrace();
          }
          monitor.worked();
        }
      }
      finally
      {
        monitor.done();
      }
    }
    if (TRACER_DEBUG.isEnabled())
    {
      TRACER_DEBUG.trace(" addIDMappings for " + commitContext.getNewObjects().length + " - time: "
          + (System.nanoTime() - __start) / 1000000.0);
      TRACER_DEBUG.trace(
          "  createObjects : " + ObjyObject.createObjectCount + " - time: " + ObjyObject.createObjectTime / 1000000.0);
      ObjyObject.createObjectTime = 0;
      ObjyObject.createObjectCount = 0;
    }
  }

  @Override
  protected CDOID getNextCDOID(CDORevision revision)
  {
    // Never called
    throw new UnsupportedOperationException();
  }

  /***************************
   * Local Utility functions.
   ***************************/
  public void ensureActiveSession()
  {
    ensureSessionBegin();
  }

  protected void ensureSessionBegin()
  {
    getObjySession();
    if (!objySession.isJoined())
    {
      objySession.join();
    }
    if (!objySession.isOpen())
    {
      if (isRead)
      {
        objySession.setOpenMode(oo.openReadOnly);
      }
      else
      {
        objySession.setOpenMode(oo.openReadWrite);
      }
      objySession.begin();
      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace(" ensureBeginSession() called begin() on session: " + objySession + " [name: "
            + objySession.getName() + " - open: " + objySession.isOpen() + "]");
      }
    }
  }

  private void ensureSessionJoin()
  {
    // we better have a session for this store.
    assert objySession != null;
    // testSwitchViewTarget() is crashing because objySession is null.
    // TBD: verify this case!!!
    if (objySession != null && !objySession.isJoined())
    {
      objySession.join();
    }
  }

  // *********************************************
  // New APIs for CDO 3.0
  // *********************************************

  public void loadCommitInfos(CDOBranch branch, long startTime, long endTime, CDOCommitInfoHandler handler)
  {
    ensureSessionBegin();

    ObjyCommitInfoHandler commitInfoHandler = getStore().getCommitInfoHandler();
    List<ObjyCommitInfo> commitInfoList = commitInfoHandler.getCommitInfo(branch, startTime, endTime);

    InternalSessionManager manager = getSession().getManager();
    InternalRepository repository = manager.getRepository();
    InternalCDOBranchManager branchManager = repository.getBranchManager();
    InternalCDOCommitInfoManager commitInfoManager = repository.getCommitInfoManager();

    for (ObjyCommitInfo ooCommitInfo : commitInfoList)
    {
      long timeStamp = ooCommitInfo.getTimeStamp();
      long previousTimeStamp = ooCommitInfo.getPreviousTimeStamp();
      String userID = ooCommitInfo.getUserId();
      String comment = ooCommitInfo.getComment();
      CDOBranch infoBranch = branch;
      if (infoBranch == null)
      {
        int id = ooCommitInfo.getBranchId();
        infoBranch = branchManager.getBranch(id);
      }

      CDOCommitInfo commitInfo = commitInfoManager.createCommitInfo(infoBranch, timeStamp, previousTimeStamp, userID,
          comment, null);
      handler.handleCommitInfo(commitInfo);
    }

  }

  @Override
  protected void writeCommitInfo(CDOBranch branch, long timeStamp, long previousTimeStamp, String userID,
      String comment, OMMonitor monitor)
  {
    ensureSessionBegin();
    // we need to write the following...
    // ...branch.getID(), timeStamp, userID, comment.
    try
    {
      ObjyCommitInfoHandler commitInfoHandler = getStore().getCommitInfoHandler();
      commitInfoHandler.writeCommitInfo(branch.getID(), timeStamp, previousTimeStamp, userID, comment);
    }
    catch (com.objy.db.ObjyRuntimeException ex)
    {
      ex.printStackTrace();
    }
  }

  public IQueryHandler getQueryHandler(org.eclipse.emf.cdo.common.util.CDOQueryInfo info)
  {
    if (ObjectivityQueryHandler.QUERY_LANGUAGE.equals(info.getQueryLanguage()))
    {
      return new ObjectivityQueryHandler(this);
    }

    return null;
  }

  public Pair<Integer, Long> createBranch(int branchID, BranchInfo branchInfo)
  {
    ensureSessionBegin();
    boolean convertToUpdate = false;
    // IS: this is a hack to overcome the issue in cdo core where the Accessor is requested for
    // read but it's trying to create stuff.
    if (isRead)
    {
      TRACER_DEBUG.trace("-->> createBranch() - Hack... Hack... changing read to update.");
      // upgrade the session to update.
      objySession.commit();
      objySession.setOpenMode(oo.openReadWrite);
      convertToUpdate = true;
      objySession.begin();
    }
    Pair<Integer, Long> retValue = objySession.getBranchManager(getRepositoryName()).createBranch(branchID, branchInfo);
    if (convertToUpdate)
    {
      // return the session to read.
      objySession.commit();
      objySession.setOpenMode(oo.openReadOnly);
      objySession.begin();
    }
    return retValue;
  }

  public BranchInfo loadBranch(int branchID)
  {
    ensureSessionBegin();
    ObjyBranch objyBranch = objySession.getBranchManager(getRepositoryName()).getBranch(branchID);
    return objyBranch != null ? objyBranch.getBranchInfo() : null;
  }

  public int loadBranches(int startID, int endID, CDOBranchHandler branchHandler)
  {
    int count = 0;
    List<ObjyBranch> branches = objySession.getBranchManager(getRepositoryName()).getBranches(startID, endID);
    InternalCDOBranchManager branchManager = getStore().getRepository().getBranchManager();

    for (ObjyBranch objyBranch : branches)
    {
      InternalCDOBranch branch = branchManager.getBranch(objyBranch.getBranchId(), new BranchInfo(
          objyBranch.getBranchName(), objyBranch.getBaseBranchId(), objyBranch.getBaseBranchTimeStamp()));
      branchHandler.handleBranch(branch);
      count++;
    }

    return count;

  }

  public SubBranchInfo[] loadSubBranches(int branchID)
  {
    ensureSessionBegin();
    List<SubBranchInfo> result = new ArrayList<SubBranchInfo>();
    List<ObjyBranch> objyBranchList = objySession.getBranchManager(getRepositoryName()).getSubBranches(branchID);
    for (ObjyBranch objyBranch : objyBranchList)
    {
      SubBranchInfo subBranchInfo = new SubBranchInfo(objyBranch.getBranchId(), objyBranch.getBranchName(),
          objyBranch.getBaseBranchTimeStamp());
      result.add(subBranchInfo);
    }
    return result.toArray(new SubBranchInfo[result.size()]);
  }

  public void handleRevisions(EClass eClass, CDOBranch branch, long timeStamp, boolean exactTime,
      CDORevisionHandler handler)
  {
    ensureSessionBegin();
    IRepository repository = getStore().getRepository();
    CDORevisionManager revisionManager = repository.getRevisionManager();
    CDOBranchManager branchManager = repository.getBranchManager();

    // scan FD for ObjyBase which is the base class for all revisions
    Iterator<?> itr = objySession.getFD().scan(ObjyBase.CLASS_NAME);
    ObjyObject objyObject = null;
    while (itr.hasNext())
    {
      objyObject = objySession.getObjectManager().getObject(((ooObj)itr).getOid());
      if (!handleRevision(objyObject, eClass, branch, timeStamp, exactTime, handler, revisionManager, branchManager))
      {
        return;
      }
    }
    // TODO: implement ObjectivityStoreAccessor.handleRevisions(eClass, branch, timeStamp, exactTime, handler)
    throw new UnsupportedOperationException();
  }

  private boolean handleRevision(ObjyObject objyObject, EClass eClass, CDOBranch branch, long timeStamp,
      boolean exactTime, CDORevisionHandler handler, CDORevisionManager revisionManager, CDOBranchManager branchManager)
  {
    if (objyObject.getVersion() < 0) // DetachedCDORevision
    {
      return true;
    }

    if (eClass != null && ObjySchema.getEClass(getStore(), objyObject.objyClass()) != eClass)
    {
      return true;
    }

    if (branch != null && objyObject.getBranchId() != branch.getID())
    {
      return true;
    }

    if (timeStamp != CDOBranchPoint.INVALID_DATE)
    {
      if (exactTime)
      {
        if (timeStamp != CDOBranchPoint.UNSPECIFIED_DATE && objyObject.getCreationTime() != timeStamp)
        {
          return true;
        }
      }
      else
      {
        long startTime = objyObject.getCreationTime();
        long endTime = objyObject.getRevisedTime();
        if (!CDOCommonUtil.isValidTimeStamp(timeStamp, startTime, endTime))
        {
          return true;
        }
      }
    }

    CDOBranchVersion branchVersion = branchManager.getBranch((int)objyObject.getBranchId())
        .getVersion(Math.abs(objyObject.getVersion()));
    InternalCDORevision revision = (InternalCDORevision)revisionManager
        .getRevisionByVersion(OBJYCDOIDUtil.getCDOID(objyObject.ooId()), branchVersion, CDORevision.UNCHUNKED, true);

    return handler.handleRevision(revision);
  }

  public Set<CDOID> readChangeSet(OMMonitor monitor, CDOChangeSetSegment... segments)
  {
    monitor.begin(segments.length);

    try
    {
      ensureSessionBegin();

      ObjyBranchManager objyBranchManager = objySession.getBranchManager(getRepositoryName());
      ObjyObjectManager objyObjectManager = objySession.getObjectManager();
      Set<CDOID> results = new HashSet<CDOID>();

      // get all revisions that has branchId, and creation timestamp, and perhaps revised before
      // end timestamp or haven't been revised.
      for (CDOChangeSetSegment segment : segments)
      {
        ObjyBranch objyBranch = objyBranchManager.getBranch(segment.getBranch().getID());
        // query the branch revisions for the time range.
        SortedSet<?> revisions = objyBranch.getRevisions();
        readChangeSet(monitor.fork(), segment, objyObjectManager, revisions, results);
      }

      if (TRACER_DEBUG.isEnabled())
      {
        TRACER_DEBUG.trace("ChangeSet " + results.toString());
      }

      return results;
    }
    finally
    {
      monitor.done();
    }
  }

  protected void readChangeSet(OMMonitor monitor, CDOChangeSetSegment segment, ObjyObjectManager objyObjectManager,
      SortedSet<?> revisions, Set<CDOID> results)
  {
    int size = revisions.size();
    monitor.begin(size);
    Async async = null;
    try
    {
      async = monitor.forkAsync();

      Iterator<?> objItr = revisions.iterator();
      while (objItr.hasNext())
      {
        ooObj anObj = (ooObj)objItr.next();
        ObjyObject objyObject = objyObjectManager.getObject(anObj.getOid());
        long creationTime = objyObject.getCreationTime();
        long revisedTime = objyObject.getRevisedTime();
        if (creationTime >= segment.getTimeStamp() && (revisedTime <= segment.getEndTime() || revisedTime == 0))
        {
          results.add(objyObject.getRevisionId());
        }

        monitor.worked();
      }
    }
    finally
    {
      async.stop();
      monitor.done();

    }
  }

  public void queryLobs(List<byte[]> ids)
  {
    // TODO: implement ObjectivityStoreAccessor.queryLobs(ids)
    throw new UnsupportedOperationException();
  }

  public void handleLobs(long fromTime, long toTime, CDOLobHandler handler) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.handleLobs(fromTime, toTime, handler)
    throw new UnsupportedOperationException();
  }

  public void loadLob(byte[] id, OutputStream out) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.loadLob(id, out)
    throw new UnsupportedOperationException();
  }

  @Override
  protected void writeBlob(byte[] id, long size, InputStream inputStream) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.writeBlob(id, size, inputStream)
    throw new UnsupportedOperationException();
  }

  @Override
  protected void writeClob(byte[] id, long size, Reader reader) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.writeClob(id, size, reader)
    throw new UnsupportedOperationException();
  }

  public void rawExport(CDODataOutput out, int fromBranchID, int toBranchID, long fromCommitTime, long toCommitTime)
      throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.rawExport();
    throw new UnsupportedOperationException();
  }

  public void rawImport(CDODataInput in, int fromBranchID, int toBranchID, long fromCommitTime, long toCommitTime,
      OMMonitor monitor) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.rawImport
    throw new UnsupportedOperationException();
  }

  public void rawStore(InternalCDOPackageUnit[] packageUnits, OMMonitor monitor)
  {
    // TODO: implement ObjectivityStoreAccessor.rawStore
    throw new UnsupportedOperationException();
  }

  public void rawStore(InternalCDORevision revision, OMMonitor monitor)
  {
    // TODO: implement ObjectivityStoreAccessor.rawStore
    throw new UnsupportedOperationException();
  }

  public void rawStore(byte[] id, long size, InputStream inputStream) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.rawStore
    throw new UnsupportedOperationException();
  }

  public void rawStore(byte[] id, long size, Reader reader) throws IOException
  {
    // TODO: implement ObjectivityStoreAccessor.rawStore
    throw new UnsupportedOperationException();
  }

  public void rawStore(CDOBranch branch, long timeStamp, long previousTimeStamp, String userID, String comment,
      OMMonitor monitor)
  {
    // TODO: implement ObjectivityStoreAccessor.rawStore
    throw new UnsupportedOperationException();
  }

  @Deprecated
  public void rawDelete(CDOID id, int version, CDOBranch branch, EClass eClass, OMMonitor monitor)
  {
    throw new UnsupportedOperationException();
  }

  public void rawCommit(double commitWork, OMMonitor monitor)
  {
    // TODO: implement ObjectivityStoreAccessor.rawCommit
    throw new UnsupportedOperationException();
  }

  public LockArea createLockArea(String userID, CDOBranchPoint branchPoint, boolean readOnly,
      Map<CDOID, LockGrade> locks)
  {
    // TODO: implement ObjectivityStoreAccessor.createLockArea
    throw new UnsupportedOperationException();
  }

  public LockArea getLockArea(String durableLockingID) throws LockAreaNotFoundException
  {
    // TODO: implement ObjectivityStoreAccessor.getLockArea
    throw new UnsupportedOperationException();
  }

  public void getLockAreas(String userIDPrefix, Handler handler)
  {
    ensureSessionBegin();

    InternalCDOBranchManager branchManager = getStore().getRepository().getBranchManager();
    ObjyLockAreaManager objyLockAreaManager = objySession.getLockAreaManager(getRepositoryName());
    objyLockAreaManager.getLockAreas(branchManager, userIDPrefix, handler);
  }

  public void deleteLockArea(String durableLockingID)
  {
    // TODO: implement ObjectivityStoreAccessor.deleteLockArea
    throw new UnsupportedOperationException();
  }

  public void lock(String durableLockingID, LockType type, Collection<? extends Object> objectsToLock)
  {
    // TODO: implement ObjectivityStoreAccessor.lock
    throw new UnsupportedOperationException();
  }

  public void unlock(String durableLockingID, LockType type, Collection<? extends Object> objectsToUnlock)
  {
    // TODO: implement ObjectivityStoreAccessor.unlock
    throw new UnsupportedOperationException();
  }

  public void unlock(String durableLockingID)
  {
    // TODO: implement ObjectivityStoreAccessor.unlock
    throw new UnsupportedOperationException();
  }
}