diff options
Diffstat (limited to 'src/rdb.h')
| -rw-r--r-- | src/rdb.h | 121 |
1 files changed, 79 insertions, 42 deletions
@@ -27,88 +27,125 @@ * POSSIBILITY OF SUCH DAMAGE. */ -#ifndef __REDIS_RDB_H -#define __REDIS_RDB_H +#ifndef __RDB_H +#define __RDB_H #include <stdio.h> #include "rio.h" /* TBD: include only necessary headers. */ -#include "redis.h" +#include "server.h" /* The current RDB version. When the format changes in a way that is no longer * backward compatible this number gets incremented. */ -#define REDIS_RDB_VERSION 6 +#define RDB_VERSION 8 /* Defines related to the dump file format. To store 32 bits lengths for short * keys requires a lot of space, so we check the most significant 2 bits of * the first byte to interpreter the length: * - * 00|000000 => if the two MSB are 00 the len is the 6 bits of this byte - * 01|000000 00000000 => 01, the len is 14 byes, 6 bits + 8 bits of next byte - * 10|000000 [32 bit integer] => if it's 01, a full 32 bit len will follow - * 11|000000 this means: specially encoded object will follow. The six bits + * 00|XXXXXX => if the two MSB are 00 the len is the 6 bits of this byte + * 01|XXXXXX XXXXXXXX => 01, the len is 14 byes, 6 bits + 8 bits of next byte + * 10|000000 [32 bit integer] => A full 32 bit len in net byte order will follow + * 10|000001 [64 bit integer] => A full 64 bit len in net byte order will follow + * 11|OBKIND this means: specially encoded object will follow. The six bits * number specify the kind of object that follows. - * See the REDIS_RDB_ENC_* defines. + * See the RDB_ENC_* defines. * * Lengths up to 63 are stored using a single byte, most DB keys, and may * values, will fit inside. */ -#define REDIS_RDB_6BITLEN 0 -#define REDIS_RDB_14BITLEN 1 -#define REDIS_RDB_32BITLEN 2 -#define REDIS_RDB_ENCVAL 3 -#define REDIS_RDB_LENERR UINT_MAX +#define RDB_6BITLEN 0 +#define RDB_14BITLEN 1 +#define RDB_32BITLEN 0x80 +#define RDB_64BITLEN 0x81 +#define RDB_ENCVAL 3 +#define RDB_LENERR UINT64_MAX /* When a length of a string object stored on disk has the first two bits - * set, the remaining two bits specify a special encoding for the object + * set, the remaining six bits specify a special encoding for the object * accordingly to the following defines: */ -#define REDIS_RDB_ENC_INT8 0 /* 8 bit signed integer */ -#define REDIS_RDB_ENC_INT16 1 /* 16 bit signed integer */ -#define REDIS_RDB_ENC_INT32 2 /* 32 bit signed integer */ -#define REDIS_RDB_ENC_LZF 3 /* string compressed with FASTLZ */ +#define RDB_ENC_INT8 0 /* 8 bit signed integer */ +#define RDB_ENC_INT16 1 /* 16 bit signed integer */ +#define RDB_ENC_INT32 2 /* 32 bit signed integer */ +#define RDB_ENC_LZF 3 /* string compressed with FASTLZ */ /* Dup object types to RDB object types. Only reason is readability (are we * dealing with RDB types or with in-memory object types?). */ -#define REDIS_RDB_TYPE_STRING 0 -#define REDIS_RDB_TYPE_LIST 1 -#define REDIS_RDB_TYPE_SET 2 -#define REDIS_RDB_TYPE_ZSET 3 -#define REDIS_RDB_TYPE_HASH 4 +#define RDB_TYPE_STRING 0 +#define RDB_TYPE_LIST 1 +#define RDB_TYPE_SET 2 +#define RDB_TYPE_ZSET 3 +#define RDB_TYPE_HASH 4 +#define RDB_TYPE_ZSET_2 5 /* ZSET version 2 with doubles stored in binary. */ +#define RDB_TYPE_MODULE 6 +#define RDB_TYPE_MODULE_2 7 /* Module value with annotations for parsing without + the generating module being loaded. */ +/* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */ /* Object types for encoded objects. */ -#define REDIS_RDB_TYPE_HASH_ZIPMAP 9 -#define REDIS_RDB_TYPE_LIST_ZIPLIST 10 -#define REDIS_RDB_TYPE_SET_INTSET 11 -#define REDIS_RDB_TYPE_ZSET_ZIPLIST 12 -#define REDIS_RDB_TYPE_HASH_ZIPLIST 13 +#define RDB_TYPE_HASH_ZIPMAP 9 +#define RDB_TYPE_LIST_ZIPLIST 10 +#define RDB_TYPE_SET_INTSET 11 +#define RDB_TYPE_ZSET_ZIPLIST 12 +#define RDB_TYPE_HASH_ZIPLIST 13 +#define RDB_TYPE_LIST_QUICKLIST 14 +/* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */ /* Test if a type is an object type. */ -#define rdbIsObjectType(t) ((t >= 0 && t <= 4) || (t >= 9 && t <= 13)) +#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 14)) /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */ -#define REDIS_RDB_OPCODE_EXPIRETIME_MS 252 -#define REDIS_RDB_OPCODE_EXPIRETIME 253 -#define REDIS_RDB_OPCODE_SELECTDB 254 -#define REDIS_RDB_OPCODE_EOF 255 +#define RDB_OPCODE_AUX 250 +#define RDB_OPCODE_RESIZEDB 251 +#define RDB_OPCODE_EXPIRETIME_MS 252 +#define RDB_OPCODE_EXPIRETIME 253 +#define RDB_OPCODE_SELECTDB 254 +#define RDB_OPCODE_EOF 255 + +/* Module serialized values sub opcodes */ +#define RDB_MODULE_OPCODE_EOF 0 /* End of module value. */ +#define RDB_MODULE_OPCODE_SINT 1 /* Signed integer. */ +#define RDB_MODULE_OPCODE_UINT 2 /* Unsigned integer. */ +#define RDB_MODULE_OPCODE_FLOAT 3 /* Float. */ +#define RDB_MODULE_OPCODE_DOUBLE 4 /* Double. */ +#define RDB_MODULE_OPCODE_STRING 5 /* String. */ + +/* rdbLoad...() functions flags. */ +#define RDB_LOAD_NONE 0 +#define RDB_LOAD_ENC (1<<0) +#define RDB_LOAD_PLAIN (1<<1) +#define RDB_LOAD_SDS (1<<2) + +#define RDB_SAVE_NONE 0 +#define RDB_SAVE_AOF_PREAMBLE (1<<0) int rdbSaveType(rio *rdb, unsigned char type); int rdbLoadType(rio *rdb); int rdbSaveTime(rio *rdb, time_t t); time_t rdbLoadTime(rio *rdb); -int rdbSaveLen(rio *rdb, uint32_t len); -uint32_t rdbLoadLen(rio *rdb, int *isencoded); +int rdbSaveLen(rio *rdb, uint64_t len); +uint64_t rdbLoadLen(rio *rdb, int *isencoded); +int rdbLoadLenByRef(rio *rdb, int *isencoded, uint64_t *lenptr); int rdbSaveObjectType(rio *rdb, robj *o); int rdbLoadObjectType(rio *rdb); -int rdbLoad(char *filename); -int rdbSaveBackground(char *filename); +int rdbLoad(char *filename, rdbSaveInfo *rsi); +int rdbSaveBackground(char *filename, rdbSaveInfo *rsi); +int rdbSaveToSlavesSockets(rdbSaveInfo *rsi); void rdbRemoveTempFile(pid_t childpid); -int rdbSave(char *filename); -int rdbSaveObject(rio *rdb, robj *o); -off_t rdbSavedObjectLen(robj *o); -off_t rdbSavedObjectPages(robj *o); +int rdbSave(char *filename, rdbSaveInfo *rsi); +ssize_t rdbSaveObject(rio *rdb, robj *o); +size_t rdbSavedObjectLen(robj *o); robj *rdbLoadObject(int type, rio *rdb); void backgroundSaveDoneHandler(int exitcode, int bysignal); int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime, long long now); robj *rdbLoadStringObject(rio *rdb); +int rdbSaveStringObject(rio *rdb, robj *obj); +ssize_t rdbSaveRawString(rio *rdb, unsigned char *s, size_t len); +void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr); +int rdbSaveBinaryDoubleValue(rio *rdb, double val); +int rdbLoadBinaryDoubleValue(rio *rdb, double *val); +int rdbSaveBinaryFloatValue(rio *rdb, float val); +int rdbLoadBinaryFloatValue(rio *rdb, float *val); +int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi); #endif |