玩一把redis源码之二—自定义hash、set数据类型

最新推荐文章于 2024-04-29 11:12:23 发布
最新推荐文章于 2024-04-29 11:12:23 发布
阅读量660 收藏
点赞数

导读

作者：郭江伟，微信号：guojiangwei690290

MySQL学员，欢迎交流拍砖~

本文为《玩一把redis源码》系列第二篇，本系列未完待续，敬请继续关注哦！

开篇请戳：玩一把redis源码(一):为redis添加自己的列表类型

温馨提示：本文内含较多代码，不适合手机端阅读，建议通过PC端阅读。

一、本文目的

模仿redis实现自定义字典数据结构
模仿redis实现自定义set、hash数据类型

二、内容简介

redis中set和hash数据类型用到了hash算法，redis中存储数据库所有数据对象使用的基础数据结构就是字典数据结构，set和hash两个数据类型底层实现都用到字典结构，但是针对不同的值类型和键值对数量set与hash还是有很大区别，比如当值都是int时set会使用一个inset结构，当键值对比较少时hash数据域会使用ziplist结构。本文只针对set和hash都采用字典结构的情况，此时set类型基本等同于value数据域为NULL的hash类型。

redis源码比本文描述复杂很多，阅读本文可以了解基本的字典结构和hash算法，对redis源码也会有一个大致认知。

本文的hashcode算法参考的jdk hashmap实现，但是比hashmap简单，能做到一定的随机性。

文档分为三大部分：

  • 环境介绍与效果演示

  • redis代码执行流程

  • 代码实现

（一）环境介绍和效果演示

环境介绍：

redis版本为5.0.3 64 bit
操作系统版本为Ubuntu 18.10 64bit
源码可以用gedit查看 gdb调试
ide 可以用eclipse+CDT

效果演示

myhash实现命令以及对应的原生hash命令：

实现命令redis命令含义
myhmsethmset新建hash
myhgetallhgetall查询所有键值对
myhdelhdel删除一个或多个field
myhgethget获取某个field值
myhexistshexists是否存在指定的field
myhkeyshkeys返回所有field
myhlenhlen获取hash键值对数量
myhmgethmget获取指定一个或多个filed值
myhvalshvals返回所有的值

myset实现命令以及对应原生set命令：

实现命令redis命令含义
mysaddsadd向set添加一个或多个成员
myscardscard返回成员数
mysmemberssmembers返回所有成员
myspopspop移除并返回一个随机元素
mysunionsunion返回所有集合的并集
mysintersinter返回给定集合的交集
mysdiffsdiff返回差集
演示效果

测试myhash

127.0.0.1:6379> myhmset gjwh1 gjwk1 gjwv1 gjwk2 gjwv2
OK
127.0.0.1:6379> myhlen gjwh1
(integer) 2
127.0.0.1:6379> myhgetall gjwh1
1) "gjwk2"
2) "gjwv2"
3) "gjwk1"
4) "gjwv1"
127.0.0.1:6379> myhget gjwh1 gjwk1
"gjwv1"
127.0.0.1:6379> myhdel gjwh1 gjwk1
(integer) 1
127.0.0.1:6379> myhgetall gjwh1
1) "gjwk2"
2) "gjwv2"
127.0.0.1:6379> mygexists gjwh1 gjwk1(error) ERR unknown command `mygexists`, with args beginning with: `gjwh1`, `gjwk1`, 
127.0.0.1:6379> myhexists gjwh1 gjwk1
(integer) 0
127.0.0.1:6379> myhexists gjwh1 gjwk2
(integer) 1
127.0.0.1:6379> myhget gjwh1 gjwk2"gjwv2"
127.0.0.1:6379> myhmset gjwh1 gjwk3 gjwv3 gjwk4 gjwv4
OK
127.0.0.1:6379> myhkeys gjwh1
1) "gjwk4"
2) "gjwk3"
3) "gjwk2"
127.0.0.1:6379> myvals gjwh1(error) ERR unknown command `myvals`, with args beginning with: `gjwh1`, 
127.0.0.1:6379> myhvals gjwh1
1) "gjwv4"
2) "gjwv3"
3) "gjwv2"

测试myset

