*

  *  *  Copyright 2014 Orient Technologies LTD (info(at)orientechnologies.com)

  *  *

  *  *  Licensed under the Apache License, Version 2.0 (the "License");

  *  *  you may not use this file except in compliance with the License.

  *  *  You may obtain a copy of the License at

  *  *

  *  *       http://www.apache.org/licenses/LICENSE-2.0

  *  *

  *  *  Unless required by applicable law or agreed to in writing, software

  *  *  distributed under the License is distributed on an "AS IS" BASIS,

  *  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  *  *  See the License for the specific language governing permissions and

  *  *  limitations under the License.

  *  *

  *  * For more information: http://www.orientechnologies.com

  *

  */

* @author Andrey Lomakin

* @since 28.03.13

*/

  protected static String[]                      ALL_FILE_EXTENSIONS                  = { ".ocf", ".pls", ".pcl", ".oda", ".odh",

      ".otx", ".ocs", ".oef", ".oem", ".oet", ODiskWriteAheadLog.WAL_SEGMENT_EXTENSION, ODiskWriteAheadLog.MASTER_RECORD_EXTENSION,

      OHashTableIndexEngine.BUCKET_FILE_EXTENSION, OHashTableIndexEngine.METADATA_FILE_EXTENSION,

      OHashTableIndexEngine.TREE_FILE_EXTENSION, OHashTableIndexEngine.NULL_BUCKET_FILE_EXTENSION,

      OClusterPositionMap.DEF_EXTENSION, OSBTreeIndexEngine.DATA_FILE_EXTENSION, OWOWCache.NAME_ID_MAP_EXTENSION,

      OIndexRIDContainer.INDEX_FILE_EXTENSION, OSBTreeCollectionManagerShared.DEFAULT_EXTENSION,

      OSBTreeIndexEngine.NULL_BUCKET_FILE_EXTENSION                                  };

  private final ConcurrentMap<String, OCluster>  clusterMap                           = new ConcurrentHashMap<String, OCluster>();

  private final ThreadLocal<OStorageTransaction> transaction                          = new ThreadLocal<OStorageTransaction>();

  private final OModificationLock                modificationLock                     = new OModificationLock();

  protected volatile OWriteAheadLog              writeAheadLog;

  protected volatile ODiskCache                  diskCache;

  private CopyOnWriteArrayList<OCluster>         clusters                             = new CopyOnWriteArrayList<OCluster>();

  private volatile int                           defaultClusterId                     = -1;

  private volatile OAtomicOperationsManager      atomicOperationsManager;

  private volatile boolean                       wereDataRestoredAfterOpen            = false;

  private boolean                                makeFullCheckPointAfterClusterCreate = OGlobalConfiguration.STORAGE_MAKE_FULL_CHECKPOINT_AFTER_CLUSTER_CREATE

                                                                                          .getValueAsBoolean();

  public OAbstractPaginatedStorage(String name, String filePath, String mode) {

    super(name, filePath, mode);

  }

  public void open(final String iUserName, final String iUserPassword, final Map<String, Object> iProperties) {

    addUser();

    if (status == STATUS.OPEN)

      // ALREADY OPENED: THIS IS THE CASE WHEN A STORAGE INSTANCE IS

      // REUSED

      return;

    lock.acquireExclusiveLock();

    try {

      if (status == STATUS.OPEN)

        // ALREADY OPENED: THIS IS THE CASE WHEN A STORAGE INSTANCE IS

        // REUSED

        return;

      status = STATUS.OPENING;

      if (!exists())

        throw new OStorageException("Cannot open the storage '" + name + "' because it does not exist in path: " + url);

      configuration.load();

      componentsFactory = new OCurrentStorageComponentsFactory(configuration);

      preOpenSteps();

      initWalAndDiskCache();

      atomicOperationsManager = new OAtomicOperationsManager(writeAheadLog);

      // OPEN BASIC SEGMENTS

      int pos;

      addDefaultClusters();

      // REGISTER CLUSTER

      for (int i = 0; i < configuration.clusters.size(); ++i) {

        final OStorageClusterConfiguration clusterConfig = configuration.clusters.get(i);

        if (clusterConfig != null) {

          pos = createClusterFromConfig(clusterConfig);

          try {

            if (pos == -1) {

              clusters.get(i).open();

            } else {

              if (clusterConfig.getName().equals(CLUSTER_DEFAULT_NAME))

                defaultClusterId = pos;

              clusters.get(pos).open();

            }

          } catch (FileNotFoundException e) {

            OLogManager.instance().warn(

                this,

                "Error on loading cluster '" + clusters.get(i).getName() + "' (" + i

                    + "): file not found. It will be excluded from current database '" + getName() + "'.");

            clusterMap.remove(clusters.get(i).getName().toLowerCase());

            setCluster(i, null);

          }

        } else {

          setCluster(i, null);

        }

      }

      restoreIfNeeded();

      clearStorageDirty();

      status = STATUS.OPEN;

    } catch (Exception e) {

      status = STATUS.CLOSED;

      throw new OStorageException("Cannot open local storage '" + url + "' with mode=" + mode, e);

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public void create(final Map<String, Object> iProperties) {

    lock.acquireExclusiveLock();

    try {

      if (status != STATUS.CLOSED)

        throw new OStorageException("Cannot create new storage '" + name + "' because it is not closed");

      addUser();

      if (exists())

        throw new OStorageException("Cannot create new storage '" + name + "' because it already exists");

      if (!configuration.getContextConfiguration().getContextKeys()

          .contains(OGlobalConfiguration.STORAGE_COMPRESSION_METHOD.getKey()))

        // SAVE COMPRESSION IN STORAGE CFG

        configuration.getContextConfiguration().setValue(OGlobalConfiguration.STORAGE_COMPRESSION_METHOD,

            OGlobalConfiguration.STORAGE_COMPRESSION_METHOD.getValue());

      componentsFactory = new OCurrentStorageComponentsFactory(configuration);

      initWalAndDiskCache();

      atomicOperationsManager = new OAtomicOperationsManager(writeAheadLog);

      preCreateSteps();

      status = STATUS.OPEN;

      // ADD THE METADATA CLUSTER TO STORE INTERNAL STUFF

      doAddCluster(OMetadataDefault.CLUSTER_INTERNAL_NAME, false, null);

      configuration.create();

      // ADD THE INDEX CLUSTER TO STORE, BY DEFAULT, ALL THE RECORDS OF

      // INDEXING

      doAddCluster(OMetadataDefault.CLUSTER_INDEX_NAME, false, null);

      // ADD THE INDEX CLUSTER TO STORE, BY DEFAULT, ALL THE RECORDS OF

      // INDEXING

      doAddCluster(OMetadataDefault.CLUSTER_MANUAL_INDEX_NAME, false, null);

      // ADD THE DEFAULT CLUSTER

      defaultClusterId = doAddCluster(CLUSTER_DEFAULT_NAME, false, null);

      clearStorageDirty();

      if (OGlobalConfiguration.STORAGE_MAKE_FULL_CHECKPOINT_AFTER_CREATE.getValueAsBoolean())

        makeFullCheckpoint();

      postCreateSteps();

    } catch (OStorageException e) {

      close();

      throw e;

    } catch (IOException e) {

      close();

      throw new OStorageException("Error on creation of storage '" + name + "'", e);

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public void makeFullCheckpoint() throws IOException {

    if (writeAheadLog == null)

      return;

    try {

      modificationLock.prohibitModifications();

      lock.acquireSharedLock();

      try {

        writeAheadLog.flush();

        if (configuration != null)

          configuration.synch();

        final OLogSequenceNumber lastLSN = writeAheadLog.logFullCheckpointStart();

        diskCache.flushBuffer();

        writeAheadLog.logFullCheckpointEnd();

        writeAheadLog.flush();

        writeAheadLog.cutTill(lastLSN);

        clearStorageDirty();

      } catch (IOException ioe) {

        throw new OStorageException("Error during checkpoint creation for storage " + name, ioe);

      } finally {

        lock.releaseSharedLock();

      }

    } finally {

      modificationLock.allowModifications();

    }

  }

  public void startAtomicOperation() throws IOException {

    lock.acquireSharedLock();

    try {

      makeStorageDirty();

      atomicOperationsManager.startAtomicOperation();

    } finally {

      lock.releaseSharedLock();

    }

  }

  public void commitAtomicOperation() throws IOException {

    lock.acquireSharedLock();

    try {

      atomicOperationsManager.endAtomicOperation(false);

    } finally {

      lock.releaseSharedLock();

    }

  }

  public void rollbackAtomicOperation() throws IOException {

    lock.acquireSharedLock();

    try {

      atomicOperationsManager.endAtomicOperation(true);

    } finally {

      lock.releaseSharedLock();

    }

  }

  public void markDirty() throws IOException {

    makeStorageDirty();

  }

  @Override

  public void close(final boolean force, boolean onDelete) {

    doClose(force, onDelete);

  }

  public void delete() {

    final long timer = Orient.instance().getProfiler().startChrono();

    lock.acquireExclusiveLock();

    try {

      // CLOSE THE DATABASE BY REMOVING THE CURRENT USER

      if (status != STATUS.CLOSED) {

        if (getUsers() > 0) {

          while (removeUser() > 0)

            ;

        }

      }

      doClose(true, true);

      try {

        Orient.instance().unregisterStorage(this);

      } catch (Exception e) {

        OLogManager.instance().error(this, "Cannot unregister storage", e);

      }

      if (writeAheadLog != null)

        writeAheadLog.delete();

      if (diskCache != null)

        diskCache.delete();

      postDeleteSteps();

    } catch (IOException e) {

      throw new OStorageException("Cannot delete database '" + name + "'.", e);

    } finally {

      lock.releaseExclusiveLock();

      Orient.instance().getProfiler().stopChrono("db." + name + ".drop", "Drop a database", timer, "db.*.drop");

    }

  }

  public boolean check(final boolean verbose, final OCommandOutputListener listener) {

    lock.acquireExclusiveLock();

    try {

      final long start = System.currentTimeMillis();

      OPageDataVerificationError[] pageErrors = diskCache.checkStoredPages(verbose ? listener : null);

      listener.onMessage("Check of storage completed in " + (System.currentTimeMillis() - start) + "ms. "

          + (pageErrors.length > 0 ? pageErrors.length + " with errors." : " without errors."));

      return pageErrors.length == 0;

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public void enableFullCheckPointAfterClusterCreate() {

    checkOpeness();

    lock.acquireExclusiveLock();

    try {

      makeFullCheckPointAfterClusterCreate = true;

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public void disableFullCheckPointAfterClusterCreate() {

    checkOpeness();

    lock.acquireExclusiveLock();

    try {

      makeFullCheckPointAfterClusterCreate = false;

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public boolean isMakeFullCheckPointAfterClusterCreate() {

    checkOpeness();

    lock.acquireSharedLock();

    try {

      return makeFullCheckPointAfterClusterCreate;

    } finally {

      lock.releaseSharedLock();

    }

  }

  public int addCluster(String clusterName, boolean forceListBased, final Object... parameters) {

    checkOpeness();

    lock.acquireExclusiveLock();

    try {

      makeStorageDirty();

      return doAddCluster(clusterName, true, parameters);

    } catch (Exception e) {

      throw new OStorageException("Error in creation of new cluster '" + clusterName, e);

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public int addCluster(String clusterName, int requestedId, boolean forceListBased, Object... parameters) {

    lock.acquireExclusiveLock();

    try {

      if (requestedId < 0) {

        throw new OConfigurationException("Cluster id must be positive!");

      }

      if (requestedId < clusters.size() && clusters.get(requestedId) != null) {

        throw new OConfigurationException("Requested cluster ID [" + requestedId + "] is occupied by cluster with name ["

            + clusters.get(requestedId).getName() + "]");

      }

      makeStorageDirty();

      return addClusterInternal(clusterName, requestedId, true, parameters);

    } catch (Exception e) {

      throw new OStorageException("Error in creation of new cluster '" + clusterName + "'", e);

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  public boolean dropCluster(final int clusterId, final boolean iTruncate) {

    lock.acquireExclusiveLock();

    try {

      if (clusterId < 0 || clusterId >= clusters.size())

        throw new IllegalArgumentException("Cluster id '" + clusterId + "' is outside the of range of configured clusters (0-"

            + (clusters.size() - 1) + ") in database '" + name + "'");

      final OCluster cluster = clusters.get(clusterId);

      if (cluster == null)

        return false;

      if (iTruncate)

        cluster.truncate();

      cluster.delete();

      makeStorageDirty();

      clusterMap.remove(cluster.getName().toLowerCase());

      clusters.set(clusterId, null);

      // UPDATE CONFIGURATION

      configuration.dropCluster(clusterId);

      makeFullCheckpoint();

      return true;

    } catch (Exception e) {

      throw new OStorageException("Error while removing cluster '" + clusterId + "'", e);

    } finally {

      lock.releaseExclusiveLock();

    }

  }

  @Override

  public Class<OSBTreeCollectionManagerShared> getCollectionManagerClass() {

    return OSBTreeCollectionManagerShared.class;

  }

  public ODiskCache getDiskCache() {

    return diskCache;

  }

  public void freeze(boolean throwException, int clusterId) {

    final OCluster cluster = getClusterById(clusterId);

    final String name = cluster.getName();

    if (OMetadataDefault.CLUSTER_INDEX_NAME.equals(name) || OMetadataDefault.CLUSTER_MANUAL_INDEX_NAME.equals(name)) {

      throw new IllegalArgumentException("It is impossible to freeze and release index or manual index cluster!");

    }

    cluster.getExternalModificationLock().prohibitModifications(throwException);

    try {

      cluster.synch();

      cluster.setSoftlyClosed(true);

    } catch (IOException e) {

      throw new OStorageException("Error on synch cluster '" + name + "'", e);

    }

  }

  public void release(int clusterId) {

    final OCluster cluster = getClusterById(clusterId);

    final String name = cluster.getName();

    if (OMetadataDefault.CLUSTER_INDEX_NAME.equals(name) || OMetadataDefault.CLUSTER_MANUAL_INDEX_NAME.equals(name)) {

      throw new IllegalArgumentException("It is impossible to freeze and release index or manualindex cluster!");

    }

    try {

      cluster.setSoftlyClosed(false);

    } catch (IOException e) {

      throw new OStorageException("Error on unfreeze storage '" + name + "'", e);

    }

    cluster.getExternalModificationLock().allowModifications();

  }

  public long count(final int iClusterId) {

    return count(iClusterId, false);

  }

  @Override

  public long count(int clusterId, boolean countTombstones) {

    if (clusterId == -1)

      throw new OStorageException("Cluster Id " + clusterId + " is invalid in database '" + name + "'");

    // COUNT PHYSICAL CLUSTER IF ANY

    checkOpeness();

    final OCluster cluster = clusters.get(clusterId);

    if (cluster == null)

      return 0;

    if (countTombstones)

      return cluster.getEntries();

    return cluster.getEntries() - cluster.getTombstonesCount();

  }

  public OClusterPosition[] getClusterDataRange(final int iClusterId) {

    if (iClusterId == -1)

      return new OClusterPosition[] { OClusterPosition.INVALID_POSITION, OClusterPosition.INVALID_POSITION };

    checkOpeness();

    try {

      return clusters.get(iClusterId) != null ? new OClusterPosition[] { clusters.get(iClusterId).getFirstPosition(),

          clusters.get(iClusterId).getLastPosition() } : new OClusterPosition[0];

    } catch (IOException ioe) {

      throw new OStorageException("Can not retrieve information about data range", ioe);

    }

  }

  public long count(final int[] iClusterIds) {

    return count(iClusterIds, false);

  }

  @Override

  public long count(int[] iClusterIds, boolean countTombstones) {

    checkOpeness();

    long tot = 0;

    for (int iClusterId : iClusterIds) {

      if (iClusterId >= clusters.size())

        throw new OConfigurationException("Cluster id " + iClusterId + " was not found in database '" + name + "'");

      if (iClusterId > -1) {

        final OCluster c = clusters.get(iClusterId);

        if (c != null)

          tot += c.getEntries() - (countTombstones ? 0L : c.getTombstonesCount());

      }

    }

    return tot;

  }

  public OStorageOperationResult<OPhysicalPosition> createRecord(final ORecordId rid, final byte[] content,

      ORecordVersion recordVersion, final byte recordType, final int mode, final ORecordCallback<OClusterPosition> callback) {

    checkOpeness();

    final long timer = Orient.instance().getProfiler().startChrono();

    final OCluster cluster = getClusterById(rid.clusterId);

    cluster.getExternalModificationLock().requestModificationLock();

    try {

      modificationLock.requestModificationLock();

      try {

        checkOpeness();

        if (content == null)

          throw new IllegalArgumentException("Record is null");

        OPhysicalPosition ppos = new OPhysicalPosition(recordType);

        try {

          lock.acquireSharedLock();

          try {

            if (recordVersion.getCounter() > -1)

              recordVersion.increment();

            else

              recordVersion = OVersionFactory.instance().createVersion();

            makeStorageDirty();

            atomicOperationsManager.startAtomicOperation();

            try {

              ppos = cluster.createRecord(content, recordVersion, recordType);

              rid.clusterPosition = ppos.clusterPosition;

              final ORecordSerializationContext context = ORecordSerializationContext.getContext();

              if (context != null)

                context.executeOperations(this);

              atomicOperationsManager.endAtomicOperation(false);

            } catch (Throwable throwable) {

              atomicOperationsManager.endAtomicOperation(true);

              OLogManager.instance().error(this, "Error on creating record in cluster: " + cluster, throwable);

              try {

                if (ppos.clusterPosition != null && ppos.clusterPosition.compareTo(OClusterPosition.INVALID_POSITION) != 0)

                  cluster.deleteRecord(ppos.clusterPosition);

              } catch (IOException e) {

                OLogManager.instance().error(this, "Error on removing record in cluster: " + cluster, e);

              }

              return null;

            }

            if (callback != null)

              callback.call(rid, ppos.clusterPosition);

            return new OStorageOperationResult<OPhysicalPosition>(ppos);

          } finally {

            lock.releaseSharedLock();

          }

        } catch (IOException ioe) {

          try {

            if (ppos.clusterPosition != null && ppos.clusterPosition.compareTo(OClusterPosition.INVALID_POSITION) != 0)

              cluster.deleteRecord(ppos.clusterPosition);

          } catch (IOException e) {

            OLogManager.instance().error(this, "Error on removing record in cluster: " + cluster, e);

          }

          OLogManager.instance().error(this, "Error on creating record in cluster: " + cluster, ioe);

          return null;

        }

      } finally {

        modificationLock.releaseModificationLock();

      }

    } finally {

      cluster.getExternalModificationLock().releaseModificationLock();

      Orient.instance().getProfiler().stopChrono(PROFILER_CREATE_RECORD, "Create a record in database", timer, "db.*.createRecord");

    }

  }

  @Override

  public ORecordMetadata getRecordMetadata(ORID rid) {

    if (rid.isNew())

      throw new OStorageException("Passed record with id " + rid + " is new and can not be stored.");

    checkOpeness();

    final OCluster cluster = getClusterById(rid.getClusterId());

    lock.acquireSharedLock();

    try {

      Lock recordLock = lockManager.acquireSharedLock(rid);

      try {

        final OPhysicalPosition ppos = cluster.getPhysicalPosition(new OPhysicalPosition(rid.getClusterPosition()));

        if (ppos == null)

          return null;

        return new ORecordMetadata(rid, ppos.recordVersion);

      } finally {

        lockManager.releaseLock(recordLock);

      }

    } catch (IOException ioe) {

      OLogManager.instance().error(this, "Retrieval of record  '" + rid + "' cause: " + ioe.getMessage(), ioe);

    } finally {

      lock.releaseSharedLock();

    }

    return null;

  }

  @Override

  public OStorageOperationResult<ORawBuffer> readRecord(final ORecordId iRid, final String iFetchPlan, boolean iIgnoreCache,

      ORecordCallback<ORawBuffer> iCallback, boolean loadTombstones, LOCKING_STRATEGY iLockingStrategy) {

    checkOpeness();

    return new OStorageOperationResult<ORawBuffer>(readRecord(getClusterById(iRid.clusterId), iRid, true, loadTombstones,

        iLockingStrategy));

  }

  @Override

  public OStorageOperationResult<ORecordVersion> updateRecord(final ORecordId rid, boolean updateContent, byte[] content,

      final ORecordVersion version, final byte recordType, final int mode, ORecordCallback<ORecordVersion> callback) {

    checkOpeness();

    final long timer = Orient.instance().getProfiler().startChrono();

    final OCluster cluster = getClusterById(rid.clusterId);

    cluster.getExternalModificationLock().requestModificationLock();

    try {

      modificationLock.requestModificationLock();

      try {

        lock.acquireSharedLock();

        try {

          // GET THE SHARED LOCK AND GET AN EXCLUSIVE LOCK AGAINST THE RECORD

          Lock recordLock = lockManager.acquireExclusiveLock(rid);

          try {

            // UPDATE IT

            final OPhysicalPosition ppos = cluster.getPhysicalPosition(new OPhysicalPosition(rid.clusterPosition));

            if (!checkForRecordValidity(ppos)) {

              final ORecordVersion recordVersion = OVersionFactory.instance().createUntrackedVersion();

              if (callback != null)

                callback.call(rid, recordVersion);

              return new OStorageOperationResult<ORecordVersion>(recordVersion);

            }

            boolean contentModified = false;

            if (updateContent) {

              final byte[] newContent = checkAndIncrementVersion(cluster, rid, version, ppos.recordVersion, content, recordType);

              if (newContent != null) {

                contentModified = true;

                content = newContent;

              }

            }

            makeStorageDirty();

            atomicOperationsManager.startAtomicOperation();

            try {

              if (updateContent)

                cluster.updateRecord(rid.clusterPosition, content, ppos.recordVersion, recordType);

              final ORecordSerializationContext context = ORecordSerializationContext.getContext();

              if (context != null)

                context.executeOperations(this);

              atomicOperationsManager.endAtomicOperation(false);

            } catch (Throwable e) {

              atomicOperationsManager.endAtomicOperation(true);

              OLogManager.instance().error(this, "Error on updating record " + rid + " (cluster: " + cluster + ")", e);

              final ORecordVersion recordVersion = OVersionFactory.instance().createUntrackedVersion();

              if (callback != null)

                callback.call(rid, recordVersion);

              return new OStorageOperationResult<ORecordVersion>(recordVersion);

            }

            if (callback != null)

              callback.call(rid, ppos.recordVersion);

            if (contentModified)

              return new OStorageOperationResult<ORecordVersion>(ppos.recordVersion, content, false);

            else

              return new OStorageOperationResult<ORecordVersion>(ppos.recordVersion);

          } finally {

            lockManager.releaseLock(recordLock);

          }

        } catch (IOException e) {

          OLogManager.instance().error(this, "Error on updating record " + rid + " (cluster: " + cluster + ")", e);

          final ORecordVersion recordVersion = OVersionFactory.instance().createUntrackedVersion();

          if (callback != null)

            callback.call(rid, recordVersion);

          return new OStorageOperationResult<ORecordVersion>(recordVersion);

        } finally {

          lock.releaseSharedLock();

        }

      } finally {

        modificationLock.releaseModificationLock();

      }

    } finally {

      cluster.getExternalModificationLock().releaseModificationLock();

      Orient.instance().getProfiler().stopChrono(PROFILER_UPDATE_RECORD, "Update a record to database", timer, "db.*.updateRecord");

    }

  }

  public OStorageTransaction getStorageTransaction() {

    return transaction.get();

  }

  public OAtomicOperationsManager getAtomicOperationsManager() {

    return atomicOperationsManager;

  }

  public OWriteAheadLog getWALInstance() {

    return writeAheadLog;

  }

  @Override

  public OStorageOperationResult<Boolean> deleteRecord(final ORecordId rid, final ORecordVersion version, final int mode,

      ORecordCallback<Boolean> callback) {

    checkOpeness();

    final long timer = Orient.instance().getProfiler().startChrono();

    final OCluster cluster = getClusterById(rid.clusterId);

    cluster.getExternalModificationLock().requestModificationLock();

    try {

      modificationLock.requestModificationLock();

      try {

        lock.acquireSharedLock();

        try {

          Lock recordLock = lockManager.acquireExclusiveLock(rid);

          try {

            final OPhysicalPosition ppos = cluster.getPhysicalPosition(new OPhysicalPosition(rid.clusterPosition));

            if (ppos == null)

              // ALREADY DELETED

              return new OStorageOperationResult<Boolean>(false);

            // MVCC TRANSACTION: CHECK IF VERSION IS THE SAME

            if (version.getCounter() > -1 && !ppos.recordVersion.equals(version))

              if (OFastConcurrentModificationException.enabled())

                throw OFastConcurrentModificationException.instance();

              else

                throw new OConcurrentModificationException(rid, ppos.recordVersion, version, ORecordOperation.DELETED);

            makeStorageDirty();

            atomicOperationsManager.startAtomicOperation();

            try {

              final ORecordSerializationContext context = ORecordSerializationContext.getContext();

              if (context != null)

                context.executeOperations(this);

              cluster.deleteRecord(ppos.clusterPosition);

              atomicOperationsManager.endAtomicOperation(false);

            } catch (Throwable e) {

              atomicOperationsManager.endAtomicOperation(true);

              OLogManager.instance().error(this, "Error on deleting record " + rid + "( cluster: " + cluster + ")", e);

              return new OStorageOperationResult<Boolean>(false);

            }

            return new OStorageOperationResult<Boolean>(true);

          } finally {

            lockManager.releaseLock(recordLock);

          }

        } finally {

          lock.releaseSharedLock();

        }

      } catch (IOException e) {

        OLogManager.instance().error(this, "Error on deleting record " + rid + "( cluster: " + cluster + ")", e);

      } finally {

        modificationLock.releaseModificationLock();

      }

    } finally {

      cluster.getExternalModificationLock().releaseModificationLock();

      Orient.instance().getProfiler()

          .stopChrono(PROFILER_DELETE_RECORD, "Delete a record from database", timer, "db.*.deleteRecord");

    }

    return new OStorageOperationResult<Boolean>(false);

  }

  @Override

  public OStorageOperationResult<Boolean> hideRecord(final ORecordId rid, final int mode, ORecordCallback<Boolean> callback) {