Deletes the B-tree leaf record having the specified data record ID and
the previously-specified search key. This method can only be called once,
immediately after construction.

@param dataRecordId
the data record ID whose record is to be deleted
480413
public void delete(RecordId dataRecordId) {
		// search range must be a constant
		if (!searchRange.isSingleValue())
			throw new IllegalStateException();

		// delete all entry with the specific key
		while (next())
			if (getDataRecordId().equals(dataRecordId)) {
				// ccMgr.modifyLeafBlock(currentPage.currentBlk());
				delete(currentSlot);
				break;
			}

		if (!isOverflowing) {
			/*
			 * If the current regular block is empty or the key of the first
			 * record is not equal to that of records in overflow blocks,
			 * transfer one record from a overflow block to here (if any).
			 */
			if (getOverflowFlag(currentPage) != -1) {
				// get overflow page
				BlockId blk = new BlockId(currentPage.currentBlk().fileName(), getOverflowFlag(currentPage));
				ccMgr.modifyLeafBlock(blk);
				BTreePage overflowPage = new BTreePage(blk, NUM_FLAGS, schema, tx);

				SearchKey firstKey = getKey(currentPage, 0, keyType.length());
				if ((currentPage.getNumRecords() == 0
						|| (overflowPage.getNumRecords() != 0
						&& getKey(overflowPage, 0, keyType.length()) != firstKey))) {
					overflowPage.transferRecords(overflowPage.getNumRecords() - 1,
							currentPage, 0, 1);
					// if the overflow block is empty, make it a dead block
					if (overflowPage.getNumRecords() == 0) {
						long overflowFlag = (getOverflowFlag(overflowPage)
								== currentPage.currentBlk().number())
								? -1 : getOverflowFlag(overflowPage);
						setOverflowFlag(currentPage, overflowFlag);
					}
					overflowPage.close();
				}
			}
		} else {
			/*
			 * If the current overflow block is empty, make it a dead block.
			 */
			if (currentPage.getNumRecords() == 0) {
				// reset the overflow flag of original page
				BlockId blk = new BlockId(currentPage.currentBlk().fileName(), moveFrom);
				// ccMgr.modifyLeafBlock(blk);
				BTreePage prePage = new BTreePage(blk, NUM_FLAGS, schema, tx);
				long overflowFlag = (getOverflowFlag(currentPage) == prePage.currentBlk().number()) ? -1
						: getOverflowFlag(currentPage);
				setOverflowFlag(prePage, overflowFlag);
				prePage.close();
			}
		}
	}
349183
public boolean setDataRecord(DataRecord dataRecord)
    {
        this.setCurrentRecord(this.getBaseRecord());
        Object[] rgobjEnabledFields = this.getBaseRecord().setEnableFieldListeners(false);
        boolean bSuccess = super.setDataRecord(dataRecord);
        this.getBaseRecord().setEnableFieldListeners(rgobjEnabledFields);
        if (bSuccess)
        {
            Record record = this.getBaseRecord();
            record.handleValidRecord(); // Display Fields
            record = this.moveToCurrentRecord(record);
            if (record != null) if (record != this.getBaseRecord())
                record.handleValidRecord(); // Display Fields
        }
        return bSuccess;
    }
310411
protected void deleteRecord(Connection connection, String hash)
            throws SQLException {
        int id = selectRecordId(hash);
        if (id > 0) {
            String[] queries = new String[] { Query.DELETE_FILEHASHES,
                    Query.DELETE_METAS, Query.DELETE_CVES,
                    Query.DELETE_RECORD_ID };
            for (String query : queries) {
                PreparedStatement ps = setObjects(connection, query, id);
                ps.execute();
                ps.close();
            }
        }
    }
662561
public void deleteByKey(DatastoreKey key) {
    try {
      nativeWriter.delete(key.nativeKey());
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
1327980
public void delete(RecordId nextDeletedSlot) {
		Constant flag = EMPTY_CONST;
		setVal(currentPos(), flag);
		setNextDeletedSlotId(nextDeletedSlot);
	}
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);
    }
1106841
public function delete()
    {
        if ($this->bID > 0) {
            if ($this->btTable) {
                $ni = new BlockRecord($this->btTable);
                $ni->bID = $this->bID;
                $ni->Load('bID=' . $this->bID);
                $ni->delete();
            }
        }
    }
257905
public void remove() throws DBException
    {
        if ((this.getRecord().getEditMode() != Constants.EDIT_CURRENT)
            && ((this.getRecord().getEditMode() != Constants.EDIT_IN_PROGRESS)))
                throw new DBException(Constants.INVALID_RECORD);
        this.doRemove();
        this.getRecord().setEditMode(Constants.EDIT_NONE);
    }
