Removed unneeded function

[redis.git] / src / redis.h

diff --git a/src/redis.h b/src/redis.h
index 463db704a5ac84b0f2b2113fc9917859f1a29718..ea05fcd0b8073c29350ca99b64a6fad7445d1ffd 100644 (file)
--- a/src/redis.h
+++ b/src/redis.h
@@ -16,6 +16,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <unistd.h>
 #include <errno.h>
 #include <inttypes.h>

+#include <pthread.h>

 
 #include "ae.h"     /* Event driven programming library */
 #include "sds.h"    /* Dynamic safe strings */
 
 #include "ae.h"     /* Event driven programming library */
 #include "sds.h"    /* Dynamic safe strings */


@@ -47,6 +48,15 @@
 #define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */
 #define REDIS_SHARED_INTEGERS 10000
 
 #define REDIS_REQUEST_MAX_SIZE (1024*1024*256) /* max bytes in inline command */
 #define REDIS_SHARED_INTEGERS 10000
 

+/* Size of a reply chunk, configured to exactly allocate 4k bytes */
+#define REDIS_REPLY_CHUNK_BYTES (4*1024)
+#define REDIS_REPLY_CHUNK_SIZE (REDIS_REPLY_CHUNK_BYTES-sizeof(struct sdshdr)-1-sizeof(size_t))
+/* It doesn't make sense to memcpy objects to a chunk when the net result is
+ * not being able to glue other objects. We want to make sure it can be glued
+ * to at least a bulk length or \r\n, so set the threshold to be a couple
+ * of bytes less than the size of the buffer. */
+#define REDIS_REPLY_CHUNK_THRESHOLD (REDIS_REPLY_CHUNK_SIZE-16)
+

 /* If more then REDIS_WRITEV_THRESHOLD write packets are pending use writev */
 #define REDIS_WRITEV_THRESHOLD      3
 /* Max number of iovecs used for each writev call */
 /* If more then REDIS_WRITEV_THRESHOLD write packets are pending use writev */
 #define REDIS_WRITEV_THRESHOLD      3
 /* Max number of iovecs used for each writev call */


@@ -71,6 +81,7 @@
 #define REDIS_SET 2
 #define REDIS_ZSET 3
 #define REDIS_HASH 4
 #define REDIS_SET 2
 #define REDIS_ZSET 3
 #define REDIS_HASH 4

+#define REDIS_REPLY_NODE 5

 #define REDIS_VMPOINTER 8
 
 /* Objects encoding. Some kind of objects like Strings and Hashes can be
 #define REDIS_VMPOINTER 8
 
 /* Objects encoding. Some kind of objects like Strings and Hashes can be


@@ -285,7 +296,7 @@ typedef struct redisClient {
     sds querybuf;
     robj **argv, **mbargv;
     int argc, mbargc;
     sds querybuf;
     robj **argv, **mbargv;
     int argc, mbargc;

-    int bulklen;            /* bulk read len. -1 if not in bulk read mode */
+    long bulklen;            /* bulk read len. -1 if not in bulk read mode */

     int multibulk;          /* multi bulk command format active */
     list *reply;
     int sentlen;
     int multibulk;          /* multi bulk command format active */
     list *reply;
     int sentlen;


