Redis — SDS API 详解

最新推荐文章于 2024-04-26 10:19:24 发布
最新推荐文章于 2024-04-26 10:19:24 发布
阅读量475 收藏
点赞数
分类专栏： Redis 文章标签： redis api SDS
原文链接：https://blog.csdn.net/u010765526/article/details/89071207
版权

SDS 数据结构

  • typedef char *sds;
 
struct sdshdr {
    // 记录buf数组中已使用字节的数量
    // 等于SDS所保存字符串的长度
    int len;
    // 记录buf数组中未使用字节的数量
    int free;
    // 字节数组,用于保存字符串
    char buf[];
};

SDS API

  • 函数名称作用复杂度
    sdsnew创建一个包含给定C字符串的SDSO(N)，N为给定C字符串的长度
    sdsempty创建一个不包含任何内容的空SDSO(1)
    sdsfree释放给定的SDSO(N)，N为被释放SDS的长度
    sdslen返回SDS已经使用过的空间字符数O(1)，直接读取SDS的len属性来直接获得
    sdsavail返回SDS中未使用的空间字符数O(1)，直接读取SDS的free属性来直接获得
    sdsdup创建一个给定SDS的副本O(N)，N为给定SDS的长度
    sdsclear清空SDS中字符串保存的内容因为惰性空间释放策略，复杂的为O(1)
    sdscat将C字符串拼接到SDS字符串末尾O(N)，N为被拼接C字符串的长度
    sdscatsds将SDS拼接到另一个SDS中O(N)，N为被拼接SDS字符串的长度
    sdscpy将给定的C字符串复制并覆盖到SDS中的字符串O(N)，N为被复制C字符串的长度
    sdsgrowzero用空字符将SDS扩展至给定的长度O(N)，N为扩展新增的字节数
    sdsrangeSDS区间内的数据保留, 区间之外的数据覆盖或清除O(N)，N为被保留数据的字节数
    sdstrim接受一个SDS和一个C字符串作为参数, 从移除SDS中移除所有在C字符串中出现过的字符O(N^2)，N为给定C字符串的长度
    sdscmp对比两个SDS字符串是否相等O(N)，N为两个SDS中较短的那个SDS的长度

