Redis学习之5种数据类型操作、实现原理及应用场景详解数据库

 1）赋值：SET key value。如set hello world 
 2）取值：GET key。如get hello。返回是world 
 3）自增：INCR key。就是Mysql的AUTO_INCREMENT。每次执行INCR key时，该key的值都会+1.若key不存在，则先建立一个0，然后+1，返回1。
　　　　如果值不是整数则报错。该操作是原子操作。 
 4）自减：DECR key。将指定key的值减少1.如DECR num，就是num-1 
 5）自增N：INCRBY key increment用来给指定key的值加increment。如INCRBY num 5就是num+5 
 6）自减N：DECRBY key increment用来给指定key的值减increment。如DECRBY num 5就是num-5 
 7）增加浮点数：INCRBYFLOAT key increment。 
 8）向尾部追加：APPEND key value。如set test:key 123     append test:key 456      get test:key就是123456 
 9）获取长度：STRLEN key。 
 10）同时给多个key 赋值：MSET title 这是标题 description 这是描述 content 这是内容。 
 11）同时获取多个key的值：MGET title description content 
 12）位操作之获取：GETBIT key offset。如字符a在redis中的存储为01100001（ASCII为98），那么GETBIT key 2就是1，GET key 0就是0。 
 13）位操作之设置：SETBIT key offset value。如字符a在redis中的存储为01100001（ASCII为98），那么SETBIT key 6 0，SETBIT key 5 1
　　　　那么get key得到的是b。因为取出的二进制为01100010。 
 14）位操作之统计：BITCOUNT key [start] [end]：BITCOUNT key用来获取key的值中二进制是1的个数。而BITCOUNT key start end则是用来
　　　　统计key的值中在第start和end之间的子字符串的二进制是1的个数（好绕啊）。 
 15）位操作之位运算：BITOP operation resultKey key1 key2。operation是位运算的操作，有AND，OR，XOR，NOT。resultKey是把运算结构
　　　　存储在这个key中，key1和key2是参与运算的key，参与运算的key可以指定多个。

1）向头部插入：LPUSH key value1 value2...。返回增加后的列表长度。 
2）向尾部插入：RPUSH key value1 value2...。返回增加后的列表长度。 
3）从头部弹出：LPOP key。返回被弹出的元素值。该操作先删除key列表的第一个元素，再将它返回。 
4）从尾部弹出：RPOP key。返回被弹出的元素值。 
5）列表元素个数：LLEN key。key不存在返回0。 
6）获取列表的子列表：LRANGE start end。返回第start个到第end个元素的列表。包含start和end。支持负数索引。-1表示最后一个元素，-2表示倒数
　　　　第二个元素。 
7）删除列表中指定值：LREM key count value。删除key这个列表中，所有值为value的元素，只删除count。如果有count+1个，那么就保留最后一个。
　　　　count不存在或者为0，则删除所有的。如果count大于0，则删除从头到尾的count个，如果count小于0，则删除从尾到头的count个。 
8）获取指定索引值：LINDEX key index。如LINDEX key 0就是列表的第一个元素。index可以是负数。 
9）设置索引和值：LSET key index value。这个操作只是修改指定key且指定index的值。如果index不存在，则报错。 
10）保留片段，删除其它：LTRIM key start end。保留start到end之间的所有元素，含start和end。其他全部删除。 
11）向列表插入元素：LINSERT key BEFORE/AFTER value1 value2。从列表头开始遍历，发现值为value1时停止，将value2插入，根据BEFORE
　　　　或者AFTER插入到value1的前面还是后面。 
12）把一个列表的一个元素转到另一个列表：RPOPLPUSH list1 list2。将列表list1的右边元素删除，并把该与元素插入到列表list2的左边。原子操作。

1）增加：SADD key value。 
2）删除：SREM key value。 
3）获取指定集合的所有元素：SMEMBERS key。 
4）判断某个元素是否存在：SISMEMBER key value。 
5）差集运算：SDIFF key1 key2...。对多个集合进行差集运算。 
6）交集运算：SINNER key1 key2...。对多个集合进行交集运算。 
7）并集运算：SUNION key1 key2...。对多个集合进行并集运算。 
8）获取集合中元素个数：SCARD key。返回集合中元素的总个数。 
9）对差集、交集、并集运算的结果存放在一个指定的key中：SDIFFSTORE storekey key1 key2。对key1和key2求差集，结果存放在key为storekey的
　　　　集合中。SINNERSTORE和SUNIONSTORE类似。 
10）获取集合中的随即元素：SRANDMEMBER key [count]。参数count可选，如果count不存在，则随即一个。count大于0，则是不重复的count个元素。
　　　　count小于0，则是一共|count|个元素，可以重复。 
11）随即弹出一个元素：SPOP key。随即从集合中弹出一个元素并删除，将该元素的值返回。

