Delete key from the version store (records cached in the Record Store belonging to this key will become unreachable)
163757
def delete(key)
      deleted = @store.delete(key)
      @on_write_failure.call(key) if !deleted && @on_write_failure
      RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
      deleted
    end
1260418
def delete(key)
      @cache.delete(key)
      File.delete(path_to(hash(key))) if disk_cache_enabled?
    end
1282941
def delete(self, key):
    '''
    '''
    key = self._service_key(key)
    self._service_ops['delete'](key)
31967
function expire() {
  var dbs = this._store.databases, i;
  for(i in dbs) {
    dbs[i].delExpiredKeys();
  }
}
1219100
function clearStore(_options) {
    const store = this;
    const state = store.state;
    entityRecords = {}, entityRefs = {}, weakParts = [];
    entityNames.forEach((name) => {
      entityRefs[name] = {};
      entityRecords[name] = state[_entityName2StoreKey[name]];
    });

    options = _options && typeof _options === 'object' ? _options : {};
    if (typeof options.truncate === 'number' && options.truncate >= 0) options.truncate = ~~options.truncate;
    else options.truncate = -1;

    if (beforeClear && typeof beforeClear === 'function') {
      const customRefs = beforeClear.call(store, state);
      if (customRefs && customRefs.length > 0) {
        customRefs.forEach((ref) => {
          const refs = entityRefs[ref.entity];
          if (!refs) return;
          refs[ref.id] = true;
        });
      }
    }

    // first run: calc non-weak and non-chain position
    _calcRef(state, structure);

    // second run: calc weak parts
    weakParts.forEach((part) => {
      let refs = entityRefs[part.entity],
        partState = part.state,
        partStruct = part.structure;
      Object.keys(part.state).forEach((id) => {
        if (!refs[id]) return;
        _calcRefForValue(partState[id], partStruct);
      });
    });

    // last run: calc ref in entity structure(for the chain ref)
    entityNameLastRefCount = {};
    Object.keys(_entityNameChain).forEach((entityName) => {
      _calcEntityOwnStructure(entityName);
    });

    // remove entities which not referenced
    const newState = Object.assign({}, state);
    entityNames.forEach((entityName) => {
      const storeKey = _entityName2StoreKey[entityName];
      let entities = newState[storeKey],
        refs = entityRefs[entityName];
      Object.keys(entities).forEach((id) => {
        if (!refs[id]) delete entities[id];
      });
    });

    options = null, entityRecords = null, entityRefs = null, weakParts = null, entityNameLastRefCount = null;
    store.setState(newState);
  }
1118081
def delete(key)
      if exists?(key)
        value = value(key)
        data(key).delete
      end
      value
    end
1080435
def clear(self, key):
        # type: (Hashable) -> DataLoader
        
        cache_key = self.get_cache_key(key)
        self._promise_cache.pop(cache_key, None)
        return self
5202
def delete_item(key):
    """"""
    CACHED_KEY_FILE = os.path.join(CURRENT_DIR, key)

    if os.path.isfile(CACHED_KEY_FILE):
        os.remove(CACHED_KEY_FILE)
1844
def delete(key, parameters = {})
      @stores.map {|s| s.delete(key, parameters)}.any?
    end
911588
def deleteFromStore(self):
        
        if (self.limit is None and
            not isinstance(self.sort, attributes.UnspecifiedOrdering)):
            # The ORDER BY is pointless here, and SQLite complains about it.
            return self.cloneQuery(sort=None).deleteFromStore()

        #We can do this the fast way or the slow way.

        # If there's a 'deleted' callback on the Item type or 'deleteFromStore'
        # is overridden, we have to do it the slow way.
        deletedOverridden = (
            self.tableClass.deleted.im_func is not item.Item.deleted.im_func)
        deleteFromStoreOverridden = (
            self.tableClass.deleteFromStore.im_func is not
            item.Item.deleteFromStore.im_func)

        if deletedOverridden or deleteFromStoreOverridden:
            for it in self:
                it.deleteFromStore()
        else:

            # Find other item types whose instances need to be deleted
            # when items of the type in this query are deleted, and
            # remove them from the store.
            def itemsToDelete(attr):
                return attr.oneOf(self.getColumn("storeID"))

            if not item.allowDeletion(self.store, self.tableClass, itemsToDelete):
                raise errors.DeletionDisallowed(
                    'Cannot delete item; '
                    'has referents with whenDeleted == reference.DISALLOW')

            for it in item.dependentItems(self.store,
                                          self.tableClass, itemsToDelete):
                it.deleteFromStore()

            # actually run the DELETE for the items in this query.
            self._runQuery('DELETE', "")
1187306
def delete(self, *args, **kwargs):
        """"""
        cache_key = self.make_key(args, kwargs)
        with self._cache_lock:
            try:
                del self._cache[cache_key]
            except KeyError:
                pass
351322
def delete(cls, object_version, key=None):
        
        with db.session.begin_nested():
            q = cls.query.filter_by(
                version_id=as_object_version_id(object_version))
            if key:
                q = q.filter_by(key=key)
            q.delete()
967758
function(key)
  {
    var db = this;
    var model = db.all[ key ];

    if ( db.cache === Cache.All )
    {
      return db.destroyLocalCachedModel( model, key );
    }
    else
    {
      return db.destroyLocalUncachedModel( model, key );
    }
  }
1053463
@Override
    public void clean(int numberToClean) {
        logger.info("Attempting to delete the last {} records for key {}", numberToClean, key);
        VersionedKey currentVersionedKey = loadKeyFromCouchbase();
        long start = 0;
        if (numberToClean != -1)
            start = currentVersionedKey.getVersion() - numberToClean;
        for (long i = start; i < currentVersionedKey.getVersion(); i++) {
            delete(currentVersionedKey.withVersion(i)
                                      .toJson());
        }
        logger.info("Finished deleting the last {} records for key {}", numberToClean, key);
    }
117291
def _delete_forever_values(self, forever_key):
        
        forever = self._store.connection().lrange(forever_key, 0, -1)

        if len(forever) > 0:
            self._store.connection().delete(*forever)
345944
def delete(self, *raw_args, **raw_kwargs):
        
        args = self.prepare_args(*raw_args)
        kwargs = self.prepare_kwargs(**raw_kwargs)
        key = self.key(*args, **kwargs)
        item = self.cache.get(key)
        if item is not None:
            self.cache.delete(key)
224660
def del_key(self, ref):
        
        if ref not in self.keys:
            response = self.request("client_del_key %s" % (ref))
            self.keys.remove(ref)
            if "success" in response:
                return None
            else:
                return response