API 实现

  • SDS 创建

    • 创建一个空的sds，len和free都为0，buf数组也为空

    • sds sdsempty(void) {
    return sdsnewlen("",0);
}

    • 创建一个sds（空的或非空）

    • sds sdsnew(const char *init) {
    size_t initlen = (init == NULL) ? 0 : strlen(init);
    return sdsnewlen(init, initlen);
}

    • 其中均会调用sdsnewlen，这个函数主要是分配内存和赋值

    • sds sdsnewlen(const void *init, size_t initlen) {
    struct sdshdr *sh;
 
    sh = malloc(sizeof(struct sdshdr)+initlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (sh == NULL) sdsOomAbort();
#else
    if (sh == NULL) return NULL;
#endif
    sh->len = initlen;
    sh->free = 0;
    if (initlen) {
        if (init) memcpy(sh->buf, init, initlen);
        else memset(sh->buf,0,initlen);
    }
    sh->buf[initlen] = '\0';
    return (char*)sh->buf;
}

  • SDS 长度操作

    • 获取 sds 的数据长度

    • size_t sdslen(const sds s) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    return sh->len;
}

    • 获取 sds 的空闲大小

    • size_t sdsavail(sds s) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    return sh->free;
}

    • 更新 sds 的长度信息

    • void sdsupdatelen(sds s) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    int reallen = strlen(s);
    sh->free += (sh->len-reallen);
    sh->len = reallen;
}

  • SDS 扩容操作

    • static sds sdsMakeRoomFor(sds s, size_t addlen) {
    struct sdshdr *sh, *newsh;
    size_t free = sdsavail(s);
    size_t len, newlen;
 
    if (free >= addlen) return s;
    len = sdslen(s);
    sh = (void*) (s-(sizeof(struct sdshdr)));
    newlen = (len+addlen)*2;   //原先数据+新增数据 的两倍
    newsh = realloc(sh, sizeof(struct sdshdr)+newlen+1);
#ifdef SDS_ABORT_ON_OOM
    if (newsh == NULL) sdsOomAbort();
#else
    if (newsh == NULL) return NULL;
#endif
 
    newsh->free = newlen - len; //两倍数据-原先数据长度，后面free再减去新增数据长度addlen，即可保证free的大小和len的最终的大小相等
    return newsh->buf;
}
    • 函数的参数 addlen是要增加的长度，首先它会跟 free 比较，如果 addlen 小，sds 放得下，无需扩容；如果 addlen 大，则需要扩容，重新分配内存，重新计算的数组大小是原先存放的数据加上新增数据之和的两倍(newlen)，因为一倍给 free，另外一倍存放最终的数据，目前的新 sds 中的free 大小是两倍长度 - 原先的数据大小。

  • SDS 追加在某个SDS的后面

    • sdscat 将字符串 t 追加在具有sds结构的 s 后面，并返回一个sds结构（如果没有扩容就是原先那个sds）
    • sds sdscat(sds s, char *t) {
    return sdscatlen(s, t, strlen(t));
}
    • 其中用到了sdscatlen
    • sds sdscatlen(sds s, void *t, size_t len) {
    struct sdshdr *sh;
    size_t curlen = sdslen(s);
 
    s = sdsMakeRoomFor(s,len);
    if (s == NULL) return NULL;
    sh = (void*) (s-(sizeof(struct sdshdr)));
    memcpy(s+curlen, t, len);
    sh->len = curlen+len;      //最终大小为原先数据长度加上新增的字符串长度
    sh->free = sh->free-len;   //这个len是新增数据长度，sh->free大小是两倍长度减去原先数据长度，再减个len，即为free字段是原先数据长度加上新增的数据长度，保证和最终的sh->len大小一致
    s[curlen+len] = '\0';
    return s;
}

  • SDS 将字符串拷贝到SDS中，会覆盖掉原先的数据

    • sds sdscpy(sds s, char *t) {
    return sdscpylen(s, t, strlen(t));
}
    • sds sdscpylen(sds s, char *t, size_t len) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    size_t totlen = sh->free+sh->len;
 
    if (totlen < len) {
        s = sdsMakeRoomFor(s,len-totlen); //此处应该是len- sh->len
        if (s == NULL) return NULL;
        sh = (void*) (s-(sizeof(struct sdshdr)));
        totlen = sh->free+sh->len; //新的sh->free为两倍大小除去原先的数据长度，sh->len为原先的数据长度，现在相加，totlen值为两倍大小
    }
    memcpy(s, t, len);
    s[len] = '\0';
    sh->len = len;     //最终的sds中的len为拷贝的字符串的长度
    sh->free = totlen-len;   最终的sds中的free也为拷贝的字符串的长度（两倍减去了一倍）
    return s;
}
    • 同样最后会保证 free 的大小和 len 的相同。

  • SDS 通过格式化输出的形式，追加到给定的SDS后

    • sds sdscatprintf(sds s, const char *fmt, ...) {
    va_list ap;
    char *buf, *t;
    size_t buflen = 32;
 
    va_start(ap, fmt);
    while(1) {
        buf = malloc(buflen);
#ifdef SDS_ABORT_ON_OOM
        if (buf == NULL) sdsOomAbort();
#else
        if (buf == NULL) return NULL;
#endif
        buf[buflen-2] = '\0';     //在倒数第二个打上标记，如果被覆盖了说明分配的内存不够
        vsnprintf(buf, buflen, fmt, ap);
        if (buf[buflen-2] != '\0') {
            free(buf);
            buflen *= 2;
            continue;
        }
        break;
    }
    va_end(ap);
    t = sdscat(s, buf);
    free(buf);
    return t;
}
    • 此函数是以格式化输出的形式追加到给定的 sds 后面，首先默认分配32字节的内存，在倒数第二个字节打上结束标记，然后拷贝格式化输出的内容，如果倒数第二个字节被覆盖，说明分配的大小不够，采取的策略是翻倍尝试，最后调用前面的 sdscat 追加。

  • SDS 比较两个SDS

    • int sdscmp(sds s1, sds s2) {
    size_t l1, l2, minlen;
    int cmp;
 
    l1 = sdslen(s1);
    l2 = sdslen(s2);
    minlen = (l1 < l2) ? l1 : l2;
    cmp = memcmp(s1,s2,minlen);
    if (cmp == 0) return l1-l2;
    return cmp;
}
    • sds s1和s2保存的字符串长度可能不一样，如果长度一样的话，直接调用 memcmp 比较即可，如果不一样的话，首先需要计算出较小的长度 minlen，调用 memcmp 比较前 minlen 个字符串，如果前 minlen 个不一样的话，直接返回比较结果（此时已出胜负），如果前 minlen 个是一样的，则较长的为大。

  • SDS 对给定的字符串按给定的 sep 分隔符来切割

    • /* Split 's' with separator in 'sep'. An array
 * of sds strings is returned. *count will be set
 * by reference to the number of tokens returned.
 *
 * On out of memory, zero length string, zero length
 * separator, NULL is returned.
 *
 * Note that 'sep' is able to split a string using
 * a multi-character separator. For example
 * sdssplit("foo_-_bar","_-_"); will return two
 * elements "foo" and "bar".
 *
 * This version of the function is binary-safe but
 * requires length arguments. sdssplit() is just the
 * same function but for zero-terminated strings.
 */
