// Delete removes key-value items stored under <key> from datastore.
424825
func (pdb *protoBroker) Delete(key string, opts ...datasync.DelOption) (existed bool, err error) {
	return pdb.broker.Delete(key, opts...)
}
1173943
func (m *dirsMap) Delete(key string) {
	m.data.Delete(m.normalizeKey(key))
}
330977
func (m *dbConn) Delete(key driver.Value) (int, error) {
	txn := m.db.Txn(true)
	err := txn.Delete(m.md.tbl.Name, key)
	if err != nil {
		txn.Abort()
		u.Warnf("could not delete: %v  err=%v", key, err)
		return 0, err
	}
	txn.Commit()
	return 1, nil
}
741436
func (c *MemoryStore) Delete(key string) error {
	c.cache.Delete(key)
	return nil
}
1083573
func (f *Facade) delete(ctx datastore.Context, ds datastore.EntityStore, key datastore.Key, be beforeEvent, ae afterEvent) error {
	glog.V(2).Infof("Facade.delete: %s:%s", key.Kind(), key.ID())
	ec := newEventCtx()
	err := f.beforeEvent(be, ec, key.ID())
	if err == nil {
		err = ds.Delete(ctx, key)
	}
	defer f.afterEvent(ae, ec, key.ID(), err)
	return err
}
1055372
func (r *MemoryNoTS) Delete(key string) error {
	delete(r.items, key)
	return nil
}
1015573
func (f *FileStore) Delete(keys [][]byte) error {
	return f.DeleteRange(keys, math.MinInt64, math.MaxInt64)
}
756829
func (db *NodeSet) Delete(key []byte) error {
	db.lock.Lock()
	defer db.lock.Unlock()

	delete(db.nodes, string(key))
	return nil
}
76891
func (d *MutexDatastore) Delete(key ds.Key) (err error) {
	d.Lock()
	defer d.Unlock()
	return d.child.Delete(key)
}
1048788
func (s Storage) Delete(bucket, key string, nested ...string) Storage {
	return s.execute(bucket, key, nil, nested, remove)
}
880190
func (c *Client) Delete(key string, opts ...datasync.DelOption) (existed bool, err error) {
	consulLogger.Debugf("Delete: %q", key)
	if _, err := c.client.KV().Delete(transformKey(key), nil); err != nil {
		return false, err
	}

	return true, nil
}
258252
func (s *RedisDeviceStore) Delete(appEUI types.AppEUI, devEUI types.DevEUI) error {
	key := s.key(appEUI, devEUI)

	deviceI, err := s.store.GetFields(key, "dev_addr")
	if err != nil {
		return err
	}

	device, ok := deviceI.(Device)
	if !ok {
		errors.New("Database did not return a Device")
	}

	if !device.DevAddr.IsEmpty() {
		if err := s.devAddrIndex.Remove(device.DevAddr.String(), key); err != nil {
			return err
		}
	}

	return s.store.Delete(key)
}
355006
func (d *Datastore) Delete(k ds.Key) error {
	d.buffer[k] = op{delete: true}
	if len(d.buffer) > d.maxBufferEntries {
		return d.Flush()
	}
	return nil
}
734056
func (db *Database) Delete(sid string, key string) (deleted bool) {
	txn := db.Service.NewTransaction(true)
	err := txn.Delete(makeKey(sid, key))
	if err != nil {
		return
	}
	txn.Commit(nil)
	return err == nil
}
574660
func (s *redisStorage) Delete(key string) error {
	cmd := s.c.Del(key)
	return cmd.Err()
}
273381
func (db *BytesConnectionEtcd) Delete(key string, opts ...datasync.DelOption) (existed bool, err error) {
	return deleteInternal(db.Logger, db.etcdClient, db.opTimeout, key, opts...)
}
587516
func (m *MemStore) Delete(key string, recurse bool) error {
	if !recurse {
		delete(m.store, key)
		return nil
	}
	for k := range m.store {
		if key == k || strings.HasPrefix(k, key) {
			delete(m.store, k)
		}
	}
	return nil
}