Debrands RedisJSON

elena-kolevska · elena-kolevska · commit bf23f92a0055 · 2023-07-03T10:53:21.000+01:00
diff --git a/docs/docs/_index.md b/docs/docs/_index.md
@@ -154,7 +154,7 @@ scientific_name = r.json().get('doc', '$..scientific-name')
 
 ### Run with Docker
 
-To run JSON with Docker, use the `redis-stack-server` Docker image:
+To run RedisJSON with Docker, use the `redis-stack-server` Docker image:
 
 ```sh
 $ docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest
@@ -164,19 +164,19 @@ For more information about running Redis Stack in a Docker container, see [Run R
 
 ### Download binaries
 
-To download and run JSON from a precompiled binary:
+To download and run the RedisJSON module that provides the JSON data structure from a precompiled binary:
 
-1. Download a precompiled version of Search and Query from the [Redis download center](https://redis.com/download-center/modules/).
+1. Download a precompiled version from the [Redis download center](https://redis.com/download-center/modules/).
 
-1. Run Redis with JSON:
+2. Load the module it in Redis
 
     ```sh
     $ redis-server --loadmodule /path/to/module/src/rejson.so
     ```
 
 ### Build from source
 
-To build JSON from the source code:
+To build RedisJSON from the source code:
 
 1. Clone the [repository](https://github.com/RedisJSON/RedisJSON) (make sure you include the `--recursive` option to properly clone submodules):
 
@@ -210,7 +210,7 @@ Otherwise, you can invoke
 $ ./deps/readies/bin/getredis
 ```
 