@@ -308,6 +319,11 @@ typedef struct redisClient {
     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
     dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
     list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
     list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
     dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
     list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */

+
+    /* Response buffer */
+    int bufpos;
+    int buflen;
+    char buf[];

 } redisClient;
 
 struct saveparam {
 } redisClient;
 
 struct saveparam {


@@ -329,10 +345,12 @@ struct sharedObjectsStruct {
 
 /* Global server state structure */
 struct redisServer {
 
 /* Global server state structure */
 struct redisServer {

+    pthread_t mainthread;

     int port;
     int fd;
     redisDb *db;
     long long dirty;            /* changes to DB from the last save */
     int port;
     int fd;
     redisDb *db;
     long long dirty;            /* changes to DB from the last save */

+    long long dirty_before_bgsave; /* used to restore dirty on failed BGSAVE */

     list *clients;
     list *slaves, *monitors;
     char neterr[ANET_ERR_LEN];
     list *clients;
     list *slaves, *monitors;
     char neterr[ANET_ERR_LEN];


@@ -543,7 +561,7 @@ typedef struct {
     int encoding;
     int ii; /* intset iterator */
     dictIterator *di;
     int encoding;
     int ii; /* intset iterator */
     dictIterator *di;

-} setIterator;
+} setTypeIterator;

 
 /* Structure to hold hash iteration abstration. Note that iteration over
  * hashes involves both fields and values. Because it is possible that
 
 /* Structure to hold hash iteration abstration. Note that iteration over
  * hashes involves both fields and values. Because it is possible that


@@ -585,6 +603,8 @@ void resetClient(redisClient *c);
 void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
 void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask);
 void addReply(redisClient *c, robj *obj);
 void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
 void sendReplyToClientWritev(aeEventLoop *el, int fd, void *privdata, int mask);
 void addReply(redisClient *c, robj *obj);

+void *addDeferredMultiBulkLength(redisClient *c);
+void setDeferredMultiBulkLength(redisClient *c, void *node, long length);

 void addReplySds(redisClient *c, sds s);
 void processInputBuffer(redisClient *c);
 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void addReplySds(redisClient *c, sds s);
 void processInputBuffer(redisClient *c);
 void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);


@@ -596,7 +616,7 @@ void addReply(redisClient *c, robj *obj);
 void addReplySds(redisClient *c, sds s);
 void addReplyDouble(redisClient *c, double d);
 void addReplyLongLong(redisClient *c, long long ll);
 void addReplySds(redisClient *c, sds s);
 void addReplyDouble(redisClient *c, double d);
 void addReplyLongLong(redisClient *c, long long ll);

-void addReplyUlong(redisClient *c, unsigned long ul);
+void addReplyMultiBulkLen(redisClient *c, long length);

 void *dupClientReplyValue(void *o);
 
 /* List data type */
 void *dupClientReplyValue(void *o);
 
 /* List data type */


@@ -732,9 +752,9 @@ robj *setTypeCreate(robj *value);
 int setTypeAdd(robj *subject, robj *value);
 int setTypeRemove(robj *subject, robj *value);
 int setTypeIsMember(robj *subject, robj *value);
 int setTypeAdd(robj *subject, robj *value);
 int setTypeRemove(robj *subject, robj *value);
 int setTypeIsMember(robj *subject, robj *value);

-setIterator *setTypeInitIterator(robj *subject);
-void setTypeReleaseIterator(setIterator *si);
-robj *setTypeNext(setIterator *si);
+setTypeIterator *setTypeInitIterator(robj *subject);
+void setTypeReleaseIterator(setTypeIterator *si);
+robj *setTypeNext(setTypeIterator *si);

 robj *setTypeRandomElement(robj *subject);
 unsigned long setTypeSize(robj *subject);
 void setTypeConvert(robj *subject, int enc);
 robj *setTypeRandomElement(robj *subject);
 unsigned long setTypeSize(robj *subject);
 void setTypeConvert(robj *subject, int enc);


@@ -767,6 +787,8 @@ int stringmatch(const char *pattern, const char *string, int nocase);
 long long memtoll(const char *p, int *err);
 int ll2string(char *s, size_t len, long long value);
 int isStringRepresentableAsLong(sds s, long *longval);
 long long memtoll(const char *p, int *err);
 int ll2string(char *s, size_t len, long long value);
 int isStringRepresentableAsLong(sds s, long *longval);

+int isStringRepresentableAsLongLong(sds s, long long *longval);
+int isObjectRepresentableAsLongLong(robj *o, long long *llongval);

 
 /* Configuration */
 void loadServerConfig(char *filename);
 
 /* Configuration */
 void loadServerConfig(char *filename);


@@ -775,10 +797,10 @@ void resetServerSaveParams();
 
 /* db.c -- Keyspace access API */
 int removeExpire(redisDb *db, robj *key);
 
 /* db.c -- Keyspace access API */
 int removeExpire(redisDb *db, robj *key);

+void propagateExpire(redisDb *db, robj *key);

 int expireIfNeeded(redisDb *db, robj *key);
 int expireIfNeeded(redisDb *db, robj *key);

-int deleteIfVolatile(redisDb *db, robj *key);

 time_t getExpire(redisDb *db, robj *key);
 time_t getExpire(redisDb *db, robj *key);

-int setExpire(redisDb *db, robj *key, time_t when);
+void setExpire(redisDb *db, robj *key, time_t when);

 robj *lookupKey(redisDb *db, robj *key);
 robj *lookupKeyRead(redisDb *db, robj *key);
 robj *lookupKeyWrite(redisDb *db, robj *key);
 robj *lookupKey(redisDb *db, robj *key);
 robj *lookupKeyRead(redisDb *db, robj *key);
 robj *lookupKeyWrite(redisDb *db, robj *key);


@@ -861,6 +883,7 @@ void expireCommand(redisClient *c);
 void expireatCommand(redisClient *c);
 void getsetCommand(redisClient *c);
 void ttlCommand(redisClient *c);
 void expireatCommand(redisClient *c);
 void getsetCommand(redisClient *c);
 void ttlCommand(redisClient *c);

+void persistCommand(redisClient *c);

 void slaveofCommand(redisClient *c);
 void debugCommand(redisClient *c);
 void msetCommand(redisClient *c);
 void slaveofCommand(redisClient *c);
 void debugCommand(redisClient *c);
 void msetCommand(redisClient *c);


@@ -882,6 +905,7 @@ void blpopCommand(redisClient *c);
 void brpopCommand(redisClient *c);
 void appendCommand(redisClient *c);
 void substrCommand(redisClient *c);
 void brpopCommand(redisClient *c);
 void appendCommand(redisClient *c);
 void substrCommand(redisClient *c);

+void strlenCommand(redisClient *c);

 void zrankCommand(redisClient *c);
 void zrevrankCommand(redisClient *c);
 void hsetCommand(redisClient *c);
 void zrankCommand(redisClient *c);
 void zrevrankCommand(redisClient *c);
 void hsetCommand(redisClient *c);


@@ -908,4 +932,11 @@ void publishCommand(redisClient *c);
 void watchCommand(redisClient *c);
 void unwatchCommand(redisClient *c);
 
 void watchCommand(redisClient *c);
 void unwatchCommand(redisClient *c);
 

+#if defined(__GNUC__)
+void *calloc(size_t count, size_t size) __attribute__ ((deprecated));
+void free(void *ptr) __attribute__ ((deprecated));
+void *malloc(size_t size) __attribute__ ((deprecated));
+void *realloc(void *ptr, size_t size) __attribute__ ((deprecated));
+#endif
+

 #endif
 #endif