Delete this record (Always called from the record class).
Always override this method.
@exception DBException File exception.
558286
public void remove() throws DBException
    {
        super.remove();
        Iterator<BaseTable> iterator = this.getTables();
        while (iterator.hasNext())
        {
            BaseTable table = iterator.next();
            if ((table != null) && (table != this.getNextTable()))
            {
                if ((table.getRecord().getEditMode() == Constants.EDIT_IN_PROGRESS) || (table.getRecord().getEditMode() == Constants.EDIT_CURRENT))
                    table.remove();
            }
        }
    }
951201
public boolean onDelete()
    {
        Record record = this.getMainRecord();
        if (record == null)
            return false;

        if (record.getEditMode() == Constants.EDIT_NONE)
            return true;
        if (record.getEditMode() == Constants.EDIT_ADD)
        {   // If they're adding, can't delete nothing!
            this.onRefresh();
            return true;
        }
        try {
            if (record.getEditMode() != Constants.EDIT_IN_PROGRESS)
                record.edit();
            record.remove();
            record.addNew();
            this.clearStatusText();
        } catch(DBException ex) {
            this.displayError(ex);
            return false;
        }
        return true;
    }
1155176
public void delete() throws IOException {
        close();
        if (osFile != null) {
            boolean deleted = osFile.delete();
            while (!deleted) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    logger.error("{} not deleted.", osFile);
                }
                System.gc();
                deleted = osFile.delete();
            }
        }
    }
1097092
@UpdateHandler(name = "delete_record", file = "RegisteredServiceDocument_delete.js")
    public void deleteRecord(final RegisteredServiceDocument record) {
        db.callUpdateHandler(stdDesignDocumentId, "delete_record", record.getId(), null);
    }
588455
public synchronized void set(FieldTable table) throws DBException
    {
        BaseBuffer bufferNew = (BaseBuffer)table.getDataSource(); // same as .getHandle(Constants.DATA_SOURCE_HANDLE);
        if (table.getRecord().getEditMode() == Constants.EDIT_IN_PROGRESS)
        {
            PKeyArea vKeyArea = this.getPKeyArea(Constants.MAIN_KEY_AREA);
            KeyAreaInfo primaryKeyArea = table.getRecord().getKeyArea(Constants.MAIN_KEY_AREA);
            primaryKeyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);     // Move these keys back to the record
            BaseBuffer bufferOld = vKeyArea.doSeek("==", table, primaryKeyArea);    // Get the old record back
            if ((bufferOld == null) || (bufferOld.getPhysicalData() == null))
                throw new DBException(Constants.INVALID_RECORD);    // This record had been freed (deleted)

            for (int iKeyArea = Constants.MAIN_KEY_AREA; iKeyArea < table.getRecord().getKeyAreaCount() + Constants.MAIN_KEY_AREA; iKeyArea++)
            {
                try   {
                    vKeyArea = this.getPKeyArea(iKeyArea);
                    KeyAreaInfo keyArea = table.getRecord().getKeyArea(iKeyArea);
                    keyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);        // Move these keys back to the record
                    if (keyArea.getUniqueKeyCode() != Constants.UNIQUE)   // The main key is part of the comparison
                        primaryKeyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);     // Move these keys back to the record
                    vKeyArea.doRemove(table, table.getRecord().getKeyArea(iKeyArea), bufferOld);
                    bufferNew.bufferToFields(table.getRecord(), Constants.DONT_DISPLAY, Constants.READ_MOVE);
                    vKeyArea.doWrite(table, table.getRecord().getKeyArea(iKeyArea), bufferNew);
                } catch (DBException e)   {
                    if (e.getErrorCode() == Constants.DUPLICATE_KEY)
                    {
                        bufferOld.bufferToFields(table.getRecord(), Constants.DONT_DISPLAY, Constants.READ_MOVE);
                        this.getPKeyArea(iKeyArea).doWrite(table, table.getRecord().getKeyArea(iKeyArea), bufferOld);
                        iKeyArea--;     // Duplicate key, back out all keys added so far!!!
                        while (iKeyArea >= Constants.MAIN_KEY_AREA)
                        {
                            vKeyArea = this.getPKeyArea(iKeyArea);
                            KeyAreaInfo keyArea = table.getRecord().getKeyArea(iKeyArea);
                            bufferNew.bufferToFields(table.getRecord(), Constants.DONT_DISPLAY, Constants.READ_MOVE);
                            vKeyArea.doRemove(table, table.getRecord().getKeyArea(iKeyArea), bufferNew);
                            keyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);        // Move these keys back to the record
                            if (keyArea.getUniqueKeyCode() != Constants.UNIQUE)   // The main key is part of the comparison
                                primaryKeyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);     // Move these keys back to the record
                            vKeyArea.doWrite(table, table.getRecord().getKeyArea(iKeyArea), bufferOld);
                            iKeyArea--;
                        }
                    }
                    throw e;
                }
            }
            if (bufferNew != bufferOld)
                bufferOld.free();   // Get rid of the old one
            bufferOld = null;
            // Restore the record before returing (key.doWrite probably changed it).
            bufferNew.bufferToFields(table.getRecord(), Constants.DONT_DISPLAY, Constants.READ_MOVE);
        }
        else
            throw new DBException(Constants.INVALID_RECORD);
    }
837263
public void remove(Object data, int iOpenMode) throws DBException, RemoteException
    {
        if (m_objCurrentKey == null)
            throw new DBException(Constants.INVALID_RECORD);
        m_mDataMap.remove(m_objCurrentKey);
        if (m_iCurrentRecord != -1)
            m_iCurrentRecord--;     // This will keep the sequential read correct.
        m_iterator = null;
    }
