Remove a FKey by given fkeyName
517943
public TableModel removeFKey(String fkeyName) {
		checkReadOnly();
		List<FKeyModel> fkeys = getFkeyConstraints();
		Iterator<FKeyModel> fkeyIter = fkeys.iterator();
		while (fkeyIter.hasNext())
			if (fkeyIter.next().getFkeyName().equalsIgnoreCase(fkeyName))
				fkeyIter.remove();
		return this;
	}
900765
def remove(self, name):
        
        attrs = [attr for attr in self.attributes if attr.name == name.strip()]
        if not attrs:
            raise ValueError(name)
        for attr in attrs:
            self.attributes.remove(attr)
865869
def remove(self,obj):
        
        relationship_table = self.params['relationship_table']
        with self.obj.backend.transaction(implicit = True):
            condition = and_(relationship_table.c[self.params['related_pk_field_name']] == obj.pk,
                             relationship_table.c[self.params['pk_field_name']] == self.obj.pk)
            self.obj.backend.connection.execute(delete(relationship_table).where(condition))
            self._queryset = None
1123561
def delete_cas(self, key, *, index):
        
        self.append({
            "Verb": "delete-cas",
            "Key": key,
            "Index": extract_attr(index, keys=["ModifyIndex", "Index"])
        })
        return self
178322
def remove(self, name):
        """"""
        self.gui.removeAction(self._actions_dict[name].qaction)
        del self._actions_dict[name]
        delattr(self, name)
332765
def remove_from_index(name, key)
      index(name).delete(key)
      index(:"#{name}_to_s").delete(key.to_s)
      index(:"#{name}_to_sym").delete(:"#{key}") if to_sym?(key)
    end
885344
def remove_by(keys, original):
    """"""
    for i in [
            original[index]
            for index, needed in enumerate(keys) if not needed
    ]:
        original.remove(i)
998964
function remove(keyId, callback) {
    commons.del(format('/%s/keys/%s', deis.version, keyId), callback);
  }
1023627
public void removeName(String name)
   {
      indexes.remove(name);
      names.remove(name);
      dirty = true;
   }
414383
def delete(self, name):
    '''
    
    '''
    keys = self._client.keys('%s%s:*'%(self._prefix,name))

    pipe = self._client.pipeline(transaction=False)
    for key in keys:
      pipe.delete( key )
    pipe.execute()

    # Could be not technically the exact number of keys deleted, but is a close
    # enough approximation
    return len(keys)
714092
def remove_parameter(self, name):
		
		if name in self.__query:
			self.__query.pop(name)
492701
def keypair_delete(name, profile=None, **kwargs):
    '''
    
    '''
    conn = _auth(profile, **kwargs)
    return conn.keypair_delete(name)
767264
def fkapply(models,pool,fn,missing_fn,(nombre,pkey,field),*args):
  ""
  if (nombre,pkey) in models: return fn(pool,models[nombre,pkey],field,*args)
  else: return missing_fn(pool,field,*args) if missing_fn else ['missing']
211036
def delete_by_user_name(user_name):
        '''
        
        '''
        try:
            del_count = TabMember.delete().where(TabMember.user_name == user_name)
            del_count.execute()
            return True
        except:
            return False
938938
def delete_(*keyname):
    '''
    
    '''
    mdata = _check_mdata_delete()
    valid_keynames = list_()
    ret = {}

    for k in keyname:
        if mdata and k in valid_keynames:
            cmd = '{0} {1}'.format(mdata, k)
            ret[k] = __salt__['cmd.run_all'](cmd, ignore_retcode=True)['retcode'] == 0
        else:
            ret[k] = True

    return ret
1023605
def delete(self, *args):
        """"""
        key = self.name_wid.text or self.name_wid.hint_text
        if not hasattr(self.store, key):
            # TODO feedback about missing key
            return
        delattr(self.store, key)
        try:
            return min(kee for kee in dir(self.store) if kee > key)
        except ValueError:
            return '+'
1190772
def _remove_prefix(name):
    """"""
    if isinstance(name, str):
        return _do_remove_prefix(name)
    return [_do_remove_prefix(nm) for nm in name]