1）赋值：HSET key field value。如hset user name lane。hset user age 23 
2）取值：HGET key field。如hget user name，得到的是lane。 
3）同一个key多个字段赋值：HMSET key field1 value1 field2 value2... 
4）同一个KEY多个字段取值：HMGET key field1 fields2... 
5）获取KEY的所有字段和所有值：HGETALL key。如HGETALL user得到的是name lane age 23。每个返回都是独立的一行。 
6）字段是否存在：HEXISTS key field。存在返回1，不存在返回0 
7）当字段不存在时赋值：HSETNX key field value。如果key下面的字段field不存在，则建立field字段，且值为value。如果field字段存在，则不执行
　　　　任何操作。它的效果等于HEXISTS + HSET。但是这个命令的优点是原子操作。再高的并发也不会怕怕。 
8）自增N：HINCREBY key field increment。同字符串的自增类型，不再阐述。 
9）删除字段：DEL key field1 field2...删除指定KEY的一个或多个字段。 
10）只获取字段名：HKEYS key。与HGETALL类似，但是只获取字段名，不获取字段值。 
11）只获取字段值：HVALS key。与HGETALL类似，但是只获取字段值，不获取字段名。 
12）获取字段数量：HLEN key。

struct dictht { 
    dictEntry **table;     //entry 数组 
    long size;            //数组长度 
    long used            //数组中的元素个数 
    ... 
} 
struct dictEntry{ 
    void *key;                //hash 的 key 
    void *val;                //hash 的 value 
    dictEntry *next;          //下一个dictEntry 链表结构 
}

1）增加：ZADD key sorce1 value1 sorce2 value2...。 
2）获取分数：ZSCORE key value。获取key的有序集合中值为value的元素的分数。 
3）获取排名在某个范围内的元素列表：ZRANFGE key start stop [WITHSCORE]。获取排名在start和end之间的元素列表，包含start和end2个元素。
　　　　每个元素一行。如果有WITHSCORE参数，则一行元素值，一行分数。时间复杂度为O(LOGn+m)。如果分数相同，则0<0<A<Z<a<z。 
4）获取指定分数范围的元素：ZRANGEBYSCORE key min max [WITHSCORE] [LIMIT offset count]。获取分数在min和max之间的元素列表。含两头。
　　　　每个元素一行。如果有WITHSCORE参数，则一行元素值，一行分数。如果min大于max则顺序反转。 
5）为某个元素增加分数：ZINCRBY key increment value。指定的有序集合的值为value的元素的分数+increment。返回值后更改后的分数。 
6）获取集合中元素的数量：ZCARD key。 
7）获取指定分数范围内的元素个数：ZCOUNT key min max。 
8）删除一个或多个元素：ZREM key value1 value2... 
9）根据排名范围删除元素：ZREMRANGEBYRANK key start end。删除排名在start和end中的元素。 
10）按照分数范围删除元素：ZREMRANGEBYSCORE key min max。 
11）获得元素排名（正序）：ZRANK key value。获取value在该集合中的从小到大的排名。 
12）获得元素排名（倒序）：ZREVRANK key value。获取value在该集合中从大到小的排名。 
13）有序集合的交集：ZINTERSTORE storekey key1 key2...[WEIGHTS weight [weight..]] [AGGREGATE SUM|MIN|MAX]。用来计算多个集合的交集，
　　　　结果存储在storekey中。返回值是storekey的元素个数。AGGREGATE为SUM则storekey集合的每个元素的分数是参与计算的集合分数和。MIN是参
　　　　与计算的分数最小值。MAX是参与计算分数最大值。WEIGHTS 设置每个集合的权重，如WEIGHTS 1 0.1。那么集合A的每个元素分数*1，集合B的每
　　　　个元素分数*0.1 
14）有序集合的并集：ZUNIONSTORE storekey key1 kye2...[WEIGHTS weight [weight..]] [AGGREGATE SUM|MIN|MAX]

//  ziplist的成员宏定义 
//  (*((uint32_t*)(zl))) 先对char *类型的zl进行强制类型转换成uint32_t *类型， 
//  然后在用*运算符进行取内容运算，此时zl能访问的内存大小为4个字节。 
  
#define ZIPLIST_BYTES(zl)       (*((uint32_t*)(zl))) 
//将zl定位到前4个字节的bytes成员，记录这整个压缩列表的内存字节数 
  
#define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t)))) 
//将zl定位到4字节到8字节的offset成员，记录着压缩列表尾节点距离列表的起始地址的偏移字节量 
  
#define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2))) 
//将zl定位到8字节到10字节的length成员，记录着压缩列表的节点数量 
  
#define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t)) 
//压缩列表表头（以上三个属性）的大小10个字节 
  
#define ZIPLIST_ENTRY_HEAD(zl)  ((zl)+ZIPLIST_HEADER_SIZE) 
//返回压缩列表首节点的地址 
  
#define ZIPLIST_ENTRY_TAIL(zl)  ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))) 
//返回压缩列表尾节点的地址 
  
#define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1) 
//返回end成员的地址，一个字节。 
  
/* We know a positive increment can only be 1 because entries can only be 
 * pushed one at a time. */ 
#define ZIPLIST_INCR_LENGTH(zl,incr) {         //增加节点数  
    if (ZIPLIST_LENGTH(zl) < UINT16_MAX)       //如果当前节点数小于65535，那么给length成员加incr个节点   
        ZIPLIST_LENGTH(zl) = intrev16ifbe(intrev16ifbe(ZIPLIST_LENGTH(zl))+incr);  
}