811849
public function delete()
    {
        $this->brokenOnDelete = true;
        $this->onBeforeDelete();
        if ($this->brokenOnDelete) {
            user_error("$this->class has a broken onBeforeDelete() function."
            . " Make sure that you call parent::onBeforeDelete().", E_USER_ERROR);
        }

        $path = $this->getFullPath();
        if (file_exists($path)) {
            unlink($path);
        }
        if ($this->storeRecord) {
            $this->storeRecord->delete();
        }

        $this->flushCache();
        $this->onAfterDelete();
    }
590552
public void doRemove() throws DBException
    {
        Object bookmark = this.getRecord().getHandle(DBConstants.BOOKMARK_HANDLE);
        String strRecordset = this.getRecord().getSQLDelete(SQLParams.USE_INSERT_UPDATE_LITERALS);
        this.executeUpdate(strRecordset, DBConstants.SQL_DELETE_TYPE);
        if (m_iRow != -1)
            m_iRow--;   // Just in case I'm in an active query this will keep requeries correct
        if (this.lockOnDBTrxType(null, DBConstants.AFTER_DELETE_TYPE, false))  // Should I do the unlock in my code?
            this.unlockIfLocked(this.getRecord(), bookmark);
    }
570481
def delete(self):
        
        self.__dmlquery__(self.__class__, self,
                          batch=self._batch,
                          timestamp=self._timestamp,
                          consistency=self.__consistency__,
                          timeout=self._timeout).delete()
1022575
public void doOpen() throws DBException
    {
        if (this.lockOnDBTrxType(null, DBConstants.AFTER_REQUERY_TYPE, false))  // AFTER_REQUERY_TYPE = Open since there is no close
            this.unlockIfLocked(this.getRecord(), null);    // Release any locks

        super.doOpen();

        m_iLastOrder = this.getRecord().getDefaultOrder();
        m_iRow = -1;
        m_iEOFRow = Integer.MAX_VALUE;
    }
1359563
def _delete(self):
        """"""
        try:
            for record in self._records:
                try:
                    self._records[record]._delete()
                except AttributeError:
                    pass
        except AttributeError:
            pass
675089
public static void delete(final @NonNull File file) throws IOException
	{
		if (file.isDirectory())
		{
			DeleteFileExtensions.deleteAllFiles(file);
		}
		else
		{
			String error = null;
			// If the file is not deleted
			if (!file.delete())
			{
				error = "Cannot delete the File " + file.getAbsolutePath() + ".";

				throw new IOException(error);

			}
		}
	}
206109
public void
removeRecord(Record r) {
	Name name = r.getName();
	int rtype = r.getRRsetType();
	synchronized (this) {
		RRset rrset = findRRset(name, rtype);
		if (rrset == null)
			return;
		if (rrset.size() == 1 && rrset.first().equals(r))
			removeRRset(name, rtype);
		else
			rrset.deleteRR(r);
	}
}
99480
public void remove(Object data, int iOpenMode) throws DBException, RemoteException
    {
        this.checkCurrentCacheIsPhysical(null);
        m_tableRemote.remove(data, iOpenMode);
        if (m_objCurrentCacheRecord != null)
        {
            if (m_mapCache != null)
                m_mapCache.set(((Integer)m_objCurrentCacheRecord).intValue(), NONE);
            else if (m_htCache != null)
                m_htCache.remove(m_objCurrentCacheRecord);
        }
        m_objCurrentPhysicalRecord = NONE;
        m_objCurrentLockedRecord = NONE;
        m_objCurrentCacheRecord = NONE;
    }
1207991
public synchronized void remove(FieldTable table) throws DBException
    {
        BaseBuffer bufferOld = (BaseBuffer)table.getDataSource(); // same as .getHandle(Constants.DATA_SOURCE_HANDLE);
        for (int iKeyArea = Constants.MAIN_KEY_AREA; iKeyArea < table.getRecord().getKeyAreaCount() + Constants.MAIN_KEY_AREA; iKeyArea++)
        {   // Delete the current key.
            KeyAreaInfo keyArea = table.getRecord().getKeyArea(iKeyArea);
            keyArea.reverseKeyBuffer(null, Constants.TEMP_KEY_AREA);
            this.getPKeyArea(iKeyArea).doRemove(table, table.getRecord().getKeyArea(iKeyArea), bufferOld);
        }
        bufferOld.free();   // Get rid of the old one
        table.setDataSource(null);  // same as .doSetHandle(null, Constants.DATA_SOURCE_HANDLE);
    }
82102
public void removeThrow() throws SQLException {
		if (last == null) {
			throw new IllegalStateException("No last " + dataClass
					+ " object to remove. Must be called after a call to next.");
		}
		if (classDao == null) {
			// we may never be able to get here since it should only be null for queryForAll methods
			throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized");
		}
		try {
			classDao.delete(last);
		} finally {
			// if we've try to delete it, clear the last marker
			last = null;
		}
	}
814599
public void delete() {
		if (tx.isReadOnly() && !isTempTable())
			throw new UnsupportedOperationException();

		if (fhp == null)
			fhp = openHeaderForModification();

		// Log that this logical operation starts
		RecordId deletedRid = currentRecordId();
		tx.recoveryMgr().logLogicalStart();

		// Delete the current record
		rp.delete(fhp.getLastDeletedSlot());
		fhp.setLastDeletedSlot(currentRecordId());

		// Log that this logical operation ends
		tx.recoveryMgr().logRecordFileDeletionEnd(ti.tableName(), deletedRid.block().number(), deletedRid.id());

		// Close the header (release the header lock)
		closeHeader();
	}