Remove all created query engines that match `name` from
        the cache (this disconnects from MongoDB, which is the point).

        :param name: Name used for :meth:`add`, or pattern
        :return: None
173130
def uncache(self, name):
        
        delme = []
        if self._is_pattern(name):
            expr = re.compile(self._pattern_to_regex(name))
            for key, obj in self._cached.items():
                if expr.match(key):
                    delme.append(key)
        else:
            if name in self._cached:
                delme.append(name)
        for key in delme:
            del self._cached[key]
1141903
def remove_block(self, name):
        

        if not self._ast or not name in self._block_map:
            raise ValueError(u"Block '{0}' does not exist"
                             .format(common.from_utf8(name)))

        block_idx = self._block_map[name]

        # remove block
        self._ast[2].pop(block_idx)
        del self._block_map[name]
732350
public void unlink(Name name) {
    DirectoryEntry entry = remove(checkNotReserved(name, "unlink"));
    entry.file().unlinked();
  }
279299
def delete(name):
    '''
    
    '''
    ret = {'name': name,
           'changes': {},
           'comment': '',
           'result': True}
    if name in __reg__:
        del __reg__[name]
    return ret
197065
def remove_context(self, name):
        
        self._context(name)
        del self.contexts[name]
        self._flush_tools()
964824
def db_remove(name, **connection_args):
    '''
    
    '''
    # check if db exists
    if not db_exists(name, **connection_args):
        log.info('DB \'%s\' does not exist', name)
        return False

    if name in ('mysql', 'information_scheme'):
        log.info('DB \'%s\' may not be removed', name)
        return False

    # db does exists, proceed
    dbc = _connect(**connection_args)
    if dbc is None:
        return False
    cur = dbc.cursor()
    s_name = quote_identifier(name)
    # identifiers cannot be used as values
    qry = 'DROP DATABASE {0};'.format(s_name)
    try:
        _execute(cur, qry)
    except MySQLdb.OperationalError as exc:
        err = 'MySQL Error {0}: {1}'.format(*exc.args)
        __context__['mysql.error'] = err
        log.error(err)
        return False

    if not db_exists(name, **connection_args):
        log.info('Database \'%s\' has been removed', name)
        return True

    log.info('Database \'%s\' has not been removed', name)
    return False
470846
def delete(name, dry_run, verbose):
    """"""
    collection = Collection.query.filter_by(name=name).one()
    if verbose:
        tr = LeftAligned(traverse=AttributeTraversal())
        click.secho(tr(collection), fg='red')
    db.session.delete(collection)
1006033
def kill_thread(self, name):
        
        if name not in self.thread_pool:
            return

        self.thread_pool[name].join()
        del self.thread_pool[name]
517395
def delete_collection_percolator(target):
    
    for name in current_search.mappings.keys():
        if target.name and target.dbquery:
            current_search.client.delete(
                index=name,
                doc_type='.percolator',
                id='collection-{}'.format(target.name),
                ignore=[404]
            )
517981
def unregister_all(self, name):
        
        try:
            templatehook = self._registry[name]
        except KeyError:
            return

        templatehook.unregister_all()
759971
def delete(self, name):
        
        if isinstance(name, (list, tuple)):
            for xx in name:
                self.delete(xx)
        else:
            if name in self._record_map:
                del self._record_map[name]
                self._record_list = [
                    r for r in self._record_list if r['name'] != name]
969903
def delete_name(name):
    '''  '''
    session = create_session()
    try:
        user = session.query(User).filter_by(name=name).first()
        session.delete(user)
        session.commit()
    except SQLAlchemyError, e:
        session.rollback()
        raise bottle.HTTPError(500, "Database Error", e)
    finally:
        session.close()
1199997
def on_discovery_remove(self, name):
        
        self.configurables[Discovery][name].stop()

        self.sync_balancer_files()
249858
def find_by_name(name, engines=None):
    
    if engines is None:
        engines = ENGINES

    for egn in engines:
        if egn.name() == name:
            return egn

    return None
525165
def engineIncluded(self, name):
        
        if self._engines is None:
            self._engines = self._dbconn.getStorageEngines()
        return self.envCheckFilter('engine', name) and name in self._engines
475156
def unregister(self, name):
        
        try:
            name = name.name
        except AttributeError:
            pass
        return self.pop(name,None)
1179189
def remove_object(self, name):
        
        if name not in self._object_map:
            raise RuntimeError('No object with name {} is registered.'.format(name))

        for fn_name in list(self._function_map.keys()):
            if fn_name.startswith(name + '.') or fn_name.startswith(name + ':'):
                self._remove_function(fn_name)

        del self._object_map[name]