Merge branch 'main' into DOC-4137

Author: cmilesb

content/commands/info/index.md

@@ -515,3 +515,24 @@ It won't be included when `INFO` or `INFO ALL` are called, and it is returned on
 **A note about the word slave used in this man page**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
 
 **Modules generated sections**: Starting with Redis 6, modules can inject their information into the `INFO` command. These are excluded by default even when the `all` argument is provided (it will include a list of loaded modules but not their generated info fields). To get these you must use either the `modules` argument or `everything`.
+
+## Redis Software and Redis Cloud compatibility
+
+| Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:----------------------|:-----------------|:------|
+| <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | In Redis Enterprise, `INFO` returns a different set of fields than Redis Community Edition.<br />Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+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.
+
+Additionally, for JSON keys, Redis implements a “shared string” mechanism to save memory when the same JSON field names or field values of type string are used more than once (either inter-key or intra-key).
+In such cases, instead of storing the field names or values many times, Redis stores them only once. This mechanism is not in place for active-active databases.
+
+On non-active-active databases, `INFO` (Memory > used_memory) reports that the shared memory is counted, but only once for all keys. On active-active databases, there is no shared memory, so if strings are repeated, they are stored multiple times.
+
+**Example**
+
+Suppose you have ten JSON keys, and each key has 5KB of unique content and 5KB of shared content.
+
+For non-active-active databases, `INFO` (used_memory) would report (10 keys * 5KB) + 5KB ~= 55KB. The last term, "+ 5KB", is the size of the shared content.
+
+For active-active databases, `INFO` (used_memory) would report 10 keys * 20KB ~= 200KB. This number includes some amount of CRDB overhead per JSON key.

content/commands/memory-usage/index.md

@@ -87,3 +87,11 @@ OK
 > MEMORY USAGE foo3
 (integer) 160
 ```
+
+## Redis Software and Redis Cloud compatibility
+
+| Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:----------------------|:-----------------|:------|
+|<span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) 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.

content/develop/connect/clients/_index.md

@@ -39,7 +39,8 @@ Redis does not support directly:
 | Language | Client name | Github | Docs |
 | :-- | :-- | :-- | :-- |
 | C | hiredis | https://github.com/redis/hiredis | https://github.com/redis/hiredis |
-| [PHP](https://www.php.net/) | predis | https://github.com/predis/predis | https://github.com/predis/predis/wiki |
+| [PHP](https://www.php.net/) | redis extension | https://github.com/phpredis/phpredis | https://github.com/phpredis/phpredis/blob/develop/README.md |
+| [PHP](https://www.php.net/) | predis library | https://github.com/predis/predis | https://github.com/predis/predis/wiki |
 | [Ruby](https://www.ruby-lang.org/en/) | redis-rb | https://github.com/redis/redis-rb | https://rubydoc.info/gems/redis |
 | [Rust](https://www.rust-lang.org/) | redis-rs | https://github.com/redis-rs/redis-rs | https://docs.rs/redis/latest/redis/ | 
 
@@ -52,4 +53,4 @@ To interact with a Redis server without writing code, use the
 [Redis CLI]({{< relref "/develop/connect/cli" >}}) and
 [Redis Insight]({{< relref "/develop/connect/insight" >}}) tools.
 
-## Client library guides
+## Client library guides

content/develop/connect/insight/_index.md

@@ -159,6 +159,11 @@ These are the locations on supported platforms:
 You can install Redis Insight on operating systems that are not officially supported, but it may not behave as expected.
 {{< /note >}}
 
+## Redis Insight API (only for Docker)
+
+If you are running Redis Insight from [Docker]({{< relref "/operate/redisinsight/install/install-on-docker" >}}),
+you can access the API from `http://localhost:5540/api/docs`.
+
 ## Feedback
 
 To provide your feedback, [open a ticket in our Redis Insight repository](https://github.com/Redis-Insight/Redis-Insight/issues/new).

content/develop/data-types/sorted-sets.md

@@ -57,7 +57,7 @@ As you can see [`ZADD`]({{< relref "/commands/zadd" >}}) is similar to [`SADD`](
 [`ZADD`]({{< relref "/commands/zadd" >}}) is also variadic, so you are free to specify multiple score-value
 pairs, even if this is not used in the example above.
 
-With sorted sets it is trivial to return a list of hackers sorted by their
+With sorted sets it is trivial to return a list of racers sorted by their
 birth year because actually *they are already sorted*.
 
 Implementation note: Sorted sets are implemented via a
@@ -163,7 +163,7 @@ Redis instance will reply with the same output).
 The main commands to operate with lexicographical ranges are [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}),
 [`ZREVRANGEBYLEX`]({{< relref "/commands/zrevrangebylex" >}}), [`ZREMRANGEBYLEX`]({{< relref "/commands/zremrangebylex" >}}) and [`ZLEXCOUNT`]({{< relref "/commands/zlexcount" >}}).
 