127.0.0.1:6379> mysadd gjws1 gjwsk1 gjwsk2 gjwsk3
(integer) 3
127.0.0.1:6379> mysmembers gjws1
1) "gjwsk1"
2) "gjwsk2"
3) "gjwsk3"
127.0.0.1:6379> myscard gjws1
(integer) 3
127.0.0.1:6379> myspop gjws1
"gjwsk1"
127.0.0.1:6379> mysmembers gjws1
1) "gjwsk2"
2) "gjwsk3"
127.0.0.1:6379> myscard gjws1
(integer) 2
127.0.0.1:6379> myspop gjws1
"gjwsk2"
127.0.0.1:6379> mysmembers gjws1
1) "gjwsk3"
127.0.0.1:6379> myscard gjws1
(integer) 1

redis代码执行流程

此部分只选择与本文档相关部分做简单介绍，下面从server.c文件的processCommand函数开始。

640?wx_fmt=png

下面以myhmset命令执行的时序图来说明具体调用的函数及其所在的文件，其他命令执行方式都类似.图中方框内的文件名，所有关于hash类型的命令都在文件t_hash.c中,所有关于set类型的命令都在文件t_set.c中，其他类型的命令处理函数可以找对应的文件，redis命令非常规范，找起来不难。

640?wx_fmt=png

代码实现

添加头文件mydict.h
头文件中定义了基础的数据结构，需要实现的与数据结构有关的方法。最重要的是hashcode、rehash、还有一个迭代器，其他方法基本都是通常操作字典的基本方法。本文并非实现了全部方法，按照本文介绍的知识，可以比较方便的编写自己的方法。

/*
 * mydict.h
 *
 *  Created on: Jan 16, 2019
 *      Author: gjw
 */

#ifndef SRC_MYDICT_H_
#define SRC_MYDICT_H_
#define mydictSlots(d) ((d)->ht[0].size+(d)->ht[1].size)
#define mydictSize(d) ((d)->ht[0].used+(d)->ht[1].used)

typedef struct mydictEntry {    
void *key;    
void *val;    
struct mydictEntry *next;
} mydictEntry;
typedef struct mydictht {
    mydictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} mydictht;
typedef struct mydict {    //dictType *type;
   // void *privdata;
    mydictht ht[2];    
long rehashidx; /* rehashing not in progress if rehashidx == -1 */
} mydict;
typedef struct mydictIterator{
    mydict * myd;
    mydictEntry *next;    
int tableNum;    
int index;
}mydictIterator;/* API */
mydict *mydictCreate();
int mydictExpand(mydict *d, unsigned long size);
int mydictAdd(mydict *d, void *key, void *val);
mydictEntry * doMydictIter(mydictIterator * iter);
mydictIterator * getMydictIterator(mydict *d);
int mydictReplace(mydict *d, void *key, void *val);
int mydictDelete(mydict *d, const void *key);
void mydictFreeUnlinkedEntry(mydict *d, mydictEntry *he);
void mydictRelease(mydict *d);
mydictEntry * mydictFind(mydict *d, const void *key);
void *mydictFetchValue(mydict *d, const void *key);
int mydictResize(mydict *d);
mydictEntry *mydictGetRandomKey(mydict *d);
unsigned int mydictGetSomeKeys(mydict *d, mydictEntry **des, unsigned int count);
int mydictGenHashFunction(const void *key, int len);
int mydictGenCaseHashFunction(const unsigned char *buf, int len);
void mydictEmpty(mydict *d, void(callback)(void*));
void mydictEnableResize(void);
void mydictDisableResize(void);
int mydictRehash(mydict *d, int n);
int mydictRehashMilliseconds(mydict *d, int ms);
void mydictSetHashFunctionSeed(int *seed);
int *mydictGetHashFunctionSeed(void);
int mydictGetHash(mydict *d, const void *key);//
mydictEntry **dictFindEntryRefByPtrAndHash(mydict *d, const void *oldptr, int hash);
mydictEntry *mydictGetRandomKey(mydict *d);#endif /* SRC_MYDICT_H_ */

mydict.c 实现具体的方法

/*
 * mydict.c
 *
 *  Created on: Jan 16, 2019
 *      Author: gjw
 */
