数据库压缩到底怎么做？只针对string和list的库压value

2024-06-30 16:43:34 [百科] 来源：避面尹邢网

数据库压缩到底怎么做？

作者：佚名 2021-10-12 10:22:33运维数据库运维 redis的数据缩压缩是针对key的压缩，只针对string和list的库压value，需要配置文件配置rdb_compression rdb压缩才会生效。数据缩

redis

redis的库压压缩是针对key的压缩

数据库压缩到底怎么做？只针对string和list的库压value

只针对string和list的value

数据库压缩到底怎么做？只针对string和list的库压value

所有的压缩最终都会调用lzf_compress/lzf_decompress

数据库压缩到底怎么做？只针对string和list的库压value

需要配置文件配置rdb_compression rdb压缩才会生效

lzf压缩限制长度要大于20，即使是数据缩aaaaaaaaaaaaaaaaaaaa也压不了，大于20才能压。库压原因没有深究

rdb内部的数据缩压缩

如何确认这个record是被压缩/解压的？

rdb解析每条数据，都有标识字段，库压压缩的数据缩record自然是单独的类型

ssize_t rdbSaveLzfStringObject(rio *rdb, unsigned char *s, size_t len) {  
... 
    comprlen = lzf_compress(s, len, out, outlen); 
    if (comprlen == 0) {  
        zfree(out); 
        return 0; 
    } 
    ssize_t nwritten = rdbSaveLzfBlob(rdb, out, comprlen, len); 
... 
} 
 
ssize_t rdbSaveLzfBlob(rio *rdb, void *data, size_t compress_len, 
                       size_t original_len) {  
... 
    /* Data compressed! Let's save it on disk */ 
    byte = (RDB_ENCVAL<<6)|RDB_ENC_LZF; 
    if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) goto writeerr; 
    nwritten += n; 
... 
}

解压缩

void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr) {  
... 
    if (isencoded) {  
        switch(len) {  
        case RDB_ENC_INT8: 
        case RDB_ENC_INT16: 
        case RDB_ENC_INT32: 
            return rdbLoadIntegerObject(rdb,len,flags,lenptr); 
        case RDB_ENC_LZF: 
            return rdbLoadLzfStringObject(rdb,flags,lenptr); 
        default: 
            rdbReportCorruptRDB("Unknown RDB string encoding type %llu",len); 
            return NULL; 
        } 
    } 
 ... 
  
 void *rdbLoadLzfStringObject(rio *rdb, int flags, size_t *lenptr) {  
... 
 
    /* Load the compressed representation and uncompress it to target. */ 
    if (rioRead(rdb,c,clen) == 0) goto err; 
    if (lzf_decompress(c,clen,val,len) != len) {  
        rdbReportCorruptRDB("Invalid LZF compressed string"); 
... 
}

接口简单容易定位

所有的类型string/hash具体到底层，都是库压string，就会走这个压缩的数据缩过程rdbSaveRawString,内部来调用rdbSaveLzfStringObject

ssize_t rdbSaveObject(rio *rdb, robj *o, robj *key, int dbid) {  
    ssize_t n = 0, nwritten = 0; 
 
    if (o->type == OBJ_STRING) {  
        /* Save a string value */ 
        if ((n = rdbSaveStringObject(rdb,o)) == -1) return -1; 
        nwritten += n; 
    } else if (o->type == OBJ_LIST) {  
 
                if (quicklistNodeIsCompressed(node)) {  
                    void *data; 
                    size_t compress_len = quicklistGetLzf(node, &data); 
                    if ((n = rdbSaveLzfBlob(rdb,data,compress_len,node->sz)) == -1) return -1; 
                    nwritten += n; 
                } else {  
                    if ((n = rdbSaveRawString(rdb,node->zl,node->sz)) == -1) return -1; 
                    nwritten += n; 
                } 
                node = node->next; 
            } 
        } else {  
            serverPanic("Unknown list encoding"); 
        } 
。。库压。数据缩 
}

quicklist的库压压缩

链表压缩可以选择深度，quicklist是数据缩redis list的底层数据结构

什么时候做压缩？

/* Insert 'new_node' after 'old_node' if 'after' is 1. 
 * Insert 'new_node' before 'old_node' if 'after' is 0. 
 * Note: 'new_node' is *always* uncompressed, so if we assign it to 
 *       head or tail, we do not need to uncompress it. */ 
REDIS_STATIC void __quicklistInsertNode(quicklist *quicklist, 
                                        quicklistNode *old_node, 
                                        quicklistNode *new_node, int after) {  
    if (after) {  
        new_node->prev = old_node; 
        if (old_node) {  
            new_node->next = old_node->next; 
            if (old_node->next) 
                old_node->next->prev = new_node; 
            old_node->next = new_node; 
        } 
        if (quicklist->tail == old_node) 
            quicklist->tail = new_node; 
    } else {  
        new_node->next = old_node; 
        if (old_node) {  
            new_node->prev = old_node->prev; 
            if (old_node->prev) 
                old_node->prev->next = new_node; 
            old_node->prev = new_node; 
        } 
        if (quicklist->head == old_node) 
            quicklist->head = new_node; 
    } 
    /* If this insert creates the only element so far, initialize head/tail. */ 
    if (quicklist->len == 0) {  
        quicklist->head = quicklist->tail = new_node; 
    } 
 
    /* Update len first, so in __quicklistCompress we know exactly len */ 
    quicklist->len++; 
 
    if (old_node) 
        quicklistCompress(quicklist, old_node); 
}