-For example, let's add again our list of famous hackers, but this time
+For example, let's add again our list of famous racers, but this time
 using a score of zero for all the elements. We'll see that because of the sorted sets ordering rules, they are already sorted lexicographically. Using [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) we can ask for lexicographical ranges:
 
 {{< clients-example ss_tutorial zadd_lex >}}

content/develop/interact/search-and-query/query/aggregation.md

@@ -46,9 +46,9 @@ Here is a more detailed explanation of the query syntax:
 
 The following example shows you how to calculate a discounted price for new bicycles:
 
-```
+{{< clients-example query_agg agg1 >}}
 FT.AGGREGATE idx:bicycle "@condition:{new}" LOAD 2 "__key" "price" APPLY "@price - (@price * 0.1)" AS "discounted"
-```
+{{< /clients-example >}}
 
 The field `__key` is a built-in field. 
 
@@ -92,9 +92,9 @@ Here is an explanation of the additional constructs:
 
 The following query shows you how to group by the field `condition` and apply a reduction based on the previously derived `price_category`. The expression `@price<1000` causes a bicycle to have the price category `1` if its price is lower than 1000 USD. Otherwise, it has the price category `0`. The output is the number of affordable bicycles grouped by price category.
 
-```
+{{< clients-example query_agg agg2 >}}
 FT.AGGREGATE idx:bicycle "*" LOAD 1 price APPLY "@price<1000" AS price_category GROUPBY 1 @condition REDUCE SUM 1 "@price_category" AS "num_affordable"
-```
+{{< /clients-example >}}
 
 ```
 1) "3"
@@ -123,9 +123,9 @@ You can't use an aggregation function outside of a `GROUPBY` clause, but you can
 
 Here is an example that adds a type attribute `bicycle` to each document before counting all documents with that type:
 
-```
+{{< clients-example query_agg agg3 >}}
 FT.AGGREGATE idx:bicycle "*" APPLY "'bicycle'" AS type GROUPBY 1 @type REDUCE COUNT 0 AS num_total
-```
+{{< /clients-example >}}
 
 The result is:
 
@@ -143,28 +143,28 @@ It's sometimes necessary to group your data without applying a mathematical aggr
 
 The following example shows how to group all bicycles by `condition`:
 
-```
-FT.AGGREGATE idx:bicycle "*" LOAD 1 "__key" GROUPBY 1 "@condition" REDUCE TOLIST 1 "__key" AS bicylces
-```
+{{< clients-example query_agg agg4 >}}
+FT.AGGREGATE idx:bicycle "*" LOAD 1 "__key" GROUPBY 1 "@condition" REDUCE TOLIST 1 "__key" AS bicycles
+{{< /clients-example >}}
 
 The output of this query is:
 
 ```
 1) "3"
 2) 1) "condition"
    1) "refurbished"
-   2) "bicylces"
+   2) "bicycles"
    3) 1) "bicycle:9"
 3) 1) "condition"
    1) "used"
-   2) "bicylces"
+   2) "bicycles"
    3) 1) "bicycle:1"
       1) "bicycle:2"
       2) "bicycle:3"
       3) "bicycle:4"
 4) 1) "condition"
    1) "new"
-   2) "bicylces"
+   2) "bicycles"
    3) 1) "bicycle:0"
       1) "bicycle:5"
       2) "bicycle:6"

content/develop/use/patterns/indexes/index.md

@@ -19,16 +19,36 @@ Redis is not exactly a key-value store, since values can be complex data structu
 
 This document explains how it is possible to create indexes in Redis using the following data structures:
 
+* Hashes and JSON documents, using a variety of field types; used in conjunction with the Redis query engine.
 * Sorted sets to create secondary indexes by ID or other numerical fields.
 * Sorted sets with lexicographical ranges for creating more advanced secondary indexes, composite indexes and graph traversal indexes.
 * Sets for creating random indexes.
 * Lists for creating simple iterable indexes and last N items indexes.
+* Time series with labels.
 
 Implementing and maintaining indexes with Redis is an advanced topic, so most
 users that need to perform complex queries on data should understand if they
 are better served by a relational store. However often, especially in caching
 scenarios, there is the explicit need to store indexed data into Redis in order to speedup common queries which require some form of indexing in order to be executed.
 