#include "mydict.h"
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "sds.h"
unsigned int hashCode(char * key) {    int len = strlen(key);
    unsigned int hash = 0;    
for (int i = 0; i < len; i++) {
        hash = 31 * hash + (key[i]);
    }    return hash ^ (hash >> 16);

}
static int _myinitht(mydictht * ht) {
    ht->table = NULL;
    ht->size = 0UL;
    ht->sizemask = 0UL;
    ht->used = 0UL;    return 0;

}
mydict *mydictCreate() {
    mydict * d = (mydict *) malloc(sizeof(*d));
    _myinitht(&d->ht[0]);
    _myinitht(&d->ht[1]);
    d->rehashidx = -1;    
         return d;
}
unsigned long _mydictNextPower(unsigned long size) {    
int i = 4;    
while (1) {        
if (i >= size)return i;
    i = i * 2;
    }
}
int mydictExpand(mydict *d, unsigned long size) {    
int realSize = _mydictNextPower(size);//    int index=d->ht[0].size==0?0:1;
    if (realSize <= d->ht[0].size)        return 1;
    mydictEntry ** entries = (mydictEntry **) malloc(realSize * sizeof(mydictEntry *));
    d->ht[1].table = entries;
    d->ht[1].size = realSize;
    d->ht[1].sizemask = realSize - 1;
    d->ht[1].used = 0;
    d->rehashidx = 0;    
for (int i = 0; i < realSize; i++) {
        d->ht[1].table[i] = NULL;
    }    
return 0;
}//return bucket index
int _myKeyIndex(mydict *d, void *key, unsigned long hash) {    
int index = 0, len1 = sdslen(key), len2 = 0;    
int i;    
for (i = 0; i <= 1; i++) {        
if (d->ht[i].size == 0)continue;
        index = hash % d->ht[i].size;
        mydictEntry * e = d->ht[i].table[index];        
             if (!e)            break;
        len2 = sdslen(e->key);        
if (len1 == len2) {            
if (memcmp(e->key, key, len1) == 0) {return -1;
            }
        }        
if (d->rehashidx == -1)    break;
    }    
return index;
}
int _mydictExpandIfNeeded(mydict *d) {    /* Incremental rehashing already in progress. Return. */
    if (d->rehashidx != -1){
        mydictRehash(d,100);        
              return 0;}    
       if (d->ht[0].size == 0)        return mydictExpand(d, 4);    
   if (d->ht[0].used >= d->ht[0].size && (d->ht[0].used / d->ht[0].size > 2)) {    
    return mydictExpand(d, d->ht[0].used * 2);
    }    
    return 0;
}
    int mydictAdd(mydict *d, void *key, void *val) {
    unsigned long hash = hashCode(key);
    _mydictExpandIfNeeded(d);    
    int index = _myKeyIndex(d, key, hash);    
    if (index == -1)        return 1;
    mydictht *ht = (d->rehashidx == -1 ? &d->ht[0] : &d->ht[1]);
    mydictEntry * n = (mydictEntry *) malloc(sizeof(mydictEntry));
    n->key=key;
    n->val=val;
    n->next = ht->table[index];
    ht->table[index] = n;
    ht->used++;    
    return 0;
    }
void _mydestroyDictEntry(mydictEntry * e) {
    mydictEntry * e1 = e;    
    while (e) {
        sdsfree(e->key);
        sdsfree(e->val);
        e = e->next;
        e1->next = NULL;
        free(e1);
    }
}
    int mydictDelete(mydict *d, const void *key) {
    unsigned long hash = hashCode(key);    
    int index = 0;    int len1 = 0, len2 = 0;
    mydictEntry * n;
    mydictEntry * previous;
    mydictEntry * head;    
    if (index == -1)        return 1;    
    for (int i = 0; i <= 1; i++) {        
    if(d->ht[i].size==0)continue;
        index = hash % d->ht[i].size;
        head = d->ht[i].table[index];
        previous = head;
        n = head;        
    while (n) {
            len1 = sdslen(n->key);
            len2 = sdslen(key);            
    if (len1 == len2 && memcmp(n->key, key, len1) == 0) {                if (n == head) {
                    d->ht[i].table[index] = NULL;
                    _mydestroyDictEntry(head);
                } else {
                    previous->next = n->next;
                    _mydestroyDictEntry(n);
                }
                d->ht[i].used--;
                _mydictExpandIfNeeded(d);                return 0;
            }
            previous = n;
            n = n->next;
        }        if (d->rehashidx == -1)    break;
    }    return 1;

}