-To load the JSON module, use one of the following methods:
+To load the RedisJSON module, use one of the following methods:
 
 * [Makefile recipe](#makefile-recipe)
 * [Configuration file](#configuration-file)
@@ -219,7 +219,7 @@ To load the JSON module, use one of the following methods:
 
 #### Makefile recipe
 
-Run Redis with JSON:
+Run Redis with RedisJSON:
 
 ```sh
 $ make run
@@ -241,9 +241,9 @@ loadmodule /path/to/module/target/release/librejson.dylib
 
 In the above lines replace `/path/to/module/` with the actual path to the module.
 
-Alternatively, you can download and run JSON from a precompiled binary:
+Alternatively, you can download and run Redis from a precompiled binary:
 
-1. Download a precompiled version of JSON from the [Redis download center](https://redis.com/download-center/modules/).
+1. Download a precompiled version of RedisJSON from the [Redis download center](https://redis.com/download-center/modules/).
 
 #### Command-line option
 
@@ -257,7 +257,7 @@ In the above lines replace `/path/to/module/` with the actual path to the module
 
 #### `MODULE LOAD` command
 
-You can also use the `MODULE LOAD` command to load JSON. Note that `MODULE LOAD` is a **dangerous command** and may be blocked/deprecated in the future due to security considerations.
+You can also use the `MODULE LOAD` command to load RedisJSON. Note that `MODULE LOAD` is a **dangerous command** and may be blocked/deprecated in the future due to security considerations.
 
 After the module has been loaded successfully, the Redis log should have lines similar to:
 
diff --git a/docs/docs/developer.md b/docs/docs/developer.md
@@ -8,10 +8,10 @@ description: >
 
 # Developing Redis JSON
 
-Developing Redis JSON involves setting up the development environment (which can be either Linux-based or macOS-based), building JSON, running tests and benchmarks, and debugging both the JSON module and its tests.
+Developing Redis JSON involves setting up the development environment (which can be either Linux-based or macOS-based), building RedisJSON (the Redis module providing JSON), running tests and benchmarks, and debugging both the JSON module and its tests.
 
 ## Cloning the git repository
-To clone the JSON module and its submodules, run:
+To clone the RedisJSON module and its submodules, run:
 ```sh
 git clone --recursive https://github.com/RedisJSON/RedisJSON.git
 ```
@@ -38,13 +38,13 @@ rejson=$(docker run -d -it -v $PWD:/build redisjson1 bash)
 docker exec -it $rejson bash
 ```
 
-You can replace `debian:bullseye` with your OS of choice. If you use the same OS as your host machine, you can run the JSON binary on your host after it is built.
+You can replace `debian:bullseye` with your OS of choice. If you use the same OS as your host machine, you can run the RedisJSON binary on your host after it is built.
 
 ## Installing prerequisites
 
-To build and test JSON one needs to install several packages, depending on the underlying OS. Currently, we support the Ubuntu/Debian, CentOS, Fedora, and macOS.
+To build and test RedisJSON one needs to install several packages, depending on the underlying OS. Currently, we support the Ubuntu/Debian, CentOS, Fedora, and macOS.
 
-Enter `RedisJSON` directory and run:
+Enter the `RedisJSON` directory and run:
 
 ```sh
 $ ./sbin/setup
@@ -124,13 +124,13 @@ make sanbox        # create container for CLang Sanitizer tests
 ```
 
 ## Building from source
-Run ```make build``` to build JSON.
+Run ```make build``` to build RedisJSON.
 
 Notes:
 
 * Binary files are placed under `target/release/`, according to platform and build variant.
 
-* JSON uses [Cargo](https://github.com/rust-lang/cargo) as its build system. ```make build``` will invoke both Cargo and the subsequent `make` command that's required to complete the build.
+* RedisJSON uses [Cargo](https://github.com/rust-lang/cargo) as its build system. ```make build``` will invoke both Cargo and the subsequent `make` command that's required to complete the build.
 
 Use ```make clean``` to remove built artifacts. ```make clean ALL=1``` will remove the entire bin subdirectory.
 
@@ -154,7 +154,7 @@ $ REDIS_PORT=6379 make test
 ```
 
 ## Debugging
-To include debugging information, you need to set the `DEBUG` environment variable before you compile JSON. For example, run `export DEBUG=1`.
+To include debugging information, you need to set the `DEBUG` environment variable before you compile RedisJSON. For example, run `export DEBUG=1`.
 
 You can add breakpoints to Python tests in single-test mode. To set a breakpoint, call the ```BB()``` function inside a test.
 
diff --git a/docs/docs/indexing_JSON.md b/docs/docs/indexing_JSON.md
@@ -7,6 +7,6 @@ description: Combine Redis JSON and Search and Query to index and search JSON do
 
 In addition to storing JSON documents, you can also index them using the [Search and Query](/docs/stack/search) feature. This enables full-text search capabilities and document retrieval based on their content.
 
-To use these features, you must install two modules: JSON and Search and Query. [Redis Stack](/docs/stack) automatically includes both modules.
+To use these features, you must install two modules: RedisJSON and RediSearch. [Redis Stack](/docs/stack) automatically includes both modules.
 
-See the [tutorial](/docs/stack/search/indexing_json) to learn how to use Search and Query with JSON.
+See the [tutorial](/docs/stack/search/indexing_json) to learn how to search and query your JSON.
diff --git a/docs/docs/path.md b/docs/docs/path.md
@@ -16,7 +16,7 @@ And if multi-paths are used, the return value is a JSON string with a top-level
 
 ## JSONPath support
 
-JSON v2.0 introduced [JSONPath](http://goessner.net/articles/JsonPath/) support. It follows the syntax described by Goessner in his [article](http://goessner.net/articles/JsonPath/).
+RedisJSON v2.0 introduced [JSONPath](http://goessner.net/articles/JsonPath/) support. It follows the syntax described by Goessner in his [article](http://goessner.net/articles/JsonPath/).
 
 A JSONPath query can resolve to several locations in a JSON document. In this case, the JSON commands apply the operation to every possible location. This is a major improvement over [legacy path](#legacy-path-syntax) queries, which only operate on the first path.
 
@@ -248,11 +248,11 @@ JSONPath queries also work with other JSON commands that accept a path as an arg
 
 ## Legacy path syntax
 
-JSON v1 had the following path implementation. JSON v2 still supports this legacy path in addition to JSONPath.
+RedisJSON v1 had the following path implementation. JSON v2 still supports this legacy path in addition to JSONPath.
 
 Paths always begin at the root of a Redis JSON value. The root is denoted by a period character (`.`). For paths that reference the root's children, it is optional to prefix the path with the root.
 
-JSON supports both dot notation and bracket notation for object key access. The following paths refer to _headphones_, which is a child of _inventory_ under the root:
+Redis JSON supports both dot notation and bracket notation for object key access. The following paths refer to _headphones_, which is a child of _inventory_ under the root:
 
 *   `.inventory.headphones`
 *   `inventory["headphones"]`
diff --git a/docs/docs/performance/_index.md b/docs/docs/performance/_index.md
@@ -14,8 +14,7 @@ The following figures were obtained from an AWS EC2 c4.8xlarge instance that ran
 server as well the as the benchmarking tool. Connections to the server are via the networking stack.
 All tests are non-pipelined.
 
-> NOTE: The results below are measured using the preview version of Redis JSON, which is still very much
-unoptimized.
+> NOTE: The results below are measured using the preview version of Redis JSON, which is still very much unoptimized.
 
 ## Redis JSON baseline
 
@@ -97,7 +96,7 @@ performance of the module:
 
 ## Comparison vs. server-side Lua scripting
 
-We compare JSON's performance with Redis' embedded Lua engine. For this purpose, we use the Lua
+We compare Redis Stack's JSON performance with Redis' embedded Lua engine. For this purpose, we use the Lua
 scripts at [/benchmarks/lua](https://github.com/RedisLabsModules/redisjson/tree/master/benchmarks/lua).
 These scripts provide JSON's GET and SET functionality on values stored in JSON or MessagePack
 formats. Each of the different operations (set root, get root, set path and get path) is executed
diff --git a/docs/docs/use_cases.md b/docs/docs/use_cases.md
@@ -10,16 +10,16 @@ aliases:
 
 You can of course use Redis native data structures to store JSON objects, and that's a common practice. For example, you can serialize JSON and save it in a Redis String.
 
-However, RedisJSON provides several benefits over this approach.
+However, Redis JSON provides several benefits over this approach.
 
 **Access and retrieval of subvalues**
 
-With RedisJSON, you can get nested values without having to transmit the entire object over the network. Being able to access sub-objects can lead to greater efficiencies when you're storing large JSON objects in Redis.
+With JSON, you can get nested values without having to transmit the entire object over the network. Being able to access sub-objects can lead to greater efficiencies when you're storing large JSON objects in Redis.
 
 **Atomic partial updates**
 
-RedisJSON allows you to atomically run operations like incrementing a value, adding, or removing elements from an array, append strings, and so on. To do the same with a serialized object, you have to retrieve and then reserialize the entire object, which can be expensive and also lack atomicity.
+JSON allows you to atomically run operations like incrementing a value, adding, or removing elements from an array, append strings, and so on. To do the same with a serialized object, you have to retrieve and then reserialize the entire object, which can be expensive and also lack atomicity.
 
 **Indexing and querying**
 
-When you store JSON objects as Redis strings, there's no good way to query those objects. On the other hand, storing these objects as JSON using RedisJSON lets you index and query them. This is provided by RediSearch.
+When you store JSON objects as Redis strings, there's no good way to query those objects. On the other hand, storing these objects as JSON using Redis Stack lets you index and query them. This is provided by the search and query capabilities of Redis Stack.