sds *sdssplitlen(char *s, int len, char *sep, int seplen, int *count) {
    int elements = 0, slots = 5, start = 0, j;
 
    sds *tokens = malloc(sizeof(sds)*slots);
#ifdef SDS_ABORT_ON_OOM
    if (tokens == NULL) sdsOomAbort();
#endif
    if (seplen < 1 || len < 0 || tokens == NULL) return NULL;
    for (j = 0; j < (len-(seplen-1)); j++) {
        /* make sure there is room for the next element and the final one */
        if (slots < elements+2) {
            slots *= 2;
            sds *newtokens = realloc(tokens,sizeof(sds)*slots);
            if (newtokens == NULL) {
#ifdef SDS_ABORT_ON_OOM
                sdsOomAbort();
#else
                goto cleanup;
#endif
            }
            tokens = newtokens;
        }
        /* search the separator */
        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
            tokens[elements] = sdsnewlen(s+start,j-start);
            if (tokens[elements] == NULL) {
#ifdef SDS_ABORT_ON_OOM
                sdsOomAbort();
#else
                goto cleanup;
#endif
            }
            elements++;
            start = j+seplen;
            j = j+seplen-1; /* skip the separator */
        }
    }
    /* Add the final element. We are sure there is room in the tokens array. */
    tokens[elements] = sdsnewlen(s+start,len-start);
    if (tokens[elements] == NULL) {
#ifdef SDS_ABORT_ON_OOM
                sdsOomAbort();
#else
                goto cleanup;
#endif
    }
    elements++;
    *count = elements;
    return tokens;
 
#ifndef SDS_ABORT_ON_OOM
cleanup:
    {
        int i;
        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
        free(tokens);
        return NULL;
    }
#endif
}
    • 比如字符串 foo_-_bar_-_fun使用分割符_-_，分割符长度是3，最后得到3个（count的值）sds *结构的 tokens，tokens[0] 存放的是sds结构的 foo，tokens[1] 存放的是 sds 结构的 bar，tokens[2] 存放的是 sds 结构的 foo。

  • SDS 字符串范围操作

    • sdsrange----截取给定的sds，[start, end]字符串。如start为3，表示字符串中第4个字符，字符串下标从0开始，如为-1，表示是最后一个字符，同理-2表示倒数第2个字符。
    • sds sdsrange(sds s, long start, long end) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    size_t newlen, len = sdslen(s);
 
    if (len == 0) return s;
    if (start < 0) {
        start = len+start;
        if (start < 0) start = 0;
    }
    if (end < 0) {
        end = len+end;
        if (end < 0) end = 0;
    }
    newlen = (start > end) ? 0 : (end-start)+1;
    if (newlen != 0) {
        if (start >= (signed)len) start = len-1;
        if (end >= (signed)len) end = len-1;
        newlen = (start > end) ? 0 : (end-start)+1;
    } else {
        start = 0;
    }
    if (start != 0) memmove(sh->buf, sh->buf+start, newlen);
    sh->buf[newlen] = 0;
    sh->free = sh->free+(sh->len-newlen);
    sh->len = newlen;
    return s;
}
    •  sdstrim---对给定sds，删除前端/后端在给定的C字符串中出现过的字符。
    • sds sdstrim(sds s, const char *cset) {
    struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
    char *start, *end, *sp, *ep;
    size_t len;
 
    sp = start = s;
    ep = end = s+sdslen(s)-1;
    while(sp <= end && strchr(cset, *sp)) sp++;
    while(ep > start && strchr(cset, *ep)) ep--;
    len = (sp > ep) ? 0 : ((ep-sp)+1);
    if (sh->buf != sp) memmove(sh->buf, sp, len);
    sh->buf[len] = '\0';
    sh->free = sh->free+(sh->len-len);
    sh->len = len;
    return s;
}

  • SDS 复制操作

    • 返回一个新的sds，内容与给定的 s 相同。
    • sds sdsdup(const sds s) {
    return sdsnewlen(s, sdslen(s));
}

  • SDS 释放操作

    • void sdsfree(sds s) {
    if (s == NULL) return;
    free(s-sizeof(struct sdshdr));
}

 