void mydictRelease(mydict *d) {    
    int size = 0;    
    for (int i = 0; i <= 1; i++) {
        size = d->ht[i].size;        
    for (int j = 0; j < size; j++) {
            _mydestroyDictEntry(d->ht[i].table[j]);
            d->ht[i].used--;
        }    
    if (d->rehashidx == -1)    break;
    }
free(d);
}
mydictEntry * mydictFind(mydict *d, const void *key) {
    unsigned int hash = hashCode(key);    
    int index, len1, len2;
    mydictEntry *e;    for (int i = 0; i <= 1; i++) {        
    if(d->ht[i].size==0)continue;
        index = hash % d->ht[i].size;
        e = d->ht[i].table[index];        
    while (e) {
            len1 = sdslen(e->key);
            len2 = sdslen(key);            
               if (len1 == len2 && memcmp(e->key, key, len1) == 0)                return e;
            e = e->next;
        }        
               return NULL;
    }
}
int mydictRehash(mydict *d, int n) {    
int emptySize = n * 10;
    int rehashinx = d->rehashidx;    
    int inx;
    mydictEntry *e, *next;    
    while (d->ht[0].size!=0&&d->ht[0].table[rehashinx] == NULL) {
        rehashinx++;
        d->rehashidx++;
        d->ht[0].size--;
    }    
    while (n--) {        
                if (d->ht[0].size == 0) {
            d->rehashidx = -1;
            d->ht[0] = d->ht[1];
            _myinitht(&d->ht[1]);    
                  break;
        }
        e = d->ht[0].table[rehashinx];        
                  while (e) {
            inx = hashCode(e->key) % (d->ht[1].size);
            next = d->ht[1].table[inx];
            e->next = next;
            d->ht[1].table[inx] = e;
            d->ht[1].used++;
            d->ht[0].used--;
            e = e->next;
        }
        d->ht[0].size--;
        rehashinx++;
        d->rehashidx = rehashinx;
    }    return 0;
}
int mydictGetHash(mydict *d, const void *key) {    return hashCode(key);
}
int mydictRehashMilliseconds(mydict *d, int ms) {    
long long start = timeInMilliseconds();
    int rehashes = 0;    
    while (mydictRehash(d, 100)) {
        rehashes += 100;        
    if (timeInMilliseconds() - start > ms)    break;
    }    
    return rehashes;
}
int mydictResize(mydict *d) {    
int minimal;    
if (d->rehashidx != -1)    return 1;
    minimal = d->ht[0].used;    
if (minimal < 4)minimal = 4;    
return mydictExpand(d, minimal);
}
mydictIterator * getMydictIterator(mydict *d) {
    mydictIterator * mi = (mydictIterator *) malloc(sizeof(mydictIterator));
    mi->index = 0;
    mi->myd = d;
    mi->tableNum = 0;
    mi->next = NULL;    
return mi;
}

mydictEntry * doMydictIter(mydictIterator * iter) {
    mydictEntry *e;
    e = iter->next;    
int size = iter->myd->ht[0].size;    
int htindex = iter->index >= size ? iter->index - size : iter->index;    
while (!e) {        
if (iter->index >= mydictSlots(iter->myd)) {
            free(iter);            
                        return e;
        }    
              if (iter->index >= iter->myd->ht[0].size) {
            iter->tableNum = 1;
        }
        e = iter->myd->ht[iter->tableNum].table[htindex];
        htindex++;
        iter->index++;
    }
    iter->next = e->next;    
return e;
}
mydictEntry *mydictGetRandomKey(mydict *d){    
if(mydictSize(d)==0)return NULL;    
while(d->rehashidx!=-1)mydictRehash(d,100);   
 int index=random() % d->ht[0].size;
    mydictEntry *e =d->ht[0].table[index];
    mydictEntry *n;    while(!e){
        index=random() % d->ht[0].size;
        e =d->ht[0].table[index];
    }
    n=e;    
 int llen=0;   
  while(n){
        n=n->next;
        llen++;
    }    int pos=random()%llen;   
   for(int i=0;i<pos;i++){
        e=e->next;
    }    return e;
}

在server.c添加字符串——执行函数映射：

