Deletes the record without checking the version.
481844
public ODatabaseRecord delete(final ORecordInternal<?> iRecord) {
    executeDeleteRecord(iRecord, -1, true, true, OPERATION_MODE.SYNCHRONOUS);
    return this;
  }
1103686
def _delete_dynamic_versions(self):
        
        if self.dynamic_version_of:
            raise ImplementationError(u'"_delete_dynamic_versions" can only be '
                                      u'executed on the base field')
        inventory = self._inventory
        for dynamic_part in inventory.smembers():
            name = self.get_name_for(dynamic_part)
            # create the field
            new_field = self._create_dynamic_version()
            new_field.name = name
            new_field._dynamic_part = dynamic_part  # avoid useless computation
            new_field._attach_to_model(self._model)
            new_field._attach_to_instance(self._instance)
            # and delete its content
            new_field.delete()

        inventory.delete()
1086117
def _clean_record(self, record):
        """"""
        for k, v in dict(record).items():
            if isinstance(v, dict):
                v = self._clean_record(v)
            if v is None:
                record.pop(k)
        return record
738389
public function actionRemovePageVersion()
    {
        $pageId = Yii::$app->request->getBodyParam('pageId');
        
        $page = NavItemPage::findOne((int) $pageId);
        
        if ($page) {
            $page->forceNavItem->updateTimestamp();
            return $page->delete();
        }
        
        return false;
    }
1135624
protected String stripVersionFromName(String name, String version) {
        int versionBeginIndex = name.lastIndexOf("-" + version);
        if ( versionBeginIndex != -1) {
            return name.substring(0, versionBeginIndex) + name.substring(versionBeginIndex + version.length() + 1);
        } else {
            return name;
        }
    }
657152
public boolean remove()
    {
        boolean bSuccess = false;
        try   {
            Record recGrid = this.getMainRecord();
            if (recGrid.getEditMode() == Constants.EDIT_CURRENT)
                recGrid.edit();
            if (recGrid.getEditMode() == Constants.EDIT_IN_PROGRESS)
                recGrid.remove();
            bSuccess = true;
        } catch (DBException ex)  {
            ex.printStackTrace();
            bSuccess = false;
        }
        return bSuccess;
    }
1292535
function skip() {
    rimraf(file, function() {})
    delete f.versions[v]
    if (f._attachments)
      delete f._attachments[file]
    need.splice(need.indexOf(v), 1)
    maybeDone(null)
  }
1195459
def delete(self, for_update=False):
        
        hash_key = self.get_hash_id()
        try:
            original_instance = self.load(hash_key, convert_key=False)
        except KeyError:
            return

        # Remove from the `all` index.
        all_index = self._query.all_index()
        all_index.remove(hash_key)

        # Remove from the secondary indexes.
        for field in self._indexes:
            for index in field.get_indexes():
                index.remove(original_instance)

        if not for_update:
            for field in self._fields.values():
                if isinstance(field, _ContainerField):
                    field._delete(self)

        # Remove the object itself.
        self.__database__.delete(hash_key)
466973
def delete(self):
        
        return self.bucket.delete_key(self.name, version_id=self.version_id)
498176
def delete(self):
        
        assert self.query.can_filter(), "Cannot use 'limit' or 'offset' with delete."

        del_query = self._clone()

        # Disable non-supported fields.
        del_query.query.clear_ordering()

        return del_query.query.delete()
83309
public function delete()
    {
        $this->getLogger()->info('Deleting Player Version version ID ' . $this->versionId);
        $this->doDelete('/playersoftware/' . $this->versionId);

        return true;
    }
557642
private void deleteVersion(final Future<Void> aFuture) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(MessageCodes.PT_DEBUG_006, myPath);
        }

        myFileSystem.delete(getVersionFilePath(), result -> {
            if (result.succeeded()) {
                if (hasPrefix()) {
                    deletePrefix(aFuture);
                } else {
                    aFuture.complete();
                }
            } else {
                aFuture.fail(result.cause());
            }
        });
    }
1292423
def delete_record(self, record):
        
        self.children.remove(record.resource)
        record.delete()
56705
protected static function _removeTempVersionNumberFromDatabase()
    {
        $oConfig = self::_getConfig();
        $sModuleId = self::_getDatabase()->quote(self::TMP_DB_ID);
        $sQuotedShopId = self::_getDatabase()->quote($oConfig->getShopId());

        $sDeleteSql = "DELETE
                FROM `oxconfig`
                WHERE oxmodule = {$sModuleId}
                  AND oxshopid = {$sQuotedShopId}";

        self::_getDatabase()->execute($sDeleteSql);
    }
316573
def delete(self, callback=None, errback=None):
        
        if not self.data:
            raise RecordException('record not loaded')

        def success(result, *args):
            if callback:
                return callback(result)
            else:
                return result

        return self._rest.delete(self.parentZone.zone,
                                 self.domain, self.type,
                                 callback=success, errback=errback)
333949
function _stripOldVersionInfo(versionInfo, buildNumber) {
        // Do a simple linear search. Since we are going in reverse-chronological order, we
        // should get through the search quickly.
        var lastIndex = 0;
        var len = versionInfo.length;
        var versionEntry;
        var validBuildEntries;

        while (lastIndex < len) {
            versionEntry = versionInfo[lastIndex];
            if (versionEntry.buildNumber <= buildNumber) {
                break;
            }
            lastIndex++;
        }

        if (lastIndex > 0) {
            // Filter recent update entries based on applicability to current platform
            validBuildEntries = versionInfo.slice(0, lastIndex).filter(_checkBuildApplicability);
        }

        return validBuildEntries;
    }
1248609
def delete(self):
        
        assert self.query.can_filter(), \
            "Cannot use 'limit' or 'offset' with delete."

        # Ensure that only current objects are selected.
        del_query = self.filter(version_end_date__isnull=True)

        # The delete is actually 2 queries - one to find related objects,
        # and one to delete. Make sure that the discovery of related
        # objects is performed on the same database as the deletion.
        del_query._for_write = True

        # Disable non-supported fields.
        del_query.query.select_for_update = False
        del_query.query.select_related = False
        del_query.query.clear_ordering(force_empty=True)

        collector_class = get_versioned_delete_collector_class()
        collector = collector_class(using=del_query.db)
        collector.collect(del_query)
        collector.delete(get_utc_now())

        # Clear the result cache, in case this QuerySet gets reused.
        self._result_cache = None