Deletes a key from a column family, specifying write options.

@param cfName
@param writeOptions
@param key
@throws RocksDBException
778548
public void delete(String cfName, WriteOptions writeOptions, String key)
            throws RocksDbException {
        if (cfName == null) {
            cfName = DEFAULT_COLUMN_FAMILY;
        }
        try {
            delete(getColumnFamilyHandle(cfName), writeOptions,
                    key.getBytes(StandardCharsets.UTF_8));
        } catch (RocksDbException.ColumnFamilyNotExists e) {
            throw new RocksDbException.ColumnFamilyNotExists(cfName);
        }
    }
19162
public void writeLock(EntityKey key, int timeout) {
		ReadWriteLock lock = getLock( key );
		Lock writeLock = lock.writeLock();
		acquireLock( key, timeout, writeLock );
	}
295809
protected void doDelete(String spaceId, String key) throws IOException {
        Term termDelete = buildIdTerm(spaceId, key);
        IndexWriter indexWriter = getIndexWriter();
        indexWriter.deleteDocuments(termDelete);
        if (!isAsyncWrite()) {
            indexWriter.commit();
        } else if (getIndexManager().getBackgroundCommitIndexPeriodMs() <= 0) {
            LOGGER.warn("Async-write is enable, autoCommitPeriodMs must be larger than 0!");
        }
    }
1234154
public int deleteByTableName(String tableName) throws SQLException {
		DeleteBuilder<FeatureTileLink, FeatureTileLinkKey> db = deleteBuilder();

		db.where().eq(FeatureTileLink.COLUMN_FEATURE_TABLE_NAME, tableName)
				.or().eq(FeatureTileLink.COLUMN_TILE_TABLE_NAME, tableName);

		PreparedDelete<FeatureTileLink> deleteQuery = db.prepare();
		int deleted = delete(deleteQuery);
		return deleted;
	}
1028927
public void delete(final Collection<K> keys) throws SQLException {
        transactionTemplate
            .doInTransaction(new SQLFunction<Connection, Object>() {
                @Override
                public Object apply(Connection connection) throws SQLException {
                    delegate.delete(connection, keys);
                    return null;
                }
            });
    }
1139929
public void doRemove(FieldTable table, KeyAreaInfo keyArea, BaseBuffer buffer) throws DBException
    {
        super.doRemove(table, keyArea, buffer);
    }
932456
public boolean unsetOption(String key) {
		// we do have null values --> check for key
		boolean b = options.containsKey(key);
		options.remove(key);
		return b;
	}
375510
public void put(String cfName, String key, String value) throws RocksDbException {
        put(cfName, key, value != null ? value.getBytes(StandardCharsets.UTF_8) : null);
    }
639525
@Override
	public void clear() {
		try {
			backend.db.delete(columnFamily, writeOptions, serializeCurrentKeyWithGroupAndNamespace());
		} catch (RocksDBException e) {
			throw new FlinkRuntimeException("Error while removing entry from RocksDB", e);
		}
	}
707240
@Override
  public void deleteRow(K key) {
    createMutator().delete(key, getColumnFamily(), null, null);
  }
1111278
public void delete(String columnName, String... keys) {
    Mutator<String> m = createMutator(keyspace, serializer);
    for (String key: keys) {
      m.addDeletion(key, columnFamilyName,  columnName, serializer);
    }
    m.execute();
  }
284827
public CompletableFuture<Void> removeEntry(String tableName, String key) {
        log.trace("remove entry called for : {} key : {}", tableName, key);

        List<TableKey<byte[]>> keys = Collections.singletonList(new TableKeyImpl<>(key.getBytes(Charsets.UTF_8), null));
        return expectingDataNotFound(withRetries(() -> segmentHelper.removeTableKeys(
                tableName, keys, authToken.get(), RequestTag.NON_EXISTENT_ID), 
                () -> String.format("remove entry: key: %s table: %s", key, tableName)), null)
                .thenAcceptAsync(v -> log.trace("entry for key {} removed from table {}", key, tableName), executor);
    }
482312
public void delete(HTableInterface hTable, Object rowKey, String columnFamily)
    {
        try
        {
            byte[] rowBytes = HBaseUtils.getBytes(rowKey);
            Delete delete = new Delete(rowBytes);
            byte[] family = HBaseUtils.getBytes(columnFamily);
            delete.deleteFamily(family);
            hTable.delete(delete);
        }
        catch (IOException e)
        {
            log.error("Error while delete on hbase for : " + rowKey);
            throw new PersistenceException(e);
        }
    }
1248178
public byte[] get(String cfName, String key) throws RocksDbException {
        return get(cfName, readOptions, key);
    }
1202070
void deleteRow(String storeName, Map<String, AttributeValue> key) {
        String tableName = storeToTableName(storeName);
        m_logger.debug("Deleting row from table {}, key={}", tableName, DynamoDBService.getDDBKey(key));
        
        Timer timer = new Timer();
        boolean bSuccess = false;
        for (int attempts = 1; !bSuccess; attempts++) {
            try {
                m_ddbClient.deleteItem(tableName, key);
                if (attempts > 1) {
                    m_logger.info("deleteRow() succeeded on attempt #{}", attempts);
                }
                bSuccess = true;
                m_logger.debug("Time to delete table {}, key={}: {}",
                               new Object[]{tableName, DynamoDBService.getDDBKey(key), timer.toString()});
            } catch (ProvisionedThroughputExceededException e) {
                if (attempts >= m_max_commit_attempts) {
                    String errMsg = "All retries exceeded; abandoning deleteRow() for table: " + tableName;
                    m_logger.error(errMsg, e);
                    throw new RuntimeException(errMsg, e);
                }
                m_logger.warn("deleteRow() attempt #{} failed: {}", attempts, e);
                try {
                    Thread.sleep(attempts * m_retry_wait_millis);
                } catch (InterruptedException ex2) {
                    // ignore
                }
            }
        }
    }
1202867
@Override
	public CPSpecificationOption removeByG_K(long groupId, String key)
		throws NoSuchCPSpecificationOptionException {
		CPSpecificationOption cpSpecificationOption = findByG_K(groupId, key);

		return remove(cpSpecificationOption);
	}
905663
function del($key)
    {
        parent::del($key);


        $realm = $this->getRealm();

        try {

            $sql = "DELETE FROM `KVStore` WHERE `realm` = '$realm' and `key` = '$key';";
            $this->pdo->exec($sql);

        } catch (\Exception $e) {
            throw new exWriteError($e->getMessage(), $e->getCode(), $e);
        }
    }