{"myhmset",myhsetCommand,-4,"wmF",0,NULL,1,1,1,0,0},
    {"myhset",myhsetCommand,-4,"wmF",0,NULL,1,1,1,0,0},
        {"myhdel",myhdelCommand,-3,"wF",0,NULL,1,1,1,0,0},
    {"myhget",myhgetCommand,3,"rF",0,NULL,1,1,1,0,0},
        {"myhlen",myhlenCommand,2,"rF",0,NULL,1,1,1,0,0},
        {"myhkeys",myhkeysCommand,2,"rS",0,NULL,1,1,1,0,0},
        {"myhvals",myhvalsCommand,2,"rS",0,NULL,1,1,1,0,0},
        {"myhgetall",myhgetALLCommand,2,"rR",0,NULL,1,1,1,0,0},
        {"myhexists",myhexistsCommand,3,"rF",0,NULL,1,1,1,0,0},
    {"myhmget",myhmgetCommand,-3,"rF",0,NULL,1,1,1,0,0},
     {"mysadd",mysaddCommand,-3,"wmF",0,NULL,1,1,1,0,0},
     {"myscard",myscardCommand,2,"rF",0,NULL,1,1,1,0,0},
    {"mysmembers",mysmembersCommand,2,"rS",0,NULL,1,1,1,0,0},
    {"myspop",myspopCommand,-2,"wRF",0,NULL,1,1,1,0,0},

在server.h中添加数据类型操作方法声明

#include "mydict.h"  /* mydict ,guojiagnwei add */
#define MYOBJ_HASH 10      /* MYHASH object. */
#define MYOBJ_SET 9      /* MYSET object. */
void myhgetALLCommand(client *c) ;
void myhsetCommand(client *c);
void myhkeysCommand(client *c) ;
void myhvalsCommand(client *c);
void myhdelCommand(client *c);
void myhgetCommand(client *c);
void myhexistsCommand(client *c);
void myhlenCommand(client *c);
void myhmgetCommand(client *c);
void mysaddCommand(client *c);
void myscardCommand(client *c);
void mysmembersCommand(client *c);
void myspopCommand(client *c);
void mysunionCommand(client *c);
void mysinterCommand(client *c);
void mysdiffCommand(client *c);

在object.c中添加创建类型方法

robj *createMyHashObject(void) {
    mydict  *myd = mydictCreate();
    robj *o = createObject(MYOBJ_HASH, myd);
    o->encoding = OBJ_ENCODING_ZIPLIST;
    return o;}

在t_hash.c中实现server.h声明的操作函数

void myhsetCommand(client *c) {
    int i, created = 0;
    robj *o;    
if ((c->argc % 2) == 1) {
        addReplyError(c, "wrong number of arguments for HMSET");
        return;
    }    
o = lookupKeyWrite(c->db, c->argv[1]);    
if (o == NULL) {
        o = createMyHashObject();        
dbAdd(c->db, c->argv[1], o);
    } else {        
       if (o->type != MYOBJ_HASH) {
            addReply(c, shared.wrongtypeerr);
            return;
        }
    }//    if ((o = hashTypeLookupWriteOrCreate(c,c->argv[1])) == NULL) return;//    hashTypeTryConversion(o,c->argv,2,c->argc-1);

    for (i = 2; i < c->argc; i += 2)created += !mydictAdd(o->ptr, sdsdup(c->argv[i]->ptr), sdsdup(c->argv[i + 1]->ptr));    
    char *cmdname = c->argv[0]->ptr;    
if (cmdname[1] == 's' || cmdname[1] == 'S') {        /* HSET */
        addReplyLongLong(c, created);
    } else {        /* HMSET */
        addReply(c, shared.ok);
    }    
signalModifiedKey(c->db, c->argv[1]);    
notifyKeyspaceEvent(NOTIFY_HASH, "hset", c->argv[1], c->db->id);
    server.dirty++;
}
void myGenerichgetALLCommand(client *c, int flag) {
    robj *o;
    int multiplier = 0;
    int length, count = 0;    
if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.emptymultibulk)) == NULL
            || checkType(c, o, MYOBJ_HASH))
        return;
    length = mydictSize((const mydict* )o->ptr);    
    if (flag == 3)
        length = length * 2;
    addReplyMultiBulkLen(c, length);    
    mydictIterator *hi = getMydictIterator(o->ptr);
    mydictEntry *e = doMydictIter(hi);
    int len1=0,len2;    
    while (e) {        
    if (flag & OBJ_HASH_KEY) {            
    len1=sdslen(e->key);            
    addReplyBulkCBuffer(c, e->key, len1);
            count++;
        }        
    if (flag & OBJ_HASH_VALUE) {            
    len2=sdslen(e->val);            
    addReplyBulkCBuffer(c, e->val, len2);
            count++;
        }

        e = doMydictIter(hi);
    }
    serverAssert(count == length);
}
void myhgetALLCommand(client *c) {
    myGenerichgetALLCommand(c, OBJ_HASH_VALUE | OBJ_HASH_KEY);
}
void myhkeysCommand(client *c) {
    myGenerichgetALLCommand(c,  OBJ_HASH_KEY);
}
void myhvalsCommand(client *c) {
    myGenerichgetALLCommand(c, OBJ_HASH_VALUE);
}
void myhdelCommand(client *c) {
    robj *o;
    int j, deleted = 0, keyremoved = 0;    
    if ((o = lookupKeyWriteOrReply(c, c->argv[1], shared.czero)) == NULL
            || checkType(c, o, MYOBJ_HASH))
        return;
        for (j = 2; j < c->argc; j++) {        
    if (!mydictDelete(o->ptr, c->argv[j]->ptr)) {
            deleted++;            
    if (mydictSize((const mydict*)o->ptr) == 0) {                
    dbDelete(c->db, c->argv[1]);
                keyremoved = 1;
                break;
            }
        }
    }    if (deleted) {        
    signalModifiedKey(c->db, c->argv[1]);        
    notifyKeyspaceEvent(NOTIFY_HASH, "hdel", c->argv[1], c->db->id);        if (keyremoved)            notifyKeyspaceEvent(NOTIFY_GENERIC, "del", c->argv[1], c->db->id);
        server.dirty += deleted;
    }
    addReplyLongLong(c, deleted);
}

