From bbd1b4c4a66fa2a87023ffb8b2f38fb02da8adf4 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 10:26:04 +0100 Subject: [PATCH 1/9] DOC-3967 moved/expanded keyspace page --- content/develop/{use => }/keyspace.md | 81 ++++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 9 deletions(-) rename content/develop/{use => }/keyspace.md (64%) diff --git a/content/develop/use/keyspace.md b/content/develop/keyspace.md similarity index 64% rename from content/develop/use/keyspace.md rename to content/develop/keyspace.md index 9b691f229d..ee955bbce3 100644 --- a/content/develop/use/keyspace.md +++ b/content/develop/keyspace.md @@ -13,18 +13,37 @@ description: 'Managing keys in Redis: Key expiration, scanning, altering and que the key space ' -linkTitle: Keyspace -title: Keyspace -weight: 1 +linkTitle: Keys and values +title: Keys and values +weight: 33 +aliases: /develop/use/keyspace --- -Redis keys are binary safe; this means that you can use any binary sequence as a -key, from a string like "foo" to the content of a JPEG file. -The empty string is also a valid key. +Every data object that you store in a Redis database has its own unique +*key*. The key is a string that you pass to Redis commands to +retrieve the corresponding object or modify its data. The data object associated with a +particular key is known as the *value* and the two together are known as +as *key-value pair*. -A few other rules about keys: +## Content of keys -* Very long keys are not a good idea. For instance a key of 1024 bytes is a bad +A key is typically a textual name that has some meaning within your +data model. Unlike variable names in a programming language, Redis keys have few +restrictions on their format, so keys with whitespace or punctuation characters +are mostly fine (for example, "1st Attempt", or "% of price in $"). Redis doesn't +support namespaces or other categories for keys, so you must take care to avoid +name collisions. However, there is a convention for using the colon ":" +character to split keys into sections (for example, "person:1", "person:2", +"office:London", "office:NewYork:1"). You can use this as a simple way to collect +keys together into categories. + +Although keys are usually textual, Redis actually implements *binary-safe* keys, +so you can use any sequence of bytes as a valid key, such as a JPEG file or +a struct value from your app. The empty string is also a valid key in Redis. + +There are also a few other things to bear in mind about keys: + +* Very long keys are not a good idea. For instance, a key of 1024 bytes is a bad idea not only memory-wise, but also because the lookup of the key in the dataset may require several costly key-comparisons. Even when the task at hand is to match the existence of a large value, hashing it (for example @@ -40,6 +59,49 @@ A few other rules about keys: fields, as in "comment:4321:reply.to" or "comment:4321:reply-to". * The maximum allowed key size is 512 MB. +### Hashtags + +Redis uses [hashing](https://en.wikipedia.org/wiki/Hash_table) to retrieve the +value associated with a key in a highly efficient way. Hashing involves combining the +raw byte values from the key to produce an integer *index* number. The index is then +used to locate the *hash slot* where the value for the key is stored. + +Normally, the whole key is used to calculate the hash index, but there are some +situations where you need to hash only a part of the key. You can select the +section of the key you want to hash using a pair of curly braces `{...}` to create +a *hashtag*. For example, the keys `person:1` and `person:2` produce different +hash indices but `{person}:1` and `{person}:2` produce the same index because +only the `person` hashtag section in the braces is used for the hash calculation. + +A common use of hashtags is to allow +[multi-key operations]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}) +with a *clustered* database (see +[Database clustering]({{< relref "/operate/rs/databases/durability-ha/clustering#multikey-operations" >}}) +for more information). Redis doesn't allow most multi-key operations in a clustered database +unless all the keys produce the same hash index. For example, the +[SINTER]({{< relref "/commands/sinter" >}}) +command finds the [intersection](https://en.wikipedia.org/wiki/Intersection_(set_theory)) +of two different [set]({{< relref "/develop/data-types/sets" >}}) values. +This means that the command + +```bash +SINTER group:1 group:2 +``` + +won't work with a clustered database but + +```bash +SINTER {group}:1 {group}:2 +``` + +will work because the hashtag ensures the two keys produce the same hash index. + +Note that although hashtags are useful in certain cases, you shouldn't make +a habit of using them generally. If you have too many keys mapped to the same +hash slot then this will eventually harm the performance of your database. +See [Database clustering]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}) +for more information about how to use hashtags. + ## Altering and querying the key space There are commands that are not defined on particular types, but are useful @@ -120,6 +182,7 @@ the [`PTTL`]({{< relref "/commands/pttl" >}}) commands, and the full list of [`S ## Navigating the keyspace ### Scan + To incrementally iterate over the keys in a Redis database in an efficient manner, you can use the [`SCAN`]({{< relref "/commands/scan" >}}) command. Since [`SCAN`]({{< relref "/commands/scan" >}}) allows for incremental iteration, returning only a small number of elements per call, it can be used in production without the downside of commands like [`KEYS`]({{< relref "/commands/keys" >}}) or [`SMEMBERS`]({{< relref "/commands/smembers" >}}) that may block the server for a long time (even several seconds) when called against big collections of keys or elements. @@ -139,7 +202,7 @@ This command is intended for debugging and special operations, such as changing your keyspace layout. Don't use [`KEYS`]({{< relref "/commands/keys" >}}) in your regular application code. If you're looking for a way to find keys in a subset of your keyspace, consider -using [`SCAN`]({{< relref "/commands/scan" >}}) or [sets][tdts]. +using [`SCAN`]({{< relref "/commands/scan" >}}) or [sets][{{< relref "/develop/data-types/sets" >}}]. [tdts]: /develop/data-types#sets From 46d364ff40412be78bf8c8c9f3a325bed74a7283 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 10:43:21 +0100 Subject: [PATCH 2/9] DOC-3967 fixed links to keyspace page --- content/commands/scan.md | 2 +- .../best-practices/index-mgmt-best-practices.md | 2 +- content/develop/data-types/_index.md | 4 ++-- content/develop/data-types/hashes.md | 2 +- content/develop/get-started/data-store.md | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/content/commands/scan.md b/content/commands/scan.md index 335d525244..2228bceffa 100644 --- a/content/commands/scan.md +++ b/content/commands/scan.md @@ -286,7 +286,7 @@ Also note that this behavior is specific of [`SSCAN`]({{< relref "/commands/ssca ## Further reading -For more information about managing keys, please refer to the [The Redis Keyspace]({{< relref "/develop/use/keyspace" >}}) tutorial. +For more information about managing keys, please refer to the [The Redis Keyspace]({{< relref "/develop/keyspace" >}}) tutorial. ## Additional examples diff --git a/content/develop/ai/search-and-query/best-practices/index-mgmt-best-practices.md b/content/develop/ai/search-and-query/best-practices/index-mgmt-best-practices.md index 4280aa4a26..4233dae684 100644 --- a/content/develop/ai/search-and-query/best-practices/index-mgmt-best-practices.md +++ b/content/develop/ai/search-and-query/best-practices/index-mgmt-best-practices.md @@ -150,7 +150,7 @@ Monitoring and troubleshooting aliases: ## Index maintenance - If schema changes are required, create a new index with the updated schema and reassign the alias once the index is ready. -- Use [Redis key expiration]({{< relref "/develop/use/keyspace#key-expiration" >}}) to automatically remove outdated records and keep indexes lean. +- Use [Redis key expiration]({{< relref "/develop/keyspace#key-expiration" >}}) to automatically remove outdated records and keep indexes lean. ### FT.ALTER vs. aliasing diff --git a/content/develop/data-types/_index.md b/content/develop/data-types/_index.md index 16e9f7fc65..b305d096bd 100644 --- a/content/develop/data-types/_index.md +++ b/content/develop/data-types/_index.md @@ -10,8 +10,8 @@ categories: - kubernetes - clients description: Overview of data types supported by Redis -linkTitle: Understand data types -title: Understand Redis data types +linkTitle: Data types +title: Redis data types hideListLinks: true weight: 35 --- diff --git a/content/develop/data-types/hashes.md b/content/develop/data-types/hashes.md index d75695a220..ea6fec41e0 100644 --- a/content/develop/data-types/hashes.md +++ b/content/develop/data-types/hashes.md @@ -101,7 +101,7 @@ See the [complete list of hash commands]({{< relref "/commands/" >}}?group=hash) ## Field expiration New in Redis Open Source 7.4 is the ability to specify an expiration time or a time-to-live (TTL) value for individual hash fields. -This capability is comparable to [key expiration]({{< relref "/develop/use/keyspace#key-expiration" >}}) and includes a number of similar commands. +This capability is comparable to [key expiration]({{< relref "/develop/keyspace#key-expiration" >}}) and includes a number of similar commands. Use the following commands to set either an exact expiration time or a TTL value for specific fields: diff --git a/content/develop/get-started/data-store.md b/content/develop/get-started/data-store.md index 6b558122bc..8505d9e876 100644 --- a/content/develop/get-started/data-store.md +++ b/content/develop/get-started/data-store.md @@ -82,7 +82,7 @@ You can get a complete overview of available data types in this documentation si ## Scan the keyspace -Each item within Redis has a unique key. All items live within the Redis [keyspace]({{< relref "/develop/use/keyspace" >}}). You can scan the Redis keyspace via the [SCAN command]({{< relref "/commands/scan" >}}). Here is an example that scans for the first 100 keys that have the prefix `bike:`: +Each item within Redis has a unique key. All items live within the Redis [keyspace]({{< relref "/develop/keyspace" >}}). You can scan the Redis keyspace via the [SCAN command]({{< relref "/commands/scan" >}}). Here is an example that scans for the first 100 keys that have the prefix `bike:`: ``` SCAN 0 MATCH "bike:*" COUNT 100 From 6ab6b8e9b904355da4e7bec2b9de4c8fd3a2fe6f Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 11:26:22 +0100 Subject: [PATCH 3/9] DOC-3967 moved transaction and pipeline pages to reference section --- content/commands/command.md | 2 +- content/develop/clients/dotnet/condexec.md | 2 +- content/develop/clients/dotnet/transpipe.md | 6 +++--- content/develop/clients/go/transpipe.md | 6 +++--- content/develop/clients/hiredis/transpipe.md | 6 +++--- content/develop/clients/jedis/transpipe.md | 6 +++--- content/develop/clients/nodejs/transpipe.md | 6 +++--- content/develop/clients/pools-and-muxing.md | 2 +- content/develop/clients/redis-py/transpipe.md | 6 +++--- content/develop/get-started/vector-database.md | 2 +- .../develop/interact/programmability/_index.md | 2 +- .../interact/programmability/eval-intro.md | 6 +++--- .../interact/programmability/functions-intro.md | 4 ++-- .../index.md => reference/pipelining.md} | 2 +- content/develop/reference/protocol-spec.md | 2 +- .../{interact => reference}/transactions.md | 1 + .../develop/use/pipelining/pipeline_iops.png | Bin 20207 -> 0 bytes content/embeds/r7.2-breaking-changes.md | 2 +- .../embeds/r7.2-combined-breaking-changes.md | 2 +- .../rc/databases/configuration/sizing.md | 2 +- static/images/dev/reference/pipeline_iops.webp | Bin 0 -> 3144 bytes 21 files changed, 34 insertions(+), 33 deletions(-) rename content/develop/{use/pipelining/index.md => reference/pipelining.md} (98%) rename content/develop/{interact => reference}/transactions.md (99%) delete mode 100644 content/develop/use/pipelining/pipeline_iops.png create mode 100644 static/images/dev/reference/pipeline_iops.webp diff --git a/content/commands/command.md b/content/commands/command.md index c305658283..621bbb6207 100644 --- a/content/commands/command.md +++ b/content/commands/command.md @@ -101,7 +101,7 @@ Command flags are an array. It can contain the following simple strings (status * **no_auth:** executing the command doesn't require authentication. * **no_async_loading:** the command is denied during asynchronous loading (that is when a replica uses disk-less `SWAPDB SYNC`, and allows access to the old dataset). * **no_mandatory_keys:** the command may accept key name arguments, but these aren't mandatory. -* **no_multi:** the command isn't allowed inside the context of a [transaction]({{< relref "/develop/interact/transactions" >}}). +* **no_multi:** the command isn't allowed inside the context of a [transaction]({{< relref "/develop/reference/transactions" >}}). * **noscript:** the command can't be called from [scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) or [functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). * **pubsub:** the command is related to [Redis Pub/Sub]({{< relref "/develop/interact/pubsub" >}}). * **random**: the command returns random results, which is a concern with verbatim script replication. diff --git a/content/develop/clients/dotnet/condexec.md b/content/develop/clients/dotnet/condexec.md index f08d602bf5..2c53a84855 100644 --- a/content/develop/clients/dotnet/condexec.md +++ b/content/develop/clients/dotnet/condexec.md @@ -17,7 +17,7 @@ weight: 60 Most Redis client libraries use transactions with the [`WATCH`]({{< relref "/commands/watch" >}}) command as the main way to prevent -two clients writing to the same key at once (see [Transactions]({{< relref "/develop/interact/transactions" >}}) for more information). Unfortunately, this approach is +two clients writing to the same key at once (see [Transactions]({{< relref "/develop/reference/transactions" >}}) for more information). Unfortunately, this approach is difficult to use explicitly in `NRedisStack`. Its [multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}}) system is highly efficient and convenient but can also cause bad interactions diff --git a/content/develop/clients/dotnet/transpipe.md b/content/develop/clients/dotnet/transpipe.md index bfb44e4421..4e4f1c2a16 100644 --- a/content/develop/clients/dotnet/transpipe.md +++ b/content/develop/clients/dotnet/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -57,7 +57,7 @@ to different keys. The basic idea is to watch for changes to any keys that you use in a transaction while you are are processing the updates. If the watched keys do change, you must restart the updates with the latest data from the keys. See -[Transactions]({{< relref "/develop/interact/transactions" >}}) +[Transactions]({{< relref "/develop/reference/transactions" >}}) for more information about optimistic locking. The approach to optimistic locking that other clients use diff --git a/content/develop/clients/go/transpipe.md b/content/develop/clients/go/transpipe.md index f22e401501..73d45bb4bf 100644 --- a/content/develop/clients/go/transpipe.md +++ b/content/develop/clients/go/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -77,7 +77,7 @@ to different keys. The basic idea is to watch for changes to any keys that you use in a transaction while you are are processing the updates. If the watched keys do change, you must restart the updates with the latest data from the keys. See -[Transactions]({{< relref "/develop/interact/transactions" >}}) +[Transactions]({{< relref "/develop/reference/transactions" >}}) for more information about optimistic locking. The code below reads a string diff --git a/content/develop/clients/hiredis/transpipe.md b/content/develop/clients/hiredis/transpipe.md index b50b417ce9..da15826faa 100644 --- a/content/develop/clients/hiredis/transpipe.md +++ b/content/develop/clients/hiredis/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -109,5 +109,5 @@ when you have finished processing it, as in the example above. you can implement them yourself using the [`MULTI`]({{< relref "/commands/multi" >}}), [`EXEC`]({{< relref "/commands/exec" >}}), and [`WATCH`]({{< relref "/commands/watch" >}}) commands as you would from [`redis-cli`]({{< relref "/develop/tools/cli" >}}). -See [Transactions]({{< relref "/develop/interact/transactions" >}}) +See [Transactions]({{< relref "/develop/reference/transactions" >}}) for more information. diff --git a/content/develop/clients/jedis/transpipe.md b/content/develop/clients/jedis/transpipe.md index d26b595f92..38bd481f37 100644 --- a/content/develop/clients/jedis/transpipe.md +++ b/content/develop/clients/jedis/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -68,7 +68,7 @@ to different keys. The basic idea is to watch for changes to any keys that you use in a transaction while you are are processing the updates. If the watched keys do change, you must restart the updates with the latest data from the keys. See -[Transactions]({{< relref "/develop/interact/transactions" >}}) +[Transactions]({{< relref "/develop/reference/transactions" >}}) for more information about optimistic locking. The code below reads a string diff --git a/content/develop/clients/nodejs/transpipe.md b/content/develop/clients/nodejs/transpipe.md index b396ddca98..43d8bcfdcf 100644 --- a/content/develop/clients/nodejs/transpipe.md +++ b/content/develop/clients/nodejs/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -112,7 +112,7 @@ to different keys. The basic idea is to watch for changes to any keys that you use in a transaction while you are are processing the updates. If the watched keys do change, you must restart the updates with the latest data from the keys. See -[Transactions]({{< relref "/develop/interact/transactions" >}}) +[Transactions]({{< relref "/develop/reference/transactions" >}}) for more information about optimistic locking. The code below reads a string diff --git a/content/develop/clients/pools-and-muxing.md b/content/develop/clients/pools-and-muxing.md index b172abccf2..a16435005e 100644 --- a/content/develop/clients/pools-and-muxing.md +++ b/content/develop/clients/pools-and-muxing.md @@ -71,7 +71,7 @@ used to identify where to send the response data from your commands. Note that it is not a problem if the multiplexer receives several commands close together in time. When this happens, the multiplexer can often combine the commands into a -[pipeline]({{< relref "/develop/use/pipelining" >}}), which +[pipeline]({{< relref "/develop/reference/pipelining" >}}), which improves efficiency. Multiplexing offers high efficiency but works transparently without requiring diff --git a/content/develop/clients/redis-py/transpipe.md b/content/develop/clients/redis-py/transpipe.md index ebd9a87a28..a03500c3d5 100644 --- a/content/develop/clients/redis-py/transpipe.md +++ b/content/develop/clients/redis-py/transpipe.md @@ -21,11 +21,11 @@ There are two types of batch that you can use: - **Pipelines** avoid network and processing overhead by sending several commands to the server together in a single communication. The server then sends back a single communication with all the responses. See the - [Pipelining]({{< relref "/develop/use/pipelining" >}}) page for more + [Pipelining]({{< relref "/develop/reference/pipelining" >}}) page for more information. - **Transactions** guarantee that all the included commands will execute to completion without being interrupted by commands from other clients. - See the [Transactions]({{< relref "/develop/interact/transactions" >}}) + See the [Transactions]({{< relref "/develop/reference/transactions" >}}) page for more information. ## Execute a pipeline @@ -62,7 +62,7 @@ to different keys. The basic idea is to watch for changes to any keys that you use in a transaction while you are processing the updates. If the watched keys do change, you must restart the updates with the latest data from the keys. See -[Transactions]({{< relref "/develop/interact/transactions" >}}) +[Transactions]({{< relref "/develop/reference/transactions" >}}) for more information about optimistic locking. The example below shows how to repeatedly attempt a transaction with a watched diff --git a/content/develop/get-started/vector-database.md b/content/develop/get-started/vector-database.md index 10d87c1ede..ceecfbb3df 100644 --- a/content/develop/get-started/vector-database.md +++ b/content/develop/get-started/vector-database.md @@ -120,7 +120,7 @@ Inspect the structure of one of the bike JSON documents: {{< clients-example search_vss dump_data />}} ### 2. Store the demo data in Redis -Now iterate over the `bikes` array to store the data as [JSON]({{< relref "/develop/data-types/json/" >}}) documents in Redis by using the [JSON.SET]({{< relref "commands/json.set/" >}}) command. The below code uses a [pipeline]({{< relref "/develop/use/pipelining" >}}) to minimize the network round-trip times: +Now iterate over the `bikes` array to store the data as [JSON]({{< relref "/develop/data-types/json/" >}}) documents in Redis by using the [JSON.SET]({{< relref "commands/json.set/" >}}) command. The below code uses a [pipeline]({{< relref "/develop/reference/pipelining" >}}) to minimize the network round-trip times: {{< clients-example search_vss load_data />}} diff --git a/content/develop/interact/programmability/_index.md b/content/develop/interact/programmability/_index.md index a302f92943..39eff44c42 100644 --- a/content/develop/interact/programmability/_index.md +++ b/content/develop/interact/programmability/_index.md @@ -60,7 +60,7 @@ Please refer to the following pages for more information: * [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) When running a script or a function, Redis guarantees its atomic execution. -The script's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/interact/transactions" >}}). +The script's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/reference/transactions" >}}). These semantics mean that all of the script's effects either have yet to happen or had already happened. The blocking semantics of an executed script apply to all connected clients at all times. diff --git a/content/develop/interact/programmability/eval-intro.md b/content/develop/interact/programmability/eval-intro.md index 7679101055..8ac052bc31 100644 --- a/content/develop/interact/programmability/eval-intro.md +++ b/content/develop/interact/programmability/eval-intro.md @@ -190,7 +190,7 @@ Please consult your client's documentation regarding the specific details. ### `EVALSHA` in the context of pipelining -Special care should be given executing [`EVALSHA`]({{< relref "/commands/evalsha" >}}) in the context of a [pipelined request]({{< relref "/develop/use/pipelining" >}}). +Special care should be given executing [`EVALSHA`]({{< relref "/commands/evalsha" >}}) in the context of a [pipelined request]({{< relref "/develop/reference/pipelining" >}}). The commands in a pipelined request run in the order they are sent, but other clients' commands may be interleaved for execution between these. Because of that, the `NOSCRIPT` error can return from a pipelined request but can't be handled. @@ -228,7 +228,7 @@ These are: _1_ means the specific SHA1 is recognized as a script already present in the scripting cache. _0_'s meaning is that a script with this SHA1 wasn't loaded before (or at least never since the latest call to [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}})). * `SCRIPT LOAD script`: this command registers the specified script in the Redis script cache. - It is a useful command in all the contexts where we want to ensure that [`EVALSHA`]({{< relref "/commands/evalsha" >}}) doesn't not fail (for instance, in a pipeline or when called from a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/interact/transactions" >}}), without the need to execute the script. + It is a useful command in all the contexts where we want to ensure that [`EVALSHA`]({{< relref "/commands/evalsha" >}}) doesn't not fail (for instance, in a pipeline or when called from a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/reference/transactions" >}}), without the need to execute the script. * [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}): this command is the only way to interrupt a long-running script (a.k.a slow script), short of shutting down the server. A script is deemed as slow once its execution's duration exceeds the configured [maximum execution time]({{< relref "/develop/interact/programmability/#maximum-execution-time" >}}) threshold. @@ -270,7 +270,7 @@ We call this **script effects replication**. starting with Redis 5.0, script effects replication is the default mode and does not need to be explicitly enabled. In this replication mode, while Lua scripts are executed, Redis collects all the commands executed by the Lua scripting engine that actually modify the dataset. -When the script execution finishes, the sequence of commands that the script generated are wrapped into a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/interact/transactions" >}}) and are sent to the replicas and AOF. +When the script execution finishes, the sequence of commands that the script generated are wrapped into a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/reference/transactions" >}}) and are sent to the replicas and AOF. This is useful in several ways depending on the use case: diff --git a/content/develop/interact/programmability/functions-intro.md b/content/develop/interact/programmability/functions-intro.md index ed96b9eadd..71291711b3 100644 --- a/content/develop/interact/programmability/functions-intro.md +++ b/content/develop/interact/programmability/functions-intro.md @@ -36,7 +36,7 @@ The underlying assumption is that scripts are a part of the application and not This approach suits many light-weight scripting use cases, but introduces several difficulties once an application becomes complex and relies more heavily on scripting, namely: 1. All client application instances must maintain a copy of all scripts. That means having some mechanism that applies script updates to all of the application's instances. -1. Calling cached scripts within the context of a [transaction]({{< relref "/develop/interact/transactions" >}}) increases the probability of the transaction failing because of a missing script. Being more likely to fail makes using cached scripts as building blocks of workflows less attractive. +1. Calling cached scripts within the context of a [transaction]({{< relref "/develop/reference/transactions" >}}) increases the probability of the transaction failing because of a missing script. Being more likely to fail makes using cached scripts as building blocks of workflows less attractive. 1. SHA1 digests are meaningless, making debugging the system extremely hard (e.g., in a [`MONITOR`]({{< relref "/commands/monitor" >}}) session). 1. When used naively, [`EVAL`]({{< relref "/commands/eval" >}}) promotes an anti-pattern in which scripts the client application renders verbatim scripts instead of responsibly using the [`KEYS` and `ARGV` Lua APIs]({{< relref "develop/interact/programmability/lua-api#runtime-globals" >}}). 1. Because they are ephemeral, a script can't call another script. This makes sharing and reusing code between scripts nearly impossible, short of client-side preprocessing (see the first point). @@ -81,7 +81,7 @@ Functions are also persisted to the AOF file and replicated from master to repli When Redis is used as an ephemeral cache, additional mechanisms (described below) are required to make functions more durable. Like all other operations in Redis, the execution of a function is atomic. -A function's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/interact/transactions" >}}). +A function's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/reference/transactions" >}}). These semantics mean that all of the script's effects either have yet to happen or had already happened. The blocking semantics of an executed function apply to all connected clients at all times. Because running a function blocks the Redis server, functions are meant to finish executing quickly, so you should avoid using long-running functions. diff --git a/content/develop/use/pipelining/index.md b/content/develop/reference/pipelining.md similarity index 98% rename from content/develop/use/pipelining/index.md rename to content/develop/reference/pipelining.md index d4acef2bc5..ac73d4d957 100644 --- a/content/develop/use/pipelining/index.md +++ b/content/develop/reference/pipelining.md @@ -100,7 +100,7 @@ call. Consequently, the number of total queries performed per second initially increases almost linearly with longer pipelines, and eventually reaches 10 times the baseline obtained without pipelining, as shown in this figure. -![Pipeline size and IOPs](pipeline_iops.png) +{{< image filename="/images/dev/reference/pipeline_iops.webp" alt="Pipeline size and IOPs" >}} ## A real world code example diff --git a/content/develop/reference/protocol-spec.md b/content/develop/reference/protocol-spec.md index 6b854f21f4..9ec0774230 100644 --- a/content/develop/reference/protocol-spec.md +++ b/content/develop/reference/protocol-spec.md @@ -696,7 +696,7 @@ Pipelining is supported, so multiple commands can be sent with a single write op 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]({{< relref "/develop/use/pipelining" >}}). +For more information, see [Pipelining]({{< relref "/develop/reference/pipelining" >}}). ## Inline commands Sometimes you may need to send a command to the Redis server but only have `telnet` available. diff --git a/content/develop/interact/transactions.md b/content/develop/reference/transactions.md similarity index 99% rename from content/develop/interact/transactions.md rename to content/develop/reference/transactions.md index 4321ca0b7c..c0c9aff063 100644 --- a/content/develop/interact/transactions.md +++ b/content/develop/reference/transactions.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/transactions description: How transactions work in Redis linkTitle: Transactions title: Transactions diff --git a/content/develop/use/pipelining/pipeline_iops.png b/content/develop/use/pipelining/pipeline_iops.png deleted file mode 100644 index 858699ad0af6d0ed608d7d305970d75de67d1ebc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20207 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 diff --git a/content/embeds/r7.2-breaking-changes.md b/content/embeds/r7.2-breaking-changes.md index c2206103f6..223809f0bd 100644 --- a/content/embeds/r7.2-breaking-changes.md +++ b/content/embeds/r7.2-breaking-changes.md @@ -19,7 +19,7 @@ Upgrading to Redis version 7.2 from version 7.0 introduces the following potenti - Time sampling is now frozen during command execution and scripts ([#10300](https://github.com/redis/redis/pull/10300)). While a command or script is running, the keys used by the command or script will not expire. This breaks any script that uses a loop to wait for a key to expire. -- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/interact/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). +- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/reference/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). ##### Error handling diff --git a/content/embeds/r7.2-combined-breaking-changes.md b/content/embeds/r7.2-combined-breaking-changes.md index d5b634b70c..ff7f7d3bfe 100644 --- a/content/embeds/r7.2-combined-breaking-changes.md +++ b/content/embeds/r7.2-combined-breaking-changes.md @@ -28,7 +28,7 @@ Upgrading to open source Redis version 7.2 from version 6.2 introduces the follo - Time sampling is now frozen during command execution and scripts ([#10300](https://github.com/redis/redis/pull/10300)). While a command or script is running, the keys used by the command or script will not expire. This breaks any script that uses a loop to wait for a key to expire. -- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/interact/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). +- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/reference/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). ##### Error handling diff --git a/content/operate/rc/databases/configuration/sizing.md b/content/operate/rc/databases/configuration/sizing.md index f62ba578c4..03df0ccb9f 100644 --- a/content/operate/rc/databases/configuration/sizing.md +++ b/content/operate/rc/databases/configuration/sizing.md @@ -55,7 +55,7 @@ Here are some things to keep in mind for optimizing throughput: - Test and monitor your app's performance and adjust the set ops/sec based on how if performs in real-world conditions. - If your average request size is larger than 3KB, consider setting your throughput higher than expected. - Track the slow logs using the [`SLOWLOG` command]({{< relref "/commands/slowlog" >}}) or the **Slowlog** tab on the [database screen]({{< relref "/operate/rc/databases/view-edit-database" >}}). -- Use [pipelining]({{< relref "/develop/use/pipelining" >}}) and [concurrent connections]({{< relref "/develop/reference/clients" >}}) effectively to optimize throughput and latency. +- Use [pipelining]({{< relref "/develop/reference/pipelining" >}}) and [concurrent connections]({{< relref "/develop/reference/clients" >}}) effectively to optimize throughput and latency. - Search databases have their own throughput requirements. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more info. ### Frequently asked questions diff --git a/static/images/dev/reference/pipeline_iops.webp b/static/images/dev/reference/pipeline_iops.webp new file mode 100644 index 0000000000000000000000000000000000000000..efb789ac3d2572dfcc6b7fa21ebddd0ed90c17ca GIT binary patch literal 3144 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 Date: Tue, 1 Jul 2025 11:42:34 +0100 Subject: [PATCH 4/9] DOC-3967 moved patterns folder to clients --- content/commands/set.md | 2 +- content/commands/setnx.md | 2 +- content/develop/{use => clients}/patterns/_index.md | 6 +++--- .../{use => clients}/patterns/bulk-loading.md | 0 .../{use => clients}/patterns/distributed-locks.md | 0 .../{use => clients}/patterns/indexes/2idx_0.png | Bin .../{use => clients}/patterns/indexes/2idx_1.png | Bin .../{use => clients}/patterns/indexes/2idx_2.png | Bin .../{use => clients}/patterns/indexes/index.md | 0 .../{use => clients}/patterns/twitter-clone.md | 0 content/develop/tools/cli.md | 2 +- 11 files changed, 6 insertions(+), 6 deletions(-) rename content/develop/{use => clients}/patterns/_index.md (79%) rename content/develop/{use => clients}/patterns/bulk-loading.md (100%) rename content/develop/{use => clients}/patterns/distributed-locks.md (100%) rename content/develop/{use => clients}/patterns/indexes/2idx_0.png (100%) rename content/develop/{use => clients}/patterns/indexes/2idx_1.png (100%) rename content/develop/{use => clients}/patterns/indexes/2idx_2.png (100%) rename content/develop/{use => clients}/patterns/indexes/index.md (100%) rename content/develop/{use => clients}/patterns/twitter-clone.md (100%) diff --git a/content/commands/set.md b/content/commands/set.md index 1da2fe740b..74e0be5299 100644 --- a/content/commands/set.md +++ b/content/commands/set.md @@ -148,7 +148,7 @@ SET anotherkey "will expire in a minute" EX 60 ## Patterns -**Note:** The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/use/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant. +**Note:** The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/clients/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant. The command `SET resource-name anystring NX EX max-lock-time` is a simple way to implement a locking system with Redis. diff --git a/content/commands/setnx.md b/content/commands/setnx.md index 7bb9ce1e14..53f103b5b7 100644 --- a/content/commands/setnx.md +++ b/content/commands/setnx.md @@ -72,7 +72,7 @@ GET mykey **Please note that:** -1. The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/use/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant. +1. The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/clients/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant. 2. We document the old pattern anyway because certain existing implementations link to this page as a reference. Moreover it is an interesting example of how Redis commands can be used in order to mount programming primitives. 3. Anyway even assuming a single-instance locking primitive, starting with 2.6.12 it is possible to create a much simpler locking primitive, equivalent to the one discussed here, using the [`SET`]({{< relref "/commands/set" >}}) command to acquire the lock, and a simple Lua script to release the lock. The pattern is documented in the [`SET`]({{< relref "/commands/set" >}}) command page. diff --git a/content/develop/use/patterns/_index.md b/content/develop/clients/patterns/_index.md similarity index 79% rename from content/develop/use/patterns/_index.md rename to content/develop/clients/patterns/_index.md index 714a33b1c3..1471cad7e3 100644 --- a/content/develop/use/patterns/_index.md +++ b/content/develop/clients/patterns/_index.md @@ -10,9 +10,9 @@ categories: - kubernetes - clients description: Novel patterns for working with Redis data structures -linkTitle: Patterns -title: Redis programming patterns -weight: 6 +linkTitle: Coding patterns +title: Coding patterns +weight: 50 --- The following documents describe some novel development patterns you can use with Redis. diff --git a/content/develop/use/patterns/bulk-loading.md b/content/develop/clients/patterns/bulk-loading.md similarity index 100% rename from content/develop/use/patterns/bulk-loading.md rename to content/develop/clients/patterns/bulk-loading.md diff --git a/content/develop/use/patterns/distributed-locks.md b/content/develop/clients/patterns/distributed-locks.md similarity index 100% rename from content/develop/use/patterns/distributed-locks.md rename to content/develop/clients/patterns/distributed-locks.md diff --git a/content/develop/use/patterns/indexes/2idx_0.png b/content/develop/clients/patterns/indexes/2idx_0.png similarity index 100% rename from content/develop/use/patterns/indexes/2idx_0.png rename to content/develop/clients/patterns/indexes/2idx_0.png diff --git a/content/develop/use/patterns/indexes/2idx_1.png b/content/develop/clients/patterns/indexes/2idx_1.png similarity index 100% rename from content/develop/use/patterns/indexes/2idx_1.png rename to content/develop/clients/patterns/indexes/2idx_1.png diff --git a/content/develop/use/patterns/indexes/2idx_2.png b/content/develop/clients/patterns/indexes/2idx_2.png similarity index 100% rename from content/develop/use/patterns/indexes/2idx_2.png rename to content/develop/clients/patterns/indexes/2idx_2.png diff --git a/content/develop/use/patterns/indexes/index.md b/content/develop/clients/patterns/indexes/index.md similarity index 100% rename from content/develop/use/patterns/indexes/index.md rename to content/develop/clients/patterns/indexes/index.md diff --git a/content/develop/use/patterns/twitter-clone.md b/content/develop/clients/patterns/twitter-clone.md similarity index 100% rename from content/develop/use/patterns/twitter-clone.md rename to content/develop/clients/patterns/twitter-clone.md diff --git a/content/develop/tools/cli.md b/content/develop/tools/cli.md index 131a24df60..75c67501df 100644 --- a/content/develop/tools/cli.md +++ b/content/develop/tools/cli.md @@ -223,7 +223,7 @@ To monitor over time the RSS memory size it's possible to use the following comm ## Mass insertion of data using `redis-cli` Mass insertion using `redis-cli` is covered in a separate page as it is a -worthwhile topic itself. Please refer to our [mass insertion guide]({{< relref "/develop/use/patterns/bulk-loading" >}}). +worthwhile topic itself. Please refer to our [mass insertion guide]({{< relref "/develop/clients/patterns/bulk-loading" >}}). ## CSV output From ed9f7e64ebf9aa1256488be6c70028beccde5571 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 11:50:20 +0100 Subject: [PATCH 5/9] DOC-3967 moved programmability folder into develop --- content/develop/{interact => }/programmability/_index.md | 2 +- content/develop/{interact => }/programmability/eval-intro.md | 0 .../develop/{interact => }/programmability/functions-intro.md | 0 content/develop/{interact => }/programmability/lua-api.md | 0 content/develop/{interact => }/programmability/lua-debugging.md | 0 5 files changed, 1 insertion(+), 1 deletion(-) rename content/develop/{interact => }/programmability/_index.md (99%) rename content/develop/{interact => }/programmability/eval-intro.md (100%) rename content/develop/{interact => }/programmability/functions-intro.md (100%) rename content/develop/{interact => }/programmability/lua-api.md (100%) rename content/develop/{interact => }/programmability/lua-debugging.md (100%) diff --git a/content/develop/interact/programmability/_index.md b/content/develop/programmability/_index.md similarity index 99% rename from content/develop/interact/programmability/_index.md rename to content/develop/programmability/_index.md index 39eff44c42..2f748d0ca6 100644 --- a/content/develop/interact/programmability/_index.md +++ b/content/develop/programmability/_index.md @@ -14,7 +14,7 @@ description: 'Extending Redis with Lua and Redis Functions ' linkTitle: Programmability title: Redis programmability -weight: 20 +weight: 50 --- Redis provides a programming interface that lets you execute custom scripts on the server itself. In Redis 7 and beyond, you can use [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) to manage and run your scripts. In Redis 6.2 and below, you use [Lua scripting with the EVAL command]({{< relref "/develop/interact/programmability/eval-intro" >}}) to program the server. diff --git a/content/develop/interact/programmability/eval-intro.md b/content/develop/programmability/eval-intro.md similarity index 100% rename from content/develop/interact/programmability/eval-intro.md rename to content/develop/programmability/eval-intro.md diff --git a/content/develop/interact/programmability/functions-intro.md b/content/develop/programmability/functions-intro.md similarity index 100% rename from content/develop/interact/programmability/functions-intro.md rename to content/develop/programmability/functions-intro.md diff --git a/content/develop/interact/programmability/lua-api.md b/content/develop/programmability/lua-api.md similarity index 100% rename from content/develop/interact/programmability/lua-api.md rename to content/develop/programmability/lua-api.md diff --git a/content/develop/interact/programmability/lua-debugging.md b/content/develop/programmability/lua-debugging.md similarity index 100% rename from content/develop/interact/programmability/lua-debugging.md rename to content/develop/programmability/lua-debugging.md From 93803833792ca7340677a5a5c834fe925ab502f2 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 14:21:35 +0100 Subject: [PATCH 6/9] DOC-3967 fixed links to programmability section --- content/apis/_index.md | 6 ++--- content/commands/command.md | 2 +- content/commands/eval.md | 6 ++--- content/commands/eval_ro.md | 4 +-- content/commands/evalsha.md | 2 +- content/commands/evalsha_ro.md | 4 +-- content/commands/fcall.md | 2 +- content/commands/fcall_ro.md | 4 +-- content/commands/function-delete.md | 2 +- content/commands/function-dump.md | 2 +- content/commands/function-flush.md | 2 +- content/commands/function-kill.md | 2 +- content/commands/function-list.md | 4 +-- content/commands/function-load.md | 4 +-- content/commands/function-restore.md | 2 +- content/commands/function-stats.md | 2 +- content/commands/info.md | 2 +- content/commands/memory-usage.md | 2 +- content/commands/script-debug.md | 4 +-- content/commands/script-exists.md | 2 +- content/commands/script-flush.md | 2 +- content/commands/script-kill.md | 2 +- content/commands/script-load.md | 2 +- content/develop/data-types/_index.md | 2 +- content/develop/programmability/_index.md | 12 ++++----- content/develop/programmability/eval-intro.md | 26 +++++++++---------- .../programmability/functions-intro.md | 20 +++++++------- content/develop/programmability/lua-api.md | 26 +++++++++---------- content/develop/reference/protocol-spec.md | 2 +- content/develop/tools/cli.md | 2 +- .../compatibility/commands/server.md | 24 ++++++++--------- .../compatibility/commands/server.md | 24 ++++++++--------- .../compatibility/commands/server.md | 24 ++++++++--------- .../rs-7-2-4-releases/rs-7-2-4-52.md | 2 +- 34 files changed, 115 insertions(+), 115 deletions(-) diff --git a/content/apis/_index.md b/content/apis/_index.md index eaef82dbfe..4a5ca54c45 100644 --- a/content/apis/_index.md +++ b/content/apis/_index.md @@ -26,12 +26,12 @@ The existing Redis commands cover most use cases, but if low latency is a critic Lua scripts have been available since early versions of Redis. With Lua, the script is provided by the client and cached on the server side, which implies the risk that different clients might use a different script version. -- [Redis Lua API reference]({{< relref "/develop/interact/programmability/lua-api" >}}) -- [Scripting with Lua introduction]({{< relref "/develop/interact/programmability/eval-intro" >}}) +- [Redis Lua API reference]({{< relref "/develop/programmability/lua-api" >}}) +- [Scripting with Lua introduction]({{< relref "/develop/programmability/eval-intro" >}}) The Redis functions feature, which became available in Redis 7, supersedes the use of Lua in prior versions of Redis. The client is still responsible for invoking the execution, but unlike the previous Lua scripts, functions can now be replicated and persisted. -- [Functions and scripting in Redis 7 and beyond]({{< relref "/develop/interact/programmability/functions-intro" >}}) +- [Functions and scripting in Redis 7 and beyond]({{< relref "/develop/programmability/functions-intro" >}}) If none of the previous methods fulfills your needs, then you can extend the functionality of Redis with new commands using the Redis Modules API. diff --git a/content/commands/command.md b/content/commands/command.md index 621bbb6207..1f18d34fe7 100644 --- a/content/commands/command.md +++ b/content/commands/command.md @@ -102,7 +102,7 @@ Command flags are an array. It can contain the following simple strings (status * **no_async_loading:** the command is denied during asynchronous loading (that is when a replica uses disk-less `SWAPDB SYNC`, and allows access to the old dataset). * **no_mandatory_keys:** the command may accept key name arguments, but these aren't mandatory. * **no_multi:** the command isn't allowed inside the context of a [transaction]({{< relref "/develop/reference/transactions" >}}). -* **noscript:** the command can't be called from [scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) or [functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +* **noscript:** the command can't be called from [scripts]({{< relref "/develop/programmability/eval-intro" >}}) or [functions]({{< relref "/develop/programmability/functions-intro" >}}). * **pubsub:** the command is related to [Redis Pub/Sub]({{< relref "/develop/interact/pubsub" >}}). * **random**: the command returns random results, which is a concern with verbatim script replication. As of Redis 7.0, this flag is a [command tip][tb]. diff --git a/content/commands/eval.md b/content/commands/eval.md index 01575fc40a..d3706a389b 100644 --- a/content/commands/eval.md +++ b/content/commands/eval.md @@ -66,10 +66,10 @@ title: EVAL Invoke the execution of a server-side Lua script. The first argument is the script's source code. -Scripts are written in [Lua](https://lua.org) and executed by the embedded [Lua 5.1]({{< relref "develop/interact/programmability/lua-api" >}}) interpreter in Redis. +Scripts are written in [Lua](https://lua.org) and executed by the embedded [Lua 5.1]({{< relref "develop/programmability/lua-api" >}}) interpreter in Redis. The second argument is the number of input key name arguments, followed by all the keys accessed by the script. -These names of input keys are available to the script as the [_KEYS_ global runtime variable]({{< relref "develop/interact/programmability/lua-api#the-keys-global-variable" >}}) +These names of input keys are available to the script as the [_KEYS_ global runtime variable]({{< relref "develop/programmability/lua-api#the-keys-global-variable" >}}) Any additional input arguments **should not** represent names of keys. **Important:** @@ -83,7 +83,7 @@ These are added to the Lua interpreter and cached to redis-server, consuming a l Starting from Redis 7.4, scripts loaded with `EVAL` or [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}) will be deleted from redis after a certain number (least recently used order). The number of evicted scripts can be viewed through [`INFO`]({{< relref "/commands/info" >}})'s `evicted_scripts`. -Please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) for more information about Lua scripts. +Please refer to the [Redis Programmability]({{< relref "/develop/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}) for more information about Lua scripts. ## Examples diff --git a/content/commands/eval_ro.md b/content/commands/eval_ro.md index b50d27b9fb..587c5af89a 100644 --- a/content/commands/eval_ro.md +++ b/content/commands/eval_ro.md @@ -65,9 +65,9 @@ title: EVAL_RO --- This is a read-only variant of the [`EVAL`]({{< relref "/commands/eval" >}}) command that cannot execute commands that modify data. -For more information about when to use this command vs [`EVAL`]({{< relref "/commands/eval" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability#read-only-scripts" >}}). +For more information about when to use this command vs [`EVAL`]({{< relref "/commands/eval" >}}), please refer to [Read-only scripts]({{< relref "develop/programmability#read-only-scripts" >}}). -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Examples diff --git a/content/commands/evalsha.md b/content/commands/evalsha.md index c3bb476552..d43d493241 100644 --- a/content/commands/evalsha.md +++ b/content/commands/evalsha.md @@ -67,7 +67,7 @@ Evaluate a script from the server's cache by its SHA1 digest. The server caches scripts by using the [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) command. The command is otherwise identical to [`EVAL`]({{< relref "/commands/eval" >}}). -Please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) for more information about Lua scripts. +Please refer to the [Redis Programmability]({{< relref "/develop/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}) for more information about Lua scripts. ## Return information diff --git a/content/commands/evalsha_ro.md b/content/commands/evalsha_ro.md index 3ded3ba264..e73c6051c5 100644 --- a/content/commands/evalsha_ro.md +++ b/content/commands/evalsha_ro.md @@ -64,9 +64,9 @@ title: EVALSHA_RO --- This is a read-only variant of the [`EVALSHA`]({{< relref "/commands/evalsha" >}}) command that cannot execute commands that modify data. -For more information about when to use this command vs [`EVALSHA`]({{< relref "/commands/evalsha" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability#read-only-scripts" >}}). +For more information about when to use this command vs [`EVALSHA`]({{< relref "/commands/evalsha" >}}), please refer to [Read-only scripts]({{< relref "develop/programmability#read-only-scripts" >}}). -For more information about [`EVALSHA`]({{< relref "/commands/evalsha" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVALSHA`]({{< relref "/commands/evalsha" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Return information diff --git a/content/commands/fcall.md b/content/commands/fcall.md index 3494b41816..5ae677795e 100644 --- a/content/commands/fcall.md +++ b/content/commands/fcall.md @@ -79,7 +79,7 @@ Functions **should never** access keys with programmatically-generated names or Any additional input argument **should not** represent names of keys. These are regular arguments and are passed in a Lua table as the callback's second argument. -For more information please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) pages. +For more information please refer to the [Redis Programmability]({{< relref "/develop/programmability/" >}}) and [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}) pages. ## Examples diff --git a/content/commands/fcall_ro.md b/content/commands/fcall_ro.md index 0cef2a52ac..8424a4e3cd 100644 --- a/content/commands/fcall_ro.md +++ b/content/commands/fcall_ro.md @@ -65,9 +65,9 @@ title: FCALL_RO --- This is a read-only variant of the [`FCALL`]({{< relref "/commands/fcall" >}}) command that cannot execute commands that modify data. -For more information about when to use this command vs [`FCALL`]({{< relref "/commands/fcall" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability/#read-only_scripts" >}}). +For more information about when to use this command vs [`FCALL`]({{< relref "/commands/fcall" >}}), please refer to [Read-only scripts]({{< relref "develop/programmability/#read-only_scripts" >}}). -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/function-delete.md b/content/commands/function-delete.md index 3da46522b7..c115290e45 100644 --- a/content/commands/function-delete.md +++ b/content/commands/function-delete.md @@ -40,7 +40,7 @@ Delete a library and all its functions. This command deletes the library called _library-name_ and all functions in it. If the library doesn't exist, the server returns an error. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Examples diff --git a/content/commands/function-dump.md b/content/commands/function-dump.md index fa1fab6809..b419502e57 100644 --- a/content/commands/function-dump.md +++ b/content/commands/function-dump.md @@ -29,7 +29,7 @@ title: FUNCTION DUMP Return the serialized payload of loaded libraries. You can restore the serialized payload later with the [`FUNCTION RESTORE`]({{< relref "/commands/function-restore" >}}) command. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Examples diff --git a/content/commands/function-flush.md b/content/commands/function-flush.md index e151ad330c..9717d233d3 100644 --- a/content/commands/function-flush.md +++ b/content/commands/function-flush.md @@ -51,7 +51,7 @@ Unless called with the optional mode argument, the `lazyfree-lazy-user-flush` co * `ASYNC`: Asynchronously flush the libraries. * `SYNC`: Synchronously flush the libraries. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/function-kill.md b/content/commands/function-kill.md index 120afd60c1..75d4cf2453 100644 --- a/content/commands/function-kill.md +++ b/content/commands/function-kill.md @@ -35,7 +35,7 @@ Kill a function that is currently executing. The `FUNCTION KILL` command can be used only on functions that did not modify the dataset during their execution (since stopping a read-only function does not violate the scripting engine's guaranteed atomicity). -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/function-list.md b/content/commands/function-list.md index 21e4eb251f..d02f63170c 100644 --- a/content/commands/function-list.md +++ b/content/commands/function-list.md @@ -52,10 +52,10 @@ The following information is provided for each of the libraries in the response: Each function has the following fields: * **name:** the name of the function. * **description:** the function's description. - * **flags:** an array of [function flags]({{< relref "develop/interact/programmability/functions-intro#function-flags" >}}). + * **flags:** an array of [function flags]({{< relref "develop/programmability/functions-intro#function-flags" >}}). * **library_code:** the library's source code (when given the `WITHCODE` modifier). -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/function-load.md b/content/commands/function-load.md index ba8fb25d7c..a460f1c082 100644 --- a/content/commands/function-load.md +++ b/content/commands/function-load.md @@ -47,7 +47,7 @@ The command's gets a single mandatory parameter which is the source code that im The library payload must start with Shebang statement that provides a metadata about the library (like the engine to use and the library name). Shebang format: `#! name=`. Currently engine name must be `lua`. -For the Lua engine, the implementation should declare one or more entry points to the library with the [`redis.register_function()` API]({{< relref "develop/interact/programmability/lua-api#redis.register_function" >}}). +For the Lua engine, the implementation should declare one or more entry points to the library with the [`redis.register_function()` API]({{< relref "develop/programmability/lua-api#redis.register_function" >}}). Once loaded, you can call the functions in the library with the [`FCALL`]({{< relref "/commands/fcall" >}}) (or [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) when applicable) command. When attempting to load a library with a name that already exists, the Redis server returns an error. @@ -61,7 +61,7 @@ The command will return an error in the following circumstances: * The engine failed in creating the library's functions (due to a compilation error, for example). * No functions were declared by the library. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Examples diff --git a/content/commands/function-restore.md b/content/commands/function-restore.md index 9da135b6ce..2f116c8a9e 100644 --- a/content/commands/function-restore.md +++ b/content/commands/function-restore.md @@ -62,7 +62,7 @@ The following policies are allowed: * **FLUSH:** deletes all existing libraries before restoring the payload. * **REPLACE:** appends the restored libraries to the existing libraries, replacing any existing ones in case of name collisions. Note that this policy doesn't prevent function name collisions, only libraries. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/function-stats.md b/content/commands/function-stats.md index a83e1b2493..fb72c33317 100644 --- a/content/commands/function-stats.md +++ b/content/commands/function-stats.md @@ -47,7 +47,7 @@ The reply is map with two keys: You can use this command to inspect the invocation of a long-running function and decide whether kill it with the [`FUNCTION KILL`]({{< relref "/commands/function-kill" >}}) command. -For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). +For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}). ## Return information diff --git a/content/commands/info.md b/content/commands/info.md index 21eb3fb6af..a253836591 100644 --- a/content/commands/info.md +++ b/content/commands/info.md @@ -621,7 +621,7 @@ It won't be included when `INFO` or `INFO ALL` are called, and it is returned on | Redis
Enterprise | Redis
Cloud | Notes | |:----------------------|:-----------------|:------| -| ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | +| ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | Note: key memory usage is different on Redis Software or Redis Cloud active-active databases than on non-active-active databases. This is because memory usage includes some amount of CRDB overhead. diff --git a/content/commands/memory-usage.md b/content/commands/memory-usage.md index aff92a98ac..24c5e0d0e8 100644 --- a/content/commands/memory-usage.md +++ b/content/commands/memory-usage.md @@ -92,7 +92,7 @@ OK | Redis
Enterprise | Redis
Cloud | Notes | |:----------------------|:-----------------|:------| -|✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +|✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | Note: key memory usage is different on Redis Software or Redis Cloud active-active databases than on non-active-active databases. This is because memory usage includes some amount of CRDB overhead. diff --git a/content/commands/script-debug.md b/content/commands/script-debug.md index b380a33ad9..798ee97f35 100644 --- a/content/commands/script-debug.md +++ b/content/commands/script-debug.md @@ -47,7 +47,7 @@ complete Lua debugger, codename LDB, that can be used to make the task of writing complex scripts much simpler. In debug mode Redis acts as a remote debugging server and a client, such as `redis-cli`, can execute scripts step by step, set breakpoints, inspect variables and more - for additional information -about LDB refer to the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}) page. +about LDB refer to the [Redis Lua debugger]({{< relref "/develop/programmability/lua-debugging" >}}) page. **Important note:** avoid debugging Lua scripts using your Redis production server. Use a development server instead. @@ -63,7 +63,7 @@ is active and retains all changes to the data set once it ends. * `SYNC`. Enable blocking synchronous debugging of Lua scripts (saves changes to data). * `NO`. Disables scripts debug mode. -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Return information diff --git a/content/commands/script-exists.md b/content/commands/script-exists.md index cbf633c79f..ab5471211a 100644 --- a/content/commands/script-exists.md +++ b/content/commands/script-exists.md @@ -45,7 +45,7 @@ loaded (and if not, to load them using [`SCRIPT LOAD`]({{< relref "/commands/scr operation can be performed solely using [`EVALSHA`]({{< relref "/commands/evalsha" >}}) instead of [`EVAL`]({{< relref "/commands/eval" >}}) to save bandwidth. -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Return information diff --git a/content/commands/script-flush.md b/content/commands/script-flush.md index 31a1783a0e..873dcc2a4e 100644 --- a/content/commands/script-flush.md +++ b/content/commands/script-flush.md @@ -56,7 +56,7 @@ It is possible to use one of the following modifiers to dictate the flushing mod * `ASYNC`: flushes the cache asynchronously * `SYNC`: flushes the cache synchronously -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Behavior change history diff --git a/content/commands/script-kill.md b/content/commands/script-kill.md index 4b1473773c..03e7e40db6 100644 --- a/content/commands/script-kill.md +++ b/content/commands/script-kill.md @@ -44,7 +44,7 @@ In such a case, only `SHUTDOWN NOSAVE` can kill the script, killing the Redis process in a hard way and preventing it from persisting with half-written information. -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Return information diff --git a/content/commands/script-load.md b/content/commands/script-load.md index f7d3f65ba6..fb7fd1e30f 100644 --- a/content/commands/script-load.md +++ b/content/commands/script-load.md @@ -45,7 +45,7 @@ FLUSH` is called). The command works in the same way even if the script was already present in the script cache. -For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}). ## Return information diff --git a/content/develop/data-types/_index.md b/content/develop/data-types/_index.md index b305d096bd..96e056be32 100644 --- a/content/develop/data-types/_index.md +++ b/content/develop/data-types/_index.md @@ -217,5 +217,5 @@ For more information, see: To extend the features provided by the included data types, use one of these options: -1. Write your own custom [server-side functions in Lua]({{< relref "/develop/interact/programmability/" >}}). +1. Write your own custom [server-side functions in Lua]({{< relref "/develop/programmability/" >}}). 1. Write your own Redis module using the [modules API]({{< relref "/develop/reference/modules/" >}}) or check out the [community-supported modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/" >}}). diff --git a/content/develop/programmability/_index.md b/content/develop/programmability/_index.md index 2f748d0ca6..ec8e4903aa 100644 --- a/content/develop/programmability/_index.md +++ b/content/develop/programmability/_index.md @@ -17,7 +17,7 @@ title: Redis programmability weight: 50 --- -Redis provides a programming interface that lets you execute custom scripts on the server itself. In Redis 7 and beyond, you can use [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) to manage and run your scripts. In Redis 6.2 and below, you use [Lua scripting with the EVAL command]({{< relref "/develop/interact/programmability/eval-intro" >}}) to program the server. +Redis provides a programming interface that lets you execute custom scripts on the server itself. In Redis 7 and beyond, you can use [Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}) to manage and run your scripts. In Redis 6.2 and below, you use [Lua scripting with the EVAL command]({{< relref "/develop/programmability/eval-intro" >}}) to program the server. ## Background @@ -36,7 +36,7 @@ Such APIs can encapsulate business logic and maintain a data model across multip User scripts are executed in Redis by an embedded, sandboxed scripting engine. Presently, Redis supports a single scripting engine, the [Lua 5.1](https://www.lua.org/) interpreter. -Please refer to the [Redis Lua API Reference]({{< relref "develop/interact/programmability/lua-api" >}}) page for complete documentation. +Please refer to the [Redis Lua API Reference]({{< relref "/develop/programmability/lua-api" >}}) page for complete documentation. ## Running scripts @@ -56,8 +56,8 @@ In this case, loading a function to the database becomes an administrative deplo Please refer to the following pages for more information: -* [Redis Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) -* [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) +* [Redis Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}) +* [Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}) When running a script or a function, Redis guarantees its atomic execution. The script's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/reference/transactions" >}}). @@ -71,7 +71,7 @@ However, if you intend to use a slow script in your application, be aware that a ## Read-only scripts A read-only script is a script that only executes commands that don't modify any keys within Redis. -Read-only scripts can be executed either by adding the `no-writes` [flag]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) to the script or by executing the script with one of the read-only script command variants: [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}), [`EVALSHA_RO`]({{< relref "/commands/evalsha_ro" >}}), or [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}). +Read-only scripts can be executed either by adding the `no-writes` [flag]({{< relref "/develop/programmability/lua-api#script_flags" >}}) to the script or by executing the script with one of the read-only script command variants: [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}), [`EVALSHA_RO`]({{< relref "/commands/evalsha_ro" >}}), or [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}). They have the following properties: * They can always be executed on replicas. @@ -91,7 +91,7 @@ In addition to the benefits provided by all read-only scripts, the read-only scr Read-only scripts and read-only script commands were introduced in Redis 7.0 * Before Redis 7.0.1 [`PUBLISH`]({{< relref "/commands/publish" >}}), [`SPUBLISH`]({{< relref "/commands/spublish" >}}) and [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) were not considered write commands in scripts -* Before Redis 7.0.1 the `no-writes` [flag]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) did not imply `allow-oom` +* Before Redis 7.0.1 the `no-writes` [flag]({{< relref "/develop/programmability/lua-api#script_flags" >}}) did not imply `allow-oom` * Before Redis 7.0.1 the `no-writes` flag did not permit the script to run during write pauses. diff --git a/content/develop/programmability/eval-intro.md b/content/develop/programmability/eval-intro.md index 8ac052bc31..c043c5383b 100644 --- a/content/develop/programmability/eval-intro.md +++ b/content/develop/programmability/eval-intro.md @@ -37,11 +37,11 @@ Such scripts can perform conditional updates across multiple keys, possibly comb Scripts are executed in Redis by an embedded execution engine. Presently, Redis supports a single scripting engine, the [Lua 5.1](https://www.lua.org/) interpreter. -Please refer to the [Redis Lua API Reference]({{< relref "develop/interact/programmability/lua-api" >}}) page for complete documentation. +Please refer to the [Redis Lua API Reference]({{< relref "/develop/programmability/lua-api" >}}) page for complete documentation. Although the server executes them, Eval scripts are regarded as a part of the client-side application, which is why they're not named, versioned, or persisted. So all scripts may need to be reloaded by the application at any time if missing (after a server restart, fail-over to a replica, etc.). -As of version 7.0, [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) offer an alternative approach to programmability which allow the server itself to be extended with additional programmed logic. +As of version 7.0, [Redis Functions]({{< relref "/develop/programmability/functions-intro" >}}) offer an alternative approach to programmability which allow the server itself to be extended with additional programmed logic. ## Getting started @@ -100,7 +100,7 @@ Any input to the function that isn't the name of a key is a regular input argume In the example above, both _Hello_ and _Parameterization!_ regular input arguments for the script. Because the script doesn't touch any keys, we use the numerical argument _0_ to specify there are no key name arguments. -The execution context makes arguments available to the script through [_KEYS_]({{< relref "develop/interact/programmability/lua-api#the-keys-global-variable" >}}) and [_ARGV_]({{< relref "develop/interact/programmability/lua-api#the-argv-global-variable" >}}) global runtime variables. +The execution context makes arguments available to the script through [_KEYS_]({{< relref "/develop/programmability/lua-api#the-keys-global-variable" >}}) and [_ARGV_]({{< relref "/develop/programmability/lua-api#the-argv-global-variable" >}}) global runtime variables. The _KEYS_ table is pre-populated with all key name arguments provided to the script before its execution, whereas the _ARGV_ table serves a similar purpose but for regular arguments. The following attempts to demonstrate the distribution of input arguments between the scripts _KEYS_ and _ARGV_ runtime global variables: @@ -117,11 +117,11 @@ redis> EVAL "return { KEYS[1], KEYS[2], ARGV[1], ARGV[2], ARGV[3] }" 2 key1 key2 **Note:** as can been seen above, Lua's table arrays are returned as [RESP2 array replies]({{< relref "/develop/reference/protocol-spec#resp-arrays" >}}), so it is likely that your client's library will convert it to the native array data type in your programming language. -Please refer to the rules that govern [data type conversion]({{< relref "develop/interact/programmability/lua-api#data-type-conversion" >}}) for more pertinent information. +Please refer to the rules that govern [data type conversion]({{< relref "/develop/programmability/lua-api#data-type-conversion" >}}) for more pertinent information. ## Interacting with Redis from a script -It is possible to call Redis commands from a Lua script either via [`redis.call()`]({{< relref "develop/interact/programmability/lua-api#redis.call" >}}) or [`redis.pcall()`]({{< relref "develop/interact/programmability/lua-api#redis.pcall" >}}). +It is possible to call Redis commands from a Lua script either via [`redis.call()`]({{< relref "/develop/programmability/lua-api#redis.call" >}}) or [`redis.pcall()`]({{< relref "/develop/programmability/lua-api#redis.pcall" >}}). The two are nearly identical. Both execute a Redis command along with its provided arguments, if these represent a well-formed command. @@ -231,10 +231,10 @@ These are: It is a useful command in all the contexts where we want to ensure that [`EVALSHA`]({{< relref "/commands/evalsha" >}}) doesn't not fail (for instance, in a pipeline or when called from a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/reference/transactions" >}}), without the need to execute the script. * [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}): this command is the only way to interrupt a long-running script (a.k.a slow script), short of shutting down the server. - A script is deemed as slow once its execution's duration exceeds the configured [maximum execution time]({{< relref "/develop/interact/programmability/#maximum-execution-time" >}}) threshold. + A script is deemed as slow once its execution's duration exceeds the configured [maximum execution time]({{< relref "/develop/programmability/#maximum-execution-time" >}}) threshold. The [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) command can be used only with scripts that did not modify the dataset during their execution (since stopping a read-only script does not violate the scripting engine's guaranteed atomicity). -* [`SCRIPT DEBUG`]({{< relref "/commands/script-debug" >}}): controls use of the built-in [Redis Lua scripts debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}). +* [`SCRIPT DEBUG`]({{< relref "/commands/script-debug" >}}): controls use of the built-in [Redis Lua scripts debugger]({{< relref "/develop/programmability/lua-debugging" >}}). ## Script replication @@ -255,7 +255,7 @@ There are two conceptual approaches when it comes to script replication: While potentially lengthier in terms of network traffic, this replication mode is deterministic by definition and therefore doesn't require special consideration. Verbatim script replication was the only mode supported until Redis 3.2, in which effects replication was added. -The _lua-replicate-commands_ configuration directive and [`redis.replicate_commands()`]({{< relref "develop/interact/programmability/lua-api#redis.replicate_commands" >}}) Lua API can be used to enable it. +The _lua-replicate-commands_ configuration directive and [`redis.replicate_commands()`]({{< relref "/develop/programmability/lua-api#redis.replicate_commands" >}}) Lua API can be used to enable it. In Redis 5.0, effects replication became the default mode. As of Redis 7.0, verbatim replication is no longer supported. @@ -286,7 +286,7 @@ Unless already enabled by the server's configuration or defaults (before Redis 7 redis.replicate_commands() ``` -The [`redis.replicate_commands()`]({{< relref "develop/interact/programmability/lua-api#redis.replicate_commands" >}}) function returns _true) if script effects replication was enabled; +The [`redis.replicate_commands()`]({{< relref "/develop/programmability/lua-api#redis.replicate_commands" >}}) function returns _true) if script effects replication was enabled; otherwise, if the function was called after the script already called a write command, it returns _false_, and normal whole script replication is used. @@ -331,7 +331,7 @@ and undergo a silent lexicographical sorting filter before returning data to Lua However, starting with Redis 5.0, this ordering is no longer performed because replicating effects circumvents this type of non-determinism. In general, even when developing for Redis 4.0, never assume that certain commands in Lua will be ordered, but instead rely on the documentation of the original command you call to see the properties it provides. * Lua's pseudo-random number generation function `math.random` is modified and always uses the same seed for every execution. - This means that calling [`math.random`]({{< relref "develop/interact/programmability/lua-api#runtime-libraries" >}}) will always generate the same sequence of numbers every time a script is executed (unless `math.randomseed` is used). + This means that calling [`math.random`]({{< relref "/develop/programmability/lua-api#runtime-libraries" >}}) will always generate the same sequence of numbers every time a script is executed (unless `math.randomseed` is used). All that said, you can still use commands that write and random behavior with a simple trick. Imagine that you want to write a Redis script that will populate a list with N random integers. @@ -409,11 +409,11 @@ Note: an important part of this behavior is that the PRNG that Redis implements Starting with Redis 3.2, Redis has support for native Lua debugging. The Redis Lua debugger is a remote debugger consisting of a server, which is Redis itself, and a client, which is by default [`redis-cli`]({{< relref "/develop/tools/cli" >}}). -The Lua debugger is described in the [Lua scripts debugging]({{< relref "/develop/interact/programmability/lua-debugging" >}}) section of the Redis documentation. +The Lua debugger is described in the [Lua scripts debugging]({{< relref "/develop/programmability/lua-debugging" >}}) section of the Redis documentation. ## Execution under low memory conditions -When memory usage in Redis exceeds the `maxmemory` limit, the first write command encountered in the script that uses additional memory will cause the script to abort (unless [`redis.pcall`]({{< relref "develop/interact/programmability/lua-api#redis.pcall" >}}) was used). +When memory usage in Redis exceeds the `maxmemory` limit, the first write command encountered in the script that uses additional memory will cause the script to abort (unless [`redis.pcall`]({{< relref "/develop/programmability/lua-api#redis.pcall" >}}) was used). However, an exception to the above is when the script's first write command does not use additional memory, as is the case with (for example, [`DEL`]({{< relref "/commands/del" >}}) and [`LREM`]({{< relref "/commands/lrem" >}})). In this case, Redis will allow all commands in the script to run to ensure atomicity. @@ -446,4 +446,4 @@ it still has a different set of defaults compared to a script without a `#!` lin Another difference is that scripts without `#!` can run commands that access keys belonging to different cluster hash slots, but ones with `#!` inherit the default flags, so they cannot. -Please refer to [Script flags]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) to learn about the various scripts and the defaults. +Please refer to [Script flags]({{< relref "/develop/programmability/lua-api#script_flags" >}}) to learn about the various scripts and the defaults. diff --git a/content/develop/programmability/functions-intro.md b/content/develop/programmability/functions-intro.md index 71291711b3..d7b2c96fd1 100644 --- a/content/develop/programmability/functions-intro.md +++ b/content/develop/programmability/functions-intro.md @@ -17,12 +17,12 @@ title: Redis functions weight: 1 --- -Redis Functions is an API for managing code to be executed on the server. This feature, which became available in Redis 7, supersedes the use of [EVAL]({{< relref "/develop/interact/programmability/eval-intro" >}}) in prior versions of Redis. +Redis Functions is an API for managing code to be executed on the server. This feature, which became available in Redis 7, supersedes the use of [EVAL]({{< relref "/develop/programmability/eval-intro" >}}) in prior versions of Redis. ## Prologue (or, what's wrong with Eval Scripts?) Prior versions of Redis made scripting available only via the [`EVAL`]({{< relref "/commands/eval" >}}) command, which allows a Lua script to be sent for execution by the server. -The core use cases for [Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) is executing part of your application logic inside Redis, efficiently and atomically. +The core use cases for [Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}) is executing part of your application logic inside Redis, efficiently and atomically. Such script can perform conditional updates across multiple keys, possibly combining several different data types. Using [`EVAL`]({{< relref "/commands/eval" >}}) requires that the application sends the entire script for execution every time. @@ -38,7 +38,7 @@ This approach suits many light-weight scripting use cases, but introduces severa 1. All client application instances must maintain a copy of all scripts. That means having some mechanism that applies script updates to all of the application's instances. 1. Calling cached scripts within the context of a [transaction]({{< relref "/develop/reference/transactions" >}}) increases the probability of the transaction failing because of a missing script. Being more likely to fail makes using cached scripts as building blocks of workflows less attractive. 1. SHA1 digests are meaningless, making debugging the system extremely hard (e.g., in a [`MONITOR`]({{< relref "/commands/monitor" >}}) session). -1. When used naively, [`EVAL`]({{< relref "/commands/eval" >}}) promotes an anti-pattern in which scripts the client application renders verbatim scripts instead of responsibly using the [`KEYS` and `ARGV` Lua APIs]({{< relref "develop/interact/programmability/lua-api#runtime-globals" >}}). +1. When used naively, [`EVAL`]({{< relref "/commands/eval" >}}) promotes an anti-pattern in which scripts the client application renders verbatim scripts instead of responsibly using the [`KEYS` and `ARGV` Lua APIs]({{< relref "/develop/programmability/lua-api#runtime-globals" >}}). 1. Because they are ephemeral, a script can't call another script. This makes sharing and reusing code between scripts nearly impossible, short of client-side preprocessing (see the first point). To address these needs while avoiding breaking changes to already-established and well-liked ephemeral scripts, Redis v7.0 introduces Redis Functions. @@ -64,10 +64,10 @@ The Redis Functions feature makes no assumptions about the implementation's lang An execution engine that is part of the definition of the function handles running it. An engine can theoretically execute functions in any language as long as it respects several rules (such as the ability to terminate an executing function). -Presently, as noted above, Redis ships with a single embedded [Lua 5.1]({{< relref "develop/interact/programmability/lua-api" >}}) engine. +Presently, as noted above, Redis ships with a single embedded [Lua 5.1]({{< relref "/develop/programmability/lua-api" >}}) engine. There are plans to support additional engines in the future. Redis functions can use all of Lua's available capabilities to ephemeral scripts, -with the only exception being the [Redis Lua scripts debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}). +with the only exception being the [Redis Lua scripts debugger]({{< relref "/develop/programmability/lua-debugging" >}}). Functions also simplify development by enabling code sharing. Every function belongs to a single library, and any given library can consist of multiple functions. @@ -90,7 +90,7 @@ Because running a function blocks the Redis server, functions are meant to finis Let's explore Redis Functions via some tangible examples and Lua snippets. -At this point, if you're unfamiliar with Lua in general and specifically in Redis, you may benefit from reviewing some of the examples in [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) and [Lua API]({{< relref "develop/interact/programmability/lua-api" >}}) pages for a better grasp of the language. +At this point, if you're unfamiliar with Lua in general and specifically in Redis, you may benefit from reviewing some of the examples in [Introduction to Eval Scripts]({{< relref "/develop/programmability/eval-intro" >}}) and [Lua API]({{< relref "/develop/programmability/lua-api" >}}) pages for a better grasp of the language. Every Redis function belongs to a single library that's loaded to Redis. Loading a library to the database is done with the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command. @@ -245,7 +245,7 @@ redis.register_function('my_hgetall', my_hgetall) redis.register_function('my_hlastmodified', my_hlastmodified) ``` -While all of the above should be straightforward, note that the `my_hgetall` also calls [`redis.setresp(3)`]({{< relref "develop/interact/programmability/lua-api#redis.setresp" >}}). +While all of the above should be straightforward, note that the `my_hgetall` also calls [`redis.setresp(3)`]({{< relref "/develop/programmability/lua-api#redis.setresp" >}}). That means that the function expects [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md) replies after calling `redis.call()`, which, unlike the default RESP2 protocol, provides dictionary (associative arrays) replies. Doing so allows the function to delete (or set to `nil` as is the case with Lua tables) specific fields from the reply, and in our case, the `_last_modified_` field. @@ -303,7 +303,7 @@ You can see that it is easy to update our library with new capabilities. On top of bundling functions together into database-managed software artifacts, libraries also facilitate code sharing. We can add to our library an error handling helper function called from other functions. The helper function `check_keys()` verifies that the input _keys_ table has a single key. -Upon success it returns `nil`, otherwise it returns an [error reply]({{< relref "develop/interact/programmability/lua-api#redis.error_reply" >}}). +Upon success it returns `nil`, otherwise it returns an [error reply]({{< relref "/develop/programmability/lua-api#redis.error_reply" >}}). The updated library's source code would be: @@ -426,7 +426,7 @@ The server will reply with this error in the following cases: 3. A disk error was detected (Redis is unable to persist so it rejects writes). In these cases, you can add the `no-writes` flag to the function's registration, disable the safeguard and allow them to run. -To register a function with flags use the [named arguments]({{< relref "develop/interact/programmability/lua-api#redis.register_function_named_args" >}}) variant of `redis.register_function`. +To register a function with flags use the [named arguments]({{< relref "/develop/programmability/lua-api#redis.register_function_named_args" >}}) variant of `redis.register_function`. The updated registration code snippet from the library looks like this: @@ -456,4 +456,4 @@ redis> FCALL_RO my_hlastmodified 1 myhash "1640772721" ``` -For the complete documentation flags, please refer to [Script flags]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}). +For the complete documentation flags, please refer to [Script flags]({{< relref "/develop/programmability/lua-api#script_flags" >}}). diff --git a/content/develop/programmability/lua-api.md b/content/develop/programmability/lua-api.md index 24151fb80a..68e77b9068 100644 --- a/content/develop/programmability/lua-api.md +++ b/content/develop/programmability/lua-api.md @@ -18,7 +18,7 @@ weight: 3 --- Redis includes an embedded [Lua 5.1](https://www.lua.org/) interpreter. -The interpreter runs user-defined [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) and [functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). Scripts run in a sandboxed context and can only access specific Lua packages. This page describes the packages and APIs available inside the execution's context. +The interpreter runs user-defined [ephemeral scripts]({{< relref "/develop/programmability/eval-intro" >}}) and [functions]({{< relref "/develop/programmability/functions-intro" >}}). Scripts run in a sandboxed context and can only access specific Lua packages. This page describes the packages and APIs available inside the execution's context. ## Sandbox context @@ -104,7 +104,7 @@ to ensure the correct execution of scripts, both in standalone and clustered dep The script **should only** access keys whose names are given as input arguments. Scripts **should never** access keys with programmatically-generated names or based on the contents of data structures stored in the database. -The _KEYS_ global variable is available only for [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +The _KEYS_ global variable is available only for [ephemeral scripts]({{< relref "/develop/programmability/eval-intro" >}}). It is pre-populated with all key name input arguments. ### The _ARGV_ global variable {#the-argv-global-variable} @@ -113,7 +113,7 @@ It is pre-populated with all key name input arguments. * Available in scripts: yes * Available in functions: no -The _ARGV_ global variable is available only in [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}). +The _ARGV_ global variable is available only in [ephemeral scripts]({{< relref "/develop/programmability/eval-intro" >}}). It is pre-populated with all regular input arguments. ## _redis_ object {#redis_object} @@ -149,7 +149,7 @@ redis> EVAL "return redis.call('ECHO', 'Echo,', 'echo... ', 'eco... ', 'o...')" (error) ERR Wrong number of args calling Redis command from script script: b0345693f4b77517a711221050e76d24ae60b7f7, on @user_script:1. ``` -Note that the call can fail due to various reasons, see [Execution under low memory conditions]({{< relref "/develop/interact/programmability/eval-intro#execution-under-low-memory-conditions" >}}) and [Script flags](#script_flags) +Note that the call can fail due to various reasons, see [Execution under low memory conditions]({{< relref "/develop/programmability/eval-intro#execution-under-low-memory-conditions" >}}) and [Script flags](#script_flags) To handle Redis runtime errors use `redis.pcall()` instead. @@ -380,7 +380,7 @@ You can use it to override the default verbatim script replication mode used by **Note:** as of Redis v7.0, verbatim script replication is no longer supported. The default, and only script replication mode supported, is script effects' replication. -For more information, please refer to [`Replicating commands instead of scripts`]({{< relref "/develop/interact/programmability/eval-intro#replicating-commands-instead-of-scripts" >}}) +For more information, please refer to [`Replicating commands instead of scripts`]({{< relref "/develop/programmability/eval-intro#replicating-commands-instead-of-scripts" >}}) ### `redis.breakpoint()` {#redis.breakpoint} @@ -388,7 +388,7 @@ For more information, please refer to [`Replicating commands instead of scripts` * Available in scripts: yes * Available in functions: no -This function triggers a breakpoint when using the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}). +This function triggers a breakpoint when using the [Redis Lua debugger]({{< relref "/develop/programmability/lua-debugging" >}}). ### `redis.debug(x)` {#redis.debug} @@ -396,7 +396,7 @@ This function triggers a breakpoint when using the [Redis Lua debugger]({{< relr * Available in scripts: yes * Available in functions: no -This function prints its argument in the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}) console. +This function prints its argument in the [Redis Lua debugger]({{< relref "/develop/programmability/lua-debugging" >}}) console. ### `redis.acl_check_cmd(command [,arg...])` {#redis.acl_check_cmd} @@ -451,7 +451,7 @@ redis> FUNCTION LOAD "#!lua name=mylib\n redis.register_function{function_name=' **Important:** Use script flags with care, which may negatively impact if misused. -Note that the default for Eval scripts are different than the default for functions that are mentioned below, see [Eval Flags]({{< relref "develop/interact/programmability/eval-intro#eval-flags" >}}) +Note that the default for Eval scripts are different than the default for functions that are mentioned below, see [Eval Flags]({{< relref "/develop/programmability/eval-intro#eval-flags" >}}) When you register a function or load an Eval script, the server does not know how it accesses the database. By default, Redis assumes that all scripts read and write data. @@ -466,7 +466,7 @@ You can use the following flags and instruct the server to treat the scripts' ex * `no-writes`: this flag indicates that the script only reads data but never writes. - By default, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) against read-only replicas, as they may attempt to perform writes. + By default, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/programmability/eval-intro#eval-flags" >}})) against read-only replicas, as they may attempt to perform writes. Similarly, the server will not allow calling scripts with [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) / [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}). Lastly, when data persistence is at risk due to a disk error, execution is blocked as well. @@ -479,15 +479,15 @@ You can use the following flags and instruct the server to treat the scripts' ex However, note that the server will return an error if the script attempts to call a write command. Also note that currently [`PUBLISH`]({{< relref "/commands/publish" >}}), [`SPUBLISH`]({{< relref "/commands/spublish" >}}) and [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) are also considered write commands in scripts, because they could attempt to propagate commands to replicas and AOF file. - For more information please refer to [Read-only scripts]({{< relref "develop/interact/programmability/#read-only_scripts" >}}) + For more information please refer to [Read-only scripts]({{< relref "/develop/programmability/#read-only_scripts" >}}) * `allow-oom`: use this flag to allow a script to execute when the server is out of memory (OOM). - Unless used, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) when in an OOM state. + Unless used, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/programmability/eval-intro#eval-flags" >}})) when in an OOM state. Furthermore, when you use this flag, the script can call any Redis command, including commands that aren't usually allowed in this state. Specifying `no-writes` or using [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) / [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}) also implies the script can run in OOM state (without specifying `allow-oom`) -* `allow-stale`: a flag that enables running the flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) against a stale replica when the `replica-serve-stale-data` config is set to `no` . +* `allow-stale`: a flag that enables running the flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/programmability/eval-intro#eval-flags" >}})) against a stale replica when the `replica-serve-stale-data` config is set to `no` . Redis can be set to prevent data consistency problems from using old data by having stale replicas return a runtime error. For scripts that do not access the data, this flag can be set to allow stale Redis replicas to run the script. @@ -507,7 +507,7 @@ You can use the following flags and instruct the server to treat the scripts' ex This flag has no effect when cluster mode is disabled. -Please refer to [Function Flags]({{< relref "develop/interact/programmability/functions-intro#function-flags" >}}) and [Eval Flags]({{< relref "develop/interact/programmability/eval-intro#eval-flags" >}}) for a detailed example. +Please refer to [Function Flags]({{< relref "/develop/programmability/functions-intro#function-flags" >}}) and [Eval Flags]({{< relref "/develop/programmability/eval-intro#eval-flags" >}}) for a detailed example. ### `redis.REDIS_VERSION` {#redis.redis_version} diff --git a/content/develop/reference/protocol-spec.md b/content/develop/reference/protocol-spec.md index 9ec0774230..02dbf1ab93 100644 --- a/content/develop/reference/protocol-spec.md +++ b/content/develop/reference/protocol-spec.md @@ -755,7 +755,7 @@ While comparable in performance to a binary protocol, the Redis protocol is sign ## Tips for Redis client authors -* For testing purposes, use [Lua's type conversions]({{< relref "develop/interact/programmability/lua-api#lua-to-resp3-type-conversion" >}}) to have Redis reply with any RESP2/RESP3 needed. +* For testing purposes, use [Lua's type conversions]({{< relref "develop/programmability/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 diff --git a/content/develop/tools/cli.md b/content/develop/tools/cli.md index 75c67501df..8430b449da 100644 --- a/content/develop/tools/cli.md +++ b/content/develop/tools/cli.md @@ -239,7 +239,7 @@ Note that the `--csv` flag will only work on a single command, not the entirety ## Run Lua scripts The `redis-cli` has extensive support for using the debugging facility -of Lua scripting, available with Redis 3.2 onwards. For this feature, refer to the [Redis Lua debugger documentation]({{< relref "/develop/interact/programmability/lua-debugging" >}}). +of Lua scripting, available with Redis 3.2 onwards. For this feature, refer to the [Redis Lua debugger documentation]({{< relref "/develop/programmability/lua-debugging" >}}). Even without using the debugger, `redis-cli` can be used to run scripts from a file as an argument: diff --git a/content/operate/rs/7.4/references/compatibility/commands/server.md b/content/operate/rs/7.4/references/compatibility/commands/server.md index 8055707664..9a5749b48e 100644 --- a/content/operate/rs/7.4/references/compatibility/commands/server.md +++ b/content/operate/rs/7.4/references/compatibility/commands/server.md @@ -21,19 +21,19 @@ Several access control list (ACL) commands are not available in Redis Enterprise | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| -| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Might reply with "unknown user" for LDAP users even if `AUTH` succeeds. | | [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL LOAD]({{< relref "/commands/acl-load" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL LOG]({{< relref "/commands/acl-log" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SAVE]({{< relref "/commands/acl-save" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Configuration commands @@ -89,7 +89,7 @@ Although Redis Enterprise does not support certain monitoring commands, you can | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| | [DBSIZE]({{< relref "/commands/dbsize" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | +| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | | [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY GRAPH]({{< relref "/commands/latency-graph" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY HELP]({{< relref "/commands/latency-help" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | @@ -98,15 +98,15 @@ Although Redis Enterprise does not support certain monitoring commands, you can | [LATENCY LATEST]({{< relref "/commands/latency-latest" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY RESET]({{< relref "/commands/latency-reset" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY STATS]({{< relref "/commands/memory-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MONITOR]({{< relref "/commands/monitor" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Persistence commands diff --git a/content/operate/rs/7.8/references/compatibility/commands/server.md b/content/operate/rs/7.8/references/compatibility/commands/server.md index cf22e1588e..fbc74a849d 100644 --- a/content/operate/rs/7.8/references/compatibility/commands/server.md +++ b/content/operate/rs/7.8/references/compatibility/commands/server.md @@ -21,19 +21,19 @@ Several access control list (ACL) commands are not available in Redis Enterprise | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| -| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Might reply with "unknown user" for LDAP users even if `AUTH` succeeds. | | [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL LOAD]({{< relref "/commands/acl-load" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL LOG]({{< relref "/commands/acl-log" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SAVE]({{< relref "/commands/acl-save" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Configuration commands @@ -89,7 +89,7 @@ Although Redis Enterprise does not support certain monitoring commands, you can | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| | [DBSIZE]({{< relref "/commands/dbsize" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | +| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | | [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY GRAPH]({{< relref "/commands/latency-graph" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY HELP]({{< relref "/commands/latency-help" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | @@ -98,15 +98,15 @@ Although Redis Enterprise does not support certain monitoring commands, you can | [LATENCY LATEST]({{< relref "/commands/latency-latest" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY RESET]({{< relref "/commands/latency-reset" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY STATS]({{< relref "/commands/memory-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MONITOR]({{< relref "/commands/monitor" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Persistence commands diff --git a/content/operate/rs/references/compatibility/commands/server.md b/content/operate/rs/references/compatibility/commands/server.md index 1f3dac4bda..cd5800b4fb 100644 --- a/content/operate/rs/references/compatibility/commands/server.md +++ b/content/operate/rs/references/compatibility/commands/server.md @@ -20,19 +20,19 @@ Several access control list (ACL) commands are not available in Redis Enterprise | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| -| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Might reply with "unknown user" for LDAP users even if `AUTH` succeeds. | | [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL HELP]({{< relref "/commands/acl-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL LIST]({{< relref "/commands/acl-list" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | | [ACL LOAD]({{< relref "/commands/acl-load" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL LOG]({{< relref "/commands/acl-log" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SAVE]({{< relref "/commands/acl-save" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL USERS]({{< relref "/commands/acl-users" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Configuration commands @@ -88,7 +88,7 @@ Although Redis Enterprise does not support certain monitoring commands, you can | Command | Redis
Enterprise | Redis
Cloud | Notes | |:--------|:----------------------|:-----------------|:------| | [DBSIZE]({{< relref "/commands/dbsize" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | +| [INFO]({{< relref "/commands/info" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.
Not supported for [scripts]({{}}). | | [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY GRAPH]({{< relref "/commands/latency-graph" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY HELP]({{< relref "/commands/latency-help" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | @@ -97,15 +97,15 @@ Although Redis Enterprise does not support certain monitoring commands, you can | [LATENCY LATEST]({{< relref "/commands/latency-latest" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [LATENCY RESET]({{< relref "/commands/latency-reset" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | | [MEMORY STATS]({{< relref "/commands/memory-stats" >}}) | ❌ Standard
❌ Active-Active | ❌ Standard
❌ Active-Active | | -| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | +| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}) in Redis versions earlier than 7. | | [MONITOR]({{< relref "/commands/monitor" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | | -| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | -| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | +| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | ✅ Standard
✅ Active-Active | ✅ Standard
✅ Active-Active | Not supported for [scripts]({{}}). | ## Persistence commands diff --git a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md index 07d8fb2c32..c652f94a34 100644 --- a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md +++ b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md @@ -53,7 +53,7 @@ This version offers: The following Redis 7.0 features are now supported: -- [Redis functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) +- [Redis functions]({{< relref "/develop/programmability/functions-intro" >}}) In Redis Enterprise Software, [`FUNCTION STATS`]({{< relref "/commands/function-stats" >}}) returns an extra parameter, an array called `all_running_scripts`, to reflect multiple functions running at the same time. From 1f03dab365e9b69470aca27facead883aea0cefe Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 14:24:34 +0100 Subject: [PATCH 7/9] DOC-3967 added aliases to programmability pages --- content/develop/programmability/_index.md | 1 + content/develop/programmability/eval-intro.md | 1 + content/develop/programmability/functions-intro.md | 1 + content/develop/programmability/lua-api.md | 1 + content/develop/programmability/lua-debugging.md | 1 + 5 files changed, 5 insertions(+) diff --git a/content/develop/programmability/_index.md b/content/develop/programmability/_index.md index ec8e4903aa..b8030c0922 100644 --- a/content/develop/programmability/_index.md +++ b/content/develop/programmability/_index.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/programmability description: 'Extending Redis with Lua and Redis Functions ' diff --git a/content/develop/programmability/eval-intro.md b/content/develop/programmability/eval-intro.md index c043c5383b..4ca58a8ac6 100644 --- a/content/develop/programmability/eval-intro.md +++ b/content/develop/programmability/eval-intro.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/programmability/eval-intro description: 'Executing Lua in Redis ' diff --git a/content/develop/programmability/functions-intro.md b/content/develop/programmability/functions-intro.md index d7b2c96fd1..ae5112dc31 100644 --- a/content/develop/programmability/functions-intro.md +++ b/content/develop/programmability/functions-intro.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/programmability/functions-intro description: 'Scripting with Redis 7 and beyond ' diff --git a/content/develop/programmability/lua-api.md b/content/develop/programmability/lua-api.md index 68e77b9068..bba2e6c415 100644 --- a/content/develop/programmability/lua-api.md +++ b/content/develop/programmability/lua-api.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/programmability/lua-api description: 'Executing Lua in Redis ' diff --git a/content/develop/programmability/lua-debugging.md b/content/develop/programmability/lua-debugging.md index ba0e166979..3cc6529944 100644 --- a/content/develop/programmability/lua-debugging.md +++ b/content/develop/programmability/lua-debugging.md @@ -9,6 +9,7 @@ categories: - oss - kubernetes - clients +- aliases: /develop/interact/programmability/lua-debugging description: How to use the built-in Lua debugger linkTitle: Debugging Lua title: Debugging Lua scripts in Redis From a3cd67acacd7f9af5b325c0bbf36ab27c699599f Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 15:01:23 +0100 Subject: [PATCH 8/9] DOC-3967 moved pub/sub and keyspace notification pages --- content/commands/cluster-info.md | 4 +- content/commands/command.md | 2 +- content/commands/psubscribe.md | 2 +- content/commands/spublish.md | 2 +- content/commands/ssubscribe.md | 2 +- content/commands/subscribe.md | 2 +- content/commands/sunsubscribe.md | 2 +- content/develop/clients/nodejs/amr.md | 2 +- content/develop/clients/nodejs/connect.md | 2 +- content/develop/clients/nodejs/migration.md | 2 +- content/develop/interact/_index.md | 87 ------------------- .../{interact/pubsub.md => pubsub/_index.md} | 6 +- .../{use => pubsub}/keyspace-notifications.md | 1 + content/develop/reference/protocol-spec.md | 2 +- content/develop/tools/cli.md | 2 +- content/develop/use/_index.md | 16 ---- .../quickstart/write-behind-guide.md | 2 +- content/operate/_index.md | 4 +- .../triggers-and-functions/Debugging.md | 2 +- .../triggers-and-functions/Quick_Start_CLI.md | 2 +- .../triggers-and-functions/Quick_Start_RI.md | 2 +- .../concepts/triggers/KeySpace_Triggers.md | 2 +- .../gears-v1/register-events.md | 4 +- .../data-access-control/configure-acls.md | 4 +- .../access-control/redis-acl-overview.md | 4 +- .../access-control/redis-acl-overview.md | 4 +- .../rs-7-2-4-releases/rs-7-2-4-52.md | 4 +- .../access-control/redis-acl-overview.md | 4 +- 28 files changed, 37 insertions(+), 137 deletions(-) delete mode 100644 content/develop/interact/_index.md rename content/develop/{interact/pubsub.md => pubsub/_index.md} (99%) rename content/develop/{use => pubsub}/keyspace-notifications.md (99%) delete mode 100644 content/develop/use/_index.md diff --git a/content/commands/cluster-info.md b/content/commands/cluster-info.md index 4b38d899f0..4d83b462c6 100644 --- a/content/commands/cluster-info.md +++ b/content/commands/cluster-info.md @@ -66,13 +66,13 @@ Here are the explanation of these fields: * `cluster_stats_messages_pong_sent` and `cluster_stats_messages_pong_received`: PONG (reply to PING). * `cluster_stats_messages_meet_sent` and `cluster_stats_messages_meet_received`: Handshake message sent to a new node, either through gossip or [`CLUSTER MEET`]({{< relref "/commands/cluster-meet" >}}). * `cluster_stats_messages_fail_sent` and `cluster_stats_messages_fail_received`: Mark node xxx as failing. -* `cluster_stats_messages_publish_sent` and `cluster_stats_messages_publish_received`: Pub/Sub Publish propagation, see [Pubsub]({{< relref "/develop/interact/pubsub#pubsub" >}}). +* `cluster_stats_messages_publish_sent` and `cluster_stats_messages_publish_received`: Pub/Sub Publish propagation, see [Pubsub]({{< relref "/develop/pubsub#pubsub" >}}). * `cluster_stats_messages_auth-req_sent` and `cluster_stats_messages_auth-req_received`: Replica initiated leader election to replace its master. * `cluster_stats_messages_auth-ack_sent` and `cluster_stats_messages_auth-ack_received`: Message indicating a vote during leader election. * `cluster_stats_messages_update_sent` and `cluster_stats_messages_update_received`: Another node slots configuration. * `cluster_stats_messages_mfstart_sent` and `cluster_stats_messages_mfstart_received`: Pause clients for manual failover. * `cluster_stats_messages_module_sent` and `cluster_stats_messages_module_received`: Module cluster API message. -* `cluster_stats_messages_publishshard_sent` and `cluster_stats_messages_publishshard_received`: Pub/Sub Publish shard propagation, see [Sharded Pubsub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}). +* `cluster_stats_messages_publishshard_sent` and `cluster_stats_messages_publishshard_received`: Pub/Sub Publish shard propagation, see [Sharded Pubsub]({{< relref "/develop/pubsub#sharded-pubsub" >}}). More information about the Current Epoch and Config Epoch variables are available in the [Redis Cluster specification document]({{< relref "/operate/oss_and_stack/reference/cluster-spec#cluster-current-epoch" >}}). diff --git a/content/commands/command.md b/content/commands/command.md index 1f18d34fe7..14267822c9 100644 --- a/content/commands/command.md +++ b/content/commands/command.md @@ -103,7 +103,7 @@ Command flags are an array. It can contain the following simple strings (status * **no_mandatory_keys:** the command may accept key name arguments, but these aren't mandatory. * **no_multi:** the command isn't allowed inside the context of a [transaction]({{< relref "/develop/reference/transactions" >}}). * **noscript:** the command can't be called from [scripts]({{< relref "/develop/programmability/eval-intro" >}}) or [functions]({{< relref "/develop/programmability/functions-intro" >}}). -* **pubsub:** the command is related to [Redis Pub/Sub]({{< relref "/develop/interact/pubsub" >}}). +* **pubsub:** the command is related to [Redis Pub/Sub]({{< relref "/develop/pubsub" >}}). * **random**: the command returns random results, which is a concern with verbatim script replication. As of Redis 7.0, this flag is a [command tip][tb]. * **readonly:** the command doesn't modify data. diff --git a/content/commands/psubscribe.md b/content/commands/psubscribe.md index e7856afd56..1794f6ae30 100644 --- a/content/commands/psubscribe.md +++ b/content/commands/psubscribe.md @@ -47,7 +47,7 @@ Use `\` to escape special characters if you want to match them verbatim. Once the client enters the subscribed state it is not supposed to issue any other commands, except for additional [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}), [`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}}), `PSUBSCRIBE`, [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}), [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}), [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}), [`PING`]({{< relref "/commands/ping" >}}), [`RESET`]({{< relref "/commands/reset" >}}) and [`QUIT`]({{< relref "/commands/quit" >}}) commands. However, if RESP3 is used (see [`HELLO`]({{< relref "/commands/hello" >}})) it is possible for a client to issue any commands while in subscribed state. -For more information, see [Pub/sub]({{< relref "/develop/interact/pubsub" >}}). +For more information, see [Pub/sub]({{< relref "/develop/pubsub" >}}). ## Behavior change history diff --git a/content/commands/spublish.md b/content/commands/spublish.md index 700b964c91..db0fa3e493 100644 --- a/content/commands/spublish.md +++ b/content/commands/spublish.md @@ -55,7 +55,7 @@ In Redis Cluster, shard channels are assigned to slots by the same algorithm use A shard message must be sent to a node that owns the slot the shard channel is hashed to. The cluster makes sure that published shard messages are forwarded to all the nodes in the shard, so clients can subscribe to a shard channel by connecting to any one of the nodes in the shard. -For more information about sharded pubsub, see [Sharded Pubsub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}). +For more information about sharded pubsub, see [Sharded Pubsub]({{< relref "/develop/pubsub#sharded-pubsub" >}}). ## Examples diff --git a/content/commands/ssubscribe.md b/content/commands/ssubscribe.md index 0a7b260263..71f0b0503b 100644 --- a/content/commands/ssubscribe.md +++ b/content/commands/ssubscribe.md @@ -53,7 +53,7 @@ Client(s) can subscribe to a node covering a slot (primary/replica) to receive t All the specified shard channels needs to belong to a single slot to subscribe in a given `SSUBSCRIBE` call, A client can subscribe to channels across different slots over separate `SSUBSCRIBE` call. -For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}). +For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/pubsub#sharded-pubsub" >}}). ## Examples diff --git a/content/commands/subscribe.md b/content/commands/subscribe.md index a57a0159da..1ea2aff7c0 100644 --- a/content/commands/subscribe.md +++ b/content/commands/subscribe.md @@ -41,7 +41,7 @@ other commands, except for additional `SUBSCRIBE`, [`SSUBSCRIBE`]({{< relref "/c [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}), [`PING`]({{< relref "/commands/ping" >}}), [`RESET`]({{< relref "/commands/reset" >}}) and [`QUIT`]({{< relref "/commands/quit" >}}) commands. However, if RESP3 is used (see [`HELLO`]({{< relref "/commands/hello" >}})) it is possible for a client to issue any commands while in subscribed state. -For more information, see [Pub/sub]({{< relref "/develop/interact/pubsub" >}}). +For more information, see [Pub/sub]({{< relref "/develop/pubsub" >}}). ## Behavior change history diff --git a/content/commands/sunsubscribe.md b/content/commands/sunsubscribe.md index 1e7aeb34a3..d3696fd4bf 100644 --- a/content/commands/sunsubscribe.md +++ b/content/commands/sunsubscribe.md @@ -54,7 +54,7 @@ In this case a message for every unsubscribed shard channel will be sent to the Note: The global channels and shard channels needs to be unsubscribed from separately. -For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}). +For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/pubsub#sharded-pubsub" >}}). ## Return information diff --git a/content/develop/clients/nodejs/amr.md b/content/develop/clients/nodejs/amr.md index 8a034b9492..99ac088b6a 100644 --- a/content/develop/clients/nodejs/amr.md +++ b/content/develop/clients/nodejs/amr.md @@ -340,7 +340,7 @@ console.log(`Database size is ${size}`); If you are using the [RESP2]({{< relref "/develop/reference/protocol-spec#resp-versions" >}}) protocol, you should -be aware that [pub/sub]({{< relref "/develop/interact/pubsub" >}}) can +be aware that [pub/sub]({{< relref "/develop/pubsub" >}}) can cause complications with reauthentication. After a connection enters PUB/SUB mode, the socket is blocked and can't process diff --git a/content/develop/clients/nodejs/connect.md b/content/develop/clients/nodejs/connect.md index 1f8a26bc62..9092c0eeb6 100644 --- a/content/develop/clients/nodejs/connect.md +++ b/content/develop/clients/nodejs/connect.md @@ -344,7 +344,7 @@ related to connection: - `reconnecting`: (No parameters) The client is about to try reconnecting after the connection was lost due to an error. - `sharded-channel-moved`: The cluster slot of a subscribed - [sharded pub/sub channel]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}) + [sharded pub/sub channel]({{< relref "/develop/pubsub#sharded-pubsub" >}}) has been moved to another shard. Note that when you use a [`RedisCluster`](#connect-to-a-redis-cluster) connection, this event is automatically handled for you. See diff --git a/content/develop/clients/nodejs/migration.md b/content/develop/clients/nodejs/migration.md index a0f36f1eab..110da9289a 100644 --- a/content/develop/clients/nodejs/migration.md +++ b/content/develop/clients/nodejs/migration.md @@ -321,7 +321,7 @@ for await (const keys of client.scanIterator()) { `ioredis` reports incoming pub/sub messages with a `message` event on the client object (see -[Publish/subscribe]({{< relref "/develop/interact/pubsub" >}}) for more +[Publish/subscribe]({{< relref "/develop/pubsub" >}}) for more information about messages): ```js diff --git a/content/develop/interact/_index.md b/content/develop/interact/_index.md deleted file mode 100644 index d74d8d67f8..0000000000 --- a/content/develop/interact/_index.md +++ /dev/null @@ -1,87 +0,0 @@ ---- -categories: -- docs -- develop -- stack -- oss -- rs -- rc -- oss -- kubernetes -- clients -description: 'How to interact with data in Redis, including queries, triggered - functions, transactions, and pub/sub' -linkTitle: Interact with data -title: Interact with data in Redis -hideListLinks: true -weight: 40 ---- - -Redis is useful as a key-value store but also gives you other powerful ways -to interact with your data: - -- [Redis Query Engine](#search-and-query) -- [Programmability](#programmability) -- [Transactions](#transactions) -- [Publish/subscribe](#publishsubscribe) - -## Search and query with the Redis Query Engine - -The [Redis query engine]({{< relref "/develop/ai/search-and-query" >}}) -lets you retrieve data by content rather than by key. You -can [index]({{< relref "/develop/ai/search-and-query/indexing" >}}) -the fields of [hash]({{< relref "/develop/data-types/hashes" >}}) -and [JSON]({{< relref "/develop/data-types/json" >}}) objects -according to their type and then perform sophisticated -[queries]({{< relref "/develop/ai/search-and-query/query" >}}) -on those fields. For example, you can use queries to find: - - matches in - [text fields]({{< relref "/develop/ai/search-and-query/query/full-text" >}}) - - numeric values that fall within a specified - [range]({{< relref "/develop/ai/search-and-query/query/range" >}}) - - [Geospatial]({{< relref "/develop/ai/search-and-query/query/geo-spatial" >}}) - coordinates that fall within a specified area - - [Vector matches]({{< relref "/develop/ai/search-and-query/query/vector-search" >}}) - against [word embeddings](https://en.wikipedia.org/wiki/Word_embedding) calculated from - your text data - -## Programmability - -Redis has an [interface]({{< relref "/develop/interact/programmability" >}}) -for the [Lua programming language](https://www.lua.org/) -that lets you store and execute scripts on the server. Use scripts -to ensure that different clients always update data using the same logic. -You can also reduce network traffic by reimplementing a sequence of -related client-side commands as a single server script. - -## Transactions - -A client will often execute a sequence of commands to make -a set of related changes to data objects. However, another client could also -modify the same data object with similar commands in between. This situation can create -corrupt or inconsistent data. - -Use a [transaction]({{< relref "/develop/interact/transactions" >}}) to -group several commands from a client together as a single unit. The -commands in the transaction are guaranteed to execute in sequence without -interruptions from other clients' commands. - -You can also use the -[`WATCH`]({{< relref "/commands/watch" >}}) command to check for changes -to the keys used in a transaction just before it executes. If the data you -are watching changes while you construct the transaction then -execution safely aborts. Use this feature for efficient -[optimistic concurrency control](https://en.wikipedia.org/wiki/Optimistic_concurrency_control) -in the common case where data is usually accessed only by one client -at a time. - -## Publish/subscribe - -Redis has a [publish/subscribe]({{< relref "/develop/interact/pubsub" >}}) (Pub/sub) -feature that implements the well-known -[design pattern](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) -of the same name. You can *publish* messages from a particular client -connection to a channel maintained by the server. Other connections that have -*subscribed* to the channel will receive the messages in the order you sent them. -Use pub/sub to share small amounts of data among clients easily and -efficiently. diff --git a/content/develop/interact/pubsub.md b/content/develop/pubsub/_index.md similarity index 99% rename from content/develop/interact/pubsub.md rename to content/develop/pubsub/_index.md index 51564d45ae..4a1321c754 100644 --- a/content/develop/interact/pubsub.md +++ b/content/develop/pubsub/_index.md @@ -11,8 +11,10 @@ categories: - clients description: How to use pub/sub channels in Redis linkTitle: Pub/sub -title: Redis Pub/Sub -weight: 40 +title: Redis Pub/sub +aliases: /develop/interact/pubsub +hideListLinks: true +weight: 60 --- [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}), [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}) and [`PUBLISH`]({{< relref "/commands/publish" >}}) implement the [Publish/Subscribe messaging paradigm](http://en.wikipedia.org/wiki/Publish/subscribe) where (citing Wikipedia) senders (publishers) are not programmed to send their messages to specific receivers (subscribers). diff --git a/content/develop/use/keyspace-notifications.md b/content/develop/pubsub/keyspace-notifications.md similarity index 99% rename from content/develop/use/keyspace-notifications.md rename to content/develop/pubsub/keyspace-notifications.md index bfff7d2e99..bac450d123 100644 --- a/content/develop/use/keyspace-notifications.md +++ b/content/develop/pubsub/keyspace-notifications.md @@ -14,6 +14,7 @@ description: 'Monitor changes to Redis keys and values in real time ' linkTitle: Keyspace notifications title: Redis keyspace notifications +aliases: /develop/use/keyspace-notifications weight: 4 --- diff --git a/content/develop/reference/protocol-spec.md b/content/develop/reference/protocol-spec.md index 02dbf1ab93..2441003b96 100644 --- a/content/develop/reference/protocol-spec.md +++ b/content/develop/reference/protocol-spec.md @@ -70,7 +70,7 @@ This is the simplest model possible; however, there are some exceptions: * Redis requests can be [pipelined](#multiple-commands-and-pipelining). Pipelining enables clients to send multiple commands at once and wait for replies later. -* When a RESP2 connection subscribes to a [Pub/Sub]({{< relref "/develop/interact/pubsub" >}}) channel, the protocol changes semantics and becomes a *push* protocol. +* When a RESP2 connection subscribes to a [Pub/Sub]({{< relref "/develop/pubsub" >}}) channel, the protocol changes semantics and becomes a *push* protocol. The client no longer requires sending commands because the server will automatically send new messages to the client (for the channels the client is subscribed to) as soon as they are received. * The [`MONITOR`]({{< relref "/commands/monitor" >}}) command. Invoking the [`MONITOR`]({{< relref "/commands/monitor" >}}) command switches the connection to an ad-hoc push mode. diff --git a/content/develop/tools/cli.md b/content/develop/tools/cli.md index 8430b449da..bc4e274361 100644 --- a/content/develop/tools/cli.md +++ b/content/develop/tools/cli.md @@ -450,7 +450,7 @@ are explained in the next sections: * Monitoring tool to show continuous stats about a Redis server. * Scanning a Redis database for very large keys. * Key space scanner with pattern matching. -* Acting as a [Pub/Sub]({{< relref "/develop/interact/pubsub" >}}) client to subscribe to channels. +* Acting as a [Pub/Sub]({{< relref "/develop/pubsub" >}}) client to subscribe to channels. * Monitoring the commands executed into a Redis instance. * Checking the [latency]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}}) of a Redis server in different ways. * Checking the scheduler latency of the local computer. diff --git a/content/develop/use/_index.md b/content/develop/use/_index.md deleted file mode 100644 index 33b9f80dbd..0000000000 --- a/content/develop/use/_index.md +++ /dev/null @@ -1,16 +0,0 @@ ---- -categories: -- docs -- develop -- stack -- oss -- rs -- rc -- oss -- kubernetes -- clients -description: A developer's guide to Redis -linkTitle: Use Redis -title: Use Redis -weight: 50 ---- diff --git a/content/integrate/write-behind/quickstart/write-behind-guide.md b/content/integrate/write-behind/quickstart/write-behind-guide.md index eaeaf58030..f2e25936ad 100644 --- a/content/integrate/write-behind/quickstart/write-behind-guide.md +++ b/content/integrate/write-behind/quickstart/write-behind-guide.md @@ -158,7 +158,7 @@ The `redis` section is common for every pipeline initiated by an event in Redis, - The `row_format` attribute can be used with the value `full` to receive both the `before` and `after` sections of the payload. Note that for write-behind events the `before` value of the key is never provided. - > Note: Write-behind does not support the [`expired`]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands) event. Therefore, keys that are expired in Redis will not be deleted from the target database automatically. + > Note: Write-behind does not support the [`expired`]({{< relref "/develop/pubsub/keyspace-notifications" >}}#events-generated-by-different-commands) event. Therefore, keys that are expired in Redis will not be deleted from the target database automatically. > Notes: The `redis` attribute is a breaking change replacing the `keyspace` attribute. The `key_pattern` attribute replaces the `pattern` attribute. The `exclude_commands` attributes replaces the `exclude-commands` attribute. If you upgrade to version 0.105 and beyond, you must edit your existing jobs and redeploy them. ### Output section diff --git a/content/operate/_index.md b/content/operate/_index.md index f1e40c8bba..6647c281a5 100644 --- a/content/operate/_index.md +++ b/content/operate/_index.md @@ -35,7 +35,7 @@ hideListLinks: true | | {{}} Redis Cloud | {{}} Redis Software | {{}} Redis Open Source | {{}} Redis for Kubernetes | |:-----------|:--------------|:-----------|:--------------|:--------------| | Monitoring | [Monitor performance]({{< relref "/operate/rc/databases/monitor-performance" >}}) | [Monitoring]({{}}) | [INFO]({{< relref "/commands/info" >}}), [MONITOR]({{< relref "/commands/monitor" >}}), and [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}})
[Analysis with Redis Insight]({{< relref "/develop/tools/insight#database-analysis" >}}) | [Export metrics to Prometheus]({{}}) | -| Logging | [System logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}) | [Logging]({{}}) | `/var/log/redis/redis.log`
[SLOWLOG]({{< relref "/commands/slowlog" >}})
[Keyspace notifications]({{< relref "/develop/use/keyspace-notifications" >}}) | [Logs]({{}}) | +| Logging | [System logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}) | [Logging]({{}}) | `/var/log/redis/redis.log`
[SLOWLOG]({{< relref "/commands/slowlog" >}})
[Keyspace notifications]({{< relref "/develop/pubsub/keyspace-notifications" >}}) | [Logs]({{}}) | | Alerts | [Alerts]({{< relref "/operate/rc/databases/view-edit-database#alerts-section" >}}) | [Alerts and events]({{}}) | [Pub/sub with Redis Sentinel]({{< relref "/operate/oss_and_stack/management/sentinel#pubsub-messages" >}}) | [REDB alertSettings]({{}}) | | Support | [Contact support](https://redis.io/support/) | [Create support package]({{}}) | | [Contact support](https://redis.io/support/) | @@ -50,5 +50,5 @@ hideListLinks: true | Single sign-on (SSO) | [SAML SSO]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) | | | | | Self-signed certificates | | [Certificates]({{}}) | [Certificate configuration]({{< relref "/operate/oss_and_stack/management/security/encryption#certificate-configuration" >}}) | [REC certificates]({{}}) | | Internode encryption | [Encryption at rest]({{< relref "/operate/rc/security/encryption-at-rest" >}}) | [Internode encryption]({{}}) | | [Enable internode encryption]({{}}) | -| Auditing | | [Audit events]({{}}) | [Keyspace notifications]({{< relref "/develop/use/keyspace-notifications" >}}) | | +| Auditing | | [Audit events]({{}}) | [Keyspace notifications]({{< relref "/develop/pubsub/keyspace-notifications" >}}) | | diff --git a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Debugging.md b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Debugging.md index 0387902c00..3a2cc5dca1 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Debugging.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Debugging.md @@ -21,7 +21,7 @@ aliases: There are two methods you can use to debug your Redis Stack functions: 1. Make judicious use of the `redis.log` function, which writes to the Redis log file. -1. Use Redis [pub/sub]({{< relref "/develop/interact/pubsub" >}}). +1. Use Redis [pub/sub]({{< relref "/develop/pubsub" >}}). ### Use `redis.log` diff --git a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_CLI.md b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_CLI.md index 1c49062d23..e8a44968e1 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_CLI.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_CLI.md @@ -98,7 +98,7 @@ redis-cli -x TFUNCTION LOAD REPLACE < ./main.js Functions within Redis can respond to events using keyspace triggers. While the majority of these events are initiated by command invocations, they also include events that occur when a key expires or is removed from the database. -For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}). +For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/pubsub/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}). The following code creates a new keyspace trigger that adds a new field to a new or updated hash with the latest update time. diff --git a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_RI.md b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_RI.md index 35b9b97659..c352222033 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_RI.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_RI.md @@ -59,7 +59,7 @@ Click on the **+ Add Library** button as before and, instead of adding the code Functions within Redis can respond to events using keyspace triggers. While the majority of these events are initiated by command invocations, they also include events that occur when a key expires or is removed from the database. -For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}). +For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/pubsub/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}). The following code creates a new keyspace trigger that adds a new field to a new or updated hash with the latest update time. diff --git a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/KeySpace_Triggers.md b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/KeySpace_Triggers.md index 51fa1f8626..ac570f137f 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/KeySpace_Triggers.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/KeySpace_Triggers.md @@ -22,7 +22,7 @@ Keyspace triggers allow you to register a function that will be executed wheneve 1. Expired: This event is fired when a key expires from the database. 2. Evicted: This event is fired when a key is evicted from the database. -For a complete list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands" >}}). +For a complete list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/pubsub/keyspace-notifications#events-generated-by-different-commands" >}}). To register a keyspace trigger, you need to use the `redis.registerKeySpaceTrigger` API when loading your library. The following example demonstrates how to register a database trigger that adds a "last updated" field whenever a hash key is modified: diff --git a/content/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-events.md b/content/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-events.md index dd81dba2d4..73fd66a5f5 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-events.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-events.md @@ -38,10 +38,10 @@ For more information and examples of event registration, see: ## Event types -For the list of event types you can register on, see the [Redis keyspace notification documentation]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands). +For the list of event types you can register on, see the [Redis keyspace notification documentation]({{< relref "/develop/pubsub/keyspace-notifications" >}}#events-generated-by-different-commands). ## Active-Active event types -In addition to standard Redis [events]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands), [Redis Enterprise Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) also support the registration of RedisGears functions for the following event types: +In addition to standard Redis [events]({{< relref "/develop/pubsub/keyspace-notifications" >}}#events-generated-by-different-commands), [Redis Enterprise Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) also support the registration of RedisGears functions for the following event types: - `change`: This event occurs when a key changes on another replica of the Active-Active database. diff --git a/content/operate/rc/security/access-control/data-access-control/configure-acls.md b/content/operate/rc/security/access-control/data-access-control/configure-acls.md index bbde88e518..aa1c56b51f 100644 --- a/content/operate/rc/security/access-control/data-access-control/configure-acls.md +++ b/content/operate/rc/security/access-control/data-access-control/configure-acls.md @@ -56,7 +56,7 @@ You can define these permissions using the [Redis ACL syntax]({{< relref "/opera - `-` *excludes* commands or command categories - `@` indicates a command category - `~` defines a permitted key pattern -- `&` allows access to a [pub/sub channel]({{< relref "/develop/interact/pubsub" >}}) +- `&` allows access to a [pub/sub channel]({{< relref "/develop/pubsub" >}}) The Redis Cloud console will validate your ACL syntax while you are typing. @@ -116,7 +116,7 @@ For more information on how this works, see the [key permissions syntax]({{< rel ### Pub/sub ACL rules -Pub/sub ACL rules determine which pub/sub channels a user can access. For more information see, [Redis pub/sub]({{< relref "/develop/interact/pubsub" >}}) +Pub/sub ACL rules determine which pub/sub channels a user can access. For more information see, [Redis pub/sub]({{< relref "/develop/pubsub" >}}) For versions older than Redis 7.0, pub/sub is permissive and allows access to all channels by default. diff --git a/content/operate/rs/7.4/security/access-control/redis-acl-overview.md b/content/operate/rs/7.4/security/access-control/redis-acl-overview.md index 29c7179e13..980e0b3665 100644 --- a/content/operate/rs/7.4/security/access-control/redis-acl-overview.md +++ b/content/operate/rs/7.4/security/access-control/redis-acl-overview.md @@ -75,7 +75,7 @@ The following example allows read and write access to all keys that start with " ### Pub/sub channels -The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). +The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). To limit access to specific channels, include `resetchannels` before the allowed channels: @@ -99,7 +99,7 @@ In the following example, the base rule allows `GET key1` and the selector allow ## Default pub/sub permissions -Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access. +Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/pubsub" >}}) a user can access. The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default: diff --git a/content/operate/rs/7.8/security/access-control/redis-acl-overview.md b/content/operate/rs/7.8/security/access-control/redis-acl-overview.md index 1e1523e878..3b5aa4993f 100644 --- a/content/operate/rs/7.8/security/access-control/redis-acl-overview.md +++ b/content/operate/rs/7.8/security/access-control/redis-acl-overview.md @@ -73,7 +73,7 @@ The following example allows read and write access to all keys that start with " ### Pub/sub channels -The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). +The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). To limit access to specific channels, include `resetchannels` before the allowed channels: @@ -97,7 +97,7 @@ In the following example, the base rule allows `GET key1` and the selector allow ## Default pub/sub permissions -Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access. +Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/pubsub" >}}) a user can access. The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default: diff --git a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md index c652f94a34..da04ff9ca7 100644 --- a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md +++ b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md @@ -131,7 +131,7 @@ If you run Redis Stack commands with Redis clients [Go-Redis](https://redis.uptr #### Sharded pub/sub -[Sharded pub/sub]({{< relref "/develop/interact/pubsub" >}}#sharded-pubsub) is now supported. +[Sharded pub/sub]({{< relref "/develop/pubsub" >}}#sharded-pubsub) is now supported. You cannot use sharded pub/sub if you [deactivate RESP3 support]({{< relref "/operate/rs/references/compatibility/resp#deactivate-resp3" >}}). @@ -586,7 +586,7 @@ Certain operating systems, such as RHEL 8, have already removed support for the #### Prepare for restrictive pub/sub permissions -Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access. +Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/pubsub" >}}) a user can access. The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default: diff --git a/content/operate/rs/security/access-control/redis-acl-overview.md b/content/operate/rs/security/access-control/redis-acl-overview.md index 8ce99d2d8d..57410069a9 100644 --- a/content/operate/rs/security/access-control/redis-acl-overview.md +++ b/content/operate/rs/security/access-control/redis-acl-overview.md @@ -72,7 +72,7 @@ The following example allows read and write access to all keys that start with " ### Pub/sub channels -The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). +The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/pubsub" >}}) (only supported for databases with Redis version 6.2 or later). To limit access to specific channels, include `resetchannels` before the allowed channels: @@ -96,7 +96,7 @@ In the following example, the base rule allows `GET key1` and the selector allow ## Default pub/sub permissions -Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access. +Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/pubsub" >}}) a user can access. The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default: From 9fde6894ef3262c98fe9b453e7e416e0049fa005 Mon Sep 17 00:00:00 2001 From: Andy Stark Date: Tue, 1 Jul 2025 15:11:23 +0100 Subject: [PATCH 9/9] DOC-3967 added missing aliases --- content/develop/clients/patterns/_index.md | 1 + content/develop/clients/patterns/bulk-loading.md | 1 + content/develop/clients/patterns/distributed-locks.md | 1 + content/develop/clients/patterns/twitter-clone.md | 1 + content/develop/reference/pipelining.md | 1 + 5 files changed, 5 insertions(+) diff --git a/content/develop/clients/patterns/_index.md b/content/develop/clients/patterns/_index.md index 1471cad7e3..d640b4ca70 100644 --- a/content/develop/clients/patterns/_index.md +++ b/content/develop/clients/patterns/_index.md @@ -12,6 +12,7 @@ categories: description: Novel patterns for working with Redis data structures linkTitle: Coding patterns title: Coding patterns +aliases: /develop/use/patterns weight: 50 --- diff --git a/content/develop/clients/patterns/bulk-loading.md b/content/develop/clients/patterns/bulk-loading.md index d37de3ef08..92c0f532b7 100644 --- a/content/develop/clients/patterns/bulk-loading.md +++ b/content/develop/clients/patterns/bulk-loading.md @@ -14,6 +14,7 @@ description: 'Writing data in bulk using the Redis protocol ' linkTitle: Bulk loading title: Bulk loading +aliases: /develop/use/patterns/bulk-loading weight: 1 --- diff --git a/content/develop/clients/patterns/distributed-locks.md b/content/develop/clients/patterns/distributed-locks.md index e7c0ae9e54..f51467a208 100644 --- a/content/develop/clients/patterns/distributed-locks.md +++ b/content/develop/clients/patterns/distributed-locks.md @@ -14,6 +14,7 @@ description: 'A distributed lock pattern with Redis ' linkTitle: Distributed locks title: Distributed Locks with Redis +aliases: /develop/use/patterns/distributed-locks weight: 1 --- Distributed locks are a very useful primitive in many environments where diff --git a/content/develop/clients/patterns/twitter-clone.md b/content/develop/clients/patterns/twitter-clone.md index 708f3997b0..7dfb6853db 100644 --- a/content/develop/clients/patterns/twitter-clone.md +++ b/content/develop/clients/patterns/twitter-clone.md @@ -12,6 +12,7 @@ categories: description: Learn several Redis patterns by building a Twitter clone linkTitle: Patterns example title: Redis patterns example +aliases: /develop/use/patterns/twitter-clone weight: 20 --- diff --git a/content/develop/reference/pipelining.md b/content/develop/reference/pipelining.md index ac73d4d957..509ced19ed 100644 --- a/content/develop/reference/pipelining.md +++ b/content/develop/reference/pipelining.md @@ -12,6 +12,7 @@ categories: description: How to optimize round-trip times by batching Redis commands linkTitle: Pipelining title: Redis pipelining +aliases: /develop/use/pipelining weight: 2 ---