Add an update that will delete the row with the given row key from the given store.

@param storeName Name of store from which to delete an object row.
@param rowKey    Row key in string form.
162478
public void deleteRow(String storeName, String rowKey) {
        m_rowDeletes.add(new RowDelete(storeName, rowKey));
    }
864965
public function deleteEntity($paritionKey, $rowKey)
    {
        $this->_proxy->deleteEntity(
            $this->_name,
            $paritionKey,
            $rowKey
        );
    }
163757
def delete(key)
      deleted = @store.delete(key)
      @on_write_failure.call(key) if !deleted && @on_write_failure
      RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
      deleted
    end
85540
public synchronized void removeUpdatesForQueue( String queueName )
    {
    	Iterator<TransactionItem> entries = items.iterator();
    	while (entries.hasNext())
		{
    		TransactionItem item = entries.next();
    		if (item.getDestination().getName().equals(queueName))
    		    entries.remove();
		}
    }
504748
def delete(self, key):
    '''
    '''
    self.logger.info('%s: delete %s' % (self, key))
    super(LoggingDatastore, self).delete(key)
911450
public function delete($storageName, $key)
    {
        if (!isset($this->data[$storageName])) {
            return;
        }

        if (!isset($this->data[$storageName][serialize($key)])) {
            return;
        }

        unset($this->data[$storageName][serialize($key)]);
    }
75302
public void deleteSpace(String spaceID, String storeID) throws ResourceException {
        try {
            StorageProvider storage = storageProviderFactory.getStorageProvider(storeID);
            storage.deleteSpace(spaceID);
        } catch (NotFoundException e) {
            throw new ResourceNotFoundException("delete space", spaceID, e);
        } catch (Exception e) {
            storageProviderFactory.expireStorageProvider(storeID);
            throw new ResourceException("delete space", spaceID, e);
        }
    }
343690
public void addColumn(String storeName, String rowKey, String columnName) {
        addColumn(storeName, rowKey, columnName, EMPTY);
    }
281582
public void delete(final K key) throws DataAccessException {
        jdbcTemplate.execute(new ConnectionCallback<Object>() {
            @Override
            public Object doInConnection(Connection connection) throws SQLException, DataAccessException {
                crud.delete(connection, key);
                return null;
            }
        });
    }
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
                }
            }
        }
    }
689212
def delete(self, key, **opts):
        """"""
        key, store = self._expand_opts(key, opts)
        try:
            del store[key]
        except KeyError:
            pass
662561
public void deleteByKey(DatastoreKey key) {
    try {
      nativeWriter.delete(key.nativeKey());
    } catch (DatastoreException exp) {
      throw DatastoreUtils.wrap(exp);
    }
  }
238830
public void deleteRow(Mutator<K> mutator, K key) {    
    mutator.addDeletion(key, columnFamily, null, topSerializer);
    executeIfNotBatched(mutator);
  }
408223
public static function delete(&$storage, $key)
    {
        if($key == null)
        {
            $storage = array();
            return;
        }

        $keys	= explode('.', $key);

        foreach($keys as $no=>$key)
        {
            if($no == 0) continue;

            $key	= array_shift($keys);

            $storage =& $storage[$key];
        }

        unset($storage[array_shift($keys)]);
    }
538555
public void deleteKey(String key) throws IOException {
        Path keyDir = getKeyDir(key);
        HdfsBlobStoreFile pf = new HdfsBlobStoreFile(keyDir, BLOBSTORE_DATA,
                _hadoopConf);
        pf.delete();
        delete(keyDir);
    }
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);
        }
    }
538799
public static void deleteKey(String keyName) throws RegistryException {
        checkError(invoke(Methods.REG_DELETE_KEY.get(), keyParts(keyName)));
    }