Future_LL
关注
专栏目录
redis--sds API 详解
sanliangGoGoGo
04-07 1398
1，sds 数据结构 typedef char *sds; struct sdshdr { long len; long free; char buf[0]; }; 注意：sizeof（struct sdshdr）的大小只包括 sizeof（len）和sizeof（free），不含buf数组，buf数组的内存紧随这个结构体后面。 2，sds API 函数名称...
Redis中简单动态字符串SDS详解
iiiiilllllll的博客
02-26 324
什么时候会触发?SDS的API修改SDS的时候,并且需要对SDS进行扩容那什么时候SDS会进行扩容?SDS的free空间不够时那在扩展的时候会做些什么?除了分配修改所需要的空间,还会为SDS分配额外的未使用的空间会分配多大的额外未使用的空间呢?要分为两种情况,有效长度小于1MB和大于1MB小于1MB呢?新字符串的有效长度小于1MB,额外空间和新字符串的有效长度一样,比如新的有效长度为13,那么SDS的实际长度为len+free+1=13+13+1=27字节。
Redis的数据结构之SDS及常用API
Cyrus_wen的博客
03-10 528
Redis的数据结构之SDS Redis没有使用C语言风格的字符串， 而是使用了一种叫SDS的简单动态字符串。 C风格的字符串用来作为字符串字面量， 比如打印日志。当表示一个可以被修改的字符串的时候， redis会用SDS表示。 redis是key_value型数据库， 它的key和value都是一个对象。 SDS除了保存数据库中的字符串外还用作缓冲区（buffer）: AOF模块中的A...
redis中SDS实现
sysucph的专栏
06-23 973
sds（simple dynamic string）是Redis自己构建的字符串，作为Redis默认的字符串表示。/* * 类型别名，用于指向 sdshdr 的 buf 属性 */typedef char *sds;/* * 保存字符串对象的结构 */struct sdshdr {        // buf 中已占用空间的长度    int len;    // buf 中剩余可用空间的长度  ...
redis源码分析(2)——SDS API详解
李余通的博客
12-19 603
源码分析章节，我尽量使用原生的redis源码，不去看黄建宏的注释，提高自己阅读源码的能力，此外，redis版本还是3.0 源码下载，大家可以到这 http://download.redis.io/releases/ sdsnewtypedef char *sds;sds sdsnewlen(const void *init, size_t initlen) { struct sdshd
底层实现-SDS 简单动态字符串
@DBA_白老大
05-30 1251
一 介绍 Redis只会使用C字符串作为字面量，大多数情况下，Redis使用SDS(Simple Dynamic String，简单动态字符串）作为字符串表示。也就是说，Redis中字符串的底层实现，一般就是SDS。底层依赖于C的标准类型 - 数组。 SDS与C字符串的不同 获取字符串长度更容易         SDS加了元数据len与f
Redis SDS简单动态字符串与C字符串的区别
MSSPLANET的博客
02-01 1719
本文只解析SDS与C字符串区别，建议搭配相关实现源码阅读，关于SDS源码实现，可以参考笔者之前的文章Redis 5.0数据结构之SDS简单动态字符串实现源码详解 SDS概述 Redis基于C语言实现，但Redis并没有采用C语言中传统的字符串表示，而是特别构建了一种叫做简单动态字符串（simple dynamic string）的数据结构，简称SDS，SDS是Redis中默认的字符串表示。 C字符串只在无须对字符串值修改的场景下作为字面量使用，如日志打印，而在字符串值可能被修改的场景下，均使用SDS表示字符
redis内部数据结构之SDS简单动态字符串详解
12-16
此外，SDS还有其他优点，例如提供API来直接获取字符串长度、方便地进行字符串增长和缩短操作，以及避免了内存碎片问题，因为Redis在扩展字符串时会一次性分配足够大的空间。 总的来说，Redis的SDS数据结构是其核心...
Redis源码阅读——SDS
qq_33620071的博客
10-29 713
Redis源码阅读——SDS 参考Redis设计与实现 以及网上博客阅读Redis源码。 SDS相关知识点见读书笔记。 创建和销毁 为了能够对sds进行相关API的测试，因此把sds模块单独提出来。阅读Redis的Makefile发现，编译sds模块需要的源文件包括sds.c, sds.h zmalloc.c test-sds: sds.c sds.h $(REDIS_CC) s...
Redis提供的API
猴子哥哥的博客
09-24 714
Redis提供的API分类整理
Redis源代码分析之五：简单动态字符串——Sds
Aegeaner的专栏
02-04 2349
一个Redis字符串的结构体定义是： struct sdshdr { int len; int free; char buf[]; }; 其中buf字符数组中储存实际的字符串。len变量保存字符串的长度。free变量指出还有多少字节可用。 sds被定义为一种新的数据类型，实际就是字符指针： typedef char *sds; 例如，sdsnewlen
Redis教程｛2｝redis设计与实现
极客蓝天
03-27 1339
SDS 与 C 字符串的区别 根据传统， C 语言使用长度为 N+1 的字符数组来表示长度为 N 的字符串， 并且字符数组的最后一个元素总是空字符 '\0' 。 比如说， 图 2-3 就展示了一个值为 "Redis" 的 C 字符串： C 语言使用的这种简单的字符串表示方式， 并不能满足 Redis 对字符串在安全性、效率、以及功能方面的要求， 本节接下来的内容将详细对比
Redis 实战 - SDS API
最新发布
qq_33240556的博客
04-26 355
Redis 使用 SDS API 来创建、管理和操作其内部的 Simple Dynamic String (SDS) 数据结构。SDS API 通过预先分配额外空间、记录字符串长度、支持二进制数据等方式，解决了传统 C 字符串存在的诸多问题，提升了 Redis 在处理字符串时的性能和安全性。
redis api 中文文档_Redis都要老了，你还在用什么古董客户端？
weixin_39957265的博客
12-03 119
不羡鸳鸯不羡仙，一行代码调半天。原创：小姐姐味道（微信公众号ID：xjjdog），欢迎分享，转载请保留出处。前几日，Redis 创始人 Antirez 在他的个人博客上宣布将结束自己的 Redis 之旅！大神累了，Redis老了，但Redis依旧很火。Redis的Java客户端有很多，比如jedis、redisson、lettuce等。那大家都在用啥呢？今天xjjdog做了一个小调查。下面是统计结...
Redis深入浅出——字符串和SDS
热门推荐
我的博客
08-15 2万+
一、字符串 字符串的类信息定义 1.1 字符串介绍 字符串是Redis中最为常见的数据存储类型，其底层实现是简单动态字符串sds(simple dynamic string)，是可以修改的字符串。 它类似于Java中的ArrayList，它采用预分配冗余空间的方式来减少内存的频繁分配。 如图中所示，内部为当前字符串实际分配的空间 。其中capacity是最大容量，len是实际长度...
Redis API接口缓存优化实战
小青蛙的博客
08-29 2627
Redis 缓存请求内容，优化 API 接口性能 在我们日常的接口开发过程中，或者第三方请求的过程中，每次刷新页面都会重新请求接口，而且大部分接口短时间内是不会变化的； 在某些场景下，我们需要转发某些第三方的API接口；所以在多次请求的情况下，就会造成很大资源浪费，也不利于WEB应用交互性能优化； 我们这章节呢，将会使用Redis对第三方请求内容做个一个定期缓存，在某个时限内，我们将会直接从本地...
Redis（五）-Redis的String字符串的数据结构之简单动态字符串
码农飞哥
07-18 2518
本文主要介绍了Redis数据库用来存储字符串对象的数据结构---简单动态字符串SDS，SDS相对于C语言传统的字符串优势明显，主要表现在杜绝缓存去内存溢出，减少字符串操作的内存重分配，二进制安全。
java redis 命令_命令界面：使用Java中的动态API处理Redis
最佳 Java 编程
06-28 666
java redis 命令 Redis是一个数据存储，支持190多个文档化命令和450多个命令排列。 社区积极支持Redis开发； 每个主要的Redis版本都附带新命令。 今年，Redis向第三方供应商开放，以开发可扩展Redis功能的模块。 对于客户端开发人员和Redis用户而言，命令的增长以及对即将发布的模块的跟踪是一项挑战。 命令增长 对于客户端库，Redis中的命令增长是一项具有挑...
redis协议的解析
azurelaker的博客
08-11 2168
操作string类型value的redis命令主要包括set,get,setnx,incr和decr. redis 命令不区分大小写,这里均以小写格式说明. redis set命令 redis set命令的格式为set key bytes\r\nxxxxxx\r\n 命令字符串,key和value之间以空格分割, set命令是buld类型的命令,其value部分由四部分组成, bytes代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值