void myhgetCommand(client *c) {
    robj *o;    if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.nullbulk)) == NULL
            || checkType(c, o, MYOBJ_HASH))
        return;    
    mydictEntry * me = mydictFind(o->ptr, c->argv[2]->ptr);    
    if (me)        addReplyBulkCBuffer(c, me->val, sdslen(me->val));    
    else
        addReply(c, shared.nullbulk);
}

void myhexistsCommand(client *c) {
    robj *o;    
    if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.czero)) == NULL
            || checkType(c, o, MYOBJ_HASH))
        return;
        addReply(c, mydictFind(o->ptr, c->argv[2]->ptr) ? shared.cone : shared.czero);
}
void myhlenCommand(client *c){

    robj *o;    if ((o = lookupKeyReadOrReply(c, c->argv[1], shared.czero)) == NULL
            || checkType(c, o, MYOBJ_HASH))
        return;    addReplyLongLong(c, mydictSize((const mydict*)o->ptr));
}
void myhmgetCommand(client *c){
    robj *o;    
    o = lookupKeyRead(c->db, c->argv[1]);    
    if (o != NULL && o->type != OBJ_HASH) {
        addReply(c, shared.wrongtypeerr);
        return;
    }    addReplyMultiBulkLen(c, c->argc - 2);    
    for (int i = 2; i < c->argc; i++) {        
    mydictEntry * me = mydictFind(o->ptr, c->argv[i]->ptr);    
    if (me == NULL)
            addReply(c, shared.nullbulk);        else
            addReplyBulkCBuffer(c, me->val, sdslen(me->val));
    }
}

在t_set.c中添加set相关的处理函数，本例为求简洁，用dict实现set类型，重用了几个t_hash中的函数

void mysaddCommand(client *c){
    robj *set;
    int j, added = 0;    
set = lookupKeyWrite(c->db,c->argv[1]);    
if (set == NULL) {
        set = createMyHashObject();        
dbAdd(c->db,c->argv[1],set);
    } else {        
if (set->type != MYOBJ_HASH) {
            addReply(c,shared.wrongtypeerr);
            return;
        }
    }    
for (j = 2; j < c->argc; j++) {        
if (!mydictAdd(set->ptr,sdsdup(c->argv[j]->ptr),NULL)) added++;
    }    if (added) {        
signalModifiedKey(c->db,c->argv[1]);        
notifyKeyspaceEvent(NOTIFY_SET,"sadd",c->argv[1],c->db->id);
    }
    server.dirty += added;
    addReplyLongLong(c,added);
}
void myscardCommand(client *c){
    myhlenCommand(c);
}
void mysmembersCommand(client *c){
    myhkeysCommand(c);
}
void myspopCommand(client *c){
    robj *set;    
if (c->argc == 3) {
        spopWithCountCommand(c);
        return;
    } else if (c->argc > 3) {
        addReply(c,shared.syntaxerr);
        return;
    }    /* Make sure a key with the name inputted exists, and that it's type is
     * indeed a set */
    if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
        checkType(c,set,MYOBJ_HASH)) return;    
