Returns all the fields and values in the Hash.

        :param name: str     the name of the redis key
        :return: Future()
502340
def hgetall(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hgetall(self.redis_key(name))

            def cb():
                data = {}
                m_decode = self.memberparse.decode
                v_decode = self._value_decode
                for k, v in res.result.items():
                    k = m_decode(k)
                    v = v_decode(k, v)
                    data[k] = v
                f.set(data)

            pipe.on_execute(cb)
            return f
513857
def get(self, key):
        
        value = self._redis.get(self._prefix + key)

        if value is not None:
            return self.unserialize(value)
317357
def srandmember(self, name, number=None):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.srandmember(self.redis_key(name), number=number)

            def cb():
                if number is None:
                    f.set(self.valueparse.decode(res.result))
                else:
                    f.set([self.valueparse.decode(v) for v in res.result])

            pipe.on_execute(cb)
            return f
1112459
def get_field(name, model=None):
    
    if '.' in name:
        m, name = name.split('.')
        model = get_model(m)

    if model:
        return getattr(model, name, None)
763343
def hdel(self, name, *keys):
        
        with self.pipe as pipe:
            m_encode = self.memberparse.encode
            keys = [m_encode(m) for m in self._parse_values(keys)]
            return pipe.hdel(self.redis_key(name), *keys)
1222974
def get_field(self, name):
        
        # TODO could use a generator here
        prog = re.compile(name)
        l = []
        for i in self.get_classes():
            for j in i.get_fields():
                if prog.match(j.get_name()):
                    l.append(j)
        return l
369857
def get(self, name):
        ""
        for bucket in self:
            for k,v in self[bucket].items():
                if k == name:
                    return v
184564
def get(self, name):
        
        if self.structs.has_key(name):
            return self.structs[name]
        elif self.enums.has_key(name):
            return self.enums[name]
        elif self.interfaces.has_key(name):
            return self.interfaces[name]
        else:
            raise RpcException(ERR_INVALID_PARAMS, "Unknown entity: '%s'" % name)
1236155
def _data(self, pipe=None):
        
        pipe = self.redis if pipe is None else pipe
        return [self._unpickle(v) for v in pipe.lrange(self.key, 0, -1)]
705174
def _data(self, pipe=None):
        
        pipe = self.redis if pipe is None else pipe
        items = pipe.hgetall(self.key).items()

        return {self._unpickle_key(k): self._unpickle(v) for k, v in items}
674251
public static function getHash(string $name, string $key): string
    {
        $obj = new RedisHash(self::handle(), $name);
        return $obj->get($key);
    }
881897
def get_records(self, name):
        
        if name in self._cache:
            return self._cache[name].values()
        else:
            return []
124162
def get_all(self):
        ''''''
        for name, values in self._map.items():
            for value in values:
                yield (name, value)
1185548
def exists(self, name):
        
        with self.pipe as pipe:
            return pipe.exists(self.redis_key(name))
132921
def get_field_key(self, key, using_name=True):
        
        try:
            if using_name:
                return self.f_name[key].key
            else:
                return self.f[key].key
        except KeyError:
            raise ValueError("'%s' are not found!" % key)
544898
def get_field(self, name):
        
        try:
            return dict.__getitem__(self, name)
        except KeyError as err:
            raise SchemaError("'%s' is not a document field (existing attributes are: %s)" % (err, list(self)))
1195995
def _get_internal_field_by_name(self, name):
        """"""
        field = self._all_fields.get(name, self._all_fields.get('%s.%s' % (self._full_name, name)))
        if field is not None:
            return field
        for field_name in self._all_fields:
            # Specific name
            if field_name.endswith('.%s' % name):
                return self._all_fields[field_name]