Added a new method sAddArray to both Redis and RedisCluster

Presently, the sAdd command is variadic, meaning that it takes a key
and then 1 to N additional arguments for the members being added.  We
need to keep this functionality to avoid breaking existing code,
but there are good performance and other reasons to have an sAdd
command which takes a key followed by an array of members, which is
what the sAddArray method implements.

Author: michael-grunder

php_redis.h

@@ -80,6 +80,7 @@ PHP_METHOD(Redis, lGetRange);
 PHP_METHOD(Redis, lSet);
 PHP_METHOD(Redis, lInsert);
 PHP_METHOD(Redis, sAdd);
+PHP_METHOD(Redis, sAddArray);
 PHP_METHOD(Redis, sSize);
 PHP_METHOD(Redis, sRemove);
 PHP_METHOD(Redis, sMove);

redis.c

@@ -156,6 +156,7 @@ static zend_function_entry redis_functions[] = {
      PHP_ME(Redis, lSet, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, lInsert, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, sAdd, NULL, ZEND_ACC_PUBLIC)
+     PHP_ME(Redis, sAddArray, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, sSize, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, sRemove, NULL, ZEND_ACC_PUBLIC)
      PHP_ME(Redis, sMove, NULL, ZEND_ACC_PUBLIC)
@@ -1252,13 +1253,18 @@ PHP_METHOD(Redis, lGetRange)
 }
 /* }}} */
 
-/* {{{ proto boolean Redis::sAdd(string key , mixed value) */
+/* {{{ proto long Redis::sAdd(string key , mixed value) */
 PHP_METHOD(Redis, sAdd)
 {
     REDIS_PROCESS_KW_CMD("SADD", redis_key_varval_cmd, redis_long_response);
 }
 /* }}} */
 
+/* {{{ proto boolean Redis::sAddArray(string key, array $values) */
+PHP_METHOD(Redis, sAddArray) {
+    REDIS_PROCESS_KW_CMD("SADD", redis_key_arr_cmd, redis_long_response);
+} /* }}} */
+
 /* {{{ proto int Redis::sSize(string key) */
 PHP_METHOD(Redis, sSize)
 {

redis_cluster.c

@@ -91,6 +91,7 @@ zend_function_entry redis_cluster_functions[] = {
     PHP_ME(RedisCluster, smembers, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, sismember, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, sadd, NULL, ZEND_ACC_PUBLIC)
+    PHP_ME(RedisCluster, saddarray, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, srem, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, sunion, NULL, ZEND_ACC_PUBLIC)
     PHP_ME(RedisCluster, sunionstore, NULL, ZEND_ACC_PUBLIC)
@@ -1196,6 +1197,12 @@ PHP_METHOD(RedisCluster, sadd) {
 }
 /* }}} */
 
+/* {{{ proto long RedisCluster::saddarray(string key, array values) */
+PHP_METHOD(RedisCluster, saddarray) {
+    CLUSTER_PROCESS_KW_CMD("SADD", redis_key_arr_cmd, cluster_long_resp, 0);
+}
+/* }}} */
+
 /* {{{ proto long RedisCluster::srem(string key, string val1 [, ...]) */
 PHP_METHOD(RedisCluster, srem) {
     CLUSTER_PROCESS_KW_CMD("SREM", redis_key_varval_cmd, cluster_long_resp, 0);

redis_cluster.h

@@ -149,6 +149,7 @@ PHP_METHOD(RedisCluster, scard);
 PHP_METHOD(RedisCluster, smembers);
 PHP_METHOD(RedisCluster, sismember);
 PHP_METHOD(RedisCluster, sadd);
+PHP_METHOD(RedisCluster, saddarray);
 PHP_METHOD(RedisCluster, srem);
 PHP_METHOD(RedisCluster, sunion);
 PHP_METHOD(RedisCluster, sunionstore);

redis_commands.c

@@ -999,6 +999,52 @@ int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     return SUCCESS;
 }
 
+/* Commands that take a key and then an array of values */
+int redis_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
+                      char *kw, char **cmd, int *cmd_len, short *slot,
+                      void **ctx)
+{
+    zval *z_key, *z_arr, **z_val;
+    HashTable *ht_arr;
+    HashPosition pos;
+    smart_str cmdstr = {0};
+    int key_len, val_len, key_free, val_free, argc = 1;
+    char *key, *val;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &key_len, 
+                              &z_arr) == FAILURE ||
+                              zend_hash_num_elements(Z_ARRVAL_P(z_arr)) == 0)
+    {
+        return FAILURE;
+    }
+
+    /* Start constructing our command */
+    ht_arr = Z_ARRVAL_P(z_arr);
+    argc += zend_hash_num_elements(ht_arr);
+    redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));
+    
+    /* Prefix if required and append the key name */
+    key_free = redis_key_prefix(redis_sock, &key, &key_len);
+    redis_cmd_append_sstr(&cmdstr, key, key_len);
+    CMD_SET_SLOT(slot, key, key_len);
+    if (key_free) efree(key);
+
+    /* Iterate our hash table, serializing and appending values */
+    for (zend_hash_internal_pointer_reset_ex(ht_arr, &pos);
+         zend_hash_get_current_data_ex(ht_arr, (void**)&z_val, &pos) == SUCCESS;
+         zend_hash_move_forward_ex(ht_arr, &pos))
+    {
+        val_free = redis_serialize(redis_sock, *z_val, &val, &val_len TSRMLS_CC);
+        redis_cmd_append_sstr(&cmdstr, val, val_len);
+        if (val_free) STR_FREE(val);
+    }
+
+    *cmd_len = cmdstr.len;
+    *cmd = cmdstr.c;
+
+    return SUCCESS;
+}
+
 /* Generic function that takes a variable number of keys, with an optional
  * timeout value.  This can handle various SUNION/SUNIONSTORE/BRPOP type
  * commands. */

redis_commands.h

@@ -67,6 +67,9 @@ int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
 int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     char *kw, char **cmd, int *cmd_len, short *slot, void **ctx);
 
+int redis_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
+    char *kw, char **cmd, int *cmd_len, short *slot, void **ctx);
+
 /* Construct SCAN and similar commands, as well as check iterator  */
 int redis_scan_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,
     REDIS_SCAN_TYPE type, char **cmd, int *cmd_len);