Delete the blob for the specified ID.
 @param id [Integer] ID of the object to be deleted
 @return [Boolean] True if object was deleted, false otherwise
174629
def delete_obj_by_id(id)
      if (pos = find_obj_addr_by_id(id))
        delete_obj_by_address(pos, id)
        return true
      end

      return false
    end
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
1021535
def delete(id, options={})
      request :delete, id, options
    rescue Stretcher::RequestError => e
      raise e if e.http_response.status != 404
      false
    end
462271
def delete(self, upload_id):
        

        return super(UploadsProxy, self).delete(upload_id, file_upload=True)
1193331
def id=(id)

      if !id.nil? && id.to_s.length > 255
        fail ArgumentError, "invalid value for 'id', the character length must be smaller than or equal to 255."
      end

      @id = id
    end
1028322
def delete(self, _id):
        
        mongo_response = yield self.collection.remove({"_id": ObjectId(_id)})

        raise Return(mongo_response)
1125953
def deleted_ids
      sql = <<-DR.squish
        SELECT object_id
        FROM rails_redshift_replicator_deleted_ids
        WHERE source_table = '#{replicable.source_table}'
      DR
      ActiveRecord::Base.connection.execute(sql).map{ |r| r['object_id'] }
    end
19942
def delete_event(self, id, **data):
        
        
        return self.delete("/events/{0}/".format(id), data=data)
248282
def delete_one(self, id_):
                
        url = "https://api.knackhq.com/v1/objects/%s/records/%s" % (
            self.key, id_)
        res = self.delete(url)
        return res
294956
def delete_upload_id(cls, tables: I2B2Tables, upload_id: int) -> int:
        
        return cls._delete_upload_id(tables.crc_connection, tables.observation_fact, upload_id)
627641
def delete_key(self, key_id):
        
        if int(key_id) <= 0:
            return False
        url = self._build_url('keys', str(key_id), base_url=self._api)
        return self._boolean(self._delete(url), 204, 404)
397032
public boolean removeChild(String id) {
        SharedPreferences prefs = loadSharedPreferences("children");

        List<String> objects = getChildrenList();

        if (objects.indexOf(id) == ArrayUtils.INDEX_NOT_FOUND) {
            return false;
        }

        objects.remove(id);
        prefs.edit().putString(String.valueOf(getId()), StringUtils.join(objects, ",")).commit();

        return true;
    }
382119
def delete_image(self, image_id):
        
        url = self.api_url + '/api/images/' + image_id
        response = self._request_url(url, 'delete', with_access_token=True)
        headers, result = self._parse_and_check(response)
        return Image.from_dict(result)
373420
def delete(self, doc_id: str) -> bool:
        """"""

        try:
            self.instance.delete(self.index, self.doc_type, doc_id)
        except RequestError as ex:
            logging.error(ex)
            return False
        else:
            return True
1317953
def delete(self, id):
        
        try:
            response = yield self.client.delete(id)

            if response.get("n") > 0:
                self.write({"message": "Deleted %s object: %s" % (self.object_name, id) })
                return

            self.raise_error(404, "Resource not found")

        except InvalidId as ex:
            self.raise_error(400, message="Your ID is malformed: %s" % id)
        except:
            self.raise_error()

        self.finish()
575815
def delete(self, request, id):
        
        if not id:
            # can't delete the whole container
            raise errors.MethodNotAllowed()
        try:
            models.User.objects.get(pk=id).delete()
        except models.User.DoesNotExist:
            # we never had it, so it's definitely deleted
            pass
350728
def delete_by_id(role_id, custom_headers:nil)
      response = delete_by_id_async(role_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end