+## Hashes and JSON indexes
+
+The Redis query engine provides capabilities to index and query both hash and JSON keys using a variety of field types:
+
+* `TEXT`
+* `TAG`
+* `NUMERIC`
+* `GEO`
+* `VECTOR`
+* `GEOSHAPE`
+
+Once hash or JSON keys have been indexed using the [`FT.CREATE`]({{< baseurl >}}/commands/ft.create) command, all keys that use the prefix defined in the index can be queried using the [`FT.SEARCH`]({{< baseurl >}}/commands/ft.search) and [`FT.AGGREGATE`]({{< baseurl >}}/commands/ft.aggregate) commands.
+
+For more information on creating hash and JSON indexes, see the following pages.
+
+* [Hash indexes]({{< relref "/develop/interact/search-and-query/basic-constructs/schema-definition" >}})
+* [JSON indexes]({{< relref "/develop/interact/search-and-query/indexing" >}})
+
 ## Simple numerical indexes with sorted sets
 
 The simplest secondary index you can create with Redis is by using the
@@ -158,6 +178,14 @@ When representing much larger numbers, you need a different form of indexing
 that is able to index numbers at any precision, called a lexicographical
 index.
 
+## Time series indexes
+
+When you create a new time series using the [`TS.CREATE`]({{< baseurl >}}/commands/ts.create) command, you can associate one or more `LABELS` with it. Each label is a name-value pair, where the both name and value are text. Labels serve as a secondary index that allows you to execute queries on groups of time series keys using various time series commands.
+
+See the [time series quickstart guide]({{< relref "/develop/data-types/timeseries/quickstart#labels" >}}) for an example of creating a time series with a label.
+
+The [`TS.MGET`]({{< baseurl >}}/commands/ts.mget), [`TS.MRANGE`]({{< baseurl >}}/commands/ts.mrange), and [`TS.MREVRANGE`]({{< baseurl >}}/commands/ts.mrevrange) commands operate on multiple time series based on specified labels or using a label-related filter expression. The [`TS.QUERYINDEX`]({{< baseurl >}}/commands/ts.queryindex) command returns all time series keys matching a given label-related filter expression.
+
 ## Lexicographical indexes
 
 Redis sorted sets have an interesting property. When elements are added

content/embeds/rc-tags-tag-module.md

@@ -3,7 +3,7 @@ You can select the tag's **Key** and **Value** from the suggestions, or you can
 {{<image filename="images/rc/tags-new-tag.png" alt="The New tag fields." >}}
 
 A valid tag must follow these guidelines:
-- Tag keys must be between 2 and 64 characters long, and values must be at least 2 characters long.
+- Tag keys must be between 1 and 64 characters long, and values must be at least 1 character long.
 - Tags can only have lowercase letters, numbers, spaces, and these special characters: `-`, `_`, `.`, `+`, `@`, and `:`.
 
 After you add your first tag, you can:

content/integrate/redis-data-integration/data-pipelines/transform-examples/redis-opcode-example.md

@@ -0,0 +1,50 @@
+---
+Title: Add the opcode to the Redis output
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Add the opcode to the Redis output
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 100
+---
+
+In the example below, the data is captured from the source table named `employee` and is written to the Redis database as a JSON document. When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+Here, the result will be Redis JSON documents with fields captured from the source table
+(`employeeid`, `firstname`, `lastname`) and also with
+an extra field `my_opcode` added using the `merge` update strategy (see the
+[JSON job example]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples/redis-json-example" >}})
+for more information). The `opcode` expression refers to the operation code captured from
+the source. This is a database-specific value that indicates which type of operation generated
+the change (insert, update, etc).
+
+```yaml
+source:
+  schema: public
+  table: employee
+  row_format: full
+transform:
+  - uses: add_field
+    with:
+      field: after.my_opcode
+      expression: opcode
+      language: jmespath
+output:
+  - uses: redis.write
+    with:
+      data_type: json
+      mapping:
+        - employeeid
+        - firstname
+        - lastname
+        - my_opcode
+      connection: target
+      on_update: merge
+```

content/integrate/redis-data-integration/faq.md

@@ -22,14 +22,6 @@ weight: 50
 You must purchase a commercial license for RDI with Redis Enterprise. This includes two extra
 Redis Enterprise shards (primary and replica) for the staging database.
 
-## Does RDI have any external dependencies?
-
-RDI is packaged with all of its dependencies except for two dependencies that
-you need if you use IBM Db2 as a source:
-
-- [Db2 JDBC driver](https://www.ibm.com/support/pages/db2-jdbc-driver-versions-and-downloads)
-- [IBM Infopshere Data Replication license](https://www.ibm.com/docs/en/db2/10.5?topic=information-licensing-replication)
-
 ## How does RDI track data changes in the source database?
 
 RDI uses mechanisms that are specific for each of the supported