mydictEntry * e=mydictGetRandomKey(set->ptr);    
    addReplyBulkCBuffer(c, e->key, sdslen(e->key));   
 if (e) {        
 mydictDelete(set->ptr,e->key);
    }    
 notifyKeyspaceEvent(NOTIFY_SET,"spop",c->argv[1],c->db->id);    
 /* Delete the set if it's empty */
    if (mydictSize((mydict *)set->ptr) == 0) {        
 dbDelete(c->db,c->argv[1]);       
  notifyKeyspaceEvent(NOTIFY_GENERIC,"del",c->argv[1],c->db->id);
    }    /* Set has been modified */
    signalModifiedKey(c->db,c->argv[1]);
    server.dirty++;

}

上一篇文章没有贴出Makefile的修改，这里一并补上

REDIS_SERVER_OBJ=mydict.o mylinkedlist.o adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o lolwut.o lolwut5.o

另外需要修改Makefile.dep

mydict.o: mydict.c mydict.h sds.hmylinkedlist.o: mylinkedlist.c mylinkedlist.h

  

640.gif?


加入知数堂

挑战40万+年薪！



640?640?640?640?


知数堂

叶金荣与吴炳锡联合打造

领跑IT精英培训

行业资深专家强强联合，倾心定制

MySQL实战/MySQL优化/MongoDB/

Python/ SQL优化/Hadoop+ELK

数门精品课程

“阅读原文”可获更多正课试听视频

密码：hg3h

紧随技术发展趋势，定期优化培训教案

融入大量生产案例，贴合企业一线需求

社群陪伴学习，一次报名，可学1年

DBA、开发工程师必修课

上千位学员已华丽转身，薪资翻番，职位提升

改变已悄然发生，你还在等什么？

640.png?



640?wx_fmt=gif 扫码加入QQ技术交流群

MySQL 8.0|MGR研究院-ZST

（QQ群号：650149401）    

640?wx_fmt=jpeg

