NWNX:EE  8193.36.12
nwnx_redis_short.nss
Go to the documentation of this file.
1 #include "nwnx"
2 #include "nwnx_redis_lib"
3 
4 
5 // Skipping sub-command: BITFIELD/{"command"=>"OVERFLOW", "type"=>"enum", "enum"=>["WRAP", "SAT", "FAIL"], "optional"=>true} - not supported yet.
6 // Skipping sub-command: CLIENT_KILL/{"command"=>"TYPE", "type"=>"enum", "enum"=>["normal", "master", "slave", "pubsub"], "optional"=>true} - not supported yet.
7 // Skipping sub-command: CLIENT_LIST/{"command"=>"TYPE", "type"=>"enum", "enum"=>["normal", "master", "replica", "pubsub"], "optional"=>true} - not supported yet.
8 // Skipping sub-command: SET/{"command"=>"expiration", "type"=>"enum", "enum"=>["EX seconds", "PX milliseconds"], "optional"=>true} - not supported yet.
9 // Skipping XCLAIM, cannot parse argument: {"name"=>"force", "enum"=>["FORCE"], "optional"=>true} - not supported yet.
10 // Skipping XCLAIM, cannot parse argument: {"name"=>"justid", "enum"=>["JUSTID"], "optional"=>true} - not supported yet.
22 int APPEND(
23  string key,
24  string value
25 );
26 
33 int AUTH(
34  string password
35 );
36 
43 int BGREWRITEAOF();
44 
51 int BGSAVE();
52 
61 int BITCOUNT(
62  string key,
63  // Redis type: integer
64  int start = 0,
65  // Redis type: integer
66  int end = 0
67 );
68 
77 int BITFIELD(
78  string key,
79  // Redis type: type
80  string get_type = "",
81  // Redis type: integer
82  int get_offset = 0,
83  // Redis type: type
84  string set_type = "",
85  // Redis type: integer
86  int set_offset = 0,
87  // Redis type: integer
88  int set_value = 0,
89  // Redis type: type
90  string incrby_type = "",
91  // Redis type: integer
92  int incrby_offset = 0,
93  // Redis type: integer
94  int incrby_increment = 0
95 );
96 
105 int BITOP(
106  string operation,
107  // Redis type: key
108  string destkey,
109  string key
110 );
111 
120 int BITPOS(
121  string key,
122  // Redis type: integer
123  int bit,
124  // Redis type: integer
125  int start = 0,
126  // Redis type: integer
127  int end = 0
128 );
129 
138 int BLPOP(
139  string key,
140  // Redis type: integer
141  int timeout
142 );
143 
152 int BRPOP(
153  string key,
154  // Redis type: integer
155  int timeout
156 );
157 
166 int BRPOPLPUSH(
167  // Redis type: key
168  string source,
169  // Redis type: key
170  string destination,
171  // Redis type: integer
172  int timeout
173 );
174 
183 int BZPOPMIN(
184  string key,
185  // Redis type: integer
186  int timeout
187 );
188 
197 int BZPOPMAX(
198  string key,
199  // Redis type: integer
200  int timeout
201 );
202 
211 int CLIENT_ID();
212 
221 int CLIENT_KILL(
222  string ip_port = "",
223  // Redis type: integer
224  int id_client_id = 0,
225  string addr_ip_port = "",
226  string skipme_yes_no = ""
227 );
228 
237 int CLIENT_LIST();
238 
247 int CLIENT_GETNAME();
248 
257 int CLIENT_PAUSE(
258  // Redis type: integer
259  int timeout
260 );
261 
272 int CLIENT_REPLY(
273  // Redis type: enum
274  string reply_mode
275 );
276 
285 int CLIENT_SETNAME(
286  string connection_name
287 );
288 
299 int CLIENT_UNBLOCK(
300  string client_id,
301  // Redis type: enum
302  string unblock_type = ""
303 );
304 
313 int CLUSTER_ADDSLOTS(
314  // Redis type: integer
315  int slot
316 );
317 
327  string node_id
328 );
329 
339  // Redis type: integer
340  int slot
341 );
342 
351 int CLUSTER_DELSLOTS(
352  // Redis type: integer
353  int slot
354 );
355 
366 int CLUSTER_FAILOVER(
367  // Redis type: enum
368  string options = ""
369 );
370 
379 int CLUSTER_FORGET(
380  string node_id
381 );
382 
392  // Redis type: integer
393  int slot,
394  // Redis type: integer
395  int count
396 );
397 
406 int CLUSTER_INFO();
407 
416 int CLUSTER_KEYSLOT(
417  string key
418 );
419 
428 int CLUSTER_MEET(
429  string ip,
430  // Redis type: integer
431  int port
432 );
433 
442 int CLUSTER_NODES();
443 
453  string node_id
454 );
455 
467 int CLUSTER_RESET(
468  // Redis type: enum
469  string reset_type = ""
470 );
471 
480 int CLUSTER_SAVECONFIG();
481 
491  // Redis type: integer
492  int config_epoch
493 );
494 
505 int CLUSTER_SETSLOT(
506  // Redis type: integer
507  int slot,
508  // Redis type: enum
509  string subcommand,
510  string node_id = ""
511 );
512 
521 int CLUSTER_SLAVES(
522  string node_id
523 );
524 
533 int CLUSTER_REPLICAS(
534  string node_id
535 );
536 
545 int CLUSTER_SLOTS();
546 
555 int COMMAND();
556 
565 int COMMAND_COUNT();
566 
575 int COMMAND_GETKEYS();
576 
585 int COMMAND_INFO(
586  string command_name
587 );
588 
595 int CONFIG_GET(
596  string parameter
597 );
598 
605 int CONFIG_REWRITE();
606 
613 int CONFIG_SET(
614  string parameter,
615  string value
616 );
617 
626 int CONFIG_RESETSTAT();
627 
634 int DBSIZE();
635 
642 int DEBUG_OBJECT(
643  string key
644 );
645 
652 int DEBUG_SEGFAULT();
653 
662 int DECR(
663  string key
664 );
665 
674 int DECRBY(
675  string key,
676  // Redis type: integer
677  int decrement
678 );
679 
691 int DEL(
692  string key
693 );
694 
701 int DISCARD();
702 
714 int DUMP(
715  string key
716 );
717 
724 int ECHO(
725  string message
726 );
727 
736 int EVAL(
737  string script,
738  // Redis type: integer
739  int numkeys,
740  string key,
741  string arg
742 );
743 
752 int EVALSHA(
753  string sha1,
754  // Redis type: integer
755  int numkeys,
756  string key,
757  string arg
758 );
759 
766 int EXEC();
767 
776 int EXISTS(
777  string key
778 );
779 
788 int EXPIRE(
789  string key,
790  // Redis type: integer
791  int seconds
792 );
793 
802 int EXPIREAT(
803  string key,
804  // Redis type: posix time
805  string timestamp
806 );
807 
816 int FLUSHALL(
817  // Redis type: enum
818  string async = ""
819 );
820 
829 int FLUSHDB(
830  // Redis type: enum
831  string async = ""
832 );
833 
843 int GEOADD(
844  string key,
845  // Redis type: double
846  float longitude,
847  // Redis type: double
848  float latitude,
849  string member
850 );
851 
861 int GEOHASH(
862  string key,
863  string member
864 );
865 
875 int GEOPOS(
876  string key,
877  string member
878 );
879 
888 int GEODIST(
889  string key,
890  string member1,
891  string member2,
892  string unit = ""
893 );
894 
915 int GEORADIUS(
916  string key,
917  // Redis type: double
918  float longitude,
919  // Redis type: double
920  float latitude,
921  // Redis type: double
922  float radius,
923  // Redis type: enum
924  string unit,
925  // Redis type: enum
926  string withcoord = "",
927  // Redis type: enum
928  string withdist = "",
929  // Redis type: enum
930  string withhash = "",
931  // Redis type: integer
932  int count_count = 0,
933  // Redis type: enum
934  string order = "",
935  // Redis type: key
936  string store_key = "",
937  // Redis type: key
938  string storedist_key = ""
939 );
940 
962  string key,
963  string member,
964  // Redis type: double
965  float radius,
966  // Redis type: enum
967  string unit,
968  // Redis type: enum
969  string withcoord = "",
970  // Redis type: enum
971  string withdist = "",
972  // Redis type: enum
973  string withhash = "",
974  // Redis type: integer
975  int count_count = 0,
976  // Redis type: enum
977  string order = "",
978  // Redis type: key
979  string store_key = "",
980  // Redis type: key
981  string storedist_key = ""
982 );
983 
992 int GET(
993  string key
994 );
995 
1004 int GETBIT(
1005  string key,
1006  // Redis type: integer
1007  int offset
1008 );
1009 
1021 int GETRANGE(
1022  string key,
1023  // Redis type: integer
1024  int start,
1025  // Redis type: integer
1026  int end
1027 );
1028 
1037 int GETSET(
1038  string key,
1039  string value
1040 );
1041 
1050 int HDEL(
1051  string key,
1052  string field
1053 );
1054 
1063 int HEXISTS(
1064  string key,
1065  string field
1066 );
1067 
1076 int HGET(
1077  string key,
1078  string field
1079 );
1080 
1089 int HGETALL(
1090  string key
1091 );
1092 
1101 int HINCRBY(
1102  string key,
1103  string field,
1104  // Redis type: integer
1105  int increment
1106 );
1107 
1116 int HINCRBYFLOAT(
1117  string key,
1118  string field,
1119  // Redis type: double
1120  float increment
1121 );
1122 
1131 int HKEYS(
1132  string key
1133 );
1134 
1143 int HLEN(
1144  string key
1145 );
1146 
1155 int HMGET(
1156  string key,
1157  string field
1158 );
1159 
1168 int HMSET(
1169  string key,
1170  string field,
1171  string value
1172 );
1173 
1182 int HSET(
1183  string key,
1184  string field,
1185  string value
1186 );
1187 
1196 int HSETNX(
1197  string key,
1198  string field,
1199  string value
1200 );
1201 
1210 int HSTRLEN(
1211  string key,
1212  string field
1213 );
1214 
1223 int HVALS(
1224  string key
1225 );
1226 
1235 int INCR(
1236  string key
1237 );
1238 
1247 int INCRBY(
1248  string key,
1249  // Redis type: integer
1250  int increment
1251 );
1252 
1261 int INCRBYFLOAT(
1262  string key,
1263  // Redis type: double
1264  float increment
1265 );
1266 
1273 int INFO(
1274  string section = ""
1275 );
1276 
1287 int KEYS(
1288  string pattern
1289 );
1290 
1297 int LASTSAVE();
1298 
1308 int LINDEX(
1309  string key,
1310  // Redis type: integer
1311  int index
1312 );
1313 
1327 int LINSERT(
1328  string key,
1329  // Redis type: enum
1330  string where,
1331  string pivot,
1332  string value
1333 );
1334 
1343 int LLEN(
1344  string key
1345 );
1346 
1355 int LPOP(
1356  string key
1357 );
1358 
1367 int LPUSH(
1368  string key,
1369  string value
1370 );
1371 
1380 int LPUSHX(
1381  string key,
1382  string value
1383 );
1384 
1395 int LRANGE(
1396  string key,
1397  // Redis type: integer
1398  int start,
1399  // Redis type: integer
1400  int stop
1401 );
1402 
1411 int LREM(
1412  string key,
1413  // Redis type: integer
1414  int count,
1415  string value
1416 );
1417 
1427 int LSET(
1428  string key,
1429  // Redis type: integer
1430  int index,
1431  string value
1432 );
1433 
1442 int LTRIM(
1443  string key,
1444  // Redis type: integer
1445  int start,
1446  // Redis type: integer
1447  int stop
1448 );
1449 
1456 int MEMORY_DOCTOR();
1457 
1464 int MEMORY_HELP();
1465 
1472 int MEMORY_MALLOC_STATS();
1473 
1480 int MEMORY_PURGE();
1481 
1488 int MEMORY_STATS();
1489 
1498 int MEMORY_USAGE(
1499  string key,
1500  // Redis type: integer
1501  int samples_count = 0
1502 );
1503 
1512 int MGET(
1513  string key
1514 );
1515 
1533 int MIGRATE(
1534  string host,
1535  string port,
1536  // Redis type: enum
1537  string key,
1538  // Redis type: integer
1539  int destination_db,
1540  // Redis type: integer
1541  int timeout,
1542  // Redis type: enum
1543  string copy = "",
1544  // Redis type: enum
1545  string replace = "",
1546  string auth_password = "",
1547  // Redis type: key
1548  string keys_key = ""
1549 );
1550 
1557 int MONITOR();
1558 
1567 int MOVE(
1568  string key,
1569  // Redis type: integer
1570  int db
1571 );
1572 
1581 int MSET(
1582  string key,
1583  string value
1584 );
1585 
1594 int MSETNX(
1595  string key,
1596  string value
1597 );
1598 
1605 int MULTI();
1606 
1615 int OBJECT(
1616  string subcommand,
1617  string arguments = ""
1618 );
1619 
1628 int PERSIST(
1629  string key
1630 );
1631 
1640 int PEXPIRE(
1641  string key,
1642  // Redis type: integer
1643  int milliseconds
1644 );
1645 
1654 int PEXPIREAT(
1655  string key,
1656  // Redis type: posix time
1657  string milliseconds_timestamp
1658 );
1659 
1668 int PFADD(
1669  string key,
1670  string element
1671 );
1672 
1683 int PFCOUNT(
1684  string key
1685 );
1686 
1695 int PFMERGE(
1696  // Redis type: key
1697  string destkey,
1698  // Redis type: key
1699  string sourcekey
1700 );
1701 
1708 int PING(
1709  string message = ""
1710 );
1711 
1720 int PSETEX(
1721  string key,
1722  // Redis type: integer
1723  int milliseconds,
1724  string value
1725 );
1726 
1738 int PUBSUB(
1739  string subcommand,
1740  string argument = ""
1741 );
1742 
1751 int PTTL(
1752  string key
1753 );
1754 
1764 int PUBLISH(
1765  string channel,
1766  string message
1767 );
1768 
1775 int QUIT();
1776 
1785 int RANDOMKEY();
1786 
1795 int READONLY();
1796 
1805 int READWRITE();
1806 
1815 int RENAME(
1816  string key,
1817  // Redis type: key
1818  string newkey
1819 );
1820 
1829 int RENAMENX(
1830  string key,
1831  // Redis type: key
1832  string newkey
1833 );
1834 
1852 int RESTORE(
1853  string key,
1854  // Redis type: integer
1855  int ttl,
1856  string serialized_value,
1857  // Redis type: enum
1858  string replace = "",
1859  // Redis type: enum
1860  string absttl = "",
1861  // Redis type: integer
1862  int idletime_seconds = 0,
1863  // Redis type: integer
1864  int freq_frequency = 0
1865 );
1866 
1873 int ROLE();
1874 
1883 int RPOP(
1884  string key
1885 );
1886 
1895 int RPOPLPUSH(
1896  // Redis type: key
1897  string source,
1898  // Redis type: key
1899  string destination
1900 );
1901 
1910 int RPUSH(
1911  string key,
1912  string value
1913 );
1914 
1923 int RPUSHX(
1924  string key,
1925  string value
1926 );
1927 
1937 int SADD(
1938  string key,
1939  string member
1940 );
1941 
1948 int SAVE();
1949 
1958 int SCARD(
1959  string key
1960 );
1961 
1972 int SCRIPT_DEBUG(
1973  // Redis type: enum
1974  string mode
1975 );
1976 
1986 int SCRIPT_EXISTS(
1987  string sha1
1988 );
1989 
1998 int SCRIPT_FLUSH();
1999 
2008 int SCRIPT_KILL();
2009 
2018 int SCRIPT_LOAD(
2019  string script
2020 );
2021 
2030 int SDIFF(
2031  string key
2032 );
2033 
2042 int SDIFFSTORE(
2043  // Redis type: key
2044  string destination,
2045  string key
2046 );
2047 
2054 int SELECT(
2055  // Redis type: integer
2056  int index
2057 );
2058 
2069 int SET(
2070  string key,
2071  string value,
2072  // Redis type: enum
2073  string condition = ""
2074 );
2075 
2084 int SETBIT(
2085  string key,
2086  // Redis type: integer
2087  int offset,
2088  string value
2089 );
2090 
2099 int SETEX(
2100  string key,
2101  // Redis type: integer
2102  int seconds,
2103  string value
2104 );
2105 
2114 int SETNX(
2115  string key,
2116  string value
2117 );
2118 
2129 int SETRANGE(
2130  string key,
2131  // Redis type: integer
2132  int offset,
2133  string value
2134 );
2135 
2144 int SHUTDOWN(
2145  // Redis type: enum
2146  string save_mode = ""
2147 );
2148 
2158 int SINTER(
2159  string key
2160 );
2161 
2171 int SINTERSTORE(
2172  // Redis type: key
2173  string destination,
2174  string key
2175 );
2176 
2185 int SISMEMBER(
2186  string key,
2187  string member
2188 );
2189 
2196 int SLAVEOF(
2197  string host,
2198  string port
2199 );
2200 
2207 int REPLICAOF(
2208  string host,
2209  string port
2210 );
2211 
2218 int SLOWLOG(
2219  string subcommand,
2220  string argument = ""
2221 );
2222 
2231 int SMEMBERS(
2232  string key
2233 );
2234 
2243 int SMOVE(
2244  // Redis type: key
2245  string source,
2246  // Redis type: key
2247  string destination,
2248  string member
2249 );
2250 
2266 int SORT(
2267  string key,
2268  // Redis type: pattern
2269  string by_pattern = "",
2270  // Redis type: integer
2271  int limit_offset = 0,
2272  // Redis type: integer
2273  int limit_count = 0,
2274  string get_pattern = "",
2275  // Redis type: enum
2276  string order = "",
2277  // Redis type: enum
2278  string sorting = "",
2279  // Redis type: key
2280  string store_destination = ""
2281 );
2282 
2291 int SPOP(
2292  string key,
2293  // Redis type: integer
2294  int count = 0
2295 );
2296 
2306 int SRANDMEMBER(
2307  string key,
2308  // Redis type: integer
2309  int count = 0
2310 );
2311 
2320 int SREM(
2321  string key,
2322  string member
2323 );
2324 
2333 int STRLEN(
2334  string key
2335 );
2336 
2345 int SUNION(
2346  string key
2347 );
2348 
2357 int SUNIONSTORE(
2358  // Redis type: key
2359  string destination,
2360  string key
2361 );
2362 
2369 int SWAPDB(
2370  // Redis type: integer
2371  int index,
2372  // Redis type: integer
2373  int index_1
2374 );
2375 
2382 int SYNC();
2383 
2392 int TIME();
2393 
2402 int TOUCH(
2403  string key
2404 );
2405 
2414 int TTL(
2415  string key
2416 );
2417 
2426 int TYPE(
2427  string key
2428 );
2429 
2440 int UNLINK(
2441  string key
2442 );
2443 
2452 int UNWATCH();
2453 
2462 int WAIT(
2463  // Redis type: integer
2464  int numreplicas,
2465  // Redis type: integer
2466  int timeout
2467 );
2468 
2477 int WATCH(
2478  string key
2479 );
2480 
2496 int ZADD(
2497  string key,
2498  // Redis type: enum
2499  string condition = "",
2500  // Redis type: enum
2501  string change = "",
2502  // Redis type: enum
2503  string increment = "",
2504  // Redis type: double
2505  float score = 0.0,
2506  string member = ""
2507 );
2508 
2517 int ZCARD(
2518  string key
2519 );
2520 
2529 int ZCOUNT(
2530  string key,
2531  // Redis type: double
2532  float min,
2533  // Redis type: double
2534  float max
2535 );
2536 
2545 int ZINCRBY(
2546  string key,
2547  // Redis type: integer
2548  int increment,
2549  string member
2550 );
2551 
2564 int ZINTERSTORE(
2565  // Redis type: key
2566  string destination,
2567  // Redis type: integer
2568  int numkeys,
2569  string key,
2570  // Redis type: integer
2571  int weights_weight = 0,
2572  // Redis type: enum
2573  string aggregate_aggregate = ""
2574 );
2575 
2584 int ZLEXCOUNT(
2585  string key,
2586  string min,
2587  string max
2588 );
2589 
2599 int ZPOPMAX(
2600  string key,
2601  // Redis type: integer
2602  int count = 0
2603 );
2604 
2614 int ZPOPMIN(
2615  string key,
2616  // Redis type: integer
2617  int count = 0
2618 );
2619 
2631 int ZRANGE(
2632  string key,
2633  // Redis type: integer
2634  int start,
2635  // Redis type: integer
2636  int stop,
2637  // Redis type: enum
2638  string withscores = ""
2639 );
2640 
2651 int ZRANGEBYLEX(
2652  string key,
2653  string min,
2654  string max,
2655  // Redis type: integer
2656  int limit_offset = 0,
2657  // Redis type: integer
2658  int limit_count = 0
2659 );
2660 
2671 int ZREVRANGEBYLEX(
2672  string key,
2673  string max,
2674  string min,
2675  // Redis type: integer
2676  int limit_offset = 0,
2677  // Redis type: integer
2678  int limit_count = 0
2679 );
2680 
2693 int ZRANGEBYSCORE(
2694  string key,
2695  // Redis type: double
2696  float min,
2697  // Redis type: double
2698  float max,
2699  // Redis type: enum
2700  string withscores = "",
2701  // Redis type: integer
2702  int limit_offset = 0,
2703  // Redis type: integer
2704  int limit_count = 0
2705 );
2706 
2715 int ZRANK(
2716  string key,
2717  string member
2718 );
2719 
2729 int ZREM(
2730  string key,
2731  string member
2732 );
2733 
2743 int ZREMRANGEBYLEX(
2744  string key,
2745  string min,
2746  string max
2747 );
2748 
2758 int ZREMRANGEBYRANK(
2759  string key,
2760  // Redis type: integer
2761  int start,
2762  // Redis type: integer
2763  int stop
2764 );
2765 
2775 int ZREMRANGEBYSCORE(
2776  string key,
2777  // Redis type: double
2778  float min,
2779  // Redis type: double
2780  float max
2781 );
2782 
2794 int ZREVRANGE(
2795  string key,
2796  // Redis type: integer
2797  int start,
2798  // Redis type: integer
2799  int stop,
2800  // Redis type: enum
2801  string withscores = ""
2802 );
2803 
2816 int ZREVRANGEBYSCORE(
2817  string key,
2818  // Redis type: double
2819  float max,
2820  // Redis type: double
2821  float min,
2822  // Redis type: enum
2823  string withscores = "",
2824  // Redis type: integer
2825  int limit_offset = 0,
2826  // Redis type: integer
2827  int limit_count = 0
2828 );
2829 
2838 int ZREVRANK(
2839  string key,
2840  string member
2841 );
2842 
2851 int ZSCORE(
2852  string key,
2853  string member
2854 );
2855 
2867 int ZUNIONSTORE(
2868  // Redis type: key
2869  string destination,
2870  // Redis type: integer
2871  int numkeys,
2872  string key,
2873  // Redis type: integer
2874  int weights_weight = 0,
2875  // Redis type: enum
2876  string aggregate_aggregate = ""
2877 );
2878 
2889 int SCAN(
2890  // Redis type: integer
2891  int cursor,
2892  // Redis type: pattern
2893  string match_pattern = "",
2894  // Redis type: integer
2895  int count_count = 0,
2896  string type_type = ""
2897 );
2898 
2909 int SSCAN(
2910  string key,
2911  // Redis type: integer
2912  int cursor,
2913  // Redis type: pattern
2914  string match_pattern = "",
2915  // Redis type: integer
2916  int count_count = 0
2917 );
2918 
2929 int HSCAN(
2930  string key,
2931  // Redis type: integer
2932  int cursor,
2933  // Redis type: pattern
2934  string match_pattern = "",
2935  // Redis type: integer
2936  int count_count = 0
2937 );
2938 
2949 int ZSCAN(
2950  string key,
2951  // Redis type: integer
2952  int cursor,
2953  // Redis type: pattern
2954  string match_pattern = "",
2955  // Redis type: integer
2956  int count_count = 0
2957 );
2958 
2971 int XINFO(
2972  // Redis type: key
2973  string consumers_key = "",
2974  string consumers_groupname = "",
2975  // Redis type: key
2976  string groups_key = "",
2977  // Redis type: key
2978  string stream_key = "",
2979  // Redis type: enum
2980  string help = ""
2981 );
2982 
2991 int XADD(
2992  string key,
2993  string ID,
2994  // Redis type: value
2995  string field,
2996  string str
2997 );
2998 
3013 int XTRIM(
3014  string key,
3015  // Redis type: enum
3016  string strategy,
3017  // Redis type: enum
3018  string approx = "",
3019  // Redis type: integer
3020  int count = 0
3021 );
3022 
3032 int XDEL(
3033  string key,
3034  string ID
3035 );
3036 
3047 int XRANGE(
3048  string key,
3049  string start,
3050  string end,
3051  // Redis type: integer
3052  int count_count = 0
3053 );
3054 
3065 int XREVRANGE(
3066  string key,
3067  string end,
3068  string start,
3069  // Redis type: integer
3070  int count_count = 0
3071 );
3072 
3081 int XLEN(
3082  string key
3083 );
3084 
3098 int XREAD(
3099  // Redis type: integer
3100  int count_count = 0,
3101  // Redis type: integer
3102  int block_milliseconds = 0,
3103  // Redis type: enum
3104  string streams = "",
3105  string key = "",
3106  string ID = ""
3107 );
3108 
3119 int XGROUP(
3120  // Redis type: key
3121  string create_key = "",
3122  string create_groupname = "",
3123  string create_id_or__ = "",
3124  // Redis type: key
3125  string setid_key = "",
3126  string setid_groupname = "",
3127  string setid_id_or__ = "",
3128  // Redis type: key
3129  string destroy_key = "",
3130  string destroy_groupname = "",
3131  // Redis type: key
3132  string delconsumer_key = "",
3133  string delconsumer_groupname = "",
3134  string delconsumer_consumername = ""
3135 );
3136 
3153 int XREADGROUP(
3154  string group_group,
3155  string group_consumer,
3156  // Redis type: integer
3157  int count_count = 0,
3158  // Redis type: integer
3159  int block_milliseconds = 0,
3160  // Redis type: enum
3161  string noack = "",
3162  // Redis type: enum
3163  string streams = "",
3164  string key = "",
3165  string ID = ""
3166 );
3167 
3176 int XACK(
3177  string key,
3178  string group,
3179  string ID
3180 );
3181 
3191 int XCLAIM(
3192  string key,
3193  string group,
3194  string consumer,
3195  string min_idle_time,
3196  string ID,
3197  // Redis type: integer
3198  int idle_ms = 0,
3199  // Redis type: integer
3200  int time_ms_unix_time = 0,
3201  // Redis type: integer
3202  int retrycount_count = 0
3203 );
3204 
3216 int XPENDING(
3217  string key,
3218  string group,
3219  string start = "",
3220  string end = "",
3221  // Redis type: integer
3222  int count = 0,
3223  string consumer = ""
3224 );
3225 
3226 
3227 
3228 // Implementation below
3230  string key,
3231  string value
3232 ) {
3233  NWNX_PushArgumentString("APPEND");
3235  NWNX_PushArgumentString(value);
3236  NWNX_CallFunction("NWNX_Redis", "Deferred");
3237  return NWNX_GetReturnValueInt();
3238 }
3239 
3240 int AUTH(
3241  string password
3242 ) {
3243  NWNX_PushArgumentString("AUTH");
3244  NWNX_PushArgumentString(password);
3245  NWNX_CallFunction("NWNX_Redis", "Deferred");
3246  return NWNX_GetReturnValueInt();
3247 }
3248 
3250  NWNX_PushArgumentString("BGREWRITEAOF");
3251  NWNX_CallFunction("NWNX_Redis", "Deferred");
3252  return NWNX_GetReturnValueInt();
3253 }
3254 
3255 int BGSAVE() {
3256  NWNX_PushArgumentString("BGSAVE");
3257  NWNX_CallFunction("NWNX_Redis", "Deferred");
3258  return NWNX_GetReturnValueInt();
3259 }
3260 
3262  string key,
3263  // Redis type: integer
3264  int start = 0,
3265  // Redis type: integer
3266  int end = 0
3267 ) {
3268  NWNX_PushArgumentString("BITCOUNT");
3270  if (start != 0) NWNX_PushArgumentString(IntToString(start));
3271  if (end != 0) NWNX_PushArgumentString(IntToString(end));
3272  NWNX_CallFunction("NWNX_Redis", "Deferred");
3273  return NWNX_GetReturnValueInt();
3274 }
3275 
3277  string key,
3278  // Redis type: type
3279  string get_type = "",
3280  // Redis type: integer
3281  int get_offset = 0,
3282  // Redis type: type
3283  string set_type = "",
3284  // Redis type: integer
3285  int set_offset = 0,
3286  // Redis type: integer
3287  int set_value = 0,
3288  // Redis type: type
3289  string incrby_type = "",
3290  // Redis type: integer
3291  int incrby_offset = 0,
3292  // Redis type: integer
3293  int incrby_increment = 0
3294 ) {
3295  NWNX_PushArgumentString("BITFIELD");
3297  if (get_type != "") NWNX_PushArgumentString(get_type);
3298  if (get_offset != 0) NWNX_PushArgumentString(IntToString(get_offset));
3299  if (set_type != "") NWNX_PushArgumentString(set_type);
3300  if (set_offset != 0) NWNX_PushArgumentString(IntToString(set_offset));
3301  if (set_value != 0) NWNX_PushArgumentString(IntToString(set_value));
3302  if (incrby_type != "") NWNX_PushArgumentString(incrby_type);
3303  if (incrby_offset != 0) NWNX_PushArgumentString(IntToString(incrby_offset));
3304  if (incrby_increment != 0) NWNX_PushArgumentString(IntToString(incrby_increment));
3305  NWNX_CallFunction("NWNX_Redis", "Deferred");
3306  return NWNX_GetReturnValueInt();
3307 }
3308 
3309 int BITOP(
3310  string operation,
3311  // Redis type: key
3312  string destkey,
3313  string key
3314 ) {
3315  NWNX_PushArgumentString("BITOP");
3316  NWNX_PushArgumentString(operation);
3317  NWNX_PushArgumentString(destkey);
3319  NWNX_CallFunction("NWNX_Redis", "Deferred");
3320  return NWNX_GetReturnValueInt();
3321 }
3322 
3324  string key,
3325  // Redis type: integer
3326  int bit,
3327  // Redis type: integer
3328  int start = 0,
3329  // Redis type: integer
3330  int end = 0
3331 ) {
3332  NWNX_PushArgumentString("BITPOS");
3334  NWNX_PushArgumentString(IntToString(bit));
3335  if (start != 0) NWNX_PushArgumentString(IntToString(start));
3336  if (end != 0) NWNX_PushArgumentString(IntToString(end));
3337  NWNX_CallFunction("NWNX_Redis", "Deferred");
3338  return NWNX_GetReturnValueInt();
3339 }
3340 
3341 int BLPOP(
3342  string key,
3343  // Redis type: integer
3344  int timeout
3345 ) {
3346  NWNX_PushArgumentString("BLPOP");
3348  NWNX_PushArgumentString(IntToString(timeout));
3349  NWNX_CallFunction("NWNX_Redis", "Deferred");
3350  return NWNX_GetReturnValueInt();
3351 }
3352 
3353 int BRPOP(
3354  string key,
3355  // Redis type: integer
3356  int timeout
3357 ) {
3358  NWNX_PushArgumentString("BRPOP");
3360  NWNX_PushArgumentString(IntToString(timeout));
3361  NWNX_CallFunction("NWNX_Redis", "Deferred");
3362  return NWNX_GetReturnValueInt();
3363 }
3364 
3366  // Redis type: key
3367  string source,
3368  // Redis type: key
3369  string destination,
3370  // Redis type: integer
3371  int timeout
3372 ) {
3373  NWNX_PushArgumentString("BRPOPLPUSH");
3374  NWNX_PushArgumentString(source);
3375  NWNX_PushArgumentString(destination);
3376  NWNX_PushArgumentString(IntToString(timeout));
3377  NWNX_CallFunction("NWNX_Redis", "Deferred");
3378  return NWNX_GetReturnValueInt();
3379 }
3380 
3382  string key,
3383  // Redis type: integer
3384  int timeout
3385 ) {
3386  NWNX_PushArgumentString("BZPOPMIN");
3388  NWNX_PushArgumentString(IntToString(timeout));
3389  NWNX_CallFunction("NWNX_Redis", "Deferred");
3390  return NWNX_GetReturnValueInt();
3391 }
3392 
3394  string key,
3395  // Redis type: integer
3396  int timeout
3397 ) {
3398  NWNX_PushArgumentString("BZPOPMAX");
3400  NWNX_PushArgumentString(IntToString(timeout));
3401  NWNX_CallFunction("NWNX_Redis", "Deferred");
3402  return NWNX_GetReturnValueInt();
3403 }
3404 
3405 int CLIENT_ID() {
3406  NWNX_PushArgumentString("CLIENT_ID");
3407  NWNX_CallFunction("NWNX_Redis", "Deferred");
3408  return NWNX_GetReturnValueInt();
3409 }
3410 
3412  string ip_port = "",
3413  // Redis type: integer
3414  int id_client_id = 0,
3415  string addr_ip_port = "",
3416  string skipme_yes_no = ""
3417 ) {
3418  NWNX_PushArgumentString("CLIENT_KILL");
3419  if (ip_port != "") NWNX_PushArgumentString(ip_port);
3420  if (id_client_id != 0) NWNX_PushArgumentString(IntToString(id_client_id));
3421  if (addr_ip_port != "") NWNX_PushArgumentString(addr_ip_port);
3422  if (skipme_yes_no != "") NWNX_PushArgumentString(skipme_yes_no);
3423  NWNX_CallFunction("NWNX_Redis", "Deferred");
3424  return NWNX_GetReturnValueInt();
3425 }
3426 
3428  NWNX_PushArgumentString("CLIENT_LIST");
3429  NWNX_CallFunction("NWNX_Redis", "Deferred");
3430  return NWNX_GetReturnValueInt();
3431 }
3432 
3434  NWNX_PushArgumentString("CLIENT_GETNAME");
3435  NWNX_CallFunction("NWNX_Redis", "Deferred");
3436  return NWNX_GetReturnValueInt();
3437 }
3438 
3440  // Redis type: integer
3441  int timeout
3442 ) {
3443  NWNX_PushArgumentString("CLIENT_PAUSE");
3444  NWNX_PushArgumentString(IntToString(timeout));
3445  NWNX_CallFunction("NWNX_Redis", "Deferred");
3446  return NWNX_GetReturnValueInt();
3447 }
3448 
3450  // Redis type: enum
3451  string reply_mode
3452 ) {
3453  NWNX_PushArgumentString("CLIENT_REPLY");
3454  NWNX_PushArgumentString(reply_mode);
3455  NWNX_CallFunction("NWNX_Redis", "Deferred");
3456  return NWNX_GetReturnValueInt();
3457 }
3458 
3460  string connection_name
3461 ) {
3462  NWNX_PushArgumentString("CLIENT_SETNAME");
3463  NWNX_PushArgumentString(connection_name);
3464  NWNX_CallFunction("NWNX_Redis", "Deferred");
3465  return NWNX_GetReturnValueInt();
3466 }
3467 
3469  string client_id,
3470  // Redis type: enum
3471  string unblock_type = ""
3472 ) {
3473  NWNX_PushArgumentString("CLIENT_UNBLOCK");
3474  NWNX_PushArgumentString(client_id);
3475  if (unblock_type != "") NWNX_PushArgumentString(unblock_type);
3476  NWNX_CallFunction("NWNX_Redis", "Deferred");
3477  return NWNX_GetReturnValueInt();
3478 }
3479 
3481  // Redis type: integer
3482  int slot
3483 ) {
3484  NWNX_PushArgumentString("CLUSTER_ADDSLOTS");
3485  NWNX_PushArgumentString(IntToString(slot));
3486  NWNX_CallFunction("NWNX_Redis", "Deferred");
3487  return NWNX_GetReturnValueInt();
3488 }
3489 
3491  string node_id
3492 ) {
3493  NWNX_PushArgumentString("CLUSTER_COUNT_FAILURE_REPORTS");
3494  NWNX_PushArgumentString(node_id);
3495  NWNX_CallFunction("NWNX_Redis", "Deferred");
3496  return NWNX_GetReturnValueInt();
3497 }
3498 
3500  // Redis type: integer
3501  int slot
3502 ) {
3503  NWNX_PushArgumentString("CLUSTER_COUNTKEYSINSLOT");
3504  NWNX_PushArgumentString(IntToString(slot));
3505  NWNX_CallFunction("NWNX_Redis", "Deferred");
3506  return NWNX_GetReturnValueInt();
3507 }
3508 
3510  // Redis type: integer
3511  int slot
3512 ) {
3513  NWNX_PushArgumentString("CLUSTER_DELSLOTS");
3514  NWNX_PushArgumentString(IntToString(slot));
3515  NWNX_CallFunction("NWNX_Redis", "Deferred");
3516  return NWNX_GetReturnValueInt();
3517 }
3518 
3520  // Redis type: enum
3521  string options = ""
3522 ) {
3523  NWNX_PushArgumentString("CLUSTER_FAILOVER");
3524  if (options != "") NWNX_PushArgumentString(options);
3525  NWNX_CallFunction("NWNX_Redis", "Deferred");
3526  return NWNX_GetReturnValueInt();
3527 }
3528 
3530  string node_id
3531 ) {
3532  NWNX_PushArgumentString("CLUSTER_FORGET");
3533  NWNX_PushArgumentString(node_id);
3534  NWNX_CallFunction("NWNX_Redis", "Deferred");
3535  return NWNX_GetReturnValueInt();
3536 }
3537 
3539  // Redis type: integer
3540  int slot,
3541  // Redis type: integer
3542  int count
3543 ) {
3544  NWNX_PushArgumentString("CLUSTER_GETKEYSINSLOT");
3545  NWNX_PushArgumentString(IntToString(slot));
3546  NWNX_PushArgumentString(IntToString(count));
3547  NWNX_CallFunction("NWNX_Redis", "Deferred");
3548  return NWNX_GetReturnValueInt();
3549 }
3550 
3552  NWNX_PushArgumentString("CLUSTER_INFO");
3553  NWNX_CallFunction("NWNX_Redis", "Deferred");
3554  return NWNX_GetReturnValueInt();
3555 }
3556 
3558  string key
3559 ) {
3560  NWNX_PushArgumentString("CLUSTER_KEYSLOT");
3562  NWNX_CallFunction("NWNX_Redis", "Deferred");
3563  return NWNX_GetReturnValueInt();
3564 }
3565 
3567  string ip,
3568  // Redis type: integer
3569  int port
3570 ) {
3571  NWNX_PushArgumentString("CLUSTER_MEET");
3573  NWNX_PushArgumentString(IntToString(port));
3574  NWNX_CallFunction("NWNX_Redis", "Deferred");
3575  return NWNX_GetReturnValueInt();
3576 }
3577 
3579  NWNX_PushArgumentString("CLUSTER_NODES");
3580  NWNX_CallFunction("NWNX_Redis", "Deferred");
3581  return NWNX_GetReturnValueInt();
3582 }
3583 
3585  string node_id
3586 ) {
3587  NWNX_PushArgumentString("CLUSTER_REPLICATE");
3588  NWNX_PushArgumentString(node_id);
3589  NWNX_CallFunction("NWNX_Redis", "Deferred");
3590  return NWNX_GetReturnValueInt();
3591 }
3592 
3594  // Redis type: enum
3595  string reset_type = ""
3596 ) {
3597  NWNX_PushArgumentString("CLUSTER_RESET");
3598  if (reset_type != "") NWNX_PushArgumentString(reset_type);
3599  NWNX_CallFunction("NWNX_Redis", "Deferred");
3600  return NWNX_GetReturnValueInt();
3601 }
3602 
3604  NWNX_PushArgumentString("CLUSTER_SAVECONFIG");
3605  NWNX_CallFunction("NWNX_Redis", "Deferred");
3606  return NWNX_GetReturnValueInt();
3607 }
3608 
3610  // Redis type: integer
3611  int config_epoch
3612 ) {
3613  NWNX_PushArgumentString("CLUSTER_SET_CONFIG_EPOCH");
3614  NWNX_PushArgumentString(IntToString(config_epoch));
3615  NWNX_CallFunction("NWNX_Redis", "Deferred");
3616  return NWNX_GetReturnValueInt();
3617 }
3618 
3620  // Redis type: integer
3621  int slot,
3622  // Redis type: enum
3623  string subcommand,
3624  string node_id = ""
3625 ) {
3626  NWNX_PushArgumentString("CLUSTER_SETSLOT");
3627  NWNX_PushArgumentString(IntToString(slot));
3628  NWNX_PushArgumentString(subcommand);
3629  if (node_id != "") NWNX_PushArgumentString(node_id);
3630  NWNX_CallFunction("NWNX_Redis", "Deferred");
3631  return NWNX_GetReturnValueInt();
3632 }
3633 
3635  string node_id
3636 ) {
3637  NWNX_PushArgumentString("CLUSTER_SLAVES");
3638  NWNX_PushArgumentString(node_id);
3639  NWNX_CallFunction("NWNX_Redis", "Deferred");
3640  return NWNX_GetReturnValueInt();
3641 }
3642 
3644  string node_id
3645 ) {
3646  NWNX_PushArgumentString("CLUSTER_REPLICAS");
3647  NWNX_PushArgumentString(node_id);
3648  NWNX_CallFunction("NWNX_Redis", "Deferred");
3649  return NWNX_GetReturnValueInt();
3650 }
3651 
3653  NWNX_PushArgumentString("CLUSTER_SLOTS");
3654  NWNX_CallFunction("NWNX_Redis", "Deferred");
3655  return NWNX_GetReturnValueInt();
3656 }
3657 
3658 int COMMAND() {
3659  NWNX_PushArgumentString("COMMAND");
3660  NWNX_CallFunction("NWNX_Redis", "Deferred");
3661  return NWNX_GetReturnValueInt();
3662 }
3663 
3665  NWNX_PushArgumentString("COMMAND_COUNT");
3666  NWNX_CallFunction("NWNX_Redis", "Deferred");
3667  return NWNX_GetReturnValueInt();
3668 }
3669 
3671  NWNX_PushArgumentString("COMMAND_GETKEYS");
3672  NWNX_CallFunction("NWNX_Redis", "Deferred");
3673  return NWNX_GetReturnValueInt();
3674 }
3675 
3677  string command_name
3678 ) {
3679  NWNX_PushArgumentString("COMMAND_INFO");
3680  NWNX_PushArgumentString(command_name);
3681  NWNX_CallFunction("NWNX_Redis", "Deferred");
3682  return NWNX_GetReturnValueInt();
3683 }
3684 
3686  string parameter
3687 ) {
3688  NWNX_PushArgumentString("CONFIG_GET");
3689  NWNX_PushArgumentString(parameter);
3690  NWNX_CallFunction("NWNX_Redis", "Deferred");
3691  return NWNX_GetReturnValueInt();
3692 }
3693 
3695  NWNX_PushArgumentString("CONFIG_REWRITE");
3696  NWNX_CallFunction("NWNX_Redis", "Deferred");
3697  return NWNX_GetReturnValueInt();
3698 }
3699 
3701  string parameter,
3702  string value
3703 ) {
3704  NWNX_PushArgumentString("CONFIG_SET");
3705  NWNX_PushArgumentString(parameter);
3706  NWNX_PushArgumentString(value);
3707  NWNX_CallFunction("NWNX_Redis", "Deferred");
3708  return NWNX_GetReturnValueInt();
3709 }
3710 
3712  NWNX_PushArgumentString("CONFIG_RESETSTAT");
3713  NWNX_CallFunction("NWNX_Redis", "Deferred");
3714  return NWNX_GetReturnValueInt();
3715 }
3716 
3717 int DBSIZE() {
3718  NWNX_PushArgumentString("DBSIZE");
3719  NWNX_CallFunction("NWNX_Redis", "Deferred");
3720  return NWNX_GetReturnValueInt();
3721 }
3722 
3724  string key
3725 ) {
3726  NWNX_PushArgumentString("DEBUG_OBJECT");
3728  NWNX_CallFunction("NWNX_Redis", "Deferred");
3729  return NWNX_GetReturnValueInt();
3730 }
3731 
3733  NWNX_PushArgumentString("DEBUG_SEGFAULT");
3734  NWNX_CallFunction("NWNX_Redis", "Deferred");
3735  return NWNX_GetReturnValueInt();
3736 }
3737 
3738 int DECR(
3739  string key
3740 ) {
3741  NWNX_PushArgumentString("DECR");
3743  NWNX_CallFunction("NWNX_Redis", "Deferred");
3744  return NWNX_GetReturnValueInt();
3745 }
3746 
3748  string key,
3749  // Redis type: integer
3750  int decrement
3751 ) {
3752  NWNX_PushArgumentString("DECRBY");
3754  NWNX_PushArgumentString(IntToString(decrement));
3755  NWNX_CallFunction("NWNX_Redis", "Deferred");
3756  return NWNX_GetReturnValueInt();
3757 }
3758 
3759 int DEL(
3760  string key
3761 ) {
3762  NWNX_PushArgumentString("DEL");
3764  NWNX_CallFunction("NWNX_Redis", "Deferred");
3765  return NWNX_GetReturnValueInt();
3766 }
3767 
3768 int DISCARD() {
3769  NWNX_PushArgumentString("DISCARD");
3770  NWNX_CallFunction("NWNX_Redis", "Deferred");
3771  return NWNX_GetReturnValueInt();
3772 }
3773 
3774 int DUMP(
3775  string key
3776 ) {
3777  NWNX_PushArgumentString("DUMP");
3779  NWNX_CallFunction("NWNX_Redis", "Deferred");
3780  return NWNX_GetReturnValueInt();
3781 }
3782 
3783 int ECHO(
3784  string message
3785 ) {
3786  NWNX_PushArgumentString("ECHO");
3788  NWNX_CallFunction("NWNX_Redis", "Deferred");
3789  return NWNX_GetReturnValueInt();
3790 }
3791 
3792 int EVAL(
3793  string script,
3794  // Redis type: integer
3795  int numkeys,
3796  string key,
3797  string arg
3798 ) {
3799  NWNX_PushArgumentString("EVAL");
3800  NWNX_PushArgumentString(script);
3801  NWNX_PushArgumentString(IntToString(numkeys));
3804  NWNX_CallFunction("NWNX_Redis", "Deferred");
3805  return NWNX_GetReturnValueInt();
3806 }
3807 
3809  string sha1,
3810  // Redis type: integer
3811  int numkeys,
3812  string key,
3813  string arg
3814 ) {
3815  NWNX_PushArgumentString("EVALSHA");
3817  NWNX_PushArgumentString(IntToString(numkeys));
3820  NWNX_CallFunction("NWNX_Redis", "Deferred");
3821  return NWNX_GetReturnValueInt();
3822 }
3823 
3824 int EXEC() {
3825  NWNX_PushArgumentString("EXEC");
3826  NWNX_CallFunction("NWNX_Redis", "Deferred");
3827  return NWNX_GetReturnValueInt();
3828 }
3829 
3831  string key
3832 ) {
3833  NWNX_PushArgumentString("EXISTS");
3835  NWNX_CallFunction("NWNX_Redis", "Deferred");
3836  return NWNX_GetReturnValueInt();
3837 }
3838 
3840  string key,
3841  // Redis type: integer
3842  int seconds
3843 ) {
3844  NWNX_PushArgumentString("EXPIRE");
3846  NWNX_PushArgumentString(IntToString(seconds));
3847  NWNX_CallFunction("NWNX_Redis", "Deferred");
3848  return NWNX_GetReturnValueInt();
3849 }
3850 
3852  string key,
3853  // Redis type: posix time
3854  string timestamp
3855 ) {
3856  NWNX_PushArgumentString("EXPIREAT");
3858  NWNX_PushArgumentString(timestamp);
3859  NWNX_CallFunction("NWNX_Redis", "Deferred");
3860  return NWNX_GetReturnValueInt();
3861 }
3862 
3864  // Redis type: enum
3865  string async = ""
3866 ) {
3867  NWNX_PushArgumentString("FLUSHALL");
3868  if (async != "") NWNX_PushArgumentString(async);
3869  NWNX_CallFunction("NWNX_Redis", "Deferred");
3870  return NWNX_GetReturnValueInt();
3871 }
3872 
3874  // Redis type: enum
3875  string async = ""
3876 ) {
3877  NWNX_PushArgumentString("FLUSHDB");
3878  if (async != "") NWNX_PushArgumentString(async);
3879  NWNX_CallFunction("NWNX_Redis", "Deferred");
3880  return NWNX_GetReturnValueInt();
3881 }
3882 
3884  string key,
3885  // Redis type: double
3886  float longitude,
3887  // Redis type: double
3888  float latitude,
3889  string member
3890 ) {
3891  NWNX_PushArgumentString("GEOADD");
3893  NWNX_PushArgumentString(FloatToString(longitude, 0));
3894  NWNX_PushArgumentString(FloatToString(latitude, 0));
3895  NWNX_PushArgumentString(member);
3896  NWNX_CallFunction("NWNX_Redis", "Deferred");
3897  return NWNX_GetReturnValueInt();
3898 }
3899 
3901  string key,
3902  string member
3903 ) {
3904  NWNX_PushArgumentString("GEOHASH");
3906  NWNX_PushArgumentString(member);
3907  NWNX_CallFunction("NWNX_Redis", "Deferred");
3908  return NWNX_GetReturnValueInt();
3909 }
3910 
3912  string key,
3913  string member
3914 ) {
3915  NWNX_PushArgumentString("GEOPOS");
3917  NWNX_PushArgumentString(member);
3918  NWNX_CallFunction("NWNX_Redis", "Deferred");
3919  return NWNX_GetReturnValueInt();
3920 }
3921 
3923  string key,
3924  string member1,
3925  string member2,
3926  string unit = ""
3927 ) {
3928  NWNX_PushArgumentString("GEODIST");
3930  NWNX_PushArgumentString(member1);
3931  NWNX_PushArgumentString(member2);
3932  if (unit != "") NWNX_PushArgumentString(unit);
3933  NWNX_CallFunction("NWNX_Redis", "Deferred");
3934  return NWNX_GetReturnValueInt();
3935 }
3936 
3938  string key,
3939  // Redis type: double
3940  float longitude,
3941  // Redis type: double
3942  float latitude,
3943  // Redis type: double
3944  float radius,
3945  // Redis type: enum
3946  string unit,
3947  // Redis type: enum
3948  string withcoord = "",
3949  // Redis type: enum
3950  string withdist = "",
3951  // Redis type: enum
3952  string withhash = "",
3953  // Redis type: integer
3954  int count_count = 0,
3955  // Redis type: enum
3956  string order = "",
3957  // Redis type: key
3958  string store_key = "",
3959  // Redis type: key
3960  string storedist_key = ""
3961 ) {
3962  NWNX_PushArgumentString("GEORADIUS");
3964  NWNX_PushArgumentString(FloatToString(longitude, 0));
3965  NWNX_PushArgumentString(FloatToString(latitude, 0));
3966  NWNX_PushArgumentString(FloatToString(radius, 0));
3968  if (withcoord != "") NWNX_PushArgumentString(withcoord);
3969  if (withdist != "") NWNX_PushArgumentString(withdist);
3970  if (withhash != "") NWNX_PushArgumentString(withhash);
3971  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
3972  if (order != "") NWNX_PushArgumentString(order);
3973  if (store_key != "") NWNX_PushArgumentString(store_key);
3974  if (storedist_key != "") NWNX_PushArgumentString(storedist_key);
3975  NWNX_CallFunction("NWNX_Redis", "Deferred");
3976  return NWNX_GetReturnValueInt();
3977 }
3978 
3980  string key,
3981  string member,
3982  // Redis type: double
3983  float radius,
3984  // Redis type: enum
3985  string unit,
3986  // Redis type: enum
3987  string withcoord = "",
3988  // Redis type: enum
3989  string withdist = "",
3990  // Redis type: enum
3991  string withhash = "",
3992  // Redis type: integer
3993  int count_count = 0,
3994  // Redis type: enum
3995  string order = "",
3996  // Redis type: key
3997  string store_key = "",
3998  // Redis type: key
3999  string storedist_key = ""
4000 ) {
4001  NWNX_PushArgumentString("GEORADIUSBYMEMBER");
4003  NWNX_PushArgumentString(member);
4004  NWNX_PushArgumentString(FloatToString(radius, 0));
4006  if (withcoord != "") NWNX_PushArgumentString(withcoord);
4007  if (withdist != "") NWNX_PushArgumentString(withdist);
4008  if (withhash != "") NWNX_PushArgumentString(withhash);
4009  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
4010  if (order != "") NWNX_PushArgumentString(order);
4011  if (store_key != "") NWNX_PushArgumentString(store_key);
4012  if (storedist_key != "") NWNX_PushArgumentString(storedist_key);
4013  NWNX_CallFunction("NWNX_Redis", "Deferred");
4014  return NWNX_GetReturnValueInt();
4015 }
4016 
4017 int GET(
4018  string key
4019 ) {
4020  NWNX_PushArgumentString("GET");
4022  NWNX_CallFunction("NWNX_Redis", "Deferred");
4023  return NWNX_GetReturnValueInt();
4024 }
4025 
4027  string key,
4028  // Redis type: integer
4029  int offset
4030 ) {
4031  NWNX_PushArgumentString("GETBIT");
4033  NWNX_PushArgumentString(IntToString(offset));
4034  NWNX_CallFunction("NWNX_Redis", "Deferred");
4035  return NWNX_GetReturnValueInt();
4036 }
4037 
4039  string key,
4040  // Redis type: integer
4041  int start,
4042  // Redis type: integer
4043  int end
4044 ) {
4045  NWNX_PushArgumentString("GETRANGE");
4047  NWNX_PushArgumentString(IntToString(start));
4048  NWNX_PushArgumentString(IntToString(end));
4049  NWNX_CallFunction("NWNX_Redis", "Deferred");
4050  return NWNX_GetReturnValueInt();
4051 }
4052 
4054  string key,
4055  string value
4056 ) {
4057  NWNX_PushArgumentString("GETSET");
4059  NWNX_PushArgumentString(value);
4060  NWNX_CallFunction("NWNX_Redis", "Deferred");
4061  return NWNX_GetReturnValueInt();
4062 }
4063 
4064 int HDEL(
4065  string key,
4066  string field
4067 ) {
4068  NWNX_PushArgumentString("HDEL");
4070  NWNX_PushArgumentString(field);
4071  NWNX_CallFunction("NWNX_Redis", "Deferred");
4072  return NWNX_GetReturnValueInt();
4073 }
4074 
4076  string key,
4077  string field
4078 ) {
4079  NWNX_PushArgumentString("HEXISTS");
4081  NWNX_PushArgumentString(field);
4082  NWNX_CallFunction("NWNX_Redis", "Deferred");
4083  return NWNX_GetReturnValueInt();
4084 }
4085 
4086 int HGET(
4087  string key,
4088  string field
4089 ) {
4090  NWNX_PushArgumentString("HGET");
4092  NWNX_PushArgumentString(field);
4093  NWNX_CallFunction("NWNX_Redis", "Deferred");
4094  return NWNX_GetReturnValueInt();
4095 }
4096 
4098  string key
4099 ) {
4100  NWNX_PushArgumentString("HGETALL");
4102  NWNX_CallFunction("NWNX_Redis", "Deferred");
4103  return NWNX_GetReturnValueInt();
4104 }
4105 
4107  string key,
4108  string field,
4109  // Redis type: integer
4110  int increment
4111 ) {
4112  NWNX_PushArgumentString("HINCRBY");
4114  NWNX_PushArgumentString(field);
4115  NWNX_PushArgumentString(IntToString(increment));
4116  NWNX_CallFunction("NWNX_Redis", "Deferred");
4117  return NWNX_GetReturnValueInt();
4118 }
4119 
4121  string key,
4122  string field,
4123  // Redis type: double
4124  float increment
4125 ) {
4126  NWNX_PushArgumentString("HINCRBYFLOAT");
4128  NWNX_PushArgumentString(field);
4129  NWNX_PushArgumentString(FloatToString(increment, 0));
4130  NWNX_CallFunction("NWNX_Redis", "Deferred");
4131  return NWNX_GetReturnValueInt();
4132 }
4133 
4134 int HKEYS(
4135  string key
4136 ) {
4137  NWNX_PushArgumentString("HKEYS");
4139  NWNX_CallFunction("NWNX_Redis", "Deferred");
4140  return NWNX_GetReturnValueInt();
4141 }
4142 
4143 int HLEN(
4144  string key
4145 ) {
4146  NWNX_PushArgumentString("HLEN");
4148  NWNX_CallFunction("NWNX_Redis", "Deferred");
4149  return NWNX_GetReturnValueInt();
4150 }
4151 
4152 int HMGET(
4153  string key,
4154  string field
4155 ) {
4156  NWNX_PushArgumentString("HMGET");
4158  NWNX_PushArgumentString(field);
4159  NWNX_CallFunction("NWNX_Redis", "Deferred");
4160  return NWNX_GetReturnValueInt();
4161 }
4162 
4163 int HMSET(
4164  string key,
4165  string field,
4166  string value
4167 ) {
4168  NWNX_PushArgumentString("HMSET");
4170  NWNX_PushArgumentString(field);
4171  NWNX_PushArgumentString(value);
4172  NWNX_CallFunction("NWNX_Redis", "Deferred");
4173  return NWNX_GetReturnValueInt();
4174 }
4175 
4176 int HSET(
4177  string key,
4178  string field,
4179  string value
4180 ) {
4181  NWNX_PushArgumentString("HSET");
4183  NWNX_PushArgumentString(field);
4184  NWNX_PushArgumentString(value);
4185  NWNX_CallFunction("NWNX_Redis", "Deferred");
4186  return NWNX_GetReturnValueInt();
4187 }
4188 
4190  string key,
4191  string field,
4192  string value
4193 ) {
4194  NWNX_PushArgumentString("HSETNX");
4196  NWNX_PushArgumentString(field);
4197  NWNX_PushArgumentString(value);
4198  NWNX_CallFunction("NWNX_Redis", "Deferred");
4199  return NWNX_GetReturnValueInt();
4200 }
4201 
4203  string key,
4204  string field
4205 ) {
4206  NWNX_PushArgumentString("HSTRLEN");
4208  NWNX_PushArgumentString(field);
4209  NWNX_CallFunction("NWNX_Redis", "Deferred");
4210  return NWNX_GetReturnValueInt();
4211 }
4212 
4213 int HVALS(
4214  string key
4215 ) {
4216  NWNX_PushArgumentString("HVALS");
4218  NWNX_CallFunction("NWNX_Redis", "Deferred");
4219  return NWNX_GetReturnValueInt();
4220 }
4221 
4222 int INCR(
4223  string key
4224 ) {
4225  NWNX_PushArgumentString("INCR");
4227  NWNX_CallFunction("NWNX_Redis", "Deferred");
4228  return NWNX_GetReturnValueInt();
4229 }
4230 
4232  string key,
4233  // Redis type: integer
4234  int increment
4235 ) {
4236  NWNX_PushArgumentString("INCRBY");
4238  NWNX_PushArgumentString(IntToString(increment));
4239  NWNX_CallFunction("NWNX_Redis", "Deferred");
4240  return NWNX_GetReturnValueInt();
4241 }
4242 
4244  string key,
4245  // Redis type: double
4246  float increment
4247 ) {
4248  NWNX_PushArgumentString("INCRBYFLOAT");
4250  NWNX_PushArgumentString(FloatToString(increment, 0));
4251  NWNX_CallFunction("NWNX_Redis", "Deferred");
4252  return NWNX_GetReturnValueInt();
4253 }
4254 
4255 int INFO(
4256  string section = ""
4257 ) {
4258  NWNX_PushArgumentString("INFO");
4259  if (section != "") NWNX_PushArgumentString(section);
4260  NWNX_CallFunction("NWNX_Redis", "Deferred");
4261  return NWNX_GetReturnValueInt();
4262 }
4263 
4264 int KEYS(
4265  string pattern
4266 ) {
4267  NWNX_PushArgumentString("KEYS");
4268  NWNX_PushArgumentString(pattern);
4269  NWNX_CallFunction("NWNX_Redis", "Deferred");
4270  return NWNX_GetReturnValueInt();
4271 }
4272 
4273 int LASTSAVE() {
4274  NWNX_PushArgumentString("LASTSAVE");
4275  NWNX_CallFunction("NWNX_Redis", "Deferred");
4276  return NWNX_GetReturnValueInt();
4277 }
4278 
4280  string key,
4281  // Redis type: integer
4282  int index
4283 ) {
4284  NWNX_PushArgumentString("LINDEX");
4286  NWNX_PushArgumentString(IntToString(index));
4287  NWNX_CallFunction("NWNX_Redis", "Deferred");
4288  return NWNX_GetReturnValueInt();
4289 }
4290 
4292  string key,
4293  // Redis type: enum
4294  string where,
4295  string pivot,
4296  string value
4297 ) {
4298  NWNX_PushArgumentString("LINSERT");
4300  NWNX_PushArgumentString(where);
4301  NWNX_PushArgumentString(pivot);
4302  NWNX_PushArgumentString(value);
4303  NWNX_CallFunction("NWNX_Redis", "Deferred");
4304  return NWNX_GetReturnValueInt();
4305 }
4306 
4307 int LLEN(
4308  string key
4309 ) {
4310  NWNX_PushArgumentString("LLEN");
4312  NWNX_CallFunction("NWNX_Redis", "Deferred");
4313  return NWNX_GetReturnValueInt();
4314 }
4315 
4316 int LPOP(
4317  string key
4318 ) {
4319  NWNX_PushArgumentString("LPOP");
4321  NWNX_CallFunction("NWNX_Redis", "Deferred");
4322  return NWNX_GetReturnValueInt();
4323 }
4324 
4325 int LPUSH(
4326  string key,
4327  string value
4328 ) {
4329  NWNX_PushArgumentString("LPUSH");
4331  NWNX_PushArgumentString(value);
4332  NWNX_CallFunction("NWNX_Redis", "Deferred");
4333  return NWNX_GetReturnValueInt();
4334 }
4335 
4337  string key,
4338  string value
4339 ) {
4340  NWNX_PushArgumentString("LPUSHX");
4342  NWNX_PushArgumentString(value);
4343  NWNX_CallFunction("NWNX_Redis", "Deferred");
4344  return NWNX_GetReturnValueInt();
4345 }
4346 
4348  string key,
4349  // Redis type: integer
4350  int start,
4351  // Redis type: integer
4352  int stop
4353 ) {
4354  NWNX_PushArgumentString("LRANGE");
4356  NWNX_PushArgumentString(IntToString(start));
4357  NWNX_PushArgumentString(IntToString(stop));
4358  NWNX_CallFunction("NWNX_Redis", "Deferred");
4359  return NWNX_GetReturnValueInt();
4360 }
4361 
4362 int LREM(
4363  string key,
4364  // Redis type: integer
4365  int count,
4366  string value
4367 ) {
4368  NWNX_PushArgumentString("LREM");
4370  NWNX_PushArgumentString(IntToString(count));
4371  NWNX_PushArgumentString(value);
4372  NWNX_CallFunction("NWNX_Redis", "Deferred");
4373  return NWNX_GetReturnValueInt();
4374 }
4375 
4376 int LSET(
4377  string key,
4378  // Redis type: integer
4379  int index,
4380  string value
4381 ) {
4382  NWNX_PushArgumentString("LSET");
4384  NWNX_PushArgumentString(IntToString(index));
4385  NWNX_PushArgumentString(value);
4386  NWNX_CallFunction("NWNX_Redis", "Deferred");
4387  return NWNX_GetReturnValueInt();
4388 }
4389 
4390 int LTRIM(
4391  string key,
4392  // Redis type: integer
4393  int start,
4394  // Redis type: integer
4395  int stop
4396 ) {
4397  NWNX_PushArgumentString("LTRIM");
4399  NWNX_PushArgumentString(IntToString(start));
4400  NWNX_PushArgumentString(IntToString(stop));
4401  NWNX_CallFunction("NWNX_Redis", "Deferred");
4402  return NWNX_GetReturnValueInt();
4403 }
4404 
4406  NWNX_PushArgumentString("MEMORY_DOCTOR");
4407  NWNX_CallFunction("NWNX_Redis", "Deferred");
4408  return NWNX_GetReturnValueInt();
4409 }
4410 
4412  NWNX_PushArgumentString("MEMORY_HELP");
4413  NWNX_CallFunction("NWNX_Redis", "Deferred");
4414  return NWNX_GetReturnValueInt();
4415 }
4416 
4418  NWNX_PushArgumentString("MEMORY_MALLOC_STATS");
4419  NWNX_CallFunction("NWNX_Redis", "Deferred");
4420  return NWNX_GetReturnValueInt();
4421 }
4422 
4424  NWNX_PushArgumentString("MEMORY_PURGE");
4425  NWNX_CallFunction("NWNX_Redis", "Deferred");
4426  return NWNX_GetReturnValueInt();
4427 }
4428 
4430  NWNX_PushArgumentString("MEMORY_STATS");
4431  NWNX_CallFunction("NWNX_Redis", "Deferred");
4432  return NWNX_GetReturnValueInt();
4433 }
4434 
4436  string key,
4437  // Redis type: integer
4438  int samples_count = 0
4439 ) {
4440  NWNX_PushArgumentString("MEMORY_USAGE");
4442  if (samples_count != 0) NWNX_PushArgumentString(IntToString(samples_count));
4443  NWNX_CallFunction("NWNX_Redis", "Deferred");
4444  return NWNX_GetReturnValueInt();
4445 }
4446 
4447 int MGET(
4448  string key
4449 ) {
4450  NWNX_PushArgumentString("MGET");
4452  NWNX_CallFunction("NWNX_Redis", "Deferred");
4453  return NWNX_GetReturnValueInt();
4454 }
4455 
4457  string host,
4458  string port,
4459  // Redis type: enum
4460  string key,
4461  // Redis type: integer
4462  int destination_db,
4463  // Redis type: integer
4464  int timeout,
4465  // Redis type: enum
4466  string copy = "",
4467  // Redis type: enum
4468  string replace = "",
4469  string auth_password = "",
4470  // Redis type: key
4471  string keys_key = ""
4472 ) {
4473  NWNX_PushArgumentString("MIGRATE");
4477  NWNX_PushArgumentString(IntToString(destination_db));
4478  NWNX_PushArgumentString(IntToString(timeout));
4479  if (copy != "") NWNX_PushArgumentString(copy);
4480  if (replace != "") NWNX_PushArgumentString(replace);
4481  if (auth_password != "") NWNX_PushArgumentString(auth_password);
4482  if (keys_key != "") NWNX_PushArgumentString(keys_key);
4483  NWNX_CallFunction("NWNX_Redis", "Deferred");
4484  return NWNX_GetReturnValueInt();
4485 }
4486 
4487 int MONITOR() {
4488  NWNX_PushArgumentString("MONITOR");
4489  NWNX_CallFunction("NWNX_Redis", "Deferred");
4490  return NWNX_GetReturnValueInt();
4491 }
4492 
4493 int MOVE(
4494  string key,
4495  // Redis type: integer
4496  int db
4497 ) {
4498  NWNX_PushArgumentString("MOVE");
4500  NWNX_PushArgumentString(IntToString(db));
4501  NWNX_CallFunction("NWNX_Redis", "Deferred");
4502  return NWNX_GetReturnValueInt();
4503 }
4504 
4505 int MSET(
4506  string key,
4507  string value
4508 ) {
4509  NWNX_PushArgumentString("MSET");
4511  NWNX_PushArgumentString(value);
4512  NWNX_CallFunction("NWNX_Redis", "Deferred");
4513  return NWNX_GetReturnValueInt();
4514 }
4515 
4517  string key,
4518  string value
4519 ) {
4520  NWNX_PushArgumentString("MSETNX");
4522  NWNX_PushArgumentString(value);
4523  NWNX_CallFunction("NWNX_Redis", "Deferred");
4524  return NWNX_GetReturnValueInt();
4525 }
4526 
4527 int MULTI() {
4528  NWNX_PushArgumentString("MULTI");
4529  NWNX_CallFunction("NWNX_Redis", "Deferred");
4530  return NWNX_GetReturnValueInt();
4531 }
4532 
4534  string subcommand,
4535  string arguments = ""
4536 ) {
4537  NWNX_PushArgumentString("OBJECT");
4538  NWNX_PushArgumentString(subcommand);
4539  if (arguments != "") NWNX_PushArgumentString(arguments);
4540  NWNX_CallFunction("NWNX_Redis", "Deferred");
4541  return NWNX_GetReturnValueInt();
4542 }
4543 
4545  string key
4546 ) {
4547  NWNX_PushArgumentString("PERSIST");
4549  NWNX_CallFunction("NWNX_Redis", "Deferred");
4550  return NWNX_GetReturnValueInt();
4551 }
4552 
4554  string key,
4555  // Redis type: integer
4556  int milliseconds
4557 ) {
4558  NWNX_PushArgumentString("PEXPIRE");
4560  NWNX_PushArgumentString(IntToString(milliseconds));
4561  NWNX_CallFunction("NWNX_Redis", "Deferred");
4562  return NWNX_GetReturnValueInt();
4563 }
4564 
4566  string key,
4567  // Redis type: posix time
4568  string milliseconds_timestamp
4569 ) {
4570  NWNX_PushArgumentString("PEXPIREAT");
4572  NWNX_PushArgumentString(milliseconds_timestamp);
4573  NWNX_CallFunction("NWNX_Redis", "Deferred");
4574  return NWNX_GetReturnValueInt();
4575 }
4576 
4577 int PFADD(
4578  string key,
4579  string element
4580 ) {
4581  NWNX_PushArgumentString("PFADD");
4583  NWNX_PushArgumentString(element);
4584  NWNX_CallFunction("NWNX_Redis", "Deferred");
4585  return NWNX_GetReturnValueInt();
4586 }
4587 
4589  string key
4590 ) {
4591  NWNX_PushArgumentString("PFCOUNT");
4593  NWNX_CallFunction("NWNX_Redis", "Deferred");
4594  return NWNX_GetReturnValueInt();
4595 }
4596 
4598  // Redis type: key
4599  string destkey,
4600  // Redis type: key
4601  string sourcekey
4602 ) {
4603  NWNX_PushArgumentString("PFMERGE");
4604  NWNX_PushArgumentString(destkey);
4605  NWNX_PushArgumentString(sourcekey);
4606  NWNX_CallFunction("NWNX_Redis", "Deferred");
4607  return NWNX_GetReturnValueInt();
4608 }
4609 
4610 int PING(
4611  string message = ""
4612 ) {
4613  NWNX_PushArgumentString("PING");
4615  NWNX_CallFunction("NWNX_Redis", "Deferred");
4616  return NWNX_GetReturnValueInt();
4617 }
4618 
4620  string key,
4621  // Redis type: integer
4622  int milliseconds,
4623  string value
4624 ) {
4625  NWNX_PushArgumentString("PSETEX");
4627  NWNX_PushArgumentString(IntToString(milliseconds));
4628  NWNX_PushArgumentString(value);
4629  NWNX_CallFunction("NWNX_Redis", "Deferred");
4630  return NWNX_GetReturnValueInt();
4631 }
4632 
4634  string subcommand,
4635  string argument = ""
4636 ) {
4637  NWNX_PushArgumentString("PUBSUB");
4638  NWNX_PushArgumentString(subcommand);
4639  if (argument != "") NWNX_PushArgumentString(argument);
4640  NWNX_CallFunction("NWNX_Redis", "Deferred");
4641  return NWNX_GetReturnValueInt();
4642 }
4643 
4644 int PTTL(
4645  string key
4646 ) {
4647  NWNX_PushArgumentString("PTTL");
4649  NWNX_CallFunction("NWNX_Redis", "Deferred");
4650  return NWNX_GetReturnValueInt();
4651 }
4652 
4654  string channel,
4655  string message
4656 ) {
4657  NWNX_PushArgumentString("PUBLISH");
4660  NWNX_CallFunction("NWNX_Redis", "Deferred");
4661  return NWNX_GetReturnValueInt();
4662 }
4663 
4664 int QUIT() {
4665  NWNX_PushArgumentString("QUIT");
4666  NWNX_CallFunction("NWNX_Redis", "Deferred");
4667  return NWNX_GetReturnValueInt();
4668 }
4669 
4670 int RANDOMKEY() {
4671  NWNX_PushArgumentString("RANDOMKEY");
4672  NWNX_CallFunction("NWNX_Redis", "Deferred");
4673  return NWNX_GetReturnValueInt();
4674 }
4675 
4676 int READONLY() {
4677  NWNX_PushArgumentString("READONLY");
4678  NWNX_CallFunction("NWNX_Redis", "Deferred");
4679  return NWNX_GetReturnValueInt();
4680 }
4681 
4682 int READWRITE() {
4683  NWNX_PushArgumentString("READWRITE");
4684  NWNX_CallFunction("NWNX_Redis", "Deferred");
4685  return NWNX_GetReturnValueInt();
4686 }
4687 
4689  string key,
4690  // Redis type: key
4691  string newkey
4692 ) {
4693  NWNX_PushArgumentString("RENAME");
4695  NWNX_PushArgumentString(newkey);
4696  NWNX_CallFunction("NWNX_Redis", "Deferred");
4697  return NWNX_GetReturnValueInt();
4698 }
4699 
4701  string key,
4702  // Redis type: key
4703  string newkey
4704 ) {
4705  NWNX_PushArgumentString("RENAMENX");
4707  NWNX_PushArgumentString(newkey);
4708  NWNX_CallFunction("NWNX_Redis", "Deferred");
4709  return NWNX_GetReturnValueInt();
4710 }
4711 
4713  string key,
4714  // Redis type: integer
4715  int ttl,
4716  string serialized_value,
4717  // Redis type: enum
4718  string replace = "",
4719  // Redis type: enum
4720  string absttl = "",
4721  // Redis type: integer
4722  int idletime_seconds = 0,
4723  // Redis type: integer
4724  int freq_frequency = 0
4725 ) {
4726  NWNX_PushArgumentString("RESTORE");
4728  NWNX_PushArgumentString(IntToString(ttl));
4729  NWNX_PushArgumentString(serialized_value);
4730  if (replace != "") NWNX_PushArgumentString(replace);
4731  if (absttl != "") NWNX_PushArgumentString(absttl);
4732  if (idletime_seconds != 0) NWNX_PushArgumentString(IntToString(idletime_seconds));
4733  if (freq_frequency != 0) NWNX_PushArgumentString(IntToString(freq_frequency));
4734  NWNX_CallFunction("NWNX_Redis", "Deferred");
4735  return NWNX_GetReturnValueInt();
4736 }
4737 
4738 int ROLE() {
4739  NWNX_PushArgumentString("ROLE");
4740  NWNX_CallFunction("NWNX_Redis", "Deferred");
4741  return NWNX_GetReturnValueInt();
4742 }
4743 
4744 int RPOP(
4745  string key
4746 ) {
4747  NWNX_PushArgumentString("RPOP");
4749  NWNX_CallFunction("NWNX_Redis", "Deferred");
4750  return NWNX_GetReturnValueInt();
4751 }
4752 
4754  // Redis type: key
4755  string source,
4756  // Redis type: key
4757  string destination
4758 ) {
4759  NWNX_PushArgumentString("RPOPLPUSH");
4760  NWNX_PushArgumentString(source);
4761  NWNX_PushArgumentString(destination);
4762  NWNX_CallFunction("NWNX_Redis", "Deferred");
4763  return NWNX_GetReturnValueInt();
4764 }
4765 
4766 int RPUSH(
4767  string key,
4768  string value
4769 ) {
4770  NWNX_PushArgumentString("RPUSH");
4772  NWNX_PushArgumentString(value);
4773  NWNX_CallFunction("NWNX_Redis", "Deferred");
4774  return NWNX_GetReturnValueInt();
4775 }
4776 
4778  string key,
4779  string value
4780 ) {
4781  NWNX_PushArgumentString("RPUSHX");
4783  NWNX_PushArgumentString(value);
4784  NWNX_CallFunction("NWNX_Redis", "Deferred");
4785  return NWNX_GetReturnValueInt();
4786 }
4787 
4788 int SADD(
4789  string key,
4790  string member
4791 ) {
4792  NWNX_PushArgumentString("SADD");
4794  NWNX_PushArgumentString(member);
4795  NWNX_CallFunction("NWNX_Redis", "Deferred");
4796  return NWNX_GetReturnValueInt();
4797 }
4798 
4799 int SAVE() {
4800  NWNX_PushArgumentString("SAVE");
4801  NWNX_CallFunction("NWNX_Redis", "Deferred");
4802  return NWNX_GetReturnValueInt();
4803 }
4804 
4805 int SCARD(
4806  string key
4807 ) {
4808  NWNX_PushArgumentString("SCARD");
4810  NWNX_CallFunction("NWNX_Redis", "Deferred");
4811  return NWNX_GetReturnValueInt();
4812 }
4813 
4815  // Redis type: enum
4816  string mode
4817 ) {
4818  NWNX_PushArgumentString("SCRIPT_DEBUG");
4820  NWNX_CallFunction("NWNX_Redis", "Deferred");
4821  return NWNX_GetReturnValueInt();
4822 }
4823 
4825  string sha1
4826 ) {
4827  NWNX_PushArgumentString("SCRIPT_EXISTS");
4829  NWNX_CallFunction("NWNX_Redis", "Deferred");
4830  return NWNX_GetReturnValueInt();
4831 }
4832 
4834  NWNX_PushArgumentString("SCRIPT_FLUSH");
4835  NWNX_CallFunction("NWNX_Redis", "Deferred");
4836  return NWNX_GetReturnValueInt();
4837 }
4838 
4840  NWNX_PushArgumentString("SCRIPT_KILL");
4841  NWNX_CallFunction("NWNX_Redis", "Deferred");
4842  return NWNX_GetReturnValueInt();
4843 }
4844 
4846  string script
4847 ) {
4848  NWNX_PushArgumentString("SCRIPT_LOAD");
4849  NWNX_PushArgumentString(script);
4850  NWNX_CallFunction("NWNX_Redis", "Deferred");
4851  return NWNX_GetReturnValueInt();
4852 }
4853 
4854 int SDIFF(
4855  string key
4856 ) {
4857  NWNX_PushArgumentString("SDIFF");
4859  NWNX_CallFunction("NWNX_Redis", "Deferred");
4860  return NWNX_GetReturnValueInt();
4861 }
4862 
4864  // Redis type: key
4865  string destination,
4866  string key
4867 ) {
4868  NWNX_PushArgumentString("SDIFFSTORE");
4869  NWNX_PushArgumentString(destination);
4871  NWNX_CallFunction("NWNX_Redis", "Deferred");
4872  return NWNX_GetReturnValueInt();
4873 }
4874 
4876  // Redis type: integer
4877  int index
4878 ) {
4879  NWNX_PushArgumentString("SELECT");
4880  NWNX_PushArgumentString(IntToString(index));
4881  NWNX_CallFunction("NWNX_Redis", "Deferred");
4882  return NWNX_GetReturnValueInt();
4883 }
4884 
4885 int SET(
4886  string key,
4887  string value,
4888  // Redis type: enum
4889  string condition = ""
4890 ) {
4891  NWNX_PushArgumentString("SET");
4893  NWNX_PushArgumentString(value);
4894  if (condition != "") NWNX_PushArgumentString(condition);
4895  NWNX_CallFunction("NWNX_Redis", "Deferred");
4896  return NWNX_GetReturnValueInt();
4897 }
4898 
4900  string key,
4901  // Redis type: integer
4902  int offset,
4903  string value
4904 ) {
4905  NWNX_PushArgumentString("SETBIT");
4907  NWNX_PushArgumentString(IntToString(offset));
4908  NWNX_PushArgumentString(value);
4909  NWNX_CallFunction("NWNX_Redis", "Deferred");
4910  return NWNX_GetReturnValueInt();
4911 }
4912 
4913 int SETEX(
4914  string key,
4915  // Redis type: integer
4916  int seconds,
4917  string value
4918 ) {
4919  NWNX_PushArgumentString("SETEX");
4921  NWNX_PushArgumentString(IntToString(seconds));
4922  NWNX_PushArgumentString(value);
4923  NWNX_CallFunction("NWNX_Redis", "Deferred");
4924  return NWNX_GetReturnValueInt();
4925 }
4926 
4927 int SETNX(
4928  string key,
4929  string value
4930 ) {
4931  NWNX_PushArgumentString("SETNX");
4933  NWNX_PushArgumentString(value);
4934  NWNX_CallFunction("NWNX_Redis", "Deferred");
4935  return NWNX_GetReturnValueInt();
4936 }
4937 
4939  string key,
4940  // Redis type: integer
4941  int offset,
4942  string value
4943 ) {
4944  NWNX_PushArgumentString("SETRANGE");
4946  NWNX_PushArgumentString(IntToString(offset));
4947  NWNX_PushArgumentString(value);
4948  NWNX_CallFunction("NWNX_Redis", "Deferred");
4949  return NWNX_GetReturnValueInt();
4950 }
4951 
4953  // Redis type: enum
4954  string save_mode = ""
4955 ) {
4956  NWNX_PushArgumentString("SHUTDOWN");
4957  if (save_mode != "") NWNX_PushArgumentString(save_mode);
4958  NWNX_CallFunction("NWNX_Redis", "Deferred");
4959  return NWNX_GetReturnValueInt();
4960 }
4961 
4963  string key
4964 ) {
4965  NWNX_PushArgumentString("SINTER");
4967  NWNX_CallFunction("NWNX_Redis", "Deferred");
4968  return NWNX_GetReturnValueInt();
4969 }
4970 
4972  // Redis type: key
4973  string destination,
4974  string key
4975 ) {
4976  NWNX_PushArgumentString("SINTERSTORE");
4977  NWNX_PushArgumentString(destination);
4979  NWNX_CallFunction("NWNX_Redis", "Deferred");
4980  return NWNX_GetReturnValueInt();
4981 }
4982 
4984  string key,
4985  string member
4986 ) {
4987  NWNX_PushArgumentString("SISMEMBER");
4989  NWNX_PushArgumentString(member);
4990  NWNX_CallFunction("NWNX_Redis", "Deferred");
4991  return NWNX_GetReturnValueInt();
4992 }
4993 
4995  string host,
4996  string port
4997 ) {
4998  NWNX_PushArgumentString("SLAVEOF");
5001  NWNX_CallFunction("NWNX_Redis", "Deferred");
5002  return NWNX_GetReturnValueInt();
5003 }
5004 
5006  string host,
5007  string port
5008 ) {
5009  NWNX_PushArgumentString("REPLICAOF");
5012  NWNX_CallFunction("NWNX_Redis", "Deferred");
5013  return NWNX_GetReturnValueInt();
5014 }
5015 
5017  string subcommand,
5018  string argument = ""
5019 ) {
5020  NWNX_PushArgumentString("SLOWLOG");
5021  NWNX_PushArgumentString(subcommand);
5022  if (argument != "") NWNX_PushArgumentString(argument);
5023  NWNX_CallFunction("NWNX_Redis", "Deferred");
5024  return NWNX_GetReturnValueInt();
5025 }
5026 
5028  string key
5029 ) {
5030  NWNX_PushArgumentString("SMEMBERS");
5032  NWNX_CallFunction("NWNX_Redis", "Deferred");
5033  return NWNX_GetReturnValueInt();
5034 }
5035 
5036 int SMOVE(
5037  // Redis type: key
5038  string source,
5039  // Redis type: key
5040  string destination,
5041  string member
5042 ) {
5043  NWNX_PushArgumentString("SMOVE");
5044  NWNX_PushArgumentString(source);
5045  NWNX_PushArgumentString(destination);
5046  NWNX_PushArgumentString(member);
5047  NWNX_CallFunction("NWNX_Redis", "Deferred");
5048  return NWNX_GetReturnValueInt();
5049 }
5050 
5051 int SORT(
5052  string key,
5053  // Redis type: pattern
5054  string by_pattern = "",
5055  // Redis type: integer
5056  int limit_offset = 0,
5057  // Redis type: integer
5058  int limit_count = 0,
5059  string get_pattern = "",
5060  // Redis type: enum
5061  string order = "",
5062  // Redis type: enum
5063  string sorting = "",
5064  // Redis type: key
5065  string store_destination = ""
5066 ) {
5067  NWNX_PushArgumentString("SORT");
5069  if (by_pattern != "") NWNX_PushArgumentString(by_pattern);
5070  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
5071  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
5072  if (get_pattern != "") NWNX_PushArgumentString(get_pattern);
5073  if (order != "") NWNX_PushArgumentString(order);
5074  if (sorting != "") NWNX_PushArgumentString(sorting);
5075  if (store_destination != "") NWNX_PushArgumentString(store_destination);
5076  NWNX_CallFunction("NWNX_Redis", "Deferred");
5077  return NWNX_GetReturnValueInt();
5078 }
5079 
5080 int SPOP(
5081  string key,
5082  // Redis type: integer
5083  int count = 0
5084 ) {
5085  NWNX_PushArgumentString("SPOP");
5087  if (count != 0) NWNX_PushArgumentString(IntToString(count));
5088  NWNX_CallFunction("NWNX_Redis", "Deferred");
5089  return NWNX_GetReturnValueInt();
5090 }
5091 
5093  string key,
5094  // Redis type: integer
5095  int count = 0
5096 ) {
5097  NWNX_PushArgumentString("SRANDMEMBER");
5099  if (count != 0) NWNX_PushArgumentString(IntToString(count));
5100  NWNX_CallFunction("NWNX_Redis", "Deferred");
5101  return NWNX_GetReturnValueInt();
5102 }
5103 
5104 int SREM(
5105  string key,
5106  string member
5107 ) {
5108  NWNX_PushArgumentString("SREM");
5110  NWNX_PushArgumentString(member);
5111  NWNX_CallFunction("NWNX_Redis", "Deferred");
5112  return NWNX_GetReturnValueInt();
5113 }
5114 
5116  string key
5117 ) {
5118  NWNX_PushArgumentString("STRLEN");
5120  NWNX_CallFunction("NWNX_Redis", "Deferred");
5121  return NWNX_GetReturnValueInt();
5122 }
5123 
5125  string key
5126 ) {
5127  NWNX_PushArgumentString("SUNION");
5129  NWNX_CallFunction("NWNX_Redis", "Deferred");
5130  return NWNX_GetReturnValueInt();
5131 }
5132 
5134  // Redis type: key
5135  string destination,
5136  string key
5137 ) {
5138  NWNX_PushArgumentString("SUNIONSTORE");
5139  NWNX_PushArgumentString(destination);
5141  NWNX_CallFunction("NWNX_Redis", "Deferred");
5142  return NWNX_GetReturnValueInt();
5143 }
5144 
5146  // Redis type: integer
5147  int index,
5148  // Redis type: integer
5149  int index_1
5150 ) {
5151  NWNX_PushArgumentString("SWAPDB");
5152  NWNX_PushArgumentString(IntToString(index));
5153  NWNX_PushArgumentString(IntToString(index_1));
5154  NWNX_CallFunction("NWNX_Redis", "Deferred");
5155  return NWNX_GetReturnValueInt();
5156 }
5157 
5158 int SYNC() {
5159  NWNX_PushArgumentString("SYNC");
5160  NWNX_CallFunction("NWNX_Redis", "Deferred");
5161  return NWNX_GetReturnValueInt();
5162 }
5163 
5164 int TIME() {
5165  NWNX_PushArgumentString("TIME");
5166  NWNX_CallFunction("NWNX_Redis", "Deferred");
5167  return NWNX_GetReturnValueInt();
5168 }
5169 
5170 int TOUCH(
5171  string key
5172 ) {
5173  NWNX_PushArgumentString("TOUCH");
5175  NWNX_CallFunction("NWNX_Redis", "Deferred");
5176  return NWNX_GetReturnValueInt();
5177 }
5178 
5179 int TTL(
5180  string key
5181 ) {
5182  NWNX_PushArgumentString("TTL");
5184  NWNX_CallFunction("NWNX_Redis", "Deferred");
5185  return NWNX_GetReturnValueInt();
5186 }
5187 
5188 int TYPE(
5189  string key
5190 ) {
5191  NWNX_PushArgumentString("TYPE");
5193  NWNX_CallFunction("NWNX_Redis", "Deferred");
5194  return NWNX_GetReturnValueInt();
5195 }
5196 
5198  string key
5199 ) {
5200  NWNX_PushArgumentString("UNLINK");
5202  NWNX_CallFunction("NWNX_Redis", "Deferred");
5203  return NWNX_GetReturnValueInt();
5204 }
5205 
5206 int UNWATCH() {
5207  NWNX_PushArgumentString("UNWATCH");
5208  NWNX_CallFunction("NWNX_Redis", "Deferred");
5209  return NWNX_GetReturnValueInt();
5210 }
5211 
5212 int WAIT(
5213  // Redis type: integer
5214  int numreplicas,
5215  // Redis type: integer
5216  int timeout
5217 ) {
5218  NWNX_PushArgumentString("WAIT");
5219  NWNX_PushArgumentString(IntToString(numreplicas));
5220  NWNX_PushArgumentString(IntToString(timeout));
5221  NWNX_CallFunction("NWNX_Redis", "Deferred");
5222  return NWNX_GetReturnValueInt();
5223 }
5224 
5225 int WATCH(
5226  string key
5227 ) {
5228  NWNX_PushArgumentString("WATCH");
5230  NWNX_CallFunction("NWNX_Redis", "Deferred");
5231  return NWNX_GetReturnValueInt();
5232 }
5233 
5234 int ZADD(
5235  string key,
5236  // Redis type: enum
5237  string condition = "",
5238  // Redis type: enum
5239  string change = "",
5240  // Redis type: enum
5241  string increment = "",
5242  // Redis type: double
5243  float score = 0.0,
5244  string member = ""
5245 ) {
5246  NWNX_PushArgumentString("ZADD");
5248  if (condition != "") NWNX_PushArgumentString(condition);
5249  if (change != "") NWNX_PushArgumentString(change);
5250  if (increment != "") NWNX_PushArgumentString(increment);
5251  NWNX_PushArgumentString(FloatToString(score, 0));
5252  NWNX_PushArgumentString(member);
5253  NWNX_CallFunction("NWNX_Redis", "Deferred");
5254  return NWNX_GetReturnValueInt();
5255 }
5256 
5257 int ZCARD(
5258  string key
5259 ) {
5260  NWNX_PushArgumentString("ZCARD");
5262  NWNX_CallFunction("NWNX_Redis", "Deferred");
5263  return NWNX_GetReturnValueInt();
5264 }
5265 
5267  string key,
5268  // Redis type: double
5269  float min,
5270  // Redis type: double
5271  float max
5272 ) {
5273  NWNX_PushArgumentString("ZCOUNT");
5275  NWNX_PushArgumentString(FloatToString(min, 0));
5276  NWNX_PushArgumentString(FloatToString(max, 0));
5277  NWNX_CallFunction("NWNX_Redis", "Deferred");
5278  return NWNX_GetReturnValueInt();
5279 }
5280 
5282  string key,
5283  // Redis type: integer
5284  int increment,
5285  string member
5286 ) {
5287  NWNX_PushArgumentString("ZINCRBY");
5289  NWNX_PushArgumentString(IntToString(increment));
5290  NWNX_PushArgumentString(member);
5291  NWNX_CallFunction("NWNX_Redis", "Deferred");
5292  return NWNX_GetReturnValueInt();
5293 }
5294 
5296  // Redis type: key
5297  string destination,
5298  // Redis type: integer
5299  int numkeys,
5300  string key,
5301  // Redis type: integer
5302  int weights_weight = 0,
5303  // Redis type: enum
5304  string aggregate_aggregate = ""
5305 ) {
5306  NWNX_PushArgumentString("ZINTERSTORE");
5307  NWNX_PushArgumentString(destination);
5308  NWNX_PushArgumentString(IntToString(numkeys));
5310  if (weights_weight != 0) NWNX_PushArgumentString(IntToString(weights_weight));
5311  if (aggregate_aggregate != "") NWNX_PushArgumentString(aggregate_aggregate);
5312  NWNX_CallFunction("NWNX_Redis", "Deferred");
5313  return NWNX_GetReturnValueInt();
5314 }
5315 
5317  string key,
5318  string min,
5319  string max
5320 ) {
5321  NWNX_PushArgumentString("ZLEXCOUNT");
5325  NWNX_CallFunction("NWNX_Redis", "Deferred");
5326  return NWNX_GetReturnValueInt();
5327 }
5328 
5330  string key,
5331  // Redis type: integer
5332  int count = 0
5333 ) {
5334  NWNX_PushArgumentString("ZPOPMAX");
5336  if (count != 0) NWNX_PushArgumentString(IntToString(count));
5337  NWNX_CallFunction("NWNX_Redis", "Deferred");
5338  return NWNX_GetReturnValueInt();
5339 }
5340 
5342  string key,
5343  // Redis type: integer
5344  int count = 0
5345 ) {
5346  NWNX_PushArgumentString("ZPOPMIN");
5348  if (count != 0) NWNX_PushArgumentString(IntToString(count));
5349  NWNX_CallFunction("NWNX_Redis", "Deferred");
5350  return NWNX_GetReturnValueInt();
5351 }
5352 
5354  string key,
5355  // Redis type: integer
5356  int start,
5357  // Redis type: integer
5358  int stop,
5359  // Redis type: enum
5360  string withscores = ""
5361 ) {
5362  NWNX_PushArgumentString("ZRANGE");
5364  NWNX_PushArgumentString(IntToString(start));
5365  NWNX_PushArgumentString(IntToString(stop));
5366  if (withscores != "") NWNX_PushArgumentString(withscores);
5367  NWNX_CallFunction("NWNX_Redis", "Deferred");
5368  return NWNX_GetReturnValueInt();
5369 }
5370 
5372  string key,
5373  string min,
5374  string max,
5375  // Redis type: integer
5376  int limit_offset = 0,
5377  // Redis type: integer
5378  int limit_count = 0
5379 ) {
5380  NWNX_PushArgumentString("ZRANGEBYLEX");
5384  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
5385  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
5386  NWNX_CallFunction("NWNX_Redis", "Deferred");
5387  return NWNX_GetReturnValueInt();
5388 }
5389 
5391  string key,
5392  string max,
5393  string min,
5394  // Redis type: integer
5395  int limit_offset = 0,
5396  // Redis type: integer
5397  int limit_count = 0
5398 ) {
5399  NWNX_PushArgumentString("ZREVRANGEBYLEX");
5403  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
5404  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
5405  NWNX_CallFunction("NWNX_Redis", "Deferred");
5406  return NWNX_GetReturnValueInt();
5407 }
5408 
5410  string key,
5411  // Redis type: double
5412  float min,
5413  // Redis type: double
5414  float max,
5415  // Redis type: enum
5416  string withscores = "",
5417  // Redis type: integer
5418  int limit_offset = 0,
5419  // Redis type: integer
5420  int limit_count = 0
5421 ) {
5422  NWNX_PushArgumentString("ZRANGEBYSCORE");
5424  NWNX_PushArgumentString(FloatToString(min, 0));
5425  NWNX_PushArgumentString(FloatToString(max, 0));
5426  if (withscores != "") NWNX_PushArgumentString(withscores);
5427  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
5428  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
5429  NWNX_CallFunction("NWNX_Redis", "Deferred");
5430  return NWNX_GetReturnValueInt();
5431 }
5432 
5433 int ZRANK(
5434  string key,
5435  string member
5436 ) {
5437  NWNX_PushArgumentString("ZRANK");
5439  NWNX_PushArgumentString(member);
5440  NWNX_CallFunction("NWNX_Redis", "Deferred");
5441  return NWNX_GetReturnValueInt();
5442 }
5443 
5444 int ZREM(
5445  string key,
5446  string member
5447 ) {
5448  NWNX_PushArgumentString("ZREM");
5450  NWNX_PushArgumentString(member);
5451  NWNX_CallFunction("NWNX_Redis", "Deferred");
5452  return NWNX_GetReturnValueInt();
5453 }
5454 
5456  string key,
5457  string min,
5458  string max
5459 ) {
5460  NWNX_PushArgumentString("ZREMRANGEBYLEX");
5464  NWNX_CallFunction("NWNX_Redis", "Deferred");
5465  return NWNX_GetReturnValueInt();
5466 }
5467 
5469  string key,
5470  // Redis type: integer
5471  int start,
5472  // Redis type: integer
5473  int stop
5474 ) {
5475  NWNX_PushArgumentString("ZREMRANGEBYRANK");
5477  NWNX_PushArgumentString(IntToString(start));
5478  NWNX_PushArgumentString(IntToString(stop));
5479  NWNX_CallFunction("NWNX_Redis", "Deferred");
5480  return NWNX_GetReturnValueInt();
5481 }
5482 
5484  string key,
5485  // Redis type: double
5486  float min,
5487  // Redis type: double
5488  float max
5489 ) {
5490  NWNX_PushArgumentString("ZREMRANGEBYSCORE");
5492  NWNX_PushArgumentString(FloatToString(min, 0));
5493  NWNX_PushArgumentString(FloatToString(max, 0));
5494  NWNX_CallFunction("NWNX_Redis", "Deferred");
5495  return NWNX_GetReturnValueInt();
5496 }
5497 
5499  string key,
5500  // Redis type: integer
5501  int start,
5502  // Redis type: integer
5503  int stop,
5504  // Redis type: enum
5505  string withscores = ""
5506 ) {
5507  NWNX_PushArgumentString("ZREVRANGE");
5509  NWNX_PushArgumentString(IntToString(start));
5510  NWNX_PushArgumentString(IntToString(stop));
5511  if (withscores != "") NWNX_PushArgumentString(withscores);
5512  NWNX_CallFunction("NWNX_Redis", "Deferred");
5513  return NWNX_GetReturnValueInt();
5514 }
5515 
5517  string key,
5518  // Redis type: double
5519  float max,
5520  // Redis type: double
5521  float min,
5522  // Redis type: enum
5523  string withscores = "",
5524  // Redis type: integer
5525  int limit_offset = 0,
5526  // Redis type: integer
5527  int limit_count = 0
5528 ) {
5529  NWNX_PushArgumentString("ZREVRANGEBYSCORE");
5531  NWNX_PushArgumentString(FloatToString(max, 0));
5532  NWNX_PushArgumentString(FloatToString(min, 0));
5533  if (withscores != "") NWNX_PushArgumentString(withscores);
5534  if (limit_offset != 0) NWNX_PushArgumentString(IntToString(limit_offset));
5535  if (limit_count != 0) NWNX_PushArgumentString(IntToString(limit_count));
5536  NWNX_CallFunction("NWNX_Redis", "Deferred");
5537  return NWNX_GetReturnValueInt();
5538 }
5539 
5541  string key,
5542  string member
5543 ) {
5544  NWNX_PushArgumentString("ZREVRANK");
5546  NWNX_PushArgumentString(member);
5547  NWNX_CallFunction("NWNX_Redis", "Deferred");
5548  return NWNX_GetReturnValueInt();
5549 }
5550 
5552  string key,
5553  string member
5554 ) {
5555  NWNX_PushArgumentString("ZSCORE");
5557  NWNX_PushArgumentString(member);
5558  NWNX_CallFunction("NWNX_Redis", "Deferred");
5559  return NWNX_GetReturnValueInt();
5560 }
5561 
5563  // Redis type: key
5564  string destination,
5565  // Redis type: integer
5566  int numkeys,
5567  string key,
5568  // Redis type: integer
5569  int weights_weight = 0,
5570  // Redis type: enum
5571  string aggregate_aggregate = ""
5572 ) {
5573  NWNX_PushArgumentString("ZUNIONSTORE");
5574  NWNX_PushArgumentString(destination);
5575  NWNX_PushArgumentString(IntToString(numkeys));
5577  if (weights_weight != 0) NWNX_PushArgumentString(IntToString(weights_weight));
5578  if (aggregate_aggregate != "") NWNX_PushArgumentString(aggregate_aggregate);
5579  NWNX_CallFunction("NWNX_Redis", "Deferred");
5580  return NWNX_GetReturnValueInt();
5581 }
5582 
5583 int SCAN(
5584  // Redis type: integer
5585  int cursor,
5586  // Redis type: pattern
5587  string match_pattern = "",
5588  // Redis type: integer
5589  int count_count = 0,
5590  string type_type = ""
5591 ) {
5592  NWNX_PushArgumentString("SCAN");
5593  NWNX_PushArgumentString(IntToString(cursor));
5594  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
5595  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5596  if (type_type != "") NWNX_PushArgumentString(type_type);
5597  NWNX_CallFunction("NWNX_Redis", "Deferred");
5598  return NWNX_GetReturnValueInt();
5599 }
5600 
5601 int SSCAN(
5602  string key,
5603  // Redis type: integer
5604  int cursor,
5605  // Redis type: pattern
5606  string match_pattern = "",
5607  // Redis type: integer
5608  int count_count = 0
5609 ) {
5610  NWNX_PushArgumentString("SSCAN");
5612  NWNX_PushArgumentString(IntToString(cursor));
5613  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
5614  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5615  NWNX_CallFunction("NWNX_Redis", "Deferred");
5616  return NWNX_GetReturnValueInt();
5617 }
5618 
5619 int HSCAN(
5620  string key,
5621  // Redis type: integer
5622  int cursor,
5623  // Redis type: pattern
5624  string match_pattern = "",
5625  // Redis type: integer
5626  int count_count = 0
5627 ) {
5628  NWNX_PushArgumentString("HSCAN");
5630  NWNX_PushArgumentString(IntToString(cursor));
5631  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
5632  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5633  NWNX_CallFunction("NWNX_Redis", "Deferred");
5634  return NWNX_GetReturnValueInt();
5635 }
5636 
5637 int ZSCAN(
5638  string key,
5639  // Redis type: integer
5640  int cursor,
5641  // Redis type: pattern
5642  string match_pattern = "",
5643  // Redis type: integer
5644  int count_count = 0
5645 ) {
5646  NWNX_PushArgumentString("ZSCAN");
5648  NWNX_PushArgumentString(IntToString(cursor));
5649  if (match_pattern != "") NWNX_PushArgumentString(match_pattern);
5650  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5651  NWNX_CallFunction("NWNX_Redis", "Deferred");
5652  return NWNX_GetReturnValueInt();
5653 }
5654 
5655 int XINFO(
5656  // Redis type: key
5657  string consumers_key = "",
5658  string consumers_groupname = "",
5659  // Redis type: key
5660  string groups_key = "",
5661  // Redis type: key
5662  string stream_key = "",
5663  // Redis type: enum
5664  string help = ""
5665 ) {
5666  NWNX_PushArgumentString("XINFO");
5667  if (consumers_key != "") NWNX_PushArgumentString(consumers_key);
5668  if (consumers_groupname != "") NWNX_PushArgumentString(consumers_groupname);
5669  if (groups_key != "") NWNX_PushArgumentString(groups_key);
5670  if (stream_key != "") NWNX_PushArgumentString(stream_key);
5671  if (help != "") NWNX_PushArgumentString(help);
5672  NWNX_CallFunction("NWNX_Redis", "Deferred");
5673  return NWNX_GetReturnValueInt();
5674 }
5675 
5676 int XADD(
5677  string key,
5678  string ID,
5679  // Redis type: value
5680  string field,
5681  string str
5682 ) {
5683  NWNX_PushArgumentString("XADD");
5686  NWNX_PushArgumentString(field);
5688  NWNX_CallFunction("NWNX_Redis", "Deferred");
5689  return NWNX_GetReturnValueInt();
5690 }
5691 
5692 int XTRIM(
5693  string key,
5694  // Redis type: enum
5695  string strategy,
5696  // Redis type: enum
5697  string approx = "",
5698  // Redis type: integer
5699  int count = 0
5700 ) {
5701  NWNX_PushArgumentString("XTRIM");
5703  NWNX_PushArgumentString(strategy);
5704  if (approx != "") NWNX_PushArgumentString(approx);
5705  NWNX_PushArgumentString(IntToString(count));
5706  NWNX_CallFunction("NWNX_Redis", "Deferred");
5707  return NWNX_GetReturnValueInt();
5708 }
5709 
5710 int XDEL(
5711  string key,
5712  string ID
5713 ) {
5714  NWNX_PushArgumentString("XDEL");
5717  NWNX_CallFunction("NWNX_Redis", "Deferred");
5718  return NWNX_GetReturnValueInt();
5719 }
5720 
5722  string key,
5723  string start,
5724  string end,
5725  // Redis type: integer
5726  int count_count = 0
5727 ) {
5728  NWNX_PushArgumentString("XRANGE");
5730  NWNX_PushArgumentString(start);
5732  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5733  NWNX_CallFunction("NWNX_Redis", "Deferred");
5734  return NWNX_GetReturnValueInt();
5735 }
5736 
5738  string key,
5739  string end,
5740  string start,
5741  // Redis type: integer
5742  int count_count = 0
5743 ) {
5744  NWNX_PushArgumentString("XREVRANGE");
5747  NWNX_PushArgumentString(start);
5748  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5749  NWNX_CallFunction("NWNX_Redis", "Deferred");
5750  return NWNX_GetReturnValueInt();
5751 }
5752 
5753 int XLEN(
5754  string key
5755 ) {
5756  NWNX_PushArgumentString("XLEN");
5758  NWNX_CallFunction("NWNX_Redis", "Deferred");
5759  return NWNX_GetReturnValueInt();
5760 }
5761 
5762 int XREAD(
5763  // Redis type: integer
5764  int count_count = 0,
5765  // Redis type: integer
5766  int block_milliseconds = 0,
5767  // Redis type: enum
5768  string streams = "",
5769  string key = "",
5770  string ID = ""
5771 ) {
5772  NWNX_PushArgumentString("XREAD");
5773  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5774  if (block_milliseconds != 0) NWNX_PushArgumentString(IntToString(block_milliseconds));
5775  NWNX_PushArgumentString(streams);
5778  NWNX_CallFunction("NWNX_Redis", "Deferred");
5779  return NWNX_GetReturnValueInt();
5780 }
5781 
5783  // Redis type: key
5784  string create_key = "",
5785  string create_groupname = "",
5786  string create_id_or__ = "",
5787  // Redis type: key
5788  string setid_key = "",
5789  string setid_groupname = "",
5790  string setid_id_or__ = "",
5791  // Redis type: key
5792  string destroy_key = "",
5793  string destroy_groupname = "",
5794  // Redis type: key
5795  string delconsumer_key = "",
5796  string delconsumer_groupname = "",
5797  string delconsumer_consumername = ""
5798 ) {
5799  NWNX_PushArgumentString("XGROUP");
5800  if (create_key != "") NWNX_PushArgumentString(create_key);
5801  if (create_groupname != "") NWNX_PushArgumentString(create_groupname);
5802  if (create_id_or__ != "") NWNX_PushArgumentString(create_id_or__);
5803  if (setid_key != "") NWNX_PushArgumentString(setid_key);
5804  if (setid_groupname != "") NWNX_PushArgumentString(setid_groupname);
5805  if (setid_id_or__ != "") NWNX_PushArgumentString(setid_id_or__);
5806  if (destroy_key != "") NWNX_PushArgumentString(destroy_key);
5807  if (destroy_groupname != "") NWNX_PushArgumentString(destroy_groupname);
5808  if (delconsumer_key != "") NWNX_PushArgumentString(delconsumer_key);
5809  if (delconsumer_groupname != "") NWNX_PushArgumentString(delconsumer_groupname);
5810  if (delconsumer_consumername != "") NWNX_PushArgumentString(delconsumer_consumername);
5811  NWNX_CallFunction("NWNX_Redis", "Deferred");
5812  return NWNX_GetReturnValueInt();
5813 }
5814 
5816  string group_group,
5817  string group_consumer,
5818  // Redis type: integer
5819  int count_count = 0,
5820  // Redis type: integer
5821  int block_milliseconds = 0,
5822  // Redis type: enum
5823  string noack = "",
5824  // Redis type: enum
5825  string streams = "",
5826  string key = "",
5827  string ID = ""
5828 ) {
5829  NWNX_PushArgumentString("XREADGROUP");
5830  NWNX_PushArgumentString(group_group);
5831  NWNX_PushArgumentString(group_consumer);
5832  if (count_count != 0) NWNX_PushArgumentString(IntToString(count_count));
5833  if (block_milliseconds != 0) NWNX_PushArgumentString(IntToString(block_milliseconds));
5834  if (noack != "") NWNX_PushArgumentString(noack);
5835  NWNX_PushArgumentString(streams);
5838  NWNX_CallFunction("NWNX_Redis", "Deferred");
5839  return NWNX_GetReturnValueInt();
5840 }
5841 
5842 int XACK(
5843  string key,
5844  string group,
5845  string ID
5846 ) {
5847  NWNX_PushArgumentString("XACK");
5849  NWNX_PushArgumentString(group);
5851  NWNX_CallFunction("NWNX_Redis", "Deferred");
5852  return NWNX_GetReturnValueInt();
5853 }
5854 
5856  string key,
5857  string group,
5858  string consumer,
5859  string min_idle_time,
5860  string ID,
5861  // Redis type: integer
5862  int idle_ms = 0,
5863  // Redis type: integer
5864  int time_ms_unix_time = 0,
5865  // Redis type: integer
5866  int retrycount_count = 0
5867 ) {
5868  NWNX_PushArgumentString("XCLAIM");
5870  NWNX_PushArgumentString(group);
5871  NWNX_PushArgumentString(consumer);
5872  NWNX_PushArgumentString(min_idle_time);
5874  if (idle_ms != 0) NWNX_PushArgumentString(IntToString(idle_ms));
5875  if (time_ms_unix_time != 0) NWNX_PushArgumentString(IntToString(time_ms_unix_time));
5876  if (retrycount_count != 0) NWNX_PushArgumentString(IntToString(retrycount_count));
5877  NWNX_CallFunction("NWNX_Redis", "Deferred");
5878  return NWNX_GetReturnValueInt();
5879 }
5880 
5882  string key,
5883  string group,
5884  string start = "",
5885  string end = "",
5886  // Redis type: integer
5887  int count = 0,
5888  string consumer = ""
5889 ) {
5890  NWNX_PushArgumentString("XPENDING");
5892  NWNX_PushArgumentString(group);
5893  if (start != "") NWNX_PushArgumentString(start);
5894  if (end != "") NWNX_PushArgumentString(end);
5895  if (count != 0) NWNX_PushArgumentString(IntToString(count));
5896  if (consumer != "") NWNX_PushArgumentString(consumer);
5897  NWNX_CallFunction("NWNX_Redis", "Deferred");
5898  return NWNX_GetReturnValueInt();
5899 }
SETNX
int SETNX(string key, string value)
Definition: nwnx_redis_short.nss:4927
XDEL
int XDEL(string key, string ID)
Definition: nwnx_redis_short.nss:5710
SETRANGE
int SETRANGE(string key, int offset, string value)
Definition: nwnx_redis_short.nss:4938
MONITOR
int MONITOR()
Definition: nwnx_redis_short.nss:4487
LLEN
int LLEN(string key)
Definition: nwnx_redis_short.nss:4307
REPLICAOF
int REPLICAOF(string host, string port)
Definition: nwnx_redis_short.nss:5005
EXEC
int EXEC()
Definition: nwnx_redis_short.nss:3824
ZREMRANGEBYSCORE
int ZREMRANGEBYSCORE(string key, float min, float max)
Definition: nwnx_redis_short.nss:5483
NWNX_GetReturnValueInt
int NWNX_GetReturnValueInt()
Returns the specified type from the c++ side.
Definition: nwnx.nss:94
LASTSAVE
int LASTSAVE()
Definition: nwnx_redis_short.nss:4273
ZUNIONSTORE
int ZUNIONSTORE(string destination, int numkeys, string key, int weights_weight=0, string aggregate_aggregate="")
Definition: nwnx_redis_short.nss:5562
BZPOPMAX
int BZPOPMAX(string key, int timeout)
Definition: nwnx_redis_short.nss:3393
CLUSTER_REPLICATE
int CLUSTER_REPLICATE(string node_id)
Definition: nwnx_redis_short.nss:3584
CLUSTER_COUNT_FAILURE_REPORTS
int CLUSTER_COUNT_FAILURE_REPORTS(string node_id)
Definition: nwnx_redis_short.nss:3490
BGSAVE
int BGSAVE()
Definition: nwnx_redis_short.nss:3255
WAIT
int WAIT(int numreplicas, int timeout)
Definition: nwnx_redis_short.nss:5212
TOUCH
int TOUCH(string key)
Definition: nwnx_redis_short.nss:5170
LRANGE
int LRANGE(string key, int start, int stop)
Definition: nwnx_redis_short.nss:4347
AUTH
int AUTH(string password)
Definition: nwnx_redis_short.nss:3240
SET
int SET(string key, string value, string condition="")
Definition: nwnx_redis_short.nss:4885
CLIENT_GETNAME
int CLIENT_GETNAME()
Definition: nwnx_redis_short.nss:3433
HINCRBY
int HINCRBY(string key, string field, int increment)
Definition: nwnx_redis_short.nss:4106
BLPOP
int BLPOP(string key, int timeout)
Definition: nwnx_redis_short.nss:3341
INFO
int INFO(string section="")
Definition: nwnx_redis_short.nss:4255
ZREMRANGEBYLEX
int ZREMRANGEBYLEX(string key, string min, string max)
Definition: nwnx_redis_short.nss:5455
MSET
int MSET(string key, string value)
Definition: nwnx_redis_short.nss:4505
HSTRLEN
int HSTRLEN(string key, string field)
Definition: nwnx_redis_short.nss:4202
ROLE
int ROLE()
Definition: nwnx_redis_short.nss:4738
WATCH
int WATCH(string key)
Definition: nwnx_redis_short.nss:5225
DUMP
int DUMP(string key)
Definition: nwnx_redis_short.nss:3774
XREAD
int XREAD(int count_count=0, int block_milliseconds=0, string streams="", string key="", string ID="")
Definition: nwnx_redis_short.nss:5762
PING
int PING(string message="")
Definition: nwnx_redis_short.nss:4610
DEBUG_SEGFAULT
int DEBUG_SEGFAULT()
Definition: nwnx_redis_short.nss:3732
GETBIT
int GETBIT(string key, int offset)
Definition: nwnx_redis_short.nss:4026
RESTORE
int RESTORE(string key, int ttl, string serialized_value, string replace="", string absttl="", int idletime_seconds=0, int freq_frequency=0)
Definition: nwnx_redis_short.nss:4712
HGET
int HGET(string key, string field)
Definition: nwnx_redis_short.nss:4086
SCAN
int SCAN(int cursor, string match_pattern="", int count_count=0, string type_type="")
Definition: nwnx_redis_short.nss:5583
ZCARD
int ZCARD(string key)
Definition: nwnx_redis_short.nss:5257
CONFIG_REWRITE
int CONFIG_REWRITE()
Definition: nwnx_redis_short.nss:3694
EXPIREAT
int EXPIREAT(string key, string timestamp)
Definition: nwnx_redis_short.nss:3851
ZRANGEBYSCORE
int ZRANGEBYSCORE(string key, float min, float max, string withscores="", int limit_offset=0, int limit_count=0)
Definition: nwnx_redis_short.nss:5409
DECR
int DECR(string key)
Definition: nwnx_redis_short.nss:3738
RANDOMKEY
int RANDOMKEY()
Definition: nwnx_redis_short.nss:4670
GETRANGE
int GETRANGE(string key, int start, int end)
Definition: nwnx_redis_short.nss:4038
PUBLISH
int PUBLISH(string channel, string message)
Definition: nwnx_redis_short.nss:4653
XINFO
int XINFO(string consumers_key="", string consumers_groupname="", string groups_key="", string stream_key="", string help="")
Definition: nwnx_redis_short.nss:5655
MEMORY_HELP
int MEMORY_HELP()
Definition: nwnx_redis_short.nss:4411
SDIFF
int SDIFF(string key)
Definition: nwnx_redis_short.nss:4854
ZREVRANK
int ZREVRANK(string key, string member)
Definition: nwnx_redis_short.nss:5540
HSETNX
int HSETNX(string key, string field, string value)
Definition: nwnx_redis_short.nss:4189
PFCOUNT
int PFCOUNT(string key)
Definition: nwnx_redis_short.nss:4588
GEOPOS
int GEOPOS(string key, string member)
Definition: nwnx_redis_short.nss:3911
CLUSTER_RESET
int CLUSTER_RESET(string reset_type="")
Definition: nwnx_redis_short.nss:3593
SUNIONSTORE
int SUNIONSTORE(string destination, string key)
Definition: nwnx_redis_short.nss:5133
MEMORY_MALLOC_STATS
int MEMORY_MALLOC_STATS()
Definition: nwnx_redis_short.nss:4417
TTL
int TTL(string key)
Definition: nwnx_redis_short.nss:5179
BZPOPMIN
int BZPOPMIN(string key, int timeout)
Definition: nwnx_redis_short.nss:3381
PERSIST
int PERSIST(string key)
Definition: nwnx_redis_short.nss:4544
SCRIPT_KILL
int SCRIPT_KILL()
Definition: nwnx_redis_short.nss:4839
LINSERT
int LINSERT(string key, string where, string pivot, string value)
Definition: nwnx_redis_short.nss:4291
INCRBYFLOAT
int INCRBYFLOAT(string key, float increment)
Definition: nwnx_redis_short.nss:4243
RPUSHX
int RPUSHX(string key, string value)
Definition: nwnx_redis_short.nss:4777
CLUSTER_SAVECONFIG
int CLUSTER_SAVECONFIG()
Definition: nwnx_redis_short.nss:3603
HVALS
int HVALS(string key)
Definition: nwnx_redis_short.nss:4213
COMMAND_GETKEYS
int COMMAND_GETKEYS()
Definition: nwnx_redis_short.nss:3670
CLUSTER_COUNTKEYSINSLOT
int CLUSTER_COUNTKEYSINSLOT(int slot)
Definition: nwnx_redis_short.nss:3499
SCARD
int SCARD(string key)
Definition: nwnx_redis_short.nss:4805
PFADD
int PFADD(string key, string element)
Definition: nwnx_redis_short.nss:4577
XPENDING
int XPENDING(string key, string group, string start="", string end="", int count=0, string consumer="")
Definition: nwnx_redis_short.nss:5881
CLUSTER_GETKEYSINSLOT
int CLUSTER_GETKEYSINSLOT(int slot, int count)
Definition: nwnx_redis_short.nss:3538
SLAVEOF
int SLAVEOF(string host, string port)
Definition: nwnx_redis_short.nss:4994
CONFIG_SET
int CONFIG_SET(string parameter, string value)
Definition: nwnx_redis_short.nss:3700
RPUSH
int RPUSH(string key, string value)
Definition: nwnx_redis_short.nss:4766
KEYS
int KEYS(string pattern)
Definition: nwnx_redis_short.nss:4264
SCRIPT_FLUSH
int SCRIPT_FLUSH()
Definition: nwnx_redis_short.nss:4833
XADD
int XADD(string key, string ID, string field, string str)
Definition: nwnx_redis_short.nss:5676
SHUTDOWN
int SHUTDOWN(string save_mode="")
Definition: nwnx_redis_short.nss:4952
GET
int GET(string key)
Definition: nwnx_redis_short.nss:4017
NWNX_CallFunction
void NWNX_CallFunction(string pluginName, string functionName)
Scripting interface to NWNX.
Definition: nwnx.nss:54
GEOHASH
int GEOHASH(string key, string member)
Definition: nwnx_redis_short.nss:3900
BRPOP
int BRPOP(string key, int timeout)
Definition: nwnx_redis_short.nss:3353
ZCOUNT
int ZCOUNT(string key, float min, float max)
Definition: nwnx_redis_short.nss:5266
MOVE
int MOVE(string key, int db)
Definition: nwnx_redis_short.nss:4493
CLUSTER_FAILOVER
int CLUSTER_FAILOVER(string options="")
Definition: nwnx_redis_short.nss:3519
MULTI
int MULTI()
Definition: nwnx_redis_short.nss:4527
PSETEX
int PSETEX(string key, int milliseconds, string value)
Definition: nwnx_redis_short.nss:4619
DISCARD
int DISCARD()
Definition: nwnx_redis_short.nss:3768
XRANGE
int XRANGE(string key, string start, string end, int count_count=0)
Definition: nwnx_redis_short.nss:5721
PEXPIRE
int PEXPIRE(string key, int milliseconds)
Definition: nwnx_redis_short.nss:4553
MEMORY_DOCTOR
int MEMORY_DOCTOR()
Definition: nwnx_redis_short.nss:4405
XTRIM
int XTRIM(string key, string strategy, string approx="", int count=0)
Definition: nwnx_redis_short.nss:5692
NWNX_PushArgumentString
void NWNX_PushArgumentString(string value)
Pushes the specified type to the c++ side.
Definition: nwnx.nss:74
CLIENT_REPLY
int CLIENT_REPLY(string reply_mode)
Definition: nwnx_redis_short.nss:3449
SMOVE
int SMOVE(string source, string destination, string member)
Definition: nwnx_redis_short.nss:5036
SSCAN
int SSCAN(string key, int cursor, string match_pattern="", int count_count=0)
Definition: nwnx_redis_short.nss:5601
SRANDMEMBER
int SRANDMEMBER(string key, int count=0)
Definition: nwnx_redis_short.nss:5092
LINDEX
int LINDEX(string key, int index)
Definition: nwnx_redis_short.nss:4279
ZRANGE
int ZRANGE(string key, int start, int stop, string withscores="")
Definition: nwnx_redis_short.nss:5353
SLOWLOG
int SLOWLOG(string subcommand, string argument="")
Definition: nwnx_redis_short.nss:5016
INCRBY
int INCRBY(string key, int increment)
Definition: nwnx_redis_short.nss:4231
XGROUP
int XGROUP(string create_key="", string create_groupname="", string create_id_or__="", string setid_key="", string setid_groupname="", string setid_id_or__="", string destroy_key="", string destroy_groupname="", string delconsumer_key="", string delconsumer_groupname="", string delconsumer_consumername="")
Definition: nwnx_redis_short.nss:5782
COMMAND
int COMMAND()
Definition: nwnx_redis_short.nss:3658
XREADGROUP
int XREADGROUP(string group_group, string group_consumer, int count_count=0, int block_milliseconds=0, string noack="", string streams="", string key="", string ID="")
Definition: nwnx_redis_short.nss:5815
HSCAN
int HSCAN(string key, int cursor, string match_pattern="", int count_count=0)
Definition: nwnx_redis_short.nss:5619
SISMEMBER
int SISMEMBER(string key, string member)
Definition: nwnx_redis_short.nss:4983
NWNX_Redis_PubSubMessageData::channel
string channel
The channel.
Definition: nwnx_redis_ps.nss:9
SINTERSTORE
int SINTERSTORE(string destination, string key)
Definition: nwnx_redis_short.nss:4971
ZRANK
int ZRANK(string key, string member)
Definition: nwnx_redis_short.nss:5433
XCLAIM
int XCLAIM(string key, string group, string consumer, string min_idle_time, string ID, int idle_ms=0, int time_ms_unix_time=0, int retrycount_count=0)
Definition: nwnx_redis_short.nss:5855
CLUSTER_NODES
int CLUSTER_NODES()
Definition: nwnx_redis_short.nss:3578
SDIFFSTORE
int SDIFFSTORE(string destination, string key)
Definition: nwnx_redis_short.nss:4863
SREM
int SREM(string key, string member)
Definition: nwnx_redis_short.nss:5104
FLUSHDB
int FLUSHDB(string async="")
Definition: nwnx_redis_short.nss:3873
CLUSTER_MEET
int CLUSTER_MEET(string ip, int port)
Definition: nwnx_redis_short.nss:3566
BITPOS
int BITPOS(string key, int bit, int start=0, int end=0)
Definition: nwnx_redis_short.nss:3323
SETEX
int SETEX(string key, int seconds, string value)
Definition: nwnx_redis_short.nss:4913
ZREMRANGEBYRANK
int ZREMRANGEBYRANK(string key, int start, int stop)
Definition: nwnx_redis_short.nss:5468
UNWATCH
int UNWATCH()
Definition: nwnx_redis_short.nss:5206
SWAPDB
int SWAPDB(int index, int index_1)
Definition: nwnx_redis_short.nss:5145
GEOADD
int GEOADD(string key, float longitude, float latitude, string member)
Definition: nwnx_redis_short.nss:3883
LPUSHX
int LPUSHX(string key, string value)
Definition: nwnx_redis_short.nss:4336
HMSET
int HMSET(string key, string field, string value)
Definition: nwnx_redis_short.nss:4163
MEMORY_STATS
int MEMORY_STATS()
Definition: nwnx_redis_short.nss:4429
DBSIZE
int DBSIZE()
Definition: nwnx_redis_short.nss:3717
QUIT
int QUIT()
Definition: nwnx_redis_short.nss:4664
CLIENT_SETNAME
int CLIENT_SETNAME(string connection_name)
Definition: nwnx_redis_short.nss:3459
TIME
int TIME()
Definition: nwnx_redis_short.nss:5164
APPEND
int APPEND(string key, string value)
Definition: nwnx_redis_short.nss:3229
FLUSHALL
int FLUSHALL(string async="")
Definition: nwnx_redis_short.nss:3863
PFMERGE
int PFMERGE(string destkey, string sourcekey)
Definition: nwnx_redis_short.nss:4597
CLUSTER_ADDSLOTS
int CLUSTER_ADDSLOTS(int slot)
Definition: nwnx_redis_short.nss:3480
XREVRANGE
int XREVRANGE(string key, string end, string start, int count_count=0)
Definition: nwnx_redis_short.nss:5737
CLUSTER_SLAVES
int CLUSTER_SLAVES(string node_id)
Definition: nwnx_redis_short.nss:3634
ZREVRANGEBYLEX
int ZREVRANGEBYLEX(string key, string max, string min, int limit_offset=0, int limit_count=0)
Definition: nwnx_redis_short.nss:5390
ZADD
int ZADD(string key, string condition="", string change="", string increment="", float score=0.0, string member="")
Definition: nwnx_redis_short.nss:5234
ZPOPMIN
int ZPOPMIN(string key, int count=0)
Definition: nwnx_redis_short.nss:5341
STRLEN
int STRLEN(string key)
Definition: nwnx_redis_short.nss:5115
CLIENT_PAUSE
int CLIENT_PAUSE(int timeout)
Definition: nwnx_redis_short.nss:3439
LSET
int LSET(string key, int index, string value)
Definition: nwnx_redis_short.nss:4376
CONFIG_GET
int CONFIG_GET(string parameter)
Definition: nwnx_redis_short.nss:3685
ZPOPMAX
int ZPOPMAX(string key, int count=0)
Definition: nwnx_redis_short.nss:5329
HEXISTS
int HEXISTS(string key, string field)
Definition: nwnx_redis_short.nss:4075
UNLINK
int UNLINK(string key)
Definition: nwnx_redis_short.nss:5197
SETBIT
int SETBIT(string key, int offset, string value)
Definition: nwnx_redis_short.nss:4899
LREM
int LREM(string key, int count, string value)
Definition: nwnx_redis_short.nss:4362
LPOP
int LPOP(string key)
Definition: nwnx_redis_short.nss:4316
HLEN
int HLEN(string key)
Definition: nwnx_redis_short.nss:4143
PUBSUB
int PUBSUB(string subcommand, string argument="")
Definition: nwnx_redis_short.nss:4633
CONFIG_RESETSTAT
int CONFIG_RESETSTAT()
Definition: nwnx_redis_short.nss:3711
MGET
int MGET(string key)
Definition: nwnx_redis_short.nss:4447
SMEMBERS
int SMEMBERS(string key)
Definition: nwnx_redis_short.nss:5027
SELECT
int SELECT(int index)
Definition: nwnx_redis_short.nss:4875
SADD
int SADD(string key, string member)
Definition: nwnx_redis_short.nss:4788
XLEN
int XLEN(string key)
Definition: nwnx_redis_short.nss:5753
COMMAND_INFO
int COMMAND_INFO(string command_name)
Definition: nwnx_redis_short.nss:3676
ECHO
int ECHO(string message)
Definition: nwnx_redis_short.nss:3783
ZLEXCOUNT
int ZLEXCOUNT(string key, string min, string max)
Definition: nwnx_redis_short.nss:5316
HSET
int HSET(string key, string field, string value)
Definition: nwnx_redis_short.nss:4176
ZREVRANGE
int ZREVRANGE(string key, int start, int stop, string withscores="")
Definition: nwnx_redis_short.nss:5498
EXPIRE
int EXPIRE(string key, int seconds)
Definition: nwnx_redis_short.nss:3839
CLUSTER_FORGET
int CLUSTER_FORGET(string node_id)
Definition: nwnx_redis_short.nss:3529
SUNION
int SUNION(string key)
Definition: nwnx_redis_short.nss:5124
DECRBY
int DECRBY(string key, int decrement)
Definition: nwnx_redis_short.nss:3747
ZINTERSTORE
int ZINTERSTORE(string destination, int numkeys, string key, int weights_weight=0, string aggregate_aggregate="")
Definition: nwnx_redis_short.nss:5295
CLUSTER_SET_CONFIG_EPOCH
int CLUSTER_SET_CONFIG_EPOCH(int config_epoch)
Definition: nwnx_redis_short.nss:3609
CLIENT_ID
int CLIENT_ID()
Definition: nwnx_redis_short.nss:3405
RPOP
int RPOP(string key)
Definition: nwnx_redis_short.nss:4744
PTTL
int PTTL(string key)
Definition: nwnx_redis_short.nss:4644
READONLY
int READONLY()
Definition: nwnx_redis_short.nss:4676
BGREWRITEAOF
int BGREWRITEAOF()
Definition: nwnx_redis_short.nss:3249
BITCOUNT
int BITCOUNT(string key, int start=0, int end=0)
Definition: nwnx_redis_short.nss:3261
SCRIPT_DEBUG
int SCRIPT_DEBUG(string mode)
Definition: nwnx_redis_short.nss:4814
INCR
int INCR(string key)
Definition: nwnx_redis_short.nss:4222
CLIENT_KILL
int CLIENT_KILL(string ip_port="", int id_client_id=0, string addr_ip_port="", string skipme_yes_no="")
Definition: nwnx_redis_short.nss:3411
MSETNX
int MSETNX(string key, string value)
Definition: nwnx_redis_short.nss:4516
LPUSH
int LPUSH(string key, string value)
Definition: nwnx_redis_short.nss:4325
HDEL
int HDEL(string key, string field)
Definition: nwnx_redis_short.nss:4064
ZRANGEBYLEX
int ZRANGEBYLEX(string key, string min, string max, int limit_offset=0, int limit_count=0)
Definition: nwnx_redis_short.nss:5371
MIGRATE
int MIGRATE(string host, string port, string key, int destination_db, int timeout, string copy="", string replace="", string auth_password="", string keys_key="")
Definition: nwnx_redis_short.nss:4456
ZREM
int ZREM(string key, string member)
Definition: nwnx_redis_short.nss:5444
OBJECT
int OBJECT(string subcommand, string arguments="")
Definition: nwnx_redis_short.nss:4533
ZSCAN
int ZSCAN(string key, int cursor, string match_pattern="", int count_count=0)
Definition: nwnx_redis_short.nss:5637
HMGET
int HMGET(string key, string field)
Definition: nwnx_redis_short.nss:4152
CLUSTER_INFO
int CLUSTER_INFO()
Definition: nwnx_redis_short.nss:3551
CLUSTER_DELSLOTS
int CLUSTER_DELSLOTS(int slot)
Definition: nwnx_redis_short.nss:3509
HGETALL
int HGETALL(string key)
Definition: nwnx_redis_short.nss:4097
ZINCRBY
int ZINCRBY(string key, int increment, string member)
Definition: nwnx_redis_short.nss:5281
SCRIPT_EXISTS
int SCRIPT_EXISTS(string sha1)
Definition: nwnx_redis_short.nss:4824
TYPE
int TYPE(string key)
Definition: nwnx_redis_short.nss:5188
CLUSTER_SETSLOT
int CLUSTER_SETSLOT(int slot, string subcommand, string node_id="")
Definition: nwnx_redis_short.nss:3619
EXISTS
int EXISTS(string key)
Definition: nwnx_redis_short.nss:3830
PEXPIREAT
int PEXPIREAT(string key, string milliseconds_timestamp)
Definition: nwnx_redis_short.nss:4565
SINTER
int SINTER(string key)
Definition: nwnx_redis_short.nss:4962
GETSET
int GETSET(string key, string value)
Definition: nwnx_redis_short.nss:4053
CLUSTER_REPLICAS
int CLUSTER_REPLICAS(string node_id)
Definition: nwnx_redis_short.nss:3643
XACK
int XACK(string key, string group, string ID)
Definition: nwnx_redis_short.nss:5842
DEBUG_OBJECT
int DEBUG_OBJECT(string key)
Definition: nwnx_redis_short.nss:3723
DEL
int DEL(string key)
Definition: nwnx_redis_short.nss:3759
RPOPLPUSH
int RPOPLPUSH(string source, string destination)
Definition: nwnx_redis_short.nss:4753
MEMORY_PURGE
int MEMORY_PURGE()
Definition: nwnx_redis_short.nss:4423
SORT
int SORT(string key, string by_pattern="", int limit_offset=0, int limit_count=0, string get_pattern="", string order="", string sorting="", string store_destination="")
Definition: nwnx_redis_short.nss:5051
HINCRBYFLOAT
int HINCRBYFLOAT(string key, string field, float increment)
Definition: nwnx_redis_short.nss:4120
RENAMENX
int RENAMENX(string key, string newkey)
Definition: nwnx_redis_short.nss:4700
SAVE
int SAVE()
Definition: nwnx_redis_short.nss:4799
BRPOPLPUSH
int BRPOPLPUSH(string source, string destination, int timeout)
Definition: nwnx_redis_short.nss:3365
EVALSHA
int EVALSHA(string sha1, int numkeys, string key, string arg)
Definition: nwnx_redis_short.nss:3808
CLIENT_LIST
int CLIENT_LIST()
Definition: nwnx_redis_short.nss:3427
SCRIPT_LOAD
int SCRIPT_LOAD(string script)
Definition: nwnx_redis_short.nss:4845
ZSCORE
int ZSCORE(string key, string member)
Definition: nwnx_redis_short.nss:5551
COMMAND_COUNT
int COMMAND_COUNT()
Definition: nwnx_redis_short.nss:3664
GEORADIUSBYMEMBER
int GEORADIUSBYMEMBER(string key, string member, float radius, string unit, string withcoord="", string withdist="", string withhash="", int count_count=0, string order="", string store_key="", string storedist_key="")
Definition: nwnx_redis_short.nss:3979
CLUSTER_KEYSLOT
int CLUSTER_KEYSLOT(string key)
Definition: nwnx_redis_short.nss:3557
BITOP
int BITOP(string operation, string destkey, string key)
Definition: nwnx_redis_short.nss:3309
GEORADIUS
int GEORADIUS(string key, float longitude, float latitude, float radius, string unit, string withcoord="", string withdist="", string withhash="", int count_count=0, string order="", string store_key="", string storedist_key="")
Definition: nwnx_redis_short.nss:3937
HKEYS
int HKEYS(string key)
Definition: nwnx_redis_short.nss:4134
MEMORY_USAGE
int MEMORY_USAGE(string key, int samples_count=0)
Definition: nwnx_redis_short.nss:4435
RENAME
int RENAME(string key, string newkey)
Definition: nwnx_redis_short.nss:4688
CLUSTER_SLOTS
int CLUSTER_SLOTS()
Definition: nwnx_redis_short.nss:3652
READWRITE
int READWRITE()
Definition: nwnx_redis_short.nss:4682
EVAL
int EVAL(string script, int numkeys, string key, string arg)
Definition: nwnx_redis_short.nss:3792
GEODIST
int GEODIST(string key, string member1, string member2, string unit="")
Definition: nwnx_redis_short.nss:3922
SYNC
int SYNC()
Definition: nwnx_redis_short.nss:5158
CLIENT_UNBLOCK
int CLIENT_UNBLOCK(string client_id, string unblock_type="")
Definition: nwnx_redis_short.nss:3468
NWNX_Redis_PubSubMessageData::message
string message
The message.
Definition: nwnx_redis_ps.nss:10
ZREVRANGEBYSCORE
int ZREVRANGEBYSCORE(string key, float max, float min, string withscores="", int limit_offset=0, int limit_count=0)
Definition: nwnx_redis_short.nss:5516
SPOP
int SPOP(string key, int count=0)
Definition: nwnx_redis_short.nss:5080
LTRIM
int LTRIM(string key, int start, int stop)
Definition: nwnx_redis_short.nss:4390
BITFIELD
int BITFIELD(string key, string get_type="", int get_offset=0, string set_type="", int set_offset=0, int set_value=0, string incrby_type="", int incrby_offset=0, int incrby_increment=0)
Definition: nwnx_redis_short.nss:3276