content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
and is terminated by CRLF (i.e., `\r\n`). Simple strings transmit short, non-binary strings with minimal overhead. For example, many Redis commands reply with just "OK" on success. The encoding of this Simple String is the following 5 bytes: +OK\r\n When Redis replies with a simple string, a client library should return to the caller a string value composed of the first character after the `+` up to the end of the string, excluding the final CRLF bytes. To send binary strings, use [bulk strings](#bulk-strings) instead. ### Simple errors RESP has specific data types for errors. Simple errors, or simply just errors, are similar to [simple strings](#simple-strings), but their first character is the minus (`-`) character. The difference between simple strings and errors in RESP is that clients should treat errors as exceptions, whereas the string encoded in the error type is the error message itself. The basic format is: -Error message\r\n Redis replies with an error only when something goes wrong, for example, when you try to operate against the wrong data type, or when the command does not exist. The client should raise an exception when it receives an Error reply. The following are examples of error replies: -ERR unknown command 'asdf' -WRONGTYPE Operation against a key holding the wrong kind of value The first upper-case word after the `-`, up to the first space or newline, represents the kind of error returned. This word is called an \_error prefix\_. Note that the error prefix is a convention used by Redis rather than part of the RESP error type. For example, in Redis, `ERR` is a generic error, whereas `WRONGTYPE` is a more specific error that implies that the client attempted an operation against the wrong data type. The error prefix allows the client to understand the type of error returned by the server without checking the exact error message. A client implementation can return different types of exceptions for various errors, or provide a generic way for trapping errors by directly providing the error name to the caller as a string. However, such a feature should not be considered vital as it is rarely useful. Also, simpler client implementations can return a generic error value, such as `false`. ### Integers This type is a CRLF-terminated string that represents a signed, base-10, 64-bit integer. RESP encodes integers in the following way: :[<+|->]\r\n \* The colon (`:`) as the first byte. \* An optional plus (`+`) or minus (`-`) as the sign. \* One or more decimal digits (`0`..`9`) as the integer's unsigned, base-10 value. \* The CRLF terminator. For example, `:0\r\n` and `:1000\r\n` are integer replies (of zero and one thousand, respectively). Many Redis commands return RESP integers, including `INCR`, `LLEN`, and `LASTSAVE`. An integer, by itself, has no special meaning other than in the context of the command that returned it. For example, it is an incremental number for `INCR`, a UNIX timestamp for `LASTSAVE`, and so forth. However, the returned integer is guaranteed to be in the range of a signed 64-bit integer. In some cases, integers can represent true and false Boolean values. For instance, `SISMEMBER` returns 1 for true and 0 for false. Other commands, including `SADD`, `SREM`, and `SETNX`, return 1 when the data changes and 0 otherwise. ### Bulk strings A bulk string represents a single binary string. The string can be of any size, but by default, Redis limits it to 512 MB (see the `proto-max-bulk-len` configuration directive). RESP encodes bulk strings in the following way: $\r\n\r\n \* The dollar sign (`$`) as the first byte. \* One or more decimal digits | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.05260300263762474,
0.017834512516856194,
-0.020822560414671898,
0.002565629780292511,
-0.02247440814971924,
-0.08837635070085526,
0.02476228028535843,
0.09851443022489548,
0.009116845205426216,
0.022858481854200363,
-0.02401932142674923,
0.01197509653866291,
0.060059159994125366,
-0.042... | 0.233482 |
represents a single binary string. The string can be of any size, but by default, Redis limits it to 512 MB (see the `proto-max-bulk-len` configuration directive). RESP encodes bulk strings in the following way: $\r\n\r\n \* The dollar sign (`$`) as the first byte. \* One or more decimal digits (`0`..`9`) as the string's length, in bytes, as an unsigned, base-10 value. \* The CRLF terminator. \* The data. \* A final CRLF. So the string "hello" is encoded as follows: $5\r\nhello\r\n The empty string's encoding is: $0\r\n\r\n #### Null bulk strings Whereas RESP3 has a dedicated data type for [null values](#nulls), RESP2 has no such type. Instead, due to historical reasons, the representation of null values in RESP2 is via predetermined forms of the [bulk strings](#bulk-strings) and [arrays](#arrays) types. The null bulk string represents a non-existing value. The `GET` command returns the Null Bulk String when the target key doesn't exist. It is encoded as a bulk string with the length of negative one (-1), like so: $-1\r\n A Redis client should return a nil object when the server replies with a null bulk string rather than the empty string. For example, a Ruby library should return `nil` while a C library should return `NULL` (or set a special flag in the reply object). ### Arrays Clients send commands to the Redis server as RESP arrays. Similarly, some Redis commands that return collections of elements use arrays as their replies. An example is the `LRANGE` command that returns elements of a list. RESP Arrays' encoding uses the following format: \*\r\n... \* An asterisk (`\*`) as the first byte. \* One or more decimal digits (`0`..`9`) as the number of elements in the array as an unsigned, base-10 value. \* The CRLF terminator. \* An additional RESP type for every element of the array. So an empty Array is just the following: \*0\r\n Whereas the encoding of an array consisting of the two bulk strings "hello" and "world" is: \*2\r\n$5\r\nhello\r\n$5\r\nworld\r\n As you can see, after the `\*CRLF` part prefixing the array, the other data types that compose the array are concatenated one after the other. For example, an Array of three integers is encoded as follows: \*3\r\n:1\r\n:2\r\n:3\r\n Arrays can contain mixed data types. For instance, the following encoding is of a list of four integers and a bulk string: \*5\r\n :1\r\n :2\r\n :3\r\n :4\r\n $5\r\n hello\r\n (The raw RESP encoding is split into multiple lines for readability). The first line the server sent is `\*5\r\n`. This numeric value tells the client that five reply types are about to follow it. Then, every successive reply constitutes an element in the array. All of the aggregate RESP types support nesting. For example, a nested array of two arrays is encoded as follows: \*2\r\n \*3\r\n :1\r\n :2\r\n :3\r\n \*2\r\n +Hello\r\n -World\r\n (The raw RESP encoding is split into multiple lines for readability). The above encodes a two-element array. The first element is an array that, in turn, contains three integers (1, 2, 3). The second element is another array containing a simple string and an error. {{% alert title="Multi bulk reply" color="info" %}} In some places, the RESP Array type may be referred to as \_multi bulk\_. The two are the same. {{% /alert %}} #### Null arrays Whereas RESP3 has a dedicated data type for [null values](#nulls), RESP2 has no such type. Instead, due to historical reasons, the representation of null values in RESP2 is via predetermined forms of the [Bulk Strings](#bulk-strings) and [arrays](#arrays) types. Null arrays exist as an alternative way of representing a null value. For instance, when the `BLPOP` | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.058831021189689636,
-0.004544292576611042,
-0.0718265026807785,
-0.046703848987817764,
-0.0217334795743227,
-0.11727555096149445,
0.020773932337760925,
0.061817578971385956,
0.026395810768008232,
-0.009307368658483028,
0.002272441051900387,
-0.05583248287439346,
0.04880911484360695,
-0.... | 0.18884 |
data type for [null values](#nulls), RESP2 has no such type. Instead, due to historical reasons, the representation of null values in RESP2 is via predetermined forms of the [Bulk Strings](#bulk-strings) and [arrays](#arrays) types. Null arrays exist as an alternative way of representing a null value. For instance, when the `BLPOP` command times out, it returns a null array. The encoding of a null array is that of an array with the length of -1, i.e.: \*-1\r\n When Redis replies with a null array, the client should return a null object rather than an empty array. This is necessary to distinguish between an empty list and a different condition (for instance, the timeout condition of the `BLPOP` command). #### Null elements in arrays Single elements of an array may be [null bulk string](#null-bulk-strings). This is used in Redis replies to signal that these elements are missing and not empty strings. This can happen, for example, with the `SORT` command when used with the `GET pattern` option if the specified key is missing. Here's an example of an array reply containing a null element: \*3\r\n $5\r\n hello\r\n $-1\r\n $5\r\n world\r\n Above, the second element is null. The client library should return to its caller something like this: ["hello",nil,"world"] ### Nulls The null data type represents non-existent values. Nulls' encoding is the underscore (`\_`) character, followed by the CRLF terminator (`\r\n`). Here's Null's raw RESP encoding: \_\r\n {{% alert title="Null Bulk String, Null Arrays and Nulls" color="info" %}} Due to historical reasons, RESP2 features two specially crafted values for representing null values of bulk strings and arrays. This duality has always been a redundancy that added zero semantical value to the protocol itself. The null type, introduced in RESP3, aims to fix this wrong. {{% /alert %}} ### Booleans RESP booleans are encoded as follows: #\r\n \* The octothorpe character (`#`) as the first byte. \* A `t` character for true values, or an `f` character for false ones. \* The CRLF terminator. ### Doubles The Double RESP type encodes a double-precision floating point value. Doubles are encoded as follows: ,[<+|->][.][[sign]]\r\n \* The comma character (`,`) as the first byte. \* An optional plus (`+`) or minus (`-`) as the sign. \* One or more decimal digits (`0`..`9`) as an unsigned, base-10 integral value. \* An optional dot (`.`), followed by one or more decimal digits (`0`..`9`) as an unsigned, base-10 fractional value. \* An optional capital or lowercase letter E (`E` or `e`), followed by an optional plus (`+`) or minus (`-`) as the exponent's sign, ending with one or more decimal digits (`0`..`9`) as an unsigned, base-10 exponent value. \* The CRLF terminator. Here's the encoding of the number 1.23: ,1.23\r\n Because the fractional part is optional, the integer value of ten (10) can, therefore, be RESP-encoded both as an integer as well as a double: :10\r\n ,10\r\n In such cases, the Redis client should return native integer and double values, respectively, providing that these types are supported by the language of its implementation. The positive infinity, negative infinity and NaN values are encoded as follows: ,inf\r\n ,-inf\r\n ,nan\r\n ### Big numbers This type can encode integer values outside the range of signed 64-bit integers. Big numbers use the following encoding: ([+|-]\r\n \* The left parenthesis character (`(`) as the first byte. \* An optional plus (`+`) or minus (`-`) as the sign. \* One or more decimal digits (`0`..`9`) as an unsigned, base-10 value. \* The CRLF terminator. Example: (3492890328409238509324850943850943825024385\r\n Big numbers can be positive or negative but can't include fractionals. Client libraries written in languages with a big number | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.04089773818850517,
0.011157829314470291,
-0.07673699408769608,
0.04991675540804863,
-0.05675448104739189,
-0.06823072582483292,
0.03375662490725517,
0.039507634937763214,
0.011878274381160736,
-0.014456952922046185,
-0.003667013719677925,
-0.0037886665668338537,
0.031541336327791214,
-0... | 0.13425 |
byte. \* An optional plus (`+`) or minus (`-`) as the sign. \* One or more decimal digits (`0`..`9`) as an unsigned, base-10 value. \* The CRLF terminator. Example: (3492890328409238509324850943850943825024385\r\n Big numbers can be positive or negative but can't include fractionals. Client libraries written in languages with a big number type should return a big number. When big numbers aren't supported, the client should return a string and, when possible, signal to the caller that the reply is a big integer (depending on the API used by the client library). ### Bulk errors This type combines the purpose of [simple errors](#simple-errors) with the expressive power of [bulk strings](#bulk-strings). It is encoded as: !\r\n\r\n \* An exclamation mark (`!`) as the first byte. \* One or more decimal digits (`0`..`9`) as the error's length, in bytes, as an unsigned, base-10 value. \* The CRLF terminator. \* The error itself. \* A final CRLF. As a convention, the error begins with an uppercase (space-delimited) word that conveys the error message. For instance, the error "SYNTAX invalid syntax" is represented by the following protocol encoding: !21\r\n SYNTAX invalid syntax\r\n (The raw RESP encoding is split into multiple lines for readability). ### Verbatim strings This type is similar to the [bulk string](#bulk-strings), with the addition of providing a hint about the data's encoding. A verbatim string's RESP encoding is as follows: =\r\n:\r\n \* An equal sign (`=`) as the first byte. \* One or more decimal digits (`0`..`9`) as the string's total length, in bytes, as an unsigned, base-10 value. \* The CRLF terminator. \* Exactly three (3) bytes represent the data's encoding. \* The colon (`:`) character separates the encoding and data. \* The data. \* A final CRLF. Example: =15\r\n txt:Some string\r\n (The raw RESP encoding is split into multiple lines for readability). Some client libraries may ignore the difference between this type and the string type and return a native string in both cases. However, interactive clients, such as command line interfaces (e.g., [`redis-cli`](/docs/manual/cli)), can use this type and know that their output should be presented to the human user as is and without quoting the string. For example, the Redis command `INFO` outputs a report that includes newlines. When using RESP3, `redis-cli` displays it correctly because it is sent as a Verbatim String reply (with its three bytes being "txt"). When using RESP2, however, the `redis-cli` is hard-coded to look for the `INFO` command to ensure its correct display to the user. ### Maps The RESP map encodes a collection of key-value tuples, i.e., a dictionary or a hash. It is encoded as follows: %\r\n... \* A percent character (`%`) as the first byte. \* One or more decimal digits (`0`..`9`) as the number of entries, or key-value tuples, in the map as an unsigned, base-10 value. \* The CRLF terminator. \* Two additional RESP types for every key and value in the map. For example, the following JSON object: { "first": 1, "second": 2 } Can be encoded in RESP like so: %2\r\n +first\r\n :1\r\n +second\r\n :2\r\n (The raw RESP encoding is split into multiple lines for readability). Both map keys and values can be any of RESP's types. Redis clients should return the idiomatic dictionary type that their language provides. However, low-level programming languages (such as C, for example) will likely return an array along with type information that indicates to the caller that it is a dictionary. {{% alert title="Map pattern in RESP2" color="info" %}} RESP2 doesn't have a map type. A map in RESP2 is represented by a flat array containing the keys and the values. | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.06987183541059494,
0.008453217335045338,
-0.02462945692241192,
-0.01899757981300354,
-0.051748014986515045,
-0.07473351061344147,
0.056731611490249634,
0.09142281860113144,
0.0042370581068098545,
-0.0067867496982216835,
-0.07445787638425827,
-0.031567685306072235,
0.07623425871133804,
0... | 0.082539 |
example) will likely return an array along with type information that indicates to the caller that it is a dictionary. {{% alert title="Map pattern in RESP2" color="info" %}} RESP2 doesn't have a map type. A map in RESP2 is represented by a flat array containing the keys and the values. The first element is a key, followed by the corresponding value, then the next key and so on, like this: `key1, value1, key2, value2, ...`. {{% /alert %}} ### Sets Sets are somewhat like [Arrays](#arrays) but are unordered and should only contain unique elements. RESP set's encoding is: ~\r\n... \* A tilde (`~`) as the first byte. \* One or more decimal digits (`0`..`9`) as the number of elements in the set as an unsigned, base-10 value. \* The CRLF terminator. \* An additional RESP type for every element of the Set. Clients should return the native set type if it is available in their programming language. Alternatively, in the absence of a native set type, an array coupled with type information can be used (in C, for example). ### Pushes RESP's pushes contain out-of-band data. They are an exception to the protocol's request-response model and provide a generic \_push mode\_ for connections. Push events are encoded similarly to [arrays](#arrays), differing only in their first byte: >\r\n... \* A greater-than sign (`>`) as the first byte. \* One or more decimal digits (`0`..`9`) as the number of elements in the message as an unsigned, base-10 value. \* The CRLF terminator. \* An additional RESP type for every element of the push event. Pushed data may precede or follow any of RESP's data types but never inside them. That means a client won't find push data in the middle of a map reply, for example. It also means that pushed data may appear before or after a command's reply, as well as by itself (without calling any command). Clients should react to pushes by invoking a callback that implements their handling of the pushed data. ## Client handshake New RESP connections should begin the session by calling the `HELLO` command. This practice accomplishes two things: 1. It allows servers to be backward compatible with RESP2 versions. This is needed in Redis to make the transition to version 3 of the protocol gentler. 2. The `HELLO` command returns information about the server and the protocol that the client can use for different goals. The `HELLO` command has the following high-level syntax: HELLO [optional-arguments] The first argument of the command is the protocol version we want the connection to be set. By default, the connection starts in RESP2 mode. If we specify a connection version that is too big and unsupported by the server, it should reply with a `-NOPROTO` error. Example: Client: HELLO 4 Server: -NOPROTO sorry, this protocol version is not supported. At that point, the client may retry with a lower protocol version. Similarly, the client can easily detect a server that is only able to speak RESP2: Client: HELLO 3 Server: -ERR unknown command 'HELLO' The client can then proceed and use RESP2 to communicate with the server. Note that even if the protocol's version is supported, the `HELLO` command may return an error, perform no action and remain in RESP2 mode. For example, when used with invalid authentication credentials in the command's optional `!AUTH` clause: Client: HELLO 3 AUTH default mypassword Server: -ERR invalid password (the connection remains in RESP2 mode) A successful reply to the `HELLO` command is a map reply. The information in the reply is partly server-dependent, but certain fields are mandatory for all the | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.01629612408578396,
0.042663443833589554,
-0.029261576011776924,
-0.014973869547247887,
-0.044719796627759933,
-0.06672178208827972,
0.13184486329555511,
0.03575354442000389,
-0.04846997931599617,
-0.05234604701399803,
-0.03581870347261429,
-0.0034323588479310274,
0.11162229627370834,
-0... | 0.128695 |
credentials in the command's optional `!AUTH` clause: Client: HELLO 3 AUTH default mypassword Server: -ERR invalid password (the connection remains in RESP2 mode) A successful reply to the `HELLO` command is a map reply. The information in the reply is partly server-dependent, but certain fields are mandatory for all the RESP3 implementations: \* \*\*server\*\*: "redis" (or other software name). \* \*\*version\*\*: the server's version. \* \*\*proto\*\*: the highest supported version of the RESP protocol. In Redis' RESP3 implementation, the following fields are also emitted: \* \*\*id\*\*: the connection's identifier (ID). \* \*\*mode\*\*: "standalone", "sentinel" or "cluster". \* \*\*role\*\*: "master" or "replica". \* \*\*modules\*\*: list of loaded modules as an Array of Bulk Strings. ## Sending commands to a Redis server Now that you are familiar with the RESP serialization format, you can use it to help write a Redis client library. We can further specify how the interaction between the client and the server works: \* A client sends the Redis server an [array](#arrays) consisting of only bulk strings. \* A Redis server replies to clients, sending any valid RESP data type as a reply. So, for example, a typical interaction could be the following. The client sends the command `LLEN mylist` to get the length of the list stored at the key \_mylist\_. Then the server replies with an [integer](#integers) reply as in the following example (`C:` is the client, `S:` the server). C: \*2\r\n C: $4\r\n C: LLEN\r\n C: $6\r\n C: mylist\r\n S: :48293\r\n As usual, we separate different parts of the protocol with newlines for simplicity, but the actual interaction is the client sending `\*2\r\n$4\r\nLLEN\r\n$6\r\nmylist\r\n` as a whole. ## Multiple commands and pipelining A client can use the same connection to issue multiple commands. Pipelining is supported, so multiple commands can be sent with a single write operation by the client. The client can skip reading replies and continue to send the commands one after the other. All the replies can be read at the end. For more information, see [Pipelining](/topics/pipelining). ## Inline commands Sometimes you may need to send a command to the Redis server but only have `telnet` available. While the Redis protocol is simple to implement, it is not ideal for interactive sessions, and `redis-cli` may not always be available. For this reason, Redis also accepts commands in the \_inline command\_ format. The following example demonstrates a server/client exchange using an inline command (the server chat starts with `S:`, the client chat with `C:`): C: PING S: +PONG Here's another example of an inline command where the server returns an integer: C: EXISTS somekey S: :0 Basically, to issue an inline command, you write space-separated arguments in a telnet session. Since no command starts with `\*` (the identifying byte of RESP Arrays), Redis detects this condition and parses your command inline. ## High-performance parser for the Redis protocol While the Redis protocol is human-readable and easy to implement, its implementation can exhibit performance similar to that of a binary protocol. RESP uses prefixed lengths to transfer bulk data. That makes scanning the payload for special characters unnecessary (unlike parsing JSON, for example). For the same reason, quoting and escaping the payload isn't needed. Reading the length of aggregate types (for example, bulk strings or arrays) can be processed with code that performs a single operation per character while at the same time scanning for the CR character. Example (in C): ```c #include int main(void) { unsigned char \*p = "$123\r\n"; int len = 0; p++; while(\*p != '\r') { len = (len\*10)+(\*p - '0'); p++; } /\* Now p points at '\r', and the | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.07541628181934357,
-0.047371841967105865,
-0.04719775915145874,
-0.007348388433456421,
-0.021380331367254257,
-0.06989736109972,
0.01651320978999138,
0.023573679849505424,
0.028495140373706818,
0.05751636251807213,
-0.0423722006380558,
-0.01059566717594862,
0.06459154933691025,
-0.01358... | 0.140941 |
operation per character while at the same time scanning for the CR character. Example (in C): ```c #include int main(void) { unsigned char \*p = "$123\r\n"; int len = 0; p++; while(\*p != '\r') { len = (len\*10)+(\*p - '0'); p++; } /\* Now p points at '\r', and the len is in bulk\_len. \*/ printf("%d\n", len); return 0; } ``` After the first CR is identified, it can be skipped along with the following LF without further processing. Then, the bulk data can be read with a single read operation that doesn't inspect the payload in any way. Finally, the remaining CR and LF characters are discarded without additional processing. While comparable in performance to a binary protocol, the Redis protocol is significantly more straightforward to implement in most high-level languages, reducing the number of bugs in client software. ## Tips for Redis client authors \* For testing purposes, use [Lua's type conversions](/topics/lua-api#lua-to-resp3-type-conversion) to have Redis reply with any RESP2/RESP3 needed. As an example, a RESP3 double can be generated like so: ``` EVAL "return { double = tonumber(ARGV[1]) }" 0 1e0 ``` | https://github.com/redis/redis-doc/blob/master//docs/reference/protocol-spec.md | master | redis | [
-0.03620944917201996,
0.005088798236101866,
-0.06838404387235641,
-0.011479857377707958,
-0.057966236025094986,
-0.05560837313532829,
0.06753697246313095,
0.040874797850847244,
0.03735164552927017,
-0.03239898011088371,
0.0216902494430542,
0.035947173833847046,
0.07712402939796448,
-0.0252... | 0.101585 |
The `COMMAND DOCS` command returns documentation-focused information about available Redis commands. The map reply that the command returns includes the \_arguments\_ key. This key stores an array that describes the command's arguments. Every element in the \_arguments\_ array is a map with the following fields: \* \*\*name:\*\* the argument's name, always present. The name of an argument is given for identification purposes alone. It isn't displayed during the command's syntax rendering. The same name can appear more than once in the entire argument tree, but it is unique compared to other sibling arguments' names. This allows obtaining a unique identifier for each argument (the concatenation of all names in the path from the root to any argument). \* \*\*display\_text:\*\* the argument's display string, present in arguments that have a displayable representation (all arguments that aren't oneof/block). This is the string used in the command's syntax rendering. \* \*\*type:\*\* the argument's type, always present. An argument must have one of the following types: - \*\*string:\*\* a string argument. - \*\*integer:\*\* an integer argument. - \*\*double:\*\* a double-precision argument. - \*\*key:\*\* a string that represents the name of a key. - \*\*pattern:\*\* a string that represents a glob-like pattern. - \*\*unix-time:\*\* an integer that represents a Unix timestamp. - \*\*pure-token:\*\* an argument is a token, meaning a reserved keyword, which may or may not be provided. Not to be confused with free-text user input. - \*\*oneof\*\*: the argument is a container for nested arguments. This type enables choice among several nested arguments (see the `XADD` example below). - \*\*block:\*\* the argument is a container for nested arguments. This type enables grouping arguments and applying a property (such as \_optional\_) to all (see the `XADD` example below). \* \*\*key\_spec\_index:\*\* this value is available for every argument of the \_key\_ type. It is a 0-based index of the specification in the command's [key specifications][tr] that corresponds to the argument. \* \*\*token\*\*: a constant literal that precedes the argument (user input) itself. \* \*\*summary:\*\* a short description of the argument. \* \*\*since:\*\* the debut Redis version of the argument (or for module commands, the module version). \* \*\*deprecated\_since:\*\* the Redis version that deprecated the command (or for module commands, the module version). \* \*\*flags:\*\* an array of argument flags. Possible flags are: - \*\*optional\*\*: denotes that the argument is optional (for example, the \_GET\_ clause of the `SET` command). - \*\*multiple\*\*: denotes that the argument may be repeated (such as the \_key\_ argument of `DEL`). - \*\*multiple-token:\*\* denotes the possible repetition of the argument with its preceding token (see `SORT`'s `GET pattern` clause). \* \*\*value:\*\* the argument's value. For arguments types other than \_oneof\_ and \_block\_, this is a string that describes the value in the command's syntax. For the \_oneof\_ and \_block\_ types, this is an array of nested arguments, each being a map as described in this section. [tr]: /topics/key-specs ## Example The trimming clause of `XADD`, i.e., `[MAXLEN|MINID [=|~] threshold [LIMIT count]]`, is represented at the top-level as \_block\_-typed argument. It consists of four nested arguments: 1. \*\*trimming strategy:\*\* this nested argument has an \_oneof\_ type with two nested arguments. Each of the nested arguments, \_MAXLEN\_ and \_MINID\_, is typed as \_pure-token\_. 2. \*\*trimming operator:\*\* this nested argument is an optional \_oneof\_ type with two nested arguments. Each of the nested arguments, \_=\_ and \_~\_, is a \_pure-token\_. 3. \*\*threshold:\*\* this nested argument is a \_string\_. 4. \*\*count:\*\* this nested argument is an optional \_integer\_ with a \_token\_ (\_LIMIT\_). Here's `XADD`'s arguments array: ``` 1) 1) "name" 2) "key" 3) "type" 4) "key" 5) "value" 6) "key" 2) 1) "name" 2) "nomkstream" | https://github.com/redis/redis-doc/blob/master//docs/reference/command-arguments.md | master | redis | [
-0.029373453930020332,
0.018283464014530182,
-0.0829152911901474,
0.07667072117328644,
-0.031019901856780052,
-0.05728526413440704,
0.04900607466697693,
0.02821933664381504,
0.02931513823568821,
-0.05011569336056709,
-0.03901183605194092,
-0.027222277596592903,
0.04734686017036438,
-0.0393... | 0.192421 |
\_=\_ and \_~\_, is a \_pure-token\_. 3. \*\*threshold:\*\* this nested argument is a \_string\_. 4. \*\*count:\*\* this nested argument is an optional \_integer\_ with a \_token\_ (\_LIMIT\_). Here's `XADD`'s arguments array: ``` 1) 1) "name" 2) "key" 3) "type" 4) "key" 5) "value" 6) "key" 2) 1) "name" 2) "nomkstream" 3) "type" 4) "pure-token" 5) "token" 6) "NOMKSTREAM" 7) "since" 8) "6.2" 9) "flags" 10) 1) optional 3) 1) "name" 2) "trim" 3) "type" 4) "block" 5) "flags" 6) 1) optional 7) "value" 8) 1) 1) "name" 2) "strategy" 3) "type" 4) "oneof" 5) "value" 6) 1) 1) "name" 2) "maxlen" 3) "type" 4) "pure-token" 5) "token" 6) "MAXLEN" 2) 1) "name" 2) "minid" 3) "type" 4) "pure-token" 5) "token" 6) "MINID" 7) "since" 8) "6.2" 2) 1) "name" 2) "operator" 3) "type" 4) "oneof" 5) "flags" 6) 1) optional 7) "value" 8) 1) 1) "name" 2) "equal" 3) "type" 4) "pure-token" 5) "token" 6) "=" 2) 1) "name" 2) "approximately" 3) "type" 4) "pure-token" 5) "token" 6) "~" 3) 1) "name" 2) "threshold" 3) "type" 4) "string" 5) "value" 6) "threshold" 4) 1) "name" 2) "count" 3) "type" 4) "integer" 5) "token" 6) "LIMIT" 7) "since" 8) "6.2" 9) "flags" 10) 1) optional 11) "value" 12) "count" 4) 1) "name" 2) "id\_or\_auto" 3) "type" 4) "oneof" 5) "value" 6) 1) 1) "name" 2) "auto\_id" 3) "type" 4) "pure-token" 5) "token" 6) "\*" 2) 1) "name" 2) "id" 3) "type" 4) "string" 5) "value" 6) "id" 5) 1) "name" 2) "field\_value" 3) "type" 4) "block" 5) "flags" 6) 1) multiple 7) "value" 8) 1) 1) "name" 2) "field" 3) "type" 4) "string" 5) "value" 6) "field" 2) 1) "name" 2) "value" 3) "type" 4) "string" 5) "value" 6) "value" ``` | https://github.com/redis/redis-doc/blob/master//docs/reference/command-arguments.md | master | redis | [
0.01242564246058464,
0.03773995116353035,
-0.03473800793290138,
-0.055079083889722824,
-0.06820499151945114,
-0.02610781416296959,
0.1456230878829956,
0.03654512017965317,
0.00003885701880790293,
0.005210602190345526,
0.03600156679749489,
-0.14254572987556458,
0.05754195898771286,
-0.02889... | 0.129478 |
\*\*Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010). Virtual Memory has been deprecated since Redis 2.6, so this documentation is here only for historical interest.\*\* The implementation of Redis strings is contained in `sds.c` (`sds` stands for Simple Dynamic Strings). The implementation is available as a standalone library at [https://github.com/antirez/sds](https://github.com/antirez/sds). The C structure `sdshdr` declared in `sds.h` represents a Redis string: struct sdshdr { long len; long free; char buf[]; }; The `buf` character array stores the actual string. The `len` field stores the length of `buf`. This makes obtaining the length of a Redis string an O(1) operation. The `free` field stores the number of additional bytes available for use. Together the `len` and `free` field can be thought of as holding the metadata of the `buf` character array. Creating Redis Strings --- A new data type named `sds` is defined in `sds.h` to be a synonym for a character pointer: typedef char \*sds; `sdsnewlen` function defined in `sds.c` creates a new Redis String: sds sdsnewlen(const void \*init, size\_t initlen) { struct sdshdr \*sh; sh = zmalloc(sizeof(struct sdshdr)+initlen+1); #ifdef SDS\_ABORT\_ON\_OOM if (sh == NULL) sdsOomAbort(); #else if (sh == NULL) return NULL; #endif sh->len = initlen; sh->free = 0; if (initlen) { if (init) memcpy(sh->buf, init, initlen); else memset(sh->buf,0,initlen); } sh->buf[initlen] = '\0'; return (char\*)sh->buf; } Remember a Redis string is a variable of type `struct sdshdr`. But `sdsnewlen` returns a character pointer!! That's a trick and needs some explanation. Suppose I create a Redis string using `sdsnewlen` like below: sdsnewlen("redis", 5); This creates a new variable of type `struct sdshdr` allocating memory for `len` and `free` fields as well as for the `buf` character array. sh = zmalloc(sizeof(struct sdshdr)+initlen+1); // initlen is length of init argument. After `sdsnewlen` successfully creates a Redis string the result is something like: ----------- |5|0|redis| ----------- ^ ^ sh sh->buf `sdsnewlen` returns `sh->buf` to the caller. What do you do if you need to free the Redis string pointed by `sh`? You want the pointer `sh` but you only have the pointer `sh->buf`. Can you get the pointer `sh` from `sh->buf`? Yes. Pointer arithmetic. Notice from the above ASCII art that if you subtract the size of two longs from `sh->buf` you get the pointer `sh`. The `sizeof` two longs happens to be the size of `struct sdshdr`. Look at `sdslen` function and see this trick at work: size\_t sdslen(const sds s) { struct sdshdr \*sh = (void\*) (s-(sizeof(struct sdshdr))); return sh->len; } Knowing this trick you could easily go through the rest of the functions in `sds.c`. The Redis string implementation is hidden behind an interface that accepts only character pointers. The users of Redis strings need not care about how it's implemented and can treat Redis strings as a character pointer. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-sds.md | master | redis | [
-0.05064210668206215,
0.009385285899043083,
-0.07440980523824692,
0.009315792471170425,
-0.027175499126315117,
-0.04019835218787193,
0.042222633957862854,
0.08978906273841858,
0.04948321729898453,
-0.029019854962825775,
0.015232691541314125,
0.018885141238570213,
0.001721127307973802,
-0.0... | 0.222327 |
\*\*Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010). Virtual Memory has been deprecated since Redis 2.6, so this documentation is here only for historical interest.\*\* This document details the internals of the Redis Virtual Memory subsystem prior to Redis 2.6. The intended audience is not the final user but programmers willing to understand or modify the Virtual Memory implementation. Keys vs Values: what is swapped out? --- The goal of the VM subsystem is to free memory transferring Redis Objects from memory to disk. This is a very generic command, but specifically, Redis transfers only objects associated with \_values\_. In order to understand better this concept we'll show, using the DEBUG command, how a key holding a value looks from the point of view of the Redis internals: redis> set foo bar OK redis> debug object foo Key at:0x100101d00 refcount:1, value at:0x100101ce0 refcount:1 encoding:raw serializedlength:4 As you can see from the above output, the Redis top level hash table maps Redis Objects (keys) to other Redis Objects (values). The Virtual Memory is only able to swap \_values\_ on disk, the objects associated to \_keys\_ are always taken in memory: this trade off guarantees very good lookup performances, as one of the main design goals of the Redis VM is to have performances similar to Redis with VM disabled when the part of the dataset frequently used fits in RAM. How does a swapped value looks like internally --- When an object is swapped out, this is what happens in the hash table entry: \* The key continues to hold a Redis Object representing the key. \* The value is set to NULL So you may wonder where we store the information that a given value (associated to a given key) was swapped out. Just in the key object! This is how the Redis Object structure \_robj\_ looks like: /\* The actual Redis Object \*/ typedef struct redisObject { void \*ptr; unsigned char type; unsigned char encoding; unsigned char storage; /\* If this object is a key, where is the value? \* REDIS\_VM\_MEMORY, REDIS\_VM\_SWAPPED, ... \*/ unsigned char vtype; /\* If this object is a key, and value is swapped out, \* this is the type of the swapped out object. \*/ int refcount; /\* VM fields, this are only allocated if VM is active, otherwise the \* object allocation function will just allocate \* sizeof(redisObject) minus sizeof(redisObjectVM), so using \* Redis without VM active will not have any overhead. \*/ struct redisObjectVM vm; } robj; As you can see there are a few fields about VM. The most important one is \_storage\_, that can be one of this values: \* `REDIS\_VM\_MEMORY`: the associated value is in memory. \* `REDIS\_VM\_SWAPPED`: the associated values is swapped, and the value entry of the hash table is just set to NULL. \* `REDIS\_VM\_LOADING`: the value is swapped on disk, the entry is NULL, but there is a job to load the object from the swap to the memory (this field is only used when threaded VM is active). \* `REDIS\_VM\_SWAPPING`: the value is in memory, the entry is a pointer to the actual Redis Object, but there is an I/O job in order to transfer this value to the swap file. If an object is swapped on disk (`REDIS\_VM\_SWAPPED` or `REDIS\_VM\_LOADING`), how do we know where it is stored, what type it is, and so forth? That's simple: the \_vtype\_ field is set to the original type of the Redis object swapped, while the \_vm\_ field (that is a \_redisObjectVM\_ structure) holds | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.04349333047866821,
-0.00021594230202026665,
-0.09030279517173767,
0.03234640881419182,
-0.03631759434938431,
-0.02797015942633152,
0.07220949977636337,
0.060186803340911865,
0.04261717572808266,
0.01154419220983982,
0.010894381441175938,
0.0015659481287002563,
0.012867056764662266,
-0.0... | 0.203811 |
an object is swapped on disk (`REDIS\_VM\_SWAPPED` or `REDIS\_VM\_LOADING`), how do we know where it is stored, what type it is, and so forth? That's simple: the \_vtype\_ field is set to the original type of the Redis object swapped, while the \_vm\_ field (that is a \_redisObjectVM\_ structure) holds information about the location of the object. This is the definition of this additional structure: /\* The VM object structure \*/ struct redisObjectVM { off\_t page; /\* the page at which the object is stored on disk \*/ off\_t usedpages; /\* number of pages used on disk \*/ time\_t atime; /\* Last access time \*/ } vm; As you can see the structure contains the page at which the object is located in the swap file, the number of pages used, and the last access time of the object (this is very useful for the algorithm that select what object is a good candidate for swapping, as we want to transfer on disk objects that are rarely accessed). As you can see, while all the other fields are using unused bytes in the old Redis Object structure (we had some free bit due to natural memory alignment concerns), the \_vm\_ field is new, and indeed uses additional memory. Should we pay such a memory cost even when VM is disabled? No! This is the code to create a new Redis Object: ... some code ... if (server.vm\_enabled) { pthread\_mutex\_unlock(&server.obj\_freelist\_mutex); o = zmalloc(sizeof(\*o)); } else { o = zmalloc(sizeof(\*o)-sizeof(struct redisObjectVM)); } ... some code ... As you can see if the VM system is not enabled we allocate just `sizeof(\*o)-sizeof(struct redisObjectVM)` of memory. Given that the \_vm\_ field is the last in the object structure, and that this fields are never accessed if VM is disabled, we are safe and Redis without VM does not pay the memory overhead. The Swap File --- The next step in order to understand how the VM subsystem works is understanding how objects are stored inside the swap file. The good news is that's not some kind of special format, we just use the same format used to store the objects in .rdb files, that are the usual dump files produced by Redis using the `SAVE` command. The swap file is composed of a given number of pages, where every page size is a given number of bytes. This parameters can be changed in redis.conf, since different Redis instances may work better with different values: it depends on the actual data you store inside it. The following are the default values: vm-page-size 32 vm-pages 134217728 Redis takes a "bitmap" (a contiguous array of bits set to zero or one) in memory, every bit represent a page of the swap file on disk: if a given bit is set to 1, it represents a page that is already used (there is some Redis Object stored there), while if the corresponding bit is zero, the page is free. Taking this bitmap (that will call the page table) in memory is a huge win in terms of performances, and the memory used is small: we just need 1 bit for every page on disk. For instance in the example below 134217728 pages of 32 bytes each (4GB swap file) is using just 16 MB of RAM for the page table. Transferring objects from memory to swap --- In order to transfer an object from memory to disk we need to perform the following steps (assuming non threaded VM, just a simple blocking approach): \* Find how many pages are needed in order to store this object on the | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.012359022162854671,
0.03704283758997917,
-0.059611402451992035,
0.041747331619262695,
-0.005956894718110561,
-0.014044762589037418,
0.0019985847175121307,
0.029191600158810616,
0.04015525430440903,
0.010987788438796997,
0.0021790352184325457,
0.0555824413895607,
-0.06014055758714676,
-0... | 0.199136 |
page table. Transferring objects from memory to swap --- In order to transfer an object from memory to disk we need to perform the following steps (assuming non threaded VM, just a simple blocking approach): \* Find how many pages are needed in order to store this object on the swap file. This is trivially accomplished just calling the function `rdbSavedObjectPages` that returns the number of pages used by an object on disk. Note that this function does not duplicate the .rdb saving code just to understand what will be the length \*after\* an object will be saved on disk, we use the trick of opening /dev/null and writing the object there, finally calling `ftello` in order check the amount of bytes required. What we do basically is to save the object on a virtual very fast file, that is, /dev/null. \* Now that we know how many pages are required in the swap file, we need to find this number of contiguous free pages inside the swap file. This task is accomplished by the `vmFindContiguousPages` function. As you can guess this function may fail if the swap is full, or so fragmented that we can't easily find the required number of contiguous free pages. When this happens we just abort the swapping of the object, that will continue to live in memory. \* Finally we can write the object on disk, at the specified position, just calling the function `vmWriteObjectOnSwap`. As you can guess once the object was correctly written in the swap file, it is freed from memory, the storage field in the associated key is set to `REDIS\_VM\_SWAPPED`, and the used pages are marked as used in the page table. Loading objects back in memory --- Loading an object from swap to memory is simpler, as we already know where the object is located and how many pages it is using. We also know the type of the object (the loading functions are required to know this information, as there is no header or any other information about the object type on disk), but this is stored in the \_vtype\_ field of the associated key as already seen above. Calling the function `vmLoadObject` passing the key object associated to the value object we want to load back is enough. The function will also take care of fixing the storage type of the key (that will be `REDIS\_VM\_MEMORY`), marking the pages as freed in the page table, and so forth. The return value of the function is the loaded Redis Object itself, that we'll have to set again as value in the main hash table (instead of the NULL value we put in place of the object pointer when the value was originally swapped out). How blocking VM works --- Now we have all the building blocks in order to describe how the blocking VM works. First of all, an important detail about configuration. In order to enable blocking VM in Redis `server.vm\_max\_threads` must be set to zero. We'll see later how this max number of threads info is used in the threaded VM, for now all it's needed to now is that Redis reverts to fully blocking VM when this is set to zero. We also need to introduce another important VM parameter, that is, `server.vm\_max\_memory`. This parameter is very important as it is used in order to trigger swapping: Redis will try to swap objects only if it is using more memory than the max memory setting, otherwise there is no need to swap as we are matching the user requested memory usage. Blocking VM swapping | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.013706705532968044,
0.0016711772186681628,
-0.08126762509346008,
0.030689775943756104,
-0.03492421656847,
0.019069762900471687,
-0.0355260893702507,
0.014918163418769836,
-0.0323089063167572,
0.1221088394522667,
-0.01857648603618145,
-0.0032303291372954845,
0.05389619991183281,
-0.05287... | 0.057263 |
parameter is very important as it is used in order to trigger swapping: Redis will try to swap objects only if it is using more memory than the max memory setting, otherwise there is no need to swap as we are matching the user requested memory usage. Blocking VM swapping --- Swapping of object from memory to disk happens in the cron function. This function used to be called every second, while in the recent Redis versions on git it is called every 100 milliseconds (that is, 10 times per second). If this function detects we are out of memory, that is, the memory used is greater than the vm-max-memory setting, it starts transferring objects from memory to disk in a loop calling the function `vmSwapOneObect`. This function takes just one argument, if 0 it will swap objects in a blocking way, otherwise if it is 1, I/O threads are used. In the blocking scenario we just call it with zero as argument. vmSwapOneObject acts performing the following steps: \* The key space in inspected in order to find a good candidate for swapping (we'll see later what a good candidate for swapping is). \* The associated value is transferred to disk, in a blocking way. \* The key storage field is set to `REDIS\_VM\_SWAPPED`, while the \_vm\_ fields of the object are set to the right values (the page index where the object was swapped, and the number of pages used to swap it). \* Finally the value object is freed and the value entry of the hash table is set to NULL. The function is called again and again until one of the following happens: there is no way to swap more objects because either the swap file is full or nearly all the objects are already transferred on disk, or simply the memory usage is already under the vm-max-memory parameter. What values to swap when we are out of memory? --- Understanding what's a good candidate for swapping is not too hard. A few objects at random are sampled, and for each their \_swappability\_ is commuted as: swappability = age\*log(size\_in\_memory) The age is the number of seconds the key was not requested, while size\_in\_memory is a fast estimation of the amount of memory (in bytes) used by the object in memory. So we try to swap out objects that are rarely accessed, and we try to swap bigger objects over smaller one, but the latter is a less important factor (because of the logarithmic function used). This is because we don't want bigger objects to be swapped out and in too often as the bigger the object the more I/O and CPU is required in order to transfer it. Blocking VM loading --- What happens if an operation against a key associated with a swapped out object is requested? For instance Redis may just happen to process the following command: GET foo If the value object of the `foo` key is swapped we need to load it back in memory before processing the operation. In Redis the key lookup process is centralized in the `lookupKeyRead` and `lookupKeyWrite` functions, this two functions are used in the implementation of all the Redis commands accessing the keyspace, so we have a single point in the code where to handle the loading of the key from the swap file to memory. So this is what happens: \* The user calls some command having as argument a swapped key \* The command implementation calls the lookup function \* The lookup function search for the key in the top level hash table. If | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.038245104253292084,
0.009506060741841793,
-0.08834079653024673,
0.05433120205998421,
-0.03525989502668381,
-0.02429206855595112,
0.06809063255786896,
0.04521336406469345,
0.030445074662566185,
0.032850947231054306,
0.01578894816339016,
0.016768459230661392,
-0.023496391251683235,
-0.059... | 0.156473 |
loading of the key from the swap file to memory. So this is what happens: \* The user calls some command having as argument a swapped key \* The command implementation calls the lookup function \* The lookup function search for the key in the top level hash table. If the value associated with the requested key is swapped (we can see that checking the \_storage\_ field of the key object), we load it back in memory in a blocking way before to return to the user. This is pretty straightforward, but things will get more \_interesting\_ with the threads. From the point of view of the blocking VM the only real problem is the saving of the dataset using another process, that is, handling `BGSAVE` and `BGREWRITEAOF` commands. Background saving when VM is active --- The default Redis way to persist on disk is to create .rdb files using a child process. Redis calls the fork() system call in order to create a child, that has the exact copy of the in memory dataset, since fork duplicates the whole program memory space (actually thanks to a technique called Copy on Write memory pages are shared between the parent and child process, so the fork() call will not require too much memory). In the child process we have a copy of the dataset in a given point in the time. Other commands issued by clients will just be served by the parent process and will not modify the child data. The child process will just store the whole dataset into the dump.rdb file and finally will exit. But what happens when the VM is active? Values can be swapped out so we don't have all the data in memory, and we need to access the swap file in order to retrieve the swapped values. While child process is saving the swap file is shared between the parent and child process, since: \* The parent process needs to access the swap file in order to load values back into memory if an operation against swapped out values are performed. \* The child process needs to access the swap file in order to retrieve the full dataset while saving the data set on disk. In order to avoid problems while both the processes are accessing the same swap file we do a simple thing, that is, not allowing values to be swapped out in the parent process while a background saving is in progress. This way both the processes will access the swap file in read only. This approach has the problem that while the child process is saving no new values can be transferred on the swap file even if Redis is using more memory than the max memory parameters dictates. This is usually not a problem as the background saving will terminate in a short amount of time and if still needed a percentage of values will be swapped on disk ASAP. An alternative to this scenario is to enable the Append Only File that will have this problem only when a log rewrite is performed using the `BGREWRITEAOF` command. The problem with the blocking VM --- The problem of blocking VM is that... it's blocking :) This is not a problem when Redis is used in batch processing activities, but for real-time usage one of the good points of Redis is the low latency. The blocking VM will have bad latency behaviors as when a client is accessing a swapped out value, or when Redis needs to swap out values, no other clients will be served in the meantime. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.0426691398024559,
-0.013047905638813972,
-0.0517345629632473,
0.019763080403208733,
-0.03637298196554184,
-0.025048615410923958,
0.023439422249794006,
0.019251404330134392,
0.025976689532399178,
0.06914304196834564,
-0.0009370172047056258,
0.07102136313915253,
0.008644158951938152,
-0.1... | 0.060739 |
but for real-time usage one of the good points of Redis is the low latency. The blocking VM will have bad latency behaviors as when a client is accessing a swapped out value, or when Redis needs to swap out values, no other clients will be served in the meantime. Swapping out keys should happen in background. Similarly when a client is accessing a swapped out value other clients accessing in memory values should be served mostly as fast as when VM is disabled. Only the clients dealing with swapped out keys should be delayed. All this limitations called for a non-blocking VM implementation. Threaded VM --- There are basically three main ways to turn the blocking VM into a non blocking one. \* 1: One way is obvious, and in my opinion, not a good idea at all, that is, turning Redis itself into a threaded server: if every request is served by a different thread automatically other clients don't need to wait for blocked ones. Redis is fast, exports atomic operations, has no locks, and is just 10k lines of code, \*because\* it is single threaded, so this was not an option for me. \* 2: Using non-blocking I/O against the swap file. After all you can think Redis already event-loop based, why don't just handle disk I/O in a non-blocking fashion? I also discarded this possibility because of two main reasons. One is that non blocking file operations, unlike sockets, are an incompatibility nightmare. It's not just like calling select, you need to use OS-specific things. The other problem is that the I/O is just one part of the time consumed to handle VM, another big part is the CPU used in order to encode/decode data to/from the swap file. This is I picked option three, that is... \* 3: Using I/O threads, that is, a pool of threads handling the swap I/O operations. This is what the Redis VM is using, so let's detail how this works. I/O Threads --- The threaded VM design goals where the following, in order of importance: \* Simple implementation, little room for race conditions, simple locking, VM system more or less completely decoupled from the rest of Redis code. \* Good performances, no locks for clients accessing values in memory. \* Ability to decode/encode objects in the I/O threads. The above goals resulted in an implementation where the Redis main thread (the one serving actual clients) and the I/O threads communicate using a queue of jobs, with a single mutex. Basically when main thread requires some work done in the background by some I/O thread, it pushes an I/O job structure in the `server.io\_newjobs` queue (that is, just a linked list). If there are no active I/O threads, one is started. At this point some I/O thread will process the I/O job, and the result of the processing is pushed in the `server.io\_processed` queue. The I/O thread will send a byte using an UNIX pipe to the main thread in order to signal that a new job was processed and the result is ready to be processed. This is how the `iojob` structure looks like: typedef struct iojob { int type; /\* Request type, REDIS\_IOJOB\_\* \*/ redisDb \*db;/\* Redis database \*/ robj \*key; /\* This I/O request is about swapping this key \*/ robj \*val; /\* the value to swap for REDIS\_IOREQ\_\*\_SWAP, otherwise this \* field is populated by the I/O thread for REDIS\_IOREQ\_LOAD. \*/ off\_t page; /\* Swap page where to read/write the object \*/ off\_t pages; /\* Swap pages needed to save object. PREPARE\_SWAP return val \*/ int | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.07768827676773071,
0.01806946098804474,
-0.050118762999773026,
0.007408175151795149,
-0.017009779810905457,
-0.028066759929060936,
0.0022787449415773153,
-0.0242221150547266,
0.031134676188230515,
0.028149841353297234,
0.025696296244859695,
0.035985227674245834,
-0.06470099836587906,
-0... | 0.144853 |
this key \*/ robj \*val; /\* the value to swap for REDIS\_IOREQ\_\*\_SWAP, otherwise this \* field is populated by the I/O thread for REDIS\_IOREQ\_LOAD. \*/ off\_t page; /\* Swap page where to read/write the object \*/ off\_t pages; /\* Swap pages needed to save object. PREPARE\_SWAP return val \*/ int canceled; /\* True if this command was canceled by blocking side of VM \*/ pthread\_t thread; /\* ID of the thread processing this entry \*/ } iojob; There are just three type of jobs that an I/O thread can perform (the type is specified by the `type` field of the structure): \* `REDIS\_IOJOB\_LOAD`: load the value associated to a given key from swap to memory. The object offset inside the swap file is `page`, the object type is `key->vtype`. The result of this operation will populate the `val` field of the structure. \* `REDIS\_IOJOB\_PREPARE\_SWAP`: compute the number of pages needed in order to save the object pointed by `val` into the swap. The result of this operation will populate the `pages` field. \* `REDIS\_IOJOB\_DO\_SWAP`: Transfer the object pointed by `val` to the swap file, at page offset `page`. The main thread delegates just the above three tasks. All the rest is handled by the I/O thread itself, for instance finding a suitable range of free pages in the swap file page table (that is a fast operation), deciding what object to swap, altering the storage field of a Redis object to reflect the current state of a value. Non blocking VM as probabilistic enhancement of blocking VM --- So now we have a way to request background jobs dealing with slow VM operations. How to add this to the mix of the rest of the work done by the main thread? While blocking VM was aware that an object was swapped out just when the object was looked up, this is too late for us: in C it is not trivial to start a background job in the middle of the command, leave the function, and re-enter in the same point the computation when the I/O thread finished what we requested (that is, no co-routines or continuations or alike). Fortunately there was a much, much simpler way to do this. And we love simple things: basically consider the VM implementation a blocking one, but add an optimization (using non the no blocking VM operations we are able to perform) to make the blocking \*very\* unlikely. This is what we do: \* Every time a client sends us a command, \*before\* the command is executed, we examine the argument vector of the command in search for swapped keys. After all we know for every command what arguments are keys, as the Redis command format is pretty simple. \* If we detect that at least a key in the requested command is swapped on disk, we block the client instead of really issuing the command. For every swapped value associated to a requested key, an I/O job is created, in order to bring the values back in memory. The main thread continues the execution of the event loop, without caring about the blocked client. \* In the meanwhile, I/O threads are loading values in memory. Every time an I/O thread finished loading a value, it sends a byte to the main thread using an UNIX pipe. The pipe file descriptor has a readable event associated in the main thread event loop, that is the function `vmThreadedIOCompletedJob`. If this function detects that all the values needed for a blocked client were loaded, the client is restarted and the original command called. So you | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.0948999673128128,
0.01134508941322565,
-0.06404252350330353,
0.015129880048334599,
-0.06066717579960823,
-0.05692111328244209,
0.03313390165567398,
0.0035066399723291397,
0.0250468160957098,
0.03714970871806145,
0.007622784469276667,
0.03898731619119644,
0.004779832437634468,
-0.1203180... | 0.232864 |
using an UNIX pipe. The pipe file descriptor has a readable event associated in the main thread event loop, that is the function `vmThreadedIOCompletedJob`. If this function detects that all the values needed for a blocked client were loaded, the client is restarted and the original command called. So you can think of this as a blocked VM that almost always happen to have the right keys in memory, since we pause clients that are going to issue commands about swapped out values until this values are loaded. If the function checking what argument is a key fails in some way, there is no problem: the lookup function will see that a given key is associated to a swapped out value and will block loading it. So our non blocking VM reverts to a blocking one when it is not possible to anticipate what keys are touched. For instance in the case of the `SORT` command used together with the `GET` or `BY` options, it is not trivial to know beforehand what keys will be requested, so at least in the first implementation, `SORT BY/GET` resorts to the blocking VM implementation. Blocking clients on swapped keys --- How to block clients? To suspend a client in an event-loop based server is pretty trivial. All we do is canceling its read handler. Sometimes we do something different (for instance for BLPOP) that is just marking the client as blocked, but not processing new data (just accumulating the new data into input buffers). Aborting I/O jobs --- There is something hard to solve about the interactions between our blocking and non blocking VM, that is, what happens if a blocking operation starts about a key that is also "interested" by a non blocking operation at the same time? For instance while SORT BY is executed, a few keys are being loaded in a blocking manner by the sort command. At the same time, another client may request the same keys with a simple \_GET key\_ command, that will trigger the creation of an I/O job to load the key in background. The only simple way to deal with this problem is to be able to kill I/O jobs in the main thread, so that if a key that we want to load or swap in a blocking way is in the `REDIS\_VM\_LOADING` or `REDIS\_VM\_SWAPPING` state (that is, there is an I/O job about this key), we can just kill the I/O job about this key, and go ahead with the blocking operation we want to perform. This is not as trivial as it is. In a given moment an I/O job can be in one of the following three queues: \* server.io\_newjobs: the job was already queued but no thread is handling it. \* server.io\_processing: the job is being processed by an I/O thread. \* server.io\_processed: the job was already processed. The function able to kill an I/O job is `vmCancelThreadedIOJob`, and this is what it does: \* If the job is in the newjobs queue, that's simple, removing the iojob structure from the queue is enough as no thread is still executing any operation. \* If the job is in the processing queue, a thread is messing with our job (and possibly with the associated object!). The only thing we can do is waiting for the item to move to the next queue in a \*blocking way\*. Fortunately this condition happens very rarely so it's not a performance problem. \* If the job is in the processed queue, we just mark it as \_canceled\_ marking setting the `canceled` field to 1 | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.06834836304187775,
0.050726357847452164,
0.015265511348843575,
-0.009827486239373684,
-0.021384764462709427,
-0.031237145885825157,
-0.005641529336571693,
-0.01559926476329565,
0.05449619144201279,
0.021681854501366615,
0.01141747459769249,
0.05387980490922928,
-0.060090430080890656,
-0... | 0.112957 |
do is waiting for the item to move to the next queue in a \*blocking way\*. Fortunately this condition happens very rarely so it's not a performance problem. \* If the job is in the processed queue, we just mark it as \_canceled\_ marking setting the `canceled` field to 1 in the iojob structure. The function processing completed jobs will just ignored and free the job instead of really processing it. Questions? --- This document is in no way complete, the only way to get the whole picture is reading the source code, but it should be a good introduction in order to make the code review / understanding a lot simpler. Something is not clear about this page? Please leave a comment and I'll try to address the issue possibly integrating the answer in this document. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-vm.md | master | redis | [
-0.1430118978023529,
0.06810171902179718,
0.030760299414396286,
0.03439471125602722,
-0.01495109312236309,
-0.08920656889677048,
0.0745878666639328,
-0.10027662664651871,
0.03160194307565689,
0.04977250471711159,
0.0034570973366498947,
0.06014533340930939,
-0.032499294728040695,
-0.0762068... | 0.143032 |
--- title: "Event library" linkTitle: "Event library" weight: 1 description: What's an event library, and how was the original Redis event library implemented? aliases: - /topics/internals-eventlib - /topics/internals-rediseventlib --- \*\*Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010), and does not necessarily reflect the latest Redis implementation.\*\* ## Why is an Event Library needed at all? Let us figure it out through a series of Q&As. Q: What do you expect a network server to be doing all the time? A: Watch for inbound connections on the port its listening and accept them. Q: Calling [accept](http://man.cx/accept%282%29) yields a descriptor. What do I do with it? A: Save the descriptor and do a non-blocking read/write operation on it. Q: Why does the read/write have to be non-blocking? A: If the file operation ( even a socket in Unix is a file ) is blocking how could the server for example accept other connection requests when its blocked in a file I/O operation. Q: I guess I have to do many such non-blocking operations on the socket to see when it's ready. Am I right? A: Yes. That is what an event library does for you. Now you get it. Q: How do Event Libraries do what they do? A: They use the operating system's polling facility along with timers. Q: So are there any open source event libraries that do what you just described? A: Yes. `libevent` and `libev` are two such event libraries that I can recall off the top of my head. Q: Does Redis use such open source event libraries for handling socket I/O? A: No. For various [reasons](http://groups.google.com/group/redis-db/browse\_thread/thread/b52814e9ef15b8d0/) Redis uses its own event library. ## The Redis event library Redis implements its own event library. The event library is implemented in `ae.c`. The best way to understand how the Redis event library works is to understand how Redis uses it. Event Loop Initialization --- `initServer` function defined in `redis.c` initializes the numerous fields of the `redisServer` structure variable. One such field is the Redis event loop `el`: aeEventLoop \*el `initServer` initializes `server.el` field by calling `aeCreateEventLoop` defined in `ae.c`. The definition of `aeEventLoop` is below: typedef struct aeEventLoop { int maxfd; long long timeEventNextId; aeFileEvent events[AE\_SETSIZE]; /\* Registered events \*/ aeFiredEvent fired[AE\_SETSIZE]; /\* Fired events \*/ aeTimeEvent \*timeEventHead; int stop; void \*apidata; /\* This is used for polling API specific data \*/ aeBeforeSleepProc \*beforesleep; } aeEventLoop; `aeCreateEventLoop` --- `aeCreateEventLoop` first `malloc`s `aeEventLoop` structure then calls `ae\_epoll.c:aeApiCreate`. `aeApiCreate` `malloc`s `aeApiState` that has two fields - `epfd` that holds the `epoll` file descriptor returned by a call from [`epoll\_create`](http://man.cx/epoll\_create%282%29) and `events` that is of type `struct epoll\_event` define by the Linux `epoll` library. The use of the `events` field will be described later. Next is `ae.c:aeCreateTimeEvent`. But before that `initServer` call `anet.c:anetTcpServer` that creates and returns a \_listening descriptor\_. The descriptor listens on \*port 6379\* by default. The returned \_listening descriptor\_ is stored in `server.fd` field. `aeCreateTimeEvent` --- `aeCreateTimeEvent` accepts the following as parameters: \* `eventLoop`: This is `server.el` in `redis.c` \* milliseconds: The number of milliseconds from the current time after which the timer expires. \* `proc`: Function pointer. Stores the address of the function that has to be called after the timer expires. \* `clientData`: Mostly `NULL`. \* `finalizerProc`: Pointer to the function that has to be called before the timed event is removed from the list of timed events. `initServer` calls `aeCreateTimeEvent` to add a timed event to `timeEventHead` field of `server.el`. `timeEventHead` is a pointer to a list of such timed events. The call | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-rediseventlib.md | master | redis | [
-0.07946261018514633,
-0.026863224804401398,
-0.032044682651758194,
-0.0008247701334767044,
0.018004760146141052,
-0.044109150767326355,
0.07108035683631897,
0.00048639479791745543,
0.08819431811571121,
0.0028994237072765827,
-0.0309982281178236,
0.03757124021649361,
-0.06126116216182709,
... | 0.214931 |
`NULL`. \* `finalizerProc`: Pointer to the function that has to be called before the timed event is removed from the list of timed events. `initServer` calls `aeCreateTimeEvent` to add a timed event to `timeEventHead` field of `server.el`. `timeEventHead` is a pointer to a list of such timed events. The call to `aeCreateTimeEvent` from `redis.c:initServer` function is given below: aeCreateTimeEvent(server.el /\*eventLoop\*/, 1 /\*milliseconds\*/, serverCron /\*proc\*/, NULL /\*clientData\*/, NULL /\*finalizerProc\*/); `redis.c:serverCron` performs many operations that helps keep Redis running properly. `aeCreateFileEvent` --- The essence of `aeCreateFileEvent` function is to execute [`epoll\_ctl`](http://man.cx/epoll\_ctl) system call which adds a watch for `EPOLLIN` event on the \_listening descriptor\_ create by `anetTcpServer` and associate it with the `epoll` descriptor created by a call to `aeCreateEventLoop`. Following is an explanation of what precisely `aeCreateFileEvent` does when called from `redis.c:initServer`. `initServer` passes the following arguments to `aeCreateFileEvent`: \* `server.el`: The event loop created by `aeCreateEventLoop`. The `epoll` descriptor is got from `server.el`. \* `server.fd`: The \_listening descriptor\_ that also serves as an index to access the relevant file event structure from the `eventLoop->events` table and store extra information like the callback function. \* `AE\_READABLE`: Signifies that `server.fd` has to be watched for `EPOLLIN` event. \* `acceptHandler`: The function that has to be executed when the event being watched for is ready. This function pointer is stored in `eventLoop->events[server.fd]->rfileProc`. This completes the initialization of Redis event loop. Event Loop Processing --- `ae.c:aeMain` called from `redis.c:main` does the job of processing the event loop that is initialized in the previous phase. `ae.c:aeMain` calls `ae.c:aeProcessEvents` in a while loop that processes pending time and file events. `aeProcessEvents` --- `ae.c:aeProcessEvents` looks for the time event that will be pending in the smallest amount of time by calling `ae.c:aeSearchNearestTimer` on the event loop. In our case there is only one timer event in the event loop that was created by `ae.c:aeCreateTimeEvent`. Remember, that the timer event created by `aeCreateTimeEvent` has probably elapsed by now because it had an expiry time of one millisecond. Since the timer has already expired, the seconds and microseconds fields of the `tvp` `timeval` structure variable is initialized to zero. The `tvp` structure variable along with the event loop variable is passed to `ae\_epoll.c:aeApiPoll`. `aeApiPoll` functions does an [`epoll\_wait`](http://man.cx/epoll\_wait) on the `epoll` descriptor and populates the `eventLoop->fired` table with the details: \* `fd`: The descriptor that is now ready to do a read/write operation depending on the mask value. \* `mask`: The read/write event that can now be performed on the corresponding descriptor. `aeApiPoll` returns the number of such file events ready for operation. Now to put things in context, if any client has requested for a connection then `aeApiPoll` would have noticed it and populated the `eventLoop->fired` table with an entry of the descriptor being the \_listening descriptor\_ and mask being `AE\_READABLE`. Now, `aeProcessEvents` calls the `redis.c:acceptHandler` registered as the callback. `acceptHandler` executes [accept](http://man.cx/accept) on the \_listening descriptor\_ returning a \_connected descriptor\_ with the client. `redis.c:createClient` adds a file event on the \_connected descriptor\_ through a call to `ae.c:aeCreateFileEvent` like below: if (aeCreateFileEvent(server.el, c->fd, AE\_READABLE, readQueryFromClient, c) == AE\_ERR) { freeClient(c); return NULL; } `c` is the `redisClient` structure variable and `c->fd` is the connected descriptor. Next the `ae.c:aeProcessEvent` calls `ae.c:processTimeEvents` `processTimeEvents` --- `ae.processTimeEvents` iterates over list of time events starting at `eventLoop->timeEventHead`. For every timed event that has elapsed `processTimeEvents` calls the registered callback. In this case it calls the only timed event callback registered, that is, `redis.c:serverCron`. The callback returns the time in milliseconds after which the callback must be called again. This change is recorded via a call to `ae.c:aeAddMilliSeconds` and will be handled on the | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-rediseventlib.md | master | redis | [
-0.0663515105843544,
0.04509318992495537,
-0.07067763805389404,
0.00034175949986092746,
0.027639256790280342,
-0.050140973180532455,
0.08215092122554779,
0.05605114623904228,
0.08319894969463348,
0.004672701004892588,
0.02724483422935009,
-0.048948634415864944,
-0.04443027824163437,
-0.049... | 0.136455 |
elapsed `processTimeEvents` calls the registered callback. In this case it calls the only timed event callback registered, that is, `redis.c:serverCron`. The callback returns the time in milliseconds after which the callback must be called again. This change is recorded via a call to `ae.c:aeAddMilliSeconds` and will be handled on the next iteration of `ae.c:aeMain` while loop. That's all. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/internals-rediseventlib.md | master | redis | [
-0.05744238197803497,
-0.01393358688801527,
-0.0810294970870018,
0.03033297136425972,
0.00853127520531416,
-0.07073201984167099,
0.07100023329257965,
0.033918801695108414,
0.11834223568439484,
-0.06877005100250244,
0.0103924460709095,
-0.0009639541385695338,
-0.07896068692207336,
-0.064534... | 0.091169 |
\*\*Note: this document was written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2013), as part of a series of design drafts. This is preserved for historical interest.\*\* # Redis Design Draft 2 -- RDB version 7 info fields \* Author: Salvatore Sanfilippo `antirez@gmail.com` \* GitHub issue [#1048](https://github.com/redis/redis/issues/1048) ## History of revisions 1.0, 10 April 2013 - Initial draft. ## Overview The Redis RDB format lacks a simple way to add info fields to an RDB file without causing a backward compatibility issue even if the added meta data is not required in order to load data from the RDB file. For example thanks to the info fields specified in this document it will be possible to add to RDB information like file creation time, Redis version generating the file, and any other useful information, in a way that not every field is required for an RDB version 7 file to be correctly processed. Also with minimal changes it will be possible to add RDB version 7 support to Redis 2.6 without actually supporting the additional fields but just skipping them when loading an RDB file. RDB info fields may have semantic meaning if needed, so that the presence of the field may add information about the data set specified in the RDB file format, however when an info field is required to be correctly decoded in order to understand and load the data set content of the RDB file, the RDB file format must be increased so that previous versions of Redis will not attempt to load it. However currently the info fields are designed to only hold additional information that are not useful to load the dataset, but can better specify how the RDB file was created. ## Info fields representation The RDB format 6 has the following layout: \* A 9 bytes magic "REDIS0006" \* key-value pairs \* An EOF opcode \* CRC64 checksum The proposal for RDB format 7 is to add the optional fields immediately after the first 9 bytes magic, so that the new format will be: \* A 9 bytes magic "REDIS0007" \* Info field 1 \* Info field 2 \* ... \* Info field N \* Info field end-of-fields \* key-value pairs \* An EOF opcode \* CRC64 checksum Every single info field has the following structure: \* A 16 bit identifier \* A 64 bit data length \* A data section of the exact length as specified Both the identifier and the data length are stored in little endian byte ordering. The special identifier 0 means that there are no other info fields, and that the remaining of the RDB file contains the key-value pairs. ## Handling of info fields A program can simply skip every info field it does not understand, as long as the RDB version matches the one that it is capable to load. ## Specification of info fields IDs and content. ### Info field 0 -- End of info fields This just means there are no longer info fields to process. ### Info field 1 -- Creation date This field represents the unix time at which the RDB file was created. The format of the unix time is a 64 bit little endian integer representing seconds since 1th January 1970. ### Info field 2 -- Redis version This field represents a null-terminated string containing the Redis version that generated the file, as displayed in the Redis version INFO field. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/rdd.md | master | redis | [
-0.06286967545747757,
0.02536400593817234,
-0.059835996478796005,
0.015086316503584385,
-0.007469965610653162,
-0.001336983172222972,
-0.0418534092605114,
0.028319332748651505,
-0.022641632705926895,
0.03146017715334892,
-0.051149193197488785,
0.02723921649158001,
0.047704823315143585,
-0.... | 0.078497 |
Info field 2 -- Redis version This field represents a null-terminated string containing the Redis version that generated the file, as displayed in the Redis version INFO field. | https://github.com/redis/redis-doc/blob/master//docs/reference/internals/rdd.md | master | redis | [
0.012343809008598328,
0.043793898075819016,
-0.058785758912563324,
-0.011266023851931095,
0.07140875607728958,
-0.05197611451148987,
0.007238847203552723,
-0.006547168362885714,
0.03948230296373367,
-0.03709215670824051,
0.04417946934700012,
0.004625075496733189,
-0.0005059869727119803,
-0... | 0.09336 |
## Sections \* [Heap allocation raw functions](#section-heap-allocation-raw-functions) \* [Commands API](#section-commands-api) \* [Module information and time measurement](#section-module-information-and-time-measurement) \* [Automatic memory management for modules](#section-automatic-memory-management-for-modules) \* [String objects APIs](#section-string-objects-apis) \* [Reply APIs](#section-reply-apis) \* [Commands replication API](#section-commands-replication-api) \* [DB and Key APIs – Generic API](#section-db-and-key-apis-generic-api) \* [Key API for String type](#section-key-api-for-string-type) \* [Key API for List type](#section-key-api-for-list-type) \* [Key API for Sorted Set type](#section-key-api-for-sorted-set-type) \* [Key API for Sorted Set iterator](#section-key-api-for-sorted-set-iterator) \* [Key API for Hash type](#section-key-api-for-hash-type) \* [Key API for Stream type](#section-key-api-for-stream-type) \* [Calling Redis commands from modules](#section-calling-redis-commands-from-modules) \* [Modules data types](#section-modules-data-types) \* [RDB loading and saving functions](#section-rdb-loading-and-saving-functions) \* [Key digest API (DEBUG DIGEST interface for modules types)](#section-key-digest-api-debug-digest-interface-for-modules-types) \* [AOF API for modules data types](#section-aof-api-for-modules-data-types) \* [IO context handling](#section-io-context-handling) \* [Logging](#section-logging) \* [Blocking clients from modules](#section-blocking-clients-from-modules) \* [Thread Safe Contexts](#section-thread-safe-contexts) \* [Module Keyspace Notifications API](#section-module-keyspace-notifications-api) \* [Modules Cluster API](#section-modules-cluster-api) \* [Modules Timers API](#section-modules-timers-api) \* [Modules EventLoop API](#section-modules-eventloop-api) \* [Modules ACL API](#section-modules-acl-api) \* [Modules Dictionary API](#section-modules-dictionary-api) \* [Modules Info fields](#section-modules-info-fields) \* [Modules utility APIs](#section-modules-utility-apis) \* [Modules API exporting / importing](#section-modules-api-exporting-importing) \* [Module Command Filter API](#section-module-command-filter-api) \* [Scanning keyspace and hashes](#section-scanning-keyspace-and-hashes) \* [Module fork API](#section-module-fork-api) \* [Server hooks implementation](#section-server-hooks-implementation) \* [Module Configurations API](#section-module-configurations-api) \* [RDB load/save API](#section-rdb-load-save-api) \* [Key eviction API](#section-key-eviction-api) \* [Miscellaneous APIs](#section-miscellaneous-apis) \* [Defrag API](#section-defrag-api) \* [Function index](#section-function-index) ## Heap allocation raw functions Memory allocated with these functions are taken into account by Redis key eviction algorithms and are reported in Redis memory usage information. ### `RedisModule\_Alloc` void \*RedisModule\_Alloc(size\_t bytes); \*\*Available since:\*\* 4.0.0 Use like `malloc()`. Memory allocated with this function is reported in Redis INFO memory, used for keys eviction according to maxmemory settings and in general is taken into account as memory allocated by Redis. You should avoid using `malloc()`. This function panics if unable to allocate enough memory. ### `RedisModule\_TryAlloc` void \*RedisModule\_TryAlloc(size\_t bytes); \*\*Available since:\*\* 7.0.0 Similar to [`RedisModule\_Alloc`](#RedisModule\_Alloc), but returns NULL in case of allocation failure, instead of panicking. ### `RedisModule\_Calloc` void \*RedisModule\_Calloc(size\_t nmemb, size\_t size); \*\*Available since:\*\* 4.0.0 Use like `calloc()`. Memory allocated with this function is reported in Redis INFO memory, used for keys eviction according to maxmemory settings and in general is taken into account as memory allocated by Redis. You should avoid using `calloc()` directly. ### `RedisModule\_Realloc` void\* RedisModule\_Realloc(void \*ptr, size\_t bytes); \*\*Available since:\*\* 4.0.0 Use like `realloc()` for memory obtained with [`RedisModule\_Alloc()`](#RedisModule\_Alloc). ### `RedisModule\_Free` void RedisModule\_Free(void \*ptr); \*\*Available since:\*\* 4.0.0 Use like `free()` for memory obtained by [`RedisModule\_Alloc()`](#RedisModule\_Alloc) and [`RedisModule\_Realloc()`](#RedisModule\_Realloc). However you should never try to free with [`RedisModule\_Free()`](#RedisModule\_Free) memory allocated with `malloc()` inside your module. ### `RedisModule\_Strdup` char \*RedisModule\_Strdup(const char \*str); \*\*Available since:\*\* 4.0.0 Like `strdup()` but returns memory allocated with [`RedisModule\_Alloc()`](#RedisModule\_Alloc). ### `RedisModule\_PoolAlloc` void \*RedisModule\_PoolAlloc(RedisModuleCtx \*ctx, size\_t bytes); \*\*Available since:\*\* 4.0.0 Return heap allocated memory that will be freed automatically when the module callback function returns. Mostly suitable for small allocations that are short living and must be released when the callback returns anyway. The returned memory is aligned to the architecture word size if at least word size bytes are requested, otherwise it is just aligned to the next power of two, so for example a 3 bytes request is 4 bytes aligned while a 2 bytes request is 2 bytes aligned. There is no realloc style function since when this is needed to use the pool allocator is not a good idea. The function returns NULL if `bytes` is 0. ## Commands API These functions are used to implement custom Redis commands. For examples, see [https://redis.io/topics/modules-intro](https://redis.io/topics/modules-intro). ### `RedisModule\_IsKeysPositionRequest` int RedisModule\_IsKeysPositionRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command, that was declared with the flag "getkeys-api", is called in a special way to get the keys positions and not | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.037506211549043655,
0.01607716828584671,
-0.0668279230594635,
0.019030723720788956,
-0.010392504744231701,
-0.05912342295050621,
0.01966010592877865,
0.014859856106340885,
-0.04782146215438843,
0.059128399938344955,
0.00808653049170971,
-0.02605033479630947,
0.08772391825914383,
-0.0149... | 0.102858 |
## Commands API These functions are used to implement custom Redis commands. For examples, see [https://redis.io/topics/modules-intro](https://redis.io/topics/modules-intro). ### `RedisModule\_IsKeysPositionRequest` int RedisModule\_IsKeysPositionRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command, that was declared with the flag "getkeys-api", is called in a special way to get the keys positions and not to get executed. Otherwise zero is returned. ### `RedisModule\_KeyAtPosWithFlags` void RedisModule\_KeyAtPosWithFlags(RedisModuleCtx \*ctx, int pos, int flags); \*\*Available since:\*\* 7.0.0 When a module command is called in order to obtain the position of keys, since it was flagged as "getkeys-api" during the registration, the command implementation checks for this special call using the [`RedisModule\_IsKeysPositionRequest()`](#RedisModule\_IsKeysPositionRequest) API and uses this function in order to report keys. The supported flags are the ones used by [`RedisModule\_SetCommandInfo`](#RedisModule\_SetCommandInfo), see `REDISMODULE\_CMD\_KEY\_`\*. The following is an example of how it could be used: if (RedisModule\_IsKeysPositionRequest(ctx)) { RedisModule\_KeyAtPosWithFlags(ctx, 2, REDISMODULE\_CMD\_KEY\_RO | REDISMODULE\_CMD\_KEY\_ACCESS); RedisModule\_KeyAtPosWithFlags(ctx, 1, REDISMODULE\_CMD\_KEY\_RW | REDISMODULE\_CMD\_KEY\_UPDATE | REDISMODULE\_CMD\_KEY\_ACCESS); } Note: in the example above the get keys API could have been handled by key-specs (preferred). Implementing the getkeys-api is required only when is it not possible to declare key-specs that cover all keys. ### `RedisModule\_KeyAtPos` void RedisModule\_KeyAtPos(RedisModuleCtx \*ctx, int pos); \*\*Available since:\*\* 4.0.0 This API existed before [`RedisModule\_KeyAtPosWithFlags`](#RedisModule\_KeyAtPosWithFlags) was added, now deprecated and can be used for compatibility with older versions, before key-specs and flags were introduced. ### `RedisModule\_IsChannelsPositionRequest` int RedisModule\_IsChannelsPositionRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 7.0.0 Return non-zero if a module command, that was declared with the flag "getchannels-api", is called in a special way to get the channel positions and not to get executed. Otherwise zero is returned. ### `RedisModule\_ChannelAtPosWithFlags` void RedisModule\_ChannelAtPosWithFlags(RedisModuleCtx \*ctx, int pos, int flags); \*\*Available since:\*\* 7.0.0 When a module command is called in order to obtain the position of channels, since it was flagged as "getchannels-api" during the registration, the command implementation checks for this special call using the [`RedisModule\_IsChannelsPositionRequest()`](#RedisModule\_IsChannelsPositionRequest) API and uses this function in order to report the channels. The supported flags are: \* `REDISMODULE\_CMD\_CHANNEL\_SUBSCRIBE`: This command will subscribe to the channel. \* `REDISMODULE\_CMD\_CHANNEL\_UNSUBSCRIBE`: This command will unsubscribe from this channel. \* `REDISMODULE\_CMD\_CHANNEL\_PUBLISH`: This command will publish to this channel. \* `REDISMODULE\_CMD\_CHANNEL\_PATTERN`: Instead of acting on a specific channel, will act on any channel specified by the pattern. This is the same access used by the PSUBSCRIBE and PUNSUBSCRIBE commands available in Redis. Not intended to be used with PUBLISH permissions. The following is an example of how it could be used: if (RedisModule\_IsChannelsPositionRequest(ctx)) { RedisModule\_ChannelAtPosWithFlags(ctx, 1, REDISMODULE\_CMD\_CHANNEL\_SUBSCRIBE | REDISMODULE\_CMD\_CHANNEL\_PATTERN); RedisModule\_ChannelAtPosWithFlags(ctx, 1, REDISMODULE\_CMD\_CHANNEL\_PUBLISH); } Note: One usage of declaring channels is for evaluating ACL permissions. In this context, unsubscribing is always allowed, so commands will only be checked against subscribe and publish permissions. This is preferred over using [`RedisModule\_ACLCheckChannelPermissions`](#RedisModule\_ACLCheckChannelPermissions), since it allows the ACLs to be checked before the command is executed. ### `RedisModule\_CreateCommand` int RedisModule\_CreateCommand(RedisModuleCtx \*ctx, const char \*name, RedisModuleCmdFunc cmdfunc, const char \*strflags, int firstkey, int lastkey, int keystep); \*\*Available since:\*\* 4.0.0 Register a new command in the Redis server, that will be handled by calling the function pointer 'cmdfunc' using the RedisModule calling convention. The function returns `REDISMODULE\_ERR` in these cases: - If creation of module command is called outside the `RedisModule\_OnLoad`. - The specified command is already busy. - The command name contains some chars that are not allowed. - A set of invalid flags were passed. Otherwise `REDISMODULE\_OK` is returned and the new command is registered. This function must be called during the initialization of the module inside the `RedisModule\_OnLoad()` function. Calling this function outside of the initialization function is not defined. The command function type is the following: int MyCommand\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc); And | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.02470935881137848,
-0.009478028863668442,
-0.09412279725074768,
0.0014329425757750869,
-0.04842584952712059,
-0.0676325112581253,
0.08061137795448303,
0.03527620807290077,
0.020252492278814316,
-0.006907612085342407,
0.04916864633560181,
-0.01557567622512579,
0.07292863726615906,
-0.065... | 0.137893 |
`REDISMODULE\_OK` is returned and the new command is registered. This function must be called during the initialization of the module inside the `RedisModule\_OnLoad()` function. Calling this function outside of the initialization function is not defined. The command function type is the following: int MyCommand\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc); And is supposed to always return `REDISMODULE\_OK`. The set of flags 'strflags' specify the behavior of the command, and should be passed as a C string composed of space separated words, like for example "write deny-oom". The set of flags are: \* \*\*"write"\*\*: The command may modify the data set (it may also read from it). \* \*\*"readonly"\*\*: The command returns data from keys but never writes. \* \*\*"admin"\*\*: The command is an administrative command (may change replication or perform similar tasks). \* \*\*"deny-oom"\*\*: The command may use additional memory and should be denied during out of memory conditions. \* \*\*"deny-script"\*\*: Don't allow this command in Lua scripts. \* \*\*"allow-loading"\*\*: Allow this command while the server is loading data. Only commands not interacting with the data set should be allowed to run in this mode. If not sure don't use this flag. \* \*\*"pubsub"\*\*: The command publishes things on Pub/Sub channels. \* \*\*"random"\*\*: The command may have different outputs even starting from the same input arguments and key values. Starting from Redis 7.0 this flag has been deprecated. Declaring a command as "random" can be done using command tips, see https://redis.io/topics/command-tips. \* \*\*"allow-stale"\*\*: The command is allowed to run on slaves that don't serve stale data. Don't use if you don't know what this means. \* \*\*"no-monitor"\*\*: Don't propagate the command on monitor. Use this if the command has sensitive data among the arguments. \* \*\*"no-slowlog"\*\*: Don't log this command in the slowlog. Use this if the command has sensitive data among the arguments. \* \*\*"fast"\*\*: The command time complexity is not greater than O(log(N)) where N is the size of the collection or anything else representing the normal scalability issue with the command. \* \*\*"getkeys-api"\*\*: The command implements the interface to return the arguments that are keys. Used when start/stop/step is not enough because of the command syntax. \* \*\*"no-cluster"\*\*: The command should not register in Redis Cluster since is not designed to work with it because, for example, is unable to report the position of the keys, programmatically creates key names, or any other reason. \* \*\*"no-auth"\*\*: This command can be run by an un-authenticated client. Normally this is used by a command that is used to authenticate a client. \* \*\*"may-replicate"\*\*: This command may generate replication traffic, even though it's not a write command. \* \*\*"no-mandatory-keys"\*\*: All the keys this command may take are optional \* \*\*"blocking"\*\*: The command has the potential to block the client. \* \*\*"allow-busy"\*\*: Permit the command while the server is blocked either by a script or by a slow module command, see RedisModule\_Yield. \* \*\*"getchannels-api"\*\*: The command implements the interface to return the arguments that are channels. The last three parameters specify which arguments of the new command are Redis keys. See [https://redis.io/commands/command](https://redis.io/commands/command) for more information. \* `firstkey`: One-based index of the first argument that's a key. Position 0 is always the command name itself. 0 for commands with no keys. \* `lastkey`: One-based index of the last argument that's a key. Negative numbers refer to counting backwards from the last argument (-1 means the last argument provided) 0 for commands with no keys. \* `keystep`: Step between first and last key indexes. 0 for commands with no keys. This information is used by ACL, Cluster and the `COMMAND` command. NOTE: The scheme | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.0026461740490049124,
-0.02353201061487198,
-0.16057220101356506,
0.07082165032625198,
-0.0860043540596962,
-0.07541802525520325,
0.1002938374876976,
0.047168176621198654,
-0.06619437783956528,
-0.039144162088632584,
0.04566536471247673,
-0.05351802334189415,
0.019329547882080078,
-0.0413... | 0.141522 |
numbers refer to counting backwards from the last argument (-1 means the last argument provided) 0 for commands with no keys. \* `keystep`: Step between first and last key indexes. 0 for commands with no keys. This information is used by ACL, Cluster and the `COMMAND` command. NOTE: The scheme described above serves a limited purpose and can only be used to find keys that exist at constant indices. For non-trivial key arguments, you may pass 0,0,0 and use [`RedisModule\_SetCommandInfo`](#RedisModule\_SetCommandInfo) to set key specs using a more advanced scheme and use [`RedisModule\_SetCommandACLCategories`](#RedisModule\_SetCommandACLCategories) to set Redis ACL categories of the commands. ### `RedisModule\_GetCommand` RedisModuleCommand \*RedisModule\_GetCommand(RedisModuleCtx \*ctx, const char \*name); \*\*Available since:\*\* 7.0.0 Get an opaque structure, representing a module command, by command name. This structure is used in some of the command-related APIs. NULL is returned in case of the following errors: \* Command not found \* The command is not a module command \* The command doesn't belong to the calling module ### `RedisModule\_CreateSubcommand` int RedisModule\_CreateSubcommand(RedisModuleCommand \*parent, const char \*name, RedisModuleCmdFunc cmdfunc, const char \*strflags, int firstkey, int lastkey, int keystep); \*\*Available since:\*\* 7.0.0 Very similar to [`RedisModule\_CreateCommand`](#RedisModule\_CreateCommand) except that it is used to create a subcommand, associated with another, container, command. Example: If a module has a configuration command, MODULE.CONFIG, then GET and SET should be individual subcommands, while MODULE.CONFIG is a command, but should not be registered with a valid `funcptr`: if (RedisModule\_CreateCommand(ctx,"module.config",NULL,"",0,0,0) == REDISMODULE\_ERR) return REDISMODULE\_ERR; RedisModuleCommand \*parent = RedisModule\_GetCommand(ctx,,"module.config"); if (RedisModule\_CreateSubcommand(parent,"set",cmd\_config\_set,"",0,0,0) == REDISMODULE\_ERR) return REDISMODULE\_ERR; if (RedisModule\_CreateSubcommand(parent,"get",cmd\_config\_get,"",0,0,0) == REDISMODULE\_ERR) return REDISMODULE\_ERR; Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` in case of the following errors: \* Error while parsing `strflags` \* Command is marked as `no-cluster` but cluster mode is enabled \* `parent` is already a subcommand (we do not allow more than one level of command nesting) \* `parent` is a command with an implementation (`RedisModuleCmdFunc`) (A parent command should be a pure container of subcommands) \* `parent` already has a subcommand called `name` \* Creating a subcommand is called outside of `RedisModule\_OnLoad`. ### `RedisModule\_SetCommandACLCategories` int RedisModule\_SetCommandACLCategories(RedisModuleCommand \*command, const char \*aclflags); \*\*Available since:\*\* 7.2.0 [`RedisModule\_SetCommandACLCategories`](#RedisModule\_SetCommandACLCategories) can be used to set ACL categories to module commands and subcommands. The set of ACL categories should be passed as a space separated C string 'aclflags'. Example, the acl flags 'write slow' marks the command as part of the write and slow ACL categories. On success `REDISMODULE\_OK` is returned. On error `REDISMODULE\_ERR` is returned. This function can only be called during the `RedisModule\_OnLoad` function. If called outside of this function, an error is returned. ### `RedisModule\_SetCommandInfo` int RedisModule\_SetCommandInfo(RedisModuleCommand \*command, const RedisModuleCommandInfo \*info); \*\*Available since:\*\* 7.0.0 Set additional command information. Affects the output of `COMMAND`, `COMMAND INFO` and `COMMAND DOCS`, Cluster, ACL and is used to filter commands with the wrong number of arguments before the call reaches the module code. This function can be called after creating a command using [`RedisModule\_CreateCommand`](#RedisModule\_CreateCommand) and fetching the command pointer using [`RedisModule\_GetCommand`](#RedisModule\_GetCommand). The information can only be set once for each command and has the following structure: typedef struct RedisModuleCommandInfo { const RedisModuleCommandInfoVersion \*version; const char \*summary; const char \*complexity; const char \*since; RedisModuleCommandHistoryEntry \*history; const char \*tips; int arity; RedisModuleCommandKeySpec \*key\_specs; RedisModuleCommandArg \*args; } RedisModuleCommandInfo; All fields except `version` are optional. Explanation of the fields: - `version`: This field enables compatibility with different Redis versions. Always set this field to `REDISMODULE\_COMMAND\_INFO\_VERSION`. - `summary`: A short description of the command (optional). - `complexity`: Complexity description (optional). - `since`: The version where the command was introduced (optional). Note: The version specified should be the module's, not Redis version. - `history`: An array of `RedisModuleCommandHistoryEntry` (optional), which | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.013391117565333843,
-0.0005049251485615969,
-0.10125773400068283,
0.04313870891928673,
-0.0918155312538147,
0.02571188099682331,
0.0882757231593132,
0.013733922503888607,
-0.03455185890197754,
-0.0477023608982563,
0.022102251648902893,
-0.09991106390953064,
0.059374600648880005,
-0.0701... | 0.098959 |
versions. Always set this field to `REDISMODULE\_COMMAND\_INFO\_VERSION`. - `summary`: A short description of the command (optional). - `complexity`: Complexity description (optional). - `since`: The version where the command was introduced (optional). Note: The version specified should be the module's, not Redis version. - `history`: An array of `RedisModuleCommandHistoryEntry` (optional), which is a struct with the following fields: const char \*since; const char \*changes; `since` is a version string and `changes` is a string describing the changes. The array is terminated by a zeroed entry, i.e. an entry with both strings set to NULL. - `tips`: A string of space-separated tips regarding this command, meant for clients and proxies. See [https://redis.io/topics/command-tips](https://redis.io/topics/command-tips). - `arity`: Number of arguments, including the command name itself. A positive number specifies an exact number of arguments and a negative number specifies a minimum number of arguments, so use -N to say >= N. Redis validates a call before passing it to a module, so this can replace an arity check inside the module command implementation. A value of 0 (or an omitted arity field) is equivalent to -2 if the command has sub commands and -1 otherwise. - `key\_specs`: An array of `RedisModuleCommandKeySpec`, terminated by an element memset to zero. This is a scheme that tries to describe the positions of key arguments better than the old [`RedisModule\_CreateCommand`](#RedisModule\_CreateCommand) arguments `firstkey`, `lastkey`, `keystep` and is needed if those three are not enough to describe the key positions. There are two steps to retrieve key positions: \*begin search\* (BS) in which index should find the first key and \*find keys\* (FK) which, relative to the output of BS, describes how can we will which arguments are keys. Additionally, there are key specific flags. Key-specs cause the triplet (firstkey, lastkey, keystep) given in RedisModule\_CreateCommand to be recomputed, but it is still useful to provide these three parameters in RedisModule\_CreateCommand, to better support old Redis versions where RedisModule\_SetCommandInfo is not available. Note that key-specs don't fully replace the "getkeys-api" (see RedisModule\_CreateCommand, RedisModule\_IsKeysPositionRequest and RedisModule\_KeyAtPosWithFlags) so it may be a good idea to supply both key-specs and implement the getkeys-api. A key-spec has the following structure: typedef struct RedisModuleCommandKeySpec { const char \*notes; uint64\_t flags; RedisModuleKeySpecBeginSearchType begin\_search\_type; union { struct { int pos; } index; struct { const char \*keyword; int startfrom; } keyword; } bs; RedisModuleKeySpecFindKeysType find\_keys\_type; union { struct { int lastkey; int keystep; int limit; } range; struct { int keynumidx; int firstkey; int keystep; } keynum; } fk; } RedisModuleCommandKeySpec; Explanation of the fields of RedisModuleCommandKeySpec: \* `notes`: Optional notes or clarifications about this key spec. \* `flags`: A bitwise or of key-spec flags described below. \* `begin\_search\_type`: This describes how the first key is discovered. There are two ways to determine the first key: \* `REDISMODULE\_KSPEC\_BS\_UNKNOWN`: There is no way to tell where the key args start. \* `REDISMODULE\_KSPEC\_BS\_INDEX`: Key args start at a constant index. \* `REDISMODULE\_KSPEC\_BS\_KEYWORD`: Key args start just after a specific keyword. \* `bs`: This is a union in which the `index` or `keyword` branch is used depending on the value of the `begin\_search\_type` field. \* `bs.index.pos`: The index from which we start the search for keys. (`REDISMODULE\_KSPEC\_BS\_INDEX` only.) \* `bs.keyword.keyword`: The keyword (string) that indicates the beginning of key arguments. (`REDISMODULE\_KSPEC\_BS\_KEYWORD` only.) \* `bs.keyword.startfrom`: An index in argv from which to start searching. Can be negative, which means start search from the end, in reverse. Example: -2 means to start in reverse from the penultimate argument. (`REDISMODULE\_KSPEC\_BS\_KEYWORD` only.) \* `find\_keys\_type`: After the "begin search", this describes which arguments are keys. The strategies are: \* `REDISMODULE\_KSPEC\_BS\_UNKNOWN`: There is no way to tell where | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0008072893251664937,
0.02400384470820427,
-0.08930256217718124,
0.010174552910029888,
-0.010892820544540882,
-0.05978775396943092,
0.01706196740269661,
0.0009046784252859652,
-0.001624214113689959,
-0.02927219867706299,
-0.013735047541558743,
0.03196415677666664,
0.0005563125014305115,
... | 0.160937 |
searching. Can be negative, which means start search from the end, in reverse. Example: -2 means to start in reverse from the penultimate argument. (`REDISMODULE\_KSPEC\_BS\_KEYWORD` only.) \* `find\_keys\_type`: After the "begin search", this describes which arguments are keys. The strategies are: \* `REDISMODULE\_KSPEC\_BS\_UNKNOWN`: There is no way to tell where the key args are located. \* `REDISMODULE\_KSPEC\_FK\_RANGE`: Keys end at a specific index (or relative to the last argument). \* `REDISMODULE\_KSPEC\_FK\_KEYNUM`: There's an argument that contains the number of key args somewhere before the keys themselves. `find\_keys\_type` and `fk` can be omitted if this keyspec describes exactly one key. \* `fk`: This is a union in which the `range` or `keynum` branch is used depending on the value of the `find\_keys\_type` field. \* `fk.range` (for `REDISMODULE\_KSPEC\_FK\_RANGE`): A struct with the following fields: \* `lastkey`: Index of the last key relative to the result of the begin search step. Can be negative, in which case it's not relative. -1 indicates the last argument, -2 one before the last and so on. \* `keystep`: How many arguments should we skip after finding a key, in order to find the next one? \* `limit`: If `lastkey` is -1, we use `limit` to stop the search by a factor. 0 and 1 mean no limit. 2 means 1/2 of the remaining args, 3 means 1/3, and so on. \* `fk.keynum` (for `REDISMODULE\_KSPEC\_FK\_KEYNUM`): A struct with the following fields: \* `keynumidx`: Index of the argument containing the number of keys to come, relative to the result of the begin search step. \* `firstkey`: Index of the fist key relative to the result of the begin search step. (Usually it's just after `keynumidx`, in which case it should be set to `keynumidx + 1`.) \* `keystep`: How many arguments should we skip after finding a key, in order to find the next one? Key-spec flags: The first four refer to what the command actually does with the \*value or metadata of the key\*, and not necessarily the user data or how it affects it. Each key-spec may must have exactly one of these. Any operation that's not distinctly deletion, overwrite or read-only would be marked as RW. \* `REDISMODULE\_CMD\_KEY\_RO`: Read-Only. Reads the value of the key, but doesn't necessarily return it. \* `REDISMODULE\_CMD\_KEY\_RW`: Read-Write. Modifies the data stored in the value of the key or its metadata. \* `REDISMODULE\_CMD\_KEY\_OW`: Overwrite. Overwrites the data stored in the value of the key. \* `REDISMODULE\_CMD\_KEY\_RM`: Deletes the key. The next four refer to \*user data inside the value of the key\*, not the metadata like LRU, type, cardinality. It refers to the logical operation on the user's data (actual input strings or TTL), being used/returned/copied/changed. It doesn't refer to modification or returning of metadata (like type, count, presence of data). ACCESS can be combined with one of the write operations INSERT, DELETE or UPDATE. Any write that's not an INSERT or a DELETE would be UPDATE. \* `REDISMODULE\_CMD\_KEY\_ACCESS`: Returns, copies or uses the user data from the value of the key. \* `REDISMODULE\_CMD\_KEY\_UPDATE`: Updates data to the value, new value may depend on the old value. \* `REDISMODULE\_CMD\_KEY\_INSERT`: Adds data to the value with no chance of modification or deletion of existing data. \* `REDISMODULE\_CMD\_KEY\_DELETE`: Explicitly deletes some content from the value of the key. Other flags: \* `REDISMODULE\_CMD\_KEY\_NOT\_KEY`: The key is not actually a key, but should be routed in cluster mode as if it was a key. \* `REDISMODULE\_CMD\_KEY\_INCOMPLETE`: The keyspec might not point out all the keys it should cover. \* `REDISMODULE\_CMD\_KEY\_VARIABLE\_FLAGS`: Some keys might have different flags depending on arguments. - `args`: An array of | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.02577560767531395,
-0.012002982199192047,
-0.05289790779352188,
0.02510414645075798,
-0.016205457970499992,
0.01576138101518154,
0.07331939786672592,
0.01886756159365177,
0.04200301319360733,
-0.05354287102818489,
0.043089114129543304,
0.018105171620845795,
0.09022171795368195,
-0.06917... | 0.120582 |
The key is not actually a key, but should be routed in cluster mode as if it was a key. \* `REDISMODULE\_CMD\_KEY\_INCOMPLETE`: The keyspec might not point out all the keys it should cover. \* `REDISMODULE\_CMD\_KEY\_VARIABLE\_FLAGS`: Some keys might have different flags depending on arguments. - `args`: An array of `RedisModuleCommandArg`, terminated by an element memset to zero. `RedisModuleCommandArg` is a structure with at the fields described below. typedef struct RedisModuleCommandArg { const char \*name; RedisModuleCommandArgType type; int key\_spec\_index; const char \*token; const char \*summary; const char \*since; int flags; struct RedisModuleCommandArg \*subargs; } RedisModuleCommandArg; Explanation of the fields: \* `name`: Name of the argument. \* `type`: The type of the argument. See below for details. The types `REDISMODULE\_ARG\_TYPE\_ONEOF` and `REDISMODULE\_ARG\_TYPE\_BLOCK` require an argument to have sub-arguments, i.e. `subargs`. \* `key\_spec\_index`: If the `type` is `REDISMODULE\_ARG\_TYPE\_KEY` you must provide the index of the key-spec associated with this argument. See `key\_specs` above. If the argument is not a key, you may specify -1. \* `token`: The token preceding the argument (optional). Example: the argument `seconds` in `SET` has a token `EX`. If the argument consists of only a token (for example `NX` in `SET`) the type should be `REDISMODULE\_ARG\_TYPE\_PURE\_TOKEN` and `value` should be NULL. \* `summary`: A short description of the argument (optional). \* `since`: The first version which included this argument (optional). \* `flags`: A bitwise or of the macros `REDISMODULE\_CMD\_ARG\_\*`. See below. \* `value`: The display-value of the argument. This string is what should be displayed when creating the command syntax from the output of `COMMAND`. If `token` is not NULL, it should also be displayed. Explanation of `RedisModuleCommandArgType`: \* `REDISMODULE\_ARG\_TYPE\_STRING`: String argument. \* `REDISMODULE\_ARG\_TYPE\_INTEGER`: Integer argument. \* `REDISMODULE\_ARG\_TYPE\_DOUBLE`: Double-precision float argument. \* `REDISMODULE\_ARG\_TYPE\_KEY`: String argument representing a keyname. \* `REDISMODULE\_ARG\_TYPE\_PATTERN`: String, but regex pattern. \* `REDISMODULE\_ARG\_TYPE\_UNIX\_TIME`: Integer, but Unix timestamp. \* `REDISMODULE\_ARG\_TYPE\_PURE\_TOKEN`: Argument doesn't have a placeholder. It's just a token without a value. Example: the `KEEPTTL` option of the `SET` command. \* `REDISMODULE\_ARG\_TYPE\_ONEOF`: Used when the user can choose only one of a few sub-arguments. Requires `subargs`. Example: the `NX` and `XX` options of `SET`. \* `REDISMODULE\_ARG\_TYPE\_BLOCK`: Used when one wants to group together several sub-arguments, usually to apply something on all of them, like making the entire group "optional". Requires `subargs`. Example: the `LIMIT offset count` parameters in `ZRANGE`. Explanation of the command argument flags: \* `REDISMODULE\_CMD\_ARG\_OPTIONAL`: The argument is optional (like GET in the SET command). \* `REDISMODULE\_CMD\_ARG\_MULTIPLE`: The argument may repeat itself (like key in DEL). \* `REDISMODULE\_CMD\_ARG\_MULTIPLE\_TOKEN`: The argument may repeat itself, and so does its token (like `GET pattern` in SORT). On success `REDISMODULE\_OK` is returned. On error `REDISMODULE\_ERR` is returned and `errno` is set to EINVAL if invalid info was provided or EEXIST if info has already been set. If the info is invalid, a warning is logged explaining which part of the info is invalid and why. ## Module information and time measurement ### `RedisModule\_IsModuleNameBusy` int RedisModule\_IsModuleNameBusy(const char \*name); \*\*Available since:\*\* 4.0.3 Return non-zero if the module name is busy. Otherwise zero is returned. ### `RedisModule\_Milliseconds` mstime\_t RedisModule\_Milliseconds(void); \*\*Available since:\*\* 4.0.0 Return the current UNIX time in milliseconds. ### `RedisModule\_MonotonicMicroseconds` uint64\_t RedisModule\_MonotonicMicroseconds(void); \*\*Available since:\*\* 7.0.0 Return counter of micro-seconds relative to an arbitrary point in time. ### `RedisModule\_Microseconds` ustime\_t RedisModule\_Microseconds(void); \*\*Available since:\*\* 7.2.0 Return the current UNIX time in microseconds ### `RedisModule\_CachedMicroseconds` ustime\_t RedisModule\_CachedMicroseconds(void); \*\*Available since:\*\* 7.2.0 Return the cached UNIX time in microseconds. It is updated in the server cron job and before executing a command. It is useful for complex call stacks, such as a command causing a key space notification, causing a module to execute a [`RedisModule\_Call`](#RedisModule\_Call), | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.03304910659790039,
0.008836803957819939,
-0.06413918733596802,
0.0558314174413681,
-0.025581849738955498,
-0.04210648685693741,
0.08785370737314224,
0.037160228937864304,
-0.10429061949253082,
-0.030532706528902054,
0.022565647959709167,
-0.07102930545806885,
0.019283782690763474,
-0.084... | 0.16819 |
### `RedisModule\_CachedMicroseconds` ustime\_t RedisModule\_CachedMicroseconds(void); \*\*Available since:\*\* 7.2.0 Return the cached UNIX time in microseconds. It is updated in the server cron job and before executing a command. It is useful for complex call stacks, such as a command causing a key space notification, causing a module to execute a [`RedisModule\_Call`](#RedisModule\_Call), causing another notification, etc. It makes sense that all this callbacks would use the same clock. ### `RedisModule\_BlockedClientMeasureTimeStart` int RedisModule\_BlockedClientMeasureTimeStart(RedisModuleBlockedClient \*bc); \*\*Available since:\*\* 6.2.0 Mark a point in time that will be used as the start time to calculate the elapsed execution time when [`RedisModule\_BlockedClientMeasureTimeEnd()`](#RedisModule\_BlockedClientMeasureTimeEnd) is called. Within the same command, you can call multiple times [`RedisModule\_BlockedClientMeasureTimeStart()`](#RedisModule\_BlockedClientMeasureTimeStart) and [`RedisModule\_BlockedClientMeasureTimeEnd()`](#RedisModule\_BlockedClientMeasureTimeEnd) to accumulate independent time intervals to the background duration. This method always return `REDISMODULE\_OK`. ### `RedisModule\_BlockedClientMeasureTimeEnd` int RedisModule\_BlockedClientMeasureTimeEnd(RedisModuleBlockedClient \*bc); \*\*Available since:\*\* 6.2.0 Mark a point in time that will be used as the end time to calculate the elapsed execution time. On success `REDISMODULE\_OK` is returned. This method only returns `REDISMODULE\_ERR` if no start time was previously defined ( meaning [`RedisModule\_BlockedClientMeasureTimeStart`](#RedisModule\_BlockedClientMeasureTimeStart) was not called ). ### `RedisModule\_Yield` void RedisModule\_Yield(RedisModuleCtx \*ctx, int flags, const char \*busy\_reply); \*\*Available since:\*\* 7.0.0 This API allows modules to let Redis process background tasks, and some commands during long blocking execution of a module command. The module can call this API periodically. The flags is a bit mask of these: - `REDISMODULE\_YIELD\_FLAG\_NONE`: No special flags, can perform some background operations, but not process client commands. - `REDISMODULE\_YIELD\_FLAG\_CLIENTS`: Redis can also process client commands. The `busy\_reply` argument is optional, and can be used to control the verbose error string after the `-BUSY` error code. When the `REDISMODULE\_YIELD\_FLAG\_CLIENTS` is used, Redis will only start processing client commands after the time defined by the `busy-reply-threshold` config, in which case Redis will start rejecting most commands with `-BUSY` error, but allow the ones marked with the `allow-busy` flag to be executed. This API can also be used in thread safe context (while locked), and during loading (in the `rdb\_load` callback, in which case it'll reject commands with the -LOADING error) ### `RedisModule\_SetModuleOptions` void RedisModule\_SetModuleOptions(RedisModuleCtx \*ctx, int options); \*\*Available since:\*\* 6.0.0 Set flags defining capabilities or behavior bit flags. `REDISMODULE\_OPTIONS\_HANDLE\_IO\_ERRORS`: Generally, modules don't need to bother with this, as the process will just terminate if a read error happens, however, setting this flag would allow repl-diskless-load to work if enabled. The module should use [`RedisModule\_IsIOError`](#RedisModule\_IsIOError) after reads, before using the data that was read, and in case of error, propagate it upwards, and also be able to release the partially populated value and all it's allocations. `REDISMODULE\_OPTION\_NO\_IMPLICIT\_SIGNAL\_MODIFIED`: See [`RedisModule\_SignalModifiedKey()`](#RedisModule\_SignalModifiedKey). `REDISMODULE\_OPTIONS\_HANDLE\_REPL\_ASYNC\_LOAD`: Setting this flag indicates module awareness of diskless async replication (repl-diskless-load=swapdb) and that redis could be serving reads during replication instead of blocking with LOADING status. `REDISMODULE\_OPTIONS\_ALLOW\_NESTED\_KEYSPACE\_NOTIFICATIONS`: Declare that the module wants to get nested key-space notifications. By default, Redis will not fire key-space notifications that happened inside a key-space notification callback. This flag allows to change this behavior and fire nested key-space notifications. Notice: if enabled, the module should protected itself from infinite recursion. ### `RedisModule\_SignalModifiedKey` int RedisModule\_SignalModifiedKey(RedisModuleCtx \*ctx, RedisModuleString \*keyname); \*\*Available since:\*\* 6.0.0 Signals that the key is modified from user's perspective (i.e. invalidate WATCH and client side caching). This is done automatically when a key opened for writing is closed, unless the option `REDISMODULE\_OPTION\_NO\_IMPLICIT\_SIGNAL\_MODIFIED` has been set using [`RedisModule\_SetModuleOptions()`](#RedisModule\_SetModuleOptions). ## Automatic memory management for modules ### `RedisModule\_AutoMemory` void RedisModule\_AutoMemory(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Enable automatic memory management. The function must be called as the first function of a command implementation that wants to use automatic memory. When enabled, automatic memory management tracks and automatically frees keys, call replies and | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.06602793186903,
0.0037960936315357685,
-0.09330813586711884,
0.05785059556365013,
0.02928049862384796,
-0.06390447914600372,
0.042189255356788635,
0.038752295076847076,
0.04751504957675934,
-0.03645982965826988,
-0.019340867176651955,
0.0041280463337898254,
-0.03660886362195015,
-0.0599... | 0.126384 |
## Automatic memory management for modules ### `RedisModule\_AutoMemory` void RedisModule\_AutoMemory(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Enable automatic memory management. The function must be called as the first function of a command implementation that wants to use automatic memory. When enabled, automatic memory management tracks and automatically frees keys, call replies and Redis string objects once the command returns. In most cases this eliminates the need of calling the following functions: 1. [`RedisModule\_CloseKey()`](#RedisModule\_CloseKey) 2. [`RedisModule\_FreeCallReply()`](#RedisModule\_FreeCallReply) 3. [`RedisModule\_FreeString()`](#RedisModule\_FreeString) These functions can still be used with automatic memory management enabled, to optimize loops that make numerous allocations for example. ## String objects APIs ### `RedisModule\_CreateString` RedisModuleString \*RedisModule\_CreateString(RedisModuleCtx \*ctx, const char \*ptr, size\_t len); \*\*Available since:\*\* 4.0.0 Create a new module string object. The returned string must be freed with [`RedisModule\_FreeString()`](#RedisModule\_FreeString), unless automatic memory is enabled. The string is created by copying the `len` bytes starting at `ptr`. No reference is retained to the passed buffer. The module context 'ctx' is optional and may be NULL if you want to create a string out of the context scope. However in that case, the automatic memory management will not be available, and the string memory must be managed manually. ### `RedisModule\_CreateStringPrintf` RedisModuleString \*RedisModule\_CreateStringPrintf(RedisModuleCtx \*ctx, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Create a new module string object from a printf format and arguments. The returned string must be freed with [`RedisModule\_FreeString()`](#RedisModule\_FreeString), unless automatic memory is enabled. The string is created using the sds formatter function `sdscatvprintf()`. The passed context 'ctx' may be NULL if necessary, see the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_CreateStringFromLongLong` RedisModuleString \*RedisModule\_CreateStringFromLongLong(RedisModuleCtx \*ctx, long long ll); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_CreateString()`](#RedisModule\_CreateString), but creates a string starting from a `long long` integer instead of taking a buffer and its length. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. The passed context 'ctx' may be NULL if necessary, see the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_CreateStringFromULongLong` RedisModuleString \*RedisModule\_CreateStringFromULongLong(RedisModuleCtx \*ctx, unsigned long long ull); \*\*Available since:\*\* 7.0.3 Like [`RedisModule\_CreateString()`](#RedisModule\_CreateString), but creates a string starting from a `unsigned long long` integer instead of taking a buffer and its length. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. The passed context 'ctx' may be NULL if necessary, see the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_CreateStringFromDouble` RedisModuleString \*RedisModule\_CreateStringFromDouble(RedisModuleCtx \*ctx, double d); \*\*Available since:\*\* 6.0.0 Like [`RedisModule\_CreateString()`](#RedisModule\_CreateString), but creates a string starting from a double instead of taking a buffer and its length. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. ### `RedisModule\_CreateStringFromLongDouble` RedisModuleString \*RedisModule\_CreateStringFromLongDouble(RedisModuleCtx \*ctx, long double ld, int humanfriendly); \*\*Available since:\*\* 6.0.0 Like [`RedisModule\_CreateString()`](#RedisModule\_CreateString), but creates a string starting from a long double. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. The passed context 'ctx' may be NULL if necessary, see the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_CreateStringFromString` RedisModuleString \*RedisModule\_CreateStringFromString(RedisModuleCtx \*ctx, const RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_CreateString()`](#RedisModule\_CreateString), but creates a string starting from another `RedisModuleString`. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. The passed context 'ctx' may be NULL if necessary, see the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_CreateStringFromStreamID` RedisModuleString \*RedisModule\_CreateStringFromStreamID(RedisModuleCtx \*ctx, const RedisModuleStreamID \*id); \*\*Available since:\*\* 6.2.0 Creates a string from a stream ID. The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString), unless automatic memory is enabled. The passed context `ctx` may be NULL if necessary. See the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_FreeString` void RedisModule\_FreeString(RedisModuleCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 Free a module string object obtained with one of the Redis modules API calls that return | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.012056437321007252,
0.008893082849681377,
-0.09212673455476761,
0.06292913854122162,
-0.050209879875183105,
-0.045294422656297684,
0.11659496277570724,
0.06267998367547989,
-0.00508420355618,
0.008356296457350254,
0.017540758475661278,
-0.019961800426244736,
0.01815006695687771,
-0.03487... | 0.214334 |
released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString), unless automatic memory is enabled. The passed context `ctx` may be NULL if necessary. See the [`RedisModule\_CreateString()`](#RedisModule\_CreateString) documentation for more info. ### `RedisModule\_FreeString` void RedisModule\_FreeString(RedisModuleCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 Free a module string object obtained with one of the Redis modules API calls that return new string objects. It is possible to call this function even when automatic memory management is enabled. In that case the string will be released ASAP and removed from the pool of string to release at the end. If the string was created with a NULL context 'ctx', it is also possible to pass ctx as NULL when releasing the string (but passing a context will not create any issue). Strings created with a context should be freed also passing the context, so if you want to free a string out of context later, make sure to create it using a NULL context. ### `RedisModule\_RetainString` void RedisModule\_RetainString(RedisModuleCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 Every call to this function, will make the string 'str' requiring an additional call to [`RedisModule\_FreeString()`](#RedisModule\_FreeString) in order to really free the string. Note that the automatic freeing of the string obtained enabling modules automatic memory management counts for one [`RedisModule\_FreeString()`](#RedisModule\_FreeString) call (it is just executed automatically). Normally you want to call this function when, at the same time the following conditions are true: 1. You have automatic memory management enabled. 2. You want to create string objects. 3. Those string objects you create need to live \*after\* the callback function(for example a command implementation) creating them returns. Usually you want this in order to store the created string object into your own data structure, for example when implementing a new data type. Note that when memory management is turned off, you don't need any call to RetainString() since creating a string will always result into a string that lives after the callback function returns, if no FreeString() call is performed. It is possible to call this function with a NULL context. When strings are going to be retained for an extended duration, it is good practice to also call [`RedisModule\_TrimStringAllocation()`](#RedisModule\_TrimStringAllocation) in order to optimize memory usage. Threaded modules that reference retained strings from other threads \*must\* explicitly trim the allocation as soon as the string is retained. Not doing so may result with automatic trimming which is not thread safe. ### `RedisModule\_HoldString` RedisModuleString\* RedisModule\_HoldString(RedisModuleCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 6.0.7 This function can be used instead of [`RedisModule\_RetainString()`](#RedisModule\_RetainString). The main difference between the two is that this function will always succeed, whereas [`RedisModule\_RetainString()`](#RedisModule\_RetainString) may fail because of an assertion. The function returns a pointer to `RedisModuleString`, which is owned by the caller. It requires a call to [`RedisModule\_FreeString()`](#RedisModule\_FreeString) to free the string when automatic memory management is disabled for the context. When automatic memory management is enabled, you can either call [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or let the automation free it. This function is more efficient than [`RedisModule\_CreateStringFromString()`](#RedisModule\_CreateStringFromString) because whenever possible, it avoids copying the underlying `RedisModuleString`. The disadvantage of using this function is that it might not be possible to use [`RedisModule\_StringAppendBuffer()`](#RedisModule\_StringAppendBuffer) on the returned `RedisModuleString`. It is possible to call this function with a NULL context. When strings are going to be held for an extended duration, it is good practice to also call [`RedisModule\_TrimStringAllocation()`](#RedisModule\_TrimStringAllocation) in order to optimize memory usage. Threaded modules that reference held strings from other threads \*must\* explicitly trim the allocation as soon as the string is held. Not doing so may result with automatic trimming which is not thread safe. ### `RedisModule\_StringPtrLen` const char \*RedisModule\_StringPtrLen(const RedisModuleString \*str, size\_t \*len); \*\*Available since:\*\* 4.0.0 | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.00022088640253059566,
0.02311379835009575,
-0.10340724140405655,
0.06040326878428459,
-0.052493467926979065,
-0.013664966449141502,
0.09370063990354538,
0.042820677161216736,
0.02018127217888832,
-0.022116130217909813,
0.05060888081789017,
-0.04109349101781845,
0.029980098828673363,
-0.... | 0.113701 |
to optimize memory usage. Threaded modules that reference held strings from other threads \*must\* explicitly trim the allocation as soon as the string is held. Not doing so may result with automatic trimming which is not thread safe. ### `RedisModule\_StringPtrLen` const char \*RedisModule\_StringPtrLen(const RedisModuleString \*str, size\_t \*len); \*\*Available since:\*\* 4.0.0 Given a string module object, this function returns the string pointer and length of the string. The returned pointer and length should only be used for read only accesses and never modified. ### `RedisModule\_StringToLongLong` int RedisModule\_StringToLongLong(const RedisModuleString \*str, long long \*ll); \*\*Available since:\*\* 4.0.0 Convert the string into a `long long` integer, storing it at `\*ll`. Returns `REDISMODULE\_OK` on success. If the string can't be parsed as a valid, strict `long long` (no spaces before/after), `REDISMODULE\_ERR` is returned. ### `RedisModule\_StringToULongLong` int RedisModule\_StringToULongLong(const RedisModuleString \*str, unsigned long long \*ull); \*\*Available since:\*\* 7.0.3 Convert the string into a `unsigned long long` integer, storing it at `\*ull`. Returns `REDISMODULE\_OK` on success. If the string can't be parsed as a valid, strict `unsigned long long` (no spaces before/after), `REDISMODULE\_ERR` is returned. ### `RedisModule\_StringToDouble` int RedisModule\_StringToDouble(const RedisModuleString \*str, double \*d); \*\*Available since:\*\* 4.0.0 Convert the string into a double, storing it at `\*d`. Returns `REDISMODULE\_OK` on success or `REDISMODULE\_ERR` if the string is not a valid string representation of a double value. ### `RedisModule\_StringToLongDouble` int RedisModule\_StringToLongDouble(const RedisModuleString \*str, long double \*ld); \*\*Available since:\*\* 6.0.0 Convert the string into a long double, storing it at `\*ld`. Returns `REDISMODULE\_OK` on success or `REDISMODULE\_ERR` if the string is not a valid string representation of a double value. ### `RedisModule\_StringToStreamID` int RedisModule\_StringToStreamID(const RedisModuleString \*str, RedisModuleStreamID \*id); \*\*Available since:\*\* 6.2.0 Convert the string into a stream ID, storing it at `\*id`. Returns `REDISMODULE\_OK` on success and returns `REDISMODULE\_ERR` if the string is not a valid string representation of a stream ID. The special IDs "+" and "-" are allowed. ### `RedisModule\_StringCompare` int RedisModule\_StringCompare(const RedisModuleString \*a, const RedisModuleString \*b); \*\*Available since:\*\* 4.0.0 Compare two string objects, returning -1, 0 or 1 respectively if a < b, a == b, a > b. Strings are compared byte by byte as two binary blobs without any encoding care / collation attempt. ### `RedisModule\_StringAppendBuffer` int RedisModule\_StringAppendBuffer(RedisModuleCtx \*ctx, RedisModuleString \*str, const char \*buf, size\_t len); \*\*Available since:\*\* 4.0.0 Append the specified buffer to the string 'str'. The string must be a string created by the user that is referenced only a single time, otherwise `REDISMODULE\_ERR` is returned and the operation is not performed. ### `RedisModule\_TrimStringAllocation` void RedisModule\_TrimStringAllocation(RedisModuleString \*str); \*\*Available since:\*\* 7.0.0 Trim possible excess memory allocated for a `RedisModuleString`. Sometimes a `RedisModuleString` may have more memory allocated for it than required, typically for argv arguments that were constructed from network buffers. This function optimizes such strings by reallocating their memory, which is useful for strings that are not short lived but retained for an extended duration. This operation is \*not thread safe\* and should only be called when no concurrent access to the string is guaranteed. Using it for an argv string in a module command before the string is potentially available to other threads is generally safe. Currently, Redis may also automatically trim retained strings when a module command returns. However, doing this explicitly should still be a preferred option: 1. Future versions of Redis may abandon auto-trimming. 2. Auto-trimming as currently implemented is \*not thread safe\*. A background thread manipulating a recently retained string may end up in a race condition with the auto-trim, which could result with data corruption. ## Reply APIs These functions are used for sending replies to the client. Most functions always return `REDISMODULE\_OK` so you can use it | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.06877127289772034,
0.027919499203562737,
-0.014693924225866795,
0.027462581172585487,
-0.10607655346393585,
0.016394738107919693,
0.00034379103453829885,
0.08835283666849136,
-0.003433670848608017,
-0.08103743940591812,
-0.00240246020257473,
0.03124532289803028,
-0.0038215452805161476,
-... | 0.101527 |
\*not thread safe\*. A background thread manipulating a recently retained string may end up in a race condition with the auto-trim, which could result with data corruption. ## Reply APIs These functions are used for sending replies to the client. Most functions always return `REDISMODULE\_OK` so you can use it with 'return' in order to return from the command implementation with: if (... some condition ...) return RedisModule\_ReplyWithLongLong(ctx,mycount); ### Reply with collection functions After starting a collection reply, the module must make calls to other `ReplyWith\*` style functions in order to emit the elements of the collection. Collection types include: Array, Map, Set and Attribute. When producing collections with a number of elements that is not known beforehand, the function can be called with a special flag `REDISMODULE\_POSTPONED\_LEN` (`REDISMODULE\_POSTPONED\_ARRAY\_LEN` in the past), and the actual number of elements can be later set with `RedisModule\_ReplySet`\*Length() call (which will set the latest "open" count if there are multiple ones). ### `RedisModule\_WrongArity` int RedisModule\_WrongArity(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Send an error about the number of arguments given to the command, citing the command name in the error message. Returns `REDISMODULE\_OK`. Example: if (argc != 3) return RedisModule\_WrongArity(ctx); ### `RedisModule\_ReplyWithLongLong` int RedisModule\_ReplyWithLongLong(RedisModuleCtx \*ctx, long long ll); \*\*Available since:\*\* 4.0.0 Send an integer reply to the client, with the specified `long long` value. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithError` int RedisModule\_ReplyWithError(RedisModuleCtx \*ctx, const char \*err); \*\*Available since:\*\* 4.0.0 Reply with the error 'err'. Note that 'err' must contain all the error, including the initial error code. The function only provides the initial "-", so the usage is, for example: RedisModule\_ReplyWithError(ctx,"ERR Wrong Type"); and not just: RedisModule\_ReplyWithError(ctx,"Wrong Type"); The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithErrorFormat` int RedisModule\_ReplyWithErrorFormat(RedisModuleCtx \*ctx, const char \*fmt, ...); \*\*Available since:\*\* 7.2.0 Reply with the error create from a printf format and arguments. Note that 'fmt' must contain all the error, including the initial error code. The function only provides the initial "-", so the usage is, for example: RedisModule\_ReplyWithErrorFormat(ctx,"ERR Wrong Type: %s",type); and not just: RedisModule\_ReplyWithErrorFormat(ctx,"Wrong Type: %s",type); The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithSimpleString` int RedisModule\_ReplyWithSimpleString(RedisModuleCtx \*ctx, const char \*msg); \*\*Available since:\*\* 4.0.0 Reply with a simple string (`+... \r\n` in RESP protocol). This replies are suitable only when sending a small non-binary string with small overhead, like "OK" or similar replies. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithArray` int RedisModule\_ReplyWithArray(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 4.0.0 Reply with an array type of 'len' elements. After starting an array reply, the module must make `len` calls to other `ReplyWith\*` style functions in order to emit the elements of the array. See Reply APIs section for more details. Use [`RedisModule\_ReplySetArrayLength()`](#RedisModule\_ReplySetArrayLength) to set deferred length. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithMap` int RedisModule\_ReplyWithMap(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Reply with a RESP3 Map type of 'len' pairs. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. After starting a map reply, the module must make `len\*2` calls to other `ReplyWith\*` style functions in order to emit the elements of the map. See Reply APIs section for more details. If the connected client is using RESP2, the reply will be converted to a flat array. Use [`RedisModule\_ReplySetMapLength()`](#RedisModule\_ReplySetMapLength) to set deferred length. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithSet` int RedisModule\_ReplyWithSet(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Reply with a RESP3 Set type of 'len' elements. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. After starting a set reply, the module must make `len` calls to other `ReplyWith\*` style functions in order to emit the elements of the set. See Reply APIs section for more details. If the connected client is using RESP2, the reply | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.06636517494916916,
0.03238764405250549,
0.002405160805210471,
0.06711423397064209,
-0.09008301049470901,
-0.07002853602170944,
0.04593294858932495,
-0.02003466710448265,
0.07217060774564743,
-0.0075896126218140125,
0.005891173612326384,
-0.01536977756768465,
-0.0008494134526699781,
-0.0... | 0.083325 |
'len' elements. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. After starting a set reply, the module must make `len` calls to other `ReplyWith\*` style functions in order to emit the elements of the set. See Reply APIs section for more details. If the connected client is using RESP2, the reply will be converted to an array type. Use [`RedisModule\_ReplySetSetLength()`](#RedisModule\_ReplySetSetLength) to set deferred length. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithAttribute` int RedisModule\_ReplyWithAttribute(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Add attributes (metadata) to the reply. Should be done before adding the actual reply. see [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md)#attribute-type After starting an attribute's reply, the module must make `len\*2` calls to other `ReplyWith\*` style functions in order to emit the elements of the attribute map. See Reply APIs section for more details. Use [`RedisModule\_ReplySetAttributeLength()`](#RedisModule\_ReplySetAttributeLength) to set deferred length. Not supported by RESP2 and will return `REDISMODULE\_ERR`, otherwise the function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithNullArray` int RedisModule\_ReplyWithNullArray(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Reply to the client with a null array, simply null in RESP3, null array in RESP2. Note: In RESP3 there's no difference between Null reply and NullArray reply, so to prevent ambiguity it's better to avoid using this API and use [`RedisModule\_ReplyWithNull`](#RedisModule\_ReplyWithNull) instead. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithEmptyArray` int RedisModule\_ReplyWithEmptyArray(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Reply to the client with an empty array. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplySetArrayLength` void RedisModule\_ReplySetArrayLength(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 4.0.0 When [`RedisModule\_ReplyWithArray()`](#RedisModule\_ReplyWithArray) is used with the argument `REDISMODULE\_POSTPONED\_LEN`, because we don't know beforehand the number of items we are going to output as elements of the array, this function will take care to set the array length. Since it is possible to have multiple array replies pending with unknown length, this function guarantees to always set the latest array length that was created in a postponed way. For example in order to output an array like [1,[10,20,30]] we could write: RedisModule\_ReplyWithArray(ctx,REDISMODULE\_POSTPONED\_LEN); RedisModule\_ReplyWithLongLong(ctx,1); RedisModule\_ReplyWithArray(ctx,REDISMODULE\_POSTPONED\_LEN); RedisModule\_ReplyWithLongLong(ctx,10); RedisModule\_ReplyWithLongLong(ctx,20); RedisModule\_ReplyWithLongLong(ctx,30); RedisModule\_ReplySetArrayLength(ctx,3); // Set len of 10,20,30 array. RedisModule\_ReplySetArrayLength(ctx,2); // Set len of top array Note that in the above example there is no reason to postpone the array length, since we produce a fixed number of elements, but in the practice the code may use an iterator or other ways of creating the output so that is not easy to calculate in advance the number of elements. ### `RedisModule\_ReplySetMapLength` void RedisModule\_ReplySetMapLength(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Very similar to [`RedisModule\_ReplySetArrayLength`](#RedisModule\_ReplySetArrayLength) except `len` should exactly half of the number of `ReplyWith\*` functions called in the context of the map. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. ### `RedisModule\_ReplySetSetLength` void RedisModule\_ReplySetSetLength(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Very similar to [`RedisModule\_ReplySetArrayLength`](#RedisModule\_ReplySetArrayLength) Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. ### `RedisModule\_ReplySetAttributeLength` void RedisModule\_ReplySetAttributeLength(RedisModuleCtx \*ctx, long len); \*\*Available since:\*\* 7.0.0 Very similar to [`RedisModule\_ReplySetMapLength`](#RedisModule\_ReplySetMapLength) Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. Must not be called if [`RedisModule\_ReplyWithAttribute`](#RedisModule\_ReplyWithAttribute) returned an error. ### `RedisModule\_ReplyWithStringBuffer` int RedisModule\_ReplyWithStringBuffer(RedisModuleCtx \*ctx, const char \*buf, size\_t len); \*\*Available since:\*\* 4.0.0 Reply with a bulk string, taking in input a C buffer pointer and length. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithCString` int RedisModule\_ReplyWithCString(RedisModuleCtx \*ctx, const char \*buf); \*\*Available since:\*\* 5.0.6 Reply with a bulk string, taking in input a C buffer pointer that is assumed to be null-terminated. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithString` int RedisModule\_ReplyWithString(RedisModuleCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 Reply with a bulk string, taking in input a `RedisModuleString` object. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithEmptyString` int RedisModule\_ReplyWithEmptyString(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Reply with an empty string. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithVerbatimStringType` int RedisModule\_ReplyWithVerbatimStringType(RedisModuleCtx \*ctx, const char \*buf, size\_t len, const char \*ext); | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.07206004858016968,
0.005748532246798277,
-0.042970094829797745,
0.0549195371568203,
-0.061534300446510315,
-0.036312125623226166,
0.07609882950782776,
0.050949838012456894,
0.02702896110713482,
-0.019444765523076057,
-0.04720667004585266,
-0.01775476150214672,
0.024513954296708107,
-0.0... | 0.086604 |
\*\*Available since:\*\* 4.0.0 Reply with a bulk string, taking in input a `RedisModuleString` object. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithEmptyString` int RedisModule\_ReplyWithEmptyString(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Reply with an empty string. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithVerbatimStringType` int RedisModule\_ReplyWithVerbatimStringType(RedisModuleCtx \*ctx, const char \*buf, size\_t len, const char \*ext); \*\*Available since:\*\* 7.0.0 Reply with a binary safe string, which should not be escaped or filtered taking in input a C buffer pointer, length and a 3 character type/extension. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithVerbatimString` int RedisModule\_ReplyWithVerbatimString(RedisModuleCtx \*ctx, const char \*buf, size\_t len); \*\*Available since:\*\* 6.0.0 Reply with a binary safe string, which should not be escaped or filtered taking in input a C buffer pointer and length. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithNull` int RedisModule\_ReplyWithNull(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Reply to the client with a NULL. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithBool` int RedisModule\_ReplyWithBool(RedisModuleCtx \*ctx, int b); \*\*Available since:\*\* 7.0.0 Reply with a RESP3 Boolean type. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. In RESP3, this is boolean type In RESP2, it's a string response of "1" and "0" for true and false respectively. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithCallReply` int RedisModule\_ReplyWithCallReply(RedisModuleCtx \*ctx, RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Reply exactly what a Redis command returned us with [`RedisModule\_Call()`](#RedisModule\_Call). This function is useful when we use [`RedisModule\_Call()`](#RedisModule\_Call) in order to execute some command, as we want to reply to the client exactly the same reply we obtained by the command. Return: - `REDISMODULE\_OK` on success. - `REDISMODULE\_ERR` if the given reply is in RESP3 format but the client expects RESP2. In case of an error, it's the module writer responsibility to translate the reply to RESP2 (or handle it differently by returning an error). Notice that for module writer convenience, it is possible to pass `0` as a parameter to the fmt argument of [`RedisModule\_Call`](#RedisModule\_Call) so that the `RedisModuleCallReply` will return in the same protocol (RESP2 or RESP3) as set in the current client's context. ### `RedisModule\_ReplyWithDouble` int RedisModule\_ReplyWithDouble(RedisModuleCtx \*ctx, double d); \*\*Available since:\*\* 4.0.0 Reply with a RESP3 Double type. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. Send a string reply obtained converting the double 'd' into a bulk string. This function is basically equivalent to converting a double into a string into a C buffer, and then calling the function [`RedisModule\_ReplyWithStringBuffer()`](#RedisModule\_ReplyWithStringBuffer) with the buffer and length. In RESP3 the string is tagged as a double, while in RESP2 it's just a plain string that the user will have to parse. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithBigNumber` int RedisModule\_ReplyWithBigNumber(RedisModuleCtx \*ctx, const char \*bignum, size\_t len); \*\*Available since:\*\* 7.0.0 Reply with a RESP3 BigNumber type. Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3. In RESP3, this is a string of length `len` that is tagged as a BigNumber, however, it's up to the caller to ensure that it's a valid BigNumber. In RESP2, this is just a plain bulk string response. The function always returns `REDISMODULE\_OK`. ### `RedisModule\_ReplyWithLongDouble` int RedisModule\_ReplyWithLongDouble(RedisModuleCtx \*ctx, long double ld); \*\*Available since:\*\* 6.0.0 Send a string reply obtained converting the long double 'ld' into a bulk string. This function is basically equivalent to converting a long double into a string into a C buffer, and then calling the function [`RedisModule\_ReplyWithStringBuffer()`](#RedisModule\_ReplyWithStringBuffer) with the buffer and length. The double string uses human readable formatting (see `addReplyHumanLongDouble` in networking.c). The function always returns `REDISMODULE\_OK`. ## Commands replication API ### `RedisModule\_Replicate` int RedisModule\_Replicate(RedisModuleCtx \*ctx, const char \*cmdname, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Replicate the specified command and arguments to slaves and AOF, as effect of execution of the calling command implementation. The replicated commands | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.011885803192853928,
0.006627859082072973,
-0.029665719717741013,
0.046351268887519836,
-0.01773916929960251,
-0.024335062131285667,
0.08033602684736252,
0.072405144572258,
-0.07389405369758606,
-0.01013213861733675,
-0.02682742476463318,
-0.09134446084499359,
0.0018554431153461337,
-0.0... | 0.121661 |
(see `addReplyHumanLongDouble` in networking.c). The function always returns `REDISMODULE\_OK`. ## Commands replication API ### `RedisModule\_Replicate` int RedisModule\_Replicate(RedisModuleCtx \*ctx, const char \*cmdname, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Replicate the specified command and arguments to slaves and AOF, as effect of execution of the calling command implementation. The replicated commands are always wrapped into the MULTI/EXEC that contains all the commands replicated in a given module command execution. However the commands replicated with [`RedisModule\_Call()`](#RedisModule\_Call) are the first items, the ones replicated with [`RedisModule\_Replicate()`](#RedisModule\_Replicate) will all follow before the EXEC. Modules should try to use one interface or the other. This command follows exactly the same interface of [`RedisModule\_Call()`](#RedisModule\_Call), so a set of format specifiers must be passed, followed by arguments matching the provided format specifiers. Please refer to [`RedisModule\_Call()`](#RedisModule\_Call) for more information. Using the special "A" and "R" modifiers, the caller can exclude either the AOF or the replicas from the propagation of the specified command. Otherwise, by default, the command will be propagated in both channels. #### Note about calling this function from a thread safe context: Normally when you call this function from the callback implementing a module command, or any other callback provided by the Redis Module API, Redis will accumulate all the calls to this function in the context of the callback, and will propagate all the commands wrapped in a MULTI/EXEC transaction. However when calling this function from a threaded safe context that can live an undefined amount of time, and can be locked/unlocked in at will, the behavior is different: MULTI/EXEC wrapper is not emitted and the command specified is inserted in the AOF and replication stream immediately. #### Return value The command returns `REDISMODULE\_ERR` if the format specifiers are invalid or the command name does not belong to a known command. ### `RedisModule\_ReplicateVerbatim` int RedisModule\_ReplicateVerbatim(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 This function will replicate the command exactly as it was invoked by the client. Note that this function will not wrap the command into a MULTI/EXEC stanza, so it should not be mixed with other replication commands. Basically this form of replication is useful when you want to propagate the command to the slaves and AOF file exactly as it was called, since the command can just be re-executed to deterministically re-create the new state starting from the old one. The function always returns `REDISMODULE\_OK`. ## DB and Key APIs – Generic API ### `RedisModule\_GetClientId` unsigned long long RedisModule\_GetClientId(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return the ID of the current client calling the currently active module command. The returned ID has a few guarantees: 1. The ID is different for each different client, so if the same client executes a module command multiple times, it can be recognized as having the same ID, otherwise the ID will be different. 2. The ID increases monotonically. Clients connecting to the server later are guaranteed to get IDs greater than any past ID previously seen. Valid IDs are from 1 to 2^64 - 1. If 0 is returned it means there is no way to fetch the ID in the context the function was currently called. After obtaining the ID, it is possible to check if the command execution is actually happening in the context of AOF loading, using this macro: if (RedisModule\_IsAOFClient(RedisModule\_GetClientId(ctx)) { // Handle it differently. } ### `RedisModule\_GetClientUserNameById` RedisModuleString \*RedisModule\_GetClientUserNameById(RedisModuleCtx \*ctx, uint64\_t id); \*\*Available since:\*\* 6.2.1 Return the ACL user name used by the client with the specified client ID. Client ID can be obtained with [`RedisModule\_GetClientId()`](#RedisModule\_GetClientId) API. If the client does not exist, NULL is returned and errno is set to ENOENT. If the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.07823742926120758,
-0.03894396498799324,
-0.06670968979597092,
0.04581136256456375,
-0.044648364186286926,
-0.09416350722312927,
-0.012777364812791348,
-0.006491674110293388,
-0.010792667046189308,
0.011515837162733078,
0.06429755687713623,
-0.00843253917992115,
0.023031312972307205,
-0... | 0.16857 |
} ### `RedisModule\_GetClientUserNameById` RedisModuleString \*RedisModule\_GetClientUserNameById(RedisModuleCtx \*ctx, uint64\_t id); \*\*Available since:\*\* 6.2.1 Return the ACL user name used by the client with the specified client ID. Client ID can be obtained with [`RedisModule\_GetClientId()`](#RedisModule\_GetClientId) API. If the client does not exist, NULL is returned and errno is set to ENOENT. If the client isn't using an ACL user, NULL is returned and errno is set to ENOTSUP ### `RedisModule\_GetClientInfoById` int RedisModule\_GetClientInfoById(void \*ci, uint64\_t id); \*\*Available since:\*\* 6.0.0 Return information about the client with the specified ID (that was previously obtained via the [`RedisModule\_GetClientId()`](#RedisModule\_GetClientId) API). If the client exists, `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned. When the client exist and the `ci` pointer is not NULL, but points to a structure of type `RedisModuleClientInfoV`1, previously initialized with the correct `REDISMODULE\_CLIENTINFO\_INITIALIZER\_V1`, the structure is populated with the following fields: uint64\_t flags; // REDISMODULE\_CLIENTINFO\_FLAG\_\* uint64\_t id; // Client ID char addr[46]; // IPv4 or IPv6 address. uint16\_t port; // TCP port. uint16\_t db; // Selected DB. Note: the client ID is useless in the context of this call, since we already know, however the same structure could be used in other contexts where we don't know the client ID, yet the same structure is returned. With flags having the following meaning: REDISMODULE\_CLIENTINFO\_FLAG\_SSL Client using SSL connection. REDISMODULE\_CLIENTINFO\_FLAG\_PUBSUB Client in Pub/Sub mode. REDISMODULE\_CLIENTINFO\_FLAG\_BLOCKED Client blocked in command. REDISMODULE\_CLIENTINFO\_FLAG\_TRACKING Client with keys tracking on. REDISMODULE\_CLIENTINFO\_FLAG\_UNIXSOCKET Client using unix domain socket. REDISMODULE\_CLIENTINFO\_FLAG\_MULTI Client in MULTI state. However passing NULL is a way to just check if the client exists in case we are not interested in any additional information. This is the correct usage when we want the client info structure returned: RedisModuleClientInfo ci = REDISMODULE\_CLIENTINFO\_INITIALIZER; int retval = RedisModule\_GetClientInfoById(&ci,client\_id); if (retval == REDISMODULE\_OK) { printf("Address: %s\n", ci.addr); } ### `RedisModule\_GetClientNameById` RedisModuleString \*RedisModule\_GetClientNameById(RedisModuleCtx \*ctx, uint64\_t id); \*\*Available since:\*\* 7.0.3 Returns the name of the client connection with the given ID. If the client ID does not exist or if the client has no name associated with it, NULL is returned. ### `RedisModule\_SetClientNameById` int RedisModule\_SetClientNameById(uint64\_t id, RedisModuleString \*name); \*\*Available since:\*\* 7.0.3 Sets the name of the client with the given ID. This is equivalent to the client calling `CLIENT SETNAME name`. Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and errno is set as follows: - ENOENT if the client does not exist - EINVAL if the name contains invalid characters ### `RedisModule\_PublishMessage` int RedisModule\_PublishMessage(RedisModuleCtx \*ctx, RedisModuleString \*channel, RedisModuleString \*message); \*\*Available since:\*\* 6.0.0 Publish a message to subscribers (see PUBLISH command). ### `RedisModule\_PublishMessageShard` int RedisModule\_PublishMessageShard(RedisModuleCtx \*ctx, RedisModuleString \*channel, RedisModuleString \*message); \*\*Available since:\*\* 7.0.0 Publish a message to shard-subscribers (see SPUBLISH command). ### `RedisModule\_GetSelectedDb` int RedisModule\_GetSelectedDb(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return the currently selected DB. ### `RedisModule\_GetContextFlags` int RedisModule\_GetContextFlags(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.3 Return the current context's flags. The flags provide information on the current request context (whether the client is a Lua script or in a MULTI), and about the Redis instance in general, i.e replication and persistence. It is possible to call this function even with a NULL context, however in this case the following flags will not be reported: \* LUA, MULTI, REPLICATED, DIRTY (see below for more info). Available flags and their meaning: \* `REDISMODULE\_CTX\_FLAGS\_LUA`: The command is running in a Lua script \* `REDISMODULE\_CTX\_FLAGS\_MULTI`: The command is running inside a transaction \* `REDISMODULE\_CTX\_FLAGS\_REPLICATED`: The command was sent over the replication link by the MASTER \* `REDISMODULE\_CTX\_FLAGS\_MASTER`: The Redis instance is a master \* `REDISMODULE\_CTX\_FLAGS\_SLAVE`: The Redis instance is a slave \* `REDISMODULE\_CTX\_FLAGS\_READONLY`: The Redis instance is read-only \* `REDISMODULE\_CTX\_FLAGS\_CLUSTER`: The Redis instance is in cluster mode \* `REDISMODULE\_CTX\_FLAGS\_AOF`: The Redis instance has AOF | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0881604254245758,
0.07068265229463577,
-0.12599726021289825,
0.014029104262590408,
-0.0333070307970047,
-0.0390770360827446,
0.12358792126178741,
0.03793894127011299,
-0.013253414072096348,
-0.09265553951263428,
0.008449454791843891,
-0.0617951937019825,
0.07603834569454193,
-0.07263820... | 0.146296 |
The command was sent over the replication link by the MASTER \* `REDISMODULE\_CTX\_FLAGS\_MASTER`: The Redis instance is a master \* `REDISMODULE\_CTX\_FLAGS\_SLAVE`: The Redis instance is a slave \* `REDISMODULE\_CTX\_FLAGS\_READONLY`: The Redis instance is read-only \* `REDISMODULE\_CTX\_FLAGS\_CLUSTER`: The Redis instance is in cluster mode \* `REDISMODULE\_CTX\_FLAGS\_AOF`: The Redis instance has AOF enabled \* `REDISMODULE\_CTX\_FLAGS\_RDB`: The instance has RDB enabled \* `REDISMODULE\_CTX\_FLAGS\_MAXMEMORY`: The instance has Maxmemory set \* `REDISMODULE\_CTX\_FLAGS\_EVICT`: Maxmemory is set and has an eviction policy that may delete keys \* `REDISMODULE\_CTX\_FLAGS\_OOM`: Redis is out of memory according to the maxmemory setting. \* `REDISMODULE\_CTX\_FLAGS\_OOM\_WARNING`: Less than 25% of memory remains before reaching the maxmemory level. \* `REDISMODULE\_CTX\_FLAGS\_LOADING`: Server is loading RDB/AOF \* `REDISMODULE\_CTX\_FLAGS\_REPLICA\_IS\_STALE`: No active link with the master. \* `REDISMODULE\_CTX\_FLAGS\_REPLICA\_IS\_CONNECTING`: The replica is trying to connect with the master. \* `REDISMODULE\_CTX\_FLAGS\_REPLICA\_IS\_TRANSFERRING`: Master -> Replica RDB transfer is in progress. \* `REDISMODULE\_CTX\_FLAGS\_REPLICA\_IS\_ONLINE`: The replica has an active link with its master. This is the contrary of STALE state. \* `REDISMODULE\_CTX\_FLAGS\_ACTIVE\_CHILD`: There is currently some background process active (RDB, AUX or module). \* `REDISMODULE\_CTX\_FLAGS\_MULTI\_DIRTY`: The next EXEC will fail due to dirty CAS (touched keys). \* `REDISMODULE\_CTX\_FLAGS\_IS\_CHILD`: Redis is currently running inside background child process. \* `REDISMODULE\_CTX\_FLAGS\_RESP3`: Indicate the that client attached to this context is using RESP3. \* `REDISMODULE\_CTX\_FLAGS\_SERVER\_STARTUP`: The Redis instance is starting ### `RedisModule\_AvoidReplicaTraffic` int RedisModule\_AvoidReplicaTraffic(void); \*\*Available since:\*\* 6.0.0 Returns true if a client sent the CLIENT PAUSE command to the server or if Redis Cluster does a manual failover, pausing the clients. This is needed when we have a master with replicas, and want to write, without adding further data to the replication channel, that the replicas replication offset, match the one of the master. When this happens, it is safe to failover the master without data loss. However modules may generate traffic by calling [`RedisModule\_Call()`](#RedisModule\_Call) with the "!" flag, or by calling [`RedisModule\_Replicate()`](#RedisModule\_Replicate), in a context outside commands execution, for instance in timeout callbacks, threads safe contexts, and so forth. When modules will generate too much traffic, it will be hard for the master and replicas offset to match, because there is more data to send in the replication channel. So modules may want to try to avoid very heavy background work that has the effect of creating data to the replication channel, when this function returns true. This is mostly useful for modules that have background garbage collection tasks, or that do writes and replicate such writes periodically in timer callbacks or other periodic callbacks. ### `RedisModule\_SelectDb` int RedisModule\_SelectDb(RedisModuleCtx \*ctx, int newid); \*\*Available since:\*\* 4.0.0 Change the currently selected DB. Returns an error if the id is out of range. Note that the client will retain the currently selected DB even after the Redis command implemented by the module calling this function returns. If the module command wishes to change something in a different DB and returns back to the original one, it should call [`RedisModule\_GetSelectedDb()`](#RedisModule\_GetSelectedDb) before in order to restore the old DB number before returning. ### `RedisModule\_KeyExists` int RedisModule\_KeyExists(RedisModuleCtx \*ctx, robj \*keyname); \*\*Available since:\*\* 7.0.0 Check if a key exists, without affecting its last access time. This is equivalent to calling [`RedisModule\_OpenKey`](#RedisModule\_OpenKey) with the mode `REDISMODULE\_READ` | `REDISMODULE\_OPEN\_KEY\_NOTOUCH`, then checking if NULL was returned and, if not, calling [`RedisModule\_CloseKey`](#RedisModule\_CloseKey) on the opened key. ### `RedisModule\_OpenKey` RedisModuleKey \*RedisModule\_OpenKey(RedisModuleCtx \*ctx, robj \*keyname, int mode); \*\*Available since:\*\* 4.0.0 Return a handle representing a Redis key, so that it is possible to call other APIs with the key handle as argument to perform operations on the key. The return value is the handle representing the key, that must be closed with [`RedisModule\_CloseKey()`](#RedisModule\_CloseKey). If the key does not exist | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.01775055192410946,
-0.0677180364727974,
-0.12357791513204575,
0.02532222867012024,
0.02062518335878849,
-0.06079534813761711,
0.019237706437706947,
-0.08075171709060669,
-0.005845659412443638,
0.021345507353544235,
0.04146202281117439,
0.019663006067276,
0.08321532607078552,
-0.06981576... | 0.091243 |
4.0.0 Return a handle representing a Redis key, so that it is possible to call other APIs with the key handle as argument to perform operations on the key. The return value is the handle representing the key, that must be closed with [`RedisModule\_CloseKey()`](#RedisModule\_CloseKey). If the key does not exist and `REDISMODULE\_WRITE` mode is requested, the handle is still returned, since it is possible to perform operations on a yet not existing key (that will be created, for example, after a list push operation). If the mode is just `REDISMODULE\_READ` instead, and the key does not exist, NULL is returned. However it is still safe to call [`RedisModule\_CloseKey()`](#RedisModule\_CloseKey) and [`RedisModule\_KeyType()`](#RedisModule\_KeyType) on a NULL value. Extra flags that can be pass to the API under the mode argument: \* `REDISMODULE\_OPEN\_KEY\_NOTOUCH` - Avoid touching the LRU/LFU of the key when opened. \* `REDISMODULE\_OPEN\_KEY\_NONOTIFY` - Don't trigger keyspace event on key misses. \* `REDISMODULE\_OPEN\_KEY\_NOSTATS` - Don't update keyspace hits/misses counters. \* `REDISMODULE\_OPEN\_KEY\_NOEXPIRE` - Avoid deleting lazy expired keys. \* `REDISMODULE\_OPEN\_KEY\_NOEFFECTS` - Avoid any effects from fetching the key. ### `RedisModule\_GetOpenKeyModesAll` int RedisModule\_GetOpenKeyModesAll(void); \*\*Available since:\*\* 7.2.0 Returns the full OpenKey modes mask, using the return value the module can check if a certain set of OpenKey modes are supported by the redis server version in use. Example: int supportedMode = RedisModule\_GetOpenKeyModesAll(); if (supportedMode & REDISMODULE\_OPEN\_KEY\_NOTOUCH) { // REDISMODULE\_OPEN\_KEY\_NOTOUCH is supported } else{ // REDISMODULE\_OPEN\_KEY\_NOTOUCH is not supported } ### `RedisModule\_CloseKey` void RedisModule\_CloseKey(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Close a key handle. ### `RedisModule\_KeyType` int RedisModule\_KeyType(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Return the type of the key. If the key pointer is NULL then `REDISMODULE\_KEYTYPE\_EMPTY` is returned. ### `RedisModule\_ValueLength` size\_t RedisModule\_ValueLength(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Return the length of the value associated with the key. For strings this is the length of the string. For all the other types is the number of elements (just counting keys for hashes). If the key pointer is NULL or the key is empty, zero is returned. ### `RedisModule\_DeleteKey` int RedisModule\_DeleteKey(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 If the key is open for writing, remove it, and setup the key to accept new writes as an empty key (that will be created on demand). On success `REDISMODULE\_OK` is returned. If the key is not open for writing `REDISMODULE\_ERR` is returned. ### `RedisModule\_UnlinkKey` int RedisModule\_UnlinkKey(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.7 If the key is open for writing, unlink it (that is delete it in a non-blocking way, not reclaiming memory immediately) and setup the key to accept new writes as an empty key (that will be created on demand). On success `REDISMODULE\_OK` is returned. If the key is not open for writing `REDISMODULE\_ERR` is returned. ### `RedisModule\_GetExpire` mstime\_t RedisModule\_GetExpire(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Return the key expire value, as milliseconds of remaining TTL. If no TTL is associated with the key or if the key is empty, `REDISMODULE\_NO\_EXPIRE` is returned. ### `RedisModule\_SetExpire` int RedisModule\_SetExpire(RedisModuleKey \*key, mstime\_t expire); \*\*Available since:\*\* 4.0.0 Set a new expire for the key. If the special expire `REDISMODULE\_NO\_EXPIRE` is set, the expire is cancelled if there was one (the same as the PERSIST command). Note that the expire must be provided as a positive integer representing the number of milliseconds of TTL the key should have. The function returns `REDISMODULE\_OK` on success or `REDISMODULE\_ERR` if the key was not open for writing or is an empty key. ### `RedisModule\_GetAbsExpire` mstime\_t RedisModule\_GetAbsExpire(RedisModuleKey \*key); \*\*Available since:\*\* 6.2.2 Return the key expire value, as absolute Unix timestamp. If no TTL is associated with the key or if the key is empty, `REDISMODULE\_NO\_EXPIRE` is returned. ### `RedisModule\_SetAbsExpire` int RedisModule\_SetAbsExpire(RedisModuleKey \*key, mstime\_t expire); \*\*Available since:\*\* 6.2.2 | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.018454015254974365,
0.015705745667219162,
-0.09635510295629501,
0.08272357285022736,
-0.04336144030094147,
-0.07548978924751282,
0.07473786175251007,
0.01415187492966652,
-0.013319650664925575,
-0.009139424189925194,
0.012903264723718166,
0.008741800673305988,
0.025126421824097633,
-0.0... | 0.085268 |
writing or is an empty key. ### `RedisModule\_GetAbsExpire` mstime\_t RedisModule\_GetAbsExpire(RedisModuleKey \*key); \*\*Available since:\*\* 6.2.2 Return the key expire value, as absolute Unix timestamp. If no TTL is associated with the key or if the key is empty, `REDISMODULE\_NO\_EXPIRE` is returned. ### `RedisModule\_SetAbsExpire` int RedisModule\_SetAbsExpire(RedisModuleKey \*key, mstime\_t expire); \*\*Available since:\*\* 6.2.2 Set a new expire for the key. If the special expire `REDISMODULE\_NO\_EXPIRE` is set, the expire is cancelled if there was one (the same as the PERSIST command). Note that the expire must be provided as a positive integer representing the absolute Unix timestamp the key should have. The function returns `REDISMODULE\_OK` on success or `REDISMODULE\_ERR` if the key was not open for writing or is an empty key. ### `RedisModule\_ResetDataset` void RedisModule\_ResetDataset(int restart\_aof, int async); \*\*Available since:\*\* 6.0.0 Performs similar operation to FLUSHALL, and optionally start a new AOF file (if enabled) If `restart\_aof` is true, you must make sure the command that triggered this call is not propagated to the AOF file. When async is set to true, db contents will be freed by a background thread. ### `RedisModule\_DbSize` unsigned long long RedisModule\_DbSize(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Returns the number of keys in the current db. ### `RedisModule\_RandomKey` RedisModuleString \*RedisModule\_RandomKey(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Returns a name of a random key, or NULL if current db is empty. ### `RedisModule\_GetKeyNameFromOptCtx` const RedisModuleString \*RedisModule\_GetKeyNameFromOptCtx(RedisModuleKeyOptCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the name of the key currently being processed. ### `RedisModule\_GetToKeyNameFromOptCtx` const RedisModuleString \*RedisModule\_GetToKeyNameFromOptCtx(RedisModuleKeyOptCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the name of the target key currently being processed. ### `RedisModule\_GetDbIdFromOptCtx` int RedisModule\_GetDbIdFromOptCtx(RedisModuleKeyOptCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the dbid currently being processed. ### `RedisModule\_GetToDbIdFromOptCtx` int RedisModule\_GetToDbIdFromOptCtx(RedisModuleKeyOptCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the target dbid currently being processed. ## Key API for String type See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the length of a string. ### `RedisModule\_StringSet` int RedisModule\_StringSet(RedisModuleKey \*key, RedisModuleString \*str); \*\*Available since:\*\* 4.0.0 If the key is open for writing, set the specified string 'str' as the value of the key, deleting the old value if any. On success `REDISMODULE\_OK` is returned. If the key is not open for writing or there is an active iterator, `REDISMODULE\_ERR` is returned. ### `RedisModule\_StringDMA` char \*RedisModule\_StringDMA(RedisModuleKey \*key, size\_t \*len, int mode); \*\*Available since:\*\* 4.0.0 Prepare the key associated string value for DMA access, and returns a pointer and size (by reference), that the user can use to read or modify the string in-place accessing it directly via pointer. The 'mode' is composed by bitwise OR-ing the following flags: REDISMODULE\_READ -- Read access REDISMODULE\_WRITE -- Write access If the DMA is not requested for writing, the pointer returned should only be accessed in a read-only fashion. On error (wrong type) NULL is returned. DMA access rules: 1. No other key writing function should be called since the moment the pointer is obtained, for all the time we want to use DMA access to read or modify the string. 2. Each time [`RedisModule\_StringTruncate()`](#RedisModule\_StringTruncate) is called, to continue with the DMA access, [`RedisModule\_StringDMA()`](#RedisModule\_StringDMA) should be called again to re-obtain a new pointer and length. 3. If the returned pointer is not NULL, but the length is zero, no byte can be touched (the string is empty, or the key itself is empty) so a [`RedisModule\_StringTruncate()`](#RedisModule\_StringTruncate) call should be used if there is to enlarge the string, and later call StringDMA() again to get the pointer. ### `RedisModule\_StringTruncate` int RedisModule\_StringTruncate(RedisModuleKey \*key, size\_t newlen); \*\*Available since:\*\* 4.0.0 If the key is open for writing and is of string type, resize it, padding with zero bytes if the new length is greater than the old one. After this call, [`RedisModule\_StringDMA()`](#RedisModule\_StringDMA) | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.02657424472272396,
-0.0019003249472007155,
-0.09131333231925964,
0.04161882400512695,
-0.017219722270965576,
-0.0016805388731881976,
0.025588031858205795,
0.09896763414144516,
0.029446396976709366,
-0.01186672318726778,
0.06702416390180588,
-0.020856890827417374,
0.04457651078701019,
-0... | 0.136608 |
later call StringDMA() again to get the pointer. ### `RedisModule\_StringTruncate` int RedisModule\_StringTruncate(RedisModuleKey \*key, size\_t newlen); \*\*Available since:\*\* 4.0.0 If the key is open for writing and is of string type, resize it, padding with zero bytes if the new length is greater than the old one. After this call, [`RedisModule\_StringDMA()`](#RedisModule\_StringDMA) must be called again to continue DMA access with the new pointer. The function returns `REDISMODULE\_OK` on success, and `REDISMODULE\_ERR` on error, that is, the key is not open for writing, is not a string or resizing for more than 512 MB is requested. If the key is empty, a string key is created with the new string value unless the new length value requested is zero. ## Key API for List type Many of the list functions access elements by index. Since a list is in essence a doubly-linked list, accessing elements by index is generally an O(N) operation. However, if elements are accessed sequentially or with indices close together, the functions are optimized to seek the index from the previous index, rather than seeking from the ends of the list. This enables iteration to be done efficiently using a simple for loop: long n = RedisModule\_ValueLength(key); for (long i = 0; i < n; i++) { RedisModuleString \*elem = RedisModule\_ListGet(key, i); // Do stuff... } Note that after modifying a list using [`RedisModule\_ListPop`](#RedisModule\_ListPop), [`RedisModule\_ListSet`](#RedisModule\_ListSet) or [`RedisModule\_ListInsert`](#RedisModule\_ListInsert), the internal iterator is invalidated so the next operation will require a linear seek. Modifying a list in any another way, for example using [`RedisModule\_Call()`](#RedisModule\_Call), while a key is open will confuse the internal iterator and may cause trouble if the key is used after such modifications. The key must be reopened in this case. See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the length of a list. ### `RedisModule\_ListPush` int RedisModule\_ListPush(RedisModuleKey \*key, int where, RedisModuleString \*ele); \*\*Available since:\*\* 4.0.0 Push an element into a list, on head or tail depending on 'where' argument (`REDISMODULE\_LIST\_HEAD` or `REDISMODULE\_LIST\_TAIL`). If the key refers to an empty key opened for writing, the key is created. On success, `REDISMODULE\_OK` is returned. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key or ele is NULL. - ENOTSUP if the key is of another type than list. - EBADF if the key is not opened for writing. Note: Before Redis 7.0, `errno` was not set by this function. ### `RedisModule\_ListPop` RedisModuleString \*RedisModule\_ListPop(RedisModuleKey \*key, int where); \*\*Available since:\*\* 4.0.0 Pop an element from the list, and returns it as a module string object that the user should be free with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory. The `where` argument specifies if the element should be popped from the beginning or the end of the list (`REDISMODULE\_LIST\_HEAD` or `REDISMODULE\_LIST\_TAIL`). On failure, the command returns NULL and sets `errno` as follows: - EINVAL if key is NULL. - ENOTSUP if the key is empty or of another type than list. - EBADF if the key is not opened for writing. Note: Before Redis 7.0, `errno` was not set by this function. ### `RedisModule\_ListGet` RedisModuleString \*RedisModule\_ListGet(RedisModuleKey \*key, long index); \*\*Available since:\*\* 7.0.0 Returns the element at index `index` in the list stored at `key`, like the LINDEX command. The element should be free'd using [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or using automatic memory management. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth. When no value is found at the given key and index, NULL is returned | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.008411419577896595,
0.03546658903360367,
-0.0063676731660962105,
0.015674546360969543,
-0.10367430001497269,
-0.06403008848428726,
0.07659170776605606,
0.11149528622627258,
-0.05335797369480133,
-0.003950731363147497,
0.019815780222415924,
0.026391642168164253,
-0.02205478772521019,
-0.0... | 0.123903 |
element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth. When no value is found at the given key and index, NULL is returned and `errno` is set as follows: - EINVAL if key is NULL. - ENOTSUP if the key is not a list. - EBADF if the key is not opened for reading. - EDOM if the index is not a valid index in the list. ### `RedisModule\_ListSet` int RedisModule\_ListSet(RedisModuleKey \*key, long index, RedisModuleString \*value); \*\*Available since:\*\* 7.0.0 Replaces the element at index `index` in the list stored at `key`. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth. On success, `REDISMODULE\_OK` is returned. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key or value is NULL. - ENOTSUP if the key is not a list. - EBADF if the key is not opened for writing. - EDOM if the index is not a valid index in the list. ### `RedisModule\_ListInsert` int RedisModule\_ListInsert(RedisModuleKey \*key, long index, RedisModuleString \*value); \*\*Available since:\*\* 7.0.0 Inserts an element at the given index. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth. The index is the element's index after inserting it. On success, `REDISMODULE\_OK` is returned. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key or value is NULL. - ENOTSUP if the key of another type than list. - EBADF if the key is not opened for writing. - EDOM if the index is not a valid index in the list. ### `RedisModule\_ListDelete` int RedisModule\_ListDelete(RedisModuleKey \*key, long index); \*\*Available since:\*\* 7.0.0 Removes an element at the given index. The index is 0-based. A negative index can also be used, counting from the end of the list. On success, `REDISMODULE\_OK` is returned. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key or value is NULL. - ENOTSUP if the key is not a list. - EBADF if the key is not opened for writing. - EDOM if the index is not a valid index in the list. ## Key API for Sorted Set type See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the length of a sorted set. ### `RedisModule\_ZsetAdd` int RedisModule\_ZsetAdd(RedisModuleKey \*key, double score, RedisModuleString \*ele, int \*flagsptr); \*\*Available since:\*\* 4.0.0 Add a new element into a sorted set, with the specified 'score'. If the element already exists, the score is updated. A new sorted set is created at value if the key is an empty open key setup for writing. Additional flags can be passed to the function via a pointer, the flags are both used to receive input and to communicate state when the function returns. 'flagsptr' can be NULL if no special flags are used. The input flags are: REDISMODULE\_ZADD\_XX: Element must already exist. Do nothing otherwise. REDISMODULE\_ZADD\_NX: Element must not exist. Do nothing otherwise. REDISMODULE\_ZADD\_GT: If element exists, new score must be greater than the current score. Do nothing otherwise. Can optionally be combined with XX. REDISMODULE\_ZADD\_LT: If element exists, new score must be less | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.006403790321201086,
0.058897461742162704,
-0.05228128284215927,
0.04400653392076492,
0.006912376265972853,
-0.05806422233581543,
0.12568123638629913,
0.08343848586082458,
-0.029778651893138885,
-0.03446340560913086,
0.05470287427306175,
-0.034299347549676895,
0.041785828769207,
-0.084363... | 0.198226 |
input flags are: REDISMODULE\_ZADD\_XX: Element must already exist. Do nothing otherwise. REDISMODULE\_ZADD\_NX: Element must not exist. Do nothing otherwise. REDISMODULE\_ZADD\_GT: If element exists, new score must be greater than the current score. Do nothing otherwise. Can optionally be combined with XX. REDISMODULE\_ZADD\_LT: If element exists, new score must be less than the current score. Do nothing otherwise. Can optionally be combined with XX. The output flags are: REDISMODULE\_ZADD\_ADDED: The new element was added to the sorted set. REDISMODULE\_ZADD\_UPDATED: The score of the element was updated. REDISMODULE\_ZADD\_NOP: No operation was performed because XX or NX flags. On success the function returns `REDISMODULE\_OK`. On the following errors `REDISMODULE\_ERR` is returned: \* The key was not opened for writing. \* The key is of the wrong type. \* 'score' double value is not a number (NaN). ### `RedisModule\_ZsetIncrby` int RedisModule\_ZsetIncrby(RedisModuleKey \*key, double score, RedisModuleString \*ele, int \*flagsptr, double \*newscore); \*\*Available since:\*\* 4.0.0 This function works exactly like [`RedisModule\_ZsetAdd()`](#RedisModule\_ZsetAdd), but instead of setting a new score, the score of the existing element is incremented, or if the element does not already exist, it is added assuming the old score was zero. The input and output flags, and the return value, have the same exact meaning, with the only difference that this function will return `REDISMODULE\_ERR` even when 'score' is a valid double number, but adding it to the existing score results into a NaN (not a number) condition. This function has an additional field 'newscore', if not NULL is filled with the new score of the element after the increment, if no error is returned. ### `RedisModule\_ZsetRem` int RedisModule\_ZsetRem(RedisModuleKey \*key, RedisModuleString \*ele, int \*deleted); \*\*Available since:\*\* 4.0.0 Remove the specified element from the sorted set. The function returns `REDISMODULE\_OK` on success, and `REDISMODULE\_ERR` on one of the following conditions: \* The key was not opened for writing. \* The key is of the wrong type. The return value does NOT indicate the fact the element was really removed (since it existed) or not, just if the function was executed with success. In order to know if the element was removed, the additional argument 'deleted' must be passed, that populates the integer by reference setting it to 1 or 0 depending on the outcome of the operation. The 'deleted' argument can be NULL if the caller is not interested to know if the element was really removed. Empty keys will be handled correctly by doing nothing. ### `RedisModule\_ZsetScore` int RedisModule\_ZsetScore(RedisModuleKey \*key, RedisModuleString \*ele, double \*score); \*\*Available since:\*\* 4.0.0 On success retrieve the double score associated at the sorted set element 'ele' and returns `REDISMODULE\_OK`. Otherwise `REDISMODULE\_ERR` is returned to signal one of the following conditions: \* There is no such element 'ele' in the sorted set. \* The key is not a sorted set. \* The key is an open empty key. ## Key API for Sorted Set iterator ### `RedisModule\_ZsetRangeStop` void RedisModule\_ZsetRangeStop(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Stop a sorted set iteration. ### `RedisModule\_ZsetRangeEndReached` int RedisModule\_ZsetRangeEndReached(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Return the "End of range" flag value to signal the end of the iteration. ### `RedisModule\_ZsetFirstInScoreRange` int RedisModule\_ZsetFirstInScoreRange(RedisModuleKey \*key, double min, double max, int minex, int maxex); \*\*Available since:\*\* 4.0.0 Setup a sorted set iterator seeking the first element in the specified range. Returns `REDISMODULE\_OK` if the iterator was correctly initialized otherwise `REDISMODULE\_ERR` is returned in the following conditions: 1. The value stored at key is not a sorted set or the key is empty. The range is specified according to the two double values 'min' and 'max'. Both can be infinite using the following two macros: \* `REDISMODULE\_POSITIVE\_INFINITE` for positive infinite value \* `REDISMODULE\_NEGATIVE\_INFINITE` | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.014377312734723091,
0.033998604863882065,
-0.059942469000816345,
0.03859624266624451,
0.007918975315988064,
-0.00814898032695055,
0.07823874801397324,
-0.027730541303753853,
-0.012759384699165821,
-0.008030647411942482,
0.044034674763679504,
-0.019312653690576553,
0.06832152605056763,
-... | 0.117105 |
in the following conditions: 1. The value stored at key is not a sorted set or the key is empty. The range is specified according to the two double values 'min' and 'max'. Both can be infinite using the following two macros: \* `REDISMODULE\_POSITIVE\_INFINITE` for positive infinite value \* `REDISMODULE\_NEGATIVE\_INFINITE` for negative infinite value 'minex' and 'maxex' parameters, if true, respectively setup a range where the min and max value are exclusive (not included) instead of inclusive. ### `RedisModule\_ZsetLastInScoreRange` int RedisModule\_ZsetLastInScoreRange(RedisModuleKey \*key, double min, double max, int minex, int maxex); \*\*Available since:\*\* 4.0.0 Exactly like [`RedisModule\_ZsetFirstInScoreRange()`](#RedisModule\_ZsetFirstInScoreRange) but the last element of the range is selected for the start of the iteration instead. ### `RedisModule\_ZsetFirstInLexRange` int RedisModule\_ZsetFirstInLexRange(RedisModuleKey \*key, RedisModuleString \*min, RedisModuleString \*max); \*\*Available since:\*\* 4.0.0 Setup a sorted set iterator seeking the first element in the specified lexicographical range. Returns `REDISMODULE\_OK` if the iterator was correctly initialized otherwise `REDISMODULE\_ERR` is returned in the following conditions: 1. The value stored at key is not a sorted set or the key is empty. 2. The lexicographical range 'min' and 'max' format is invalid. 'min' and 'max' should be provided as two `RedisModuleString` objects in the same format as the parameters passed to the ZRANGEBYLEX command. The function does not take ownership of the objects, so they can be released ASAP after the iterator is setup. ### `RedisModule\_ZsetLastInLexRange` int RedisModule\_ZsetLastInLexRange(RedisModuleKey \*key, RedisModuleString \*min, RedisModuleString \*max); \*\*Available since:\*\* 4.0.0 Exactly like [`RedisModule\_ZsetFirstInLexRange()`](#RedisModule\_ZsetFirstInLexRange) but the last element of the range is selected for the start of the iteration instead. ### `RedisModule\_ZsetRangeCurrentElement` RedisModuleString \*RedisModule\_ZsetRangeCurrentElement(RedisModuleKey \*key, double \*score); \*\*Available since:\*\* 4.0.0 Return the current sorted set element of an active sorted set iterator or NULL if the range specified in the iterator does not include any element. ### `RedisModule\_ZsetRangeNext` int RedisModule\_ZsetRangeNext(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Go to the next element of the sorted set iterator. Returns 1 if there was a next element, 0 if we are already at the latest element or the range does not include any item at all. ### `RedisModule\_ZsetRangePrev` int RedisModule\_ZsetRangePrev(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Go to the previous element of the sorted set iterator. Returns 1 if there was a previous element, 0 if we are already at the first element or the range does not include any item at all. ## Key API for Hash type See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the number of fields in a hash. ### `RedisModule\_HashSet` int RedisModule\_HashSet(RedisModuleKey \*key, int flags, ...); \*\*Available since:\*\* 4.0.0 Set the field of the specified hash field to the specified value. If the key is an empty key open for writing, it is created with an empty hash value, in order to set the specified field. The function is variadic and the user must specify pairs of field names and values, both as `RedisModuleString` pointers (unless the CFIELD option is set, see later). At the end of the field/value-ptr pairs, NULL must be specified as last argument to signal the end of the arguments in the variadic function. Example to set the hash argv[1] to the value argv[2]: RedisModule\_HashSet(key,REDISMODULE\_HASH\_NONE,argv[1],argv[2],NULL); The function can also be used in order to delete fields (if they exist) by setting them to the specified value of `REDISMODULE\_HASH\_DELETE`: RedisModule\_HashSet(key,REDISMODULE\_HASH\_NONE,argv[1], REDISMODULE\_HASH\_DELETE,NULL); The behavior of the command changes with the specified flags, that can be set to `REDISMODULE\_HASH\_NONE` if no special behavior is needed. REDISMODULE\_HASH\_NX: The operation is performed only if the field was not already existing in the hash. REDISMODULE\_HASH\_XX: The operation is performed only if the field was already existing, so that a new value could be associated to an existing filed, but no new fields are | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.006598243024200201,
0.054601702839136124,
-0.024960018694400787,
-0.0009194466983899474,
-0.0455324687063694,
-0.02166581153869629,
0.04674384742975235,
0.0642293244600296,
-0.09249594062566757,
-0.050633519887924194,
0.028813453391194344,
-0.0573241263628006,
0.1305939108133316,
-0.040... | 0.022522 |
no special behavior is needed. REDISMODULE\_HASH\_NX: The operation is performed only if the field was not already existing in the hash. REDISMODULE\_HASH\_XX: The operation is performed only if the field was already existing, so that a new value could be associated to an existing filed, but no new fields are created. REDISMODULE\_HASH\_CFIELDS: The field names passed are null terminated C strings instead of RedisModuleString objects. REDISMODULE\_HASH\_COUNT\_ALL: Include the number of inserted fields in the returned number, in addition to the number of updated and deleted fields. (Added in Redis 6.2.) Unless NX is specified, the command overwrites the old field value with the new one. When using `REDISMODULE\_HASH\_CFIELDS`, field names are reported using normal C strings, so for example to delete the field "foo" the following code can be used: RedisModule\_HashSet(key,REDISMODULE\_HASH\_CFIELDS,"foo", REDISMODULE\_HASH\_DELETE,NULL); Return value: The number of fields existing in the hash prior to the call, which have been updated (its old value has been replaced by a new value) or deleted. If the flag `REDISMODULE\_HASH\_COUNT\_ALL` is set, inserted fields not previously existing in the hash are also counted. If the return value is zero, `errno` is set (since Redis 6.2) as follows: - EINVAL if any unknown flags are set or if key is NULL. - ENOTSUP if the key is associated with a non Hash value. - EBADF if the key was not opened for writing. - ENOENT if no fields were counted as described under Return value above. This is not actually an error. The return value can be zero if all fields were just created and the `COUNT\_ALL` flag was unset, or if changes were held back due to the NX and XX flags. NOTICE: The return value semantics of this function are very different between Redis 6.2 and older versions. Modules that use it should determine the Redis version and handle it accordingly. ### `RedisModule\_HashGet` int RedisModule\_HashGet(RedisModuleKey \*key, int flags, ...); \*\*Available since:\*\* 4.0.0 Get fields from a hash value. This function is called using a variable number of arguments, alternating a field name (as a `RedisModuleString` pointer) with a pointer to a `RedisModuleString` pointer, that is set to the value of the field if the field exists, or NULL if the field does not exist. At the end of the field/value-ptr pairs, NULL must be specified as last argument to signal the end of the arguments in the variadic function. This is an example usage: RedisModuleString \*first, \*second; RedisModule\_HashGet(mykey,REDISMODULE\_HASH\_NONE,argv[1],&first, argv[2],&second,NULL); As with [`RedisModule\_HashSet()`](#RedisModule\_HashSet) the behavior of the command can be specified passing flags different than `REDISMODULE\_HASH\_NONE`: `REDISMODULE\_HASH\_CFIELDS`: field names as null terminated C strings. `REDISMODULE\_HASH\_EXISTS`: instead of setting the value of the field expecting a `RedisModuleString` pointer to pointer, the function just reports if the field exists or not and expects an integer pointer as the second element of each pair. Example of `REDISMODULE\_HASH\_CFIELDS`: RedisModuleString \*username, \*hashedpass; RedisModule\_HashGet(mykey,REDISMODULE\_HASH\_CFIELDS,"username",&username,"hp",&hashedpass, NULL); Example of `REDISMODULE\_HASH\_EXISTS`: int exists; RedisModule\_HashGet(mykey,REDISMODULE\_HASH\_EXISTS,argv[1],&exists,NULL); The function returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` if the key is not a hash value. Memory management: The returned `RedisModuleString` objects should be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString), or by enabling automatic memory management. ## Key API for Stream type For an introduction to streams, see [https://redis.io/topics/streams-intro](https://redis.io/topics/streams-intro). The type `RedisModuleStreamID`, which is used in stream functions, is a struct with two 64-bit fields and is defined as typedef struct RedisModuleStreamID { uint64\_t ms; uint64\_t seq; } RedisModuleStreamID; See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the length of a stream, and the conversion functions [`RedisModule\_StringToStreamID()`](#RedisModule\_StringToStreamID) and [`RedisModule\_CreateStringFromStreamID()`](#RedisModule\_CreateStringFromStreamID). ### `RedisModule\_StreamAdd` int RedisModule\_StreamAdd(RedisModuleKey \*key, int flags, RedisModuleStreamID \*id, RedisModuleString \*\*argv, long numfields); \*\*Available since:\*\* 6.2.0 Adds an entry to a stream. Like XADD without trimming. | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.006916575133800507,
-0.02006099745631218,
-0.05798952654004097,
0.026477821171283722,
0.00038967415457591414,
-0.0745985135436058,
0.04639989137649536,
-0.06396129727363586,
0.09952203929424286,
-0.025558466091752052,
0.039694320410490036,
0.04795091599225998,
0.035240910947322845,
-0.06... | 0.07785 |
{ uint64\_t ms; uint64\_t seq; } RedisModuleStreamID; See also [`RedisModule\_ValueLength()`](#RedisModule\_ValueLength), which returns the length of a stream, and the conversion functions [`RedisModule\_StringToStreamID()`](#RedisModule\_StringToStreamID) and [`RedisModule\_CreateStringFromStreamID()`](#RedisModule\_CreateStringFromStreamID). ### `RedisModule\_StreamAdd` int RedisModule\_StreamAdd(RedisModuleKey \*key, int flags, RedisModuleStreamID \*id, RedisModuleString \*\*argv, long numfields); \*\*Available since:\*\* 6.2.0 Adds an entry to a stream. Like XADD without trimming. - `key`: The key where the stream is (or will be) stored - `flags`: A bit field of - `REDISMODULE\_STREAM\_ADD\_AUTOID`: Assign a stream ID automatically, like `\*` in the XADD command. - `id`: If the `AUTOID` flag is set, this is where the assigned ID is returned. Can be NULL if `AUTOID` is set, if you don't care to receive the ID. If `AUTOID` is not set, this is the requested ID. - `argv`: A pointer to an array of size `numfields \* 2` containing the fields and values. - `numfields`: The number of field-value pairs in `argv`. Returns `REDISMODULE\_OK` if an entry has been added. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with invalid arguments - ENOTSUP if the key refers to a value of a type other than stream - EBADF if the key was not opened for writing - EDOM if the given ID was 0-0 or not greater than all other IDs in the stream (only if the AUTOID flag is unset) - EFBIG if the stream has reached the last possible ID - ERANGE if the elements are too large to be stored. ### `RedisModule\_StreamDelete` int RedisModule\_StreamDelete(RedisModuleKey \*key, RedisModuleStreamID \*id); \*\*Available since:\*\* 6.2.0 Deletes an entry from a stream. - `key`: A key opened for writing, with no stream iterator started. - `id`: The stream ID of the entry to delete. Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with invalid arguments - ENOTSUP if the key refers to a value of a type other than stream or if the key is empty - EBADF if the key was not opened for writing or if a stream iterator is associated with the key - ENOENT if no entry with the given stream ID exists See also [`RedisModule\_StreamIteratorDelete()`](#RedisModule\_StreamIteratorDelete) for deleting the current entry while iterating using a stream iterator. ### `RedisModule\_StreamIteratorStart` int RedisModule\_StreamIteratorStart(RedisModuleKey \*key, int flags, RedisModuleStreamID \*start, RedisModuleStreamID \*end); \*\*Available since:\*\* 6.2.0 Sets up a stream iterator. - `key`: The stream key opened for reading using [`RedisModule\_OpenKey()`](#RedisModule\_OpenKey). - `flags`: - `REDISMODULE\_STREAM\_ITERATOR\_EXCLUSIVE`: Don't include `start` and `end` in the iterated range. - `REDISMODULE\_STREAM\_ITERATOR\_REVERSE`: Iterate in reverse order, starting from the `end` of the range. - `start`: The lower bound of the range. Use NULL for the beginning of the stream. - `end`: The upper bound of the range. Use NULL for the end of the stream. Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with invalid arguments - ENOTSUP if the key refers to a value of a type other than stream or if the key is empty - EBADF if the key was not opened for writing or if a stream iterator is already associated with the key - EDOM if `start` or `end` is outside the valid range Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` if the key doesn't refer to a stream or if invalid arguments were given. The stream IDs are retrieved using [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) and for each stream ID, the fields and values are retrieved using [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField). The iterator is freed by calling [`RedisModule\_StreamIteratorStop()`](#RedisModule\_StreamIteratorStop). Example (error handling omitted): RedisModule\_StreamIteratorStart(key, 0, startid\_ptr, endid\_ptr); RedisModuleStreamID id; long numfields; while (RedisModule\_StreamIteratorNextID(key, &id, &numfields) == REDISMODULE\_OK) { | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.04003659263253212,
0.04790028557181358,
-0.11337536573410034,
-0.04660731181502342,
-0.025768080726265907,
-0.02428930252790451,
0.06792505830526352,
0.0720953494310379,
-0.013948936946690083,
-0.04086000472307205,
-0.011413266882300377,
-0.09431483596563339,
0.027374302968382835,
-0.080... | 0.086617 |
invalid arguments were given. The stream IDs are retrieved using [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) and for each stream ID, the fields and values are retrieved using [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField). The iterator is freed by calling [`RedisModule\_StreamIteratorStop()`](#RedisModule\_StreamIteratorStop). Example (error handling omitted): RedisModule\_StreamIteratorStart(key, 0, startid\_ptr, endid\_ptr); RedisModuleStreamID id; long numfields; while (RedisModule\_StreamIteratorNextID(key, &id, &numfields) == REDISMODULE\_OK) { RedisModuleString \*field, \*value; while (RedisModule\_StreamIteratorNextField(key, &field, &value) == REDISMODULE\_OK) { // // ... Do stuff ... // RedisModule\_FreeString(ctx, field); RedisModule\_FreeString(ctx, value); } } RedisModule\_StreamIteratorStop(key); ### `RedisModule\_StreamIteratorStop` int RedisModule\_StreamIteratorStop(RedisModuleKey \*key); \*\*Available since:\*\* 6.2.0 Stops a stream iterator created using [`RedisModule\_StreamIteratorStart()`](#RedisModule\_StreamIteratorStart) and reclaims its memory. Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with a NULL key - ENOTSUP if the key refers to a value of a type other than stream or if the key is empty - EBADF if the key was not opened for writing or if no stream iterator is associated with the key ### `RedisModule\_StreamIteratorNextID` int RedisModule\_StreamIteratorNextID(RedisModuleKey \*key, RedisModuleStreamID \*id, long \*numfields); \*\*Available since:\*\* 6.2.0 Finds the next stream entry and returns its stream ID and the number of fields. - `key`: Key for which a stream iterator has been started using [`RedisModule\_StreamIteratorStart()`](#RedisModule\_StreamIteratorStart). - `id`: The stream ID returned. NULL if you don't care. - `numfields`: The number of fields in the found stream entry. NULL if you don't care. Returns `REDISMODULE\_OK` and sets `\*id` and `\*numfields` if an entry was found. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with a NULL key - ENOTSUP if the key refers to a value of a type other than stream or if the key is empty - EBADF if no stream iterator is associated with the key - ENOENT if there are no more entries in the range of the iterator In practice, if [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) is called after a successful call to [`RedisModule\_StreamIteratorStart()`](#RedisModule\_StreamIteratorStart) and with the same key, it is safe to assume that an `REDISMODULE\_ERR` return value means that there are no more entries. Use [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField) to retrieve the fields and values. See the example at [`RedisModule\_StreamIteratorStart()`](#RedisModule\_StreamIteratorStart). ### `RedisModule\_StreamIteratorNextField` int RedisModule\_StreamIteratorNextField(RedisModuleKey \*key, RedisModuleString \*\*field\_ptr, RedisModuleString \*\*value\_ptr); \*\*Available since:\*\* 6.2.0 Retrieves the next field of the current stream ID and its corresponding value in a stream iteration. This function should be called repeatedly after calling [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) to fetch each field-value pair. - `key`: Key where a stream iterator has been started. - `field\_ptr`: This is where the field is returned. - `value\_ptr`: This is where the value is returned. Returns `REDISMODULE\_OK` and points `\*field\_ptr` and `\*value\_ptr` to freshly allocated `RedisModuleString` objects. The string objects are freed automatically when the callback finishes if automatic memory is enabled. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if called with a NULL key - ENOTSUP if the key refers to a value of a type other than stream or if the key is empty - EBADF if no stream iterator is associated with the key - ENOENT if there are no more fields in the current stream entry In practice, if [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField) is called after a successful call to [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) and with the same key, it is safe to assume that an `REDISMODULE\_ERR` return value means that there are no more fields. See the example at [`RedisModule\_StreamIteratorStart()`](#RedisModule\_StreamIteratorStart). ### `RedisModule\_StreamIteratorDelete` int RedisModule\_StreamIteratorDelete(RedisModuleKey \*key); \*\*Available since:\*\* 6.2.0 Deletes the current stream entry while iterating. This function can be called after [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) or after any calls to [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField). Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key is NULL - ENOTSUP | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.026078984141349792,
0.03871086612343788,
-0.08160529285669327,
-0.04861338064074516,
0.03630054369568825,
-0.006986256688833237,
0.06241852790117264,
0.028235986828804016,
-0.04092763364315033,
-0.07109376043081284,
-0.028392499312758446,
-0.07059688121080399,
0.0036150417290627956,
-0.0... | 0.066906 |
`RedisModule\_StreamIteratorDelete` int RedisModule\_StreamIteratorDelete(RedisModuleKey \*key); \*\*Available since:\*\* 6.2.0 Deletes the current stream entry while iterating. This function can be called after [`RedisModule\_StreamIteratorNextID()`](#RedisModule\_StreamIteratorNextID) or after any calls to [`RedisModule\_StreamIteratorNextField()`](#RedisModule\_StreamIteratorNextField). Returns `REDISMODULE\_OK` on success. On failure, `REDISMODULE\_ERR` is returned and `errno` is set as follows: - EINVAL if key is NULL - ENOTSUP if the key is empty or is of another type than stream - EBADF if the key is not opened for writing, if no iterator has been started - ENOENT if the iterator has no current stream entry ### `RedisModule\_StreamTrimByLength` long long RedisModule\_StreamTrimByLength(RedisModuleKey \*key, int flags, long long length); \*\*Available since:\*\* 6.2.0 Trim a stream by length, similar to XTRIM with MAXLEN. - `key`: Key opened for writing. - `flags`: A bitfield of - `REDISMODULE\_STREAM\_TRIM\_APPROX`: Trim less if it improves performance, like XTRIM with `~`. - `length`: The number of stream entries to keep after trimming. Returns the number of entries deleted. On failure, a negative value is returned and `errno` is set as follows: - EINVAL if called with invalid arguments - ENOTSUP if the key is empty or of a type other than stream - EBADF if the key is not opened for writing ### `RedisModule\_StreamTrimByID` long long RedisModule\_StreamTrimByID(RedisModuleKey \*key, int flags, RedisModuleStreamID \*id); \*\*Available since:\*\* 6.2.0 Trim a stream by ID, similar to XTRIM with MINID. - `key`: Key opened for writing. - `flags`: A bitfield of - `REDISMODULE\_STREAM\_TRIM\_APPROX`: Trim less if it improves performance, like XTRIM with `~`. - `id`: The smallest stream ID to keep after trimming. Returns the number of entries deleted. On failure, a negative value is returned and `errno` is set as follows: - EINVAL if called with invalid arguments - ENOTSUP if the key is empty or of a type other than stream - EBADF if the key is not opened for writing ## Calling Redis commands from modules [`RedisModule\_Call()`](#RedisModule\_Call) sends a command to Redis. The remaining functions handle the reply. ### `RedisModule\_FreeCallReply` void RedisModule\_FreeCallReply(RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Free a Call reply and all the nested replies it contains if it's an array. ### `RedisModule\_CallReplyType` int RedisModule\_CallReplyType(RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Return the reply type as one of the following: - `REDISMODULE\_REPLY\_UNKNOWN` - `REDISMODULE\_REPLY\_STRING` - `REDISMODULE\_REPLY\_ERROR` - `REDISMODULE\_REPLY\_INTEGER` - `REDISMODULE\_REPLY\_ARRAY` - `REDISMODULE\_REPLY\_NULL` - `REDISMODULE\_REPLY\_MAP` - `REDISMODULE\_REPLY\_SET` - `REDISMODULE\_REPLY\_BOOL` - `REDISMODULE\_REPLY\_DOUBLE` - `REDISMODULE\_REPLY\_BIG\_NUMBER` - `REDISMODULE\_REPLY\_VERBATIM\_STRING` - `REDISMODULE\_REPLY\_ATTRIBUTE` - `REDISMODULE\_REPLY\_PROMISE` ### `RedisModule\_CallReplyLength` size\_t RedisModule\_CallReplyLength(RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Return the reply type length, where applicable. ### `RedisModule\_CallReplyArrayElement` RedisModuleCallReply \*RedisModule\_CallReplyArrayElement(RedisModuleCallReply \*reply, size\_t idx); \*\*Available since:\*\* 4.0.0 Return the 'idx'-th nested call reply element of an array reply, or NULL if the reply type is wrong or the index is out of range. ### `RedisModule\_CallReplyInteger` long long RedisModule\_CallReplyInteger(RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Return the `long long` of an integer reply. ### `RedisModule\_CallReplyDouble` double RedisModule\_CallReplyDouble(RedisModuleCallReply \*reply); \*\*Available since:\*\* 7.0.0 Return the double value of a double reply. ### `RedisModule\_CallReplyBigNumber` const char \*RedisModule\_CallReplyBigNumber(RedisModuleCallReply \*reply, size\_t \*len); \*\*Available since:\*\* 7.0.0 Return the big number value of a big number reply. ### `RedisModule\_CallReplyVerbatim` const char \*RedisModule\_CallReplyVerbatim(RedisModuleCallReply \*reply, size\_t \*len, const char \*\*format); \*\*Available since:\*\* 7.0.0 Return the value of a verbatim string reply, An optional output argument can be given to get verbatim reply format. ### `RedisModule\_CallReplyBool` int RedisModule\_CallReplyBool(RedisModuleCallReply \*reply); \*\*Available since:\*\* 7.0.0 Return the Boolean value of a Boolean reply. ### `RedisModule\_CallReplySetElement` RedisModuleCallReply \*RedisModule\_CallReplySetElement(RedisModuleCallReply \*reply, size\_t idx); \*\*Available since:\*\* 7.0.0 Return the 'idx'-th nested call reply element of a set reply, or NULL if the reply type is wrong or the index is out of range. ### `RedisModule\_CallReplyMapElement` int RedisModule\_CallReplyMapElement(RedisModuleCallReply \*reply, size\_t idx, RedisModuleCallReply \*\*key, RedisModuleCallReply \*\*val); \*\*Available since:\*\* 7.0.0 Retrieve the 'idx'-th key and value of | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0010262641590088606,
-0.013266101479530334,
-0.08649555593729019,
-0.02228400856256485,
0.05438389629125595,
-0.05506712198257446,
0.09881194680929184,
-0.0009278973448090255,
0.03806270658969879,
-0.06558439880609512,
0.02831001952290535,
-0.028995150700211525,
-0.013552796095609665,
-... | 0.176723 |
\*\*Available since:\*\* 7.0.0 Return the 'idx'-th nested call reply element of a set reply, or NULL if the reply type is wrong or the index is out of range. ### `RedisModule\_CallReplyMapElement` int RedisModule\_CallReplyMapElement(RedisModuleCallReply \*reply, size\_t idx, RedisModuleCallReply \*\*key, RedisModuleCallReply \*\*val); \*\*Available since:\*\* 7.0.0 Retrieve the 'idx'-th key and value of a map reply. Returns: - `REDISMODULE\_OK` on success. - `REDISMODULE\_ERR` if idx out of range or if the reply type is wrong. The `key` and `value` arguments are used to return by reference, and may be NULL if not required. ### `RedisModule\_CallReplyAttribute` RedisModuleCallReply \*RedisModule\_CallReplyAttribute(RedisModuleCallReply \*reply); \*\*Available since:\*\* 7.0.0 Return the attribute of the given reply, or NULL if no attribute exists. ### `RedisModule\_CallReplyAttributeElement` int RedisModule\_CallReplyAttributeElement(RedisModuleCallReply \*reply, size\_t idx, RedisModuleCallReply \*\*key, RedisModuleCallReply \*\*val); \*\*Available since:\*\* 7.0.0 Retrieve the 'idx'-th key and value of an attribute reply. Returns: - `REDISMODULE\_OK` on success. - `REDISMODULE\_ERR` if idx out of range or if the reply type is wrong. The `key` and `value` arguments are used to return by reference, and may be NULL if not required. ### `RedisModule\_CallReplyPromiseSetUnblockHandler` void RedisModule\_CallReplyPromiseSetUnblockHandler(RedisModuleCallReply \*reply, RedisModuleOnUnblocked on\_unblock, void \*private\_data); \*\*Available since:\*\* 7.2.0 Set unblock handler (callback and private data) on the given promise `RedisModuleCallReply`. The given reply must be of promise type (`REDISMODULE\_REPLY\_PROMISE`). ### `RedisModule\_CallReplyPromiseAbort` int RedisModule\_CallReplyPromiseAbort(RedisModuleCallReply \*reply, void \*\*private\_data); \*\*Available since:\*\* 7.2.0 Abort the execution of a given promise `RedisModuleCallReply`. return `REDMODULE\_OK` in case the abort was done successfully and `REDISMODULE\_ERR` if its not possible to abort the execution (execution already finished). In case the execution was aborted (`REDMODULE\_OK` was returned), the `private\_data` out parameter will be set with the value of the private data that was given on '[`RedisModule\_CallReplyPromiseSetUnblockHandler`](#RedisModule\_CallReplyPromiseSetUnblockHandler)' so the caller will be able to release the private data. If the execution was aborted successfully, it is promised that the unblock handler will not be called. That said, it is possible that the abort operation will successes but the operation will still continue. This can happened if, for example, a module implements some blocking command and does not respect the disconnect callback. For pure Redis commands this can not happened. ### `RedisModule\_CallReplyStringPtr` const char \*RedisModule\_CallReplyStringPtr(RedisModuleCallReply \*reply, size\_t \*len); \*\*Available since:\*\* 4.0.0 Return the pointer and length of a string or error reply. ### `RedisModule\_CreateStringFromCallReply` RedisModuleString \*RedisModule\_CreateStringFromCallReply(RedisModuleCallReply \*reply); \*\*Available since:\*\* 4.0.0 Return a new string object from a call reply of type string, error or integer. Otherwise (wrong reply type) return NULL. ### `RedisModule\_SetContextUser` void RedisModule\_SetContextUser(RedisModuleCtx \*ctx, const RedisModuleUser \*user); \*\*Available since:\*\* 7.0.6 Modifies the user that [`RedisModule\_Call`](#RedisModule\_Call) will use (e.g. for ACL checks) ### `RedisModule\_Call` RedisModuleCallReply \*RedisModule\_Call(RedisModuleCtx \*ctx, const char \*cmdname, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Exported API to call any Redis command from modules. \* \*\*cmdname\*\*: The Redis command to call. \* \*\*fmt\*\*: A format specifier string for the command's arguments. Each of the arguments should be specified by a valid type specification. The format specifier can also contain the modifiers `!`, `A`, `3` and `R` which don't have a corresponding argument. \* `b` -- The argument is a buffer and is immediately followed by another argument that is the buffer's length. \* `c` -- The argument is a pointer to a plain C string (null-terminated). \* `l` -- The argument is a `long long` integer. \* `s` -- The argument is a RedisModuleString. \* `v` -- The argument(s) is a vector of RedisModuleString. \* `!` -- Sends the Redis command and its arguments to replicas and AOF. \* `A` -- Suppress AOF propagation, send only to replicas (requires `!`). \* `R` -- Suppress replicas propagation, send only to AOF (requires `!`). \* `3` -- Return a RESP3 reply. This will change | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.01150701753795147,
0.028684493154287338,
-0.017401395365595818,
0.0454915389418602,
-0.08645709604024887,
-0.026633400470018387,
0.11671622842550278,
0.060832008719444275,
-0.04541684314608574,
-0.035936228930950165,
-0.012075139209628105,
-0.05721428245306015,
0.0445873886346817,
-0.08... | 0.110156 |
of RedisModuleString. \* `!` -- Sends the Redis command and its arguments to replicas and AOF. \* `A` -- Suppress AOF propagation, send only to replicas (requires `!`). \* `R` -- Suppress replicas propagation, send only to AOF (requires `!`). \* `3` -- Return a RESP3 reply. This will change the command reply. e.g., HGETALL returns a map instead of a flat array. \* `0` -- Return the reply in auto mode, i.e. the reply format will be the same as the client attached to the given RedisModuleCtx. This will probably used when you want to pass the reply directly to the client. \* `C` -- Run a command as the user attached to the context. User is either attached automatically via the client that directly issued the command and created the context or via RedisModule\_SetContextUser. If the context is not directly created by an issued command (such as a background context and no user was set on it via RedisModule\_SetContextUser, RedisModule\_Call will fail. Checks if the command can be executed according to ACL rules and causes the command to run as the determined user, so that any future user dependent activity, such as ACL checks within scripts will proceed as expected. Otherwise, the command will run as the Redis unrestricted user. \* `S` -- Run the command in a script mode, this means that it will raise an error if a command which are not allowed inside a script (flagged with the `deny-script` flag) is invoked (like SHUTDOWN). In addition, on script mode, write commands are not allowed if there are not enough good replicas (as configured with `min-replicas-to-write`) or when the server is unable to persist to the disk. \* `W` -- Do not allow to run any write command (flagged with the `write` flag). \* `M` -- Do not allow `deny-oom` flagged commands when over the memory limit. \* `E` -- Return error as RedisModuleCallReply. If there is an error before invoking the command, the error is returned using errno mechanism. This flag allows to get the error also as an error CallReply with relevant error message. \* 'D' -- A "Dry Run" mode. Return before executing the underlying call(). If everything succeeded, it will return with a NULL, otherwise it will return with a CallReply object denoting the error, as if it was called with the 'E' code. \* 'K' -- Allow running blocking commands. If enabled and the command gets blocked, a special REDISMODULE\_REPLY\_PROMISE will be returned. This reply type indicates that the command was blocked and the reply will be given asynchronously. The module can use this reply object to set a handler which will be called when the command gets unblocked using RedisModule\_CallReplyPromiseSetUnblockHandler. The handler must be set immediately after the command invocation (without releasing the Redis lock in between). If the handler is not set, the blocking command will still continue its execution but the reply will be ignored (fire and forget), notice that this is dangerous in case of role change, as explained below. The module can use RedisModule\_CallReplyPromiseAbort to abort the command invocation if it was not yet finished (see RedisModule\_CallReplyPromiseAbort documentation for more details). It is also the module's responsibility to abort the execution on role change, either by using server event (to get notified when the instance becomes a replica) or relying on the disconnect callback of the original client. Failing to do so can result in a write operation on a replica. Unlike other call replies, promise call reply \*\*must\*\* be freed while the Redis GIL is locked. Notice that on unblocking, the only promise is that | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.00872464757412672,
-0.016067994758486748,
-0.1349550485610962,
0.03041156753897667,
-0.010190986096858978,
-0.07431980967521667,
0.12534193694591522,
0.010160171426832676,
-0.00114659802056849,
-0.021394941955804825,
-0.016236193478107452,
-0.07256767898797989,
0.05734853446483612,
-0.0... | 0.165368 |
a replica) or relying on the disconnect callback of the original client. Failing to do so can result in a write operation on a replica. Unlike other call replies, promise call reply \*\*must\*\* be freed while the Redis GIL is locked. Notice that on unblocking, the only promise is that the unblock handler will be called, If the blocking RedisModule\_Call caused the module to also block some real client (using RedisModule\_BlockClient), it is the module responsibility to unblock this client on the unblock handler. On the unblock handler it is only allowed to perform the following: \* Calling additional Redis commands using RedisModule\_Call \* Open keys using RedisModule\_OpenKey \* Replicate data to the replica or AOF Specifically, it is not allowed to call any Redis module API which are client related such as: \* RedisModule\_Reply\* API's \* RedisModule\_BlockClient \* RedisModule\_GetCurrentUserName \* \*\*...\*\*: The actual arguments to the Redis command. On success a `RedisModuleCallReply` object is returned, otherwise NULL is returned and errno is set to the following values: \* EBADF: wrong format specifier. \* EINVAL: wrong command arity. \* ENOENT: command does not exist. \* EPERM: operation in Cluster instance with key in non local slot. \* EROFS: operation in Cluster instance when a write command is sent in a readonly state. \* ENETDOWN: operation in Cluster instance when cluster is down. \* ENOTSUP: No ACL user for the specified module context \* EACCES: Command cannot be executed, according to ACL rules \* ENOSPC: Write or deny-oom command is not allowed \* ESPIPE: Command not allowed on script mode Example code fragment: reply = RedisModule\_Call(ctx,"INCRBY","sc",argv[1],"10"); if (RedisModule\_CallReplyType(reply) == REDISMODULE\_REPLY\_INTEGER) { long long myval = RedisModule\_CallReplyInteger(reply); // Do something with myval. } This API is documented here: [https://redis.io/topics/modules-intro](https://redis.io/topics/modules-intro) ### `RedisModule\_CallReplyProto` const char \*RedisModule\_CallReplyProto(RedisModuleCallReply \*reply, size\_t \*len); \*\*Available since:\*\* 4.0.0 Return a pointer, and a length, to the protocol returned by the command that returned the reply object. ## Modules data types When String DMA or using existing data structures is not enough, it is possible to create new data types from scratch and export them to Redis. The module must provide a set of callbacks for handling the new values exported (for example in order to provide RDB saving/loading, AOF rewrite, and so forth). In this section we define this API. ### `RedisModule\_CreateDataType` moduleType \*RedisModule\_CreateDataType(RedisModuleCtx \*ctx, const char \*name, int encver, void \*typemethods\_ptr); \*\*Available since:\*\* 4.0.0 Register a new data type exported by the module. The parameters are the following. Please for in depth documentation check the modules API documentation, especially [https://redis.io/topics/modules-native-types](https://redis.io/topics/modules-native-types). \* \*\*name\*\*: A 9 characters data type name that MUST be unique in the Redis Modules ecosystem. Be creative... and there will be no collisions. Use the charset A-Z a-z 9-0, plus the two "-\_" characters. A good idea is to use, for example `-`. For example "tree-AntZ" may mean "Tree data structure by @antirez". To use both lower case and upper case letters helps in order to prevent collisions. \* \*\*encver\*\*: Encoding version, which is, the version of the serialization that a module used in order to persist data. As long as the "name" matches, the RDB loading will be dispatched to the type callbacks whatever 'encver' is used, however the module can understand if the encoding it must load are of an older version of the module. For example the module "tree-AntZ" initially used encver=0. Later after an upgrade, it started to serialize data in a different format and to register the type with encver=1. However this module may still load old data produced by an older version if the `rdb\_load` callback is able to check the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.15078270435333252,
-0.04912767559289932,
-0.0647500678896904,
0.057031016796827316,
0.020491013303399086,
-0.07216809689998627,
0.010556263849139214,
-0.05289691314101219,
0.0782996416091919,
0.010802463628351688,
-0.004140907432883978,
0.06418660283088684,
0.000439409603131935,
-0.0457... | 0.12743 |
For example the module "tree-AntZ" initially used encver=0. Later after an upgrade, it started to serialize data in a different format and to register the type with encver=1. However this module may still load old data produced by an older version if the `rdb\_load` callback is able to check the encver value and act accordingly. The encver must be a positive value between 0 and 1023. \* \*\*typemethods\_ptr\*\* is a pointer to a `RedisModuleTypeMethods` structure that should be populated with the methods callbacks and structure version, like in the following example: RedisModuleTypeMethods tm = { .version = REDISMODULE\_TYPE\_METHOD\_VERSION, .rdb\_load = myType\_RDBLoadCallBack, .rdb\_save = myType\_RDBSaveCallBack, .aof\_rewrite = myType\_AOFRewriteCallBack, .free = myType\_FreeCallBack, // Optional fields .digest = myType\_DigestCallBack, .mem\_usage = myType\_MemUsageCallBack, .aux\_load = myType\_AuxRDBLoadCallBack, .aux\_save = myType\_AuxRDBSaveCallBack, .free\_effort = myType\_FreeEffortCallBack, .unlink = myType\_UnlinkCallBack, .copy = myType\_CopyCallback, .defrag = myType\_DefragCallback // Enhanced optional fields .mem\_usage2 = myType\_MemUsageCallBack2, .free\_effort2 = myType\_FreeEffortCallBack2, .unlink2 = myType\_UnlinkCallBack2, .copy2 = myType\_CopyCallback2, } \* \*\*rdb\_load\*\*: A callback function pointer that loads data from RDB files. \* \*\*rdb\_save\*\*: A callback function pointer that saves data to RDB files. \* \*\*aof\_rewrite\*\*: A callback function pointer that rewrites data as commands. \* \*\*digest\*\*: A callback function pointer that is used for `DEBUG DIGEST`. \* \*\*free\*\*: A callback function pointer that can free a type value. \* \*\*aux\_save\*\*: A callback function pointer that saves out of keyspace data to RDB files. 'when' argument is either `REDISMODULE\_AUX\_BEFORE\_RDB` or `REDISMODULE\_AUX\_AFTER\_RDB`. \* \*\*aux\_load\*\*: A callback function pointer that loads out of keyspace data from RDB files. Similar to `aux\_save`, returns `REDISMODULE\_OK` on success, and ERR otherwise. \* \*\*free\_effort\*\*: A callback function pointer that used to determine whether the module's memory needs to be lazy reclaimed. The module should return the complexity involved by freeing the value. for example: how many pointers are gonna be freed. Note that if it returns 0, we'll always do an async free. \* \*\*unlink\*\*: A callback function pointer that used to notifies the module that the key has been removed from the DB by redis, and may soon be freed by a background thread. Note that it won't be called on FLUSHALL/FLUSHDB (both sync and async), and the module can use the `RedisModuleEvent\_FlushDB` to hook into that. \* \*\*copy\*\*: A callback function pointer that is used to make a copy of the specified key. The module is expected to perform a deep copy of the specified value and return it. In addition, hints about the names of the source and destination keys is provided. A NULL return value is considered an error and the copy operation fails. Note: if the target key exists and is being overwritten, the copy callback will be called first, followed by a free callback to the value that is being replaced. \* \*\*defrag\*\*: A callback function pointer that is used to request the module to defrag a key. The module should then iterate pointers and call the relevant `RedisModule\_Defrag\*()` functions to defragment pointers or complex types. The module should continue iterating as long as [`RedisModule\_DefragShouldStop()`](#RedisModule\_DefragShouldStop) returns a zero value, and return a zero value if finished or non-zero value if more work is left to be done. If more work needs to be done, [`RedisModule\_DefragCursorSet()`](#RedisModule\_DefragCursorSet) and [`RedisModule\_DefragCursorGet()`](#RedisModule\_DefragCursorGet) can be used to track this work across different calls. Normally, the defrag mechanism invokes the callback without a time limit, so [`RedisModule\_DefragShouldStop()`](#RedisModule\_DefragShouldStop) always returns zero. The "late defrag" mechanism which has a time limit and provides cursor support is used only for keys that are determined to have significant internal complexity. To determine this, the defrag mechanism uses the `free\_effort` callback and the 'active-defrag-max-scan-fields' config directive. NOTE: The | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0037966438103467226,
-0.01431945338845253,
-0.04793979600071907,
0.013801857829093933,
-0.010238257236778736,
-0.03704584389925003,
-0.05127539485692978,
0.027862509712576866,
-0.1014656126499176,
0.02456985041499138,
0.01804923824965954,
-0.008743200451135635,
-0.0006798068061470985,
-... | 0.034549 |
time limit, so [`RedisModule\_DefragShouldStop()`](#RedisModule\_DefragShouldStop) always returns zero. The "late defrag" mechanism which has a time limit and provides cursor support is used only for keys that are determined to have significant internal complexity. To determine this, the defrag mechanism uses the `free\_effort` callback and the 'active-defrag-max-scan-fields' config directive. NOTE: The value is passed as a `void\*\*` and the function is expected to update the pointer if the top-level value pointer is defragmented and consequently changes. \* \*\*mem\_usage2\*\*: Similar to `mem\_usage`, but provides the `RedisModuleKeyOptCtx` parameter so that meta information such as key name and db id can be obtained, and the `sample\_size` for size estimation (see MEMORY USAGE command). \* \*\*free\_effort2\*\*: Similar to `free\_effort`, but provides the `RedisModuleKeyOptCtx` parameter so that meta information such as key name and db id can be obtained. \* \*\*unlink2\*\*: Similar to `unlink`, but provides the `RedisModuleKeyOptCtx` parameter so that meta information such as key name and db id can be obtained. \* \*\*copy2\*\*: Similar to `copy`, but provides the `RedisModuleKeyOptCtx` parameter so that meta information such as key names and db ids can be obtained. \* \*\*aux\_save2\*\*: Similar to `aux\_save`, but with small semantic change, if the module saves nothing on this callback then no data about this aux field will be written to the RDB and it will be possible to load the RDB even if the module is not loaded. Note: the module name "AAAAAAAAA" is reserved and produces an error, it happens to be pretty lame as well. If [`RedisModule\_CreateDataType()`](#RedisModule\_CreateDataType) is called outside of `RedisModule\_OnLoad()` function, there is already a module registering a type with the same name, or if the module name or encver is invalid, NULL is returned. Otherwise the new type is registered into Redis, and a reference of type `RedisModuleType` is returned: the caller of the function should store this reference into a global variable to make future use of it in the modules type API, since a single module may register multiple types. Example code fragment: static RedisModuleType \*BalancedTreeType; int RedisModule\_OnLoad(RedisModuleCtx \*ctx) { // some code here ... BalancedTreeType = RedisModule\_CreateDataType(...); } ### `RedisModule\_ModuleTypeSetValue` int RedisModule\_ModuleTypeSetValue(RedisModuleKey \*key, moduleType \*mt, void \*value); \*\*Available since:\*\* 4.0.0 If the key is open for writing, set the specified module type object as the value of the key, deleting the old value if any. On success `REDISMODULE\_OK` is returned. If the key is not open for writing or there is an active iterator, `REDISMODULE\_ERR` is returned. ### `RedisModule\_ModuleTypeGetType` moduleType \*RedisModule\_ModuleTypeGetType(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Assuming [`RedisModule\_KeyType()`](#RedisModule\_KeyType) returned `REDISMODULE\_KEYTYPE\_MODULE` on the key, returns the module type pointer of the value stored at key. If the key is NULL, is not associated with a module type, or is empty, then NULL is returned instead. ### `RedisModule\_ModuleTypeGetValue` void \*RedisModule\_ModuleTypeGetValue(RedisModuleKey \*key); \*\*Available since:\*\* 4.0.0 Assuming [`RedisModule\_KeyType()`](#RedisModule\_KeyType) returned `REDISMODULE\_KEYTYPE\_MODULE` on the key, returns the module type low-level value stored at key, as it was set by the user via [`RedisModule\_ModuleTypeSetValue()`](#RedisModule\_ModuleTypeSetValue). If the key is NULL, is not associated with a module type, or is empty, then NULL is returned instead. ## RDB loading and saving functions ### `RedisModule\_IsIOError` int RedisModule\_IsIOError(RedisModuleIO \*io); \*\*Available since:\*\* 6.0.0 Returns true if any previous IO API failed. for `Load\*` APIs the `REDISMODULE\_OPTIONS\_HANDLE\_IO\_ERRORS` flag must be set with [`RedisModule\_SetModuleOptions`](#RedisModule\_SetModuleOptions) first. ### `RedisModule\_SaveUnsigned` void RedisModule\_SaveUnsigned(RedisModuleIO \*io, uint64\_t value); \*\*Available since:\*\* 4.0.0 Save an unsigned 64 bit value into the RDB file. This function should only be called in the context of the `rdb\_save` method of modules implementing new data types. ### `RedisModule\_LoadUnsigned` uint64\_t RedisModule\_LoadUnsigned(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 Load an unsigned 64 bit value from the RDB file. This function should only be | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.03135963901877403,
-0.00042594721890054643,
-0.0817505270242691,
0.007452947553247213,
0.038965001702308655,
-0.10682496428489685,
0.11374218016862869,
0.09947207570075989,
-0.044633012264966965,
0.006520635448396206,
0.012767894193530083,
0.029422327876091003,
0.03828190267086029,
-0.0... | 0.157878 |
unsigned 64 bit value into the RDB file. This function should only be called in the context of the `rdb\_save` method of modules implementing new data types. ### `RedisModule\_LoadUnsigned` uint64\_t RedisModule\_LoadUnsigned(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 Load an unsigned 64 bit value from the RDB file. This function should only be called in the context of the `rdb\_load` method of modules implementing new data types. ### `RedisModule\_SaveSigned` void RedisModule\_SaveSigned(RedisModuleIO \*io, int64\_t value); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_SaveUnsigned()`](#RedisModule\_SaveUnsigned) but for signed 64 bit values. ### `RedisModule\_LoadSigned` int64\_t RedisModule\_LoadSigned(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_LoadUnsigned()`](#RedisModule\_LoadUnsigned) but for signed 64 bit values. ### `RedisModule\_SaveString` void RedisModule\_SaveString(RedisModuleIO \*io, RedisModuleString \*s); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_save` method of a module type, saves a string into the RDB file taking as input a `RedisModuleString`. The string can be later loaded with [`RedisModule\_LoadString()`](#RedisModule\_LoadString) or other Load family functions expecting a serialized string inside the RDB file. ### `RedisModule\_SaveStringBuffer` void RedisModule\_SaveStringBuffer(RedisModuleIO \*io, const char \*str, size\_t len); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_SaveString()`](#RedisModule\_SaveString) but takes a raw C pointer and length as input. ### `RedisModule\_LoadString` RedisModuleString \*RedisModule\_LoadString(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_load` method of a module data type, loads a string from the RDB file, that was previously saved with [`RedisModule\_SaveString()`](#RedisModule\_SaveString) functions family. The returned string is a newly allocated `RedisModuleString` object, and the user should at some point free it with a call to [`RedisModule\_FreeString()`](#RedisModule\_FreeString). If the data structure does not store strings as `RedisModuleString` objects, the similar function [`RedisModule\_LoadStringBuffer()`](#RedisModule\_LoadStringBuffer) could be used instead. ### `RedisModule\_LoadStringBuffer` char \*RedisModule\_LoadStringBuffer(RedisModuleIO \*io, size\_t \*lenptr); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_LoadString()`](#RedisModule\_LoadString) but returns a heap allocated string that was allocated with [`RedisModule\_Alloc()`](#RedisModule\_Alloc), and can be resized or freed with [`RedisModule\_Realloc()`](#RedisModule\_Realloc) or [`RedisModule\_Free()`](#RedisModule\_Free). The size of the string is stored at '\*lenptr' if not NULL. The returned string is not automatically NULL terminated, it is loaded exactly as it was stored inside the RDB file. ### `RedisModule\_SaveDouble` void RedisModule\_SaveDouble(RedisModuleIO \*io, double value); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_save` method of a module data type, saves a double value to the RDB file. The double can be a valid number, a NaN or infinity. It is possible to load back the value with [`RedisModule\_LoadDouble()`](#RedisModule\_LoadDouble). ### `RedisModule\_LoadDouble` double RedisModule\_LoadDouble(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_save` method of a module data type, loads back the double value saved by [`RedisModule\_SaveDouble()`](#RedisModule\_SaveDouble). ### `RedisModule\_SaveFloat` void RedisModule\_SaveFloat(RedisModuleIO \*io, float value); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_save` method of a module data type, saves a float value to the RDB file. The float can be a valid number, a NaN or infinity. It is possible to load back the value with [`RedisModule\_LoadFloat()`](#RedisModule\_LoadFloat). ### `RedisModule\_LoadFloat` float RedisModule\_LoadFloat(RedisModuleIO \*io); \*\*Available since:\*\* 4.0.0 In the context of the `rdb\_save` method of a module data type, loads back the float value saved by [`RedisModule\_SaveFloat()`](#RedisModule\_SaveFloat). ### `RedisModule\_SaveLongDouble` void RedisModule\_SaveLongDouble(RedisModuleIO \*io, long double value); \*\*Available since:\*\* 6.0.0 In the context of the `rdb\_save` method of a module data type, saves a long double value to the RDB file. The double can be a valid number, a NaN or infinity. It is possible to load back the value with [`RedisModule\_LoadLongDouble()`](#RedisModule\_LoadLongDouble). ### `RedisModule\_LoadLongDouble` long double RedisModule\_LoadLongDouble(RedisModuleIO \*io); \*\*Available since:\*\* 6.0.0 In the context of the `rdb\_save` method of a module data type, loads back the long double value saved by [`RedisModule\_SaveLongDouble()`](#RedisModule\_SaveLongDouble). ## Key digest API (DEBUG DIGEST interface for modules types) ### `RedisModule\_DigestAddStringBuffer` void RedisModule\_DigestAddStringBuffer(RedisModuleDigest \*md, const char \*ele, size\_t len); \*\*Available since:\*\* 4.0.0 Add a new element to the digest. This function can be called multiple times one element after | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.07578077912330627,
0.030161675065755844,
-0.09278734773397446,
-0.017173029482364655,
-0.054925233125686646,
0.009052298963069916,
-0.025362027809023857,
0.06452581286430359,
-0.09309985488653183,
0.017204612493515015,
-0.01166684553027153,
-0.05592711642384529,
0.06499528139829636,
-0.0... | 0.013711 |
type, loads back the long double value saved by [`RedisModule\_SaveLongDouble()`](#RedisModule\_SaveLongDouble). ## Key digest API (DEBUG DIGEST interface for modules types) ### `RedisModule\_DigestAddStringBuffer` void RedisModule\_DigestAddStringBuffer(RedisModuleDigest \*md, const char \*ele, size\_t len); \*\*Available since:\*\* 4.0.0 Add a new element to the digest. This function can be called multiple times one element after the other, for all the elements that constitute a given data structure. The function call must be followed by the call to [`RedisModule\_DigestEndSequence`](#RedisModule\_DigestEndSequence) eventually, when all the elements that are always in a given order are added. See the Redis Modules data types documentation for more info. However this is a quick example that uses Redis data types as an example. To add a sequence of unordered elements (for example in the case of a Redis Set), the pattern to use is: foreach element { AddElement(element); EndSequence(); } Because Sets are not ordered, so every element added has a position that does not depend from the other. However if instead our elements are ordered in pairs, like field-value pairs of a Hash, then one should use: foreach key,value { AddElement(key); AddElement(value); EndSequence(); } Because the key and value will be always in the above order, while instead the single key-value pairs, can appear in any position into a Redis hash. A list of ordered elements would be implemented with: foreach element { AddElement(element); } EndSequence(); ### `RedisModule\_DigestAddLongLong` void RedisModule\_DigestAddLongLong(RedisModuleDigest \*md, long long ll); \*\*Available since:\*\* 4.0.0 Like [`RedisModule\_DigestAddStringBuffer()`](#RedisModule\_DigestAddStringBuffer) but takes a `long long` as input that gets converted into a string before adding it to the digest. ### `RedisModule\_DigestEndSequence` void RedisModule\_DigestEndSequence(RedisModuleDigest \*md); \*\*Available since:\*\* 4.0.0 See the documentation for `RedisModule\_DigestAddElement()`. ### `RedisModule\_LoadDataTypeFromStringEncver` void \*RedisModule\_LoadDataTypeFromStringEncver(const RedisModuleString \*str, const moduleType \*mt, int encver); \*\*Available since:\*\* 7.0.0 Decode a serialized representation of a module data type 'mt', in a specific encoding version 'encver' from string 'str' and return a newly allocated value, or NULL if decoding failed. This call basically reuses the '`rdb\_load`' callback which module data types implement in order to allow a module to arbitrarily serialize/de-serialize keys, similar to how the Redis 'DUMP' and 'RESTORE' commands are implemented. Modules should generally use the `REDISMODULE\_OPTIONS\_HANDLE\_IO\_ERRORS` flag and make sure the de-serialization code properly checks and handles IO errors (freeing allocated buffers and returning a NULL). If this is NOT done, Redis will handle corrupted (or just truncated) serialized data by producing an error message and terminating the process. ### `RedisModule\_LoadDataTypeFromString` void \*RedisModule\_LoadDataTypeFromString(const RedisModuleString \*str, const moduleType \*mt); \*\*Available since:\*\* 6.0.0 Similar to [`RedisModule\_LoadDataTypeFromStringEncver`](#RedisModule\_LoadDataTypeFromStringEncver), original version of the API, kept for backward compatibility. ### `RedisModule\_SaveDataTypeToString` RedisModuleString \*RedisModule\_SaveDataTypeToString(RedisModuleCtx \*ctx, void \*data, const moduleType \*mt); \*\*Available since:\*\* 6.0.0 Encode a module data type 'mt' value 'data' into serialized form, and return it as a newly allocated `RedisModuleString`. This call basically reuses the '`rdb\_save`' callback which module data types implement in order to allow a module to arbitrarily serialize/de-serialize keys, similar to how the Redis 'DUMP' and 'RESTORE' commands are implemented. ### `RedisModule\_GetKeyNameFromDigest` const RedisModuleString \*RedisModule\_GetKeyNameFromDigest(RedisModuleDigest \*dig); \*\*Available since:\*\* 7.0.0 Returns the name of the key currently being processed. ### `RedisModule\_GetDbIdFromDigest` int RedisModule\_GetDbIdFromDigest(RedisModuleDigest \*dig); \*\*Available since:\*\* 7.0.0 Returns the database id of the key currently being processed. ## AOF API for modules data types ### `RedisModule\_EmitAOF` void RedisModule\_EmitAOF(RedisModuleIO \*io, const char \*cmdname, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Emits a command into the AOF during the AOF rewriting process. This function is only called in the context of the `aof\_rewrite` method of data types exported by a module. The command works exactly like [`RedisModule\_Call()`](#RedisModule\_Call) in the way the parameters are passed, but it does not return anything as the error handling is performed by Redis | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.04663857817649841,
-0.02519715391099453,
-0.058461640030145645,
0.04401180148124695,
-0.05980667471885681,
-0.06702651083469391,
0.0527845099568367,
-0.004539534915238619,
-0.02482474222779274,
-0.050056472420692444,
0.004422045778483152,
0.0013273553922772408,
0.02586827427148819,
-0.07... | 0.115398 |
the AOF rewriting process. This function is only called in the context of the `aof\_rewrite` method of data types exported by a module. The command works exactly like [`RedisModule\_Call()`](#RedisModule\_Call) in the way the parameters are passed, but it does not return anything as the error handling is performed by Redis itself. ## IO context handling ### `RedisModule\_GetKeyNameFromIO` const RedisModuleString \*RedisModule\_GetKeyNameFromIO(RedisModuleIO \*io); \*\*Available since:\*\* 5.0.5 Returns the name of the key currently being processed. There is no guarantee that the key name is always available, so this may return NULL. ### `RedisModule\_GetKeyNameFromModuleKey` const RedisModuleString \*RedisModule\_GetKeyNameFromModuleKey(RedisModuleKey \*key); \*\*Available since:\*\* 6.0.0 Returns a `RedisModuleString` with the name of the key from `RedisModuleKey`. ### `RedisModule\_GetDbIdFromModuleKey` int RedisModule\_GetDbIdFromModuleKey(RedisModuleKey \*key); \*\*Available since:\*\* 7.0.0 Returns a database id of the key from `RedisModuleKey`. ### `RedisModule\_GetDbIdFromIO` int RedisModule\_GetDbIdFromIO(RedisModuleIO \*io); \*\*Available since:\*\* 7.0.0 Returns the database id of the key currently being processed. There is no guarantee that this info is always available, so this may return -1. ## Logging ### `RedisModule\_Log` void RedisModule\_Log(RedisModuleCtx \*ctx, const char \*levelstr, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Produces a log message to the standard Redis log, the format accepts printf-alike specifiers, while level is a string describing the log level to use when emitting the log, and must be one of the following: \* "debug" (`REDISMODULE\_LOGLEVEL\_DEBUG`) \* "verbose" (`REDISMODULE\_LOGLEVEL\_VERBOSE`) \* "notice" (`REDISMODULE\_LOGLEVEL\_NOTICE`) \* "warning" (`REDISMODULE\_LOGLEVEL\_WARNING`) If the specified log level is invalid, verbose is used by default. There is a fixed limit to the length of the log line this function is able to emit, this limit is not specified but is guaranteed to be more than a few lines of text. The ctx argument may be NULL if cannot be provided in the context of the caller for instance threads or callbacks, in which case a generic "module" will be used instead of the module name. ### `RedisModule\_LogIOError` void RedisModule\_LogIOError(RedisModuleIO \*io, const char \*levelstr, const char \*fmt, ...); \*\*Available since:\*\* 4.0.0 Log errors from RDB / AOF serialization callbacks. This function should be used when a callback is returning a critical error to the caller since cannot load or save the data for some critical reason. ### `RedisModule\_\_Assert` void RedisModule\_\_Assert(const char \*estr, const char \*file, int line); \*\*Available since:\*\* 6.0.0 Redis-like assert function. The macro `RedisModule\_Assert(expression)` is recommended, rather than calling this function directly. A failed assertion will shut down the server and produce logging information that looks identical to information generated by Redis itself. ### `RedisModule\_LatencyAddSample` void RedisModule\_LatencyAddSample(const char \*event, mstime\_t latency); \*\*Available since:\*\* 6.0.0 Allows adding event to the latency monitor to be observed by the LATENCY command. The call is skipped if the latency is smaller than the configured latency-monitor-threshold. ## Blocking clients from modules For a guide about blocking commands in modules, see [https://redis.io/topics/modules-blocking-ops](https://redis.io/topics/modules-blocking-ops). ### `RedisModule\_RegisterAuthCallback` void RedisModule\_RegisterAuthCallback(RedisModuleCtx \*ctx, RedisModuleAuthCallback cb); \*\*Available since:\*\* 7.2.0 This API registers a callback to execute in addition to normal password based authentication. Multiple callbacks can be registered across different modules. When a Module is unloaded, all the auth callbacks registered by it are unregistered. The callbacks are attempted (in the order of most recently registered first) when the AUTH/HELLO (with AUTH field provided) commands are called. The callbacks will be called with a module context along with a username and a password, and are expected to take one of the following actions: (1) Authenticate - Use the `RedisModule\_AuthenticateClient`\* API and return `REDISMODULE\_AUTH\_HANDLED`. This will immediately end the auth chain as successful and add the OK reply. (2) Deny Authentication - Return `REDISMODULE\_AUTH\_HANDLED` without authenticating or blocking the client. Optionally, `err` can be set to a custom error message and `err` | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.015575017780065536,
0.0009795152582228184,
-0.04206237941980362,
0.060422301292419434,
-0.027926597744226456,
-0.0845203846693039,
0.0733356699347496,
0.042740099132061005,
-0.007599682547152042,
0.015750929713249207,
-0.02636522799730301,
-0.014723378233611584,
-0.020718954503536224,
-... | 0.126771 |
following actions: (1) Authenticate - Use the `RedisModule\_AuthenticateClient`\* API and return `REDISMODULE\_AUTH\_HANDLED`. This will immediately end the auth chain as successful and add the OK reply. (2) Deny Authentication - Return `REDISMODULE\_AUTH\_HANDLED` without authenticating or blocking the client. Optionally, `err` can be set to a custom error message and `err` will be automatically freed by the server. This will immediately end the auth chain as unsuccessful and add the ERR reply. (3) Block a client on authentication - Use the [`RedisModule\_BlockClientOnAuth`](#RedisModule\_BlockClientOnAuth) API and return `REDISMODULE\_AUTH\_HANDLED`. Here, the client will be blocked until the [`RedisModule\_UnblockClient`](#RedisModule\_UnblockClient) API is used which will trigger the auth reply callback (provided through the [`RedisModule\_BlockClientOnAuth`](#RedisModule\_BlockClientOnAuth)). In this reply callback, the Module should authenticate, deny or skip handling authentication. (4) Skip handling Authentication - Return `REDISMODULE\_AUTH\_NOT\_HANDLED` without blocking the client. This will allow the engine to attempt the next module auth callback. If none of the callbacks authenticate or deny auth, then password based auth is attempted and will authenticate or add failure logs and reply to the clients accordingly. Note: If a client is disconnected while it was in the middle of blocking module auth, that occurrence of the AUTH or HELLO command will not be tracked in the INFO command stats. The following is an example of how non-blocking module based authentication can be used: int auth\_cb(RedisModuleCtx \*ctx, RedisModuleString \*username, RedisModuleString \*password, RedisModuleString \*\*err) { const char \*user = RedisModule\_StringPtrLen(username, NULL); const char \*pwd = RedisModule\_StringPtrLen(password, NULL); if (!strcmp(user,"foo") && !strcmp(pwd,"valid\_password")) { RedisModule\_AuthenticateClientWithACLUser(ctx, "foo", 3, NULL, NULL, NULL); return REDISMODULE\_AUTH\_HANDLED; } else if (!strcmp(user,"foo") && !strcmp(pwd,"wrong\_password")) { RedisModuleString \*log = RedisModule\_CreateString(ctx, "Module Auth", 11); RedisModule\_ACLAddLogEntryByUserName(ctx, username, log, REDISMODULE\_ACL\_LOG\_AUTH); RedisModule\_FreeString(ctx, log); const char \*err\_msg = "Auth denied by Misc Module."; \*err = RedisModule\_CreateString(ctx, err\_msg, strlen(err\_msg)); return REDISMODULE\_AUTH\_HANDLED; } return REDISMODULE\_AUTH\_NOT\_HANDLED; } int RedisModule\_OnLoad(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { if (RedisModule\_Init(ctx,"authmodule",1,REDISMODULE\_APIVER\_1)== REDISMODULE\_ERR) return REDISMODULE\_ERR; RedisModule\_RegisterAuthCallback(ctx, auth\_cb); return REDISMODULE\_OK; } ### `RedisModule\_BlockClient` RedisModuleBlockedClient \*RedisModule\_BlockClient(RedisModuleCtx \*ctx, RedisModuleCmdFunc reply\_callback, ; \*\*Available since:\*\* 4.0.0 Block a client in the context of a blocking command, returning a handle which will be used, later, in order to unblock the client with a call to [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient). The arguments specify callback functions and a timeout after which the client is unblocked. The callbacks are called in the following contexts: reply\_callback: called after a successful RedisModule\_UnblockClient() call in order to reply to the client and unblock it. timeout\_callback: called when the timeout is reached or if `CLIENT UNBLOCK` is invoked, in order to send an error to the client. free\_privdata: called in order to free the private data that is passed by RedisModule\_UnblockClient() call. Note: [`RedisModule\_UnblockClient`](#RedisModule\_UnblockClient) should be called for every blocked client, even if client was killed, timed-out or disconnected. Failing to do so will result in memory leaks. There are some cases where [`RedisModule\_BlockClient()`](#RedisModule\_BlockClient) cannot be used: 1. If the client is a Lua script. 2. If the client is executing a MULTI block. In these cases, a call to [`RedisModule\_BlockClient()`](#RedisModule\_BlockClient) will \*\*not\*\* block the client, but instead produce a specific error reply. A module that registers a `timeout\_callback` function can also be unblocked using the `CLIENT UNBLOCK` command, which will trigger the timeout callback. If a callback function is not registered, then the blocked client will be treated as if it is not in a blocked state and `CLIENT UNBLOCK` will return a zero value. Measuring background time: By default the time spent in the blocked command is not account for the total command duration. To include such time you should use [`RedisModule\_BlockedClientMeasureTimeStart()`](#RedisModule\_BlockedClientMeasureTimeStart) and [`RedisModule\_BlockedClientMeasureTimeEnd()`](#RedisModule\_BlockedClientMeasureTimeEnd) one, or multiple times within the blocking command background work. ### `RedisModule\_BlockClientOnAuth` RedisModuleBlockedClient \*RedisModule\_BlockClientOnAuth(RedisModuleCtx \*ctx, RedisModuleAuthCallback reply\_callback, ; | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.12268833070993423,
0.07464609295129776,
-0.04848455637693405,
0.04765790328383446,
0.02091224491596222,
-0.08439906686544418,
0.0384947694838047,
-0.03109772875905037,
0.020026126876473427,
-0.02566942758858204,
-0.005333370994776487,
-0.027311047539114952,
0.07017084956169128,
0.028462... | 0.052929 |
zero value. Measuring background time: By default the time spent in the blocked command is not account for the total command duration. To include such time you should use [`RedisModule\_BlockedClientMeasureTimeStart()`](#RedisModule\_BlockedClientMeasureTimeStart) and [`RedisModule\_BlockedClientMeasureTimeEnd()`](#RedisModule\_BlockedClientMeasureTimeEnd) one, or multiple times within the blocking command background work. ### `RedisModule\_BlockClientOnAuth` RedisModuleBlockedClient \*RedisModule\_BlockClientOnAuth(RedisModuleCtx \*ctx, RedisModuleAuthCallback reply\_callback, ; \*\*Available since:\*\* 7.2.0 Block the current client for module authentication in the background. If module auth is not in progress on the client, the API returns NULL. Otherwise, the client is blocked and the `RedisModule\_BlockedClient` is returned similar to the [`RedisModule\_BlockClient`](#RedisModule\_BlockClient) API. Note: Only use this API from the context of a module auth callback. ### `RedisModule\_BlockClientGetPrivateData` void \*RedisModule\_BlockClientGetPrivateData(RedisModuleBlockedClient \*blocked\_client); \*\*Available since:\*\* 7.2.0 Get the private data that was previusely set on a blocked client ### `RedisModule\_BlockClientSetPrivateData` void RedisModule\_BlockClientSetPrivateData(RedisModuleBlockedClient \*blocked\_client, void \*private\_data); \*\*Available since:\*\* 7.2.0 Set private data on a blocked client ### `RedisModule\_BlockClientOnKeys` RedisModuleBlockedClient \*RedisModule\_BlockClientOnKeys(RedisModuleCtx \*ctx, RedisModuleCmdFunc reply\_callback, ; \*\*Available since:\*\* 6.0.0 This call is similar to [`RedisModule\_BlockClient()`](#RedisModule\_BlockClient), however in this case we don't just block the client, but also ask Redis to unblock it automatically once certain keys become "ready", that is, contain more data. Basically this is similar to what a typical Redis command usually does, like BLPOP or BZPOPMAX: the client blocks if it cannot be served ASAP, and later when the key receives new data (a list push for instance), the client is unblocked and served. However in the case of this module API, when the client is unblocked? 1. If you block on a key of a type that has blocking operations associated, like a list, a sorted set, a stream, and so forth, the client may be unblocked once the relevant key is targeted by an operation that normally unblocks the native blocking operations for that type. So if we block on a list key, an RPUSH command may unblock our client and so forth. 2. If you are implementing your native data type, or if you want to add new unblocking conditions in addition to "1", you can call the modules API [`RedisModule\_SignalKeyAsReady()`](#RedisModule\_SignalKeyAsReady). Anyway we can't be sure if the client should be unblocked just because the key is signaled as ready: for instance a successive operation may change the key, or a client in queue before this one can be served, modifying the key as well and making it empty again. So when a client is blocked with [`RedisModule\_BlockClientOnKeys()`](#RedisModule\_BlockClientOnKeys) the reply callback is not called after [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient) is called, but every time a key is signaled as ready: if the reply callback can serve the client, it returns `REDISMODULE\_OK` and the client is unblocked, otherwise it will return `REDISMODULE\_ERR` and we'll try again later. The reply callback can access the key that was signaled as ready by calling the API [`RedisModule\_GetBlockedClientReadyKey()`](#RedisModule\_GetBlockedClientReadyKey), that returns just the string name of the key as a `RedisModuleString` object. Thanks to this system we can setup complex blocking scenarios, like unblocking a client only if a list contains at least 5 items or other more fancy logics. Note that another difference with [`RedisModule\_BlockClient()`](#RedisModule\_BlockClient), is that here we pass the private data directly when blocking the client: it will be accessible later in the reply callback. Normally when blocking with [`RedisModule\_BlockClient()`](#RedisModule\_BlockClient) the private data to reply to the client is passed when calling [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient) but here the unblocking is performed by Redis itself, so we need to have some private data before hand. The private data is used to store any information about the specific unblocking operation that you are implementing. Such information will be freed using the `free\_privdata` callback provided by the user. However the reply | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.06131891533732414,
0.051514096558094025,
-0.08203888684511185,
0.027187997475266457,
0.042033787816762924,
-0.07045034319162369,
0.02371237985789776,
-0.0014022282557561994,
0.05167732015252113,
-0.03419274464249611,
-0.002383577637374401,
-0.1082196980714798,
0.015026313252747059,
0.01... | 0.056075 |
unblocking is performed by Redis itself, so we need to have some private data before hand. The private data is used to store any information about the specific unblocking operation that you are implementing. Such information will be freed using the `free\_privdata` callback provided by the user. However the reply callback will be able to access the argument vector of the command, so the private data is often not needed. Note: Under normal circumstances [`RedisModule\_UnblockClient`](#RedisModule\_UnblockClient) should not be called for clients that are blocked on keys (Either the key will become ready or a timeout will occur). If for some reason you do want to call RedisModule\_UnblockClient it is possible: Client will be handled as if it were timed-out (You must implement the timeout callback in that case). ### `RedisModule\_BlockClientOnKeysWithFlags` RedisModuleBlockedClient \*RedisModule\_BlockClientOnKeysWithFlags(RedisModuleCtx \*ctx, RedisModuleCmdFunc reply\_callback, ; \*\*Available since:\*\* 7.2.0 Same as [`RedisModule\_BlockClientOnKeys`](#RedisModule\_BlockClientOnKeys), but can take `REDISMODULE\_BLOCK\_`\* flags Can be either `REDISMODULE\_BLOCK\_UNBLOCK\_DEFAULT`, which means default behavior (same as calling [`RedisModule\_BlockClientOnKeys`](#RedisModule\_BlockClientOnKeys)) The flags is a bit mask of these: - `REDISMODULE\_BLOCK\_UNBLOCK\_DELETED`: The clients should to be awakened in case any of `keys` are deleted. Mostly useful for commands that require the key to exist (like XREADGROUP) ### `RedisModule\_SignalKeyAsReady` void RedisModule\_SignalKeyAsReady(RedisModuleCtx \*ctx, RedisModuleString \*key); \*\*Available since:\*\* 6.0.0 This function is used in order to potentially unblock a client blocked on keys with [`RedisModule\_BlockClientOnKeys()`](#RedisModule\_BlockClientOnKeys). When this function is called, all the clients blocked for this key will get their `reply\_callback` called. ### `RedisModule\_UnblockClient` int RedisModule\_UnblockClient(RedisModuleBlockedClient \*bc, void \*privdata); \*\*Available since:\*\* 4.0.0 Unblock a client blocked by `RedisModule\_BlockedClient`. This will trigger the reply callbacks to be called in order to reply to the client. The 'privdata' argument will be accessible by the reply callback, so the caller of this function can pass any value that is needed in order to actually reply to the client. A common usage for 'privdata' is a thread that computes something that needs to be passed to the client, included but not limited some slow to compute reply or some reply obtained via networking. Note 1: this function can be called from threads spawned by the module. Note 2: when we unblock a client that is blocked for keys using the API [`RedisModule\_BlockClientOnKeys()`](#RedisModule\_BlockClientOnKeys), the privdata argument here is not used. Unblocking a client that was blocked for keys using this API will still require the client to get some reply, so the function will use the "timeout" handler in order to do so (The privdata provided in [`RedisModule\_BlockClientOnKeys()`](#RedisModule\_BlockClientOnKeys) is accessible from the timeout callback via [`RedisModule\_GetBlockedClientPrivateData`](#RedisModule\_GetBlockedClientPrivateData)). ### `RedisModule\_AbortBlock` int RedisModule\_AbortBlock(RedisModuleBlockedClient \*bc); \*\*Available since:\*\* 4.0.0 Abort a blocked client blocking operation: the client will be unblocked without firing any callback. ### `RedisModule\_SetDisconnectCallback` void RedisModule\_SetDisconnectCallback(RedisModuleBlockedClient \*bc, RedisModuleDisconnectFunc callback); \*\*Available since:\*\* 5.0.0 Set a callback that will be called if a blocked client disconnects before the module has a chance to call [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient) Usually what you want to do there, is to cleanup your module state so that you can call [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient) safely, otherwise the client will remain blocked forever if the timeout is large. Notes: 1. It is not safe to call Reply\* family functions here, it is also useless since the client is gone. 2. This callback is not called if the client disconnects because of a timeout. In such a case, the client is unblocked automatically and the timeout callback is called. ### `RedisModule\_IsBlockedReplyRequest` int RedisModule\_IsBlockedReplyRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command was called in order to fill the reply for a blocked client. ### `RedisModule\_IsBlockedTimeoutRequest` int RedisModule\_IsBlockedTimeoutRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command was called in order to fill the reply | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.09703602641820908,
0.0010198048548772931,
-0.10299833863973618,
0.048882436007261276,
-0.008147330023348331,
-0.022960079833865166,
0.006282041314989328,
-0.0225497018545866,
0.03733719885349274,
-0.01399286463856697,
0.007258704863488674,
0.022272730246186256,
-0.007372533902525902,
-0... | 0.024278 |
is called. ### `RedisModule\_IsBlockedReplyRequest` int RedisModule\_IsBlockedReplyRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command was called in order to fill the reply for a blocked client. ### `RedisModule\_IsBlockedTimeoutRequest` int RedisModule\_IsBlockedTimeoutRequest(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Return non-zero if a module command was called in order to fill the reply for a blocked client that timed out. ### `RedisModule\_GetBlockedClientPrivateData` void \*RedisModule\_GetBlockedClientPrivateData(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Get the private data set by [`RedisModule\_UnblockClient()`](#RedisModule\_UnblockClient) ### `RedisModule\_GetBlockedClientReadyKey` RedisModuleString \*RedisModule\_GetBlockedClientReadyKey(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.0 Get the key that is ready when the reply callback is called in the context of a client blocked by [`RedisModule\_BlockClientOnKeys()`](#RedisModule\_BlockClientOnKeys). ### `RedisModule\_GetBlockedClientHandle` RedisModuleBlockedClient \*RedisModule\_GetBlockedClientHandle(RedisModuleCtx \*ctx); \*\*Available since:\*\* 5.0.0 Get the blocked client associated with a given context. This is useful in the reply and timeout callbacks of blocked clients, before sometimes the module has the blocked client handle references around, and wants to cleanup it. ### `RedisModule\_BlockedClientDisconnected` int RedisModule\_BlockedClientDisconnected(RedisModuleCtx \*ctx); \*\*Available since:\*\* 5.0.0 Return true if when the free callback of a blocked client is called, the reason for the client to be unblocked is that it disconnected while it was blocked. ## Thread Safe Contexts ### `RedisModule\_GetThreadSafeContext` RedisModuleCtx \*RedisModule\_GetThreadSafeContext(RedisModuleBlockedClient \*bc); \*\*Available since:\*\* 4.0.0 Return a context which can be used inside threads to make Redis context calls with certain modules APIs. If 'bc' is not NULL then the module will be bound to a blocked client, and it will be possible to use the `RedisModule\_Reply\*` family of functions to accumulate a reply for when the client will be unblocked. Otherwise the thread safe context will be detached by a specific client. To call non-reply APIs, the thread safe context must be prepared with: RedisModule\_ThreadSafeContextLock(ctx); ... make your call here ... RedisModule\_ThreadSafeContextUnlock(ctx); This is not needed when using `RedisModule\_Reply\*` functions, assuming that a blocked client was used when the context was created, otherwise no `RedisModule\_Reply`\* call should be made at all. NOTE: If you're creating a detached thread safe context (bc is NULL), consider using [`RedisModule\_GetDetachedThreadSafeContext`](#RedisModule\_GetDetachedThreadSafeContext) which will also retain the module ID and thus be more useful for logging. ### `RedisModule\_GetDetachedThreadSafeContext` RedisModuleCtx \*RedisModule\_GetDetachedThreadSafeContext(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.9 Return a detached thread safe context that is not associated with any specific blocked client, but is associated with the module's context. This is useful for modules that wish to hold a global context over a long term, for purposes such as logging. ### `RedisModule\_FreeThreadSafeContext` void RedisModule\_FreeThreadSafeContext(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Release a thread safe context. ### `RedisModule\_ThreadSafeContextLock` void RedisModule\_ThreadSafeContextLock(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Acquire the server lock before executing a thread safe API call. This is not needed for `RedisModule\_Reply\*` calls when there is a blocked client connected to the thread safe context. ### `RedisModule\_ThreadSafeContextTryLock` int RedisModule\_ThreadSafeContextTryLock(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.0.8 Similar to [`RedisModule\_ThreadSafeContextLock`](#RedisModule\_ThreadSafeContextLock) but this function would not block if the server lock is already acquired. If successful (lock acquired) `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set accordingly. ### `RedisModule\_ThreadSafeContextUnlock` void RedisModule\_ThreadSafeContextUnlock(RedisModuleCtx \*ctx); \*\*Available since:\*\* 4.0.0 Release the server lock after a thread safe API call was executed. ## Module Keyspace Notifications API ### `RedisModule\_SubscribeToKeyspaceEvents` int RedisModule\_SubscribeToKeyspaceEvents(RedisModuleCtx \*ctx, int types, RedisModuleNotificationFunc callback); \*\*Available since:\*\* 4.0.9 Subscribe to keyspace notifications. This is a low-level version of the keyspace-notifications API. A module can register callbacks to be notified when keyspace events occur. Notification events are filtered by their type (string events, set events, etc), and the subscriber callback receives only events that match a specific mask of event types. When subscribing to notifications with [`RedisModule\_SubscribeToKeyspaceEvents`](#RedisModule\_SubscribeToKeyspaceEvents) the module must provide an event type-mask, denoting the events the subscriber is interested in. This can be an ORed mask of | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.022057093679904938,
0.038112834095954895,
-0.09719625115394592,
0.030219074338674545,
0.00528284115716815,
-0.01289067417383194,
0.05685081705451012,
0.019717738032341003,
-0.025039659813046455,
-0.012011957354843616,
0.05260052531957626,
-0.06378232687711716,
0.01135907880961895,
-0.03... | 0.119413 |
their type (string events, set events, etc), and the subscriber callback receives only events that match a specific mask of event types. When subscribing to notifications with [`RedisModule\_SubscribeToKeyspaceEvents`](#RedisModule\_SubscribeToKeyspaceEvents) the module must provide an event type-mask, denoting the events the subscriber is interested in. This can be an ORed mask of any of the following flags: - `REDISMODULE\_NOTIFY\_GENERIC`: Generic commands like DEL, EXPIRE, RENAME - `REDISMODULE\_NOTIFY\_STRING`: String events - `REDISMODULE\_NOTIFY\_LIST`: List events - `REDISMODULE\_NOTIFY\_SET`: Set events - `REDISMODULE\_NOTIFY\_HASH`: Hash events - `REDISMODULE\_NOTIFY\_ZSET`: Sorted Set events - `REDISMODULE\_NOTIFY\_EXPIRED`: Expiration events - `REDISMODULE\_NOTIFY\_EVICTED`: Eviction events - `REDISMODULE\_NOTIFY\_STREAM`: Stream events - `REDISMODULE\_NOTIFY\_MODULE`: Module types events - `REDISMODULE\_NOTIFY\_KEYMISS`: Key-miss events Notice, key-miss event is the only type of event that is fired from within a read command. Performing RedisModule\_Call with a write command from within this notification is wrong and discourage. It will cause the read command that trigger the event to be replicated to the AOF/Replica. - `REDISMODULE\_NOTIFY\_ALL`: All events (Excluding `REDISMODULE\_NOTIFY\_KEYMISS`) - `REDISMODULE\_NOTIFY\_LOADED`: A special notification available only for modules, indicates that the key was loaded from persistence. Notice, when this event fires, the given key can not be retained, use RedisModule\_CreateStringFromString instead. We do not distinguish between key events and keyspace events, and it is up to the module to filter the actions taken based on the key. The subscriber signature is: int (\*RedisModuleNotificationFunc) (RedisModuleCtx \*ctx, int type, const char \*event, RedisModuleString \*key); `type` is the event type bit, that must match the mask given at registration time. The event string is the actual command being executed, and key is the relevant Redis key. Notification callback gets executed with a redis context that can not be used to send anything to the client, and has the db number where the event occurred as its selected db number. Notice that it is not necessary to enable notifications in redis.conf for module notifications to work. Warning: the notification callbacks are performed in a synchronous manner, so notification callbacks must to be fast, or they would slow Redis down. If you need to take long actions, use threads to offload them. Moreover, the fact that the notification is executed synchronously means that the notification code will be executed in the middle on Redis logic (commands logic, eviction, expire). Changing the key space while the logic runs is dangerous and discouraged. In order to react to key space events with write actions, please refer to [`RedisModule\_AddPostNotificationJob`](#RedisModule\_AddPostNotificationJob). See [https://redis.io/topics/notifications](https://redis.io/topics/notifications) for more information. ### `RedisModule\_AddPostNotificationJob` int RedisModule\_AddPostNotificationJob(RedisModuleCtx \*ctx, RedisModulePostNotificationJobFunc callback, void \*privdata, void (\*free\_privdata)(void\*)); \*\*Available since:\*\* 7.2.0 When running inside a key space notification callback, it is dangerous and highly discouraged to perform any write operation (See [`RedisModule\_SubscribeToKeyspaceEvents`](#RedisModule\_SubscribeToKeyspaceEvents)). In order to still perform write actions in this scenario, Redis provides [`RedisModule\_AddPostNotificationJob`](#RedisModule\_AddPostNotificationJob) API. The API allows to register a job callback which Redis will call when the following condition are promised to be fulfilled: 1. It is safe to perform any write operation. 2. The job will be called atomically along side the key space notification. Notice, one job might trigger key space notifications that will trigger more jobs. This raises a concerns of entering an infinite loops, we consider infinite loops as a logical bug that need to be fixed in the module, an attempt to protect against infinite loops by halting the execution could result in violation of the feature correctness and so Redis will make no attempt to protect the module from infinite loops. '`free\_pd`' can be NULL and in such case will not be used. Return `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` if was called while loading data from disk (AOF or RDB) or if the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.016844013705849648,
-0.03527521714568138,
0.0017430963926017284,
0.06400282680988312,
0.060816001147031784,
-0.02410362847149372,
0.11986593157052994,
-0.030429990962147713,
0.038859207183122635,
-0.05088881775736809,
-0.009029067121446133,
-0.08931252360343933,
0.02106044627726078,
0.0... | 0.128378 |
of the feature correctness and so Redis will make no attempt to protect the module from infinite loops. '`free\_pd`' can be NULL and in such case will not be used. Return `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` if was called while loading data from disk (AOF or RDB) or if the instance is a readonly replica. ### `RedisModule\_GetNotifyKeyspaceEvents` int RedisModule\_GetNotifyKeyspaceEvents(void); \*\*Available since:\*\* 6.0.0 Get the configured bitmap of notify-keyspace-events (Could be used for additional filtering in `RedisModuleNotificationFunc`) ### `RedisModule\_NotifyKeyspaceEvent` int RedisModule\_NotifyKeyspaceEvent(RedisModuleCtx \*ctx, int type, const char \*event, RedisModuleString \*key); \*\*Available since:\*\* 6.0.0 Expose notifyKeyspaceEvent to modules ## Modules Cluster API ### `RedisModule\_RegisterClusterMessageReceiver` void RedisModule\_RegisterClusterMessageReceiver(RedisModuleCtx \*ctx, uint8\_t type, RedisModuleClusterMessageReceiver callback); \*\*Available since:\*\* 5.0.0 Register a callback receiver for cluster messages of type 'type'. If there was already a registered callback, this will replace the callback function with the one provided, otherwise if the callback is set to NULL and there is already a callback for this function, the callback is unregistered (so this API call is also used in order to delete the receiver). ### `RedisModule\_SendClusterMessage` int RedisModule\_SendClusterMessage(RedisModuleCtx \*ctx, const char \*target\_id, uint8\_t type, const char \*msg, uint32\_t len); \*\*Available since:\*\* 5.0.0 Send a message to all the nodes in the cluster if `target` is NULL, otherwise at the specified target, which is a `REDISMODULE\_NODE\_ID\_LEN` bytes node ID, as returned by the receiver callback or by the nodes iteration functions. The function returns `REDISMODULE\_OK` if the message was successfully sent, otherwise if the node is not connected or such node ID does not map to any known cluster node, `REDISMODULE\_ERR` is returned. ### `RedisModule\_GetClusterNodesList` char \*\*RedisModule\_GetClusterNodesList(RedisModuleCtx \*ctx, size\_t \*numnodes); \*\*Available since:\*\* 5.0.0 Return an array of string pointers, each string pointer points to a cluster node ID of exactly `REDISMODULE\_NODE\_ID\_LEN` bytes (without any null term). The number of returned node IDs is stored into `\*numnodes`. However if this function is called by a module not running an a Redis instance with Redis Cluster enabled, NULL is returned instead. The IDs returned can be used with [`RedisModule\_GetClusterNodeInfo()`](#RedisModule\_GetClusterNodeInfo) in order to get more information about single node. The array returned by this function must be freed using the function [`RedisModule\_FreeClusterNodesList()`](#RedisModule\_FreeClusterNodesList). Example: size\_t count, j; char \*\*ids = RedisModule\_GetClusterNodesList(ctx,&count); for (j = 0; j < count; j++) { RedisModule\_Log(ctx,"notice","Node %.\*s", REDISMODULE\_NODE\_ID\_LEN,ids[j]); } RedisModule\_FreeClusterNodesList(ids); ### `RedisModule\_FreeClusterNodesList` void RedisModule\_FreeClusterNodesList(char \*\*ids); \*\*Available since:\*\* 5.0.0 Free the node list obtained with [`RedisModule\_GetClusterNodesList`](#RedisModule\_GetClusterNodesList). ### `RedisModule\_GetMyClusterID` const char \*RedisModule\_GetMyClusterID(void); \*\*Available since:\*\* 5.0.0 Return this node ID (`REDISMODULE\_CLUSTER\_ID\_LEN` bytes) or NULL if the cluster is disabled. ### `RedisModule\_GetClusterSize` size\_t RedisModule\_GetClusterSize(void); \*\*Available since:\*\* 5.0.0 Return the number of nodes in the cluster, regardless of their state (handshake, noaddress, ...) so that the number of active nodes may actually be smaller, but not greater than this number. If the instance is not in cluster mode, zero is returned. ### `RedisModule\_GetClusterNodeInfo` int RedisModule\_GetClusterNodeInfo(RedisModuleCtx \*ctx, const char \*id, char \*ip, char \*master\_id, int \*port, int \*flags); \*\*Available since:\*\* 5.0.0 Populate the specified info for the node having as ID the specified 'id', then returns `REDISMODULE\_OK`. Otherwise if the format of node ID is invalid or the node ID does not exist from the POV of this local node, `REDISMODULE\_ERR` is returned. The arguments `ip`, `master\_id`, `port` and `flags` can be NULL in case we don't need to populate back certain info. If an `ip` and `master\_id` (only populated if the instance is a slave) are specified, they point to buffers holding at least `REDISMODULE\_NODE\_ID\_LEN` bytes. The strings written back as `ip` and `master\_id` are not null terminated. The list of flags reported is the following: \* `REDISMODULE\_NODE\_MYSELF`: This node \* `REDISMODULE\_NODE\_MASTER`: The node is a master | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.02542608045041561,
-0.023577604442834854,
-0.06481867283582687,
0.00044364601490087807,
0.05583985522389412,
-0.05060616880655289,
0.08022931963205338,
0.011630917899310589,
0.004942173603922129,
-0.024225883185863495,
0.04610748961567879,
-0.06309220939874649,
0.041985884308815,
-0.085... | 0.104584 |
(only populated if the instance is a slave) are specified, they point to buffers holding at least `REDISMODULE\_NODE\_ID\_LEN` bytes. The strings written back as `ip` and `master\_id` are not null terminated. The list of flags reported is the following: \* `REDISMODULE\_NODE\_MYSELF`: This node \* `REDISMODULE\_NODE\_MASTER`: The node is a master \* `REDISMODULE\_NODE\_SLAVE`: The node is a replica \* `REDISMODULE\_NODE\_PFAIL`: We see the node as failing \* `REDISMODULE\_NODE\_FAIL`: The cluster agrees the node is failing \* `REDISMODULE\_NODE\_NOFAILOVER`: The slave is configured to never failover ### `RedisModule\_SetClusterFlags` void RedisModule\_SetClusterFlags(RedisModuleCtx \*ctx, uint64\_t flags); \*\*Available since:\*\* 5.0.0 Set Redis Cluster flags in order to change the normal behavior of Redis Cluster, especially with the goal of disabling certain functions. This is useful for modules that use the Cluster API in order to create a different distributed system, but still want to use the Redis Cluster message bus. Flags that can be set: \* `CLUSTER\_MODULE\_FLAG\_NO\_FAILOVER` \* `CLUSTER\_MODULE\_FLAG\_NO\_REDIRECTION` With the following effects: \* `NO\_FAILOVER`: prevent Redis Cluster slaves from failing over a dead master. Also disables the replica migration feature. \* `NO\_REDIRECTION`: Every node will accept any key, without trying to perform partitioning according to the Redis Cluster algorithm. Slots information will still be propagated across the cluster, but without effect. ## Modules Timers API Module timers are a high precision "green timers" abstraction where every module can register even millions of timers without problems, even if the actual event loop will just have a single timer that is used to awake the module timers subsystem in order to process the next event. All the timers are stored into a radix tree, ordered by expire time, when the main Redis event loop timer callback is called, we try to process all the timers already expired one after the other. Then we re-enter the event loop registering a timer that will expire when the next to process module timer will expire. Every time the list of active timers drops to zero, we unregister the main event loop timer, so that there is no overhead when such feature is not used. ### `RedisModule\_CreateTimer` RedisModuleTimerID RedisModule\_CreateTimer(RedisModuleCtx \*ctx, mstime\_t period, RedisModuleTimerProc callback, void \*data); \*\*Available since:\*\* 5.0.0 Create a new timer that will fire after `period` milliseconds, and will call the specified function using `data` as argument. The returned timer ID can be used to get information from the timer or to stop it before it fires. Note that for the common use case of a repeating timer (Re-registration of the timer inside the `RedisModuleTimerProc` callback) it matters when this API is called: If it is called at the beginning of 'callback' it means the event will triggered every 'period'. If it is called at the end of 'callback' it means there will 'period' milliseconds gaps between events. (If the time it takes to execute 'callback' is negligible the two statements above mean the same) ### `RedisModule\_StopTimer` int RedisModule\_StopTimer(RedisModuleCtx \*ctx, RedisModuleTimerID id, void \*\*data); \*\*Available since:\*\* 5.0.0 Stop a timer, returns `REDISMODULE\_OK` if the timer was found, belonged to the calling module, and was stopped, otherwise `REDISMODULE\_ERR` is returned. If not NULL, the data pointer is set to the value of the data argument when the timer was created. ### `RedisModule\_GetTimerInfo` int RedisModule\_GetTimerInfo(RedisModuleCtx \*ctx, RedisModuleTimerID id, uint64\_t \*remaining, void \*\*data); \*\*Available since:\*\* 5.0.0 Obtain information about a timer: its remaining time before firing (in milliseconds), and the private data pointer associated with the timer. If the timer specified does not exist or belongs to a different module no information is returned and the function returns `REDISMODULE\_ERR`, otherwise `REDISMODULE\_OK` is returned. The arguments remaining or data can be NULL if the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.00875362940132618,
0.0014705476351082325,
-0.06908532232046127,
0.04716144874691963,
0.049776166677474976,
-0.03373843804001808,
0.009727943688631058,
-0.02275325544178486,
-0.05829562619328499,
-0.00005776532634627074,
-0.005505644250661135,
-0.03397219628095627,
0.02500511333346367,
-0... | 0.152042 |
time before firing (in milliseconds), and the private data pointer associated with the timer. If the timer specified does not exist or belongs to a different module no information is returned and the function returns `REDISMODULE\_ERR`, otherwise `REDISMODULE\_OK` is returned. The arguments remaining or data can be NULL if the caller does not need certain information. ## Modules EventLoop API ### `RedisModule\_EventLoopAdd` int RedisModule\_EventLoopAdd(int fd, int mask, RedisModuleEventLoopFunc func, void \*user\_data); \*\*Available since:\*\* 7.0.0 Add a pipe / socket event to the event loop. \* `mask` must be one of the following values: \* `REDISMODULE\_EVENTLOOP\_READABLE` \* `REDISMODULE\_EVENTLOOP\_WRITABLE` \* `REDISMODULE\_EVENTLOOP\_READABLE | REDISMODULE\_EVENTLOOP\_WRITABLE` On success `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to the following values: \* ERANGE: `fd` is negative or higher than `maxclients` Redis config. \* EINVAL: `callback` is NULL or `mask` value is invalid. `errno` might take other values in case of an internal error. Example: void onReadable(int fd, void \*user\_data, int mask) { char buf[32]; int bytes = read(fd,buf,sizeof(buf)); printf("Read %d bytes \n", bytes); } RedisModule\_EventLoopAdd(fd, REDISMODULE\_EVENTLOOP\_READABLE, onReadable, NULL); ### `RedisModule\_EventLoopDel` int RedisModule\_EventLoopDel(int fd, int mask); \*\*Available since:\*\* 7.0.0 Delete a pipe / socket event from the event loop. \* `mask` must be one of the following values: \* `REDISMODULE\_EVENTLOOP\_READABLE` \* `REDISMODULE\_EVENTLOOP\_WRITABLE` \* `REDISMODULE\_EVENTLOOP\_READABLE | REDISMODULE\_EVENTLOOP\_WRITABLE` On success `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to the following values: \* ERANGE: `fd` is negative or higher than `maxclients` Redis config. \* EINVAL: `mask` value is invalid. ### `RedisModule\_EventLoopAddOneShot` int RedisModule\_EventLoopAddOneShot(RedisModuleEventLoopOneShotFunc func, void \*user\_data); \*\*Available since:\*\* 7.0.0 This function can be called from other threads to trigger callback on Redis main thread. On success `REDISMODULE\_OK` is returned. If `func` is NULL `REDISMODULE\_ERR` is returned and errno is set to EINVAL. ## Modules ACL API Implements a hook into the authentication and authorization within Redis. ### `RedisModule\_CreateModuleUser` RedisModuleUser \*RedisModule\_CreateModuleUser(const char \*name); \*\*Available since:\*\* 6.0.0 Creates a Redis ACL user that the module can use to authenticate a client. After obtaining the user, the module should set what such user can do using the `RedisModule\_SetUserACL()` function. Once configured, the user can be used in order to authenticate a connection, with the specified ACL rules, using the `RedisModule\_AuthClientWithUser()` function. Note that: \* Users created here are not listed by the ACL command. \* Users created here are not checked for duplicated name, so it's up to the module calling this function to take care of not creating users with the same name. \* The created user can be used to authenticate multiple Redis connections. The caller can later free the user using the function [`RedisModule\_FreeModuleUser()`](#RedisModule\_FreeModuleUser). When this function is called, if there are still clients authenticated with this user, they are disconnected. The function to free the user should only be used when the caller really wants to invalidate the user to define a new one with different capabilities. ### `RedisModule\_FreeModuleUser` int RedisModule\_FreeModuleUser(RedisModuleUser \*user); \*\*Available since:\*\* 6.0.0 Frees a given user and disconnects all of the clients that have been authenticated with it. See [`RedisModule\_CreateModuleUser`](#RedisModule\_CreateModuleUser) for detailed usage. ### `RedisModule\_SetModuleUserACL` int RedisModule\_SetModuleUserACL(RedisModuleUser \*user, const char\* acl); \*\*Available since:\*\* 6.0.0 Sets the permissions of a user created through the redis module interface. The syntax is the same as ACL SETUSER, so refer to the documentation in acl.c for more information. See [`RedisModule\_CreateModuleUser`](#RedisModule\_CreateModuleUser) for detailed usage. Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` on failure and will set an errno describing why the operation failed. ### `RedisModule\_SetModuleUserACLString` int RedisModule\_SetModuleUserACLString(RedisModuleCtx \*ctx, RedisModuleUser \*user, const char \*acl, RedisModuleString \*\*error); \*\*Available since:\*\* 7.0.6 Sets the permission of a user with a complete ACL string, such as one would use on | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.029055438935756683,
0.03110956959426403,
-0.10006647557020187,
0.07721124589443207,
-0.02953682839870453,
-0.03548622503876686,
0.0872969999909401,
0.0621199756860733,
0.03383639454841614,
-0.03031543456017971,
0.03039821796119213,
-0.10263124853372574,
-0.050118595361709595,
-0.01387740... | 0.168437 |
Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` on failure and will set an errno describing why the operation failed. ### `RedisModule\_SetModuleUserACLString` int RedisModule\_SetModuleUserACLString(RedisModuleCtx \*ctx, RedisModuleUser \*user, const char \*acl, RedisModuleString \*\*error); \*\*Available since:\*\* 7.0.6 Sets the permission of a user with a complete ACL string, such as one would use on the redis ACL SETUSER command line API. This differs from [`RedisModule\_SetModuleUserACL`](#RedisModule\_SetModuleUserACL), which only takes single ACL operations at a time. Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` on failure if a `RedisModuleString` is provided in error, a string describing the error will be returned ### `RedisModule\_GetModuleUserACLString` RedisModuleString \*RedisModule\_GetModuleUserACLString(RedisModuleUser \*user); \*\*Available since:\*\* 7.0.6 Get the ACL string for a given user Returns a `RedisModuleString` ### `RedisModule\_GetCurrentUserName` RedisModuleString \*RedisModule\_GetCurrentUserName(RedisModuleCtx \*ctx); \*\*Available since:\*\* 7.0.0 Retrieve the user name of the client connection behind the current context. The user name can be used later, in order to get a `RedisModuleUser`. See more information in [`RedisModule\_GetModuleUserFromUserName`](#RedisModule\_GetModuleUserFromUserName). The returned string must be released with [`RedisModule\_FreeString()`](#RedisModule\_FreeString) or by enabling automatic memory management. ### `RedisModule\_GetModuleUserFromUserName` RedisModuleUser \*RedisModule\_GetModuleUserFromUserName(RedisModuleString \*name); \*\*Available since:\*\* 7.0.0 A `RedisModuleUser` can be used to check if command, key or channel can be executed or accessed according to the ACLs rules associated with that user. When a Module wants to do ACL checks on a general ACL user (not created by [`RedisModule\_CreateModuleUser`](#RedisModule\_CreateModuleUser)), it can get the `RedisModuleUser` from this API, based on the user name retrieved by [`RedisModule\_GetCurrentUserName`](#RedisModule\_GetCurrentUserName). Since a general ACL user can be deleted at any time, this `RedisModuleUser` should be used only in the context where this function was called. In order to do ACL checks out of that context, the Module can store the user name, and call this API at any other context. Returns NULL if the user is disabled or the user does not exist. The caller should later free the user using the function [`RedisModule\_FreeModuleUser()`](#RedisModule\_FreeModuleUser). ### `RedisModule\_ACLCheckCommandPermissions` int RedisModule\_ACLCheckCommandPermissions(RedisModuleUser \*user, RedisModuleString \*\*argv, int argc); \*\*Available since:\*\* 7.0.0 Checks if the command can be executed by the user, according to the ACLs associated with it. On success a `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to the following values: \* ENOENT: Specified command does not exist. \* EACCES: Command cannot be executed, according to ACL rules ### `RedisModule\_ACLCheckKeyPermissions` int RedisModule\_ACLCheckKeyPermissions(RedisModuleUser \*user, RedisModuleString \*key, int flags); \*\*Available since:\*\* 7.0.0 Check if the key can be accessed by the user according to the ACLs attached to the user and the flags representing the key access. The flags are the same that are used in the keyspec for logical operations. These flags are documented in [`RedisModule\_SetCommandInfo`](#RedisModule\_SetCommandInfo) as the `REDISMODULE\_CMD\_KEY\_ACCESS`, `REDISMODULE\_CMD\_KEY\_UPDATE`, `REDISMODULE\_CMD\_KEY\_INSERT`, and `REDISMODULE\_CMD\_KEY\_DELETE` flags. If no flags are supplied, the user is still required to have some access to the key for this command to return successfully. If the user is able to access the key then `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to one of the following values: \* EINVAL: The provided flags are invalid. \* EACCESS: The user does not have permission to access the key. ### `RedisModule\_ACLCheckChannelPermissions` int RedisModule\_ACLCheckChannelPermissions(RedisModuleUser \*user, RedisModuleString \*ch, int flags); \*\*Available since:\*\* 7.0.0 Check if the pubsub channel can be accessed by the user based off of the given access flags. See [`RedisModule\_ChannelAtPosWithFlags`](#RedisModule\_ChannelAtPosWithFlags) for more information about the possible flags that can be passed in. If the user is able to access the pubsub channel then `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to one of the following values: \* EINVAL: The provided flags are invalid. \* EACCESS: The user does not have permission to access the pubsub channel. ### `RedisModule\_ACLAddLogEntry` int RedisModule\_ACLAddLogEntry(RedisModuleCtx \*ctx, | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.03887438029050827,
0.02242635190486908,
-0.08319592475891113,
0.06153689697384834,
-0.04054996743798256,
-0.065894216299057,
0.12610043585300446,
0.06052428111433983,
-0.043775979429483414,
-0.07874183356761932,
0.031036537140607834,
-0.064351387321949,
0.051052071154117584,
0.016482142... | 0.110517 |
is able to access the pubsub channel then `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set to one of the following values: \* EINVAL: The provided flags are invalid. \* EACCESS: The user does not have permission to access the pubsub channel. ### `RedisModule\_ACLAddLogEntry` int RedisModule\_ACLAddLogEntry(RedisModuleCtx \*ctx, RedisModuleUser \*user, RedisModuleString \*object, RedisModuleACLLogEntryReason reason); \*\*Available since:\*\* 7.0.0 Adds a new entry in the ACL log. Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` on error. For more information about ACL log, please refer to [https://redis.io/commands/acl-log](https://redis.io/commands/acl-log) ### `RedisModule\_ACLAddLogEntryByUserName` int RedisModule\_ACLAddLogEntryByUserName(RedisModuleCtx \*ctx, RedisModuleString \*username, RedisModuleString \*object, RedisModuleACLLogEntryReason reason); \*\*Available since:\*\* 7.2.0 Adds a new entry in the ACL log with the `username` `RedisModuleString` provided. Returns `REDISMODULE\_OK` on success and `REDISMODULE\_ERR` on error. For more information about ACL log, please refer to [https://redis.io/commands/acl-log](https://redis.io/commands/acl-log) ### `RedisModule\_AuthenticateClientWithUser` int RedisModule\_AuthenticateClientWithUser(RedisModuleCtx \*ctx, RedisModuleUser \*module\_user, RedisModuleUserChangedFunc callback, void \*privdata, uint64\_t \*client\_id); \*\*Available since:\*\* 6.0.0 Authenticate the current context's user with the provided redis acl user. Returns `REDISMODULE\_ERR` if the user is disabled. See authenticateClientWithUser for information about callback, `client\_id`, and general usage for authentication. ### `RedisModule\_AuthenticateClientWithACLUser` int RedisModule\_AuthenticateClientWithACLUser(RedisModuleCtx \*ctx, const char \*name, size\_t len, RedisModuleUserChangedFunc callback, void \*privdata, uint64\_t \*client\_id); \*\*Available since:\*\* 6.0.0 Authenticate the current context's user with the provided redis acl user. Returns `REDISMODULE\_ERR` if the user is disabled or the user does not exist. See authenticateClientWithUser for information about callback, `client\_id`, and general usage for authentication. ### `RedisModule\_DeauthenticateAndCloseClient` int RedisModule\_DeauthenticateAndCloseClient(RedisModuleCtx \*ctx, uint64\_t client\_id); \*\*Available since:\*\* 6.0.0 Deauthenticate and close the client. The client resources will not be immediately freed, but will be cleaned up in a background job. This is the recommended way to deauthenticate a client since most clients can't handle users becoming deauthenticated. Returns `REDISMODULE\_ERR` when the client doesn't exist and `REDISMODULE\_OK` when the operation was successful. The client ID is returned from the [`RedisModule\_AuthenticateClientWithUser`](#RedisModule\_AuthenticateClientWithUser) and [`RedisModule\_AuthenticateClientWithACLUser`](#RedisModule\_AuthenticateClientWithACLUser) APIs, but can be obtained through the CLIENT api or through server events. This function is not thread safe, and must be executed within the context of a command or thread safe context. ### `RedisModule\_RedactClientCommandArgument` int RedisModule\_RedactClientCommandArgument(RedisModuleCtx \*ctx, int pos); \*\*Available since:\*\* 7.0.0 Redact the client command argument specified at the given position. Redacted arguments are obfuscated in user facing commands such as SLOWLOG or MONITOR, as well as never being written to server logs. This command may be called multiple times on the same position. Note that the command name, position 0, can not be redacted. Returns `REDISMODULE\_OK` if the argument was redacted and `REDISMODULE\_ERR` if there was an invalid parameter passed in or the position is outside the client argument range. ### `RedisModule\_GetClientCertificate` RedisModuleString \*RedisModule\_GetClientCertificate(RedisModuleCtx \*ctx, uint64\_t client\_id); \*\*Available since:\*\* 6.0.9 Return the X.509 client-side certificate used by the client to authenticate this connection. The return value is an allocated `RedisModuleString` that is a X.509 certificate encoded in PEM (Base64) format. It should be freed (or auto-freed) by the caller. A NULL value is returned in the following conditions: - Connection ID does not exist - Connection is not a TLS connection - Connection is a TLS connection but no client certificate was used ## Modules Dictionary API Implements a sorted dictionary (actually backed by a radix tree) with the usual get / set / del / num-items API, together with an iterator capable of going back and forth. ### `RedisModule\_CreateDict` RedisModuleDict \*RedisModule\_CreateDict(RedisModuleCtx \*ctx); \*\*Available since:\*\* 5.0.0 Create a new dictionary. The 'ctx' pointer can be the current module context or NULL, depending on what you want. Please follow the following rules: 1. Use a NULL context if you plan to retain a reference to this dictionary that will survive the time of the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.02535814419388771,
-0.025457898154854774,
-0.1604013442993164,
0.017701270058751106,
-0.007261462509632111,
-0.04490678757429123,
0.05226610228419304,
0.0014363458612933755,
0.007637823466211557,
-0.04035180062055588,
0.010301589965820312,
-0.05311179533600807,
0.024612100794911385,
0.01... | 0.108596 |
\*\*Available since:\*\* 5.0.0 Create a new dictionary. The 'ctx' pointer can be the current module context or NULL, depending on what you want. Please follow the following rules: 1. Use a NULL context if you plan to retain a reference to this dictionary that will survive the time of the module callback where you created it. 2. Use a NULL context if no context is available at the time you are creating the dictionary (of course...). 3. However use the current callback context as 'ctx' argument if the dictionary time to live is just limited to the callback scope. In this case, if enabled, you can enjoy the automatic memory management that will reclaim the dictionary memory, as well as the strings returned by the Next / Prev dictionary iterator calls. ### `RedisModule\_FreeDict` void RedisModule\_FreeDict(RedisModuleCtx \*ctx, RedisModuleDict \*d); \*\*Available since:\*\* 5.0.0 Free a dictionary created with [`RedisModule\_CreateDict()`](#RedisModule\_CreateDict). You need to pass the context pointer 'ctx' only if the dictionary was created using the context instead of passing NULL. ### `RedisModule\_DictSize` uint64\_t RedisModule\_DictSize(RedisModuleDict \*d); \*\*Available since:\*\* 5.0.0 Return the size of the dictionary (number of keys). ### `RedisModule\_DictSetC` int RedisModule\_DictSetC(RedisModuleDict \*d, void \*key, size\_t keylen, void \*ptr); \*\*Available since:\*\* 5.0.0 Store the specified key into the dictionary, setting its value to the pointer 'ptr'. If the key was added with success, since it did not already exist, `REDISMODULE\_OK` is returned. Otherwise if the key already exists the function returns `REDISMODULE\_ERR`. ### `RedisModule\_DictReplaceC` int RedisModule\_DictReplaceC(RedisModuleDict \*d, void \*key, size\_t keylen, void \*ptr); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictSetC()`](#RedisModule\_DictSetC) but will replace the key with the new value if the key already exists. ### `RedisModule\_DictSet` int RedisModule\_DictSet(RedisModuleDict \*d, RedisModuleString \*key, void \*ptr); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictSetC()`](#RedisModule\_DictSetC) but takes the key as a `RedisModuleString`. ### `RedisModule\_DictReplace` int RedisModule\_DictReplace(RedisModuleDict \*d, RedisModuleString \*key, void \*ptr); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictReplaceC()`](#RedisModule\_DictReplaceC) but takes the key as a `RedisModuleString`. ### `RedisModule\_DictGetC` void \*RedisModule\_DictGetC(RedisModuleDict \*d, void \*key, size\_t keylen, int \*nokey); \*\*Available since:\*\* 5.0.0 Return the value stored at the specified key. The function returns NULL both in the case the key does not exist, or if you actually stored NULL at key. So, optionally, if the 'nokey' pointer is not NULL, it will be set by reference to 1 if the key does not exist, or to 0 if the key exists. ### `RedisModule\_DictGet` void \*RedisModule\_DictGet(RedisModuleDict \*d, RedisModuleString \*key, int \*nokey); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictGetC()`](#RedisModule\_DictGetC) but takes the key as a `RedisModuleString`. ### `RedisModule\_DictDelC` int RedisModule\_DictDelC(RedisModuleDict \*d, void \*key, size\_t keylen, void \*oldval); \*\*Available since:\*\* 5.0.0 Remove the specified key from the dictionary, returning `REDISMODULE\_OK` if the key was found and deleted, or `REDISMODULE\_ERR` if instead there was no such key in the dictionary. When the operation is successful, if 'oldval' is not NULL, then '\*oldval' is set to the value stored at the key before it was deleted. Using this feature it is possible to get a pointer to the value (for instance in order to release it), without having to call [`RedisModule\_DictGet()`](#RedisModule\_DictGet) before deleting the key. ### `RedisModule\_DictDel` int RedisModule\_DictDel(RedisModuleDict \*d, RedisModuleString \*key, void \*oldval); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictDelC()`](#RedisModule\_DictDelC) but gets the key as a `RedisModuleString`. ### `RedisModule\_DictIteratorStartC` RedisModuleDictIter \*RedisModule\_DictIteratorStartC(RedisModuleDict \*d, const char \*op, void \*key, size\_t keylen); \*\*Available since:\*\* 5.0.0 Return an iterator, setup in order to start iterating from the specified key by applying the operator 'op', which is just a string specifying the comparison operator to use in order to seek the first element. The operators available are: \* `^` – Seek the first (lexicographically smaller) key. \* `$` – Seek the last (lexicographically bigger) key. \* `>` – Seek the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.05028184875845909,
0.005881933029741049,
-0.1026100292801857,
0.03846372291445732,
-0.06436727941036224,
-0.005561484955251217,
0.0747322142124176,
0.021343909204006195,
-0.015759265050292015,
-0.008788038045167923,
0.05308106169104576,
0.0003943542542401701,
0.021426180377602577,
-0.00... | 0.059704 |
by applying the operator 'op', which is just a string specifying the comparison operator to use in order to seek the first element. The operators available are: \* `^` – Seek the first (lexicographically smaller) key. \* `$` – Seek the last (lexicographically bigger) key. \* `>` – Seek the first element greater than the specified key. \* `>=` – Seek the first element greater or equal than the specified key. \* `<` – Seek the first element smaller than the specified key. \* `<=` – Seek the first element smaller or equal than the specified key. \* `==` – Seek the first element matching exactly the specified key. Note that for `^` and `$` the passed key is not used, and the user may just pass NULL with a length of 0. If the element to start the iteration cannot be seeked based on the key and operator passed, [`RedisModule\_DictNext()`](#RedisModule\_DictNext) / Prev() will just return `REDISMODULE\_ERR` at the first call, otherwise they'll produce elements. ### `RedisModule\_DictIteratorStart` RedisModuleDictIter \*RedisModule\_DictIteratorStart(RedisModuleDict \*d, const char \*op, RedisModuleString \*key); \*\*Available since:\*\* 5.0.0 Exactly like [`RedisModule\_DictIteratorStartC`](#RedisModule\_DictIteratorStartC), but the key is passed as a `RedisModuleString`. ### `RedisModule\_DictIteratorStop` void RedisModule\_DictIteratorStop(RedisModuleDictIter \*di); \*\*Available since:\*\* 5.0.0 Release the iterator created with [`RedisModule\_DictIteratorStart()`](#RedisModule\_DictIteratorStart). This call is mandatory otherwise a memory leak is introduced in the module. ### `RedisModule\_DictIteratorReseekC` int RedisModule\_DictIteratorReseekC(RedisModuleDictIter \*di, const char \*op, void \*key, size\_t keylen); \*\*Available since:\*\* 5.0.0 After its creation with [`RedisModule\_DictIteratorStart()`](#RedisModule\_DictIteratorStart), it is possible to change the currently selected element of the iterator by using this API call. The result based on the operator and key is exactly like the function [`RedisModule\_DictIteratorStart()`](#RedisModule\_DictIteratorStart), however in this case the return value is just `REDISMODULE\_OK` in case the seeked element was found, or `REDISMODULE\_ERR` in case it was not possible to seek the specified element. It is possible to reseek an iterator as many times as you want. ### `RedisModule\_DictIteratorReseek` int RedisModule\_DictIteratorReseek(RedisModuleDictIter \*di, const char \*op, RedisModuleString \*key); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictIteratorReseekC()`](#RedisModule\_DictIteratorReseekC) but takes the key as a `RedisModuleString`. ### `RedisModule\_DictNextC` void \*RedisModule\_DictNextC(RedisModuleDictIter \*di, size\_t \*keylen, void \*\*dataptr); \*\*Available since:\*\* 5.0.0 Return the current item of the dictionary iterator `di` and steps to the next element. If the iterator already yield the last element and there are no other elements to return, NULL is returned, otherwise a pointer to a string representing the key is provided, and the `\*keylen` length is set by reference (if keylen is not NULL). The `\*dataptr`, if not NULL is set to the value of the pointer stored at the returned key as auxiliary data (as set by the [`RedisModule\_DictSet`](#RedisModule\_DictSet) API). Usage example: ... create the iterator here ... char \*key; void \*data; while((key = RedisModule\_DictNextC(iter,&keylen,&data)) != NULL) { printf("%.\*s %p\n", (int)keylen, key, data); } The returned pointer is of type void because sometimes it makes sense to cast it to a `char\*` sometimes to an unsigned `char\*` depending on the fact it contains or not binary data, so this API ends being more comfortable to use. The validity of the returned pointer is until the next call to the next/prev iterator step. Also the pointer is no longer valid once the iterator is released. ### `RedisModule\_DictPrevC` void \*RedisModule\_DictPrevC(RedisModuleDictIter \*di, size\_t \*keylen, void \*\*dataptr); \*\*Available since:\*\* 5.0.0 This function is exactly like [`RedisModule\_DictNext()`](#RedisModule\_DictNext) but after returning the currently selected element in the iterator, it selects the previous element (lexicographically smaller) instead of the next one. ### `RedisModule\_DictNext` RedisModuleString \*RedisModule\_DictNext(RedisModuleCtx \*ctx, RedisModuleDictIter \*di, void \*\*dataptr); \*\*Available since:\*\* 5.0.0 Like `RedisModuleNextC()`, but instead of returning an internally allocated buffer and key length, it returns directly a module string object allocated in the specified context | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0354275144636631,
0.04622366279363632,
0.016161054372787476,
0.00959479995071888,
-0.07603183388710022,
-0.11753963679075241,
0.0762333944439888,
0.008489061146974564,
-0.041692450642585754,
-0.037768326699733734,
0.026002265512943268,
0.019031409174203873,
0.07498025894165039,
-0.03467... | 0.080863 |
iterator, it selects the previous element (lexicographically smaller) instead of the next one. ### `RedisModule\_DictNext` RedisModuleString \*RedisModule\_DictNext(RedisModuleCtx \*ctx, RedisModuleDictIter \*di, void \*\*dataptr); \*\*Available since:\*\* 5.0.0 Like `RedisModuleNextC()`, but instead of returning an internally allocated buffer and key length, it returns directly a module string object allocated in the specified context 'ctx' (that may be NULL exactly like for the main API [`RedisModule\_CreateString`](#RedisModule\_CreateString)). The returned string object should be deallocated after use, either manually or by using a context that has automatic memory management active. ### `RedisModule\_DictPrev` RedisModuleString \*RedisModule\_DictPrev(RedisModuleCtx \*ctx, RedisModuleDictIter \*di, void \*\*dataptr); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictNext()`](#RedisModule\_DictNext) but after returning the currently selected element in the iterator, it selects the previous element (lexicographically smaller) instead of the next one. ### `RedisModule\_DictCompareC` int RedisModule\_DictCompareC(RedisModuleDictIter \*di, const char \*op, void \*key, size\_t keylen); \*\*Available since:\*\* 5.0.0 Compare the element currently pointed by the iterator to the specified element given by key/keylen, according to the operator 'op' (the set of valid operators are the same valid for [`RedisModule\_DictIteratorStart`](#RedisModule\_DictIteratorStart)). If the comparison is successful the command returns `REDISMODULE\_OK` otherwise `REDISMODULE\_ERR` is returned. This is useful when we want to just emit a lexicographical range, so in the loop, as we iterate elements, we can also check if we are still on range. The function return `REDISMODULE\_ERR` if the iterator reached the end of elements condition as well. ### `RedisModule\_DictCompare` int RedisModule\_DictCompare(RedisModuleDictIter \*di, const char \*op, RedisModuleString \*key); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_DictCompareC`](#RedisModule\_DictCompareC) but gets the key to compare with the current iterator key as a `RedisModuleString`. ## Modules Info fields ### `RedisModule\_InfoAddSection` int RedisModule\_InfoAddSection(RedisModuleInfoCtx \*ctx, const char \*name); \*\*Available since:\*\* 6.0.0 Used to start a new section, before adding any fields. the section name will be prefixed by `\_` and must only include A-Z,a-z,0-9. NULL or empty string indicates the default section (only ``) is used. When return value is `REDISMODULE\_ERR`, the section should and will be skipped. ### `RedisModule\_InfoBeginDictField` int RedisModule\_InfoBeginDictField(RedisModuleInfoCtx \*ctx, const char \*name); \*\*Available since:\*\* 6.0.0 Starts a dict field, similar to the ones in INFO KEYSPACE. Use normal `RedisModule\_InfoAddField`\* functions to add the items to this field, and terminate with [`RedisModule\_InfoEndDictField`](#RedisModule\_InfoEndDictField). ### `RedisModule\_InfoEndDictField` int RedisModule\_InfoEndDictField(RedisModuleInfoCtx \*ctx); \*\*Available since:\*\* 6.0.0 Ends a dict field, see [`RedisModule\_InfoBeginDictField`](#RedisModule\_InfoBeginDictField) ### `RedisModule\_InfoAddFieldString` int RedisModule\_InfoAddFieldString(RedisModuleInfoCtx \*ctx, const char \*field, RedisModuleString \*value); \*\*Available since:\*\* 6.0.0 Used by `RedisModuleInfoFunc` to add info fields. Each field will be automatically prefixed by `\_`. Field names or values must not include `\r\n` or `:`. ### `RedisModule\_InfoAddFieldCString` int RedisModule\_InfoAddFieldCString(RedisModuleInfoCtx \*ctx, const char \*field, const char \*value); \*\*Available since:\*\* 6.0.0 See [`RedisModule\_InfoAddFieldString()`](#RedisModule\_InfoAddFieldString). ### `RedisModule\_InfoAddFieldDouble` int RedisModule\_InfoAddFieldDouble(RedisModuleInfoCtx \*ctx, const char \*field, double value); \*\*Available since:\*\* 6.0.0 See [`RedisModule\_InfoAddFieldString()`](#RedisModule\_InfoAddFieldString). ### `RedisModule\_InfoAddFieldLongLong` int RedisModule\_InfoAddFieldLongLong(RedisModuleInfoCtx \*ctx, const char \*field, long long value); \*\*Available since:\*\* 6.0.0 See [`RedisModule\_InfoAddFieldString()`](#RedisModule\_InfoAddFieldString). ### `RedisModule\_InfoAddFieldULongLong` int RedisModule\_InfoAddFieldULongLong(RedisModuleInfoCtx \*ctx, const char \*field, unsigned long long value); \*\*Available since:\*\* 6.0.0 See [`RedisModule\_InfoAddFieldString()`](#RedisModule\_InfoAddFieldString). ### `RedisModule\_RegisterInfoFunc` int RedisModule\_RegisterInfoFunc(RedisModuleCtx \*ctx, RedisModuleInfoFunc cb); \*\*Available since:\*\* 6.0.0 Registers callback for the INFO command. The callback should add INFO fields by calling the `RedisModule\_InfoAddField\*()` functions. ### `RedisModule\_GetServerInfo` RedisModuleServerInfoData \*RedisModule\_GetServerInfo(RedisModuleCtx \*ctx, const char \*section); \*\*Available since:\*\* 6.0.0 Get information about the server similar to the one that returns from the INFO command. This function takes an optional 'section' argument that may be NULL. The return value holds the output and can be used with [`RedisModule\_ServerInfoGetField`](#RedisModule\_ServerInfoGetField) and alike to get the individual fields. When done, it needs to be freed with [`RedisModule\_FreeServerInfo`](#RedisModule\_FreeServerInfo) or with the automatic memory management mechanism if enabled. ### `RedisModule\_FreeServerInfo` void RedisModule\_FreeServerInfo(RedisModuleCtx \*ctx, RedisModuleServerInfoData \*data); \*\*Available since:\*\* 6.0.0 Free data created with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). You need to pass the context pointer 'ctx' only if the dictionary was created using the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.012906729243695736,
0.012198731303215027,
-0.021091749891638756,
0.04341442137956619,
-0.07884340733289719,
-0.0781640037894249,
0.09700775891542435,
0.0460239052772522,
-0.016289634630084038,
-0.05319648236036301,
0.04174825921654701,
-0.041069287806749344,
0.0044124796986579895,
-0.042... | 0.084982 |
fields. When done, it needs to be freed with [`RedisModule\_FreeServerInfo`](#RedisModule\_FreeServerInfo) or with the automatic memory management mechanism if enabled. ### `RedisModule\_FreeServerInfo` void RedisModule\_FreeServerInfo(RedisModuleCtx \*ctx, RedisModuleServerInfoData \*data); \*\*Available since:\*\* 6.0.0 Free data created with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). You need to pass the context pointer 'ctx' only if the dictionary was created using the context instead of passing NULL. ### `RedisModule\_ServerInfoGetField` RedisModuleString \*RedisModule\_ServerInfoGetField(RedisModuleCtx \*ctx, RedisModuleServerInfoData \*data, const char\* field); \*\*Available since:\*\* 6.0.0 Get the value of a field from data collected with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). You need to pass the context pointer 'ctx' only if you want to use auto memory mechanism to release the returned string. Return value will be NULL if the field was not found. ### `RedisModule\_ServerInfoGetFieldC` const char \*RedisModule\_ServerInfoGetFieldC(RedisModuleServerInfoData \*data, const char\* field); \*\*Available since:\*\* 6.0.0 Similar to [`RedisModule\_ServerInfoGetField`](#RedisModule\_ServerInfoGetField), but returns a char\* which should not be freed but the caller. ### `RedisModule\_ServerInfoGetFieldSigned` long long RedisModule\_ServerInfoGetFieldSigned(RedisModuleServerInfoData \*data, const char\* field, int \*out\_err); \*\*Available since:\*\* 6.0.0 Get the value of a field from data collected with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). If the field is not found, or is not numerical or out of range, return value will be 0, and the optional `out\_err` argument will be set to `REDISMODULE\_ERR`. ### `RedisModule\_ServerInfoGetFieldUnsigned` unsigned long long RedisModule\_ServerInfoGetFieldUnsigned(RedisModuleServerInfoData \*data, const char\* field, int \*out\_err); \*\*Available since:\*\* 6.0.0 Get the value of a field from data collected with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). If the field is not found, or is not numerical or out of range, return value will be 0, and the optional `out\_err` argument will be set to `REDISMODULE\_ERR`. ### `RedisModule\_ServerInfoGetFieldDouble` double RedisModule\_ServerInfoGetFieldDouble(RedisModuleServerInfoData \*data, const char\* field, int \*out\_err); \*\*Available since:\*\* 6.0.0 Get the value of a field from data collected with [`RedisModule\_GetServerInfo()`](#RedisModule\_GetServerInfo). If the field is not found, or is not a double, return value will be 0, and the optional `out\_err` argument will be set to `REDISMODULE\_ERR`. ## Modules utility APIs ### `RedisModule\_GetRandomBytes` void RedisModule\_GetRandomBytes(unsigned char \*dst, size\_t len); \*\*Available since:\*\* 5.0.0 Return random bytes using SHA1 in counter mode with a /dev/urandom initialized seed. This function is fast so can be used to generate many bytes without any effect on the operating system entropy pool. Currently this function is not thread safe. ### `RedisModule\_GetRandomHexChars` void RedisModule\_GetRandomHexChars(char \*dst, size\_t len); \*\*Available since:\*\* 5.0.0 Like [`RedisModule\_GetRandomBytes()`](#RedisModule\_GetRandomBytes) but instead of setting the string to random bytes the string is set to random characters in the in the hex charset [0-9a-f]. ## Modules API exporting / importing ### `RedisModule\_ExportSharedAPI` int RedisModule\_ExportSharedAPI(RedisModuleCtx \*ctx, const char \*apiname, void \*func); \*\*Available since:\*\* 5.0.4 This function is called by a module in order to export some API with a given name. Other modules will be able to use this API by calling the symmetrical function [`RedisModule\_GetSharedAPI()`](#RedisModule\_GetSharedAPI) and casting the return value to the right function pointer. The function will return `REDISMODULE\_OK` if the name is not already taken, otherwise `REDISMODULE\_ERR` will be returned and no operation will be performed. IMPORTANT: the apiname argument should be a string literal with static lifetime. The API relies on the fact that it will always be valid in the future. ### `RedisModule\_GetSharedAPI` void \*RedisModule\_GetSharedAPI(RedisModuleCtx \*ctx, const char \*apiname); \*\*Available since:\*\* 5.0.4 Request an exported API pointer. The return value is just a void pointer that the caller of this function will be required to cast to the right function pointer, so this is a private contract between modules. If the requested API is not available then NULL is returned. Because modules can be loaded at different times with different order, this function calls should be put inside some module generic API registering step, that is called every time a module attempts to execute a command that requires external APIs: if | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.012725570239126682,
-0.0000070303212851285934,
-0.11429480463266373,
0.02613813243806362,
-0.030021876096725464,
-0.04510759562253952,
0.11710573732852936,
0.02420749142765999,
-0.02915746532380581,
-0.003310284810140729,
0.04470350965857506,
-0.045922815799713135,
0.010555691085755825,
... | 0.071499 |
requested API is not available then NULL is returned. Because modules can be loaded at different times with different order, this function calls should be put inside some module generic API registering step, that is called every time a module attempts to execute a command that requires external APIs: if some API cannot be resolved, the command should return an error. Here is an example: int ... myCommandImplementation(void) { if (getExternalAPIs() == 0) { reply with an error here if we cannot have the APIs } // Use the API: myFunctionPointer(foo); } And the function registerAPI() is: int getExternalAPIs(void) { static int api\_loaded = 0; if (api\_loaded != 0) return 1; // APIs already resolved. myFunctionPointer = RedisModule\_GetSharedAPI("..."); if (myFunctionPointer == NULL) return 0; return 1; } ## Module Command Filter API ### `RedisModule\_RegisterCommandFilter` RedisModuleCommandFilter \*RedisModule\_RegisterCommandFilter(RedisModuleCtx \*ctx, RedisModuleCommandFilterFunc callback, int flags); \*\*Available since:\*\* 5.0.5 Register a new command filter function. Command filtering makes it possible for modules to extend Redis by plugging into the execution flow of all commands. A registered filter gets called before Redis executes \*any\* command. This includes both core Redis commands and commands registered by any module. The filter applies in all execution paths including: 1. Invocation by a client. 2. Invocation through [`RedisModule\_Call()`](#RedisModule\_Call) by any module. 3. Invocation through Lua `redis.call()`. 4. Replication of a command from a master. The filter executes in a special filter context, which is different and more limited than a `RedisModuleCtx`. Because the filter affects any command, it must be implemented in a very efficient way to reduce the performance impact on Redis. All Redis Module API calls that require a valid context (such as [`RedisModule\_Call()`](#RedisModule\_Call), [`RedisModule\_OpenKey()`](#RedisModule\_OpenKey), etc.) are not supported in a filter context. The `RedisModuleCommandFilterCtx` can be used to inspect or modify the executed command and its arguments. As the filter executes before Redis begins processing the command, any change will affect the way the command is processed. For example, a module can override Redis commands this way: 1. Register a `MODULE.SET` command which implements an extended version of the Redis `SET` command. 2. Register a command filter which detects invocation of `SET` on a specific pattern of keys. Once detected, the filter will replace the first argument from `SET` to `MODULE.SET`. 3. When filter execution is complete, Redis considers the new command name and therefore executes the module's own command. Note that in the above use case, if `MODULE.SET` itself uses [`RedisModule\_Call()`](#RedisModule\_Call) the filter will be applied on that call as well. If that is not desired, the `REDISMODULE\_CMDFILTER\_NOSELF` flag can be set when registering the filter. The `REDISMODULE\_CMDFILTER\_NOSELF` flag prevents execution flows that originate from the module's own [`RedisModule\_Call()`](#RedisModule\_Call) from reaching the filter. This flag is effective for all execution flows, including nested ones, as long as the execution begins from the module's command context or a thread-safe context that is associated with a blocking command. Detached thread-safe contexts are \*not\* associated with the module and cannot be protected by this flag. If multiple filters are registered (by the same or different modules), they are executed in the order of registration. ### `RedisModule\_UnregisterCommandFilter` int RedisModule\_UnregisterCommandFilter(RedisModuleCtx \*ctx, RedisModuleCommandFilter \*filter); \*\*Available since:\*\* 5.0.5 Unregister a command filter. ### `RedisModule\_CommandFilterArgsCount` int RedisModule\_CommandFilterArgsCount(RedisModuleCommandFilterCtx \*fctx); \*\*Available since:\*\* 5.0.5 Return the number of arguments a filtered command has. The number of arguments include the command itself. ### `RedisModule\_CommandFilterArgGet` RedisModuleString \*RedisModule\_CommandFilterArgGet(RedisModuleCommandFilterCtx \*fctx, int pos); \*\*Available since:\*\* 5.0.5 Return the specified command argument. The first argument (position 0) is the command itself, and the rest are user-provided args. ### `RedisModule\_CommandFilterArgInsert` int RedisModule\_CommandFilterArgInsert(RedisModuleCommandFilterCtx \*fctx, int pos, RedisModuleString \*arg); \*\*Available since:\*\* 5.0.5 Modify the filtered command | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.07241848111152649,
-0.03325691074132919,
-0.04594182223081589,
0.04042380675673485,
-0.05204033851623535,
0.0019528224365785718,
-0.012975974939763546,
0.10119014233350754,
-0.030874211341142654,
-0.08308830857276917,
0.008708986453711987,
-0.12702523171901703,
0.0010708689223974943,
-0... | 0.08545 |
include the command itself. ### `RedisModule\_CommandFilterArgGet` RedisModuleString \*RedisModule\_CommandFilterArgGet(RedisModuleCommandFilterCtx \*fctx, int pos); \*\*Available since:\*\* 5.0.5 Return the specified command argument. The first argument (position 0) is the command itself, and the rest are user-provided args. ### `RedisModule\_CommandFilterArgInsert` int RedisModule\_CommandFilterArgInsert(RedisModuleCommandFilterCtx \*fctx, int pos, RedisModuleString \*arg); \*\*Available since:\*\* 5.0.5 Modify the filtered command by inserting a new argument at the specified position. The specified `RedisModuleString` argument may be used by Redis after the filter context is destroyed, so it must not be auto-memory allocated, freed or used elsewhere. ### `RedisModule\_CommandFilterArgReplace` int RedisModule\_CommandFilterArgReplace(RedisModuleCommandFilterCtx \*fctx, int pos, RedisModuleString \*arg); \*\*Available since:\*\* 5.0.5 Modify the filtered command by replacing an existing argument with a new one. The specified `RedisModuleString` argument may be used by Redis after the filter context is destroyed, so it must not be auto-memory allocated, freed or used elsewhere. ### `RedisModule\_CommandFilterArgDelete` int RedisModule\_CommandFilterArgDelete(RedisModuleCommandFilterCtx \*fctx, int pos); \*\*Available since:\*\* 5.0.5 Modify the filtered command by deleting an argument at the specified position. ### `RedisModule\_CommandFilterGetClientId` unsigned long long RedisModule\_CommandFilterGetClientId(RedisModuleCommandFilterCtx \*fctx); \*\*Available since:\*\* 7.2.0 Get Client ID for client that issued the command we are filtering ### `RedisModule\_MallocSize` size\_t RedisModule\_MallocSize(void\* ptr); \*\*Available since:\*\* 6.0.0 For a given pointer allocated via [`RedisModule\_Alloc()`](#RedisModule\_Alloc) or [`RedisModule\_Realloc()`](#RedisModule\_Realloc), return the amount of memory allocated for it. Note that this may be different (larger) than the memory we allocated with the allocation calls, since sometimes the underlying allocator will allocate more memory. ### `RedisModule\_MallocUsableSize` size\_t RedisModule\_MallocUsableSize(void \*ptr); \*\*Available since:\*\* 7.0.1 Similar to [`RedisModule\_MallocSize`](#RedisModule\_MallocSize), the difference is that [`RedisModule\_MallocUsableSize`](#RedisModule\_MallocUsableSize) returns the usable size of memory by the module. ### `RedisModule\_MallocSizeString` size\_t RedisModule\_MallocSizeString(RedisModuleString\* str); \*\*Available since:\*\* 7.0.0 Same as [`RedisModule\_MallocSize`](#RedisModule\_MallocSize), except it works on `RedisModuleString` pointers. ### `RedisModule\_MallocSizeDict` size\_t RedisModule\_MallocSizeDict(RedisModuleDict\* dict); \*\*Available since:\*\* 7.0.0 Same as [`RedisModule\_MallocSize`](#RedisModule\_MallocSize), except it works on `RedisModuleDict` pointers. Note that the returned value is only the overhead of the underlying structures, it does not include the allocation size of the keys and values. ### `RedisModule\_GetUsedMemoryRatio` float RedisModule\_GetUsedMemoryRatio(void); \*\*Available since:\*\* 6.0.0 Return the a number between 0 to 1 indicating the amount of memory currently used, relative to the Redis "maxmemory" configuration. \* 0 - No memory limit configured. \* Between 0 and 1 - The percentage of the memory used normalized in 0-1 range. \* Exactly 1 - Memory limit reached. \* Greater 1 - More memory used than the configured limit. ## Scanning keyspace and hashes ### `RedisModule\_ScanCursorCreate` RedisModuleScanCursor \*RedisModule\_ScanCursorCreate(void); \*\*Available since:\*\* 6.0.0 Create a new cursor to be used with [`RedisModule\_Scan`](#RedisModule\_Scan) ### `RedisModule\_ScanCursorRestart` void RedisModule\_ScanCursorRestart(RedisModuleScanCursor \*cursor); \*\*Available since:\*\* 6.0.0 Restart an existing cursor. The keys will be rescanned. ### `RedisModule\_ScanCursorDestroy` void RedisModule\_ScanCursorDestroy(RedisModuleScanCursor \*cursor); \*\*Available since:\*\* 6.0.0 Destroy the cursor struct. ### `RedisModule\_Scan` int RedisModule\_Scan(RedisModuleCtx \*ctx, RedisModuleScanCursor \*cursor, RedisModuleScanCB fn, void \*privdata); \*\*Available since:\*\* 6.0.0 Scan API that allows a module to scan all the keys and value in the selected db. Callback for scan implementation. void scan\_callback(RedisModuleCtx \*ctx, RedisModuleString \*keyname, RedisModuleKey \*key, void \*privdata); - `ctx`: the redis module context provided to for the scan. - `keyname`: owned by the caller and need to be retained if used after this function. - `key`: holds info on the key and value, it is provided as best effort, in some cases it might be NULL, in which case the user should (can) use [`RedisModule\_OpenKey()`](#RedisModule\_OpenKey) (and CloseKey too). when it is provided, it is owned by the caller and will be free when the callback returns. - `privdata`: the user data provided to [`RedisModule\_Scan()`](#RedisModule\_Scan). The way it should be used: RedisModuleScanCursor \*c = RedisModule\_ScanCursorCreate(); while(RedisModule\_Scan(ctx, c, callback, privateData)); RedisModule\_ScanCursorDestroy(c); It is also possible to use this API from another thread while the lock is acquired during the actual call to | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.006037721876055002,
0.0007239804835990071,
-0.06988052278757095,
0.03146524727344513,
-0.013807497918605804,
-0.018364164978265762,
0.14542555809020996,
0.01810617186129093,
-0.04303888976573944,
-0.016970587894320488,
-0.013691502623260021,
-0.09615884721279144,
-0.010914765298366547,
... | 0.110812 |
be free when the callback returns. - `privdata`: the user data provided to [`RedisModule\_Scan()`](#RedisModule\_Scan). The way it should be used: RedisModuleScanCursor \*c = RedisModule\_ScanCursorCreate(); while(RedisModule\_Scan(ctx, c, callback, privateData)); RedisModule\_ScanCursorDestroy(c); It is also possible to use this API from another thread while the lock is acquired during the actual call to [`RedisModule\_Scan`](#RedisModule\_Scan): RedisModuleScanCursor \*c = RedisModule\_ScanCursorCreate(); RedisModule\_ThreadSafeContextLock(ctx); while(RedisModule\_Scan(ctx, c, callback, privateData)){ RedisModule\_ThreadSafeContextUnlock(ctx); // do some background job RedisModule\_ThreadSafeContextLock(ctx); } RedisModule\_ScanCursorDestroy(c); The function will return 1 if there are more elements to scan and 0 otherwise, possibly setting errno if the call failed. It is also possible to restart an existing cursor using [`RedisModule\_ScanCursorRestart`](#RedisModule\_ScanCursorRestart). IMPORTANT: This API is very similar to the Redis SCAN command from the point of view of the guarantees it provides. This means that the API may report duplicated keys, but guarantees to report at least one time every key that was there from the start to the end of the scanning process. NOTE: If you do database changes within the callback, you should be aware that the internal state of the database may change. For instance it is safe to delete or modify the current key, but may not be safe to delete any other key. Moreover playing with the Redis keyspace while iterating may have the effect of returning more duplicates. A safe pattern is to store the keys names you want to modify elsewhere, and perform the actions on the keys later when the iteration is complete. However this can cost a lot of memory, so it may make sense to just operate on the current key when possible during the iteration, given that this is safe. ### `RedisModule\_ScanKey` int RedisModule\_ScanKey(RedisModuleKey \*key, RedisModuleScanCursor \*cursor, RedisModuleScanKeyCB fn, void \*privdata); \*\*Available since:\*\* 6.0.0 Scan api that allows a module to scan the elements in a hash, set or sorted set key Callback for scan implementation. void scan\_callback(RedisModuleKey \*key, RedisModuleString\* field, RedisModuleString\* value, void \*privdata); - key - the redis key context provided to for the scan. - field - field name, owned by the caller and need to be retained if used after this function. - value - value string or NULL for set type, owned by the caller and need to be retained if used after this function. - privdata - the user data provided to [`RedisModule\_ScanKey`](#RedisModule\_ScanKey). The way it should be used: RedisModuleScanCursor \*c = RedisModule\_ScanCursorCreate(); RedisModuleKey \*key = RedisModule\_OpenKey(...) while(RedisModule\_ScanKey(key, c, callback, privateData)); RedisModule\_CloseKey(key); RedisModule\_ScanCursorDestroy(c); It is also possible to use this API from another thread while the lock is acquired during the actual call to [`RedisModule\_ScanKey`](#RedisModule\_ScanKey), and re-opening the key each time: RedisModuleScanCursor \*c = RedisModule\_ScanCursorCreate(); RedisModule\_ThreadSafeContextLock(ctx); RedisModuleKey \*key = RedisModule\_OpenKey(...) while(RedisModule\_ScanKey(ctx, c, callback, privateData)){ RedisModule\_CloseKey(key); RedisModule\_ThreadSafeContextUnlock(ctx); // do some background job RedisModule\_ThreadSafeContextLock(ctx); RedisModuleKey \*key = RedisModule\_OpenKey(...) } RedisModule\_CloseKey(key); RedisModule\_ScanCursorDestroy(c); The function will return 1 if there are more elements to scan and 0 otherwise, possibly setting errno if the call failed. It is also possible to restart an existing cursor using [`RedisModule\_ScanCursorRestart`](#RedisModule\_ScanCursorRestart). NOTE: Certain operations are unsafe while iterating the object. For instance while the API guarantees to return at least one time all the elements that are present in the data structure consistently from the start to the end of the iteration (see HSCAN and similar commands documentation), the more you play with the elements, the more duplicates you may get. In general deleting the current element of the data structure is safe, while removing the key you are iterating is not safe. ## Module fork API ### `RedisModule\_Fork` int RedisModule\_Fork(RedisModuleForkDoneHandler cb, void \*user\_data); \*\*Available since:\*\* 6.0.0 Create a background child process with the current frozen snapshot of the main process | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.06933820247650146,
-0.008233868516981602,
-0.14497756958007812,
-0.02343646250665188,
-0.04705924540758133,
-0.04086867719888687,
0.13126562535762787,
-0.036098890006542206,
-0.010600196197628975,
-0.012351217679679394,
0.02660864032804966,
0.024140968918800354,
0.040811385959386826,
-0... | 0.101397 |
In general deleting the current element of the data structure is safe, while removing the key you are iterating is not safe. ## Module fork API ### `RedisModule\_Fork` int RedisModule\_Fork(RedisModuleForkDoneHandler cb, void \*user\_data); \*\*Available since:\*\* 6.0.0 Create a background child process with the current frozen snapshot of the main process where you can do some processing in the background without affecting / freezing the traffic and no need for threads and GIL locking. Note that Redis allows for only one concurrent fork. When the child wants to exit, it should call [`RedisModule\_ExitFromChild`](#RedisModule\_ExitFromChild). If the parent wants to kill the child it should call [`RedisModule\_KillForkChild`](#RedisModule\_KillForkChild) The done handler callback will be executed on the parent process when the child existed (but not when killed) Return: -1 on failure, on success the parent process will get a positive PID of the child, and the child process will get 0. ### `RedisModule\_SendChildHeartbeat` void RedisModule\_SendChildHeartbeat(double progress); \*\*Available since:\*\* 6.2.0 The module is advised to call this function from the fork child once in a while, so that it can report progress and COW memory to the parent which will be reported in INFO. The `progress` argument should between 0 and 1, or -1 when not available. ### `RedisModule\_ExitFromChild` int RedisModule\_ExitFromChild(int retcode); \*\*Available since:\*\* 6.0.0 Call from the child process when you want to terminate it. retcode will be provided to the done handler executed on the parent process. ### `RedisModule\_KillForkChild` int RedisModule\_KillForkChild(int child\_pid); \*\*Available since:\*\* 6.0.0 Can be used to kill the forked child process from the parent process. `child\_pid` would be the return value of [`RedisModule\_Fork`](#RedisModule\_Fork). ## Server hooks implementation ### `RedisModule\_SubscribeToServerEvent` int RedisModule\_SubscribeToServerEvent(RedisModuleCtx \*ctx, RedisModuleEvent event, RedisModuleEventCallback callback); \*\*Available since:\*\* 6.0.0 Register to be notified, via a callback, when the specified server event happens. The callback is called with the event as argument, and an additional argument which is a void pointer and should be cased to a specific type that is event-specific (but many events will just use NULL since they do not have additional information to pass to the callback). If the callback is NULL and there was a previous subscription, the module will be unsubscribed. If there was a previous subscription and the callback is not null, the old callback will be replaced with the new one. The callback must be of this type: int (\*RedisModuleEventCallback)(RedisModuleCtx \*ctx, RedisModuleEvent eid, uint64\_t subevent, void \*data); The 'ctx' is a normal Redis module context that the callback can use in order to call other modules APIs. The 'eid' is the event itself, this is only useful in the case the module subscribed to multiple events: using the 'id' field of this structure it is possible to check if the event is one of the events we registered with this callback. The 'subevent' field depends on the event that fired. Finally the 'data' pointer may be populated, only for certain events, with more relevant data. Here is a list of events you can use as 'eid' and related sub events: \* `RedisModuleEvent\_ReplicationRoleChanged`: This event is called when the instance switches from master to replica or the other way around, however the event is also called when the replica remains a replica but starts to replicate with a different master. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_REPLROLECHANGED\_NOW\_MASTER` \* `REDISMODULE\_SUBEVENT\_REPLROLECHANGED\_NOW\_REPLICA` The 'data' field can be casted by the callback to a `RedisModuleReplicationInfo` structure with the following fields: int master; // true if master, false if replica char \*masterhost; // master instance hostname for NOW\_REPLICA int masterport; // master instance port for NOW\_REPLICA char \*replid1; // Main replication ID char \*replid2; // Secondary replication ID | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.029751446098089218,
0.01565447449684143,
-0.07042133063077927,
-0.02427072450518608,
-0.001228551845997572,
-0.11635163426399231,
0.05816872417926788,
0.033971499651670456,
0.007620999589562416,
0.024543212726712227,
0.04795454815030098,
0.04996016249060631,
0.03732529655098915,
-0.0668... | 0.072502 |
be casted by the callback to a `RedisModuleReplicationInfo` structure with the following fields: int master; // true if master, false if replica char \*masterhost; // master instance hostname for NOW\_REPLICA int masterport; // master instance port for NOW\_REPLICA char \*replid1; // Main replication ID char \*replid2; // Secondary replication ID uint64\_t repl1\_offset; // Main replication offset uint64\_t repl2\_offset; // Offset of replid2 validity \* `RedisModuleEvent\_Persistence` This event is called when RDB saving or AOF rewriting starts and ends. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_RDB\_START` \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_AOF\_START` \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_SYNC\_RDB\_START` \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_SYNC\_AOF\_START` \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_ENDED` \* `REDISMODULE\_SUBEVENT\_PERSISTENCE\_FAILED` The above events are triggered not just when the user calls the relevant commands like BGSAVE, but also when a saving operation or AOF rewriting occurs because of internal server triggers. The SYNC\_RDB\_START sub events are happening in the foreground due to SAVE command, FLUSHALL, or server shutdown, and the other RDB and AOF sub events are executed in a background fork child, so any action the module takes can only affect the generated AOF or RDB, but will not be reflected in the parent process and affect connected clients and commands. Also note that the AOF\_START sub event may end up saving RDB content in case of an AOF with rdb-preamble. \* `RedisModuleEvent\_FlushDB` The FLUSHALL, FLUSHDB or an internal flush (for instance because of replication, after the replica synchronization) happened. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_FLUSHDB\_START` \* `REDISMODULE\_SUBEVENT\_FLUSHDB\_END` The data pointer can be casted to a RedisModuleFlushInfo structure with the following fields: int32\_t async; // True if the flush is done in a thread. // See for instance FLUSHALL ASYNC. // In this case the END callback is invoked // immediately after the database is put // in the free list of the thread. int32\_t dbnum; // Flushed database number, -1 for all the DBs // in the case of the FLUSHALL operation. The start event is called \*before\* the operation is initiated, thus allowing the callback to call DBSIZE or other operation on the yet-to-free keyspace. \* `RedisModuleEvent\_Loading` Called on loading operations: at startup when the server is started, but also after a first synchronization when the replica is loading the RDB file from the master. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_LOADING\_RDB\_START` \* `REDISMODULE\_SUBEVENT\_LOADING\_AOF\_START` \* `REDISMODULE\_SUBEVENT\_LOADING\_REPL\_START` \* `REDISMODULE\_SUBEVENT\_LOADING\_ENDED` \* `REDISMODULE\_SUBEVENT\_LOADING\_FAILED` Note that AOF loading may start with an RDB data in case of rdb-preamble, in which case you'll only receive an AOF\_START event. \* `RedisModuleEvent\_ClientChange` Called when a client connects or disconnects. The data pointer can be casted to a RedisModuleClientInfo structure, documented in RedisModule\_GetClientInfoById(). The following sub events are available: \* `REDISMODULE\_SUBEVENT\_CLIENT\_CHANGE\_CONNECTED` \* `REDISMODULE\_SUBEVENT\_CLIENT\_CHANGE\_DISCONNECTED` \* `RedisModuleEvent\_Shutdown` The server is shutting down. No subevents are available. \* `RedisModuleEvent\_ReplicaChange` This event is called when the instance (that can be both a master or a replica) get a new online replica, or lose a replica since it gets disconnected. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_REPLICA\_CHANGE\_ONLINE` \* `REDISMODULE\_SUBEVENT\_REPLICA\_CHANGE\_OFFLINE` No additional information is available so far: future versions of Redis will have an API in order to enumerate the replicas connected and their state. \* `RedisModuleEvent\_CronLoop` This event is called every time Redis calls the serverCron() function in order to do certain bookkeeping. Modules that are required to do operations from time to time may use this callback. Normally Redis calls this function 10 times per second, but this changes depending on the "hz" configuration. No sub events are available. The data pointer can be casted to a RedisModuleCronLoop structure with the following fields: int32\_t hz; // Approximate number of events per second. \* `RedisModuleEvent\_MasterLinkChange` This is called for replicas | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.055690474808216095,
-0.06454567611217499,
-0.034626856446266174,
-0.009712424129247665,
-0.01784515753388405,
-0.0034182274248450994,
-0.005261996760964394,
-0.04205511137843132,
0.043529026210308075,
0.017877984791994095,
0.03688749298453331,
-0.02511594444513321,
0.0380840040743351,
-... | 0.12377 |
calls this function 10 times per second, but this changes depending on the "hz" configuration. No sub events are available. The data pointer can be casted to a RedisModuleCronLoop structure with the following fields: int32\_t hz; // Approximate number of events per second. \* `RedisModuleEvent\_MasterLinkChange` This is called for replicas in order to notify when the replication link becomes functional (up) with our master, or when it goes down. Note that the link is not considered up when we just connected to the master, but only if the replication is happening correctly. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_MASTER\_LINK\_UP` \* `REDISMODULE\_SUBEVENT\_MASTER\_LINK\_DOWN` \* `RedisModuleEvent\_ModuleChange` This event is called when a new module is loaded or one is unloaded. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_MODULE\_LOADED` \* `REDISMODULE\_SUBEVENT\_MODULE\_UNLOADED` The data pointer can be casted to a RedisModuleModuleChange structure with the following fields: const char\* module\_name; // Name of module loaded or unloaded. int32\_t module\_version; // Module version. \* `RedisModuleEvent\_LoadingProgress` This event is called repeatedly called while an RDB or AOF file is being loaded. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_LOADING\_PROGRESS\_RDB` \* `REDISMODULE\_SUBEVENT\_LOADING\_PROGRESS\_AOF` The data pointer can be casted to a RedisModuleLoadingProgress structure with the following fields: int32\_t hz; // Approximate number of events per second. int32\_t progress; // Approximate progress between 0 and 1024, // or -1 if unknown. \* `RedisModuleEvent\_SwapDB` This event is called when a SWAPDB command has been successfully Executed. For this event call currently there is no subevents available. The data pointer can be casted to a RedisModuleSwapDbInfo structure with the following fields: int32\_t dbnum\_first; // Swap Db first dbnum int32\_t dbnum\_second; // Swap Db second dbnum \* `RedisModuleEvent\_ReplBackup` WARNING: Replication Backup events are deprecated since Redis 7.0 and are never fired. See RedisModuleEvent\_ReplAsyncLoad for understanding how Async Replication Loading events are now triggered when repl-diskless-load is set to swapdb. Called when repl-diskless-load config is set to swapdb, And redis needs to backup the current database for the possibility to be restored later. A module with global data and maybe with aux\_load and aux\_save callbacks may need to use this notification to backup / restore / discard its globals. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_REPL\_BACKUP\_CREATE` \* `REDISMODULE\_SUBEVENT\_REPL\_BACKUP\_RESTORE` \* `REDISMODULE\_SUBEVENT\_REPL\_BACKUP\_DISCARD` \* `RedisModuleEvent\_ReplAsyncLoad` Called when repl-diskless-load config is set to swapdb and a replication with a master of same data set history (matching replication ID) occurs. In which case redis serves current data set while loading new database in memory from socket. Modules must have declared they support this mechanism in order to activate it, through REDISMODULE\_OPTIONS\_HANDLE\_REPL\_ASYNC\_LOAD flag. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_REPL\_ASYNC\_LOAD\_STARTED` \* `REDISMODULE\_SUBEVENT\_REPL\_ASYNC\_LOAD\_ABORTED` \* `REDISMODULE\_SUBEVENT\_REPL\_ASYNC\_LOAD\_COMPLETED` \* `RedisModuleEvent\_ForkChild` Called when a fork child (AOFRW, RDBSAVE, module fork...) is born/dies The following sub events are available: \* `REDISMODULE\_SUBEVENT\_FORK\_CHILD\_BORN` \* `REDISMODULE\_SUBEVENT\_FORK\_CHILD\_DIED` \* `RedisModuleEvent\_EventLoop` Called on each event loop iteration, once just before the event loop goes to sleep or just after it wakes up. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_EVENTLOOP\_BEFORE\_SLEEP` \* `REDISMODULE\_SUBEVENT\_EVENTLOOP\_AFTER\_SLEEP` \* `RedisModule\_Event\_Config` Called when a configuration event happens The following sub events are available: \* `REDISMODULE\_SUBEVENT\_CONFIG\_CHANGE` The data pointer can be casted to a RedisModuleConfigChange structure with the following fields: const char \*\*config\_names; // An array of C string pointers containing the // name of each modified configuration item uint32\_t num\_changes; // The number of elements in the config\_names array \* `RedisModule\_Event\_Key` Called when a key is removed from the keyspace. We can't modify any key in the event. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_KEY\_DELETED` \* `REDISMODULE\_SUBEVENT\_KEY\_EXPIRED` \* `REDISMODULE\_SUBEVENT\_KEY\_EVICTED` \* `REDISMODULE\_SUBEVENT\_KEY\_OVERWRITTEN` The data pointer can be casted to a RedisModuleKeyInfo structure with the following fields: RedisModuleKey | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.06399377435445786,
-0.07069522887468338,
-0.05064723640680313,
0.0754009336233139,
-0.02719518169760704,
-0.028344061225652695,
0.02501819096505642,
0.007709567900747061,
0.038338448852300644,
-0.021577240899205208,
0.026495615020394325,
0.024175403639674187,
0.01747838966548443,
-0.044... | 0.202887 |
config\_names array \* `RedisModule\_Event\_Key` Called when a key is removed from the keyspace. We can't modify any key in the event. The following sub events are available: \* `REDISMODULE\_SUBEVENT\_KEY\_DELETED` \* `REDISMODULE\_SUBEVENT\_KEY\_EXPIRED` \* `REDISMODULE\_SUBEVENT\_KEY\_EVICTED` \* `REDISMODULE\_SUBEVENT\_KEY\_OVERWRITTEN` The data pointer can be casted to a RedisModuleKeyInfo structure with the following fields: RedisModuleKey \*key; // Key name The function returns `REDISMODULE\_OK` if the module was successfully subscribed for the specified event. If the API is called from a wrong context or unsupported event is given then `REDISMODULE\_ERR` is returned. ### `RedisModule\_IsSubEventSupported` int RedisModule\_IsSubEventSupported(RedisModuleEvent event, int64\_t subevent); \*\*Available since:\*\* 6.0.9 For a given server event and subevent, return zero if the subevent is not supported and non-zero otherwise. ## Module Configurations API ### `RedisModule\_RegisterStringConfig` int RedisModule\_RegisterStringConfig(RedisModuleCtx \*ctx, const char \*name, const char \*default\_val, unsigned int flags, RedisModuleConfigGetStringFunc getfn, RedisModuleConfigSetStringFunc setfn, RedisModuleConfigApplyFunc applyfn, void \*privdata); \*\*Available since:\*\* 7.0.0 Create a string config that Redis users can interact with via the Redis config file, `CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. The actual config value is owned by the module, and the `getfn`, `setfn` and optional `applyfn` callbacks that are provided to Redis in order to access or manipulate the value. The `getfn` callback retrieves the value from the module, while the `setfn` callback provides a value to be stored into the module config. The optional `applyfn` callback is called after a `CONFIG SET` command modified one or more configs using the `setfn` callback and can be used to atomically apply a config after several configs were changed together. If there are multiple configs with `applyfn` callbacks set by a single `CONFIG SET` command, they will be deduplicated if their `applyfn` function and `privdata` pointers are identical, and the callback will only be run once. Both the `setfn` and `applyfn` can return an error if the provided value is invalid or cannot be used. The config also declares a type for the value that is validated by Redis and provided to the module. The config system provides the following types: \* Redis String: Binary safe string data. \* Enum: One of a finite number of string tokens, provided during registration. \* Numeric: 64 bit signed integer, which also supports min and max values. \* Bool: Yes or no value. The `setfn` callback is expected to return `REDISMODULE\_OK` when the value is successfully applied. It can also return `REDISMODULE\_ERR` if the value can't be applied, and the \*err pointer can be set with a `RedisModuleString` error message to provide to the client. This `RedisModuleString` will be freed by redis after returning from the set callback. All configs are registered with a name, a type, a default value, private data that is made available in the callbacks, as well as several flags that modify the behavior of the config. The name must only contain alphanumeric characters or dashes. The supported flags are: \* `REDISMODULE\_CONFIG\_DEFAULT`: The default flags for a config. This creates a config that can be modified after startup. \* `REDISMODULE\_CONFIG\_IMMUTABLE`: This config can only be provided loading time. \* `REDISMODULE\_CONFIG\_SENSITIVE`: The value stored in this config is redacted from all logging. \* `REDISMODULE\_CONFIG\_HIDDEN`: The name is hidden from `CONFIG GET` with pattern matching. \* `REDISMODULE\_CONFIG\_PROTECTED`: This config will be only be modifiable based off the value of enable-protected-configs. \* `REDISMODULE\_CONFIG\_DENY\_LOADING`: This config is not modifiable while the server is loading data. \* `REDISMODULE\_CONFIG\_MEMORY`: For numeric configs, this config will convert data unit notations into their byte equivalent. \* `REDISMODULE\_CONFIG\_BITFLAGS`: For enum configs, this config will allow multiple entries to be combined as bit flags. Default values are used on startup to set the value if | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.03928197920322418,
-0.017716873437166214,
-0.04681308567523956,
0.05123474448919296,
-0.0013342672027647495,
-0.05894404649734497,
0.07676107436418533,
-0.01226812694221735,
0.03623778000473976,
-0.037565749138593674,
0.03710563853383064,
0.019624732434749603,
0.05195505917072296,
-0.04... | 0.145397 |
while the server is loading data. \* `REDISMODULE\_CONFIG\_MEMORY`: For numeric configs, this config will convert data unit notations into their byte equivalent. \* `REDISMODULE\_CONFIG\_BITFLAGS`: For enum configs, this config will allow multiple entries to be combined as bit flags. Default values are used on startup to set the value if it is not provided via the config file or command line. Default values are also used to compare to on a config rewrite. Notes: 1. On string config sets that the string passed to the set callback will be freed after execution and the module must retain it. 2. On string config gets the string will not be consumed and will be valid after execution. Example implementation: RedisModuleString \*strval; int adjustable = 1; RedisModuleString \*getStringConfigCommand(const char \*name, void \*privdata) { return strval; } int setStringConfigCommand(const char \*name, RedisModuleString \*new, void \*privdata, RedisModuleString \*\*err) { if (adjustable) { RedisModule\_Free(strval); RedisModule\_RetainString(NULL, new); strval = new; return REDISMODULE\_OK; } \*err = RedisModule\_CreateString(NULL, "Not adjustable.", 15); return REDISMODULE\_ERR; } ... RedisModule\_RegisterStringConfig(ctx, "string", NULL, REDISMODULE\_CONFIG\_DEFAULT, getStringConfigCommand, setStringConfigCommand, NULL, NULL); If the registration fails, `REDISMODULE\_ERR` is returned and one of the following errno is set: \* EBUSY: Registering the Config outside of `RedisModule\_OnLoad`. \* EINVAL: The provided flags are invalid for the registration or the name of the config contains invalid characters. \* EALREADY: The provided configuration name is already used. ### `RedisModule\_RegisterBoolConfig` int RedisModule\_RegisterBoolConfig(RedisModuleCtx \*ctx, const char \*name, int default\_val, unsigned int flags, RedisModuleConfigGetBoolFunc getfn, RedisModuleConfigSetBoolFunc setfn, RedisModuleConfigApplyFunc applyfn, void \*privdata); \*\*Available since:\*\* 7.0.0 Create a bool config that server clients can interact with via the `CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. See [`RedisModule\_RegisterStringConfig`](#RedisModule\_RegisterStringConfig) for detailed information about configs. ### `RedisModule\_RegisterEnumConfig` int RedisModule\_RegisterEnumConfig(RedisModuleCtx \*ctx, const char \*name, int default\_val, unsigned int flags, const char \*\*enum\_values, const int \*int\_values, int num\_enum\_vals, RedisModuleConfigGetEnumFunc getfn, RedisModuleConfigSetEnumFunc setfn, RedisModuleConfigApplyFunc applyfn, void \*privdata); \*\*Available since:\*\* 7.0.0 Create an enum config that server clients can interact with via the `CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. Enum configs are a set of string tokens to corresponding integer values, where the string value is exposed to Redis clients but the value passed Redis and the module is the integer value. These values are defined in `enum\_values`, an array of null-terminated c strings, and `int\_vals`, an array of enum values who has an index partner in `enum\_values`. Example Implementation: const char \*enum\_vals[3] = {"first", "second", "third"}; const int int\_vals[3] = {0, 2, 4}; int enum\_val = 0; int getEnumConfigCommand(const char \*name, void \*privdata) { return enum\_val; } int setEnumConfigCommand(const char \*name, int val, void \*privdata, const char \*\*err) { enum\_val = val; return REDISMODULE\_OK; } ... RedisModule\_RegisterEnumConfig(ctx, "enum", 0, REDISMODULE\_CONFIG\_DEFAULT, enum\_vals, int\_vals, 3, getEnumConfigCommand, setEnumConfigCommand, NULL, NULL); Note that you can use `REDISMODULE\_CONFIG\_BITFLAGS` so that multiple enum string can be combined into one integer as bit flags, in which case you may want to sort your enums so that the preferred combinations are present first. See [`RedisModule\_RegisterStringConfig`](#RedisModule\_RegisterStringConfig) for detailed general information about configs. ### `RedisModule\_RegisterNumericConfig` int RedisModule\_RegisterNumericConfig(RedisModuleCtx \*ctx, const char \*name, long long default\_val, unsigned int flags, long long min, long long max, RedisModuleConfigGetNumericFunc getfn, RedisModuleConfigSetNumericFunc setfn, RedisModuleConfigApplyFunc applyfn, void \*privdata); \*\*Available since:\*\* 7.0.0 Create an integer config that server clients can interact with via the `CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. See [`RedisModule\_RegisterStringConfig`](#RedisModule\_RegisterStringConfig) for detailed information about configs. ### `RedisModule\_LoadConfigs` int RedisModule\_LoadConfigs(RedisModuleCtx \*ctx); \*\*Available since:\*\* 7.0.0 Applies all pending configurations on the module load. This should be called after all of the configurations have been registered for the module inside of `RedisModule\_OnLoad`. This will return `REDISMODULE\_ERR` if it is called outside `RedisModule\_OnLoad`. This API needs to be | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.03656916320323944,
0.014162356965243816,
-0.16433241963386536,
0.032835595309734344,
-0.09940876811742783,
-0.02661040797829628,
0.09595142304897308,
0.08355402946472168,
-0.06790594011545181,
-0.0751912072300911,
0.03002176061272621,
-0.009668576531112194,
0.030825922265648842,
-0.08614... | 0.163794 |
configs. ### `RedisModule\_LoadConfigs` int RedisModule\_LoadConfigs(RedisModuleCtx \*ctx); \*\*Available since:\*\* 7.0.0 Applies all pending configurations on the module load. This should be called after all of the configurations have been registered for the module inside of `RedisModule\_OnLoad`. This will return `REDISMODULE\_ERR` if it is called outside `RedisModule\_OnLoad`. This API needs to be called when configurations are provided in either `MODULE LOADEX` or provided as startup arguments. ## RDB load/save API ### `RedisModule\_RdbStreamCreateFromFile` RedisModuleRdbStream \*RedisModule\_RdbStreamCreateFromFile(const char \*filename); \*\*Available since:\*\* 7.2.0 Create a stream object to save/load RDB to/from a file. This function returns a pointer to `RedisModuleRdbStream` which is owned by the caller. It requires a call to [`RedisModule\_RdbStreamFree()`](#RedisModule\_RdbStreamFree) to free the object. ### `RedisModule\_RdbStreamFree` void RedisModule\_RdbStreamFree(RedisModuleRdbStream \*stream); \*\*Available since:\*\* 7.2.0 Release an RDB stream object. ### `RedisModule\_RdbLoad` int RedisModule\_RdbLoad(RedisModuleCtx \*ctx, RedisModuleRdbStream \*stream, int flags); \*\*Available since:\*\* 7.2.0 Load RDB file from the `stream`. Dataset will be cleared first and then RDB file will be loaded. `flags` must be zero. This parameter is for future use. On success `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set accordingly. Example: RedisModuleRdbStream \*s = RedisModule\_RdbStreamCreateFromFile("exp.rdb"); RedisModule\_RdbLoad(ctx, s, 0); RedisModule\_RdbStreamFree(s); ### `RedisModule\_RdbSave` int RedisModule\_RdbSave(RedisModuleCtx \*ctx, RedisModuleRdbStream \*stream, int flags); \*\*Available since:\*\* 7.2.0 Save dataset to the RDB stream. `flags` must be zero. This parameter is for future use. On success `REDISMODULE\_OK` is returned, otherwise `REDISMODULE\_ERR` is returned and errno is set accordingly. Example: RedisModuleRdbStream \*s = RedisModule\_RdbStreamCreateFromFile("exp.rdb"); RedisModule\_RdbSave(ctx, s, 0); RedisModule\_RdbStreamFree(s); ## Key eviction API ### `RedisModule\_SetLRU` int RedisModule\_SetLRU(RedisModuleKey \*key, mstime\_t lru\_idle); \*\*Available since:\*\* 6.0.0 Set the key last access time for LRU based eviction. not relevant if the servers's maxmemory policy is LFU based. Value is idle time in milliseconds. returns `REDISMODULE\_OK` if the LRU was updated, `REDISMODULE\_ERR` otherwise. ### `RedisModule\_GetLRU` int RedisModule\_GetLRU(RedisModuleKey \*key, mstime\_t \*lru\_idle); \*\*Available since:\*\* 6.0.0 Gets the key last access time. Value is idletime in milliseconds or -1 if the server's eviction policy is LFU based. returns `REDISMODULE\_OK` if when key is valid. ### `RedisModule\_SetLFU` int RedisModule\_SetLFU(RedisModuleKey \*key, long long lfu\_freq); \*\*Available since:\*\* 6.0.0 Set the key access frequency. only relevant if the server's maxmemory policy is LFU based. The frequency is a logarithmic counter that provides an indication of the access frequencyonly (must be <= 255). returns `REDISMODULE\_OK` if the LFU was updated, `REDISMODULE\_ERR` otherwise. ### `RedisModule\_GetLFU` int RedisModule\_GetLFU(RedisModuleKey \*key, long long \*lfu\_freq); \*\*Available since:\*\* 6.0.0 Gets the key access frequency or -1 if the server's eviction policy is not LFU based. returns `REDISMODULE\_OK` if when key is valid. ## Miscellaneous APIs ### `RedisModule\_GetModuleOptionsAll` int RedisModule\_GetModuleOptionsAll(void); \*\*Available since:\*\* 7.2.0 Returns the full module options flags mask, using the return value the module can check if a certain set of module options are supported by the redis server version in use. Example: int supportedFlags = RedisModule\_GetModuleOptionsAll(); if (supportedFlags & REDISMODULE\_OPTIONS\_ALLOW\_NESTED\_KEYSPACE\_NOTIFICATIONS) { // REDISMODULE\_OPTIONS\_ALLOW\_NESTED\_KEYSPACE\_NOTIFICATIONS is supported } else{ // REDISMODULE\_OPTIONS\_ALLOW\_NESTED\_KEYSPACE\_NOTIFICATIONS is not supported } ### `RedisModule\_GetContextFlagsAll` int RedisModule\_GetContextFlagsAll(void); \*\*Available since:\*\* 6.0.9 Returns the full ContextFlags mask, using the return value the module can check if a certain set of flags are supported by the redis server version in use. Example: int supportedFlags = RedisModule\_GetContextFlagsAll(); if (supportedFlags & REDISMODULE\_CTX\_FLAGS\_MULTI) { // REDISMODULE\_CTX\_FLAGS\_MULTI is supported } else{ // REDISMODULE\_CTX\_FLAGS\_MULTI is not supported } ### `RedisModule\_GetKeyspaceNotificationFlagsAll` int RedisModule\_GetKeyspaceNotificationFlagsAll(void); \*\*Available since:\*\* 6.0.9 Returns the full KeyspaceNotification mask, using the return value the module can check if a certain set of flags are supported by the redis server version in use. Example: int supportedFlags = RedisModule\_GetKeyspaceNotificationFlagsAll(); if (supportedFlags & REDISMODULE\_NOTIFY\_LOADED) { // REDISMODULE\_NOTIFY\_LOADED is supported } else{ // REDISMODULE\_NOTIFY\_LOADED is not supported } ### `RedisModule\_GetServerVersion` int RedisModule\_GetServerVersion(void); \*\*Available since:\*\* 6.0.9 Return the redis version in | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.006591970566660166,
-0.03563418239355087,
-0.10663575679063797,
0.02514149621129036,
-0.006938476115465164,
0.006854237988591194,
0.02794370800256729,
0.09899624437093735,
-0.09924372285604477,
-0.0063704680651426315,
-0.030767710879445076,
-0.00874012615531683,
0.00648169219493866,
0.02... | 0.053167 |
check if a certain set of flags are supported by the redis server version in use. Example: int supportedFlags = RedisModule\_GetKeyspaceNotificationFlagsAll(); if (supportedFlags & REDISMODULE\_NOTIFY\_LOADED) { // REDISMODULE\_NOTIFY\_LOADED is supported } else{ // REDISMODULE\_NOTIFY\_LOADED is not supported } ### `RedisModule\_GetServerVersion` int RedisModule\_GetServerVersion(void); \*\*Available since:\*\* 6.0.9 Return the redis version in format of 0x00MMmmpp. Example for 6.0.7 the return value will be 0x00060007. ### `RedisModule\_GetTypeMethodVersion` int RedisModule\_GetTypeMethodVersion(void); \*\*Available since:\*\* 6.2.0 Return the current redis-server runtime value of `REDISMODULE\_TYPE\_METHOD\_VERSION`. You can use that when calling [`RedisModule\_CreateDataType`](#RedisModule\_CreateDataType) to know which fields of `RedisModuleTypeMethods` are gonna be supported and which will be ignored. ### `RedisModule\_ModuleTypeReplaceValue` int RedisModule\_ModuleTypeReplaceValue(RedisModuleKey \*key, moduleType \*mt, void \*new\_value, void \*\*old\_value); \*\*Available since:\*\* 6.0.0 Replace the value assigned to a module type. The key must be open for writing, have an existing value, and have a moduleType that matches the one specified by the caller. Unlike [`RedisModule\_ModuleTypeSetValue()`](#RedisModule\_ModuleTypeSetValue) which will free the old value, this function simply swaps the old value with the new value. The function returns `REDISMODULE\_OK` on success, `REDISMODULE\_ERR` on errors such as: 1. Key is not opened for writing. 2. Key is not a module data type key. 3. Key is a module datatype other than 'mt'. If `old\_value` is non-NULL, the old value is returned by reference. ### `RedisModule\_GetCommandKeysWithFlags` int \*RedisModule\_GetCommandKeysWithFlags(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc, int \*num\_keys, int \*\*out\_flags); \*\*Available since:\*\* 7.0.0 For a specified command, parse its arguments and return an array that contains the indexes of all key name arguments. This function is essentially a more efficient way to do `COMMAND GETKEYS`. The `out\_flags` argument is optional, and can be set to NULL. When provided it is filled with `REDISMODULE\_CMD\_KEY\_` flags in matching indexes with the key indexes of the returned array. A NULL return value indicates the specified command has no keys, or an error condition. Error conditions are indicated by setting errno as follows: \* ENOENT: Specified command does not exist. \* EINVAL: Invalid command arity specified. NOTE: The returned array is not a Redis Module object so it does not get automatically freed even when auto-memory is used. The caller must explicitly call [`RedisModule\_Free()`](#RedisModule\_Free) to free it, same as the `out\_flags` pointer if used. ### `RedisModule\_GetCommandKeys` int \*RedisModule\_GetCommandKeys(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc, int \*num\_keys); \*\*Available since:\*\* 6.0.9 Identical to [`RedisModule\_GetCommandKeysWithFlags`](#RedisModule\_GetCommandKeysWithFlags) when flags are not needed. ### `RedisModule\_GetCurrentCommandName` const char \*RedisModule\_GetCurrentCommandName(RedisModuleCtx \*ctx); \*\*Available since:\*\* 6.2.5 Return the name of the command currently running ## Defrag API ### `RedisModule\_RegisterDefragFunc` int RedisModule\_RegisterDefragFunc(RedisModuleCtx \*ctx, RedisModuleDefragFunc cb); \*\*Available since:\*\* 6.2.0 Register a defrag callback for global data, i.e. anything that the module may allocate that is not tied to a specific data type. ### `RedisModule\_DefragShouldStop` int RedisModule\_DefragShouldStop(RedisModuleDefragCtx \*ctx); \*\*Available since:\*\* 6.2.0 When the data type defrag callback iterates complex structures, this function should be called periodically. A zero (false) return indicates the callback may continue its work. A non-zero value (true) indicates it should stop. When stopped, the callback may use [`RedisModule\_DefragCursorSet()`](#RedisModule\_DefragCursorSet) to store its position so it can later use [`RedisModule\_DefragCursorGet()`](#RedisModule\_DefragCursorGet) to resume defragging. When stopped and more work is left to be done, the callback should return 1. Otherwise, it should return 0. NOTE: Modules should consider the frequency in which this function is called, so it generally makes sense to do small batches of work in between calls. ### `RedisModule\_DefragCursorSet` int RedisModule\_DefragCursorSet(RedisModuleDefragCtx \*ctx, unsigned long cursor); \*\*Available since:\*\* 6.2.0 Store an arbitrary cursor value for future re-use. This should only be called if [`RedisModule\_DefragShouldStop()`](#RedisModule\_DefragShouldStop) has returned a non-zero value and the defrag callback is about to exit without fully iterating its data type. This behavior is reserved to cases where late defrag | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
0.03263130038976669,
-0.04561399295926094,
-0.10499737411737442,
-0.011467759497463703,
0.04981116205453873,
-0.03837191313505173,
0.004201340023428202,
-0.01097459252923727,
-0.017660077661275864,
-0.02090127393603325,
-0.009129871614277363,
-0.013019499368965626,
-0.026905791833996773,
-... | 0.096471 |
\*ctx, unsigned long cursor); \*\*Available since:\*\* 6.2.0 Store an arbitrary cursor value for future re-use. This should only be called if [`RedisModule\_DefragShouldStop()`](#RedisModule\_DefragShouldStop) has returned a non-zero value and the defrag callback is about to exit without fully iterating its data type. This behavior is reserved to cases where late defrag is performed. Late defrag is selected for keys that implement the `free\_effort` callback and return a `free\_effort` value that is larger than the defrag 'active-defrag-max-scan-fields' configuration directive. Smaller keys, keys that do not implement `free\_effort` or the global defrag callback are not called in late-defrag mode. In those cases, a call to this function will return `REDISMODULE\_ERR`. The cursor may be used by the module to represent some progress into the module's data type. Modules may also store additional cursor-related information locally and use the cursor as a flag that indicates when traversal of a new key begins. This is possible because the API makes a guarantee that concurrent defragmentation of multiple keys will not be performed. ### `RedisModule\_DefragCursorGet` int RedisModule\_DefragCursorGet(RedisModuleDefragCtx \*ctx, unsigned long \*cursor); \*\*Available since:\*\* 6.2.0 Fetch a cursor value that has been previously stored using [`RedisModule\_DefragCursorSet()`](#RedisModule\_DefragCursorSet). If not called for a late defrag operation, `REDISMODULE\_ERR` will be returned and the cursor should be ignored. See [`RedisModule\_DefragCursorSet()`](#RedisModule\_DefragCursorSet) for more details on defrag cursors. ### `RedisModule\_DefragAlloc` void \*RedisModule\_DefragAlloc(RedisModuleDefragCtx \*ctx, void \*ptr); \*\*Available since:\*\* 6.2.0 Defrag a memory allocation previously allocated by [`RedisModule\_Alloc`](#RedisModule\_Alloc), [`RedisModule\_Calloc`](#RedisModule\_Calloc), etc. The defragmentation process involves allocating a new memory block and copying the contents to it, like `realloc()`. If defragmentation was not necessary, NULL is returned and the operation has no other effect. If a non-NULL value is returned, the caller should use the new pointer instead of the old one and update any reference to the old pointer, which must not be used again. ### `RedisModule\_DefragRedisModuleString` RedisModuleString \*RedisModule\_DefragRedisModuleString(RedisModuleDefragCtx \*ctx, RedisModuleString \*str); \*\*Available since:\*\* 6.2.0 Defrag a `RedisModuleString` previously allocated by [`RedisModule\_Alloc`](#RedisModule\_Alloc), [`RedisModule\_Calloc`](#RedisModule\_Calloc), etc. See [`RedisModule\_DefragAlloc()`](#RedisModule\_DefragAlloc) for more information on how the defragmentation process works. NOTE: It is only possible to defrag strings that have a single reference. Typically this means strings retained with [`RedisModule\_RetainString`](#RedisModule\_RetainString) or [`RedisModule\_HoldString`](#RedisModule\_HoldString) may not be defragmentable. One exception is command argvs which, if retained by the module, will end up with a single reference (because the reference on the Redis side is dropped as soon as the command callback returns). ### `RedisModule\_GetKeyNameFromDefragCtx` const RedisModuleString \*RedisModule\_GetKeyNameFromDefragCtx(RedisModuleDefragCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the name of the key currently being processed. There is no guarantee that the key name is always available, so this may return NULL. ### `RedisModule\_GetDbIdFromDefragCtx` int RedisModule\_GetDbIdFromDefragCtx(RedisModuleDefragCtx \*ctx); \*\*Available since:\*\* 7.0.0 Returns the database id of the key currently being processed. There is no guarantee that this info is always available, so this may return -1. ## Function index \* [`RedisModule\_ACLAddLogEntry`](#RedisModule\_ACLAddLogEntry) \* [`RedisModule\_ACLAddLogEntryByUserName`](#RedisModule\_ACLAddLogEntryByUserName) \* [`RedisModule\_ACLCheckChannelPermissions`](#RedisModule\_ACLCheckChannelPermissions) \* [`RedisModule\_ACLCheckCommandPermissions`](#RedisModule\_ACLCheckCommandPermissions) \* [`RedisModule\_ACLCheckKeyPermissions`](#RedisModule\_ACLCheckKeyPermissions) \* [`RedisModule\_AbortBlock`](#RedisModule\_AbortBlock) \* [`RedisModule\_AddPostNotificationJob`](#RedisModule\_AddPostNotificationJob) \* [`RedisModule\_Alloc`](#RedisModule\_Alloc) \* [`RedisModule\_AuthenticateClientWithACLUser`](#RedisModule\_AuthenticateClientWithACLUser) \* [`RedisModule\_AuthenticateClientWithUser`](#RedisModule\_AuthenticateClientWithUser) \* [`RedisModule\_AutoMemory`](#RedisModule\_AutoMemory) \* [`RedisModule\_AvoidReplicaTraffic`](#RedisModule\_AvoidReplicaTraffic) \* [`RedisModule\_BlockClient`](#RedisModule\_BlockClient) \* [`RedisModule\_BlockClientGetPrivateData`](#RedisModule\_BlockClientGetPrivateData) \* [`RedisModule\_BlockClientOnAuth`](#RedisModule\_BlockClientOnAuth) \* [`RedisModule\_BlockClientOnKeys`](#RedisModule\_BlockClientOnKeys) \* [`RedisModule\_BlockClientOnKeysWithFlags`](#RedisModule\_BlockClientOnKeysWithFlags) \* [`RedisModule\_BlockClientSetPrivateData`](#RedisModule\_BlockClientSetPrivateData) \* [`RedisModule\_BlockedClientDisconnected`](#RedisModule\_BlockedClientDisconnected) \* [`RedisModule\_BlockedClientMeasureTimeEnd`](#RedisModule\_BlockedClientMeasureTimeEnd) \* [`RedisModule\_BlockedClientMeasureTimeStart`](#RedisModule\_BlockedClientMeasureTimeStart) \* [`RedisModule\_CachedMicroseconds`](#RedisModule\_CachedMicroseconds) \* [`RedisModule\_Call`](#RedisModule\_Call) \* [`RedisModule\_CallReplyArrayElement`](#RedisModule\_CallReplyArrayElement) \* [`RedisModule\_CallReplyAttribute`](#RedisModule\_CallReplyAttribute) \* [`RedisModule\_CallReplyAttributeElement`](#RedisModule\_CallReplyAttributeElement) \* [`RedisModule\_CallReplyBigNumber`](#RedisModule\_CallReplyBigNumber) \* [`RedisModule\_CallReplyBool`](#RedisModule\_CallReplyBool) \* [`RedisModule\_CallReplyDouble`](#RedisModule\_CallReplyDouble) \* [`RedisModule\_CallReplyInteger`](#RedisModule\_CallReplyInteger) \* [`RedisModule\_CallReplyLength`](#RedisModule\_CallReplyLength) \* [`RedisModule\_CallReplyMapElement`](#RedisModule\_CallReplyMapElement) \* [`RedisModule\_CallReplyPromiseAbort`](#RedisModule\_CallReplyPromiseAbort) \* [`RedisModule\_CallReplyPromiseSetUnblockHandler`](#RedisModule\_CallReplyPromiseSetUnblockHandler) \* [`RedisModule\_CallReplyProto`](#RedisModule\_CallReplyProto) \* [`RedisModule\_CallReplySetElement`](#RedisModule\_CallReplySetElement) \* [`RedisModule\_CallReplyStringPtr`](#RedisModule\_CallReplyStringPtr) \* [`RedisModule\_CallReplyType`](#RedisModule\_CallReplyType) \* [`RedisModule\_CallReplyVerbatim`](#RedisModule\_CallReplyVerbatim) \* [`RedisModule\_Calloc`](#RedisModule\_Calloc) \* [`RedisModule\_ChannelAtPosWithFlags`](#RedisModule\_ChannelAtPosWithFlags) \* [`RedisModule\_CloseKey`](#RedisModule\_CloseKey) \* [`RedisModule\_CommandFilterArgDelete`](#RedisModule\_CommandFilterArgDelete) \* [`RedisModule\_CommandFilterArgGet`](#RedisModule\_CommandFilterArgGet) \* [`RedisModule\_CommandFilterArgInsert`](#RedisModule\_CommandFilterArgInsert) \* [`RedisModule\_CommandFilterArgReplace`](#RedisModule\_CommandFilterArgReplace) \* [`RedisModule\_CommandFilterArgsCount`](#RedisModule\_CommandFilterArgsCount) \* [`RedisModule\_CommandFilterGetClientId`](#RedisModule\_CommandFilterGetClientId) \* [`RedisModule\_CreateCommand`](#RedisModule\_CreateCommand) \* [`RedisModule\_CreateDataType`](#RedisModule\_CreateDataType) \* [`RedisModule\_CreateDict`](#RedisModule\_CreateDict) \* [`RedisModule\_CreateModuleUser`](#RedisModule\_CreateModuleUser) \* [`RedisModule\_CreateString`](#RedisModule\_CreateString) \* [`RedisModule\_CreateStringFromCallReply`](#RedisModule\_CreateStringFromCallReply) \* [`RedisModule\_CreateStringFromDouble`](#RedisModule\_CreateStringFromDouble) \* [`RedisModule\_CreateStringFromLongDouble`](#RedisModule\_CreateStringFromLongDouble) \* [`RedisModule\_CreateStringFromLongLong`](#RedisModule\_CreateStringFromLongLong) \* [`RedisModule\_CreateStringFromStreamID`](#RedisModule\_CreateStringFromStreamID) \* [`RedisModule\_CreateStringFromString`](#RedisModule\_CreateStringFromString) \* [`RedisModule\_CreateStringFromULongLong`](#RedisModule\_CreateStringFromULongLong) \* [`RedisModule\_CreateStringPrintf`](#RedisModule\_CreateStringPrintf) \* [`RedisModule\_CreateSubcommand`](#RedisModule\_CreateSubcommand) \* [`RedisModule\_CreateTimer`](#RedisModule\_CreateTimer) \* [`RedisModule\_DbSize`](#RedisModule\_DbSize) \* [`RedisModule\_DeauthenticateAndCloseClient`](#RedisModule\_DeauthenticateAndCloseClient) \* [`RedisModule\_DefragAlloc`](#RedisModule\_DefragAlloc) \* [`RedisModule\_DefragCursorGet`](#RedisModule\_DefragCursorGet) \* [`RedisModule\_DefragCursorSet`](#RedisModule\_DefragCursorSet) \* [`RedisModule\_DefragRedisModuleString`](#RedisModule\_DefragRedisModuleString) \* [`RedisModule\_DefragShouldStop`](#RedisModule\_DefragShouldStop) \* | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.11256297677755356,
0.01726105622947216,
-0.057577282190322876,
0.026258936151862144,
0.048250578343868256,
-0.08999577164649963,
0.0880742147564888,
0.06692492216825485,
-0.007293592672795057,
-0.0250889603048563,
0.04643361270427704,
0.051950450986623764,
-0.0068991295993328094,
-0.059... | 0.182924 |
[`RedisModule\_CommandFilterArgReplace`](#RedisModule\_CommandFilterArgReplace) \* [`RedisModule\_CommandFilterArgsCount`](#RedisModule\_CommandFilterArgsCount) \* [`RedisModule\_CommandFilterGetClientId`](#RedisModule\_CommandFilterGetClientId) \* [`RedisModule\_CreateCommand`](#RedisModule\_CreateCommand) \* [`RedisModule\_CreateDataType`](#RedisModule\_CreateDataType) \* [`RedisModule\_CreateDict`](#RedisModule\_CreateDict) \* [`RedisModule\_CreateModuleUser`](#RedisModule\_CreateModuleUser) \* [`RedisModule\_CreateString`](#RedisModule\_CreateString) \* [`RedisModule\_CreateStringFromCallReply`](#RedisModule\_CreateStringFromCallReply) \* [`RedisModule\_CreateStringFromDouble`](#RedisModule\_CreateStringFromDouble) \* [`RedisModule\_CreateStringFromLongDouble`](#RedisModule\_CreateStringFromLongDouble) \* [`RedisModule\_CreateStringFromLongLong`](#RedisModule\_CreateStringFromLongLong) \* [`RedisModule\_CreateStringFromStreamID`](#RedisModule\_CreateStringFromStreamID) \* [`RedisModule\_CreateStringFromString`](#RedisModule\_CreateStringFromString) \* [`RedisModule\_CreateStringFromULongLong`](#RedisModule\_CreateStringFromULongLong) \* [`RedisModule\_CreateStringPrintf`](#RedisModule\_CreateStringPrintf) \* [`RedisModule\_CreateSubcommand`](#RedisModule\_CreateSubcommand) \* [`RedisModule\_CreateTimer`](#RedisModule\_CreateTimer) \* [`RedisModule\_DbSize`](#RedisModule\_DbSize) \* [`RedisModule\_DeauthenticateAndCloseClient`](#RedisModule\_DeauthenticateAndCloseClient) \* [`RedisModule\_DefragAlloc`](#RedisModule\_DefragAlloc) \* [`RedisModule\_DefragCursorGet`](#RedisModule\_DefragCursorGet) \* [`RedisModule\_DefragCursorSet`](#RedisModule\_DefragCursorSet) \* [`RedisModule\_DefragRedisModuleString`](#RedisModule\_DefragRedisModuleString) \* [`RedisModule\_DefragShouldStop`](#RedisModule\_DefragShouldStop) \* [`RedisModule\_DeleteKey`](#RedisModule\_DeleteKey) \* [`RedisModule\_DictCompare`](#RedisModule\_DictCompare) \* [`RedisModule\_DictCompareC`](#RedisModule\_DictCompareC) \* [`RedisModule\_DictDel`](#RedisModule\_DictDel) \* [`RedisModule\_DictDelC`](#RedisModule\_DictDelC) \* [`RedisModule\_DictGet`](#RedisModule\_DictGet) \* [`RedisModule\_DictGetC`](#RedisModule\_DictGetC) \* [`RedisModule\_DictIteratorReseek`](#RedisModule\_DictIteratorReseek) \* [`RedisModule\_DictIteratorReseekC`](#RedisModule\_DictIteratorReseekC) \* [`RedisModule\_DictIteratorStart`](#RedisModule\_DictIteratorStart) \* [`RedisModule\_DictIteratorStartC`](#RedisModule\_DictIteratorStartC) \* [`RedisModule\_DictIteratorStop`](#RedisModule\_DictIteratorStop) \* [`RedisModule\_DictNext`](#RedisModule\_DictNext) \* [`RedisModule\_DictNextC`](#RedisModule\_DictNextC) \* [`RedisModule\_DictPrev`](#RedisModule\_DictPrev) \* [`RedisModule\_DictPrevC`](#RedisModule\_DictPrevC) \* [`RedisModule\_DictReplace`](#RedisModule\_DictReplace) \* [`RedisModule\_DictReplaceC`](#RedisModule\_DictReplaceC) \* [`RedisModule\_DictSet`](#RedisModule\_DictSet) \* [`RedisModule\_DictSetC`](#RedisModule\_DictSetC) \* [`RedisModule\_DictSize`](#RedisModule\_DictSize) \* [`RedisModule\_DigestAddLongLong`](#RedisModule\_DigestAddLongLong) \* [`RedisModule\_DigestAddStringBuffer`](#RedisModule\_DigestAddStringBuffer) \* [`RedisModule\_DigestEndSequence`](#RedisModule\_DigestEndSequence) \* [`RedisModule\_EmitAOF`](#RedisModule\_EmitAOF) \* [`RedisModule\_EventLoopAdd`](#RedisModule\_EventLoopAdd) \* [`RedisModule\_EventLoopAddOneShot`](#RedisModule\_EventLoopAddOneShot) \* [`RedisModule\_EventLoopDel`](#RedisModule\_EventLoopDel) \* [`RedisModule\_ExitFromChild`](#RedisModule\_ExitFromChild) \* [`RedisModule\_ExportSharedAPI`](#RedisModule\_ExportSharedAPI) \* [`RedisModule\_Fork`](#RedisModule\_Fork) \* [`RedisModule\_Free`](#RedisModule\_Free) \* [`RedisModule\_FreeCallReply`](#RedisModule\_FreeCallReply) \* [`RedisModule\_FreeClusterNodesList`](#RedisModule\_FreeClusterNodesList) \* [`RedisModule\_FreeDict`](#RedisModule\_FreeDict) \* [`RedisModule\_FreeModuleUser`](#RedisModule\_FreeModuleUser) \* [`RedisModule\_FreeServerInfo`](#RedisModule\_FreeServerInfo) \* [`RedisModule\_FreeString`](#RedisModule\_FreeString) \* [`RedisModule\_FreeThreadSafeContext`](#RedisModule\_FreeThreadSafeContext) \* [`RedisModule\_GetAbsExpire`](#RedisModule\_GetAbsExpire) \* [`RedisModule\_GetBlockedClientHandle`](#RedisModule\_GetBlockedClientHandle) \* [`RedisModule\_GetBlockedClientPrivateData`](#RedisModule\_GetBlockedClientPrivateData) \* [`RedisModule\_GetBlockedClientReadyKey`](#RedisModule\_GetBlockedClientReadyKey) \* [`RedisModule\_GetClientCertificate`](#RedisModule\_GetClientCertificate) \* [`RedisModule\_GetClientId`](#RedisModule\_GetClientId) \* [`RedisModule\_GetClientInfoById`](#RedisModule\_GetClientInfoById) \* [`RedisModule\_GetClientNameById`](#RedisModule\_GetClientNameById) \* [`RedisModule\_GetClientUserNameById`](#RedisModule\_GetClientUserNameById) \* [`RedisModule\_GetClusterNodeInfo`](#RedisModule\_GetClusterNodeInfo) \* [`RedisModule\_GetClusterNodesList`](#RedisModule\_GetClusterNodesList) \* [`RedisModule\_GetClusterSize`](#RedisModule\_GetClusterSize) \* [`RedisModule\_GetCommand`](#RedisModule\_GetCommand) \* [`RedisModule\_GetCommandKeys`](#RedisModule\_GetCommandKeys) \* [`RedisModule\_GetCommandKeysWithFlags`](#RedisModule\_GetCommandKeysWithFlags) \* [`RedisModule\_GetContextFlags`](#RedisModule\_GetContextFlags) \* [`RedisModule\_GetContextFlagsAll`](#RedisModule\_GetContextFlagsAll) \* [`RedisModule\_GetCurrentCommandName`](#RedisModule\_GetCurrentCommandName) \* [`RedisModule\_GetCurrentUserName`](#RedisModule\_GetCurrentUserName) \* [`RedisModule\_GetDbIdFromDefragCtx`](#RedisModule\_GetDbIdFromDefragCtx) \* [`RedisModule\_GetDbIdFromDigest`](#RedisModule\_GetDbIdFromDigest) \* [`RedisModule\_GetDbIdFromIO`](#RedisModule\_GetDbIdFromIO) \* [`RedisModule\_GetDbIdFromModuleKey`](#RedisModule\_GetDbIdFromModuleKey) \* [`RedisModule\_GetDbIdFromOptCtx`](#RedisModule\_GetDbIdFromOptCtx) \* [`RedisModule\_GetDetachedThreadSafeContext`](#RedisModule\_GetDetachedThreadSafeContext) \* [`RedisModule\_GetExpire`](#RedisModule\_GetExpire) \* [`RedisModule\_GetKeyNameFromDefragCtx`](#RedisModule\_GetKeyNameFromDefragCtx) \* [`RedisModule\_GetKeyNameFromDigest`](#RedisModule\_GetKeyNameFromDigest) \* [`RedisModule\_GetKeyNameFromIO`](#RedisModule\_GetKeyNameFromIO) \* [`RedisModule\_GetKeyNameFromModuleKey`](#RedisModule\_GetKeyNameFromModuleKey) \* [`RedisModule\_GetKeyNameFromOptCtx`](#RedisModule\_GetKeyNameFromOptCtx) \* [`RedisModule\_GetKeyspaceNotificationFlagsAll`](#RedisModule\_GetKeyspaceNotificationFlagsAll) \* [`RedisModule\_GetLFU`](#RedisModule\_GetLFU) \* [`RedisModule\_GetLRU`](#RedisModule\_GetLRU) \* [`RedisModule\_GetModuleOptionsAll`](#RedisModule\_GetModuleOptionsAll) \* [`RedisModule\_GetModuleUserACLString`](#RedisModule\_GetModuleUserACLString) \* [`RedisModule\_GetModuleUserFromUserName`](#RedisModule\_GetModuleUserFromUserName) \* [`RedisModule\_GetMyClusterID`](#RedisModule\_GetMyClusterID) \* [`RedisModule\_GetNotifyKeyspaceEvents`](#RedisModule\_GetNotifyKeyspaceEvents) \* [`RedisModule\_GetOpenKeyModesAll`](#RedisModule\_GetOpenKeyModesAll) \* [`RedisModule\_GetRandomBytes`](#RedisModule\_GetRandomBytes) \* [`RedisModule\_GetRandomHexChars`](#RedisModule\_GetRandomHexChars) \* [`RedisModule\_GetSelectedDb`](#RedisModule\_GetSelectedDb) \* [`RedisModule\_GetServerInfo`](#RedisModule\_GetServerInfo) \* [`RedisModule\_GetServerVersion`](#RedisModule\_GetServerVersion) \* [`RedisModule\_GetSharedAPI`](#RedisModule\_GetSharedAPI) \* [`RedisModule\_GetThreadSafeContext`](#RedisModule\_GetThreadSafeContext) \* [`RedisModule\_GetTimerInfo`](#RedisModule\_GetTimerInfo) \* [`RedisModule\_GetToDbIdFromOptCtx`](#RedisModule\_GetToDbIdFromOptCtx) \* [`RedisModule\_GetToKeyNameFromOptCtx`](#RedisModule\_GetToKeyNameFromOptCtx) \* [`RedisModule\_GetTypeMethodVersion`](#RedisModule\_GetTypeMethodVersion) \* [`RedisModule\_GetUsedMemoryRatio`](#RedisModule\_GetUsedMemoryRatio) \* [`RedisModule\_HashGet`](#RedisModule\_HashGet) \* [`RedisModule\_HashSet`](#RedisModule\_HashSet) \* [`RedisModule\_HoldString`](#RedisModule\_HoldString) \* [`RedisModule\_InfoAddFieldCString`](#RedisModule\_InfoAddFieldCString) \* [`RedisModule\_InfoAddFieldDouble`](#RedisModule\_InfoAddFieldDouble) \* [`RedisModule\_InfoAddFieldLongLong`](#RedisModule\_InfoAddFieldLongLong) \* [`RedisModule\_InfoAddFieldString`](#RedisModule\_InfoAddFieldString) \* [`RedisModule\_InfoAddFieldULongLong`](#RedisModule\_InfoAddFieldULongLong) \* [`RedisModule\_InfoAddSection`](#RedisModule\_InfoAddSection) \* [`RedisModule\_InfoBeginDictField`](#RedisModule\_InfoBeginDictField) \* [`RedisModule\_InfoEndDictField`](#RedisModule\_InfoEndDictField) \* [`RedisModule\_IsBlockedReplyRequest`](#RedisModule\_IsBlockedReplyRequest) \* [`RedisModule\_IsBlockedTimeoutRequest`](#RedisModule\_IsBlockedTimeoutRequest) \* [`RedisModule\_IsChannelsPositionRequest`](#RedisModule\_IsChannelsPositionRequest) \* [`RedisModule\_IsIOError`](#RedisModule\_IsIOError) \* [`RedisModule\_IsKeysPositionRequest`](#RedisModule\_IsKeysPositionRequest) \* [`RedisModule\_IsModuleNameBusy`](#RedisModule\_IsModuleNameBusy) \* [`RedisModule\_IsSubEventSupported`](#RedisModule\_IsSubEventSupported) \* [`RedisModule\_KeyAtPos`](#RedisModule\_KeyAtPos) \* [`RedisModule\_KeyAtPosWithFlags`](#RedisModule\_KeyAtPosWithFlags) \* [`RedisModule\_KeyExists`](#RedisModule\_KeyExists) \* [`RedisModule\_KeyType`](#RedisModule\_KeyType) \* [`RedisModule\_KillForkChild`](#RedisModule\_KillForkChild) \* [`RedisModule\_LatencyAddSample`](#RedisModule\_LatencyAddSample) \* [`RedisModule\_ListDelete`](#RedisModule\_ListDelete) \* [`RedisModule\_ListGet`](#RedisModule\_ListGet) \* [`RedisModule\_ListInsert`](#RedisModule\_ListInsert) \* [`RedisModule\_ListPop`](#RedisModule\_ListPop) \* [`RedisModule\_ListPush`](#RedisModule\_ListPush) \* [`RedisModule\_ListSet`](#RedisModule\_ListSet) \* [`RedisModule\_LoadConfigs`](#RedisModule\_LoadConfigs) \* [`RedisModule\_LoadDataTypeFromString`](#RedisModule\_LoadDataTypeFromString) \* [`RedisModule\_LoadDataTypeFromStringEncver`](#RedisModule\_LoadDataTypeFromStringEncver) \* [`RedisModule\_LoadDouble`](#RedisModule\_LoadDouble) \* [`RedisModule\_LoadFloat`](#RedisModule\_LoadFloat) \* [`RedisModule\_LoadLongDouble`](#RedisModule\_LoadLongDouble) \* [`RedisModule\_LoadSigned`](#RedisModule\_LoadSigned) \* [`RedisModule\_LoadString`](#RedisModule\_LoadString) \* [`RedisModule\_LoadStringBuffer`](#RedisModule\_LoadStringBuffer) \* [`RedisModule\_LoadUnsigned`](#RedisModule\_LoadUnsigned) \* [`RedisModule\_Log`](#RedisModule\_Log) \* [`RedisModule\_LogIOError`](#RedisModule\_LogIOError) \* [`RedisModule\_MallocSize`](#RedisModule\_MallocSize) \* [`RedisModule\_MallocSizeDict`](#RedisModule\_MallocSizeDict) \* [`RedisModule\_MallocSizeString`](#RedisModule\_MallocSizeString) \* [`RedisModule\_MallocUsableSize`](#RedisModule\_MallocUsableSize) \* [`RedisModule\_Microseconds`](#RedisModule\_Microseconds) \* [`RedisModule\_Milliseconds`](#RedisModule\_Milliseconds) \* [`RedisModule\_ModuleTypeGetType`](#RedisModule\_ModuleTypeGetType) \* [`RedisModule\_ModuleTypeGetValue`](#RedisModule\_ModuleTypeGetValue) \* [`RedisModule\_ModuleTypeReplaceValue`](#RedisModule\_ModuleTypeReplaceValue) \* [`RedisModule\_ModuleTypeSetValue`](#RedisModule\_ModuleTypeSetValue) \* [`RedisModule\_MonotonicMicroseconds`](#RedisModule\_MonotonicMicroseconds) \* [`RedisModule\_NotifyKeyspaceEvent`](#RedisModule\_NotifyKeyspaceEvent) \* [`RedisModule\_OpenKey`](#RedisModule\_OpenKey) \* [`RedisModule\_PoolAlloc`](#RedisModule\_PoolAlloc) \* [`RedisModule\_PublishMessage`](#RedisModule\_PublishMessage) \* [`RedisModule\_PublishMessageShard`](#RedisModule\_PublishMessageShard) \* [`RedisModule\_RandomKey`](#RedisModule\_RandomKey) \* [`RedisModule\_RdbLoad`](#RedisModule\_RdbLoad) \* [`RedisModule\_RdbSave`](#RedisModule\_RdbSave) \* [`RedisModule\_RdbStreamCreateFromFile`](#RedisModule\_RdbStreamCreateFromFile) \* [`RedisModule\_RdbStreamFree`](#RedisModule\_RdbStreamFree) \* [`RedisModule\_Realloc`](#RedisModule\_Realloc) \* [`RedisModule\_RedactClientCommandArgument`](#RedisModule\_RedactClientCommandArgument) \* [`RedisModule\_RegisterAuthCallback`](#RedisModule\_RegisterAuthCallback) \* [`RedisModule\_RegisterBoolConfig`](#RedisModule\_RegisterBoolConfig) \* [`RedisModule\_RegisterClusterMessageReceiver`](#RedisModule\_RegisterClusterMessageReceiver) \* [`RedisModule\_RegisterCommandFilter`](#RedisModule\_RegisterCommandFilter) \* [`RedisModule\_RegisterDefragFunc`](#RedisModule\_RegisterDefragFunc) \* [`RedisModule\_RegisterEnumConfig`](#RedisModule\_RegisterEnumConfig) \* [`RedisModule\_RegisterInfoFunc`](#RedisModule\_RegisterInfoFunc) \* [`RedisModule\_RegisterNumericConfig`](#RedisModule\_RegisterNumericConfig) \* [`RedisModule\_RegisterStringConfig`](#RedisModule\_RegisterStringConfig) \* [`RedisModule\_Replicate`](#RedisModule\_Replicate) \* [`RedisModule\_ReplicateVerbatim`](#RedisModule\_ReplicateVerbatim) \* [`RedisModule\_ReplySetArrayLength`](#RedisModule\_ReplySetArrayLength) \* [`RedisModule\_ReplySetAttributeLength`](#RedisModule\_ReplySetAttributeLength) \* [`RedisModule\_ReplySetMapLength`](#RedisModule\_ReplySetMapLength) \* [`RedisModule\_ReplySetSetLength`](#RedisModule\_ReplySetSetLength) \* [`RedisModule\_ReplyWithArray`](#RedisModule\_ReplyWithArray) \* [`RedisModule\_ReplyWithAttribute`](#RedisModule\_ReplyWithAttribute) \* [`RedisModule\_ReplyWithBigNumber`](#RedisModule\_ReplyWithBigNumber) \* [`RedisModule\_ReplyWithBool`](#RedisModule\_ReplyWithBool) \* [`RedisModule\_ReplyWithCString`](#RedisModule\_ReplyWithCString) \* [`RedisModule\_ReplyWithCallReply`](#RedisModule\_ReplyWithCallReply) \* [`RedisModule\_ReplyWithDouble`](#RedisModule\_ReplyWithDouble) \* [`RedisModule\_ReplyWithEmptyArray`](#RedisModule\_ReplyWithEmptyArray) \* [`RedisModule\_ReplyWithEmptyString`](#RedisModule\_ReplyWithEmptyString) \* [`RedisModule\_ReplyWithError`](#RedisModule\_ReplyWithError) \* [`RedisModule\_ReplyWithErrorFormat`](#RedisModule\_ReplyWithErrorFormat) \* [`RedisModule\_ReplyWithLongDouble`](#RedisModule\_ReplyWithLongDouble) \* [`RedisModule\_ReplyWithLongLong`](#RedisModule\_ReplyWithLongLong) \* [`RedisModule\_ReplyWithMap`](#RedisModule\_ReplyWithMap) \* [`RedisModule\_ReplyWithNull`](#RedisModule\_ReplyWithNull) \* [`RedisModule\_ReplyWithNullArray`](#RedisModule\_ReplyWithNullArray) \* [`RedisModule\_ReplyWithSet`](#RedisModule\_ReplyWithSet) \* [`RedisModule\_ReplyWithSimpleString`](#RedisModule\_ReplyWithSimpleString) \* [`RedisModule\_ReplyWithString`](#RedisModule\_ReplyWithString) \* [`RedisModule\_ReplyWithStringBuffer`](#RedisModule\_ReplyWithStringBuffer) \* [`RedisModule\_ReplyWithVerbatimString`](#RedisModule\_ReplyWithVerbatimString) \* [`RedisModule\_ReplyWithVerbatimStringType`](#RedisModule\_ReplyWithVerbatimStringType) \* [`RedisModule\_ResetDataset`](#RedisModule\_ResetDataset) \* [`RedisModule\_RetainString`](#RedisModule\_RetainString) \* [`RedisModule\_SaveDataTypeToString`](#RedisModule\_SaveDataTypeToString) \* [`RedisModule\_SaveDouble`](#RedisModule\_SaveDouble) \* [`RedisModule\_SaveFloat`](#RedisModule\_SaveFloat) \* [`RedisModule\_SaveLongDouble`](#RedisModule\_SaveLongDouble) \* [`RedisModule\_SaveSigned`](#RedisModule\_SaveSigned) \* [`RedisModule\_SaveString`](#RedisModule\_SaveString) \* [`RedisModule\_SaveStringBuffer`](#RedisModule\_SaveStringBuffer) \* [`RedisModule\_SaveUnsigned`](#RedisModule\_SaveUnsigned) \* [`RedisModule\_Scan`](#RedisModule\_Scan) \* [`RedisModule\_ScanCursorCreate`](#RedisModule\_ScanCursorCreate) \* [`RedisModule\_ScanCursorDestroy`](#RedisModule\_ScanCursorDestroy) \* [`RedisModule\_ScanCursorRestart`](#RedisModule\_ScanCursorRestart) \* [`RedisModule\_ScanKey`](#RedisModule\_ScanKey) \* [`RedisModule\_SelectDb`](#RedisModule\_SelectDb) \* [`RedisModule\_SendChildHeartbeat`](#RedisModule\_SendChildHeartbeat) \* [`RedisModule\_SendClusterMessage`](#RedisModule\_SendClusterMessage) \* [`RedisModule\_ServerInfoGetField`](#RedisModule\_ServerInfoGetField) \* [`RedisModule\_ServerInfoGetFieldC`](#RedisModule\_ServerInfoGetFieldC) \* [`RedisModule\_ServerInfoGetFieldDouble`](#RedisModule\_ServerInfoGetFieldDouble) \* [`RedisModule\_ServerInfoGetFieldSigned`](#RedisModule\_ServerInfoGetFieldSigned) \* [`RedisModule\_ServerInfoGetFieldUnsigned`](#RedisModule\_ServerInfoGetFieldUnsigned) \* [`RedisModule\_SetAbsExpire`](#RedisModule\_SetAbsExpire) \* [`RedisModule\_SetClientNameById`](#RedisModule\_SetClientNameById) \* [`RedisModule\_SetClusterFlags`](#RedisModule\_SetClusterFlags) \* [`RedisModule\_SetCommandACLCategories`](#RedisModule\_SetCommandACLCategories) \* [`RedisModule\_SetCommandInfo`](#RedisModule\_SetCommandInfo) \* [`RedisModule\_SetContextUser`](#RedisModule\_SetContextUser) \* [`RedisModule\_SetDisconnectCallback`](#RedisModule\_SetDisconnectCallback) \* [`RedisModule\_SetExpire`](#RedisModule\_SetExpire) \* [`RedisModule\_SetLFU`](#RedisModule\_SetLFU) \* [`RedisModule\_SetLRU`](#RedisModule\_SetLRU) \* [`RedisModule\_SetModuleOptions`](#RedisModule\_SetModuleOptions) \* [`RedisModule\_SetModuleUserACL`](#RedisModule\_SetModuleUserACL) \* [`RedisModule\_SetModuleUserACLString`](#RedisModule\_SetModuleUserACLString) \* [`RedisModule\_SignalKeyAsReady`](#RedisModule\_SignalKeyAsReady) \* [`RedisModule\_SignalModifiedKey`](#RedisModule\_SignalModifiedKey) \* [`RedisModule\_StopTimer`](#RedisModule\_StopTimer) \* [`RedisModule\_Strdup`](#RedisModule\_Strdup) \* [`RedisModule\_StreamAdd`](#RedisModule\_StreamAdd) \* [`RedisModule\_StreamDelete`](#RedisModule\_StreamDelete) \* [`RedisModule\_StreamIteratorDelete`](#RedisModule\_StreamIteratorDelete) \* [`RedisModule\_StreamIteratorNextField`](#RedisModule\_StreamIteratorNextField) \* [`RedisModule\_StreamIteratorNextID`](#RedisModule\_StreamIteratorNextID) \* [`RedisModule\_StreamIteratorStart`](#RedisModule\_StreamIteratorStart) \* [`RedisModule\_StreamIteratorStop`](#RedisModule\_StreamIteratorStop) \* [`RedisModule\_StreamTrimByID`](#RedisModule\_StreamTrimByID) \* [`RedisModule\_StreamTrimByLength`](#RedisModule\_StreamTrimByLength) \* [`RedisModule\_StringAppendBuffer`](#RedisModule\_StringAppendBuffer) \* [`RedisModule\_StringCompare`](#RedisModule\_StringCompare) \* [`RedisModule\_StringDMA`](#RedisModule\_StringDMA) \* [`RedisModule\_StringPtrLen`](#RedisModule\_StringPtrLen) \* [`RedisModule\_StringSet`](#RedisModule\_StringSet) \* [`RedisModule\_StringToDouble`](#RedisModule\_StringToDouble) \* [`RedisModule\_StringToLongDouble`](#RedisModule\_StringToLongDouble) \* [`RedisModule\_StringToLongLong`](#RedisModule\_StringToLongLong) \* [`RedisModule\_StringToStreamID`](#RedisModule\_StringToStreamID) \* [`RedisModule\_StringToULongLong`](#RedisModule\_StringToULongLong) \* [`RedisModule\_StringTruncate`](#RedisModule\_StringTruncate) \* [`RedisModule\_SubscribeToKeyspaceEvents`](#RedisModule\_SubscribeToKeyspaceEvents) \* [`RedisModule\_SubscribeToServerEvent`](#RedisModule\_SubscribeToServerEvent) \* [`RedisModule\_ThreadSafeContextLock`](#RedisModule\_ThreadSafeContextLock) \* [`RedisModule\_ThreadSafeContextTryLock`](#RedisModule\_ThreadSafeContextTryLock) \* [`RedisModule\_ThreadSafeContextUnlock`](#RedisModule\_ThreadSafeContextUnlock) \* [`RedisModule\_TrimStringAllocation`](#RedisModule\_TrimStringAllocation) \* [`RedisModule\_TryAlloc`](#RedisModule\_TryAlloc) \* [`RedisModule\_UnblockClient`](#RedisModule\_UnblockClient) \* [`RedisModule\_UnlinkKey`](#RedisModule\_UnlinkKey) \* [`RedisModule\_UnregisterCommandFilter`](#RedisModule\_UnregisterCommandFilter) \* [`RedisModule\_ValueLength`](#RedisModule\_ValueLength) \* [`RedisModule\_WrongArity`](#RedisModule\_WrongArity) \* [`RedisModule\_Yield`](#RedisModule\_Yield) \* [`RedisModule\_ZsetAdd`](#RedisModule\_ZsetAdd) \* [`RedisModule\_ZsetFirstInLexRange`](#RedisModule\_ZsetFirstInLexRange) \* [`RedisModule\_ZsetFirstInScoreRange`](#RedisModule\_ZsetFirstInScoreRange) \* [`RedisModule\_ZsetIncrby`](#RedisModule\_ZsetIncrby) \* [`RedisModule\_ZsetLastInLexRange`](#RedisModule\_ZsetLastInLexRange) \* [`RedisModule\_ZsetLastInScoreRange`](#RedisModule\_ZsetLastInScoreRange) \* [`RedisModule\_ZsetRangeCurrentElement`](#RedisModule\_ZsetRangeCurrentElement) \* [`RedisModule\_ZsetRangeEndReached`](#RedisModule\_ZsetRangeEndReached) \* [`RedisModule\_ZsetRangeNext`](#RedisModule\_ZsetRangeNext) \* | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.009639625437557697,
0.002535981358960271,
-0.06637091934680939,
0.0035882387310266495,
-0.03214823454618454,
-0.07945293188095093,
0.13969410955905914,
-0.0134983966127038,
-0.042163968086242676,
-0.005022862926125526,
0.015416799113154411,
-0.0927555039525032,
0.09310605376958847,
-0.0... | 0.041735 |
[`RedisModule\_StringToStreamID`](#RedisModule\_StringToStreamID) \* [`RedisModule\_StringToULongLong`](#RedisModule\_StringToULongLong) \* [`RedisModule\_StringTruncate`](#RedisModule\_StringTruncate) \* [`RedisModule\_SubscribeToKeyspaceEvents`](#RedisModule\_SubscribeToKeyspaceEvents) \* [`RedisModule\_SubscribeToServerEvent`](#RedisModule\_SubscribeToServerEvent) \* [`RedisModule\_ThreadSafeContextLock`](#RedisModule\_ThreadSafeContextLock) \* [`RedisModule\_ThreadSafeContextTryLock`](#RedisModule\_ThreadSafeContextTryLock) \* [`RedisModule\_ThreadSafeContextUnlock`](#RedisModule\_ThreadSafeContextUnlock) \* [`RedisModule\_TrimStringAllocation`](#RedisModule\_TrimStringAllocation) \* [`RedisModule\_TryAlloc`](#RedisModule\_TryAlloc) \* [`RedisModule\_UnblockClient`](#RedisModule\_UnblockClient) \* [`RedisModule\_UnlinkKey`](#RedisModule\_UnlinkKey) \* [`RedisModule\_UnregisterCommandFilter`](#RedisModule\_UnregisterCommandFilter) \* [`RedisModule\_ValueLength`](#RedisModule\_ValueLength) \* [`RedisModule\_WrongArity`](#RedisModule\_WrongArity) \* [`RedisModule\_Yield`](#RedisModule\_Yield) \* [`RedisModule\_ZsetAdd`](#RedisModule\_ZsetAdd) \* [`RedisModule\_ZsetFirstInLexRange`](#RedisModule\_ZsetFirstInLexRange) \* [`RedisModule\_ZsetFirstInScoreRange`](#RedisModule\_ZsetFirstInScoreRange) \* [`RedisModule\_ZsetIncrby`](#RedisModule\_ZsetIncrby) \* [`RedisModule\_ZsetLastInLexRange`](#RedisModule\_ZsetLastInLexRange) \* [`RedisModule\_ZsetLastInScoreRange`](#RedisModule\_ZsetLastInScoreRange) \* [`RedisModule\_ZsetRangeCurrentElement`](#RedisModule\_ZsetRangeCurrentElement) \* [`RedisModule\_ZsetRangeEndReached`](#RedisModule\_ZsetRangeEndReached) \* [`RedisModule\_ZsetRangeNext`](#RedisModule\_ZsetRangeNext) \* [`RedisModule\_ZsetRangePrev`](#RedisModule\_ZsetRangePrev) \* [`RedisModule\_ZsetRangeStop`](#RedisModule\_ZsetRangeStop) \* [`RedisModule\_ZsetRem`](#RedisModule\_ZsetRem) \* [`RedisModule\_ZsetScore`](#RedisModule\_ZsetScore) \* [`RedisModule\_\_Assert`](#RedisModule\_\_Assert) | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-api-ref.md | master | redis | [
-0.0219742301851511,
-0.005208424758166075,
-0.021737273782491684,
0.00841006264090538,
0.0132682416588068,
-0.0321703776717186,
0.10224732011556625,
-0.02758154645562172,
-0.00966913253068924,
-0.04415406286716461,
-0.01270477194339037,
-0.04620712250471115,
0.033876750618219376,
-0.05408... | 0.105344 |
Redis modules can access Redis built-in data structures both at high level, by calling Redis commands, and at low level, by manipulating the data structures directly. By using these capabilities in order to build new abstractions on top of existing Redis data structures, or by using strings DMA in order to encode modules data structures into Redis strings, it is possible to create modules that \*feel like\* they are exporting new data types. However, for more complex problems, this is not enough, and the implementation of new data structures inside the module is needed. We call the ability of Redis modules to implement new data structures that feel like native Redis ones \*\*native types support\*\*. This document describes the API exported by the Redis modules system in order to create new data structures and handle the serialization in RDB files, the rewriting process in AOF, the type reporting via the `TYPE` command, and so forth. Overview of native types --- A module exporting a native type is composed of the following main parts: \* The implementation of some kind of new data structure and of commands operating on the new data structure. \* A set of callbacks that handle: RDB saving, RDB loading, AOF rewriting, releasing of a value associated with a key, calculation of a value digest (hash) to be used with the `DEBUG DIGEST` command. \* A 9 characters name that is unique to each module native data type. \* An encoding version, used to persist into RDB files a module-specific data version, so that a module will be able to load older representations from RDB files. While to handle RDB loading, saving and AOF rewriting may look complex as a first glance, the modules API provide very high level function for handling all this, without requiring the user to handle read/write errors, so in practical terms, writing a new data structure for Redis is a simple task. A \*\*very easy\*\* to understand but complete example of native type implementation is available inside the Redis distribution in the `/modules/hellotype.c` file. The reader is encouraged to read the documentation by looking at this example implementation to see how things are applied in the practice. Registering a new data type === In order to register a new native type into the Redis core, the module needs to declare a global variable that will hold a reference to the data type. The API to register the data type will return a data type reference that will be stored in the global variable. static RedisModuleType \*MyType; #define MYTYPE\_ENCODING\_VERSION 0 int RedisModule\_OnLoad(RedisModuleCtx \*ctx) { RedisModuleTypeMethods tm = { .version = REDISMODULE\_TYPE\_METHOD\_VERSION, .rdb\_load = MyTypeRDBLoad, .rdb\_save = MyTypeRDBSave, .aof\_rewrite = MyTypeAOFRewrite, .free = MyTypeFree }; MyType = RedisModule\_CreateDataType(ctx, "MyType-AZ", MYTYPE\_ENCODING\_VERSION, &tm); if (MyType == NULL) return REDISMODULE\_ERR; } As you can see from the example above, a single API call is needed in order to register the new type. However a number of function pointers are passed as arguments. Certain are optionals while some are mandatory. The above set of methods \*must\* be passed, while `.digest` and `.mem\_usage` are optional and are currently not actually supported by the modules internals, so for now you can just ignore them. The `ctx` argument is the context that we receive in the `OnLoad` function. The type `name` is a 9 character name in the character set that includes from `A-Z`, `a-z`, `0-9`, plus the underscore `\_` and minus `-` characters. Note that \*\*this name must be unique\*\* for each data type in the Redis ecosystem, so be creative, use both lower-case and upper case if it makes | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
-0.065529964864254,
-0.03436756134033203,
-0.05791084095835686,
0.02073424495756626,
-0.05698773264884949,
-0.09908080101013184,
0.0060904985293745995,
0.0233021043241024,
-0.06103372573852539,
-0.030057888478040695,
-0.035740096122026443,
-0.01586524397134781,
0.030659811571240425,
-0.015... | 0.173731 |
is a 9 character name in the character set that includes from `A-Z`, `a-z`, `0-9`, plus the underscore `\_` and minus `-` characters. Note that \*\*this name must be unique\*\* for each data type in the Redis ecosystem, so be creative, use both lower-case and upper case if it makes sense, and try to use the convention of mixing the type name with the name of the author of the module, to create a 9 character unique name. \*\*NOTE:\*\* It is very important that the name is exactly 9 chars or the registration of the type will fail. Read more to understand why. For example if I'm building a \*b-tree\* data structure and my name is \*antirez\* I'll call my type \*\*btree1-az\*\*. The name, converted to a 64 bit integer, is stored inside the RDB file when saving the type, and will be used when the RDB data is loaded in order to resolve what module can load the data. If Redis finds no matching module, the integer is converted back to a name in order to provide some clue to the user about what module is missing in order to load the data. The type name is also used as a reply for the `TYPE` command when called with a key holding the registered type. The `encver` argument is the encoding version used by the module to store data inside the RDB file. For example I can start with an encoding version of 0, but later when I release version 2.0 of my module, I can switch encoding to something better. The new module will register with an encoding version of 1, so when it saves new RDB files, the new version will be stored on disk. However when loading RDB files, the module `rdb\_load` method will be called even if there is data found for a different encoding version (and the encoding version is passed as argument to `rdb\_load`), so that the module can still load old RDB files. The last argument is a structure used in order to pass the type methods to the registration function: `rdb\_load`, `rdb\_save`, `aof\_rewrite`, `digest` and `free` and `mem\_usage` are all callbacks with the following prototypes and uses: typedef void \*(\*RedisModuleTypeLoadFunc)(RedisModuleIO \*rdb, int encver); typedef void (\*RedisModuleTypeSaveFunc)(RedisModuleIO \*rdb, void \*value); typedef void (\*RedisModuleTypeRewriteFunc)(RedisModuleIO \*aof, RedisModuleString \*key, void \*value); typedef size\_t (\*RedisModuleTypeMemUsageFunc)(void \*value); typedef void (\*RedisModuleTypeDigestFunc)(RedisModuleDigest \*digest, void \*value); typedef void (\*RedisModuleTypeFreeFunc)(void \*value); \* `rdb\_load` is called when loading data from the RDB file. It loads data in the same format as `rdb\_save` produces. \* `rdb\_save` is called when saving data to the RDB file. \* `aof\_rewrite` is called when the AOF is being rewritten, and the module needs to tell Redis what is the sequence of commands to recreate the content of a given key. \* `digest` is called when `DEBUG DIGEST` is executed and a key holding this module type is found. Currently this is not yet implemented so the function ca be left empty. \* `mem\_usage` is called when the `MEMORY` command asks for the total memory consumed by a specific key, and is used in order to get the amount of bytes used by the module value. \* `free` is called when a key with the module native type is deleted via `DEL` or in any other mean, in order to let the module reclaim the memory associated with such a value. Ok, but \*why\* modules types require a 9 characters name? --- Oh, I understand you need to understand this, so here is a very specific explanation. When Redis persists to RDB files, modules specific data types require | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
-0.0740438774228096,
-0.04517840966582298,
-0.04723077267408371,
0.02514590509235859,
-0.13367319107055664,
-0.04451218992471695,
0.09861290454864502,
0.04250776767730713,
-0.0033613662235438824,
-0.0483168326318264,
0.019930582493543625,
-0.03333568945527077,
0.12194310873746872,
-0.01545... | 0.095315 |
order to let the module reclaim the memory associated with such a value. Ok, but \*why\* modules types require a 9 characters name? --- Oh, I understand you need to understand this, so here is a very specific explanation. When Redis persists to RDB files, modules specific data types require to be persisted as well. Now RDB files are sequences of key-value pairs like the following: [1 byte type] [key] [a type specific value] The 1 byte type identifies strings, lists, sets, and so forth. In the case of modules data, it is set to a special value of `module data`, but of course this is not enough, we need the information needed to link a specific value with a specific module type that is able to load and handle it. So when we save a `type specific value` about a module, we prefix it with a 64 bit integer. 64 bits is large enough to store the information needed in order to lookup the module that can handle that specific type, but is short enough that we can prefix each module value we store inside the RDB without making the final RDB file too big. At the same time, this solution of prefixing the value with a 64 bit \*signature\* does not require to do strange things like defining in the RDB header a list of modules specific types. Everything is pretty simple. So, what you can store in 64 bits in order to identify a given module in a reliable way? Well if you build a character set of 64 symbols, you can easily store 9 characters of 6 bits, and you are left with 10 bits, that are used in order to store the \*encoding version\* of the type, so that the same type can evolve in the future and provide a different and more efficient or updated serialization format for RDB files. So the 64 bit prefix stored before each module value is like the following: 6|6|6|6|6|6|6|6|6|10 The first 9 elements are 6-bits characters, the final 10 bits is the encoding version. When the RDB file is loaded back, it reads the 64 bit value, masks the final 10 bits, and searches for a matching module in the modules types cache. When a matching one is found, the method to load the RDB file value is called with the 10 bits encoding version as argument, so that the module knows what version of the data layout to load, if it can support multiple versions. Now the interesting thing about all this is that, if instead the module type cannot be resolved, since there is no loaded module having this signature, we can convert back the 64 bit value into a 9 characters name, and print an error to the user that includes the module type name! So that she or he immediately realizes what's wrong. Setting and getting keys --- After registering our new data type in the `RedisModule\_OnLoad()` function, we also need to be able to set Redis keys having as value our native type. This normally happens in the context of commands that write data to a key. The native types API allow to set and get keys to module native data types, and to test if a given key is already associated to a value of a specific data type. The API uses the normal modules `RedisModule\_OpenKey()` low level key access interface in order to deal with this. This is an example of setting a native type private data structure to a Redis key: RedisModuleKey \*key = RedisModule\_OpenKey(ctx,keyname,REDISMODULE\_WRITE); struct some\_private\_struct \*data = createMyDataStructure(); | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
0.01881609857082367,
-0.006207865197211504,
-0.10759474337100983,
0.04929183050990105,
-0.05710061267018318,
0.016352782025933266,
0.05099950730800629,
0.06260891258716583,
0.010604120790958405,
-0.04932936653494835,
-0.018401097506284714,
0.06519726663827896,
0.04099494591355324,
-0.01065... | 0.069143 |
a value of a specific data type. The API uses the normal modules `RedisModule\_OpenKey()` low level key access interface in order to deal with this. This is an example of setting a native type private data structure to a Redis key: RedisModuleKey \*key = RedisModule\_OpenKey(ctx,keyname,REDISMODULE\_WRITE); struct some\_private\_struct \*data = createMyDataStructure(); RedisModule\_ModuleTypeSetValue(key,MyType,data); The function `RedisModule\_ModuleTypeSetValue()` is used with a key handle open for writing, and gets three arguments: the key handle, the reference to the native type, as obtained during the type registration, and finally a `void\*` pointer that contains the private data implementing the module native type. Note that Redis has no clues at all about what your data contains. It will just call the callbacks you provided during the method registration in order to perform operations on the type. Similarly we can retrieve the private data from a key using this function: struct some\_private\_struct \*data; data = RedisModule\_ModuleTypeGetValue(key); We can also test for a key to have our native type as value: if (RedisModule\_ModuleTypeGetType(key) == MyType) { /\* ... do something ... \*/ } However for the calls to do the right thing, we need to check if the key is empty, if it contains a value of the right kind, and so forth. So the idiomatic code to implement a command writing to our native type is along these lines: RedisModuleKey \*key = RedisModule\_OpenKey(ctx,argv[1], REDISMODULE\_READ|REDISMODULE\_WRITE); int type = RedisModule\_KeyType(key); if (type != REDISMODULE\_KEYTYPE\_EMPTY && RedisModule\_ModuleTypeGetType(key) != MyType) { return RedisModule\_ReplyWithError(ctx,REDISMODULE\_ERRORMSG\_WRONGTYPE); } Then if we successfully verified the key is not of the wrong type, and we are going to write to it, we usually want to create a new data structure if the key is empty, or retrieve the reference to the value associated to the key if there is already one: /\* Create an empty value object if the key is currently empty. \*/ struct some\_private\_struct \*data; if (type == REDISMODULE\_KEYTYPE\_EMPTY) { data = createMyDataStructure(); RedisModule\_ModuleTypeSetValue(key,MyTyke,data); } else { data = RedisModule\_ModuleTypeGetValue(key); } /\* Do something with 'data'... \*/ Free method --- As already mentioned, when Redis needs to free a key holding a native type value, it needs help from the module in order to release the memory. This is the reason why we pass a `free` callback during the type registration: typedef void (\*RedisModuleTypeFreeFunc)(void \*value); A trivial implementation of the free method can be something like this, assuming our data structure is composed of a single allocation: void MyTypeFreeCallback(void \*value) { RedisModule\_Free(value); } However a more real world one will call some function that performs a more complex memory reclaiming, by casting the void pointer to some structure and freeing all the resources composing the value. RDB load and save methods --- The RDB saving and loading callbacks need to create (and load back) a representation of the data type on disk. Redis offers a high level API that can automatically store inside the RDB file the following types: \* Unsigned 64 bit integers. \* Signed 64 bit integers. \* Doubles. \* Strings. It is up to the module to find a viable representation using the above base types. However note that while the integer and double values are stored and loaded in an architecture and \*endianness\* agnostic way, if you use the raw string saving API to, for example, save a structure on disk, you have to care those details yourself. This is the list of functions performing RDB saving and loading: void RedisModule\_SaveUnsigned(RedisModuleIO \*io, uint64\_t value); uint64\_t RedisModule\_LoadUnsigned(RedisModuleIO \*io); void RedisModule\_SaveSigned(RedisModuleIO \*io, int64\_t value); int64\_t RedisModule\_LoadSigned(RedisModuleIO \*io); void RedisModule\_SaveString(RedisModuleIO \*io, RedisModuleString \*s); void RedisModule\_SaveStringBuffer(RedisModuleIO \*io, const char \*str, size\_t len); RedisModuleString \*RedisModule\_LoadString(RedisModuleIO \*io); | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
-0.029312385246157646,
-0.023537224158644676,
-0.11864938586950302,
0.07294502854347229,
-0.08445187658071518,
-0.06194847822189331,
0.07091186940670013,
0.08237927407026291,
-0.014231903478503227,
-0.02213115058839321,
0.029846081510186195,
0.004040644969791174,
0.006081124301999807,
-0.0... | 0.190568 |
you have to care those details yourself. This is the list of functions performing RDB saving and loading: void RedisModule\_SaveUnsigned(RedisModuleIO \*io, uint64\_t value); uint64\_t RedisModule\_LoadUnsigned(RedisModuleIO \*io); void RedisModule\_SaveSigned(RedisModuleIO \*io, int64\_t value); int64\_t RedisModule\_LoadSigned(RedisModuleIO \*io); void RedisModule\_SaveString(RedisModuleIO \*io, RedisModuleString \*s); void RedisModule\_SaveStringBuffer(RedisModuleIO \*io, const char \*str, size\_t len); RedisModuleString \*RedisModule\_LoadString(RedisModuleIO \*io); char \*RedisModule\_LoadStringBuffer(RedisModuleIO \*io, size\_t \*lenptr); void RedisModule\_SaveDouble(RedisModuleIO \*io, double value); double RedisModule\_LoadDouble(RedisModuleIO \*io); The functions don't require any error checking from the module, that can always assume calls succeed. As an example, imagine I've a native type that implements an array of double values, with the following structure: struct double\_array { size\_t count; double \*values; }; My `rdb\_save` method may look like the following: void DoubleArrayRDBSave(RedisModuleIO \*io, void \*ptr) { struct dobule\_array \*da = ptr; RedisModule\_SaveUnsigned(io,da->count); for (size\_t j = 0; j < da->count; j++) RedisModule\_SaveDouble(io,da->values[j]); } What we did was to store the number of elements followed by each double value. So when later we'll have to load the structure in the `rdb\_load` method we'll do something like this: void \*DoubleArrayRDBLoad(RedisModuleIO \*io, int encver) { if (encver != DOUBLE\_ARRAY\_ENC\_VER) { /\* We should actually log an error here, or try to implement the ability to load older versions of our data structure. \*/ return NULL; } struct double\_array \*da; da = RedisModule\_Alloc(sizeof(\*da)); da->count = RedisModule\_LoadUnsigned(io); da->values = RedisModule\_Alloc(da->count \* sizeof(double)); for (size\_t j = 0; j < da->count; j++) da->values[j] = RedisModule\_LoadDouble(io); return da; } The load callback just reconstruct back the data structure from the data we stored in the RDB file. Note that while there is no error handling on the API that writes and reads from disk, still the load callback can return NULL on errors in case what it reads does not look correct. Redis will just panic in that case. AOF rewriting --- void RedisModule\_EmitAOF(RedisModuleIO \*io, const char \*cmdname, const char \*fmt, ...); Handling multiple encodings --- WORK IN PROGRESS Allocating memory --- Modules data types should try to use `RedisModule\_Alloc()` functions family in order to allocate, reallocate and release heap memory used to implement the native data structures (see the other Redis Modules documentation for detailed information). This is not just useful in order for Redis to be able to account for the memory used by the module, but there are also more advantages: \* Redis uses the `jemalloc` allocator, that often prevents fragmentation problems that could be caused by using the libc allocator. \* When loading strings from the RDB file, the native types API is able to return strings allocated directly with `RedisModule\_Alloc()`, so that the module can directly link this memory into the data structure representation, avoiding a useless copy of the data. Even if you are using external libraries implementing your data structures, the allocation functions provided by the module API is exactly compatible with `malloc()`, `realloc()`, `free()` and `strdup()`, so converting the libraries in order to use these functions should be trivial. In case you have an external library that uses libc `malloc()`, and you want to avoid replacing manually all the calls with the Redis Modules API calls, an approach could be to use simple macros in order to replace the libc calls with the Redis API calls. Something like this could work: #define malloc RedisModule\_Alloc #define realloc RedisModule\_Realloc #define free RedisModule\_Free #define strdup RedisModule\_Strdup However take in mind that mixing libc calls with Redis API calls will result into troubles and crashes, so if you replace calls using macros, you need to make sure that all the calls are correctly replaced, and that the code with the substituted calls will never, for example, attempt to call | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
0.04754302278161049,
-0.004092744551599026,
-0.11984233558177948,
-0.024156825616955757,
-0.08409976959228516,
0.007898344658315182,
-0.012485799379646778,
0.08805178105831146,
-0.08343978971242905,
0.006121041718870401,
-0.03210330754518509,
-0.0714777484536171,
0.04473593458533287,
-0.07... | 0.078926 |
in mind that mixing libc calls with Redis API calls will result into troubles and crashes, so if you replace calls using macros, you need to make sure that all the calls are correctly replaced, and that the code with the substituted calls will never, for example, attempt to call `RedisModule\_Free()` with a pointer allocated using libc `malloc()`. | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-native-types.md | master | redis | [
-0.009588897228240967,
-0.05386849865317345,
-0.10673082619905472,
0.018652064725756645,
-0.05106010660529137,
-0.04843149706721306,
0.026688069105148315,
0.05387771874666214,
0.011488573625683784,
-0.031277406960725784,
-0.03439124673604965,
-0.020284729078412056,
-0.0292372889816761,
-0.... | 0.087433 |
Redis has a few blocking commands among the built-in set of commands. One of the most used is `BLPOP` (or the symmetric `BRPOP`) which blocks waiting for elements arriving in a list. The interesting fact about blocking commands is that they do not block the whole server, but just the client calling them. Usually the reason to block is that we expect some external event to happen: this can be some change in the Redis data structures like in the `BLPOP` case, a long computation happening in a thread, to receive some data from the network, and so forth. Redis modules have the ability to implement blocking commands as well, this documentation shows how the API works and describes a few patterns that can be used in order to model blocking commands. How blocking and resuming works. --- \_Note: You may want to check the `helloblock.c` example in the Redis source tree inside the `src/modules` directory, for a simple to understand example on how the blocking API is applied.\_ In Redis modules, commands are implemented by callback functions that are invoked by the Redis core when the specific command is called by the user. Normally the callback terminates its execution sending some reply to the client. Using the following function instead, the function implementing the module command may request that the client is put into the blocked state: RedisModuleBlockedClient \*RedisModule\_BlockClient(RedisModuleCtx \*ctx, RedisModuleCmdFunc reply\_callback, RedisModuleCmdFunc timeout\_callback, void (\*free\_privdata)(void\*), long long timeout\_ms); The function returns a `RedisModuleBlockedClient` object, which is later used in order to unblock the client. The arguments have the following meaning: \* `ctx` is the command execution context as usually in the rest of the API. \* `reply\_callback` is the callback, having the same prototype of a normal command function, that is called when the client is unblocked in order to return a reply to the client. \* `timeout\_callback` is the callback, having the same prototype of a normal command function that is called when the client reached the `ms` timeout. \* `free\_privdata` is the callback that is called in order to free the private data. Private data is a pointer to some data that is passed between the API used to unblock the client, to the callback that will send the reply to the client. We'll see how this mechanism works later in this document. \* `ms` is the timeout in milliseconds. When the timeout is reached, the timeout callback is called and the client is automatically aborted. Once a client is blocked, it can be unblocked with the following API: int RedisModule\_UnblockClient(RedisModuleBlockedClient \*bc, void \*privdata); The function takes as argument the blocked client object returned by the previous call to `RedisModule\_BlockClient()`, and unblock the client. Immediately before the client gets unblocked, the `reply\_callback` function specified when the client was blocked is called: this function will have access to the `privdata` pointer used here. IMPORTANT: The above function is thread safe, and can be called from within a thread doing some work in order to implement the command that blocked the client. The `privdata` data will be freed automatically using the `free\_privdata` callback when the client is unblocked. This is useful \*\*since the reply callback may never be called\*\* in case the client timeouts or disconnects from the server, so it's important that it's up to an external function to have the responsibility to free the data passed if needed. To better understand how the API works, we can imagine writing a command that blocks a client for one second, and then send as reply "Hello!". Note: arity checks and other non important things are not implemented int | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-blocking-ops.md | master | redis | [
-0.10709188133478165,
-0.03649653121829033,
-0.06432223320007324,
0.02550407312810421,
0.03280298039317131,
-0.10125011950731277,
0.006940905470401049,
-0.05405903607606888,
0.06366021931171417,
-0.01609537936747074,
0.004345500376075506,
0.038113079965114594,
-0.020640365779399872,
-0.083... | 0.158077 |
function to have the responsibility to free the data passed if needed. To better understand how the API works, we can imagine writing a command that blocks a client for one second, and then send as reply "Hello!". Note: arity checks and other non important things are not implemented int his command, in order to take the example simple. int Example\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { RedisModuleBlockedClient \*bc = RedisModule\_BlockClient(ctx,reply\_func,timeout\_func,NULL,0); pthread\_t tid; pthread\_create(&tid,NULL,threadmain,bc); return REDISMODULE\_OK; } void \*threadmain(void \*arg) { RedisModuleBlockedClient \*bc = arg; sleep(1); /\* Wait one second and unblock. \*/ RedisModule\_UnblockClient(bc,NULL); } The above command blocks the client ASAP, spawning a thread that will wait a second and will unblock the client. Let's check the reply and timeout callbacks, which are in our case very similar, since they just reply the client with a different reply type. int reply\_func(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { return RedisModule\_ReplyWithSimpleString(ctx,"Hello!"); } int timeout\_func(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { return RedisModule\_ReplyWithNull(ctx); } The reply callback just sends the "Hello!" string to the client. The important bit here is that the reply callback is called when the client is unblocked from the thread. The timeout command returns `NULL`, as it often happens with actual Redis blocking commands timing out. Passing reply data when unblocking --- The above example is simple to understand but lacks an important real world aspect of an actual blocking command implementation: often the reply function will need to know what to reply to the client, and this information is often provided as the client is unblocked. We could modify the above example so that the thread generates a random number after waiting one second. You can think at it as an actually expansive operation of some kind. Then this random number can be passed to the reply function so that we return it to the command caller. In order to make this working, we modify the functions as follow: void \*threadmain(void \*arg) { RedisModuleBlockedClient \*bc = arg; sleep(1); /\* Wait one second and unblock. \*/ long \*mynumber = RedisModule\_Alloc(sizeof(long)); \*mynumber = rand(); RedisModule\_UnblockClient(bc,mynumber); } As you can see, now the unblocking call is passing some private data, that is the `mynumber` pointer, to the reply callback. In order to obtain this private data, the reply callback will use the following function: void \*RedisModule\_GetBlockedClientPrivateData(RedisModuleCtx \*ctx); So our reply callback is modified like that: int reply\_func(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { long \*mynumber = RedisModule\_GetBlockedClientPrivateData(ctx); /\* IMPORTANT: don't free mynumber here, but in the \* free privdata callback. \*/ return RedisModule\_ReplyWithLongLong(ctx,mynumber); } Note that we also need to pass a `free\_privdata` function when blocking the client with `RedisModule\_BlockClient()`, since the allocated long value must be freed. Our callback will look like the following: void free\_privdata(void \*privdata) { RedisModule\_Free(privdata); } NOTE: It is important to stress that the private data is best freed in the `free\_privdata` callback because the reply function may not be called if the client disconnects or timeout. Also note that the private data is also accessible from the timeout callback, always using the `GetBlockedClientPrivateData()` API. Aborting the blocking of a client --- One problem that sometimes arises is that we need to allocate resources in order to implement the non blocking command. So we block the client, then, for example, try to create a thread, but the thread creation function returns an error. What to do in such a condition in order to recover? We don't want to take the client blocked, nor we want to call `UnblockClient()` because this will trigger the reply callback to be called. In this case the best thing to | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-blocking-ops.md | master | redis | [
-0.0686042457818985,
0.04976751282811165,
-0.06061457097530365,
0.025902315974235535,
-0.04764120280742645,
-0.05842529237270355,
0.0624825693666935,
0.01158866472542286,
0.058372240513563156,
0.024227144196629524,
-0.02705281786620617,
-0.054344650357961655,
-0.007898536510765553,
-0.0836... | 0.201651 |
but the thread creation function returns an error. What to do in such a condition in order to recover? We don't want to take the client blocked, nor we want to call `UnblockClient()` because this will trigger the reply callback to be called. In this case the best thing to do is to use the following function: int RedisModule\_AbortBlock(RedisModuleBlockedClient \*bc); Practically this is how to use it: int Example\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { RedisModuleBlockedClient \*bc = RedisModule\_BlockClient(ctx,reply\_func,timeout\_func,NULL,0); pthread\_t tid; if (pthread\_create(&tid,NULL,threadmain,bc) != 0) { RedisModule\_AbortBlock(bc); RedisModule\_ReplyWithError(ctx,"Sorry can't create a thread"); } return REDISMODULE\_OK; } The client will be unblocked but the reply callback will not be called. Implementing the command, reply and timeout callback using a single function --- The following functions can be used in order to implement the reply and callback with the same function that implements the primary command function: int RedisModule\_IsBlockedReplyRequest(RedisModuleCtx \*ctx); int RedisModule\_IsBlockedTimeoutRequest(RedisModuleCtx \*ctx); So I could rewrite the example command without using a separated reply and timeout callback: int Example\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { if (RedisModule\_IsBlockedReplyRequest(ctx)) { long \*mynumber = RedisModule\_GetBlockedClientPrivateData(ctx); return RedisModule\_ReplyWithLongLong(ctx,mynumber); } else if (RedisModule\_IsBlockedTimeoutRequest) { return RedisModule\_ReplyWithNull(ctx); } RedisModuleBlockedClient \*bc = RedisModule\_BlockClient(ctx,reply\_func,timeout\_func,NULL,0); pthread\_t tid; if (pthread\_create(&tid,NULL,threadmain,bc) != 0) { RedisModule\_AbortBlock(bc); RedisModule\_ReplyWithError(ctx,"Sorry can't create a thread"); } return REDISMODULE\_OK; } Functionally is the same but there are people that will prefer the less verbose implementation that concentrates most of the command logic in a single function. Working on copies of data inside a thread --- An interesting pattern in order to work with threads implementing the slow part of a command, is to work with a copy of the data, so that while some operation is performed in a key, the user continues to see the old version. However when the thread terminated its work, the representations are swapped and the new, processed version, is used. An example of this approach is the [Neural Redis module](https://github.com/antirez/neural-redis) where neural networks are trained in different threads while the user can still execute and inspect their older versions. Future work --- An API is work in progress right now in order to allow Redis modules APIs to be called in a safe way from threads, so that the threaded command can access the data space and do incremental operations. There is no ETA for this feature but it may appear in the course of the Redis 4.0 release at some point. | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/modules-blocking-ops.md | master | redis | [
-0.09968757629394531,
-0.0003359966503921896,
-0.04411478340625763,
0.011974290944635868,
-0.06598770618438721,
-0.011848872527480125,
0.04708974435925484,
0.008492803201079369,
0.01453245710581541,
0.01660796068608761,
0.0031750935595482588,
-0.08899535238742828,
-0.009528255090117455,
-0... | 0.088732 |
The modules documentation is composed of the following pages: \* Introduction to Redis modules (this file). An overview about Redis Modules system and API. It's a good idea to start your reading here. \* [Implementing native data types](/topics/modules-native-types) covers the implementation of native data types into modules. \* [Blocking operations](/topics/modules-blocking-ops) shows how to write blocking commands that will not reply immediately, but will block the client, without blocking the Redis server, and will provide a reply whenever will be possible. \* [Redis modules API reference](/topics/modules-api-ref) is generated from module.c top comments of RedisModule functions. It is a good reference in order to understand how each function works. Redis modules make it possible to extend Redis functionality using external modules, rapidly implementing new Redis commands with features similar to what can be done inside the core itself. Redis modules are dynamic libraries that can be loaded into Redis at startup, or using the `MODULE LOAD` command. Redis exports a C API, in the form of a single C header file called `redismodule.h`. Modules are meant to be written in C, however it will be possible to use C++ or other languages that have C binding functionalities. Modules are designed in order to be loaded into different versions of Redis, so a given module does not need to be designed, or recompiled, in order to run with a specific version of Redis. For this reason, the module will register to the Redis core using a specific API version. The current API version is "1". This document is about an alpha version of Redis modules. API, functionalities and other details may change in the future. ## Loading modules In order to test the module you are developing, you can load the module using the following `redis.conf` configuration directive: loadmodule /path/to/mymodule.so It is also possible to load a module at runtime using the following command: MODULE LOAD /path/to/mymodule.so In order to list all loaded modules, use: MODULE LIST Finally, you can unload (and later reload if you wish) a module using the following command: MODULE UNLOAD mymodule Note that `mymodule` above is not the filename without the `.so` suffix, but instead, the name the module used to register itself into the Redis core. The name can be obtained using `MODULE LIST`. However it is good practice that the filename of the dynamic library is the same as the name the module uses to register itself into the Redis core. ## The simplest module you can write In order to show the different parts of a module, here we'll show a very simple module that implements a command that outputs a random number. #include "redismodule.h" #include int HelloworldRand\_RedisCommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { RedisModule\_ReplyWithLongLong(ctx,rand()); return REDISMODULE\_OK; } int RedisModule\_OnLoad(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc) { if (RedisModule\_Init(ctx,"helloworld",1,REDISMODULE\_APIVER\_1) == REDISMODULE\_ERR) return REDISMODULE\_ERR; if (RedisModule\_CreateCommand(ctx,"helloworld.rand", HelloworldRand\_RedisCommand, "fast random", 0, 0, 0) == REDISMODULE\_ERR) return REDISMODULE\_ERR; return REDISMODULE\_OK; } The example module has two functions. One implements a command called HELLOWORLD.RAND. This function is specific of that module. However the other function called `RedisModule\_OnLoad()` must be present in each Redis module. It is the entry point for the module to be initialized, register its commands, and potentially other private data structures it uses. Note that it is a good idea for modules to call commands with the name of the module followed by a dot, and finally the command name, like in the case of `HELLOWORLD.RAND`. This way it is less likely to have collisions. Note that if different modules have colliding commands, they'll not be able to work in Redis at the same time, since the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/_index.md | master | redis | [
-0.0928284227848053,
-0.042633604258298874,
-0.1010688990354538,
0.03070845454931259,
0.03382544964551926,
-0.0780840516090393,
0.02749108150601387,
0.034405168145895004,
-0.022351285442709923,
-0.05878088250756264,
-0.0033916013780981302,
0.037549376487731934,
-0.0005523791187442839,
-0.0... | 0.231785 |
name of the module followed by a dot, and finally the command name, like in the case of `HELLOWORLD.RAND`. This way it is less likely to have collisions. Note that if different modules have colliding commands, they'll not be able to work in Redis at the same time, since the function `RedisModule\_CreateCommand` will fail in one of the modules, so the module loading will abort returning an error condition. ## Module initialization The above example shows the usage of the function `RedisModule\_Init()`. It should be the first function called by the module `OnLoad` function. The following is the function prototype: int RedisModule\_Init(RedisModuleCtx \*ctx, const char \*modulename, int module\_version, int api\_version); The `Init` function announces the Redis core that the module has a given name, its version (that is reported by `MODULE LIST`), and that is willing to use a specific version of the API. If the API version is wrong, the name is already taken, or there are other similar errors, the function will return `REDISMODULE\_ERR`, and the module `OnLoad` function should return ASAP with an error. Before the `Init` function is called, no other API function can be called, otherwise the module will segfault and the Redis instance will crash. The second function called, `RedisModule\_CreateCommand`, is used in order to register commands into the Redis core. The following is the prototype: int RedisModule\_CreateCommand(RedisModuleCtx \*ctx, const char \*name, RedisModuleCmdFunc cmdfunc, const char \*strflags, int firstkey, int lastkey, int keystep); As you can see, most Redis modules API calls all take as first argument the `context` of the module, so that they have a reference to the module calling it, to the command and client executing a given command, and so forth. To create a new command, the above function needs the context, the command's name, a pointer to the function implementing the command, the command's flags and the positions of key names in the command's arguments. The function that implements the command must have the following prototype: int mycommand(RedisModuleCtx \*ctx, RedisModuleString \*\*argv, int argc); The command function arguments are just the context, that will be passed to all the other API calls, the command argument vector, and total number of arguments, as passed by the user. As you can see, the arguments are provided as pointers to a specific data type, the `RedisModuleString`. This is an opaque data type you have API functions to access and use, direct access to its fields is never needed. Zooming into the example command implementation, we can find another call: int RedisModule\_ReplyWithLongLong(RedisModuleCtx \*ctx, long long integer); This function returns an integer to the client that invoked the command, exactly like other Redis commands do, like for example `INCR` or `SCARD`. ## Module cleanup In most cases, there is no need for special cleanup. When a module is unloaded, Redis will automatically unregister commands and unsubscribe from notifications. However in the case where a module contains some persistent memory or configuration, a module may include an optional `RedisModule\_OnUnload` function. If a module provides this function, it will be invoked during the module unload process. The following is the function prototype: int RedisModule\_OnUnload(RedisModuleCtx \*ctx); The `OnUnload` function may prevent module unloading by returning `REDISMODULE\_ERR`. Otherwise, `REDISMODULE\_OK` should be returned. ## Setup and dependencies of a Redis module Redis modules don't depend on Redis or some other library, nor they need to be compiled with a specific `redismodule.h` file. In order to create a new module, just copy a recent version of `redismodule.h` in your source tree, link all the libraries you want, and create a dynamic library having the `RedisModule\_OnLoad()` function symbol exported. The module will | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/_index.md | master | redis | [
-0.09090466797351837,
-0.04908423498272896,
-0.11082995682954788,
0.019875532016158104,
0.037132084369659424,
-0.13732413947582245,
0.05730465427041054,
0.009135037660598755,
-0.019503289833664894,
-0.07155273854732513,
0.021980829536914825,
0.01458335667848587,
0.07295633852481842,
-0.059... | 0.155025 |
library, nor they need to be compiled with a specific `redismodule.h` file. In order to create a new module, just copy a recent version of `redismodule.h` in your source tree, link all the libraries you want, and create a dynamic library having the `RedisModule\_OnLoad()` function symbol exported. The module will be able to load into different versions of Redis. A module can be designed to support both newer and older Redis versions where certain API functions are not available in all versions. If an API function is not implemented in the currently running Redis version, the function pointer is set to NULL. This allows the module to check if a function exists before using it: if (RedisModule\_SetCommandInfo != NULL) { RedisModule\_SetCommandInfo(cmd, &info); } In recent versions of `redismodule.h`, a convenience macro `RMAPI\_FUNC\_SUPPORTED(funcname)` is defined. Using the macro or just comparing with NULL is a matter of personal preference. # Passing configuration parameters to Redis modules When the module is loaded with the `MODULE LOAD` command, or using the `loadmodule` directive in the `redis.conf` file, the user is able to pass configuration parameters to the module by adding arguments after the module file name: loadmodule mymodule.so foo bar 1234 In the above example the strings `foo`, `bar` and `1234` will be passed to the module `OnLoad()` function in the `argv` argument as an array of RedisModuleString pointers. The number of arguments passed is into `argc`. The way you can access those strings will be explained in the rest of this document. Normally the module will store the module configuration parameters in some `static` global variable that can be accessed module wide, so that the configuration can change the behavior of different commands. ## Working with RedisModuleString objects The command argument vector `argv` passed to module commands, and the return value of other module APIs functions, are of type `RedisModuleString`. Usually you directly pass module strings to other API calls, however sometimes you may need to directly access the string object. There are a few functions in order to work with string objects: const char \*RedisModule\_StringPtrLen(RedisModuleString \*string, size\_t \*len); The above function accesses a string by returning its pointer and setting its length in `len`. You should never write to a string object pointer, as you can see from the `const` pointer qualifier. However, if you want, you can create new string objects using the following API: RedisModuleString \*RedisModule\_CreateString(RedisModuleCtx \*ctx, const char \*ptr, size\_t len); The string returned by the above command must be freed using a corresponding call to `RedisModule\_FreeString()`: void RedisModule\_FreeString(RedisModuleString \*str); However if you want to avoid having to free strings, the automatic memory management, covered later in this document, can be a good alternative, by doing it for you. Note that the strings provided via the argument vector `argv` never need to be freed. You only need to free new strings you create, or new strings returned by other APIs, where it is specified that the returned string must be freed. ## Creating strings from numbers or parsing strings as numbers Creating a new string from an integer is a very common operation, so there is a function to do this: RedisModuleString \*mystr = RedisModule\_CreateStringFromLongLong(ctx,10); Similarly in order to parse a string as a number: long long myval; if (RedisModule\_StringToLongLong(ctx,argv[1],&myval) == REDISMODULE\_OK) { /\* Do something with 'myval' \*/ } ## Accessing Redis keys from modules Most Redis modules, in order to be useful, have to interact with the Redis data space (this is not always true, for example an ID generator may never touch Redis keys). Redis modules have two different APIs in order to access the | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/_index.md | master | redis | [
-0.020976442843675613,
-0.04790358617901802,
-0.14382125437259674,
-0.0030604396015405655,
0.022558346390724182,
-0.05652804672718048,
-0.0012623267248272896,
0.042157139629125595,
-0.02356063760817051,
-0.09073712676763535,
0.00012363291170913726,
-0.024149904027581215,
0.0092216981574893,
... | 0.089411 |
\*/ } ## Accessing Redis keys from modules Most Redis modules, in order to be useful, have to interact with the Redis data space (this is not always true, for example an ID generator may never touch Redis keys). Redis modules have two different APIs in order to access the Redis data space, one is a low level API that provides very fast access and a set of functions to manipulate Redis data structures. The other API is more high level, and allows to call Redis commands and fetch the result, similarly to how Lua scripts access Redis. The high level API is also useful in order to access Redis functionalities that are not available as APIs. In general modules developers should prefer the low level API, because commands implemented using the low level API run at a speed comparable to the speed of native Redis commands. However there are definitely use cases for the higher level API. For example often the bottleneck could be processing the data and not accessing it. Also note that sometimes using the low level API is not harder compared to the higher level one. ## Calling Redis commands The high level API to access Redis is the sum of the `RedisModule\_Call()` function, together with the functions needed in order to access the reply object returned by `Call()`. `RedisModule\_Call` uses a special calling convention, with a format specifier that is used to specify what kind of objects you are passing as arguments to the function. Redis commands are invoked just using a command name and a list of arguments. However when calling commands, the arguments may originate from different kind of strings: null-terminated C strings, RedisModuleString objects as received from the `argv` parameter in the command implementation, binary safe C buffers with a pointer and a length, and so forth. For example if I want to call `INCRBY` using a first argument (the key) a string received in the argument vector `argv`, which is an array of RedisModuleString object pointers, and a C string representing the number "10" as second argument (the increment), I'll use the following function call: RedisModuleCallReply \*reply; reply = RedisModule\_Call(ctx,"INCRBY","sc",argv[1],"10"); The first argument is the context, and the second is always a null terminated C string with the command name. The third argument is the format specifier where each character corresponds to the type of the arguments that will follow. In the above case `"sc"` means a RedisModuleString object, and a null terminated C string. The other arguments are just the two arguments as specified. In fact `argv[1]` is a RedisModuleString and `"10"` is a null terminated C string. This is the full list of format specifiers: \* \*\*c\*\* -- Null terminated C string pointer. \* \*\*b\*\* -- C buffer, two arguments needed: C string pointer and `size\_t` length. \* \*\*s\*\* -- RedisModuleString as received in `argv` or by other Redis module APIs returning a RedisModuleString object. \* \*\*l\*\* -- Long long integer. \* \*\*v\*\* -- Array of RedisModuleString objects. \* \*\*!\*\* -- This modifier just tells the function to replicate the command to replicas and AOF. It is ignored from the point of view of arguments parsing. \* \*\*A\*\* -- This modifier, when `!` is given, tells to suppress AOF propagation: the command will be propagated only to replicas. \* \*\*R\*\* -- This modifier, when `!` is given, tells to suppress replicas propagation: the command will be propagated only to the AOF if enabled. The function returns a `RedisModuleCallReply` object on success, on error NULL is returned. NULL is returned when the command name is invalid, the format specifier uses | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/_index.md | master | redis | [
-0.107613705098629,
-0.04589592665433884,
-0.0643669068813324,
0.007323624100536108,
0.013685262762010098,
-0.12275972962379456,
0.015442407689988613,
0.08048021793365479,
0.04740913584828377,
-0.05298205837607384,
0.02430545724928379,
0.042873721569776535,
0.032332196831703186,
-0.0528684... | 0.200596 |
\*\*R\*\* -- This modifier, when `!` is given, tells to suppress replicas propagation: the command will be propagated only to the AOF if enabled. The function returns a `RedisModuleCallReply` object on success, on error NULL is returned. NULL is returned when the command name is invalid, the format specifier uses characters that are not recognized, or when the command is called with the wrong number of arguments. In the above cases the `errno` var is set to `EINVAL`. NULL is also returned when, in an instance with Cluster enabled, the target keys are about non local hash slots. In this case `errno` is set to `EPERM`. ## Working with RedisModuleCallReply objects. `RedisModuleCall` returns reply objects that can be accessed using the `RedisModule\_CallReply\*` family of functions. In order to obtain the type or reply (corresponding to one of the data types supported by the Redis protocol), the function `RedisModule\_CallReplyType()` is used: reply = RedisModule\_Call(ctx,"INCRBY","sc",argv[1],"10"); if (RedisModule\_CallReplyType(reply) == REDISMODULE\_REPLY\_INTEGER) { long long myval = RedisModule\_CallReplyInteger(reply); /\* Do something with myval. \*/ } Valid reply types are: \* `REDISMODULE\_REPLY\_STRING` Bulk string or status replies. \* `REDISMODULE\_REPLY\_ERROR` Errors. \* `REDISMODULE\_REPLY\_INTEGER` Signed 64 bit integers. \* `REDISMODULE\_REPLY\_ARRAY` Array of replies. \* `REDISMODULE\_REPLY\_NULL` NULL reply. Strings, errors and arrays have an associated length. For strings and errors the length corresponds to the length of the string. For arrays the length is the number of elements. To obtain the reply length the following function is used: size\_t reply\_len = RedisModule\_CallReplyLength(reply); In order to obtain the value of an integer reply, the following function is used, as already shown in the example above: long long reply\_integer\_val = RedisModule\_CallReplyInteger(reply); Called with a reply object of the wrong type, the above function always returns `LLONG\_MIN`. Sub elements of array replies are accessed this way: RedisModuleCallReply \*subreply; subreply = RedisModule\_CallReplyArrayElement(reply,idx); The above function returns NULL if you try to access out of range elements. Strings and errors (which are like strings but with a different type) can be accessed using in the following way, making sure to never write to the resulting pointer (that is returned as a `const` pointer so that misusing must be pretty explicit): size\_t len; char \*ptr = RedisModule\_CallReplyStringPtr(reply,&len); If the reply type is not a string or an error, NULL is returned. RedisCallReply objects are not the same as module string objects (RedisModuleString types). However sometimes you may need to pass replies of type string or integer, to API functions expecting a module string. When this is the case, you may want to evaluate if using the low level API could be a simpler way to implement your command, or you can use the following function in order to create a new string object from a call reply of type string, error or integer: RedisModuleString \*mystr = RedisModule\_CreateStringFromCallReply(myreply); If the reply is not of the right type, NULL is returned. The returned string object should be released with `RedisModule\_FreeString()` as usually, or by enabling automatic memory management (see corresponding section). ## Releasing call reply objects Reply objects must be freed using `RedisModule\_FreeCallReply`. For arrays, you need to free only the top level reply, not the nested replies. Currently the module implementation provides a protection in order to avoid crashing if you free a nested reply object for error, however this feature is not guaranteed to be here forever, so should not be considered part of the API. If you use automatic memory management (explained later in this document) you don't need to free replies (but you still could if you wish to release memory ASAP). ## Returning values from Redis commands Like normal Redis commands, new | https://github.com/redis/redis-doc/blob/master//docs/reference/modules/_index.md | master | redis | [
-0.030292462557554245,
-0.040399741381406784,
-0.09645705670118332,
0.06061948090791702,
0.005380000453442335,
-0.07532567530870438,
0.056479763239622116,
0.016624199226498604,
0.026910515502095222,
-0.015709271654486656,
0.04464053362607956,
-0.04322238266468048,
0.0313723124563694,
-0.03... | 0.20143 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.