186385
def delete_record(self, domain, recordid, params=None):
        ''' 
        '''
        params = update_params(params, {
            'domain': domain,
            'RECORDID': recordid
        })
        return self.request('/v1/dns/delete_record', params, 'POST')
315946
public void deleteNodeIndex(EntityMetadata entityMetadata, GraphDatabaseService graphDb, Node node)
    {
        if (!isNodeAutoIndexingEnabled(graphDb) && entityMetadata.isIndexable())
        {
            Index<Node> nodeIndex = graphDb.index().forNodes(entityMetadata.getIndexName());
            nodeIndex.remove(node);
        }
    }
778906
public void doValidRecord(boolean bDisplayOption) // init this field override for other value
    {
        Object bookmark = null;
        try   {
            bookmark = this.getOwner().getHandle(m_iHandleType);
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
        this.addBookmarkFilter(bookmark);
        super.doValidRecord(bDisplayOption);
    }
1313964
void setDelete(
    GBSNode      deleteNode,
    int          deleteIndex)
  {
    _deleteNode  = deleteNode;
    _deleteIndex = deleteIndex;
    _notFound = false;
  }
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);
	}
}
275080
public void moveToRecordId(RecordId rid) {
		moveTo(rid.block().number());
		rp.moveToId(rid.id());
	}
219541
public void doSet(Rec record) throws DBException
    {
        super.doSet(record);
        if (m_arrayCache != null)
            if (m_iLogicalIndex != NO_INDEX)
            {
                m_arrayCache.set(m_iLogicalIndex, this.getDataSource());    // Show the current record as deleted.
            }
    }
1308283
function deleteNode(record: RecordProxy, nodeID: DataID): void {
  const {EDGES, NODE} = RelayConnectionInterface.get();

  const edges = record.getLinkedRecords(EDGES);
  if (!edges) {
    return;
  }
  let nextEdges;
  for (let ii = 0; ii < edges.length; ii++) {
    const edge = edges[ii];
    const node = edge && edge.getLinkedRecord(NODE);
    if (node != null && node.getDataID() === nodeID) {
      if (nextEdges === undefined) {
        nextEdges = edges.slice(0, ii);
      }
    } else if (nextEdges !== undefined) {
      nextEdges.push(edge);
    }
  }
  if (nextEdges !== undefined) {
    record.setLinkedRecords(nextEdges, EDGES);
  }
}
194719
public boolean setDataRecord(DataRecord dataRecord)
    {
        m_objectID = null;
        m_dataSource = null;
    
        boolean bFound = false;
        if (dataRecord.getBuffer() == null)
        {
            this.getCurrentTable().getRecord().setEditMode(Constants.EDIT_NONE);    // Make sure read doesn't use current record.
        }
        else
        {
            m_iRecordStatus = DBConstants.RECORD_NORMAL;
            this.getCurrentTable().getRecord().setEditMode(Constants.EDIT_CURRENT);     // Data Current, not locked
            dataRecord.getBuffer().bufferToFields(this.getCurrentTable().getRecord(), DBConstants.DONT_DISPLAY, DBConstants.READ_MOVE);
            this.getCurrentTable().getRecord().handleValidRecord();   // Display Fields
            bFound = true;
            m_objectID = dataRecord.getHandle(DBConstants.OBJECT_ID_HANDLE);
            m_dataSource = dataRecord.getHandle(DBConstants.DATA_SOURCE_HANDLE);
        } 
        try   {
            if (!bFound) if (dataRecord.getHandle(DBConstants.DATA_SOURCE_HANDLE) != null)
                bFound = (this.setHandle(dataRecord.getHandle(DBConstants.DATA_SOURCE_HANDLE), DBConstants.DATA_SOURCE_HANDLE) != null);
            } catch (DBException ex)    {
                return false; // Not found
            }   
    
        try   {
            if (!bFound) if (dataRecord.getHandle(DBConstants.BOOKMARK_HANDLE) != null)
                bFound = (this.setHandle(dataRecord.getHandle(DBConstants.BOOKMARK_HANDLE), DBConstants.BOOKMARK_HANDLE) != null);
            } catch (DBException ex)    {
                return false; // Not found
            }   
    
        try   {
            if (!bFound) if (dataRecord.getHandle(DBConstants.OBJECT_ID_HANDLE) != null)
                bFound = (this.setHandle(dataRecord.getHandle(DBConstants.OBJECT_ID_HANDLE), DBConstants.OBJECT_ID_HANDLE) != null);
            } catch (DBException ex)    {
                return false; // Not found
            }
    
        return bFound;  // Return
    }