Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Newer
Older
100644 448 lines (401 sloc) 16.28 kB
eb46f4b @antirez initial zipmap.c implementation
authored
1 /* String -> String Map data structure optimized for size.
2 * This file implements a data structure mapping strings to other strings
3 * implementing an O(n) lookup data structure designed to be very memory
4 * efficient.
5 *
6 * The Redis Hash type uses this data structure for hashes composed of a small
7 * number of elements, to switch to an hash table once a given number of
8 * elements is reached.
9 *
10 * Given that many times Redis Hashes are used to represent objects composed
11 * of few fields, this is a very big win in terms of used memory.
12 *
13 * --------------------------------------------------------------------------
14 *
15 * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are met:
20 *
21 * * Redistributions of source code must retain the above copyright notice,
22 * this list of conditions and the following disclaimer.
23 * * Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * * Neither the name of Redis nor the names of its contributors may be used
27 * to endorse or promote products derived from this software without
28 * specific prior written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
31 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
34 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
38 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGE.
41 */
42
43 /* Memory layout of a zipmap, for the map "foo" => "bar", "hello" => "world":
44 *
45 * <status><len>"foo"<len><free>"bar"<len>"hello"<len><free>"world"
46 *
47 * <status> is 1 byte status. Currently only 1 bit is used: if the least
48 * significant bit is set, it means the zipmap needs to be defragmented.
49 *
50 * <len> is the length of the following string (key or value).
51 * <len> lengths are encoded in a single value or in a 5 bytes value.
52 * If the first byte value (as an unsigned 8 bit value) is between 0 and
53 * 252, it's a single-byte length. If it is 253 then a four bytes unsigned
54 * integer follows (in the host byte ordering). A value fo 255 is used to
55 * signal the end of the hash. The special value 254 is used to mark
56 * empty space that can be used to add new key/value pairs.
57 *
58 * <free> is the number of free unused bytes
59 * after the string, resulting from modification of values associated to a
60 * key (for instance if "foo" is set to "bar', and later "foo" will be se to
61 * "hi", I'll have a free byte to use if the value will enlarge again later,
62 * or even in order to add a key/value pair if it fits.
63 *
64 * <free> is always an unsigned 8 bit number, because if after an
65 * update operation there are more than a few free bytes, they'll be converted
66 * into empty space prefixed by the special value 254.
67 *
68 * The most compact representation of the above two elements hash is actually:
69 *
be0af2f @antirez minor fixes for zipmap.c
authored
70 * "\x00\x03foo\x03\x00bar\x05hello\x05\x00world\xff"
eb46f4b @antirez initial zipmap.c implementation
authored
71 *
72 * Empty space is marked using a 254 bytes + a <len> (coded as already
73 * specified). The length includes the 254 bytes in the count and the
74 * space taken by the <len> field. So for instance removing the "foo" key
75 * from the zipmap above will lead to the following representation:
76 *
be0af2f @antirez minor fixes for zipmap.c
authored
77 * "\x00\xfd\x10........\x05hello\x05\x00world\xff"
eb46f4b @antirez initial zipmap.c implementation
authored
78 *
79 * Note that because empty space, keys, values, are all prefixed length
80 * "objects", the lookup will take O(N) where N is the numeber of elements
81 * in the zipmap and *not* the number of bytes needed to represent the zipmap.
82 * This lowers the constant times considerably.
83 */
84
85 #include <stdio.h>
86 #include <string.h>
87 #include <assert.h>
88 #include "zmalloc.h"
89
90 #define ZIPMAP_BIGLEN 253
91 #define ZIPMAP_EMPTY 254
92 #define ZIPMAP_END 255
93
94 #define ZIPMAP_STATUS_FRAGMENTED 1
95
96 /* The following defines the max value for the <free> field described in the
97 * comments above, that is, the max number of trailing bytes in a value. */
98 #define ZIPMAP_VALUE_MAX_FREE 5
99
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
100 /* The following macro returns the number of bytes needed to encode the length
101 * for the integer value _l, that is, 1 byte for lengths < ZIPMAP_BIGLEN and
102 * 5 bytes for all the other lengths. */
103 #define ZIPMAP_LEN_BYTES(_l) (((_l) < ZIPMAP_BIGLEN) ? 1 : sizeof(unsigned int)+1)
104
eb46f4b @antirez initial zipmap.c implementation
authored
105 /* Create a new empty zipmap. */
106 unsigned char *zipmapNew(void) {
107 unsigned char *zm = zmalloc(2);
108
109 zm[0] = 0; /* Status */
110 zm[1] = ZIPMAP_END;
111 return zm;
112 }
113
114 /* Decode the encoded length pointed by 'p' */
115 static unsigned int zipmapDecodeLength(unsigned char *p) {
116 unsigned int len = *p;
117
118 if (len < ZIPMAP_BIGLEN) return len;
ad6de43 @antirez zipmap fix for large values
authored
119 memcpy(&len,p+1,sizeof(unsigned int));
eb46f4b @antirez initial zipmap.c implementation
authored
120 return len;
121 }
122
123 /* Encode the length 'l' writing it in 'p'. If p is NULL it just returns
124 * the amount of bytes required to encode such a length. */
125 static unsigned int zipmapEncodeLength(unsigned char *p, unsigned int len) {
126 if (p == NULL) {
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
127 return ZIPMAP_LEN_BYTES(len);
eb46f4b @antirez initial zipmap.c implementation
authored
128 } else {
129 if (len < ZIPMAP_BIGLEN) {
130 p[0] = len;
131 return 1;
132 } else {
133 p[0] = ZIPMAP_BIGLEN;
134 memcpy(p+1,&len,sizeof(len));
135 return 1+sizeof(len);
136 }
137 }
138 }
139
140 /* Search for a matching key, returning a pointer to the entry inside the
141 * zipmap. Returns NULL if the key is not found.
142 *
143 * If NULL is returned, and totlen is not NULL, it is set to the entire
144 * size of the zimap, so that the calling function will be able to
145 * reallocate the original zipmap to make room for more entries.
146 *
147 * If NULL is returned, and freeoff and freelen are not NULL, they are set
148 * to the offset of the first empty space that can hold '*freelen' bytes
149 * (freelen is an integer pointer used both to signal the required length
150 * and to get the reply from the function). If there is not a suitable
151 * free space block to hold the requested bytes, *freelen is set to 0. */
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
152 static unsigned char *zipmapLookupRaw(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned int *totlen) {
153 unsigned char *p = zm+1, *k = NULL;
eb46f4b @antirez initial zipmap.c implementation
authored
154 unsigned int l;
155
156 while(*p != ZIPMAP_END) {
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
157 unsigned char free;
158
159 /* Match or skip the key */
160 l = zipmapDecodeLength(p);
161 if (k == NULL && l == klen && !memcmp(p+1,key,l)) {
162 /* Only return when the user doesn't care
163 * for the total length of the zipmap. */
164 if (totlen != NULL) {
165 k = p;
166 } else {
167 return p;
eb46f4b @antirez initial zipmap.c implementation
authored
168 }
169 }
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
170 p += zipmapEncodeLength(NULL,l) + l;
171 /* Skip the value as well */
172 l = zipmapDecodeLength(p);
173 p += zipmapEncodeLength(NULL,l);
174 free = p[0];
175 p += l+1+free; /* +1 to skip the free byte */
eb46f4b @antirez initial zipmap.c implementation
authored
176 }
177 if (totlen != NULL) *totlen = (unsigned int)(p-zm)+1;
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
178 return k;
eb46f4b @antirez initial zipmap.c implementation
authored
179 }
180
181 static unsigned long zipmapRequiredLength(unsigned int klen, unsigned int vlen) {
182 unsigned int l;
183
184 l = klen+vlen+3;
185 if (klen >= ZIPMAP_BIGLEN) l += 4;
186 if (vlen >= ZIPMAP_BIGLEN) l += 4;
187 return l;
188 }
189
8ec0832 @antirez first zipmap fix of a long sequence in the days to come ;)
authored
190 /* Return the total amount used by a key (encoded length + payload) */
eb46f4b @antirez initial zipmap.c implementation
authored
191 static unsigned int zipmapRawKeyLength(unsigned char *p) {
192 unsigned int l = zipmapDecodeLength(p);
193
194 return zipmapEncodeLength(NULL,l) + l;
195 }
196
8ec0832 @antirez first zipmap fix of a long sequence in the days to come ;)
authored
197 /* Return the total amount used by a value
eb46f4b @antirez initial zipmap.c implementation
authored
198 * (encoded length + single byte free count + payload) */
199 static unsigned int zipmapRawValueLength(unsigned char *p) {
200 unsigned int l = zipmapDecodeLength(p);
201 unsigned int used;
202
203 used = zipmapEncodeLength(NULL,l);
204 used += p[used] + 1 + l;
205 return used;
206 }
207
cd5a96e @antirez zipampDel() implemented
authored
208 /* If 'p' points to a key, this function returns the total amount of
209 * bytes used to store this entry (entry = key + associated value + trailing
210 * free space if any). */
211 static unsigned int zipmapRawEntryLength(unsigned char *p) {
212 unsigned int l = zipmapRawKeyLength(p);
213
214 return l + zipmapRawValueLength(p+l);
215 }
216
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
217 static inline unsigned char *zipmapResize(unsigned char *zm, unsigned int len) {
218 zm = zrealloc(zm, len);
219 zm[len-1] = ZIPMAP_END;
220 return zm;
221 }
222
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
223 /* Set key to value, creating the key if it does not already exist.
224 * If 'update' is not NULL, *update is set to 1 if the key was
225 * already preset, otherwise to 0. */
226 unsigned char *zipmapSet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char *val, unsigned int vlen, int *update) {
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
227 unsigned int zmlen;
228 unsigned int freelen, reqlen = zipmapRequiredLength(klen,vlen);
eb46f4b @antirez initial zipmap.c implementation
authored
229 unsigned int empty, vempty;
230 unsigned char *p;
231
232 freelen = reqlen;
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
233 if (update) *update = 0;
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
234 p = zipmapLookupRaw(zm,key,klen,&zmlen);
235 if (p == NULL) {
236 /* Key not found: enlarge */
237 zm = zipmapResize(zm, zmlen+reqlen);
238 p = zm+zmlen-1;
239 zmlen = zmlen+reqlen;
eb46f4b @antirez initial zipmap.c implementation
authored
240 } else {
241 unsigned char *b = p;
242
243 /* Key found. Is there enough space for the new value? */
244 /* Compute the total length: */
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
245 if (update) *update = 1;
eb46f4b @antirez initial zipmap.c implementation
authored
246 freelen = zipmapRawKeyLength(b);
247 b += freelen;
248 freelen += zipmapRawValueLength(b);
249 if (freelen < reqlen) {
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
250 /* Move remaining entries to the current position, so this
251 * pair can be appended. Note: the +1 in memmove is caused
252 * by the end-of-zipmap byte. */
253 memmove(p, p+freelen, zmlen-((p-zm)+freelen+1));
254 zm = zipmapResize(zm, zmlen-freelen+reqlen);
255 p = zm+zmlen-1-freelen;
256 zmlen = zmlen-1-freelen+reqlen;
257 freelen = reqlen;
eb46f4b @antirez initial zipmap.c implementation
authored
258 }
259 }
260
261 /* Ok we have a suitable block where to write the new key/value
262 * entry. */
263 empty = freelen-reqlen;
264 /* If there is too much free space mark it as a free block instead
265 * of adding it as trailing empty space for the value, as we want
266 * zipmaps to be very space efficient. */
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
267 if (empty >= ZIPMAP_VALUE_MAX_FREE) {
268 memmove(p+reqlen, p+freelen, zmlen-((p-zm)+freelen+1));
269 zmlen -= empty;
270 zm = zipmapResize(zm, zmlen);
eb46f4b @antirez initial zipmap.c implementation
authored
271 vempty = 0;
272 } else {
273 vempty = empty;
274 }
275
276 /* Just write the key + value and we are done. */
277 /* Key: */
278 p += zipmapEncodeLength(p,klen);
279 memcpy(p,key,klen);
280 p += klen;
281 /* Value: */
282 p += zipmapEncodeLength(p,vlen);
283 *p++ = vempty;
284 memcpy(p,val,vlen);
285 return zm;
286 }
287
cd5a96e @antirez zipampDel() implemented
authored
288 /* Remove the specified key. If 'deleted' is not NULL the pointed integer is
289 * set to 0 if the key was not found, to 1 if it was found and deleted. */
290 unsigned char *zipmapDel(unsigned char *zm, unsigned char *key, unsigned int klen, int *deleted) {
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
291 unsigned int zmlen;
292 unsigned char *p = zipmapLookupRaw(zm,key,klen,&zmlen);
cd5a96e @antirez zipampDel() implemented
authored
293 if (p) {
294 unsigned int freelen = zipmapRawEntryLength(p);
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
295 memmove(p, p+freelen, zmlen-((p-zm)+freelen+1));
296 zm = zipmapResize(zm, zmlen-freelen);
cd5a96e @antirez zipampDel() implemented
authored
297 if (deleted) *deleted = 1;
298 } else {
299 if (deleted) *deleted = 0;
300 }
301 return zm;
302 }
303
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
304 /* Call it before to iterate trought elements via zipmapNext() */
305 unsigned char *zipmapRewind(unsigned char *zm) {
306 return zm+1;
307 }
308
66ef8da @antirez zipmap iteration code
authored
309 /* This function is used to iterate through all the zipmap elements.
310 * In the first call the first argument is the pointer to the zipmap + 1.
311 * In the next calls what zipmapNext returns is used as first argument.
312 * Example:
313 *
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
314 * unsigned char *i = zipmapRewind(my_zipmap);
66ef8da @antirez zipmap iteration code
authored
315 * while((i = zipmapNext(i,&key,&klen,&value,&vlen)) != NULL) {
316 * printf("%d bytes key at $p\n", klen, key);
317 * printf("%d bytes value at $p\n", vlen, value);
318 * }
319 */
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
320 unsigned char *zipmapNext(unsigned char *zm, unsigned char **key, unsigned int *klen, unsigned char **value, unsigned int *vlen) {
66ef8da @antirez zipmap iteration code
authored
321 while(zm[0] == ZIPMAP_EMPTY)
322 zm += zipmapDecodeLength(zm+1);
323 if (zm[0] == ZIPMAP_END) return NULL;
324 if (key) {
325 *key = zm;
326 *klen = zipmapDecodeLength(zm);
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
327 *key += ZIPMAP_LEN_BYTES(*klen);
66ef8da @antirez zipmap iteration code
authored
328 }
329 zm += zipmapRawKeyLength(zm);
330 if (value) {
331 *value = zm+1;
332 *vlen = zipmapDecodeLength(zm);
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
333 *value += ZIPMAP_LEN_BYTES(*vlen);
66ef8da @antirez zipmap iteration code
authored
334 }
335 zm += zipmapRawValueLength(zm);
336 return zm;
337 }
338
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
339 /* Search a key and retrieve the pointer and len of the associated value.
340 * If the key is found the function returns 1, otherwise 0. */
341 int zipmapGet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char **value, unsigned int *vlen) {
342 unsigned char *p;
343
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
344 if ((p = zipmapLookupRaw(zm,key,klen,NULL)) == NULL) return 0;
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
345 p += zipmapRawKeyLength(p);
346 *vlen = zipmapDecodeLength(p);
347 *value = p + ZIPMAP_LEN_BYTES(*vlen) + 1;
348 return 1;
349 }
350
351 /* Return 1 if the key exists, otherwise 0 is returned. */
352 int zipmapExists(unsigned char *zm, unsigned char *key, unsigned int klen) {
43078ff @pietern implemented strategy that doesn't use free blocks in zipmaps
pietern authored
353 return zipmapLookupRaw(zm,key,klen,NULL) != NULL;
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
354 }
355
b1befe6 @antirez Hashes saving / fixes
authored
356 /* Return the number of entries inside a zipmap */
357 unsigned int zipmapLen(unsigned char *zm) {
358 unsigned char *p = zipmapRewind(zm);
359 unsigned int len = 0;
360
361 while((p = zipmapNext(p,NULL,NULL,NULL,NULL)) != NULL) len++;
362 return len;
363 }
364
eb46f4b @antirez initial zipmap.c implementation
authored
365 void zipmapRepr(unsigned char *p) {
366 unsigned int l;
367
368 printf("{status %u}",*p++);
369 while(1) {
370 if (p[0] == ZIPMAP_END) {
371 printf("{end}");
372 break;
373 } else if (p[0] == ZIPMAP_EMPTY) {
374 l = zipmapDecodeLength(p+1);
375 printf("{%u empty block}", l);
376 p += l;
377 } else {
378 unsigned char e;
379
380 l = zipmapDecodeLength(p);
381 printf("{key %u}",l);
382 p += zipmapEncodeLength(NULL,l);
383 fwrite(p,l,1,stdout);
384 p += l;
385
386 l = zipmapDecodeLength(p);
387 printf("{value %u}",l);
388 p += zipmapEncodeLength(NULL,l);
389 e = *p++;
390 fwrite(p,l,1,stdout);
8ec0832 @antirez first zipmap fix of a long sequence in the days to come ;)
authored
391 p += l+e;
eb46f4b @antirez initial zipmap.c implementation
authored
392 if (e) {
393 printf("[");
394 while(e--) printf(".");
395 printf("]");
396 }
397 }
398 }
399 printf("\n");
400 }
401
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
402 #ifdef ZIPMAP_TEST_MAIN
eb46f4b @antirez initial zipmap.c implementation
authored
403 int main(void) {
404 unsigned char *zm;
405
406 zm = zipmapNew();
cbba7dd @antirez HSET fixes, now the new pointer is stored back in the object pointer …
authored
407
408 zm = zipmapSet(zm,(unsigned char*) "name",4, (unsigned char*) "foo",3,NULL);
409 zm = zipmapSet(zm,(unsigned char*) "surname",7, (unsigned char*) "foo",3,NULL);
410 zm = zipmapSet(zm,(unsigned char*) "age",3, (unsigned char*) "foo",3,NULL);
411 zipmapRepr(zm);
412 exit(1);
413
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
414 zm = zipmapSet(zm,(unsigned char*) "hello",5, (unsigned char*) "world!",6,NULL);
415 zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "bar",3,NULL);
416 zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "!",1,NULL);
eb46f4b @antirez initial zipmap.c implementation
authored
417 zipmapRepr(zm);
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
418 zm = zipmapSet(zm,(unsigned char*) "foo",3, (unsigned char*) "12345",5,NULL);
be0af2f @antirez minor fixes for zipmap.c
authored
419 zipmapRepr(zm);
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
420 zm = zipmapSet(zm,(unsigned char*) "new",3, (unsigned char*) "xx",2,NULL);
978c2c9 @antirez first implementation of HSET/HSET. More work needed
authored
421 zm = zipmapSet(zm,(unsigned char*) "noval",5, (unsigned char*) "",0,NULL);
be0af2f @antirez minor fixes for zipmap.c
authored
422 zipmapRepr(zm);
cd5a96e @antirez zipampDel() implemented
authored
423 zm = zipmapDel(zm,(unsigned char*) "new",3,NULL);
424 zipmapRepr(zm);
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
425 printf("\nPerform a direct lookup:\n");
426 {
427 unsigned char *value;
428 unsigned int vlen;
429
430 if (zipmapGet(zm,(unsigned char*) "foo",3,&value,&vlen)) {
431 printf(" foo is associated to the %d bytes value: %.*s\n",
432 vlen, vlen, value);
433 }
434 }
435 printf("\nIterate trought elements:\n");
66ef8da @antirez zipmap iteration code
authored
436 {
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
437 unsigned char *i = zipmapRewind(zm);
66ef8da @antirez zipmap iteration code
authored
438 unsigned char *key, *value;
439 unsigned int klen, vlen;
440
441 while((i = zipmapNext(i,&key,&klen,&value,&vlen)) != NULL) {
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
442 printf(" %d:%.*s => %d:%.*s\n", klen, klen, key, vlen, vlen, value);
66ef8da @antirez zipmap iteration code
authored
443 }
444 }
eb46f4b @antirez initial zipmap.c implementation
authored
445 return 0;
446 }
5234952 @antirez zipmaps functions to get, iterate, test for existence. Initial works …
authored
447 #endif
Something went wrong with that request. Please try again.