Deletes a key from a column family.

@param cfName
@param key
@throws RocksDBException
519624
public void delete(String cfName, String key) throws RocksDbException {
        delete(cfName, writeOptions, key);
    }
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
1167552
public void put(String key, String value) throws RocksDbException {
        put(DEFAULT_COLUMN_FAMILY, key, value);
    }
1124516
public String getProperty(String cfName, String name) throws RocksDbException {
        ColumnFamilyHandle cfh = getColumnFamilyHandle(cfName);
        if (cfh == null) {
            throw new RocksDbException.ColumnFamilyNotExists(cfName);
        }
        try {
            return rocksDb.getProperty(cfh, name);
        } catch (Exception e) {
            throw e instanceof RocksDbException ? (RocksDbException) e : new RocksDbException(e);
        }
    }
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();
  }
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;
                }
            });
    }
199529
def remove(self, key):
        '''
        
        '''
        encodedKey = json.dumps(key)
        sql = 'DELETE FROM ' + self.table + ' WHERE name = %s'
        with self.connect() as conn:
            with doTransaction(conn):
                return executeSQL(conn, sql, args=[encodedKey])
414375
protected void delete(ColumnFamilyHandle cfh, WriteOptions writeOptions, byte[] key)
            throws RocksDbException {
        if (readOnly) {
            throw new RocksDbException.ReadOnlyException("delete");
        }
        if (cfh == null) {
            throw new RocksDbException.ColumnFamilyNotExists();
        }
        try {
            rocksDb.delete(cfh, writeOptions != null ? writeOptions : this.writeOptions, key);
        } catch (Exception e) {
            throw e instanceof RocksDbException ? (RocksDbException) e : new RocksDbException(e);
        }
    }
1249337
@Override
    public void deleteStoreIfPresent(String storeName) {
        DBConn dbConn = getDBConnection();
        try {
            synchronized (m_schemaLock) {
                if (m_schemaMgr.columnFamilyExists(dbConn, m_keyspace, storeName)) {
                    m_schemaMgr.deleteColumnFamily(dbConn, storeName);
                }
            }
        } finally {
            returnDBConnection(dbConn);
        }
    }
198761
public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }
166738
public static void delete( Key key ) { 
    Value val = DKV.get(key);
    if( val==null ) return;
    ((Lockable)val.get()).delete();
  }
442609
public static function deleteColumn(string $tableName, string $column)
    {
        if(Schema::hasTable($tableName)) {
            Schema::table(
                $tableName, function ($table) use ($tableName, $column) {
                    if(Schema::hasColumn($tableName, $column)) {
                        $table->dropColumn($column);
                    }
                }
            );
        }
    }
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);
		}
	}
1157627
public void deleteColumn(Mutator<K> mutator, K key, N columnName) {
    mutator.addDeletion(key, columnFamily, columnName, topSerializer);
    executeIfNotBatched(mutator);
  }
236478
def delete(self, key):
        """"""
        assert key, "A key must be supplied for delete operations"
        self._collection.remove(spec_or_id={'_id': key})
        LOG.debug("DB REMOVE: %s.%s", self.collection_name, key)
737251
public void remove(Object key) {
		for (Scope cur=this; cur!=null; cur=cur.parent) {
			if (cur.data != null && cur.data.containsKey(key)) {
				cur.data.remove(key);
				return ;
			}
		}
	}
793144
private static void deleteRange(
		RocksDB db,
		List<ColumnFamilyHandle> columnFamilyHandles,
		byte[] beginKeyBytes,
		byte[] endKeyBytes) throws RocksDBException {

		for (ColumnFamilyHandle columnFamilyHandle : columnFamilyHandles) {
			try (RocksIteratorWrapper iteratorWrapper = RocksDBOperationUtils.getRocksIterator(db, columnFamilyHandle);
				RocksDBWriteBatchWrapper writeBatchWrapper = new RocksDBWriteBatchWrapper(db)) {

				iteratorWrapper.seek(beginKeyBytes);

				while (iteratorWrapper.isValid()) {
					final byte[] currentKey = iteratorWrapper.key();
					if (beforeThePrefixBytes(currentKey, endKeyBytes)) {
						writeBatchWrapper.remove(columnFamilyHandle, currentKey);
					} else {
						break;
					}
					iteratorWrapper.next();
				}
			}
		}
	}