老叶茶馆_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis相关知识汇总（三）数据类型之hash和set
了缺的专栏
01-31 568
hash 我感觉hash没啥好说的， 直接上图就好了，内部就是一个dict。 值得注意的地方, hash是有限制的： redis.conf hash-max-ziplist-value 64 // ziplist中最大能存放的值长度 hash-max-ziplist-entries 512 // ziplist中最多能存放的entry节点数量 ...
Redis开发：hash存储自定义Java对象及value的序列化器设置
学亮编程手记
02-10 919
Redis 源码解析 - Redis hset、hmset 命令学习
qq_33240556的博客
04-29 598
Redis 的HSET和HMSET命令用于哈希（hash）数据类型的操作，分别用于设置单个字段(field)的值和同时设置多个字段的值。了解它们的源码实现可以帮助深入理解Redis如何处理哈希类型的数据操作。
自定义HashSet
weixin_41047492的博客
12-26 176
package cn.sxt.mycollection; import java.util.HashMap; import java.util.TreeSet; /** 手动实现一个HashSet，更深刻理解HashSet底层原理 */ public class HashSet { HashMap map; private static final Object PRESENT = ne...
redis的数据结构sets和hash
feiyan的博客
10-12 1381
3．存储sets类型 在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我 们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要 说明的是，这些操作的时间是常量时间。Set可包含的最大元素数是4294967295。 和List类型不同的是，Set集合中不允许出现重复的元素。和List类型相比，Set类 型在功能上还存在着一个非常重要的特性，即在...
使用自定义注解+AOP实现存放HASH类型的Redis缓存
叁金Coder
03-26 288
使用自定义注解+AOP实现存放HASH类型的Redis缓存1.自定义的Redis方法2.自定义注解3.自定义Aspect 1.自定义的Redis方法 /** * @description 获取返回值 * @param key - 键 不能为null * @param hashKey - 项 不能为null * @return Object - ...
Redis安装及基本数据类型
09-09
本文将详细介绍Redis的安装过程以及其五种基本数据类型：String、List、Hash、Set和Sorted Set。 **Redis安装** Redis的安装分为Linux和Windows两种平台。在Linux环境下，我们以CentOS为例： 1. 通过`wget`命令...
redis源码资源下载
最新发布
05-24
数据结构丰富：Redis支持多种数据结构，包括字符串（string）、哈希（hash）、列表（list）、集合（set）、有序集合（sorted set）等。这些数据结构都支持丰富的操作，如push/pop、add/remove以及取交集、并集和差集...
redis源码分析教程之压缩链表ziplist详解
12-16
尽管如此，ziplist在内存效率和性能上的优势使其成为Redis中许多数据结构（如list、hash、set和sorted set）在数据量较小的情况下的首选存储方式。 在源码分析中，理解ziplist的结构和编码规则对于优化Redis的性能...
NoSQL数据库之Redis数据库管理一(string类型和hash类型)
02-15
总结，Redis作为NoSQL数据库的一员，凭借其高效、灵活的特性和丰富多样的数据类型，为开发人员提供了强大且便捷的数据管理工具。理解和掌握Redis的使用，对于提升应用程序的性能和扩展性至关重要。
redis-unstable_Redis数据库源码_
09-30
Redis使用多种自定义的数据结构来存储和操作数据，如字符串（String）、哈希表（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。这些数据结构在源码中都有对应的实现，例如` SDS (Simple Dynamic ...
redis hash操作代码梳理
zjjxxl的博客
09-29 136
1、hget deviceinfo:123456 time 2、hgetall deviceinfo:123456 3、hset deviceinfo:123456 time "2013-12-24 12:12:12" 4、hmset subserial 123456 status 1 time "2013-12-24 12:12:12" 5、redis初始化时加载AOF文件执...
c++ unordered_map/set自定义对象的hash
字节跳动 内推找我
01-11 1万+
平时很少用到unordered_set的自定义对象，常用的都是unordered_map<int>, unordered_map<string>之类的内建数据类型。前段时间在写一个编码库的时候，用到了自定义对象，却无从下手，在此对其进行总结。unordered_map/set是采用hash散列进行存储的，因此存储的对象必须提供两个方法，1，hash告知此容器如何生成hash的值，2，equal_to
Hash_Set 基本用法以及自定义实现
zxjzxj1234的专栏
07-10 210
Set与数学中的“集合”对应，特点是无序不可重复。 最常见的实现类就是HashSet。 HashSet底层是通过HashMap实现的。 Eg：HashSet里的add方法是通过Map里的put方法实现的。 public boolean add(E e) { return map.put(e, PRESENT)==null; } package cn.zhouxj.collec...
redis中的hash（哈希） 的一些方法
weixin_42881524的博客
09-05 423
其中的一些API Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。 Set就是一种简化的Hash,只变动key,而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息。 ...
Redis源码和java jdk源码中hashcode的不同实现
无界编程
03-22 2193
一.redis实际上是使用了siphash 这个比较简单，我说的简单是指redis代码比较少不像jdk一样调用C++代码调用栈非常深。 先看这个rehashing.c 主要就是dictKeyHash函数，需要调用dict.h头文件中定义的dictGenHashFunction #include "redis.h" #include "dict.h" void _redisAssert(...
redis中set和hset命令的区别
Sw_Pro的博客
09-27 2552
一、String的set命令 1、Redis set 命令用于设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。 2、以key-value 方式存储无序不重复的数据，存储单个大文本非结构化数据，可以设置过期时间。时间复杂度为 O(1)。 二、Hash的hset命令 1、Redis Hset 命令用于为哈希表中的字段赋值 。如果哈希表不存在，一个新的哈希表被创建...
深入理解redis的hash与set以及中间的zipset
lcarus008的博客
10-20 1077
它将所有的元素紧挨着一起存储，分配的是一块连续的内存。大字典的扩容是比较耗时间的，需要重新申请新的数组，然后将旧字典所有链表中的元 素重新挂接到新的数组下面，这是一个 O(n)级别的操作，作为单线程的 Redis 表示很难承受 这样耗时的过程。所以，在刚才的二级编码中，我们只用图片ID最后3位作为Hash集合的key，也就保证了Hash集合的元素个数不超过1000，同时，我们把hash-max-ziplist-entries设置为1000，这样一来，Hash集合就可以一直使用压缩列表来节省内存空间了。
Redis深入浅出—hash、set
热门推荐
我的博客
08-15 1万+
一 、Hash 1.1 介绍 Redis中的字典采用哈希表作为底层实现，一个哈希表有多个节点，每个节点保存一个键值对。 在Redis源码文件中，字典的实现代码在dict.c和dict.h文件中。 Redis的数据库就是使用字典作为底层实现的，通过key和value的键值对形式，代表了数据库中全部数据。而且，所有对数据库的增、删、查、改的命令，都是建立在对字典的操作上。 同时，字典还是R...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值