tag stable 2.4.0

Co-authored-by: Lynn Club <lynncho@live.com>
Co-authored-by: Lynn Club <10293848+lynnclub@users.noreply.github.com>
Co-authored-by: Till Krüss <tillkruss@users.noreply.github.com>

.codespellrc

@@ -0,0 +1,6 @@
+[codespell]
+skip=./.git
+check-hidden=
+check-filenames=
+builtin=clear,rare,informal,usage,code,names
+ignore-words-list=master,masters,slave,slaves,whitelist,cas,exat,smove,SUGGET,sugget,ro,DOF,dof

.coveralls.yml

@@ -0,0 +1 @@
+coverage_clover: build/logs/clover-*.xml

.editorconfig

@@ -0,0 +1,27 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+block_comment_start = /*
+block_comment = *
+block_comment_end = */
+
+[*.php]
+max_line_length = 150
+
+[*.{md,yml,yaml,neon,sh}]
+indent_size = 2
+
+[VERSION]
+insert_final_newline = false
+
+[tests/**.php]
+max_line_length = unset
+
+[{src/ClientInterface.php,src/ClientContextInterface.php}]
+max_line_length = unset

.gitattributes

@@ -0,0 +1,20 @@
+* text=auto
+
+/.github export-ignore
+/bin export-ignore
+/examples export-ignore
+/tests export-ignore
+/.codespellrc export-ignore linguist-language=INI
+/.coveralls.yml export-ignore
+/.editorconfig export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore
+/.php-cs-fixer.dist.php export-ignore
+/CHANGELOG.md export-ignore linguist-documentation
+/CONTRIBUTING.md export-ignore linguist-documentation
+/FAQ.md export-ignore linguist-documentation
+/VERSION export-ignore
+/phpunit.relay.xml export-ignore
+/phpunit.xml.dist export-ignore
+/phpstan.dist.neon export-ignore
+/phpstan-tests.dist.neon export-ignore

.github/CODEOWNERS

@@ -0,0 +1,14 @@
+# Default
+*                                     @tillkruss
+
+# Redis commands
+src/Command/Redis/*                   @predis/team @tillkruss
+
+# Redis Stack
+src/Command/Redis/Json/*              @predis/team
+src/Command/Redis/Search/*            @predis/team
+src/Command/Redis/TopK/*              @predis/team
+src/Command/Redis/TDigest/*           @predis/team
+src/Command/Redis/BloomFilter/*       @predis/team
+src/Command/Redis/CuckooFilter/*      @predis/team
+src/Command/Redis/CountMinSketch/*    @predis/team

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,6 @@
+The Predis code of conduct is derived from the Ruby code of conduct. Any violations of the code of conduct may be reported to [Till Krüss](https://till.im):
+
+- Participants will be tolerant of opposing views.
+- Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+- When interpreting the words and actions of others, participants should always assume good intentions.
+- Behavior that can be reasonably considered harassment will not be tolerated.

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: tillkruss
+custom: "https://www.paypal.me/tillkruss"

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Run command '...'
+2. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Versions (please complete the following information):**
+- Predis: [e.g. 1.1.2]
+- PHP [e.g. 8.0.0]
+- Redis Server [e.g. 6.0.0]
+- OS [e.g. Ubuntu 20.10]
+
+**Code sample**
+If applicable, a small snippet of code that reproduces the issue.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/docker-compose.yml

@@ -0,0 +1,73 @@
+---
+
+services:
+
+  redis-official:
+    image: ${REDIS_IMAGE_NAME:-redis:7.4}
+    container_name: redis-standalone
+    healthcheck:
+      test: [ "CMD", "redis-cli", "PING" ]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    ports:
+      - "6379:6379"
+    profiles:
+      - all
+      - official
+      - standalone
+
+  redis-clients:
+    image: ${REDIS_IMAGE_NAME:-redislabs/client-libs-test:7.4.2}
+    container_name: redis-standalone
+    environment:
+      - TLS_ENABLED=yes
+      - REDIS_CLUSTER=no
+      - PORT=6379
+      - TLS_PORT=6666
+    command: ${REDIS_EXTRA_ARGS:---enable-debug-command yes --enable-module-command yes --tls-auth-clients optional --save ""}
+    ports:
+      - 6379:6379
+      - 6666:6666 # TLS port
+    volumes:
+      - "./dockers/standalone:/redis/work"
+    profiles:
+      - all
+      - clients
+      - standalone
+
+  redis-cluster:
+    image: ${REDIS_IMAGE_NAME:-redislabs/client-libs-test:7.4.2}
+    container_name: redis-cluster
+    environment:
+      - REDIS_CLUSTER=yes
+      - NODES=6
+      - REPLICAS=1
+      - TLS_ENABLED=yes
+      - PORT=16379
+      - TLS_PORT=27379
+    command: ${REDIS_EXTRA_ARGS:---enable-debug-command yes --enable-module-command yes --tls-auth-clients optional --save ""}
+    ports:
+      - "6372-6377:16379-16384"
+    volumes:
+      - "./dockers/cluster:/redis/work"
+    profiles:
+      - all
+      - clients
+      - cluster
+
+  redis-stack:
+    image: ${REDIS_STACK_IMAGE_NAME:-redislabs/client-libs-test:rs-7.4.0-v2}
+    container_name: redis-stack
+    ports:
+      - "6479:6379"
+    environment:
+      - REDIS_CLUSTER=no
+      - PORT=6379
+    command: ${REDIS_EXTRA_ARGS:---enable-debug-command yes --enable-module-command yes --save ""}
+    volumes:
+      - "./dockers/redis-stack:/redis/work"
+    profiles:
+      - all
+      - clients
+      - stack

.github/release-drafter-config.yml

@@ -0,0 +1,49 @@
+name-template: 'v$NEXT_MINOR_VERSION'
+tag-template: 'v$NEXT_MINOR_VERSION'
+change-template: '- $TITLE (#$NUMBER)'
+
+autolabeler:
+  - label: 'maintenance'
+    files:
+      - '*.md'
+      - '.github/*'
+  - label: 'bug'
+    branch:
+      - '/bug-.+'
+  - label: 'maintenance'
+    branch:
+      - '/maintenance-.+'
+  - label: 'feature'
+    branch:
+      - '/feature-.+'
+
+categories:
+  - title: 'Breaking Changes'
+    labels:
+      - 'breakingchange'
+  - title: 'Experimental Features'
+    labels:
+      - 'experimental'
+  - title: 'New Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: 'Bug Fixes'
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+      - 'BUG'
+  - title: 'Maintenance'
+    label: 'maintenance'
+
+exclude-labels:
+  - 'skip-changelog'
+
+template: |
+  $CHANGES
+
+  ## Contributors
+  We'd like to thank all the contributors who worked on this release!
+
+  $CONTRIBUTORS

.github/workflows/README.md

@@ -0,0 +1,9 @@
+# Workflows
+
+## Delete runs by workflow name
+
+```bash
+gh run list --workflow 'redis-server-tests.yml' --limit 1000 --json databaseId \
+  | jq '.[].databaseId' \
+  | xargs -I % gh api --silent -X DELETE /repos/predis/predis/actions/runs/%
+```

.github/workflows/linters.yml

@@ -0,0 +1,196 @@
+# yaml-language-server: $schema=https://json.schemastore.org/github-workflow
+
+name: Linters
+
+on:
+  push:
+    branches:
+      - main
+      - v2.**
+  pull_request: null
+
+permissions: {}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  byte_level:
+    name: Byte-level
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Check file permissions
+        run: test "$(find . -type f -not -path './.git/*' -executable)" = "./bin/create-command-test"
+
+      - name: "Find non-printable ASCII characters"
+        run: |
+          ! LC_ALL=C.UTF-8 find . -type f -name '*.php' -print0 \
+            | xargs --null -- grep --perl-regexp --with-filename --line-number '[^ -~ü]'
+
+  syntax_errors:
+    name: Syntax errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Set up PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.1"
+          coverage: none
+          tools: parallel-lint
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Check source code for syntax errors
+        run: composer exec -- parallel-lint bin/ examples/ src/ tests/
+
+  static_analysis:
+    name: Static Analysis
+    needs:
+      - byte_level
+      - syntax_errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Set up PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.2"
+          coverage: none
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Validate Composer configuration
+        run: composer validate --no-interaction --strict
+
+      - name: Install dependencies
+        uses: ramsey/composer-install@v2
+        with:
+          dependency-versions: highest
+
+      - name: Check PSR-4 mapping
+        run: composer dump-autoload --no-interaction --optimize --strict-psr
+
+      - name: Perform static analysis
+        run: composer run phpstan
+
+      - name: Perform static analysis on tests
+        run: composer run phpstan -- --configuration=phpstan-tests.dist.neon
+
+  coding_standards:
+    name: Coding Standards
+    needs:
+      - byte_level
+      - syntax_errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Set up PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.1"
+          coverage: none
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Check EditorConfig configuration
+        run: test -f .editorconfig
+
+      - name: Check adherence to EditorConfig
+        uses: greut/eclint-action@v0
+
+      - name: Install dependencies
+        uses: ramsey/composer-install@v2
+        with:
+          dependency-versions: highest
+
+      - name: Check coding style
+        run: composer exec -- php-cs-fixer fix --diff --dry-run --allow-risky=yes --using-cache=no
+
+      - name: Search for TODO-s and FIXME-s
+        run: |
+          ! git grep --extended-regexp --ignore-case '\b(TODO|FIXME)\b' -- ':/' ':!tests/*' ':!*/linters\.yml'
+
+  exported_files:
+    name: Exported files
+    needs:
+      - byte_level
+      - syntax_errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Check exported files
+        run: |
+          EXPECTED="LICENSE,README.md,autoload.php,composer.json"
+          CURRENT="$(
+              git archive HEAD \
+                  | tar --list --exclude="src" --exclude="src/*" --exclude="bin" --exclude="bin/*" \
+                  | paste --serial --delimiters=","
+          )"
+          echo "CURRENT =${CURRENT}"
+          echo "EXPECTED=${EXPECTED}"
+          test "${CURRENT}" = "${EXPECTED}"
+
+  spelling:
+    name: Spelling
+    needs:
+      - byte_level
+      - syntax_errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Cache pip
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-codespell
+
+      - name: Install codespell
+        run: pip install --user 'codespell>=2.2'
+
+      - name: Search for misspellings
+        run: $(python -m site --user-base)/bin/codespell
+
+  changelog:
+
+    name: Changelog
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    if: >-
+      github.event_name == 'pull_request' &&
+      !contains(github.event.head_commit.message, 'nochangelog') &&
+      !contains(github.event.head_commit.message, 'no-changelog') &&
+      !contains(github.event.head_commit.message, 'no changelog') &&
+      !contains(github.event.pull_request.labels.*.name, 'no-changelog')
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Check for CHANGELOG entry
+        env:
+          TARGET: ${{ github.event.pull_request.base.ref }}
+        run:  |
+          FILES_CHANGED=$(git diff --name-only origin/$TARGET...HEAD | grep -E 'CHANGELOG\.md' -c)
+          if [ "$FILES_CHANGED" != "1" ]; then
+            echo "CHANGELOG.md was not updated";
+            exit 1;
+          fi;

.github/workflows/release-drafter.yml

@@ -0,0 +1,25 @@
+name: Release Drafter
+
+on:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  update_release_draft:
+
+    name: Update release draft
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - uses: release-drafter/release-drafter@v5
+        with:
+          config-name: release-drafter-config.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/tests.yml

@@ -0,0 +1,183 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+      - v2.**
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  predis:
+    name: PHP ${{ matrix.php }} (Redis ${{ matrix.redis }})
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        php:
+          - '7.2'
+          - '8.0'
+          - '8.3'
+          - '8.4'
+        redis:
+          - '4.0'
+          - '6.2'
+          - '7.2'
+          - '7.4'
+          - '8.0'
+
+    steps:
+
+      - name: Resolve container name
+        run: |
+          # Mapping of original redis versions to client test containers
+          declare -A redis_clients_version_mapping=(
+            ["8.0"]="8.0-RC2-pre"
+            ["7.4"]="7.4.2"
+            ["7.2"]="7.2.7"
+            ["6.2"]="6.2.17"
+          )
+
+          # Mapping of redis version to stack version
+          declare -A redis_stack_version_mapping=(
+            ["7.4"]="rs-7.4.0-v3"
+            ["7.2"]="rs-7.2.0-v15"
+            ["6.2"]="rs-6.2.6-v19"
+          )
+
+          if [[ -v redis_clients_version_mapping[${{ matrix.redis }}] ]]; then
+            echo "REDIS_IMAGE_NAME=redislabs/client-libs-test:${redis_clients_version_mapping[${{ matrix.redis }}]}" >> $GITHUB_ENV
+            echo "REDIS_STACK_IMAGE_NAME=redislabs/client-libs-test:${redis_stack_version_mapping[${{ matrix.redis }}]}" >> $GITHUB_ENV
+            echo "DOCKER_SERVICE=redis-clients" >> $GITHUB_ENV
+
+            redis_major_version=$(echo "${{ matrix.redis }}" | grep -oP '^\d+')
+
+            # Some configuration options available since Redis > 7
+            if (( redis_major_version < 7 )); then
+              echo "REDIS_EXTRA_ARGS="--tls-auth-clients optional --save ''"" >> $GITHUB_ENV
+            else
+              # Since 8.0 modules are bundled with core
+              echo "REDIS_STACK_SERVER_PORT=6379" >> $GITHUB_ENV
+            fi
+
+          else
+            echo "REDIS_IMAGE_NAME=redis:${{ matrix.redis }}" >> $GITHUB_ENV
+            echo "DOCKER_SERVICE=redis-official" >> $GITHUB_ENV
+          fi
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Start Redis standalone image
+        uses: hoverkraft-tech/compose-action@v2.0.1
+        with:
+          compose-file: .github/docker-compose.yml
+          services: ${{ env.DOCKER_SERVICE }}
+
+      - name: Start Redis stack image
+        id: stack_infra
+        uses: hoverkraft-tech/compose-action@v2.0.1
+        if: ${{ matrix.redis >= '6.2' && matrix.redis < '8.0' }}
+        with:
+          compose-file: .github/docker-compose.yml
+          services: redis-stack
+
+      - name: Start Redis cluster image
+        id: cluster_infra
+        uses: hoverkraft-tech/compose-action@v2.0.1
+        if: ${{ matrix.redis > '4.0' }}
+        with:
+          compose-file: .github/docker-compose.yml
+          services: redis-cluster
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          extensions: relay
+          coverage: ${{ (matrix.php == '8.4' && matrix.redis == '7.4') && 'xdebug' || 'none' }}
+
+      - name: Install Composer dependencies
+        uses: ramsey/composer-install@v2
+        with:
+          dependency-versions: highest
+          composer-options: ${{ matrix.php == '8.0' && '--ignore-platform-reqs' || '' }}
+
+      - name: Run tests
+        if: ${{ matrix.php != '8.4' || matrix.redis != '7.4' }}
+        run: vendor/bin/phpunit
+
+      - name: Run tests with coverage
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' }}
+        run: vendor/bin/phpunit --coverage-php build/cov/coverage-predis.cov --coverage-filter ./src
+
+      - name: Run tests using Relay
+        if: ${{ matrix.php != '8.4' && matrix.redis >= '6.2' }}
+        run: vendor/bin/phpunit -c phpunit.relay.xml
+
+      - name: Run tests using Relay with coverage
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' }}
+        run: vendor/bin/phpunit -c phpunit.relay.xml --coverage-php build/cov/coverage-relay.cov --coverage-filter ./src
+
+      - name: Run stack tests
+        if: ${{ (matrix.php != '8.4' || matrix.redis != '7.4') && matrix.redis >= '6.2' }}
+        run: vendor/bin/phpunit --group realm-stack
+
+      - name: Run stack tests with coverage
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' && steps.stack_infra.conclusion == 'success' }}
+        run: vendor/bin/phpunit --group realm-stack --coverage-php build/cov/coverage-stack.cov --coverage-filter ./src
+        env:
+          REDIS_STACK_SERVER_PORT: 6479
+
+      - name: Run stack tests using Relay
+        if: ${{ matrix.php != '8.4' && matrix.redis == '7.4' }}
+        run: vendor/bin/phpunit --group realm-stack -c phpunit.relay.xml
+
+      - name: Run stack tests using Relay with coverage
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' }}
+        run: vendor/bin/phpunit --group realm-stack -c phpunit.relay.xml --coverage-php build/cov/coverage-stack-relay.cov --coverage-filter ./src
+        env:
+          REDIS_STACK_SERVER_PORT: 6479
+
+      - name: Run tests against cluster
+        if: ${{ (matrix.php != '8.4' || matrix.redis != '7.4') && steps.cluster_infra.conclusion == 'success' }}
+        run: |
+          vendor/bin/phpunit --group cluster
+
+      - name: Run tests against cluster with coverage
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' && steps.cluster_infra.conclusion == 'success' }}
+        run: |
+          vendor/bin/phpunit --group cluster --coverage-php build/cov/coverage-cluster.cov --coverage-filter ./src
+
+      - name: Run tests against cluster using Relay
+        if: ${{ matrix.php != '8.4' && matrix.redis == '7.4' }}
+        run: |
+          vendor/bin/phpunit -c phpunit.relay.xml --group cluster
+
+      - name: Merge coverage reports
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' }}
+        run: php vendor/bin/phpcov merge --clover build/logs/clover.xml build/cov
+
+      - name: Send coverage to Coveralls
+        uses: coverallsapp/github-action@v2
+        if: ${{ matrix.php == '8.4' && matrix.redis == '7.4' }}
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          parallel: true
+
+  finish:
+    name: Finish Coverall
+    needs: predis
+    if: ${{ always() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Coveralls Finished
+        uses: coverallsapp/github-action@v2
+        with:
+          parallel-finished: true

.gitignore

@@ -0,0 +1,8 @@
+/build
+/vendor
+.php-version
+.php_cs.cache
+.phpunit.result.cache
+.php-cs-fixer.cache
+composer.lock
+phpunit.xml

.php-cs-fixer.dist.php

@@ -0,0 +1,43 @@
+<?php
+
+$PREDIS_HEADER = <<<EOS
+This file is part of the Predis package.
+
+(c) 2009-2020 Daniele Alessandri
+(c) 2021-2025 Till Krüss
+
+For the full copyright and license information, please view the LICENSE
+file that was distributed with this source code.
+EOS;
+
+$fixer = new PhpCsFixer\Config;
+
+$fixer->setParallelConfig(
+    \PhpCsFixer\Runner\Parallel\ParallelConfigFactory::detect()
+);
+
+$fixer->setRules([
+    '@PHP71Migration' => true,
+    'header_comment' => ['header' => $PREDIS_HEADER],
+    '@Symfony' => true,
+    'phpdoc_separation' => false,
+    'phpdoc_annotation_without_dot' => false,
+    'no_superfluous_phpdoc_tags' => false,
+    'no_unneeded_curly_braces' => false,
+    'no_unneeded_braces' => false,
+    'global_namespace_import' => true,
+    'yoda_style' => false,
+    'single_line_throw' => false,
+    'concat_space' => ['spacing' => 'one'],
+    'increment_style' => false,
+    'trailing_comma_in_multiline' => ['after_heredoc' => true, 'elements' => ['array_destructuring', 'arrays']]
+])
+    ->setFinder(
+        PhpCsFixer\Finder::create()
+            ->in(__DIR__ . '/bin')
+            ->in(__DIR__ . '/examples')
+            ->in(__DIR__ . '/src')
+            ->in(__DIR__ . '/tests')
+    );
+
+return $fixer;

CHANGELOG

@@ -1,185 +0,0 @@
-v0.6.2 (2010-11-28)
-  * Minor internal improvements and clean ups.
-
-  * New commands available in the Redis v2.2 profile (dev):
-      - Strings: STRLEN
-      - Lists  : LINSERT, RPUSHX, LPUSHX
-      - ZSets  : ZREVRANGEBYSCORE
-      - Misc.  : PERSIST
-
-  * WATCH also accepts a single array parameter with the keys that should be 
-    monitored during a transaction.
-
-  * Improved the behaviour of Predis\MultiExecBlock in certain corner cases.
-
-  * Improved parameters checking for the SORT command.
-
-  * FIX: the STORE parameter for the SORT command didn't work correctly when 
-    using '0' as the target key (ISSUE #13).
-
-  * FIX: the methods for UNWATCH and DISCARD do not break anymore method 
-    chaining with Predis\MultiExecBlock.
-
-v0.6.1 (2010-07-11)
-  * Minor internal improvements and clean ups.
-
-  * New commands available in the Redis v2.2 profile (dev):
-      - Misc.  : WATCH, UNWATCH
-
-  * Optional modifiers for ZRANGE, ZREVRANGE and ZRANGEBYSCORE queries are 
-    supported using an associative array passed as the last argument of their 
-    respective methods.
-
-  * The LIMIT modifier for ZRANGEBYSCORE can be specified using either: 
-      - an indexed array: array($offset, $count)
-      - an associative array: array('offset' => $offset, 'count' => $count)
-
-  * The method Predis\Client::__construct() now accepts also instances of 
-    Predis\ConnectionParameters.
-
-  * Predis\MultiExecBlock and Predis\PubSubContext now throw an exception 
-    when trying to create their instances using a profile that does not 
-    support the required Redis commands or when the client is connected to 
-    a cluster of connections.
-
-  * Various improvements to Predis\MultiExecBlock:
-      - fixes and more consistent behaviour across various usage cases.
-      - support for WATCH and UNWATCH when using the current development 
-        profile (Redis v2.2) and aborted transactions.
-
-  * New signature for Predis\Client::multiExec() which is now able to accept 
-    an array of options for the underlying instance of Predis\MultiExecBlock. 
-    Backwards compatibility with previous releases of Predis is ensured.
-
-  * New signature for Predis\Client::pipeline() which is now able to accept 
-    an array of options for the underlying instance of Predis\CommandPipeline. 
-    Backwards compatibility with previous releases of Predis is ensured. 
-    The method Predis\Client::pipelineSafe() is to be considered deprecated.
-
-  * FIX: The WEIGHT modifier for ZUNIONSTORE and ZINTERSTORE was handled 
-    incorrectly with more than two weights specified.
-
-v0.6.0 (2010-05-24)
-  * Switched to the new multi-bulk request protocol for all of the commands 
-    in the Redis 1.2 and Redis 2.0 profiles. Inline and bulk requests are now 
-    deprecated as they will be removed in future releases of Redis.
-
-  * The default server profile is "2.0" (targeting Redis 2.0.x). If you are 
-    using older versions of Redis, it is highly recommended that you specify 
-    which server profile the client should use (e.g. "1.2" when connecting 
-    to instances of Redis 1.2.x).
-
-  * Support for Redis 1.0 is now optional and it is provided by requiring 
-    'Predis_Compatibility.php' before creating an instance of Predis\Client.
-
-  * New commands added to the Redis 2.0 profile since Predis 0.5.1:
-      - Strings: SETEX, APPEND, SUBSTR
-      - ZSets  : ZCOUNT, ZRANK, ZUNIONSTORE, ZINTERSTORE, ZREMBYRANK, ZREVRANK
-      - Hashes : HSET, HSETNX, HMSET, HINCRBY, HGET, HMGET, HDEL, HEXISTS, 
-                 HLEN, HKEYS, HVALS, HGETALL
-      - PubSub : PUBLISH, SUBSCRIBE, UNSUBSCRIBE
-      - Misc.  : DISCARD, CONFIG
-
-  * Introduced client-level options with the new Predis\ClientOptions class. 
-    Options can be passed to Predis\Client::__construct in its second argument 
-    as an array or an instance of Predis\ClientOptions. For brevity's sake and 
-    compatibility with older versions, the constructor of Predis\Client still 
-    accepts an instance of Predis\RedisServerProfile in its second argument.
-    The currently supported client options are:
-      - profile [default: "2.0" as of Predis 0.6.0]
-        specifies which server profile to use when connecting to Redis. This 
-        option accepts an instance of Predis\RedisServerProfile or a string 
-        that indicates the target version.
-      - key_distribution [default: Predis\Distribution\HashRing]
-        specifies which key distribution strategy to use to distribute keys 
-        among the servers that compose a cluster. This option accepts an 
-        instance of Predis\Distribution\IDistributionStrategy so that users 
-        can implement their own key distribution strategy. Optionally, the new 
-        Predis\Distribution\KetamaPureRing class also provides a pure-PHP 
-        implementation of the same algorithm used by libketama.
-      - throw_on_error [default: TRUE]
-        server errors can optionally be handled "silently": instead of throwing 
-        an exception, the client returns an error response type.
-      - iterable_multibulk [EXPERIMENTAL - default: FALSE]
-        in addition to the classic way of fetching a whole multibulk reply 
-        into an array, the client can now optionally stream a multibulk reply 
-        down to the user code by using PHP iterators. It is just a little bit 
-        slower, but it can save a lot of memory in certain scenarios.
-
-  * New parameters for connections: 
-      - alias [default: not set]
-        every connection can now be identified by an alias that is useful to 
-        get a certain connection when connected to a cluster of Redis servers.
-      - weight [default: not set]
-        allows the client to balance the keys asymmetrically across multiple 
-        servers. This might be useful when you have servers with different 
-        amounts of memory and you want to distribute the load of your keys 
-        accordingly.
-      - connection_async [default: FALSE]
-        estabilish connections to servers in a non-blocking way, so that the 
-        client is not blocked while the underlying resource performs the actual 
-        connection.
-      - connection_persistent [default: FALSE]
-        the underlying connection resource is left open when a script ends its 
-        lifecycle. Persistent connections can lead to unpredictable or strange 
-        behaviours, so they should be used with extreme care.
-
-  * Introduced the Predis\Pipeline\IPipelineExecutor interface. Classes that 
-    implements this interface are used internally by the Predis\CommandPipeline 
-    class to change the behaviour of the pipeline when writing/reading commands 
-    from one or multiple servers. Here is the list of the default executors:
-      - Predis\Pipeline\StandardExecutor
-        Exceptions generated by server errors might be thrown depending on the 
-        options passed to the client (see "throw_on_error"). Instead, protocol 
-        or network errors always throw exceptions. This is the default executor 
-        for single and clustered connections and shares the same behaviour of 
-        Predis 0.5.x.
-      - Predis\Pipeline\SafeExecutor
-        Exceptions generated by server, protocol or network errors are not 
-        thrown, instead they are returned in the response array as instances of 
-        ResponseError or CommunicationException.
-      - Predis\Pipeline\SafeClusterExecutor
-        This executor shares the same behaviour of Predis\Pipeline\SafeExecutor 
-        but it is geared towards clustered connections.
-
-  * Support for PUBSUB is handled by the new Predis\PubSubContext class, which 
-    could also be used to build a callback dispatcher for PUBSUB scenarios.
-
-  * When connected to a cluster of connections, it is now possible to get a 
-    new Predis\Client instance for a single connection of the cluster by 
-    passing its alias/index to the new Predis\Client::getClientFor() method.
-
-  * CommandPipeline and MultiExecBlock return their instances when invoking 
-    commands, thus allowing method chaining in pipelines and multi-exec blocks.
-
-  * MultiExecBlock instances can handle the new DISCARD command.
-
-  * Connections now support float values for the connection_timeout parameter 
-    to express timeouts with a microsecond resolution.
-
-  * FIX: TCP connections now respect the read/write timeout parameter when 
-    reading the payload of server responses. Previously, stream_get_contents() 
-    was being used internally to read data from a connection but it looks like 
-    PHP does not honour the specified timeout for socket streams when inside 
-    this function.
-
-  * FIX: The GET parameter for the SORT command now accepts also multiple key 
-    patterns by passing an array of strings. (ISSUE #1).
-
-  * FIX: Replies to the DEL command return the number of elements deleted by 
-    the server and not 0 or 1 interpreted as a boolean response. (ISSUE #4).
-
-v0.5.1 (2010-01-23)
-  * RPOPLPUSH has been changed from bulk command to inline command in Redis
-    1.2.1, so ListPopLastPushHead now extends InlineCommand. The old RPOPLPUSH
-    behavior is still available via the ListPopLastPushHeadBulk class so that
-    you can override the server profile if you need the old (and uncorrect)
-    behaviour when connecting to a Redis 1.2.0 instance.
-
-  * Added missing support for BGREWRITEAOF for Redis >= 1.2.0
-
-  * Implemented a factory method for the RedisServerProfile class to ease the 
-    creation of new server profile instances based on a version string.
-
-v0.5.0 (2010-01-09)
-  * First versioned release of Predis

CHANGELOG.md

@@ -0,0 +1,300 @@
+## Changelog
+
+## v2.4.0 (2025-04-30)
+### Added
+- Added new hash-field expiration commands (#1520)
+- Added missing `FT._LIST` and `BITFIELD_RO` commands (#1521)
+
+### Changed
+- Update `WATCH` command to accept `string|string[]` (#1476)
+- Optimize cluster slotmap with compact slot range object (#1493)
+
+### Fixed
+- Fixed `EVAL_RO` cluster support (#1449)
+- Fixed PHP 8.4 compatibility with `stream_context_set_option()` (#1503)
+- Prevent named arguments runtime failure (#1509)
+- Mark `GEOSEARCH` as read-only to ensure execution on replica (#1481)
+- Fixed protocol loss during redis cluster `MOVED` / `ASK` (#1530)
+
+### Maintenance
+- Added CI testing with Redis 8.0 (#1510)
+- Added test coverage for compatibility with Redis 8.0 (#1513)
+- Use parallel on PHP-CS-Fixer (#1489)
+
+## v2.3.0 (2024-11-21)
+### Added
+- Added `GeoShapeField` field (#1467)
+- Added hash expiration commands (#1456)
+- Added support for time series `IGNORE` filter (#1458)
+- Added `XREAD` commands (#1459)
+- Added `NOVALUES` argument support to `HSCAN` (#1459)
+- Added support for search `INDEXMISSING` and `INDEXEMPTY` arguments (#1464)
+
+### Changed
+- Explicitly mark nullable parameters as nullable (#1448)
+- Filter out available replicas based on link status flag (#1440)
+- Respect `prefix` for `ZPOPMIN`, `ZPOPMAX`, `ZMSCORE`, `LMOVE`, `BLMOVE`, `SMISMEMBER` and `GEOSEARCH` (#1451, #1453, #1455, #1468)
+- Updated test infrastructure (#1510)
+
+### Fixed
+- Fixed Relay support when using Redis Cluster (#1397)
+- Fixed `cmsincrby()` type annotation (#1333)
+- Fixed `set()` type annotation (#1394)
+- Fixed operator precedence in connection factory (#1405)
+- Fixed a bug with `null` arguments in `set()` method (#1470, #1471)
+
+## v2.2.2 (2023-09-13)
+
+### Added
+- Added `client_info` client parameter
+- Added support for `CLUSTER` container command
+
+### Fixed
+- Fixed `EXPIRETIME` not using `prefix`
+- Disabled `CLIENT SETINFO` calls by default
+
+## v2.2.1 (2023-08-15)
+
+### Added
+- Added support for `WAITAOF` command (#1357)
+- Added support for `SHUTDOWN` command (#1359)
+- Added support for `FUNCTION` command (#1332)
+- Added support for new optional `PEXPIRE`, `PEXPIREAT` and `COMMAND`
+- Added missing Redis Stack commands to `KeyPrefixProcessor` (#1358)
+
+### Changed
+- Set client name and version when establishing a connection (#1347)
+
+## v2.2.0 (2023-06-14)
+
+Predis v2.2.0 introduces official support for [Redis Stack](https://redis.io/docs/stack/) as well as a [Relay](https://github.com/cachewerk/relay) integration for substantially [faster read performance](https://github.com/predis/predis/wiki/Using-Relay).
+
+### Added
+- Added support for [Relay](https://github.com/predis/predis/wiki/Using-Relay) (#1263)
+- Added support for `FCALL_RO` command (#1191)
+- Added support for Redis `JSON`, `Bloom`, `Search` and `TimeSeries`  module (#1253)
+- Added support for `ACL SETUSER, GETUSER, DRYRUN` commands (#1193)
+
+### Changed
+- Minor code style and type-hint changes (#1311)
+
+### Fixed
+- Fixed prefixes for `XTRIM` and `XREVRANGE` commands (#1230)
+- Fixed `fclose()` being called on invalid stream resource (#1199)
+- Fixed `BitByte` and `ExpireOptions` traits skip processing on null values (#1169)
+- Fixed missing `@return` annotations (#1265)
+- Fixed `GETDEL` prefixing (#1306)
+
+## v2.1.2 (2023-03-02)
+
+### Added
+- Added stream commands to `KeyPrefixProcessor` (#1051)
+- Added `ReplicationStrategy::$loadBalancing` option to disable replica reads (#1168)
+- Added support for `FCALL` and `FUNCTIONS` commands (#1049)
+- Added support for `PEXPIRETIME` command (#1031)
+- Added support for `EXPIRETIME` command (#1029)
+- Added support for `EVAL_RO` command (#1032)
+- Added support for `LCS` command (#1035)
+- Added support for `SORT_RO` command (#1044)
+- Added support for `SINTERCARD` command (#1027)
+- Added support for `EVALSHA_RO` command (#1034)
+- Added support for new arguments for `BITPOS` and `BITCOUNT` commands (#1045)
+- Added support for new arguments for `EXPIRE` and `EXPIREAT` commands (#1046)
+
+### Bug Fixes
+- Fixed deprecated function call syntax
+
+### Deprecated
+- Further deprecated phpiredis and webdis integration (#1179)
+
+### Maintenance
+- Applied coding standards
+- Pass PHPStan level 2
+
+## v2.1.1 (2023-01-17)
+
+### Bug Fixes
+- Fix `@template` in `Predis\Client` (#1017)
+- Fix support options array in `ZINTERSTORE` and `ZUNIONSTORE` (#1018)
+
+### Deprecated
+- Deprecated phpiredis and webdis connections
+
+## v2.1.0 (2023-01-16)
+
+### New Features
+- Implemented `GETEX` command (#872)
+- Implemented `GETDEL` command (#869)
+- Implemented `COPY` command (#866)
+- Implemented `FAILOVER` command (#875)
+- Implemented `LMOVE` command (#863)
+- Implemented `LMPOP` command (#1013)
+- Implemented `HRANDFIELD` command (#870)
+- Implemented `SMISMEMBER` command (#871)
+- Implemented `ZMPOP` command (#831)
+- Implemented `BLMOVE` command (#865)
+- Implemented `BLMPOP` command (#1015)
+- Implemented `BZMPOP` command (#833)
+- Implemented `BZPOPMIN` command (#862)
+- Implemented `BZPOPMAX` command (#864)
+- Implemented `ZUNION` command (#860)
+- Implemented `ZINTER` command (#859)
+- Implemented `ZINTERCARD` command (#861)
+- Implemented `ZRANGESTORE` command (#829)
+- Implemented `ZDIFFSTORE` command (#828)
+- Implemented `ZDIFF` command (#826)
+- Implemented `ZRANDMEMBER` command (#825)
+- Implemented `ZMSCORE` (#823)
+- Implemented `GEOSEARCH` command (#867)
+- Implemented `GEOSEARCHSTORE` command (#873)
+
+### Bug Fixes
+- Added annotations to suppress PHP 8.1 return type deprecation warning (#810)
+
+### Maintenance
+- Added mixin annotations for traits (#835)
+
+## v2.0.3 (2022-10-11)
+
+- Improved PHP 8.2 support
+- Call `is_resource()` before reading/writing
+- Added partial support for Redis Stream commands
+- Fixed Sentinel authentication issue
+
+## v2.0.2 (2022-09-06)
+
+- Fixed PHP 8.2 deprecation notice: Use of "static" in callables
+
+## v2.0.1 (2022-09-04)
+
+- Added retry interval to `RedisCluster` with a default of `10ms`
+- Avoid PHP 8.2 warning in `Connection\Parameters`
+- Fixed Sentinel reconnect issue in long-running PHP processes
+
+## v2.0.0 (2022-06-08)
+
+- Dropped support for PHP 7.1 and older
+
+- Accepted values for some client options have changed, this is the new list of
+  accepted values:
+
+  - `aggregate`: callable returning an aggregate connection.
+  - `cluster`: string value (`predis`, `redis`), callable returning an aggregate
+    connection.
+  - `replication`: string value (`predis`, `sentinel`), callable returning an
+    aggregate connection.
+  - `commands`: command factory, named array mapping command IDs to PHP classes,
+    callable returning a command factory or a named array.
+  - `connections`: connection factory, callable object returning a connection
+    factory, named array mapping URI schemes to PHP classes, string identifying
+    a supported combination of configurations for the connection factory.
+  - `prefix`: string value, command processor, callable.
+  - `exceptions`: boolean.
+
+  Note that both the `cluster` and `replication` options now return a closure
+  acting as initializer instead of an aggregate connection instance.
+
+- The `connections` client option now accepts certain string values identifying
+  certain combinations of configurations for the connection factory. Currently
+  this is used to provide a short way to configure Predis to load our phpiredis
+  based connection backends simply, accepted values are:
+
+  - `phpiredis-stream` maps `Phpiredis\Connection\PhpiredisStreamConnection` to
+    `tcp`, `redis`, `unix` URI schemes.
+  - `phpiredis-socket` maps `Phpiredis\Connection\PhpiredisSocketConnection` to
+    `tcp`, `redis`, `unix` URI schemes.
+  - `phpiredis-stream` is simply an alias of `phpiredis-stream`.
+
+- Added the new `Predis\Cluster\Hash\PhpiredisCRC16` class using ext-phpiredis
+  to speed-up the generation of the CRC16 hash of keys for redis-cluster. Predis
+  automatically uses this class when ext-phpiredis is loaded, but it is possible
+  to configure the hash generator using the new `crc16` client option (accepted
+  values `predis`, `phpiredis` or an hash generator instance).
+
+- Replication backends now use the `role` parameter instead of `alias` in order
+  to distinguish the role of a connection. Accepted values are `master`, `slave`
+  and, for redis-sentinel, `sentinel`. This led to a redesign of how connections
+  can be retrieved from replication backends: the method getConnectionById() now
+  retrieves a connection only by its ID (ip:port pair), to get a connection by
+  its alias there is the new method getConnectionByAlias(). This method is not
+  supported by the redis-sentinel backend due to its dynamic nature (connections
+  are retrieved and initialized at runtime from sentinels) but it is possible to
+  get a single connection from the pool by using its ID. It is also possible to
+  retrieve a connection by role using the method getConnectionByRole().
+
+- The concept of connection ID (ip:port pair) and connection alias (the `alias`
+  parameter) in `Predis\Connection\Cluster\PredisCluster` has been separated.
+  This change does not affect distribution and it is safe for existing clusters.
+
+- Client option classes now live in the `Predis\Configuration\Option` namespace.
+
+- Classes for Redis commands have been moved into the new `Predis\Command\Redis`
+  namespace and each class name mirrors the respective Redis command ID.
+
+- The concept of server profiles is gone, the library now uses a single command
+  factory to create instances of commands classes. The `profile` option has been
+  replaced by the `commands` option accepting `Predis\Command\FactoryInterface`
+  to customize the underlying command factory. The default command factory class
+  used by Predis is `Predis\Command\RedisFactory` and it still allows developers
+  to define or override commands with their own implementations. In addition to
+  that, `Predis\Command\RedisFactory` relies on a convention-over-configuration
+  approach by looking for a suitable class with the same name as the command ID
+  in the `Predis\Command\Redis` when the internal class map does not contain a
+  class associated.
+
+- The method `Predis\Client::getClientFor($connectionID)` has been replaced by
+  `getClientBy($selector, $value, $callable = null)` which is more flexible as
+  it is not limited to picking a connection from the underlying replication or
+  cluster backend by ID, but allows users to specify a `$selector` that can be
+  either `id` (the old behavior), `key`, `slot` or `command`. The client uses
+  duck-typing instead of type-checking to verify that the underlying connection
+  implements a method that matches the specified selector which means that some
+  selectors may not be available to all kinds of connection backends.
+
+- The method `Predis\Client::getConnectionById($connectionID)` has been removed.
+
+- Changed the signature for the constructor of `Predis\Command\RawCommand`.
+
+- The `Predis\Connection\Aggregate` namespace has been split into two separate
+  namespaces for cluster backends (`Predis\Connection\Cluster`) and replication
+  backends (`Predis\Connection\Replication`).
+
+- The method `Predis\Connection\AggregateConnectionInterface::getConnection()`
+  has been renamed to `getConnectionByCommand()`.
+
+- The methods `switchToMaster()` and `switchToSlave()` have been promoted to be
+  part of `Predis\Connection\Replication\ReplicationInterface` while the method
+  `switchTo($connection)` has been removed from it.
+
+- The method `Predis\Connection\Cluster\PredisCluster::executeCommandOnNodes()`
+  has been removed as it is possible to achieve the same by iterating over the
+  connection or, even better, over the client instance in order to execute the
+  same command against all of the registered connections.
+
+- The class `Predis\CommunicationException` now uses the correct default types
+  for the `$message` (string) and `$code` (integer) parameters.
+
+- The method `onConnectionError()` in `Predis\Connection\AbstractConnection`
+  class now passes the second argument as an integer value `0` as its default
+  value instead of `null`.
+
+- Support Pub/Sub and Pipelines when using replication
+
+- The class `Predis\Transaction\AbortedMultiExecException` now uses the correct
+  default types for the `$code` (integer) parameter.
+
+- __FIX__: using `strval` in `getScanOptions()` method, part of
+  `Predis\Collection\Iterator\CursorBasedIterator` to make sure we retrieve the
+  string value of `$this->match` and not passing `null` to `strlen()` function.
+
+- __FIX__: the value returned from `getArgument()` in `isReadOperation()` method,
+  part of `Predis\Replication\ReplicationStrategy` class, is checked to not pass
+  `null` to `sha1` function.
+
+- __FIX__: the value returned from `getArgument()` in `parseResponse()`method,
+  part of `Predis\Command\Redis\SENTINEL` class, is checked to not pass `null`
+  to `strtolower()` function.
+
+## v2.0.0-beta.1 (2022-05-26)
+
+Same as v2.0.0

FAQ.md

@@ -0,0 +1,97 @@
+# Frequently asked questions about Predis #
+
+## What is the point of Predis? ##
+
+The main point of Predis is about offering a highly customizable and extensible client for Redis,
+that can be easily extended by developers while still being reasonably fast. With Predis you can
+swap almost any class with your own custom implementation: you can have custom connection classes,
+new distribution strategies for client-side sharding, or handlers to replace or add Redis commands.
+All of this can be achieved without messing with the source code of the library and directly in your
+own application. Given the fast pace at which Redis is developed and adds new features, this can be
+a great asset since it allows developers to add new and still missing features or commands or change
+the standard behaviour of the library without the need to break dependencies in production code (at
+least to some degree).
+
+## Does Predis support UNIX domain sockets and persistent connections? ##
+
+Yes. Obviously persistent connections actually work only when using PHP configured as a persistent
+process reused by the web server (see [PHP-FPM](http://php-fpm.org)).
+
+## Does Predis support SSL-encrypted connections? ##
+
+Yes. Encrypted connections are mostly useful when connecting to Redis instances exposed by various
+cloud hosting providers without the need to configure an SSL proxy, but you should also take into
+account the general performances degradation especially during the connect() operation when the TLS
+handshake must be performed to secure the connection. Persistent SSL-encrypted connections may help
+in that respect, but they are supported only when running on PHP >= 7.0.0.
+
+## Does Predis support transparent (de)serialization of values? ##
+
+When using [Relay](https://github.com/cachewerk/relay) as the underlying client, several
+serialization and compression algorithms are supported. This slightly increases CPU usage,
+but significantly reduces bytes sent over the network and Redis memory usage.
+
+Without Relay, Predis will not serialize data and will never do that by default. The reason
+behind this decision is that serialization is usually something that developers prefer to
+customize depending on their needs and can not be easily generalized when using Redis because
+of the many possible access patterns for your data. This does not mean that it is impossible
+to have such a feature since you can leverage the extensibility of this library to define
+your own serialization-aware commands. You can find more details about how to do that
+[on this issue](http://github.com/predis/predis/issues/29#issuecomment-1202624).
+
+## How can I force Predis to connect to Redis before sending any command? ##
+
+Explicitly connecting to Redis is usually not needed since the client initializes connections lazily
+only when they are needed. Admittedly, this behavior can be inconvenient in certain scenarios when
+you absolutely need to perform an upfront check to determine if the server is up and running and
+eventually catch exceptions on failures. Forcing the client to open the underlying connection can be
+done by invoking `Predis\Client::connect()`:
+
+```php
+$client = new Predis\Client();
+
+try {
+    $client->connect();
+} catch (Predis\Connection\ConnectionException $exception) {
+    // We could not connect to Redis! Your handling code goes here.
+}
+
+$client->info();
+```
+
+## How Predis abstracts Redis commands? ##
+
+The approach used to implement Redis commands is quite simple: by default each command follows the
+same signature as defined on the [Redis documentation](http://redis.io/commands) which makes things
+pretty easy if you already know how Redis works or you need to look up how to use certain commands.
+Alternatively, variadic commands can accept an array for keys or values (depending on the command)
+instead of a list of arguments. Commands such as [`RPUSH`](http://redis.io/commands/rpush) and
+[`HMSET`](http://redis.io/commands/hmset) are great examples:
+
+```php
+$client->rpush('my:list', 'value1', 'value2', 'value3');             // plain method arguments
+$client->rpush('my:list', ['value1', 'value2', 'value3']);           // single argument array
+
+$client->hmset('my:hash', 'field1', 'value1', 'field2', 'value2');   // plain method arguments
+$client->hmset('my:hash', ['field1'=>'value1', 'field2'=>'value2']); // single named array
+```
+
+An exception to this rule is [`SORT`](http://redis.io/commands/sort) for which modifiers are passed
+[using a named array](tests/Predis/Command/KeySortTest.php#L54-L75).
+
+## When should I use Relay? ##
+
+If you care about performance, __always__. [Relay][relay] is free to use.
+
+## When should I use PhpRedis? ###
+
+Predis is fast enough when Redis is located on the same machine as PHP.
+
+[PhpRedis][phpredis] and [Relay][relay] perform significantly better when network I/O is involved,
+due to its ability to compress data by ~75%. Fewer bytes and received sent over the network
+[means faster operations][performance], and potentially cost savings when network traffic isn't
+free (e.g. AWS ElastiCache Inter-AZ transfer costs).
+
+[phpredis]: https://github.com/phpredis/phpredis
+[relay]: [https://github.com/phpredis/phpredis](https://github.com/cachewerk/relay)
+[performance]: https://akalongman.medium.com/phpredis-vs-predis-comparison-on-real-production-data-a819b48cbadb

LICENSE

@@ -1,22 +1,22 @@
-Copyright (c) 2009-2010 Daniele Alessandri
+MIT License
 
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
+Copyright (c) 2009-2020 Daniele Alessandri (original work)
+Copyright (c) 2021-2024 Till Krüss (modified work)
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.markdown

@@ -1,141 +0,0 @@
-# Predis #
-
-## About ##
-
-Predis is a flexible and feature-complete PHP client library for the Redis key-value 
-database. It currently comes in two flavors:
-
- - the mainline client library, which targets PHP 5.3.x and leverages a lot of the 
-   features introduced in this new version of the PHP interpreter.
- - a backport to PHP 5.2.x for those who can not upgrade their environment yet 
-   (it admittedly has a lower priority compared to the mainline library, although we 
-   try to keep the two versions aligned as much as possible).
-
-Please refer to the TODO file to see which issues are still pending and what is due 
-to be implemented soon in Predis.
-
-
-## Main features ##
-
-- Full support for Redis 2.0. Different versions of Redis are supported via server profiles.
-- Client-side sharding (support for consistent hashing and custom distribution strategies).
-- Command pipelining on single and multiple connections (transparent).
-- Lazy connections (connections to Redis instances are only established just in time).
-- Flexible system to define and register your own set of commands to a client instance.
-
-
-## Quick examples ##
-
-See the [official wiki](http://wiki.github.com/nrk/predis) of the project for a more 
-complete coverage of all the features available in Predis.
-
-### Connecting to a local instance of Redis ###
-
-You don't have to specify a tcp host and port when connecting to Redis instances 
-running on the localhost on the default port:
-
-    $redis = new Predis\Client();
-    $redis->set('library', 'predis');
-    $value = $redis->get('library');
-
-
-### Pipelining multiple commands to a remote instance of Redis ##
-
-Pipelining helps with performances when there is the need to issue many commands 
-to a server in one go:
-
-    $redis   = new Predis\Client('redis://10.0.0.1:6379/');
-    $replies = $redis->pipeline(function($pipe) {
-        $pipe->ping();
-        $pipe->incrby('counter', 10);
-        $pipe->incrby('counter', 30);
-        $pipe->get('counter');
-    });
-
-
-### Pipelining multiple commands to multiple instances of Redis (sharding) ##
-
-Predis supports data sharding using consistent-hashing on keys on the client side. 
-Furthermore, a pipeline can be initialized on a cluster of redis instances in the 
-same exact way they are created on single connection. Sharding is still transparent 
-to the user:
-
-    $redis = Predis\Client::create(
-        array('host' => '10.0.0.1', 'port' => 6379),
-        array('host' => '10.0.0.2', 'port' => 6379)
-    );
-
-    $replies = $redis->pipeline(function($pipe) {
-        for ($i = 0; $i < 1000; $i++) {
-            $pipe->set("key:$i", str_pad($i, 4, '0', 0));
-            $pipe->get("key:$i");
-        }
-    });
-
-
-### Definition and runtime registration of new commands on the client ###
-
-Let's suppose Redis just added the support for a brand new feature associated 
-with a new command. If you want to start using the above mentioned new feature 
-right away without messing with Predis source code or waiting for it to find 
-its way into a stable Predis release, then you can start off by creating a new 
-class that matches the command type and its behaviour and then bind it to a 
-client instance at runtime. Actually, it is easier done than said:
-
-    class BrandNewRedisCommand extends \Predis\MultiBulkCommand {
-        public function getCommandId() { return 'NEWCMD'; }
-    }
-
-    $redis = new Predis\Client();
-    $redis->getProfile()->registerCommand('BrandNewRedisCommand', 'newcmd');
-    $redis->newcmd();
-
-
-## Development ##
-
-Predis is fully backed up by a test suite which tries to cover all the aspects of the 
-client library and the interaction of every single command with a Redis server. If you 
-want to work on Predis, it is highly recommended that you first run the test suite to 
-be sure that everything is OK, and report strange behaviours or bugs.
-
-The recommended way to contribute to Predis is to fork the project on GitHub, fix or 
-add features on your newly created repository and then submit issues on the Predis 
-issue tracker with a link to your repository. Obviously, you can use any other Git 
-hosting provider of you preference. Diff patches will be accepted too, even though 
-they are not the preferred way to contribute to Predis.
-
-When modifying Predis please be sure that no warnings or notices are emitted by PHP 
-by running the interpreter in your development environment with the "error_reporting"
-variable set to E_ALL | E_STRICT.
-
-
-## Dependencies ##
-
-- PHP >= 5.3.0 (for the mainline client library)
-- PHP >= 5.2.6 (for the backported client library)
-- PHPUnit (needed to run the test suite)
-
-## Links ##
-
-### Project ###
-- [Source code](http://github.com/nrk/predis/)
-- [Wiki](http://wiki.github.com/nrk/predis/)
-- [Issue tracker](http://github.com/nrk/predis/issues)
-
-### Related ###
-- [Redis](http://code.google.com/p/redis/)
-- [PHP](http://php.net/)
-- [PHPUnit](http://www.phpunit.de/)
-- [Git](http://git-scm.com/)
-
-## Author ##
-
-[Daniele Alessandri](mailto:suppakilla@gmail.com)
-
-## Contributors ##
-
-[Lorenzo Castelli](http://github.com/lcastelli)
-
-## License ##
-
-The code for Predis is distributed under the terms of the MIT license (see LICENSE).

README.md

@@ -0,0 +1,466 @@
+# Predis #
+
+[![Software license][ico-license]](LICENSE)
+[![Latest stable][ico-version-stable]][link-releases]
+[![Latest development][ico-version-dev]][link-releases]
+[![Monthly installs][ico-downloads-monthly]][link-downloads]
+[![Build status][ico-build]][link-actions]
+[![Coverage Status][ico-coverage]][link-coverage]
+
+A flexible and feature-complete [Redis](http://redis.io) / [Valkey](https://github.com/valkey-io/valkey) client for PHP 7.2 and newer.
+
+More details about this project can be found on the [frequently asked questions](FAQ.md).
+
+
+## Main features ##
+
+- Support for Redis from __3.0__ to __8.0__.
+- Support for clustering using client-side sharding and pluggable keyspace distributors.
+- Support for [redis-cluster](http://redis.io/topics/cluster-tutorial) (Redis >= 3.0).
+- Support for master-slave replication setups and [redis-sentinel](http://redis.io/topics/sentinel).
+- Transparent key prefixing of keys using a customizable prefix strategy.
+- Command pipelining on both single nodes and clusters (client-side sharding only).
+- Abstraction for Redis transactions (Redis >= 2.0) and CAS operations (Redis >= 2.2).
+- Abstraction for Lua scripting (Redis >= 2.6) and automatic switching between `EVALSHA` or `EVAL`.
+- Abstraction for `SCAN`, `SSCAN`, `ZSCAN` and `HSCAN` (Redis >= 2.8) based on PHP iterators.
+- Connections are established lazily by the client upon the first command and can be persisted.
+- Connections can be established via TCP/IP (also TLS/SSL-encrypted) or UNIX domain sockets.
+- Support for custom connection classes for providing different network or protocol backends.
+- Flexible system for defining custom commands and override the default ones.
+
+
+## How to _install_ and use Predis ##
+
+This library can be found on [Packagist](http://packagist.org/packages/predis/predis) for an easier
+management of projects dependencies using [Composer](http://packagist.org/about-composer).
+Compressed archives of each release are [available on GitHub](https://github.com/predis/predis/releases).
+
+```shell
+composer require predis/predis
+```
+
+
+### Loading the library ###
+
+Predis relies on the autoloading features of PHP to load its files when needed and complies with the
+[PSR-4 standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md).
+Autoloading is handled automatically when dependencies are managed through Composer, but it is also
+possible to leverage its own autoloader in projects or scripts lacking any autoload facility:
+
+```php
+// Prepend a base path if Predis is not available in your "include_path".
+require 'Predis/Autoloader.php';
+
+Predis\Autoloader::register();
+```
+
+
+### Connecting to Redis ###
+
+When creating a client instance without passing any connection parameter, Predis assumes `127.0.0.1`
+and `6379` as default host and port. The default timeout for the `connect()` operation is 5 seconds:
+
+```php
+$client = new Predis\Client();
+$client->set('foo', 'bar');
+$value = $client->get('foo');
+```
+
+Connection parameters can be supplied either in the form of URI strings or named arrays. The latter
+is the preferred way to supply parameters, but URI strings can be useful when parameters are read
+from non-structured or partially-structured sources:
+
+```php
+// Parameters passed using a named array:
+$client = new Predis\Client([
+    'scheme' => 'tcp',
+    'host'   => '10.0.0.1',
+    'port'   => 6379,
+]);
+
+// Same set of parameters, passed using an URI string:
+$client = new Predis\Client('tcp://10.0.0.1:6379');
+```
+
+Password protected servers can be accessed by adding `password` to the parameters set. When ACLs are
+enabled on Redis >= 6.0, both `username` and `password` are required for user authentication.
+
+It is also possible to connect to local instances of Redis using UNIX domain sockets, in this case
+the parameters must use the `unix` scheme and specify a path for the socket file:
+
+```php
+$client = new Predis\Client(['scheme' => 'unix', 'path' => '/path/to/redis.sock']);
+$client = new Predis\Client('unix:/path/to/redis.sock');
+```
+
+The client can leverage TLS/SSL encryption to connect to secured remote Redis instances without the
+need to configure an SSL proxy like stunnel. This can be useful when connecting to nodes running on
+various cloud hosting providers. Encryption can be enabled with using the `tls` scheme and an array
+of suitable [options](http://php.net/manual/context.ssl.php) passed via the `ssl` parameter:
+
+```php
+// Named array of connection parameters:
+$client = new Predis\Client([
+  'scheme' => 'tls',
+  'ssl'    => ['cafile' => 'private.pem', 'verify_peer' => true],
+]);
+
+// Same set of parameters, but using an URI string:
+$client = new Predis\Client('tls://127.0.0.1?ssl[cafile]=private.pem&ssl[verify_peer]=1');
+```
+
+The connection schemes [`redis`](http://www.iana.org/assignments/uri-schemes/prov/redis) (alias of
+`tcp`) and [`rediss`](http://www.iana.org/assignments/uri-schemes/prov/rediss) (alias of `tls`) are
+also supported, with the difference that URI strings containing these schemes are parsed following
+the rules described on their respective IANA provisional registration documents.
+
+The actual list of supported connection parameters can vary depending on each connection backend so
+it is recommended to refer to their specific documentation or implementation for details.
+
+Predis can aggregate multiple connections when providing an array of connection parameters and the
+appropriate option to instruct the client about how to aggregate them (clustering, replication or a
+custom aggregation logic). Named arrays and URI strings can be mixed when providing configurations
+for each node:
+
+```php
+$client = new Predis\Client([
+    'tcp://10.0.0.1?alias=first-node', ['host' => '10.0.0.2', 'alias' => 'second-node'],
+], [
+    'cluster' => 'predis',
+]);
+```
+
+See the [aggregate connections](#aggregate-connections) section of this document for more details.
+
+Connections to Redis are lazy meaning that the client connects to a server only if and when needed.
+While it is recommended to let the client do its own stuff under the hood, there may be times when
+it is still desired to have control of when the connection is opened or closed: this can easily be
+achieved by invoking `$client->connect()` and `$client->disconnect()`. Please note that the effect
+of these methods on aggregate connections may differ depending on each specific implementation.
+
+
+### Client configuration ###
+
+Many aspects and behaviors of the client can be configured by passing specific client options to the
+second argument of `Predis\Client::__construct()`:
+
+```php
+$client = new Predis\Client($parameters, ['prefix' => 'sample:']);
+```
+
+Options are managed using a mini DI-alike container and their values can be lazily initialized only
+when needed. The client options supported by default in Predis are:
+
+  - `prefix`: prefix string applied to every key found in commands.
+  - `exceptions`: whether the client should throw or return responses upon Redis errors.
+  - `connections`: list of connection backends or a connection factory instance.
+  - `cluster`: specifies a cluster backend (`predis`, `redis` or callable).
+  - `replication`: specifies a replication backend (`predis`, `sentinel` or callable).
+  - `aggregate`: configures the client with a custom aggregate connection (callable).
+  - `parameters`: list of default connection parameters for aggregate connections.
+  - `commands`: specifies a command factory instance to use through the library.
+
+Users can also provide custom options with values or callable objects (for lazy initialization) that
+are stored in the options container for later use through the library.
+
+
+### Aggregate connections ###
+
+Aggregate connections are the foundation upon which Predis implements clustering and replication and
+they are used to group multiple connections to single Redis nodes and hide the specific logic needed
+to handle them properly depending on the context. Aggregate connections usually require an array of
+connection parameters along with the appropriate client option when creating a new client instance.
+
+#### Cluster ####
+
+Predis can be configured to work in clustering mode with a traditional client-side sharding approach
+to create a cluster of independent nodes and distribute the keyspace among them. This approach needs
+some sort of external health monitoring of nodes and requires the keyspace to be rebalanced manually
+when nodes are added or removed:
+
+```php
+$parameters = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
+$options    = ['cluster' => 'predis'];
+
+$client = new Predis\Client($parameters);
+```
+
+Along with Redis 3.0, a new supervised and coordinated type of clustering was introduced in the form
+of [redis-cluster](http://redis.io/topics/cluster-tutorial). This kind of approach uses a different
+algorithm to distribute the keyspaces, with Redis nodes coordinating themselves by communicating via
+a gossip protocol to handle health status, rebalancing, nodes discovery and request redirection. In
+order to connect to a cluster managed by redis-cluster, the client requires a list of its nodes (not
+necessarily complete since it will automatically discover new nodes if necessary) and the `cluster`
+client options set to `redis`:
+
+```php
+$parameters = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
+$options    = ['cluster' => 'redis'];
+
+$client = new Predis\Client($parameters, $options);
+```
+
+#### Replication ####
+
+The client can be configured to operate in a single master / multiple slaves setup to provide better
+service availability. When using replication, Predis recognizes read-only commands and sends them to
+a random slave in order to provide some sort of load-balancing and switches to the master as soon as
+it detects a command that performs any kind of operation that would end up modifying the keyspace or
+the value of a key. Instead of raising a connection error when a slave fails, the client attempts to
+fall back to a different slave among the ones provided in the configuration.
+
+The basic configuration needed to use the client in replication mode requires one Redis server to be
+identified as the master (this can be done via connection parameters by setting the `role` parameter
+to `master`) and one or more slaves (in this case setting `role` to `slave` for slaves is optional):
+
+```php
+$parameters = ['tcp://10.0.0.1?role=master', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
+$options    = ['replication' => 'predis'];
+
+$client = new Predis\Client($parameters, $options);
+```
+
+The above configuration has a static list of servers and relies entirely on the client's logic, but
+it is possible to rely on [`redis-sentinel`](http://redis.io/topics/sentinel) for a more robust HA
+environment with sentinel servers acting as a source of authority for clients for service discovery.
+The minimum configuration required by the client to work with redis-sentinel is a list of connection
+parameters pointing to a bunch of sentinel instances, the `replication` option set to `sentinel` and
+the `service` option set to the name of the service:
+
+```php
+$sentinels = ['tcp://10.0.0.1', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
+$options   = ['replication' => 'sentinel', 'service' => 'mymaster'];
+
+$client = new Predis\Client($sentinels, $options);
+```
+
+If the master and slave nodes are configured to require an authentication from clients, a password
+must be provided via the global `parameters` client option. This option can also be used to specify
+a different database index. The client options array would then look like this:
+
+```php
+$options = [
+    'replication' => 'sentinel',
+    'service' => 'mymaster',
+    'parameters' => [
+        'password' => $secretpassword,
+        'database' => 10,
+    ],
+];
+```
+
+While Predis is able to distinguish commands performing write and read-only operations, `EVAL` and
+`EVALSHA` represent a corner case in which the client switches to the master node because it cannot
+tell when a Lua script is safe to be executed on slaves. While this is indeed the default behavior,
+when certain Lua scripts do not perform write operations it is possible to provide an hint to tell
+the client to stick with slaves for their execution:
+
+```php
+$parameters = ['tcp://10.0.0.1?role=master', 'tcp://10.0.0.2', 'tcp://10.0.0.3'];
+$options    = ['replication' => function () {
+    // Set scripts that won't trigger a switch from a slave to the master node.
+    $strategy = new Predis\Replication\ReplicationStrategy();
+    $strategy->setScriptReadOnly($LUA_SCRIPT);
+
+    return new Predis\Connection\Replication\MasterSlaveReplication($strategy);
+}];
+
+$client = new Predis\Client($parameters, $options);
+$client->eval($LUA_SCRIPT, 0);             // Sticks to slave using `eval`...
+$client->evalsha(sha1($LUA_SCRIPT), 0);    // ... and `evalsha`, too.
+```
+
+The [`examples`](examples/) directory contains a few scripts that demonstrate how the client can be
+configured and used to leverage replication in both basic and complex scenarios.
+
+
+### Command pipelines ###
+
+Pipelining can help with performances when many commands need to be sent to a server by reducing the
+latency introduced by network round-trip timings. Pipelining also works with aggregate connections.
+The client can execute the pipeline inside a callable block or return a pipeline instance with the
+ability to chain commands thanks to its fluent interface:
+
+```php
+// Executes a pipeline inside the given callable block:
+$responses = $client->pipeline(function ($pipe) {
+    for ($i = 0; $i < 1000; $i++) {
+        $pipe->set("key:$i", str_pad($i, 4, '0', 0));
+        $pipe->get("key:$i");
+    }
+});
+
+// Returns a pipeline that can be chained thanks to its fluent interface:
+$responses = $client->pipeline()->set('foo', 'bar')->get('foo')->execute();
+```
+
+
+### Transactions ###
+
+The client provides an abstraction for Redis transactions based on `MULTI` and `EXEC` with a similar
+interface to command pipelines:
+
+```php
+// Executes a transaction inside the given callable block:
+$responses = $client->transaction(function ($tx) {
+    $tx->set('foo', 'bar');
+    $tx->get('foo');
+});
+
+// Returns a transaction that can be chained thanks to its fluent interface:
+$responses = $client->transaction()->set('foo', 'bar')->get('foo')->execute();
+```
+
+This abstraction can perform check-and-set operations thanks to `WATCH` and `UNWATCH` and provides
+automatic retries of transactions aborted by Redis when `WATCH`ed keys are touched. For an example
+of a transaction using CAS you can see [the following example](examples/transaction_using_cas.php).
+
+
+### Adding new commands ###
+
+While we try to update Predis to stay up to date with all the commands available in Redis, you might
+prefer to stick with an old version of the library or provide a different way to filter arguments or
+parse responses for specific commands. To achieve that, Predis provides the ability to implement new
+command classes to define or override commands in the default command factory used by the client:
+
+```php
+// Define a new command by extending Predis\Command\Command:
+class BrandNewRedisCommand extends Predis\Command\Command
+{
+    public function getId()
+    {
+        return 'NEWCMD';
+    }
+}
+
+// Inject your command in the current command factory:
+$client = new Predis\Client($parameters, [
+    'commands' => [
+        'newcmd' => 'BrandNewRedisCommand',
+    ],
+]);
+
+$response = $client->newcmd();
+```
+
+There is also a method to send raw commands without filtering their arguments or parsing responses.
+Users must provide the list of arguments for the command as an array, following the signatures as
+defined by the [Redis documentation for commands](http://redis.io/commands):
+
+```php
+$response = $client->executeRaw(['SET', 'foo', 'bar']);
+```
+
+
+### Script commands ###
+
+While it is possible to leverage [Lua scripting](http://redis.io/commands/eval) on Redis 2.6+ using
+directly [`EVAL`](http://redis.io/commands/eval) and [`EVALSHA`](http://redis.io/commands/evalsha),
+Predis offers script commands as an higher level abstraction built upon them to make things simple.
+Script commands can be registered in the command factory used by the client and are accessible as if
+they were plain Redis commands, but they define Lua scripts that get transmitted to the server for
+remote execution. Internally they use [`EVALSHA`](http://redis.io/commands/evalsha) by default and
+identify a script by its SHA1 hash to save bandwidth, but [`EVAL`](http://redis.io/commands/eval)
+is used as a fall back when needed:
+
+```php
+// Define a new script command by extending Predis\Command\ScriptCommand:
+class ListPushRandomValue extends Predis\Command\ScriptCommand
+{
+    public function getKeysCount()
+    {
+        return 1;
+    }
+
+    public function getScript()
+    {
+        return <<<LUA
+math.randomseed(ARGV[1])
+local rnd = tostring(math.random())
+redis.call('lpush', KEYS[1], rnd)
+return rnd
+LUA;
+    }
+}
+
+// Inject the script command in the current command factory:
+$client = new Predis\Client($parameters, [
+    'commands' => [
+        'lpushrand' => 'ListPushRandomValue',
+    ],
+]);
+
+$response = $client->lpushrand('random_values', $seed = mt_rand());
+```
+
+
+### Customizable connection backends ###
+
+Predis can use different connection backends to connect to Redis. The builtin Relay integration
+leverages the [Relay](https://github.com/cachewerk/relay) extension for PHP for major performance
+gains, by caching a partial replica of the Redis dataset in PHP shared runtime memory.
+
+```php
+$client = new Predis\Client('tcp://127.0.0.1', [
+    'connections' => 'relay',
+]);
+```
+
+Developers can create their own connection classes to support whole new network backends, extend
+existing classes or provide completely different implementations. Connection classes must implement
+`Predis\Connection\NodeConnectionInterface` or extend `Predis\Connection\AbstractConnection`:
+
+```php
+class MyConnectionClass implements Predis\Connection\NodeConnectionInterface
+{
+    // Implementation goes here...
+}
+
+// Use MyConnectionClass to handle connections for the `tcp` scheme:
+$client = new Predis\Client('tcp://127.0.0.1', [
+    'connections' => ['tcp' => 'MyConnectionClass'],
+]);
+```
+
+For a more in-depth insight on how to create new connection backends you can refer to the actual
+implementation of the standard connection classes available in the `Predis\Connection` namespace.
+
+
+## Development ##
+
+
+### Reporting bugs and contributing code ###
+
+Contributions to Predis are highly appreciated either in the form of pull requests for new features,
+bug fixes, or just bug reports. We only ask you to adhere to issue and pull request templates.
+
+
+### Test suite ###
+
+__ATTENTION__: Do not ever run the test suite shipped with Predis against instances of Redis running
+in production environments or containing data you are interested in!
+
+Predis has a comprehensive test suite covering every aspect of the library and that can optionally
+perform integration tests against a running instance of Redis (required >= 2.4.0 in order to verify
+the correct behavior of the implementation of each command. Integration tests for unsupported Redis
+commands are automatically skipped. If you do not have Redis up and running, integration tests can
+be disabled. See [the tests README](tests/README.md) for more details about testing this library.
+
+Predis uses GitHub Actions for continuous integration and the history for past and current builds can be
+found [on its actions page](https://github.com/predis/predis/actions).
+
+### License ###
+
+The code for Predis is distributed under the terms of the MIT license (see [LICENSE](LICENSE)).
+
+[ico-license]: https://img.shields.io/github/license/predis/predis.svg?style=flat-square
+[ico-version-stable]: https://img.shields.io/github/v/tag/predis/predis?label=stable&style=flat-square
+[ico-version-dev]: https://img.shields.io/github/v/tag/predis/predis?include_prereleases&label=pre-release&style=flat-square
+[ico-downloads-monthly]: https://img.shields.io/packagist/dm/predis/predis.svg?style=flat-square
+[ico-build]: https://img.shields.io/github/actions/workflow/status/predis/predis/tests.yml?branch=main&style=flat-square
+[ico-coverage]: https://img.shields.io/coverallsCoverage/github/predis/predis?style=flat-square
+
+[link-releases]: https://github.com/predis/predis/releases
+[link-actions]: https://github.com/predis/predis/actions
+[link-downloads]: https://packagist.org/packages/predis/predis/stats
+[link-coverage]: https://coveralls.io/github/predis/predis

TODO

@@ -1,7 +0,0 @@
-* Documentation! The README is obviously not enought to show how to use 
-  Predis as it does not cover all of its features.
-
-* Add more tests targeting specific functions of the library.
-
-* Missing tests for commands: 
-    PUBLISH, SUBSCRIBE, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE

VERSION

@@ -1 +1 @@
-0.6.2
+2.4.0

autoload.php

@@ -0,0 +1,12 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__.'/src/Autoloader.php';
+
+Predis\Autoloader::register();

bin/create-command-test

@@ -0,0 +1,274 @@
+#!/usr/bin/env php
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+// -------------------------------------------------------------------------- //
+// This script can be used to automatically generate a file with the scheleton
+// of a test case to test a Redis command by specifying the name of the class
+// in the Predis\Command namespace (only classes in this namespace are valid).
+// For example, to generate a test case for SET (which is represented by the
+// Predis\Command\Redis\StringSet class):
+//
+//   $ ./bin/generate-command-test --class=StringSet
+//
+// Here is a list of optional arguments:
+//
+// --realm: each command has its own realm (commands that operate on strings,
+// lists, sets and such) but while this realm is usually inferred from the name
+// of the specified class, sometimes it can be useful to override it with a
+// custom one.
+//
+// --output: write the generated test case to the specified path instead of
+// the default one.
+//
+// --overwrite: pre-existing test files are not overwritten unless this option
+// is explicitly specified.
+// -------------------------------------------------------------------------- //
+
+use Predis\Command\CommandInterface;
+use Predis\Command\PrefixableCommandInterface;
+
+class CommandTestCaseGenerator
+{
+    private $options;
+
+    public function __construct(array $options)
+    {
+        if (!isset($options['class'])) {
+            throw new RuntimeException("Missing 'class' option.");
+        }
+
+        if (!isset($options['realm'])) {
+            throw new RuntimeException("Missing 'realm' option.");
+        }
+
+        $this->options = $options;
+    }
+
+    public static function fromCommandLine()
+    {
+        $parameters = array(
+            'c:'  => 'class:',
+            'r::' => 'realm::',
+            'o::' => 'output::',
+            'x::' => 'overwrite::'
+        );
+
+        $getops = getopt(implode(array_keys($parameters)), $parameters);
+
+        $options = array(
+            'overwrite' => false,
+            'tests' => __DIR__.'/../tests/Predis',
+        );
+
+        foreach ($getops as $option => $value) {
+            switch ($option) {
+                case 'c':
+                case 'class':
+                    $options['class'] = $value;
+                    break;
+
+                case 'r':
+                case 'realm':
+                    $options['realm'] = $value;
+                    break;
+
+                case 'o':
+                case 'output':
+                    $options['output'] = $value;
+                    break;
+
+                case 'x':
+                case 'overwrite':
+                    $options['overwrite'] = true;
+                    break;
+            }
+        }
+
+        if (!isset($options['class'])) {
+            throw new RuntimeException("Missing 'class' option.");
+        }
+
+        if (!isset($options['realm'])) {
+            throw new RuntimeException("Missing 'realm' option.");
+        }
+
+        $options['fqn'] = "Predis\\Command\\Redis\\{$options['class']}";
+        $options['path'] = "Command/Redis/{$options['class']}.php";
+
+        $source = __DIR__.'/../src/'.$options['path'];
+        if (!file_exists($source)) {
+            throw new RuntimeException("Cannot find class file for {$options['fqn']} in $source.");
+        }
+
+        if (!isset($options['output'])) {
+            $options['output'] = sprintf("%s/%s", $options['tests'], str_replace('.php', '_Test.php', $options['path']));
+        }
+
+        return new self($options);
+    }
+
+    protected function getTestRealm()
+    {
+        if (empty($this->options['realm'])) {
+            throw new RuntimeException('Invalid value for realm has been specified (empty).');
+        }
+
+        return $this->options['realm'];
+    }
+
+    public function generate()
+    {
+        $reflection = new ReflectionClass($class = $this->options['fqn']);
+
+        if (!$reflection->isInstantiable()) {
+            throw new RuntimeException("Class $class must be instantiable, abstract classes or interfaces are not allowed.");
+        }
+
+        if (!$reflection->implementsInterface('Predis\Command\CommandInterface')) {
+            throw new RuntimeException("Class $class must implement Predis\Command\CommandInterface.");
+        }
+
+        /*
+         * @var CommandInterface
+         */
+        $instance = $reflection->newInstance();
+
+        $buffer = $this->getTestCaseBuffer($instance);
+
+        return $buffer;
+    }
+
+    public function save()
+    {
+        $options = $this->options;
+        if (file_exists($options['output']) && !$options['overwrite']) {
+            throw new RuntimeException("File {$options['output']} already exist. Specify the --overwrite option to overwrite the existing file.");
+        }
+        file_put_contents($options['output'], $this->generate());
+    }
+
+    protected function getTestCaseBuffer(CommandInterface $instance)
+    {
+        $id = $instance->getId();
+        $fqn = get_class($instance);
+        $fqnParts = explode('\\', $fqn);
+        $class = array_pop($fqnParts) . "Test";
+        $realm = $this->getTestRealm();
+
+        $buffer =<<<PHP
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis\Command\Redis;
+
+/**
+ * @group commands
+ * @group realm-$realm
+ */
+class $class extends PredisCommandTestCase
+{
+    /**
+     * {@inheritdoc}
+     */
+    protected function getExpectedCommand(): string
+    {
+        return '$fqn';
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getExpectedId(): string
+    {
+        return '$id';
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testFilterArguments(): void
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$arguments = array(/* add arguments */);
+        \$expected = array(/* add arguments */);
+
+        \$command = \$this->getCommand();
+        \$command->setArguments(\$arguments);
+
+        \$this->assertSame(\$expected, \$command->getArguments());
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testParseResponse(): void
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$raw = null;
+        \$expected = null;
+
+        \$command = \$this->getCommand();
+
+        \$this->assertSame(\$expected, \$command->parseResponse(\$raw));
+    }
+
+PHP;
+
+        if ($instance instanceof PrefixableCommandInterface) {
+            $buffer .=<<<PHP
+
+    /**
+     * @group disconnected
+     */
+    public function testPrefixKeys(): void
+    {
+        \$this->markTestIncomplete('This test has not been implemented yet.');
+
+        \$arguments = array(/* add arguments */);
+        \$expected = array(/* add arguments */);
+
+        \$command = \$this->getCommandWithArgumentsArray(\$arguments);
+        \$command->prefixKeys('prefix:');
+
+        \$this->assertSame(\$expected, \$command->getArguments());
+    }
+
+    /**
+     * @group disconnected
+     */
+    public function testPrefixKeysIgnoredOnEmptyArguments(): void
+    {
+        \$command = \$this->getCommand();
+        \$command->prefixKeys('prefix:');
+
+        \$this->assertSame(array(), \$command->getArguments());
+    }
+
+PHP;
+        }
+
+        return "$buffer}\n";
+    }
+}
+
+// ------------------------------------------------------------------------- //
+
+require __DIR__.'/../autoload.php';
+
+$generator = CommandTestCaseGenerator::fromCommandLine();
+$generator->save();

composer.json

@@ -0,0 +1,52 @@
+{
+    "name": "predis/predis",
+    "type": "library",
+    "description": "A flexible and feature-complete Redis/Valkey client for PHP.",
+    "keywords": ["nosql", "redis", "predis"],
+    "homepage": "http://github.com/predis/predis",
+    "license": "MIT",
+    "support": {
+        "issues": "https://github.com/predis/predis/issues"
+    },
+    "authors": [
+        {
+            "name": "Till Krüss",
+            "homepage": "https://till.im",
+            "role": "Maintainer"
+        }
+    ],
+    "funding": [
+        {
+            "type": "github",
+            "url": "https://github.com/sponsors/tillkruss"
+        }
+    ],
+    "require": {
+        "php": "^7.2 || ^8.0"
+    },
+    "require-dev": {
+        "friendsofphp/php-cs-fixer": "^3.3",
+        "phpstan/phpstan": "^1.9",
+        "phpunit/phpunit": "^8.0 || ^9.4",
+        "phpunit/phpcov": "^6.0 || ^8.0"
+    },
+    "suggest": {
+        "ext-relay": "Faster connection with in-memory caching (>=0.6.2)"
+    },
+    "scripts": {
+        "phpstan": "phpstan analyse",
+        "style": "php-cs-fixer fix --diff --dry-run",
+        "style:fix": "php-cs-fixer fix"
+    },
+    "autoload": {
+        "psr-4": {
+            "Predis\\": "src/"
+        }
+    },
+    "config": {
+        "sort-packages": true,
+        "preferred-install": "dist"
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true
+}

examples/CommandPipeline.php

@@ -1,38 +0,0 @@
-<?php
-require_once 'SharedConfigurations.php';
-
-// When you have a whole set of consecutive commands to send to 
-// a redis server, you can use a pipeline to improve performances.
-
-$redis = new Predis\Client($single_server);
-
-$replies = $redis->pipeline(function($pipe) {
-    $pipe->ping();
-    $pipe->flushdb();
-    $pipe->incrby('counter', 10);
-    $pipe->incrby('counter', 30);
-    $pipe->exists('counter');
-    $pipe->get('counter');
-    $pipe->mget('does_not_exist', 'counter');
-});
-
-print_r($replies);
-
-/* OUTPUT:
-Array
-(
-    [0] => 1
-    [1] => 1
-    [2] => 10
-    [3] => 40
-    [4] => 1
-    [5] => 40
-    [6] => Array
-        (
-            [0] => 
-            [1] => 40
-        )
-
-)
-*/
-?>

examples/Commands/Json/json_debug_memory.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of JSON.DEBUG command usage:
+
+// 1. Set JSON object
+$client = new Client();
+
+$client->jsonset('key', '$', '{"key1":"value1","key2":"value2"}');
+
+// 2. Dump information about json memory usage in bytes
+$response = $client->jsondebug->memory('key', '$');
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_aggregate.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\AggregateArguments;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SchemaFields\AbstractField;
+use Predis\Command\Argument\Search\SchemaFields\NumericField;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.AGGREGATE command usage:
+
+// 1. Create index
+$client = new Client();
+
+$ftCreateArguments = (new CreateArguments())->prefix(['user:']);
+$schema = [
+    new TextField('name'),
+    new TextField('country'),
+    new NumericField('dob', '', AbstractField::SORTABLE),
+];
+
+$client->ftcreate('idx', $schema, $ftCreateArguments);
+
+// 2. Add documents
+$client->hset('user:0', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+$client->hset('user:1', 'name', 'Vlad', 'country', 'Israel', 'dob', 782265600);
+$client->hset('user:2', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+
+// 3. Execute aggregation query
+$ftAggregateArguments = (new AggregateArguments())
+    ->apply('year(@dob)', 'birth')
+    ->groupBy('@country', '@birth')
+    ->reduce('COUNT', true, 'country_birth_Vlad_count')
+    ->sortBy(0, '@birth', 'DESC');
+
+$response = $client->ftaggregate('idx', '@name: "Vlad"', $ftAggregateArguments);
+
+// Response grouped by user country and birth year, with users count in each group, sorted by birth year from DESC.
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_alter.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.ALTER command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_alter', $schema);
+
+echo 'Default index attributes:' . "\n";
+$defaultAttributes = $client->ftinfo('index_alter');
+print_r($defaultAttributes[7]);
+
+// 2. Add additional attribute to existing index
+$schema = [
+    new TextField('new_field_name'),
+];
+
+$client->ftalter('index_alter', $schema);
+
+echo 'Updated index attributes:' . "\n";
+$updatedAttributes = $client->ftinfo('index_alter');
+print_r($updatedAttributes[7]);

examples/Commands/Search/ft_config_help.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.CONFIG HELP command usage:
+
+// 1. Dump helpful information about FT.CONFIG MAXEXPANSIONS option
+$client = new Client();
+
+echo 'Response:' . "\n";
+print_r(
+    $client->ftconfig->help('MAXEXPANSIONS')
+);

examples/Commands/Search/ft_config_set_get.php

@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.CONFIG SET command usage:
+
+// 1. Change default timeout setting
+$client = new Client();
+
+echo 'Response:' . "\n";
+
+print_r(
+    $client->ftconfig->set('TIMEOUT', 42)
+);
+print_r(
+    $client->ftconfig->get('TIMEOUT')
+);

examples/Commands/Search/ft_cursor_del.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\AggregateArguments;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SchemaFields\AbstractField;
+use Predis\Command\Argument\Search\SchemaFields\NumericField;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.CURSOR DEL command usage
+
+// 1. Create index
+$client = new Client();
+
+$ftCreateArguments = (new CreateArguments())->prefix(['user:']);
+$schema = [
+    new TextField('name'),
+    new TextField('country'),
+    new NumericField('dob', '', AbstractField::SORTABLE),
+];
+
+$client->ftcreate('index_cursor_del', $schema, $ftCreateArguments);
+
+// 2. Add documents
+$client->hset('user:0', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+$client->hset('user:1', 'name', 'Vlad', 'country', 'Israel', 'dob', 782265600);
+$client->hset('user:2', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+
+// 3. Execute aggregation query
+$ftAggregateArguments = (new AggregateArguments())
+    ->apply('year(@dob)', 'birth')
+    ->groupBy('@country', '@birth')
+    ->reduce('COUNT', true, 'country_birth_Vlad_count')
+    ->sortBy(0, '@birth', 'DESC')
+    ->withCursor(1);
+
+[$_, $cursor] = $client->ftaggregate('index_cursor_del', '@name: "Vlad"', $ftAggregateArguments);
+
+// 4. Explicitly remove returned cursor
+$client->ftcursor->del('index_cursor_del', $cursor);
+
+echo "Cursor with cursorId - {$cursor} was removed";

examples/Commands/Search/ft_cursor_read.php

@@ -0,0 +1,62 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\AggregateArguments;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SchemaFields\AbstractField;
+use Predis\Command\Argument\Search\SchemaFields\NumericField;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.CURSOR READ command usage
+
+// 1. Create index
+$client = new Client();
+
+$ftCreateArguments = (new CreateArguments())->prefix(['user:']);
+$schema = [
+    new TextField('name'),
+    new TextField('country'),
+    new NumericField('dob', '', AbstractField::SORTABLE),
+];
+
+$client->ftcreate('index_cursor_read', $schema, $ftCreateArguments);
+
+// 2. Add documents
+$client->hset('user:0', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+$client->hset('user:1', 'name', 'Vlad', 'country', 'Israel', 'dob', 782265600);
+$client->hset('user:2', 'name', 'Vlad', 'country', 'Ukraine', 'dob', 813801600);
+
+// 3. Execute aggregation query
+$ftAggregateArguments = (new AggregateArguments())
+    ->apply('year(@dob)', 'birth')
+    ->groupBy('@country', '@birth')
+    ->reduce('COUNT', true, 'country_birth_Vlad_count')
+    ->sortBy(0, '@birth', 'DESC')
+    ->withCursor(1);
+
+[$response, $cursor] = $client->ftaggregate('index_cursor_read', '@name: "Vlad"', $ftAggregateArguments);
+
+// 4. Processing response in loop until cursorId exists
+$actualResponse = [];
+$cursors = [];
+
+while ($cursor) {
+    $actualResponse[] = $response[1];
+    $cursors[] = $cursor;
+    [$response, $cursor] = $client->ftcursor->read('index_cursor_read', $cursor);
+}
+
+echo "Response: \n";
+print_r($actualResponse);

examples/Commands/Search/ft_explain.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.EXPLAIN command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_explain', $schema);
+
+// 2. Run query explanations
+$response = $client->ftexplain('index_explain', '(foo bar)|(hello world) @date:[100 200]|@date:[500 +inf]');
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_profile.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\ProfileArguments;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.PROFILE command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_profile', $schema);
+
+// 2. Create FT.PROFILE command arguments
+$arguments = (new ProfileArguments())
+                ->search()
+                ->query('query');
+
+// 3. Run profile query
+$response = $client->ftprofile('index_profile', $arguments);
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_spellcheck.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+use Predis\Command\Argument\Search\SpellcheckArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.SPELLCHECK command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_spellcheck', $schema);
+
+// 2. Add dictionary with terms
+$client->ftdictadd('dict', 'hello', 'help');
+
+// 3. Perform spelling correction query
+$response = $client->ftspellcheck(
+    'index_spellcheck',
+    'held',
+    (new SpellcheckArguments())->distance(2)->terms('dict')
+);
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_sug_add_get_del_len.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SugAddArguments;
+use Predis\Command\Argument\Search\SugGetArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.SUGADD, FT.SUGGET, FT.SUGDEL, FT.SUGLEN commands usage:
+
+// 1. Add suggestion to key with payload
+$client = new Client();
+
+$client->ftsugadd('key', 'hello', 2, (new SugAddArguments())->payload('payload'));
+
+echo 'Suggestions dictionary length: ' . $client->ftsuglen('key') . "\n";
+
+// 2. Perform fuzzy search by prefix to get previous suggestion with payload
+$response = $client->ftsugget('key', 'hellp', (new SugGetArguments())->fuzzy()->withPayloads());
+
+echo 'Suggestion for "hellp" prefix:' . "\n";
+print_r($response);
+
+// 3. Removes previous suggestion from key
+$client->ftsugdel('key', 'hello');
+$response = $client->ftsugget('key', 'hello');
+
+echo 'Suggestions, after removing "hello" suggestion:' . "\n";
+print_r($response);

examples/Commands/Search/ft_syndump.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.SYNDUMP command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_syndump', $schema);
+
+// 2. Add synonyms group with terms
+$client->ftsynupdate('index_syndump', 'synonym1', null, 'term1', 'term2');
+
+// 3. Dump terms with synonyms
+$response = $client->ftsyndump('index_syndump');
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_synupdate.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.SYNUPDATE command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TextField('text_field'),
+];
+$client->ftcreate('index_synupdate', $schema);
+
+// 2. Add synonyms into synonym group
+$response = $client->ftsynupdate('index_synupdate', 'synonym1', null, 'term1', 'term2');
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/Search/ft_tagvals.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SchemaFields\TagField;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of FT.TAGVALS command usage:
+
+// 1. Create index
+$client = new Client();
+
+$schema = [
+    new TagField('tag_field'),
+];
+$client->ftcreate('index_tagvals', $schema, (new CreateArguments())->prefix(['prefix:']));
+
+// 2. Add indexed tags
+$client->hset('prefix:1', 'tag_field', 'Hello, World');
+$client->hset('prefix:2', 'tag_field', 'Hey, World');
+
+// 3. Unique tags value query
+$response = $client->fttagvals('index_tagvals', 'tag_field');
+
+echo 'Response:' . "\n";
+print_r($response);

examples/Commands/TimeSeries/ts_add.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\AddArguments;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.ADD command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Add sample into newly created time series
+$addArguments = (new AddArguments())
+    ->retentionMsecs(31536000000);
+
+$response = $client->tsadd('temperature:2:32', 123123123123, 27, $addArguments);
+
+echo "Timeseries was added with timestamp: {$response}";

examples/Commands/TimeSeries/ts_alter.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\AlterArguments;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.ALTER command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$response = $client->tscreate('temperature:2:32', $arguments);
+
+echo "Time series creation status: {$response}\n";
+
+// 2. Update Duplicate policy for time series above
+$arguments = (new AlterArguments())
+    ->duplicatePolicy(CommonArguments::POLICY_FIRST);
+
+$response = $client->tsalter('temperature:2:32', $arguments);
+$output = ($response == 'OK') ? 'Duplicate policy was successfully updated' : $response;
+
+echo $output;

examples/Commands/TimeSeries/ts_create.php

@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.CREATE command usage:
+
+// Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$response = $client->tscreate('temperature:2:32', $arguments);
+
+echo "Time series creation status: {$response}";

examples/Commands/TimeSeries/ts_createrule.php

@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.CREATERULE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->labels('type', 'temp', 'location', 'TLV');
+
+$createResponse = $client->tscreate('temp:TLV', $arguments);
+echo "Original time series creation status: {$createResponse}\n";
+
+$createResponse = $client->tscreate('dailyAvgTemp:TLV', $arguments);
+echo "Compacted time series creation status: {$createResponse}\n";
+
+$createRuleResponse = $client->tscreaterule('temp:TLV', 'dailyAvgTemp:TLV', 'avg', 1000);
+echo "Compacted rule for compacted time series creation status: {$createRuleResponse}\n";

examples/Commands/TimeSeries/ts_decrby.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\AddArguments;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\DecrByArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.DECRBY command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Add sample into newly created time series
+$addArguments = (new AddArguments())
+    ->retentionMsecs(31536000000);
+
+$response = $client->tsadd('temperature:2:32', 123123123123, 27, $addArguments);
+
+echo "Timeseries was added with timestamp: {$response}\n";
+
+// 3. Increasing value and timestamp
+$client->tsdecrby('temperature:2:32', 1, (new DecrByArguments())->timestamp(123123123124));
+$response = $client->tsget('temperature:2:32');
+
+echo "Decreased value to - {$response[1]} and timestamp to {$response[0]}";

examples/Commands/TimeSeries/ts_del.php

@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.GET command usage:
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Add samples into time series
+$client->tsadd('temperature:2:32', 123123123123, 27);
+$client->tsadd('temperature:2:32', 123123123124, 28);
+$client->tsadd('temperature:2:32', 123123123125, 29);
+
+$response = $client->tsget('temperature:2:32');
+
+echo "Sample with highest timestamp - {$response[0]} and value {$response[1]}\n";
+
+// 3. Removes 2 samples with the highest timestamps
+$response = $client->tsdel('temperature:2:32', 123123123124, 123123123125);
+
+echo "Removed {$response} samples from timeseries.\n";
+
+// 3. Retrieve a timestamp with the highest timestamp
+$response = $client->tsget('temperature:2:32');
+
+echo "New sample with highest timestamp - {$response[0]} and value {$response[1]}";

examples/Commands/TimeSeries/ts_deleterule.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.CREATERULE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->labels('type', 'temp', 'location', 'TLV');
+
+$createResponse = $client->tscreate('temp:TLV', $arguments);
+echo "Original time series creation status: {$createResponse}\n";
+
+$createResponse = $client->tscreate('dailyAvgTemp:TLV', $arguments);
+echo "Compacted time series creation status: {$createResponse}\n";
+
+$createRuleResponse = $client->tscreaterule('temp:TLV', 'dailyAvgTemp:TLV', 'avg', 1000);
+echo "Compacted rule for compacted time series creation status: {$createRuleResponse}\n";
+
+// 2. Remove compaction rule
+$deleteRuleResponse = $client->tsdeleterule('temp:TLV', 'dailyAvgTemp:TLV');
+echo "Compacted rule for compacted time series deletion status: {$deleteRuleResponse}\n";

examples/Commands/TimeSeries/ts_get.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.GET command usage:
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Add samples into time series
+$client->tsadd('temperature:2:32', 123123123123, 27);
+$client->tsadd('temperature:2:32', 123123123124, 28);
+$client->tsadd('temperature:2:32', 123123123125, 29);
+
+// 3. Retrieve a timestamp with highest timestamp
+$response = $client->tsget('temperature:2:32');
+
+echo "Sample with highest timestamp - {$response[0]} and value - {$response[1]}";

examples/Commands/TimeSeries/ts_incrby.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\AddArguments;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\IncrByArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.INCRBY command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Add sample into newly created time series
+$addArguments = (new AddArguments())
+    ->retentionMsecs(31536000000);
+
+$response = $client->tsadd('temperature:2:32', 123123123123, 27, $addArguments);
+
+echo "Timeseries was added with timestamp: {$response}\n";
+
+// 3. Increasing value and timestamp
+$client->tsincrby('temperature:2:32', 1, (new IncrByArguments())->timestamp(123123123124));
+$response = $client->tsget('temperature:2:32');
+
+echo "Increased value to - {$response[1]} and timestamp to {$response[0]}";

examples/Commands/TimeSeries/ts_info.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.CREATE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+
+// 2. Show info about given time series
+print_r($client->tsinfo('temperature:2:32'));

examples/Commands/TimeSeries/ts_madd.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.MADD command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+$client->tscreate('temperature:2:33', $arguments);
+
+// 2. Add samples into few time series
+$response = $client->tsmadd('temperature:2:32', 123123123123, 27, 'temperature:2:33', 123123123124, 28);
+$stringResponse = implode(', ', $response);
+
+echo "Samples was added to time series - timestamps: {$stringResponse}";

examples/Commands/TimeSeries/ts_mget.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CommonArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\MGetArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.MGET command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->retentionMsecs(60000)
+    ->duplicatePolicy(CommonArguments::POLICY_MAX)
+    ->labels('type', 'temp', 'sensor_id', 2, 'area_id', 32);
+
+$client->tscreate('temperature:2:32', $arguments);
+$client->tscreate('temperature:2:33', $arguments);
+
+// 2. Add samples into time series
+$client->tsadd('temperature:2:32', 123123123123, 27);
+$client->tsadd('temperature:2:33', 123123123124, 27);
+
+// 3. Get sample from multiple time series matching given filter expression, with selected labels only
+$response = $client->tsmget((new MGetArguments())->selectedLabels('type'), 'type=temp');
+
+echo "Sample from time series, with label = 'type':\n";
+print_r($response);

examples/Commands/TimeSeries/ts_mrange.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\MRangeArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.MRANGE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$response = $client->tscreate('stock:A', (new CreateArguments())->labels('type', 'stock', 'name', 'A'));
+echo "Time series A creation status: {$response}\n";
+
+$response = $client->tscreate('stock:B', (new CreateArguments())->labels('type', 'stock', 'name', 'B'));
+echo "Time series B creation status: {$response}\n";
+
+// 2. Add samples into both time series
+$response = $client->tsmadd('stock:A', 1000, 100, 'stock:A', 1010, 110, 'stock:A', 1020, 120);
+$stringResponse = implode(', ', $response);
+echo "Added samples into time series A with following timestamps: {$stringResponse}\n";
+
+$response = $client->tsmadd('stock:B', 1000, 120, 'stock:B', 1010, 110, 'stock:B', 1020, 100);
+$stringResponse = implode(', ', $response);
+echo "Added samples into time series B with following timestamps: {$stringResponse}\n";
+
+// 3. Query range across both time series filtered by "type" and grouped by max type
+$mrangeArguments = (new MRangeArguments())
+    ->withLabels()
+    ->filter('type=stock')
+    ->groupBy('type', 'max');
+
+$response = $client->tsmrange('-', '+', $mrangeArguments);
+
+echo "Response:\n";
+print_r($response);

examples/Commands/TimeSeries/ts_mrevrange.php

@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\MRangeArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.MREVRANGE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$response = $client->tscreate('stock:A', (new CreateArguments())->labels('type', 'stock', 'name', 'A'));
+echo "Time series A creation status: {$response}\n";
+
+$response = $client->tscreate('stock:B', (new CreateArguments())->labels('type', 'stock', 'name', 'B'));
+echo "Time series B creation status: {$response}\n";
+
+// 2. Add samples into both time series
+$response = $client->tsmadd('stock:A', 1000, 100, 'stock:A', 1010, 110, 'stock:A', 1020, 120);
+$stringResponse = implode(', ', $response);
+echo "Added samples into time series A with following timestamps: {$stringResponse}\n";
+
+$response = $client->tsmadd('stock:B', 1000, 120, 'stock:B', 1010, 110, 'stock:B', 1020, 100);
+$stringResponse = implode(', ', $response);
+echo "Added samples into time series B with following timestamps: {$stringResponse}\n";
+
+// 3. Query range across both time series filtered by "type" and grouped by max type
+$mrangeArguments = (new MRangeArguments())
+    ->withLabels()
+    ->filter('type=stock')
+    ->groupBy('type', 'max');
+
+$response = $client->tsmrevrange('-', '+', $mrangeArguments);
+
+echo "Response:\n";
+print_r($response);

examples/Commands/TimeSeries/ts_queryindex.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.QUERYINDEX command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$arguments = (new CreateArguments())
+    ->labels('type', 'temp', 'location', 'TLV');
+
+$createResponse = $client->tscreate('temp:TLV', $arguments);
+echo "Time series with location TLV creation status: {$createResponse}\n";
+
+$anotherArguments = (new CreateArguments())
+    ->labels('type', 'temp', 'location', 'JER');
+
+$createResponse = $client->tscreate('temp:JER', $anotherArguments);
+echo "Time series with location JER creation status: {$createResponse}\n";
+
+echo "Returns all keys with location=TLV:\n";
+print_r($client->tsqueryindex('location=TLV'));

examples/Commands/TimeSeries/ts_range.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\RangeArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.RANGE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$createArguments = (new CreateArguments())->labels('type', 'temp', 'location', 'TLV');
+$createResponse = $client->tscreate('temp:TLV', $createArguments);
+
+echo "Time series creation status: {$createResponse}\n";
+
+// 2. Add samples into time series
+$maddResponse = $client->tsmadd('temp:TLV', 1000, 30, 'temp:TLV', 1010, 35, 'temp:TLV', 1020, 9999, 'temp:TLV', 1030, 40);
+$stringResponse = implode(', ', $maddResponse);
+
+echo "Samples was added with following timestamps: {$stringResponse}\n";
+
+// 3. Query samples by values in the given range
+$rangeArguments = (new RangeArguments())->filterByValue(-100, 100);
+$rangeResponse = $client->tsrange('temp:TLV', '-', '+', $rangeArguments);
+
+echo "Samples with temperature in range -100 to 100 degrees:\n";
+print_r($rangeResponse);

examples/Commands/TimeSeries/ts_revrange.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+use Predis\Command\Argument\TimeSeries\CreateArguments;
+use Predis\Command\Argument\TimeSeries\RangeArguments;
+
+require __DIR__ . '/../../shared.php';
+
+// Example of TS.REVRANGE command usage:
+
+// 1. Create time series
+$client = new Client();
+
+$createArguments = (new CreateArguments())->labels('type', 'temp', 'location', 'TLV');
+$createResponse = $client->tscreate('temp:TLV', $createArguments);
+
+echo "Time series creation status: {$createResponse}\n";
+
+// 2. Add samples into time series
+$maddResponse = $client->tsmadd('temp:TLV', 1000, 30, 'temp:TLV', 1010, 35, 'temp:TLV', 1020, 9999, 'temp:TLV', 1030, 40);
+$stringResponse = implode(', ', $maddResponse);
+
+echo "Samples was added with following timestamps: {$stringResponse}\n";
+
+// 3. Query samples by values in the given range
+$rangeArguments = (new RangeArguments())->filterByValue(-100, 100);
+$rangeResponse = $client->tsrevrange('temp:TLV', '-', '+', $rangeArguments);
+
+echo "Samples with temperature in range -100 to 100 degrees in reverse order:\n";
+print_r($rangeResponse);

examples/Commands/acl_dry_run.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../shared.php';
+
+// Example of ACL DRYRUN command usage:
+
+// 1. Set user with permissions to call only 'SET' command.
+$client = new Client($single_server);
+$response = $client->acl->setUser('Test_dry', '+SET', '~*');
+$created = ($response == 'OK') ? 'Yes' : 'No';
+
+echo "User with username 'Test' was created: {$created}. Permissions only to use SET command\n";
+
+// 2. Dry run 'SET' command under 'Test_dry' user
+$response = $client->acl->dryRun('Test_dry', 'SET', 'foo', 'bar');
+
+echo 'Dry run "SET" command.' . "\n";
+echo 'Response: ' . $response . "\n";
+
+// 3. Dry run 'GET' command under 'Test_dry' user
+$response = $client->acl->dryRun('Test_dry', 'GET', 'foo');
+
+echo 'Dry run "GET" command.' . "\n";
+echo 'Response: ' . $response;

examples/Commands/acl_get_user.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../shared.php';
+
+// Example of ACL GETUSER command usage:
+
+// 1. Set user
+$client = new Client($single_server);
+$response = $client->acl->setUser('Test');
+
+// 2. Retrieve user rules:
+
+echo 'Rules: ' . "\n";
+print_r(
+    $client->acl->getUser('Test')
+);

examples/Commands/acl_set_user.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../shared.php';
+
+// Example of ACL SETUSER command usage:
+
+// 1. Set user
+$client = new Client($single_server);
+$response = $client->acl->setUser('Test');
+$created = ($response == 'OK') ? 'Yes' : 'No';
+
+echo "User with username 'Test' was created: {$created}";

examples/Commands/fcall_ro.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../shared.php';
+
+// Example of FCALL_RO command usage:
+
+// 1. Set key-value pair
+$client = new Client($single_server);
+$client->set('foo', 'bar');
+
+echo "Set key 'foo' with value 'bar'\n";
+
+// 2. Load redis function with 'no-writes' flag
+$client->function->load(
+    "#!lua name=mylib
+                redis.register_function{
+                    function_name='myfunc',
+                    callback=function(keys, args) return redis.call('GET', keys[1]) end,
+                    flags={'no-writes'}
+                }"
+);
+
+echo 'Loaded custom function that perform GET command against provided key.' . "\n";
+
+// 3. Call function above with given key
+$response = $client->fcall_ro('myfunc', ['foo']);
+
+echo "Function returned value against provided key 'foo' is '{$response}'";
+
+// 4. Delete test library
+$client->function->delete('mylib');

examples/Commands/waitaof.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Predis\Client;
+
+require __DIR__ . '/../shared.php';
+
+// Example of WAITAOF command usage:
+
+// 1. Enable appendonly mode if it's not (command works only in appendonly mode)
+$client = new Client($single_server);
+$info = $client->info();
+$enabled = false;
+
+if ($info['Persistence']['aof_enabled'] === '0') {
+    $client->config('set', 'appendonly', 'yes');
+    $enabled = true;
+}
+
+// 2. Set key value pair
+$response = $client->set('foo', 'bar');
+echo "Key-value pair set status: {$response}\n";
+
+// 3. Run WAITAOF command to make sure that all previous writes was fsynced
+$response = $client->waitaof(1, 0, 0);
+
+echo "Quantity of local instances that was fsynced - {$response[0]}, quantity of replicas - {$response[1]}";
+
+// 4. Disable appendonly mode if it was enabled during script execution
+if ($enabled) {
+    $client->config('set', 'appendonly', 'no');
+}

examples/CustomDistributionStrategy.php

@@ -1,60 +0,0 @@
-<?php
-require_once 'SharedConfigurations.php';
-
-// Developers can customize the distribution strategy used by the client 
-// to distribute keys among a cluster of servers simply by creating a class 
-// that implements the Predis\Distribution\IDistributionAlgorithm interface.
-
-class NaiveDistributionStrategy
-    implements Predis\Distribution\IDistributionStrategy {
-
-    private $_nodes, $_nodesCount;
-
-    public function __constructor() {
-        $this->_nodes = array();
-        $this->_nodesCount = 0;
-    }
-
-    public function add($node, $weight = null) {
-        $this->_nodes[] = $node;
-        $this->_nodesCount++;
-    }
-
-    public function remove($node) {
-        $this->_nodes = array_filter($this->_nodes, function($n) use($node) {
-            return $n !== $node;
-        });
-        $this->_nodesCount = count($this->_nodes);
-    }
-
-    public function get($key) {
-        $count = $this->_nodesCount;
-        if ($count === 0) {
-            throw new RuntimeException('No connections');
-        }
-        return $this->_nodes[$count > 1 ? abs(crc32($key) % $count) : 0];
-    }
-
-    public function generateKey($value) {
-        return crc32($value);
-    }
-}
-
-$options = array(
-    'key_distribution' => new NaiveDistributionStrategy(),
-);
-
-$redis = new Predis\Client($multiple_servers, $options);
-
-for ($i = 0; $i < 100; $i++) {
-    $redis->set("key:$i", str_pad($i, 4, '0', 0));
-    $redis->get("key:$i");
-}
-
-$server1 = $redis->getClientFor('first')->info();
-$server2 = $redis->getClientFor('second')->info();
-
-printf("Server '%s' has %d keys while server '%s' has %d keys.\n", 
-    'first', $server1['db15']['keys'], 'second', $server2['db15']['keys']
-);
-?>

examples/MultipleSetAndGet.php

@@ -1,29 +0,0 @@
-<?php
-require_once 'SharedConfigurations.php';
-
-// redis can set keys and their relative values in one go 
-// using MSET, then the same values can be retrieved with 
-// a single command using MGET.
-
-$mkv = array(
-    'usr:0001' => 'First user',
-    'usr:0002' => 'Second user', 
-    'usr:0003' => 'Third user' 
-);
-
-$redis = new Predis\Client($single_server);
-
-$redis->mset($mkv);
-$retval = $redis->mget(array_keys($mkv));
-
-print_r($retval);
-
-/* OUTPUT:
-Array
-(
-    [0] => First user
-    [1] => Second user
-    [2] => Third user
-)
-*/
-?>

examples/PubSubContext.php

@@ -1,52 +0,0 @@
-<?php
-require_once 'SharedConfigurations.php';
-
-// Redis 2.0 features new commands that allow clients to subscribe for 
-// events published on certain channels (PUBSUB).
-
-// Create a client and disable r/w timeout on the socket
-$redis  = new Predis\Client($single_server + array('read_write_timeout' => -1));
-
-// Initialize a new pubsub context
-$pubsub = $redis->pubSubContext();
-
-// Subscribe to your channels
-$pubsub->subscribe('control_channel');
-$pubsub->subscribe('notifications');
-
-// Start processing the pubsup messages. Open a terminal and use redis-cli 
-// to push messages to the channels. Examples:
-//   ./redis-cli PUBLISH notifications "this is a test"
-//   ./redis-cli PUBLISH control_channel quit_loop
-foreach ($pubsub as $message) {
-    switch ($message->kind) {
-        case 'subscribe':
-            echo "Subscribed to {$message->channel}\n";
-            break;
-        case 'message':
-            if ($message->channel == 'control_channel') {
-                if ($message->payload == 'quit_loop') {
-                    echo "Aborting pubsub loop...\n";
-                    $pubsub->unsubscribe();
-                }
-                else {
-                    echo "Received an unrecognized command: {$message->payload}.\n";
-                }
-            }
-            else {
-                echo "Received the following message from {$message->channel}:\n",
-                     "  {$message->payload}\n\n";
-            }
-            break;
-    }
-}
-
-// Always unset the pubsub context instance when you are done! The 
-// class destructor will take care of cleanups and prevent protocol 
-// desynchronizations between the client and the server.
-unset($pubsub);
-
-// Say goodbye :-)
-$info = $redis->info();
-print_r("Goodbye from Redis v{$info['redis_version']}!\n");
-?>

examples/SharedConfigurations.php

@@ -1,24 +0,0 @@
-<?php
-require_once '../lib/Predis.php';
-
-$single_server = array(
-    'host'     => '127.0.0.1', 
-    'port'     => 6379, 
-    'database' => 15
-);
-
-$multiple_servers = array(
-    array(
-       'host'     => '127.0.0.1',
-       'port'     => 6379,
-       'database' => 15,
-       'alias'    => 'first',
-    ),
-    array(
-       'host'     => '127.0.0.1',
-       'port'     => 6380,
-       'database' => 15,
-       'alias'    => 'second',
-    ),
-);
-?>

examples/SimpleSetAndGet.php

@@ -1,16 +0,0 @@
-<?php
-require_once 'SharedConfigurations.php';
-
-// simple set and get scenario
-
-$redis = new Predis\Client($single_server);
-
-$redis->set('library', 'predis');
-$retval = $redis->get('library');
-
-print_r($retval);
-
-/* OUTPUT
-predis
-*/
-?>

examples/custom_cluster_distributor.php

@@ -0,0 +1,118 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Developers can implement Predis\Distribution\DistributorInterface to create
+// their own distributors used by the client to distribute keys among a cluster
+// of servers.
+
+use Predis\Cluster\Distributor\DistributorInterface;
+use Predis\Cluster\Hash\HashGeneratorInterface;
+use Predis\Cluster\PredisStrategy;
+use Predis\Connection\Cluster\PredisCluster;
+
+class NaiveDistributor implements DistributorInterface, HashGeneratorInterface
+{
+    private $nodes;
+    private $nodesCount;
+
+    public function __construct()
+    {
+        $this->nodes = [];
+        $this->nodesCount = 0;
+    }
+
+    public function add($node, $weight = null)
+    {
+        $this->nodes[] = $node;
+        ++$this->nodesCount;
+    }
+
+    public function remove($node)
+    {
+        $this->nodes = array_filter($this->nodes, function ($n) use ($node) {
+            return $n !== $node;
+        });
+
+        $this->nodesCount = count($this->nodes);
+    }
+
+    public function getSlot($hash)
+    {
+        return $this->nodesCount > 1 ? abs($hash % $this->nodesCount) : 0;
+    }
+
+    public function getBySlot($slot)
+    {
+        return $this->nodes[$slot] ?? null;
+    }
+
+    public function getByHash($hash)
+    {
+        if (!$this->nodesCount) {
+            throw new RuntimeException('No connections.');
+        }
+
+        $slot = $this->getSlot($hash);
+        $node = $this->getBySlot($slot);
+
+        return $node;
+    }
+
+    public function get($value)
+    {
+        $hash = $this->hash($value);
+        $node = $this->getByHash($hash);
+
+        return $node;
+    }
+
+    public function hash($value)
+    {
+        return crc32($value);
+    }
+
+    public function getHashGenerator()
+    {
+        return $this;
+    }
+}
+
+$options = [
+    'cluster' => function () {
+        $distributor = new NaiveDistributor();
+        $strategy = new PredisStrategy($distributor);
+        $cluster = new PredisCluster($strategy);
+
+        return $cluster;
+    },
+];
+
+$client = new Predis\Client($multiple_servers, $options);
+
+for ($i = 0; $i < 100; ++$i) {
+    $client->set("key:$i", str_pad($i, 4, '0', 0));
+    $client->get("key:$i");
+}
+
+$server1 = $client->getClientBy('alias', 'first')->info();
+$server2 = $client->getClientBy('alias', 'second')->info();
+
+if (isset($server1['Keyspace'], $server2['Keyspace'])) {
+    $server1 = $server1['Keyspace'];
+    $server2 = $server2['Keyspace'];
+}
+
+printf("Server '%s' has %d keys while server '%s' has %d keys.\n",
+    'first', $server1['db15']['keys'], 'second', $server2['db15']['keys']
+);

examples/debuggable_connection.php

@@ -0,0 +1,93 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This is an example of how you can easily extend an existing connection class
+// and trace the execution of commands for debugging purposes. This can be quite
+// useful as a starting point to understand how your application interacts with
+// Redis.
+
+use Predis\Command\CommandInterface;
+use Predis\Connection\StreamConnection;
+
+class SimpleDebuggableConnection extends StreamConnection
+{
+    private $tstart = 0;
+    private $debugBuffer = [];
+
+    public function connect()
+    {
+        $this->tstart = microtime(true);
+
+        parent::connect();
+    }
+
+    private function storeDebug(CommandInterface $command, $direction)
+    {
+        $firtsArg = $command->getArgument(0);
+        $timestamp = round(microtime(true) - $this->tstart, 4);
+
+        $debug = $command->getId();
+        $debug .= isset($firtsArg) ? " $firtsArg " : ' ';
+        $debug .= "$direction $this";
+        $debug .= " [{$timestamp}s]";
+
+        $this->debugBuffer[] = $debug;
+    }
+
+    public function writeRequest(CommandInterface $command)
+    {
+        parent::writeRequest($command);
+
+        $this->storeDebug($command, '->');
+    }
+
+    public function readResponse(CommandInterface $command)
+    {
+        $response = parent::readResponse($command);
+        $this->storeDebug($command, '<-');
+
+        return $response;
+    }
+
+    public function getDebugBuffer()
+    {
+        return $this->debugBuffer;
+    }
+}
+
+$options = [
+    'connections' => [
+        'tcp' => 'SimpleDebuggableConnection',
+    ],
+];
+
+$client = new Predis\Client($single_server, $options);
+$client->set('foo', 'bar');
+$client->get('foo');
+$client->info();
+
+var_export($client->getConnection()->getDebugBuffer());
+
+/* OUTPUT:
+array (
+    0 => 'SELECT 15 -> 127.0.0.1:6379 [0.0008s]',
+    1 => 'SELECT 15 <- 127.0.0.1:6379 [0.001s]',
+    2 => 'SET foo -> 127.0.0.1:6379 [0.001s]',
+    3 => 'SET foo <- 127.0.0.1:6379 [0.0011s]',
+    4 => 'GET foo -> 127.0.0.1:6379 [0.0013s]',
+    5 => 'GET foo <- 127.0.0.1:6379 [0.0015s]',
+    6 => 'INFO -> 127.0.0.1:6379 [0.0019s]',
+    7 => 'INFO <- 127.0.0.1:6379 [0.0022s]',
+)
+*/

examples/dispatcher_loop.php

@@ -0,0 +1,80 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This is a basic example on how to use the Predis\DispatcherLoop class.
+//
+// To see this example in action you can just use redis-cli and publish some
+// messages to the 'events' and 'control' channel, e.g.:
+
+// ./redis-cli
+// PUBLISH events first
+// PUBLISH events second
+// PUBLISH events third
+// PUBLISH control terminate_dispatcher
+
+// Create a client and disable r/w timeout on the socket
+$client = new Predis\Client($single_server + ['read_write_timeout' => 0]);
+
+// Return an initialized PubSub consumer instance from the client.
+$pubsub = $client->pubSubLoop();
+
+// Create a dispatcher loop instance and attach a bunch of callbacks.
+$dispatcher = new Predis\PubSub\DispatcherLoop($pubsub);
+
+// Demonstrate how to use a callable class as a callback for the dispatcher loop.
+class EventsListener implements Countable
+{
+    private $events;
+
+    public function __construct()
+    {
+        $this->events = [];
+    }
+
+    public function count()
+    {
+        return count($this->events);
+    }
+
+    public function getEvents()
+    {
+        return $this->events;
+    }
+
+    public function __invoke($payload, $dispatcher)
+    {
+        $this->events[] = $payload;
+    }
+}
+
+// Attach our callable class to the dispatcher.
+$dispatcher->attachCallback('events', $events = new EventsListener());
+
+// Attach a function to control the dispatcher loop termination with a message.
+$dispatcher->attachCallback('control', function ($payload, $dispatcher) {
+    if ($payload === 'terminate_dispatcher') {
+        $dispatcher->stop();
+    }
+});
+
+// Run the dispatcher loop until the callback attached to the 'control' channel
+// receives 'terminate_dispatcher' as a message.
+$dispatcher->run();
+
+// Display our achievements!
+echo "We received {$events->count()} messages!", PHP_EOL;
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

examples/executing_redis_commands.php

@@ -0,0 +1,63 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+$client = new Predis\Client($single_server);
+
+// Plain old SET and GET example...
+$client->set('library', 'predis');
+$response = $client->get('library');
+
+var_export($response);
+echo PHP_EOL;
+/* OUTPUT: 'predis' */
+
+// Redis has the MSET and MGET commands to set or get multiple keys in one go,
+// cases like this Predis accepts arguments for variadic commands both as a list
+// of arguments or an array containing all of the keys and/or values.
+$mkv = [
+    'uid:0001' => '1st user',
+    'uid:0002' => '2nd user',
+    'uid:0003' => '3rd user',
+];
+
+$client->mset($mkv);
+$response = $client->mget(array_keys($mkv));
+
+var_export($response);
+echo PHP_EOL;
+/* OUTPUT:
+array (
+    0 => '1st user',
+    1 => '2nd user',
+    2 => '3rd user',
+)
+*/
+
+// Predis can also send "raw" commands to Redis. The difference between sending
+// commands to Redis the usual way and the "raw" way is that in the latter case
+// their arguments are not filtered nor responses coming from Redis are parsed.
+
+$response = $client->executeRaw([
+    'MGET', 'uid:0001', 'uid:0002', 'uid:0003',
+]);
+
+var_export($response);
+echo PHP_EOL;
+/* OUTPUT:
+array (
+    0 => '1st user',
+    1 => '2nd user',
+    2 => '3rd user',
+)
+*/

examples/key_prefixing.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Predis can prefix keys found in commands arguments before sending commands to
+// Redis, even for complex commands such as SORT, ZUNIONSTORE and ZINTERSTORE.
+// Prefixing keys can be useful to create user-level namespaces for you keyspace
+// thus reducing the need for separate logical databases in certain scenarios.
+
+$client = new Predis\Client($single_server, ['prefix' => 'nrk:']);
+
+$client->mset(['foo' => 'bar', 'lol' => 'wut']);
+var_export($client->mget('foo', 'lol'));
+/*
+array (
+    0 => 'bar',
+    1 => 'wut',
+)
+*/
+
+var_export($client->keys('*'));
+/*
+array (
+    0 => 'nrk:foo',
+    1 => 'nrk:lol',
+)
+*/

examples/lua_scripting_abstraction.php

@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This example will not work with versions of Redis < 2.6.
+//
+// Additionally to the EVAL command, the Predis\Command\ScriptCommand class can
+// be used to leverage an higher level abstraction for Lua scripting that makes
+// scripts appear just like any other command on the client-side. This is basic
+// example on how a script-based INCREX command can be defined:
+
+use Predis\Command\ScriptCommand;
+
+class IncrementExistingKeysBy extends ScriptCommand
+{
+    public function getKeysCount()
+    {
+        // Tell Predis to use all the arguments but the last one as arguments
+        // for KEYS. The last one will be used to populate ARGV.
+        return -1;
+    }
+
+    public function getScript()
+    {
+        return <<<LUA
+local cmd, insert = redis.call, table.insert
+local increment, results = ARGV[1], { }
+
+for idx, key in ipairs(KEYS) do
+    if cmd('exists', key) == 1 then
+        insert(results, idx, cmd('incrby', key, increment))
+    else
+        insert(results, idx, false)
+    end
+end
+
+return results
+LUA;
+    }
+}
+
+$client = new Predis\Client($single_server, [
+    'commands' => [
+        'increxby' => 'IncrementExistingKeysBy',
+    ],
+]);
+
+$client->mset('foo', 10, 'foobar', 100);
+
+var_export($client->increxby('foo', 'foofoo', 'foobar', 50));
+
+/*
+array (
+    0 => 60,
+    1 => NULL,
+    2 => 150,
+)
+*/

examples/monitor_consumer.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This is a basic example on how to use the Predis\Monitor\Consumer class. You
+// can use redis-cli to send commands to the same Redis instance your client is
+// connected to, and then type "ECHO QUIT_MONITOR" in redis-cli when you want to
+// exit the monitor loop and terminate this script in a graceful way.
+
+// Create a client and disable r/w timeout on the socket.
+$client = new Predis\Client($single_server + ['read_write_timeout' => 0]);
+
+// Use only one instance of DateTime, we will update the timestamp later.
+$timestamp = new DateTime();
+
+foreach (($monitor = $client->monitor()) as $event) {
+    $timestamp->setTimestamp((int) $event->timestamp);
+
+    // If we notice a ECHO command with the message QUIT_MONITOR, we stop the
+    // monitor consumer and then break the loop.
+    if ($event->command === 'ECHO' && $event->arguments === '"QUIT_MONITOR"') {
+        echo 'Exiting the monitor loop...', PHP_EOL;
+        $monitor->stop();
+        break;
+    }
+
+    echo "* Received {$event->command} on DB {$event->database} at {$timestamp->format(DateTime::W3C)}", PHP_EOL;
+    if (isset($event->arguments)) {
+        echo "    Arguments: {$event->arguments}", PHP_EOL;
+    }
+}
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

examples/pipelining_commands.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// When you have a whole set of consecutive commands to send to a redis server,
+// you can use a pipeline to dramatically improve performances. Pipelines can
+// greatly reduce the effects of network round-trips.
+
+$client = new Predis\Client($single_server);
+
+$responses = $client->pipeline(function ($pipe) {
+    $pipe->flushdb();
+    $pipe->incrby('counter', 10);
+    $pipe->incrby('counter', 30);
+    $pipe->exists('counter');
+    $pipe->get('counter');
+    $pipe->mget('does_not_exist', 'counter');
+});
+
+var_export($responses);
+
+/* OUTPUT:
+array (
+    0 => Predis\Response\Status::__set_state(array(
+        'payload' => 'OK',
+    )),
+    1 => 10,
+    2 => 40,
+    3 => true,
+    4 => '40',
+    5 => array (
+        0 => NULL,
+        1 => '40',
+    ),
+)
+*/

examples/pubsub_consumer.php

@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Starting from Redis 2.0 clients can subscribe and listen for events published
+// on certain channels using a Publish/Subscribe (PUB/SUB) approach.
+
+// Create a client and disable r/w timeout on the socket
+$client = new Predis\Client($single_server + ['read_write_timeout' => 0]);
+
+// Initialize a new pubsub consumer.
+$pubsub = $client->pubSubLoop();
+
+// Subscribe to your channels
+$pubsub->subscribe('control_channel', 'notifications');
+
+// Start processing the pubsub messages. Open a terminal and use redis-cli
+// to push messages to the channels. Examples:
+//   redis-cli PUBLISH notifications "this is a test"
+//   redis-cli PUBLISH control_channel quit_loop
+foreach ($pubsub as $message) {
+    switch ($message->kind) {
+        case 'subscribe':
+            echo "Subscribed to {$message->channel}", PHP_EOL;
+            break;
+
+        case 'message':
+            if ($message->channel == 'control_channel') {
+                if ($message->payload == 'quit_loop') {
+                    echo 'Aborting pubsub loop...', PHP_EOL;
+                    $pubsub->unsubscribe();
+                } else {
+                    echo "Received an unrecognized command: {$message->payload}.", PHP_EOL;
+                }
+            } else {
+                echo "Received the following message from {$message->channel}:",
+                PHP_EOL, "  {$message->payload}", PHP_EOL, PHP_EOL;
+            }
+            break;
+    }
+}
+
+// Always unset the pubsub consumer instance when you are done! The
+// class destructor will take care of cleanups and prevent protocol
+// desynchronizations between the client and the server.
+unset($pubsub);
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

examples/redis_collections_iterators.php

@@ -0,0 +1,99 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+use Predis\Collection\Iterator;
+
+// Starting with Redis 2.8, clients can iterate incrementally over collections
+// without blocking the server like it happens when a command such as KEYS is
+// executed on a Redis instance storing millions of keys. These commands are:
+//
+//   - SCAN (iterates over the keyspace)
+//   - SSCAN (iterates over members of a set)
+//   - ZSCAN (iterates over members and ranks of a sorted set)
+//   - HSCAN (iterates over fields and values of an hash).
+
+// Predis provides a specialized abstraction for each command based on standard
+// SPL iterators making it possible to easily consume SCAN-based iterations in
+// your PHP code.
+//
+// See http://redis.io/commands/scan for more details.
+//
+
+$client = new Predis\Client($single_server);
+
+// Prepare some keys for our example
+$client->del('predis:set', 'predis:zset', 'predis:hash');
+for ($i = 0; $i < 5; ++$i) {
+    $client->sadd('predis:set', "member:$i");
+    $client->zadd('predis:zset', -$i, "member:$i");
+    $client->hset('predis:hash', "field:$i", "value:$i");
+}
+
+// === Keyspace iterator based on SCAN ===
+echo 'Scan the keyspace matching only our prefixed keys:', PHP_EOL;
+foreach (new Iterator\Keyspace($client, 'predis:*') as $key) {
+    echo " - $key", PHP_EOL;
+}
+
+/* OUTPUT
+Scan the keyspace matching only our prefixed keys:
+    - predis:zset
+    - predis:set
+    - predis:hash
+*/
+
+// === Set iterator based on SSCAN ===
+echo 'Scan members of `predis:set`:', PHP_EOL;
+foreach (new Iterator\SetKey($client, 'predis:set') as $member) {
+    echo " - $member", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members of `predis:set`:
+    - member:1
+    - member:4
+    - member:0
+    - member:3
+    - member:2
+*/
+
+// === Sorted set iterator based on ZSCAN ===
+echo 'Scan members and ranks of `predis:zset`:', PHP_EOL;
+foreach (new Iterator\SortedSetKey($client, 'predis:zset') as $member => $rank) {
+    echo " - $member [rank: $rank]", PHP_EOL;
+}
+
+/* OUTPUT
+Scan members and ranks of `predis:zset`:
+    - member:4 [rank: -4]
+    - member:3 [rank: -3]
+    - member:2 [rank: -2]
+    - member:1 [rank: -1]
+    - member:0 [rank: 0]
+*/
+
+// === Hash iterator based on HSCAN ===
+echo 'Scan fields and values of `predis:hash`:', PHP_EOL;
+foreach (new Iterator\HashKey($client, 'predis:hash') as $field => $value) {
+    echo " - $field => $value", PHP_EOL;
+}
+
+/* OUTPUT
+Scan fields and values of `predis:hash`:
+    - field:0 => value:0
+    - field:1 => value:1
+    - field:2 => value:2
+    - field:3 => value:3
+    - field:4 => value:4
+*/

examples/relay_compression.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Enable igbinary serializer as well as LZ4 compression
+$options = [
+    'serializer' => 'igbinary',
+    'compression' => 'lz4',
+];
+
+$client = new Predis\Client($single_server + $options, [
+    'connections' => 'relay',
+]);
+
+$quote = (object) [
+    'author' => 'Jean-Luc Picard',
+    'text' => 'I look forward to your report Mr. Broccoli.',
+];
+
+// Serialize object and apply LZ4 compression, then write key to Redis
+$client->set('quote', $client->pack($quote));
+
+// NOTE: In Predis v3.x serialization and compression will happen
+// automatically without the need to call `pack()` and `unpack()`
+
+// Retrieve raw binary value from Redis
+$raw = $client->get('quote');
+
+// Decompress and unserialize binary value
+$data = $client->unpack($raw);
+
+var_dump($quote == $data); // true
+
+var_dump($data);
+
+/*
+object(stdClass)#11 (2) {
+    ["author"]=>string(15) "Jean-Luc Picard"
+    ["text"]=>string(43) "I look forward to your report Mr. Broccoli."
+}
+*/

examples/relay_connection.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+$options = [
+    'timeout' => 1.0,
+    'read_write_timeout' => 1.0,
+
+    // Relay specific options
+    'cache' => true,
+    // 'compression' => 'lz4',
+    // 'serializer' => 'igbinary',
+];
+
+$client = new Predis\Client($single_server + $options, [
+    'connections' => 'relay',
+]);
+
+// Write key to Redis
+$client->set('torpedo', mt_rand());
+
+// Retrieve key from Redis
+$client->get('torpedo');
+
+// Retrieve key from Relay (without talking to Redis)
+// This key is now available to all PHP workers in this FPM pool
+$client->get('torpedo');
+
+// For debugging only:
+var_export(
+    $client->getConnection()->getClient()->_getKeys()
+);
+
+/*
+array (
+    'torpedo' => array (
+        0 => array (
+            'type' => 'string',
+            'local-len' => 10,
+            'remote-len' => 10,
+            'size' => 10,
+        ),
+    ),
+)
+*/

examples/relay_events.php

@@ -0,0 +1,61 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+$key = null;
+
+$client = new Predis\Client($single_server, [
+    'connections' => 'relay',
+]);
+
+/** @var Predis\Connection\RelayConnection $relay */
+$relay = $client->getConnection();
+
+// establish connection
+$client->ping();
+
+// register `FLUSH*` callback
+$relay->onFlushed(
+    static function (Relay\Event $event) use (&$key) {
+        echo 'Redis was flushed, unsetting $key...' . PHP_EOL;
+        $key = null;
+    }
+);
+
+// register `INVALIDATE` callback
+$relay->onInvalidated(
+    static function (Relay\Event $event) use (&$key) {
+        if ($event->key === 'library') {
+            echo "The `{$event->key}` key was invalidated, unsetting \$key..." . PHP_EOL;
+            $key = null;
+        }
+    }
+);
+
+// Write key to Redis
+$client->set('library', mt_rand());
+
+// Retrieve key once from Redis, then cached in Relay and $key
+$key = $client->get('library');
+
+while (true) {
+    echo '$key is: ' . var_export($key, true) . PHP_EOL;
+
+    // To trigger our event callbacks, we need to either interact with Relay:
+    $client->get(mt_rand());
+
+    // ... or alternatively dispatch events directly on Relay:
+    $relay->dispatchEvents();
+
+    sleep(1);
+}

examples/relay_pubsub_consumer.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Create a Relay client and disable r/w timeout on the connection
+$client = new Predis\Client(
+    $single_server + ['read_write_timeout' => 0],
+    ['connections' => 'relay']
+);
+
+// Initialize a new pubsub consumer.
+$pubsub = $client->pubSubLoop();
+
+// When using Relay you cannot use foreach-loops to iterate
+// over messages instead use a callback function
+$poorMansKafka = function ($message, $client) {
+    switch ($message->kind) {
+        case 'subscribe':
+            echo "Subscribed to {$message->channel}", PHP_EOL;
+            break;
+
+        case 'message':
+        case 'pmessage':
+            if ($message->channel == 'control_channel') {
+                if ($message->payload == 'quit_loop') {
+                    echo 'Aborting pubsub loop...', PHP_EOL;
+                    $client->unsubscribe();
+                } else {
+                    echo "Received an unrecognized command: {$message->payload}.", PHP_EOL;
+                }
+            } else {
+                echo "Received the message from `{$message->channel}` channel:",
+                PHP_EOL, "  {$message->payload}", PHP_EOL, PHP_EOL;
+            }
+    }
+};
+
+// Subscribe to your channels and start processing the messages.
+$pubsub->subscribe('control_channel', 'notifications', $poorMansKafka);
+
+// Open a terminal and use redis-cli to push messages to the channels. Examples:
+//   redis-cli PUBLISH notifications "this is a test"
+//   redis-cli PUBLISH control_channel quit_loop
+
+// When using Relay, there is no need to unset the pubsub consumer instance when you are done
+
+// Say goodbye :-)
+$version = redis_version($client->info());
+echo "Goodbye from Redis $version!", PHP_EOL;

examples/replication_complex.php

@@ -0,0 +1,83 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Predis allows to set Lua scripts as read-only operations for replication.
+// This works for both EVAL and EVALSHA and also for the client-side abstraction
+// built upon them (Predis\Command\ScriptCommand). This example shows a slightly
+// more complex configuration that injects a new script command in the command
+// factory used by the client and marks it as a read-only operation so that it
+// will be executed on slaves.
+
+use Predis\Command\ScriptCommand;
+use Predis\Connection\Replication\MasterSlaveReplication;
+use Predis\Replication\ReplicationStrategy;
+
+// ------------------------------------------------------------------------- //
+
+// Define a new script command that returns all the fields of a variable number
+// of hashes with a single roundtrip.
+
+class HashMultipleGetAll extends ScriptCommand
+{
+    public const BODY = <<<LUA
+local hashes = {}
+for _, key in pairs(KEYS) do
+    table.insert(hashes, key)
+    table.insert(hashes, redis.call('hgetall', key))
+end
+return hashes
+LUA;
+
+    public function getScript()
+    {
+        return self::BODY;
+    }
+}
+
+// ------------------------------------------------------------------------- //
+
+$parameters = [
+    'tcp://127.0.0.1:6381?role=master&database=15',
+    'tcp://127.0.0.1:6382?role=slave&alias=slave-01&database=15',
+];
+
+$options = [
+    'commands' => [
+        'hmgetall' => 'HashMultipleGetAll',
+    ],
+    'replication' => function () {
+        $strategy = new ReplicationStrategy();
+        $strategy->setScriptReadOnly(HashMultipleGetAll::BODY);
+
+        $replication = new MasterSlaveReplication($strategy);
+
+        return $replication;
+    },
+];
+
+// ------------------------------------------------------------------------- //
+
+$client = new Predis\Client($parameters, $options);
+
+// Execute the following commands on the master server using redis-cli:
+// $ ./redis-cli HMSET metavars foo bar hoge piyo
+// $ ./redis-cli HMSET servers master host1 slave host2
+
+$hashes = $client->hmgetall('metavars', 'servers');
+
+$replication = $client->getConnection();
+$stillOnSlave = $replication->getCurrent() === $replication->getConnectionByAlias('slave-01');
+
+echo 'Is still on slave? ', $stillOnSlave ? 'YES!' : 'NO!', PHP_EOL;
+var_export($hashes);

examples/replication_sentinel.php

@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Predis supports redis-sentinel to provide high availability in master / slave
+// scenarios. The only but relevant difference with a basic replication scenario
+// is that sentinel servers can manage the master server and its slaves based on
+// their state, which means that they are able to provide an authoritative and
+// updated configuration to clients thus avoiding static configurations for the
+// replication servers and their roles.
+
+// Instead of connection parameters pointing to redis nodes, we provide a list
+// of instances of redis-sentinel. Users should always provide a timeout value
+// low enough to not hinder operations just in case a sentinel is unreachable
+// but Predis uses a default value of 100 milliseconds for sentinel parameters
+// without an explicit timeout value.
+//
+// NOTE: in real-world scenarios sentinels should be running on different hosts!
+$sentinels = [
+    'tcp://127.0.0.1:5380?timeout=0.100',
+    'tcp://127.0.0.1:5381?timeout=0.100',
+    'tcp://127.0.0.1:5382?timeout=0.100',
+];
+
+$client = new Predis\Client($sentinels, [
+    'replication' => 'sentinel',
+    'service' => 'mymaster',
+]);
+
+// Read operation.
+$exists = $client->exists('foo') ? 'yes' : 'no';
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Does 'foo' exist on {$current->role}? $exists.", PHP_EOL;
+
+// Write operation.
+$client->set('foo', 'bar');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Now 'foo' has been set to 'bar' on {$current->role}!", PHP_EOL;
+
+// Read operation.
+$bar = $client->get('foo');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "We fetched 'foo' from {$current->role} and its value is '$bar'.", PHP_EOL;
+
+/* OUTPUT:
+Does 'foo' exist on slave-127.0.0.1:6381? yes.
+Now 'foo' has been set to 'bar' on master!
+We fetched 'foo' from master and its value is 'bar'.
+*/

examples/replication_simple.php

@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// Predis supports master / slave replication scenarios where write operations
+// are performed on the master server and read operations are executed against
+// one of the slaves. The behavior of commands or EVAL scripts can be customized
+// at will. As soon as a write operation is performed the client switches to the
+// master server for all the subsequent requests (either reads and writes).
+//
+// This example must be executed using the second Redis server configured as the
+// slave of the first one (see the "SLAVEOF" command).
+//
+
+$parameters = [
+    'tcp://127.0.0.1:6381?role=master&database=15',
+    'tcp://127.0.0.1:6382?role=slave&database=15',
+];
+
+$options = ['replication' => 'predis'];
+
+$client = new Predis\Client($parameters, $options);
+
+// Read operation.
+$exists = $client->exists('foo') ? 'yes' : 'no';
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Does 'foo' exist on {$current->role}? $exists.", PHP_EOL;
+
+// Write operation.
+$client->set('foo', 'bar');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "Now 'foo' has been set to 'bar' on {$current->role}!", PHP_EOL;
+
+// Read operation.
+$bar = $client->get('foo');
+$current = $client->getConnection()->getCurrent()->getParameters();
+echo "We fetched 'foo' from {$current->role} and its value is '$bar'.", PHP_EOL;
+
+/* OUTPUT:
+Does 'foo' exist on slave? yes.
+Now 'foo' has been set to 'bar' on master!
+We fetched 'foo' from master and its value is 'bar'.
+*/

examples/session_handler.php

@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This example demonstrates how to use Predis to save PHP sessions on Redis.
+//
+// The value of `session.gc_maxlifetime` in `php.ini` will be used by default as
+// the TTL for keys holding session data but this value can be overridden when
+// creating the session handler instance using the `gc_maxlifetime` option.
+//
+// NOTE: this class requires PHP >= 5.4 but can be used on PHP 5.3 if a polyfill
+// for SessionHandlerInterface is provided either by you or an external package
+// like `symfony/http-foundation`.
+//
+// See http://www.php.net/class.sessionhandlerinterface.php for more details.
+//
+
+if (!interface_exists('SessionHandlerInterface')) {
+    exit('ATTENTION: the session handler implemented by Predis requires PHP >= 5.4.0 ' .
+        "or a polyfill for SessionHandlerInterface provided by an external package.\n");
+}
+
+// Instantiate a new client just like you would normally do. Using a prefix for
+// keys will effectively prefix all session keys with the specified string.
+$client = new Predis\Client($single_server, ['prefix' => 'sessions:']);
+
+// Set `gc_maxlifetime` to specify a time-to-live of 5 seconds for session keys.
+$handler = new Predis\Session\Handler($client, ['gc_maxlifetime' => 5]);
+
+// Register the session handler.
+$handler->register();
+
+// We just set a fixed session ID only for the sake of our example.
+session_id('example_session_id');
+
+session_start();
+
+if (isset($_SESSION['foo'])) {
+    echo "Session has `foo` set to {$_SESSION['foo']}", PHP_EOL;
+} else {
+    $_SESSION['foo'] = $value = mt_rand();
+    echo "Empty session, `foo` has been set with $value", PHP_EOL;
+}

examples/shared.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (PHP_SAPI !== 'cli') {
+    exit('Example scripts are meant to be executed locally via CLI.');
+}
+
+require __DIR__ . '/../autoload.php';
+
+function redis_version($info)
+{
+    if (isset($info['Server']['redis_version'])) {
+        return $info['Server']['redis_version'];
+    } elseif (isset($info['redis_version'])) {
+        return $info['redis_version'];
+    } else {
+        return 'unknown version';
+    }
+}
+
+$single_server = [
+    'host' => '127.0.0.1',
+    'port' => 6379,
+    'database' => 15,
+];
+
+$multiple_servers = [
+    [
+        'host' => '127.0.0.1',
+        'port' => 6379,
+        'database' => 15,
+        'alias' => 'first',
+    ],
+    [
+        'host' => '127.0.0.1',
+        'port' => 6380,
+        'database' => 15,
+        'alias' => 'second',
+    ],
+];

examples/transaction_using_cas.php

@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require __DIR__ . '/shared.php';
+
+// This is an implementation of an atomic client-side ZPOP using the support for
+// check-and-set (CAS) operations with MULTI/EXEC transactions, as described in
+// "WATCH explained" from http://redis.io/topics/transactions
+//
+// First, populate your database with a tiny sample data set:
+//
+// ./redis-cli
+// SELECT 15
+// ZADD zset 1 a 2 b 3 c
+//
+// Then execute this script four times and see its output.
+//
+
+function zpop($client, $key)
+{
+    $element = null;
+    $options = [
+        'cas' => true,      // Initialize with support for CAS operations
+        'watch' => $key,    // Key that needs to be WATCHed to detect changes
+        'retry' => 3,       // Number of retries on aborted transactions, after
+        // which the client bails out with an exception.
+    ];
+
+    $client->transaction($options, function ($tx) use ($key, &$element) {
+        @[$element] = $tx->zrange($key, 0, 0);
+
+        if (isset($element)) {
+            $tx->multi();   // With CAS, MULTI *must* be explicitly invoked.
+            $tx->zrem($key, $element);
+        }
+    });
+
+    return $element;
+}
+
+$client = new Predis\Client($single_server);
+$zpopped = zpop($client, 'zset');
+
+echo isset($zpopped) ? "ZPOPed $zpopped" : 'Nothing to ZPOP!', PHP_EOL;

lib/Predis_Compatibility.php

@@ -1,500 +0,0 @@
-<?php
-namespace Predis;
-
-RedisServerProfile::registerProfile('\Predis\RedisServer_v1_0', '1.0');
-
-class RedisServer_v1_0 extends \Predis\RedisServerProfile {
-    public function getVersion() { return '1.0'; }
-    public function getSupportedCommands() {
-        return array(
-            /* miscellaneous commands */
-            'ping'      => '\Predis\Compatibility\v1_0\Commands\Ping',
-            'echo'      => '\Predis\Compatibility\v1_0\Commands\DoEcho',
-            'auth'      => '\Predis\Compatibility\v1_0\Commands\Auth',
-
-            /* connection handling */
-            'quit'      => '\Predis\Compatibility\v1_0\Commands\Quit',
-
-            /* commands operating on string values */
-            'set'                     => '\Predis\Compatibility\v1_0\Commands\Set',
-            'setnx'                   => '\Predis\Compatibility\v1_0\Commands\SetPreserve',
-                'setPreserve'         => '\Predis\Compatibility\v1_0\Commands\SetPreserve',
-            'get'                     => '\Predis\Compatibility\v1_0\Commands\Get',
-            'mget'                    => '\Predis\Compatibility\v1_0\Commands\GetMultiple',
-                'getMultiple'         => '\Predis\Compatibility\v1_0\Commands\GetMultiple',
-            'getset'                  => '\Predis\Compatibility\v1_0\Commands\GetSet',
-                'getSet'              => '\Predis\Compatibility\v1_0\Commands\GetSet',
-            'incr'                    => '\Predis\Compatibility\v1_0\Commands\Increment',
-                'increment'           => '\Predis\Compatibility\v1_0\Commands\Increment',
-            'incrby'                  => '\Predis\Compatibility\v1_0\Commands\IncrementBy',
-                'incrementBy'         => '\Predis\Compatibility\v1_0\Commands\IncrementBy',
-            'decr'                    => '\Predis\Compatibility\v1_0\Commands\Decrement',
-                'decrement'           => '\Predis\Compatibility\v1_0\Commands\Decrement',
-            'decrby'                  => '\Predis\Compatibility\v1_0\Commands\DecrementBy',
-                'decrementBy'         => '\Predis\Compatibility\v1_0\Commands\DecrementBy',
-            'exists'                  => '\Predis\Compatibility\v1_0\Commands\Exists',
-            'del'                     => '\Predis\Compatibility\v1_0\Commands\Delete',
-                'delete'              => '\Predis\Compatibility\v1_0\Commands\Delete',
-            'type'                    => '\Predis\Compatibility\v1_0\Commands\Type',
-
-            /* commands operating on the key space */
-            'keys'               => '\Predis\Compatibility\v1_0\Commands\Keys',
-            'randomkey'          => '\Predis\Compatibility\v1_0\Commands\RandomKey',
-                'randomKey'      => '\Predis\Compatibility\v1_0\Commands\RandomKey',
-            'rename'             => '\Predis\Compatibility\v1_0\Commands\Rename',
-            'renamenx'           => '\Predis\Compatibility\v1_0\Commands\RenamePreserve',
-                'renamePreserve' => '\Predis\Compatibility\v1_0\Commands\RenamePreserve',
-            'expire'             => '\Predis\Compatibility\v1_0\Commands\Expire',
-            'expireat'           => '\Predis\Compatibility\v1_0\Commands\ExpireAt',
-                'expireAt'       => '\Predis\Compatibility\v1_0\Commands\ExpireAt',
-            'dbsize'             => '\Predis\Compatibility\v1_0\Commands\DatabaseSize',
-                'databaseSize'   => '\Predis\Compatibility\v1_0\Commands\DatabaseSize',
-            'ttl'                => '\Predis\Compatibility\v1_0\Commands\TimeToLive',
-                'timeToLive'     => '\Predis\Compatibility\v1_0\Commands\TimeToLive',
-
-            /* commands operating on lists */
-            'rpush'            => '\Predis\Compatibility\v1_0\Commands\ListPushTail',
-                'pushTail'     => '\Predis\Compatibility\v1_0\Commands\ListPushTail',
-            'lpush'            => '\Predis\Compatibility\v1_0\Commands\ListPushHead',
-                'pushHead'     => '\Predis\Compatibility\v1_0\Commands\ListPushHead',
-            'llen'             => '\Predis\Compatibility\v1_0\Commands\ListLength',
-                'listLength'   => '\Predis\Compatibility\v1_0\Commands\ListLength',
-            'lrange'           => '\Predis\Compatibility\v1_0\Commands\ListRange',
-                'listRange'    => '\Predis\Compatibility\v1_0\Commands\ListRange',
-            'ltrim'            => '\Predis\Compatibility\v1_0\Commands\ListTrim',
-                'listTrim'     => '\Predis\Compatibility\v1_0\Commands\ListTrim',
-            'lindex'           => '\Predis\Compatibility\v1_0\Commands\ListIndex',
-                'listIndex'    => '\Predis\Compatibility\v1_0\Commands\ListIndex',
-            'lset'             => '\Predis\Compatibility\v1_0\Commands\ListSet',
-                'listSet'      => '\Predis\Compatibility\v1_0\Commands\ListSet',
-            'lrem'             => '\Predis\Compatibility\v1_0\Commands\ListRemove',
-                'listRemove'   => '\Predis\Compatibility\v1_0\Commands\ListRemove',
-            'lpop'             => '\Predis\Compatibility\v1_0\Commands\ListPopFirst',
-                'popFirst'     => '\Predis\Compatibility\v1_0\Commands\ListPopFirst',
-            'rpop'             => '\Predis\Compatibility\v1_0\Commands\ListPopLast',
-                'popLast'      => '\Predis\Compatibility\v1_0\Commands\ListPopLast',
-
-            /* commands operating on sets */
-            'sadd'                      => '\Predis\Compatibility\v1_0\Commands\SetAdd', 
-                'setAdd'                => '\Predis\Compatibility\v1_0\Commands\SetAdd',
-            'srem'                      => '\Predis\Compatibility\v1_0\Commands\SetRemove', 
-                'setRemove'             => '\Predis\Compatibility\v1_0\Commands\SetRemove',
-            'spop'                      => '\Predis\Compatibility\v1_0\Commands\SetPop',
-                'setPop'                => '\Predis\Compatibility\v1_0\Commands\SetPop',
-            'smove'                     => '\Predis\Compatibility\v1_0\Commands\SetMove', 
-                'setMove'               => '\Predis\Compatibility\v1_0\Commands\SetMove',
-            'scard'                     => '\Predis\Compatibility\v1_0\Commands\SetCardinality', 
-                'setCardinality'        => '\Predis\Compatibility\v1_0\Commands\SetCardinality',
-            'sismember'                 => '\Predis\Compatibility\v1_0\Commands\SetIsMember', 
-                'setIsMember'           => '\Predis\Compatibility\v1_0\Commands\SetIsMember',
-            'sinter'                    => '\Predis\Compatibility\v1_0\Commands\SetIntersection', 
-                'setIntersection'       => '\Predis\Compatibility\v1_0\Commands\SetIntersection',
-            'sinterstore'               => '\Predis\Compatibility\v1_0\Commands\SetIntersectionStore', 
-                'setIntersectionStore'  => '\Predis\Compatibility\v1_0\Commands\SetIntersectionStore',
-            'sunion'                    => '\Predis\Compatibility\v1_0\Commands\SetUnion', 
-                'setUnion'              => '\Predis\Compatibility\v1_0\Commands\SetUnion',
-            'sunionstore'               => '\Predis\Compatibility\v1_0\Commands\SetUnionStore', 
-                'setUnionStore'         => '\Predis\Compatibility\v1_0\Commands\SetUnionStore',
-            'sdiff'                     => '\Predis\Compatibility\v1_0\Commands\SetDifference', 
-                'setDifference'         => '\Predis\Compatibility\v1_0\Commands\SetDifference',
-            'sdiffstore'                => '\Predis\Compatibility\v1_0\Commands\SetDifferenceStore', 
-                'setDifferenceStore'    => '\Predis\Compatibility\v1_0\Commands\SetDifferenceStore',
-            'smembers'                  => '\Predis\Compatibility\v1_0\Commands\SetMembers', 
-                'setMembers'            => '\Predis\Compatibility\v1_0\Commands\SetMembers',
-            'srandmember'               => '\Predis\Compatibility\v1_0\Commands\SetRandomMember', 
-                'setRandomMember'       => '\Predis\Compatibility\v1_0\Commands\SetRandomMember',
-
-            /* multiple databases handling commands */
-            'select'                => '\Predis\Compatibility\v1_0\Commands\SelectDatabase', 
-                'selectDatabase'    => '\Predis\Compatibility\v1_0\Commands\SelectDatabase',
-            'move'                  => '\Predis\Compatibility\v1_0\Commands\MoveKey', 
-                'moveKey'           => '\Predis\Compatibility\v1_0\Commands\MoveKey',
-            'flushdb'               => '\Predis\Compatibility\v1_0\Commands\FlushDatabase', 
-                'flushDatabase'     => '\Predis\Compatibility\v1_0\Commands\FlushDatabase',
-            'flushall'              => '\Predis\Compatibility\v1_0\Commands\FlushAll', 
-                'flushDatabases'    => '\Predis\Compatibility\v1_0\Commands\FlushAll',
-
-            /* sorting */
-            'sort'                  => '\Predis\Compatibility\v1_0\Commands\Sort',
-
-            /* remote server control commands */
-            'info'                  => '\Predis\Compatibility\v1_0\Commands\Info',
-            'slaveof'               => '\Predis\Compatibility\v1_0\Commands\SlaveOf', 
-                'slaveOf'           => '\Predis\Compatibility\v1_0\Commands\SlaveOf',
-
-            /* persistence control commands */
-            'save'                  => '\Predis\Compatibility\v1_0\Commands\Save',
-            'bgsave'                => '\Predis\Compatibility\v1_0\Commands\BackgroundSave', 
-                'backgroundSave'    => '\Predis\Compatibility\v1_0\Commands\BackgroundSave',
-            'lastsave'              => '\Predis\Compatibility\v1_0\Commands\LastSave', 
-                'lastSave'          => '\Predis\Compatibility\v1_0\Commands\LastSave',
-            'shutdown'              => '\Predis\Compatibility\v1_0\Commands\Shutdown',
-        );
-    }
-}
-
-/* ------------------------------------------------------------------------- */
-
-namespace Predis\Compatibility\v1_0\Commands;
-
-/* miscellaneous commands */
-class Ping extends  \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'PING'; }
-    public function parseResponse($data) {
-        return $data === 'PONG' ? true : false;
-    }
-}
-
-class DoEcho extends \Predis\BulkCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'ECHO'; }
-}
-
-class Auth extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'AUTH'; }
-}
-
-/* connection handling */
-class Quit extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'QUIT'; }
-    public function closesConnection() { return true; }
-}
-
-/* commands operating on string values */
-class Set extends \Predis\BulkCommand {
-    public function getCommandId() { return 'SET'; }
-}
-
-class SetPreserve extends \Predis\BulkCommand {
-    public function getCommandId() { return 'SETNX'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class Get extends \Predis\InlineCommand {
-    public function getCommandId() { return 'GET'; }
-}
-
-class GetMultiple extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'MGET'; }
-}
-
-class GetSet extends \Predis\BulkCommand {
-    public function getCommandId() { return 'GETSET'; }
-}
-
-class Increment extends \Predis\InlineCommand {
-    public function getCommandId() { return 'INCR'; }
-}
-
-class IncrementBy extends \Predis\InlineCommand {
-    public function getCommandId() { return 'INCRBY'; }
-}
-
-class Decrement extends \Predis\InlineCommand {
-    public function getCommandId() { return 'DECR'; }
-}
-
-class DecrementBy extends \Predis\InlineCommand {
-    public function getCommandId() { return 'DECRBY'; }
-}
-
-class Exists extends \Predis\InlineCommand {
-    public function getCommandId() { return 'EXISTS'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class Delete extends \Predis\InlineCommand {
-    public function getCommandId() { return 'DEL'; }
-}
-
-class Type extends \Predis\InlineCommand {
-    public function getCommandId() { return 'TYPE'; }
-}
-
-/* commands operating on the key space */
-class Keys extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'KEYS'; }
-    public function parseResponse($data) { 
-        return strlen($data) > 0 ? explode(' ', $data) : array();
-    }
-}
-
-class RandomKey extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'RANDOMKEY'; }
-    public function parseResponse($data) { return $data !== '' ? $data : null; }
-}
-
-class Rename extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'RENAME'; }
-}
-
-class RenamePreserve extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'RENAMENX'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class Expire extends \Predis\InlineCommand {
-    public function getCommandId() { return 'EXPIRE'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class ExpireAt extends \Predis\InlineCommand {
-    public function getCommandId() { return 'EXPIREAT'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class DatabaseSize extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'DBSIZE'; }
-}
-
-class TimeToLive extends \Predis\InlineCommand {
-    public function getCommandId() { return 'TTL'; }
-}
-
-/* commands operating on lists */
-class ListPushTail extends \Predis\BulkCommand {
-    public function getCommandId() { return 'RPUSH'; }
-}
-
-class ListPushHead extends \Predis\BulkCommand {
-    public function getCommandId() { return 'LPUSH'; }
-}
-
-class ListLength extends \Predis\InlineCommand {
-    public function getCommandId() { return 'LLEN'; }
-}
-
-class ListRange extends \Predis\InlineCommand {
-    public function getCommandId() { return 'LRANGE'; }
-}
-
-class ListTrim extends \Predis\InlineCommand {
-    public function getCommandId() { return 'LTRIM'; }
-}
-
-class ListIndex extends \Predis\InlineCommand {
-    public function getCommandId() { return 'LINDEX'; }
-}
-
-class ListSet extends \Predis\BulkCommand {
-    public function getCommandId() { return 'LSET'; }
-}
-
-class ListRemove extends \Predis\BulkCommand {
-    public function getCommandId() { return 'LREM'; }
-}
-
-class ListPopFirst extends \Predis\InlineCommand {
-    public function getCommandId() { return 'LPOP'; }
-}
-
-class ListPopLast extends \Predis\InlineCommand {
-    public function getCommandId() { return 'RPOP'; }
-}
-
-/* commands operating on sets */
-class SetAdd extends \Predis\BulkCommand {
-    public function getCommandId() { return 'SADD'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class SetRemove extends \Predis\BulkCommand {
-    public function getCommandId() { return 'SREM'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class SetPop  extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SPOP'; }
-}
-
-class SetMove extends \Predis\BulkCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'SMOVE'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class SetCardinality extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SCARD'; }
-}
-
-class SetIsMember extends \Predis\BulkCommand {
-    public function getCommandId() { return 'SISMEMBER'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class SetIntersection extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SINTER'; }
-}
-
-class SetIntersectionStore extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SINTERSTORE'; }
-}
-
-class SetUnion extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SUNION'; }
-}
-
-class SetUnionStore extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SUNIONSTORE'; }
-}
-
-class SetDifference extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SDIFF'; }
-}
-
-class SetDifferenceStore extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SDIFFSTORE'; }
-}
-
-class SetMembers extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SMEMBERS'; }
-}
-
-class SetRandomMember extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SRANDMEMBER'; }
-}
-
-/* multiple databases handling commands */
-class SelectDatabase extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'SELECT'; }
-}
-
-class MoveKey extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'MOVE'; }
-    public function parseResponse($data) { return (bool) $data; }
-}
-
-class FlushDatabase extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'FLUSHDB'; }
-}
-
-class FlushAll extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'FLUSHALL'; }
-}
-
-/* sorting */
-class Sort extends \Predis\InlineCommand {
-    public function getCommandId() { return 'SORT'; }
-    public function filterArguments(Array $arguments) {
-        if (count($arguments) === 1) {
-            return $arguments;
-        }
-
-        // TODO: add more parameters checks
-        $query = array($arguments[0]);
-        $sortParams = $arguments[1];
-
-        if (isset($sortParams['by'])) {
-            $query[] = 'BY';
-            $query[] = $sortParams['by'];
-        }
-        if (isset($sortParams['get'])) {
-            $getargs = $sortParams['get'];
-            if (is_array($getargs)) {
-                foreach ($getargs as $getarg) {
-                    $query[] = 'GET';
-                    $query[] = $getarg;
-                }
-            }
-            else {
-                $query[] = 'GET';
-                $query[] = $getargs;
-            }
-        }
-        if (isset($sortParams['limit']) && is_array($sortParams['limit'])) {
-            $query[] = 'LIMIT';
-            $query[] = $sortParams['limit'][0];
-            $query[] = $sortParams['limit'][1];
-        }
-        if (isset($sortParams['sort'])) {
-            $query[] = strtoupper($sortParams['sort']);
-        }
-        if (isset($sortParams['alpha']) && $sortParams['alpha'] == true) {
-            $query[] = 'ALPHA';
-        }
-        if (isset($sortParams['store']) && $sortParams['store'] == true) {
-            $query[] = 'STORE';
-            $query[] = $sortParams['store'];
-        }
-
-        return $query;
-    }
-}
-
-/* persistence control commands */
-class Save extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'SAVE'; }
-}
-
-class BackgroundSave extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'BGSAVE'; }
-    public function parseResponse($data) {
-        if ($data == 'Background saving started') {
-            return true;
-        }
-        return $data;
-    }
-}
-
-class LastSave extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'LASTSAVE'; }
-}
-
-class Shutdown extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'SHUTDOWN'; }
-    public function closesConnection() { return true; }
-}
-
-/* remote server control commands */
-class Info extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'INFO'; }
-    public function parseResponse($data) {
-        $info      = array();
-        $infoLines = explode("\r\n", $data, -1);
-        foreach ($infoLines as $row) {
-            list($k, $v) = explode(':', $row);
-            if (!preg_match('/^db\d+$/', $k)) {
-                $info[$k] = $v;
-            }
-            else {
-                $db = array();
-                foreach (explode(',', $v) as $dbvar) {
-                    list($dbvk, $dbvv) = explode('=', $dbvar);
-                    $db[trim($dbvk)] = $dbvv;
-                }
-                $info[$k] = $db;
-            }
-        }
-        return $info;
-    }
-}
-
-class SlaveOf extends \Predis\InlineCommand {
-    public function canBeHashed()  { return false; }
-    public function getCommandId() { return 'SLAVEOF'; }
-    public function filterArguments(Array $arguments) {
-        if (count($arguments) === 0 || $arguments[0] === 'NO ONE') {
-            return array('NO', 'ONE');
-        }
-        return $arguments;
-    }
-}
-?>

phpstan-tests.dist.neon

@@ -0,0 +1,15 @@
+parameters:
+  level: 0
+
+  paths:
+    - tests/
+
+  ignoreErrors:
+    # Uses func_get_args()
+    - message: "#^Static method Predis\\\\Command\\\\RawCommand\\:\\:create\\(\\) invoked with 0 parameters, at least 1 required\\.$#"
+      count: 1
+      path: tests/Predis/Command/RawCommandTest.php
+    # Mockery
+    - message: "#^Call to an undefined method Predis\\\\Configuration\\\\Option\\\\AggregateTest\\:\\:getMockConnectionClass\\(\\)\\.$#"
+      count: 2
+      path: tests/Predis/Configuration/Option/AggregateTest.php

phpstan.dist.neon

@@ -0,0 +1,56 @@
+parameters:
+  level: 2
+
+  paths:
+    - src/
+
+  ignoreErrors:
+    # Tricky ones
+    - message: "#^Cannot cast Predis\\\\Response\\\\ResponseInterface to string\\.$#"
+      count: 1
+      path: src/Client.php
+    - message: "#^Cannot cast Predis\\\\Connection\\\\ConnectionInterface to string\\.$#"
+      count: 1
+      path: src/Client.php
+    # phpiredis extension is not installed
+    - "#^Function phpiredis_\\w+ not found\\.$#"
+    - "#^Constant PHPIREDIS_#"
+    # "new static" in non-final classes
+    - message: "#^Unsafe usage of new static\\(\\)\\.$#"
+      count: 3
+      path: src/Client.php
+    - message: "#^Unsafe usage of new static\\(\\)\\.$#"
+      count: 1
+      path: src/Connection/Parameters.php
+    # Using an interface as concrete type
+    - message: "#^Call to an undefined method Predis\\\\Command\\\\FactoryInterface\\:\\:define\\(\\)\\.$#"
+      count: 1
+      path: src/Configuration/Option/Commands.php
+    - message: "#^Call to an undefined method Predis\\\\Command\\\\FactoryInterface\\:\\:undefine\\(\\)\\.$#"
+      count: 1
+      path: src/Configuration/Option/Commands.php
+    - message: "#^Access to an undefined property Predis\\\\Configuration\\\\OptionsInterface\\:\\:\\$parameters\\.$#"
+      count: 1
+      path: src/Configuration/Option/Connections.php
+    - message: "#^Access to an undefined property Predis\\\\Connection\\\\ParametersInterface\\:\\:\\$weight\\.$#"
+      count: 1
+      path: src/Connection/Cluster/PredisCluster.php
+    - message: "#^Variable \\$response might not be defined\\.$#"
+      count: 2
+      path: src/Connection/Cluster/RedisCluster.php
+    - message: "#^Access to an undefined property Predis\\\\Connection\\\\ParametersInterface\\:\\:\\$role\\.$#"
+      count: 1
+      path: src/Connection/Replication/MasterSlaveReplication.php
+    - message: "#^Access to an undefined property Predis\\\\Connection\\\\ParametersInterface\\:\\:\\$role\\.$#"
+      count: 1
+      path: src/Connection/Replication/SentinelReplication.php
+    # try/catch problems
+    - message: "#^Variable \\$connection might not be defined\\.$#"
+      count: 1
+      path: src/Connection/Replication/MasterSlaveReplication.php
+    - message: "#^Variable \\$response might not be defined\\.$#"
+      count: 1
+      path: src/Connection/Replication/MasterSlaveReplication.php
+    - message: "#^Variable \\$response might not be defined\\.$#"
+      count: 1
+      path: src/Connection/Replication/SentinelReplication.php

phpunit.relay.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit
+    bootstrap="tests/bootstrap.php"
+    colors="true"
+    convertErrorsToExceptions="true"
+    convertNoticesToExceptions="true"
+    convertWarningsToExceptions="true"
+    processIsolation="false"
+    stopOnError="false"
+    stopOnFailure="false"
+    beStrictAboutTestsThatDoNotTestAnything="true"
+>
+
+    <testsuites>
+        <testsuite name="Predis Test Suite">
+            <directory phpVersion="7.4">tests/Predis/</directory>
+        </testsuite>
+    </testsuites>
+
+    <groups>
+        <exclude>
+            <group>relay-incompatible</group>
+            <group>relay-resp3</group>
+            <group>realm-webdis</group>
+            <group>realm-stack</group>
+            <group>ext-curl</group>
+            <group>ext-phpiredis</group>
+            <group>cluster</group>
+        </exclude>
+    </groups>
+
+    <filter>
+        <whitelist>
+            <directory suffix=".php">src/</directory>
+        </whitelist>
+    </filter>
+
+    <php>
+        <const name="REDIS_SERVER_HOST" value="127.0.0.1" />
+        <const name="REDIS_SERVER_PORT" value="6379" />
+        <const name="REDIS_SERVER_DBNUM" value="0" />
+        <env name="USE_RELAY" value="true" />
+        <env name="REDIS_STACK_SERVER_PORT" value="6479" />
+
+        <!-- Redis Cluster -->
+        <!-- Only master nodes endpoints included -->
+        <const name="REDIS_CLUSTER_ENDPOINTS" value="127.0.0.1:6372,127.0.0.1:6373,127.0.0.1:6374" />
+    </php>
+</phpunit>

phpunit.xml.dist

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit
+    bootstrap="tests/bootstrap.php"
+    colors="true"
+    convertErrorsToExceptions="true"
+    convertNoticesToExceptions="true"
+    convertWarningsToExceptions="true"
+    processIsolation="false"
+    stopOnError="false"
+    stopOnFailure="false"
+    beStrictAboutTestsThatDoNotTestAnything="true"
+>
+
+    <testsuites>
+        <testsuite name="Predis Test Suite">
+            <directory>tests/Predis/</directory>
+        </testsuite>
+    </testsuites>
+
+    <coverage processUncoveredFiles="true">
+        <include>
+            <directory suffix=".php">./src</directory>
+        </include>
+        <report>
+            <clover outputFile="build/logs/clover.xml"/>
+        </report>
+    </coverage>
+
+    <groups>
+        <exclude>
+            <group>realm-webdis</group>
+            <group>realm-stack</group>
+            <group>ext-relay</group>
+            <group>ext-curl</group>
+            <group>ext-phpiredis</group>
+            <group>cluster</group>
+            <!-- <group>connected</group> -->
+            <!-- <group>disconnected</group> -->
+            <!-- <group>commands</group> -->
+            <!-- <group>slow</group> -->
+        </exclude>
+    </groups>
+
+    <filter>
+        <whitelist>
+            <directory suffix=".php">src/</directory>
+        </whitelist>
+    </filter>
+
+    <php>
+        <const name="REDIS_SERVER_HOST" value="127.0.0.1" />
+        <const name="REDIS_SERVER_PORT" value="6379" />
+        <const name="REDIS_SERVER_DBNUM" value="0" />
+        <env name="USE_RELAY" value="false" />
+        <env name="REDIS_STACK_SERVER_PORT" value="6479" />
+
+        <!-- Redis Cluster -->
+        <!-- Only master nodes endpoints included -->
+        <const name="REDIS_CLUSTER_ENDPOINTS" value="127.0.0.1:6372,127.0.0.1:6373,127.0.0.1:6374" />
+    </php>
+</phpunit>

src/Autoloader.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+/**
+ * Implements a lightweight PSR-0 compliant autoloader for Predis.
+ *
+ * @author Eric Naeseth <eric@thumbtack.com>
+ * @author Daniele Alessandri <suppakilla@gmail.com>
+ * @codeCoverageIgnore
+ */
+class Autoloader
+{
+    private $directory;
+    private $prefix;
+    private $prefixLength;
+
+    /**
+     * @param string $baseDirectory Base directory where the source files are located.
+     */
+    public function __construct($baseDirectory = __DIR__)
+    {
+        $this->directory = $baseDirectory;
+        $this->prefix = __NAMESPACE__ . '\\';
+        $this->prefixLength = strlen($this->prefix);
+    }
+
+    /**
+     * Registers the autoloader class with the PHP SPL autoloader.
+     *
+     * @param bool $prepend Prepend the autoloader on the stack instead of appending it.
+     */
+    public static function register($prepend = false)
+    {
+        spl_autoload_register([new self(), 'autoload'], true, $prepend);
+    }
+
+    /**
+     * Loads a class from a file using its fully qualified name.
+     *
+     * @param string $className Fully qualified name of a class.
+     */
+    public function autoload($className)
+    {
+        if (0 === strpos($className, $this->prefix)) {
+            $parts = explode('\\', substr($className, $this->prefixLength));
+            $filepath = $this->directory . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $parts) . '.php';
+
+            if (is_file($filepath)) {
+                require $filepath;
+            }
+        }
+    }
+}

src/Client.php

@@ -0,0 +1,612 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+use ArrayIterator;
+use InvalidArgumentException;
+use IteratorAggregate;
+use Predis\Command\CommandInterface;
+use Predis\Command\RawCommand;
+use Predis\Command\Redis\Container\ContainerFactory;
+use Predis\Command\Redis\Container\ContainerInterface;
+use Predis\Command\ScriptCommand;
+use Predis\Configuration\Options;
+use Predis\Configuration\OptionsInterface;
+use Predis\Connection\ConnectionInterface;
+use Predis\Connection\Parameters;
+use Predis\Connection\ParametersInterface;
+use Predis\Connection\RelayConnection;
+use Predis\Monitor\Consumer as MonitorConsumer;
+use Predis\Pipeline\Atomic;
+use Predis\Pipeline\FireAndForget;
+use Predis\Pipeline\Pipeline;
+use Predis\Pipeline\RelayAtomic;
+use Predis\Pipeline\RelayPipeline;
+use Predis\PubSub\Consumer as PubSubConsumer;
+use Predis\PubSub\RelayConsumer as RelayPubSubConsumer;
+use Predis\Response\ErrorInterface as ErrorResponseInterface;
+use Predis\Response\ResponseInterface;
+use Predis\Response\ServerException;
+use Predis\Transaction\MultiExec as MultiExecTransaction;
+use ReturnTypeWillChange;
+use RuntimeException;
+use Traversable;
+
+/**
+ * Client class used for connecting and executing commands on Redis.
+ *
+ * This is the main high-level abstraction of Predis upon which various other
+ * abstractions are built. Internally it aggregates various other classes each
+ * one with its own responsibility and scope.
+ *
+ * @template-implements \IteratorAggregate<string, static>
+ */
+class Client implements ClientInterface, IteratorAggregate
+{
+    public const VERSION = '2.4.0';
+
+    /** @var OptionsInterface */
+    private $options;
+
+    /** @var ConnectionInterface */
+    private $connection;
+
+    /** @var Command\FactoryInterface */
+    private $commands;
+
+    /**
+     * @param mixed $parameters Connection parameters for one or more servers.
+     * @param mixed $options    Options to configure some behaviours of the client.
+     */
+    public function __construct($parameters = null, $options = null)
+    {
+        $this->options = static::createOptions($options ?? new Options());
+        $this->connection = static::createConnection($this->options, $parameters ?? new Parameters());
+        $this->commands = $this->options->commands;
+    }
+
+    /**
+     * Creates a new set of client options for the client.
+     *
+     * @param array|OptionsInterface $options Set of client options
+     *
+     * @return OptionsInterface
+     * @throws InvalidArgumentException
+     */
+    protected static function createOptions($options)
+    {
+        if (is_array($options)) {
+            return new Options($options);
+        } elseif ($options instanceof OptionsInterface) {
+            return $options;
+        } else {
+            throw new InvalidArgumentException('Invalid type for client options');
+        }
+    }
+
+    /**
+     * Creates single or aggregate connections from supplied arguments.
+     *
+     * This method accepts the following types to create a connection instance:
+     *
+     *  - Array (dictionary: single connection, indexed: aggregate connections)
+     *  - String (URI for a single connection)
+     *  - Callable (connection initializer callback)
+     *  - Instance of Predis\Connection\ParametersInterface (used as-is)
+     *  - Instance of Predis\Connection\ConnectionInterface (returned as-is)
+     *
+     * When a callable is passed, it receives the original set of client options
+     * and must return an instance of Predis\Connection\ConnectionInterface.
+     *
+     * Connections are created using the connection factory (in case of single
+     * connections) or a specialized aggregate connection initializer (in case
+     * of cluster and replication) retrieved from the supplied client options.
+     *
+     * @param OptionsInterface $options    Client options container
+     * @param mixed            $parameters Connection parameters
+     *
+     * @return ConnectionInterface
+     * @throws InvalidArgumentException
+     */
+    protected static function createConnection(OptionsInterface $options, $parameters)
+    {
+        if ($parameters instanceof ConnectionInterface) {
+            return $parameters;
+        }
+
+        if ($parameters instanceof ParametersInterface || is_string($parameters)) {
+            return $options->connections->create($parameters);
+        }
+
+        if (is_array($parameters)) {
+            if (!isset($parameters[0])) {
+                return $options->connections->create($parameters);
+            } elseif ($options->defined('cluster') && $initializer = $options->cluster) {
+                return $initializer($parameters, true);
+            } elseif ($options->defined('replication') && $initializer = $options->replication) {
+                return $initializer($parameters, true);
+            } elseif ($options->defined('aggregate') && $initializer = $options->aggregate) {
+                return $initializer($parameters, false);
+            } else {
+                throw new InvalidArgumentException(
+                    'Array of connection parameters requires `cluster`, `replication` or `aggregate` client option'
+                );
+            }
+        }
+
+        if (is_callable($parameters)) {
+            $connection = call_user_func($parameters, $options);
+
+            if (!$connection instanceof ConnectionInterface) {
+                throw new InvalidArgumentException('Callable parameters must return a valid connection');
+            }
+
+            return $connection;
+        }
+
+        throw new InvalidArgumentException('Invalid type for connection parameters');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getCommandFactory()
+    {
+        return $this->commands;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOptions()
+    {
+        return $this->options;
+    }
+
+    /**
+     * Creates a new client using a specific underlying connection.
+     *
+     * This method allows to create a new client instance by picking a specific
+     * connection out of an aggregate one, with the same options of the original
+     * client instance.
+     *
+     * The specified selector defines which logic to use to look for a suitable
+     * connection by the specified value. Supported selectors are:
+     *
+     *   - `id`
+     *   - `key`
+     *   - `slot`
+     *   - `command`
+     *   - `alias`
+     *   - `role`
+     *
+     * Internally the client relies on duck-typing and follows this convention:
+     *
+     *   $selector string => getConnectionBy$selector($value) method
+     *
+     * This means that support for specific selectors may vary depending on the
+     * actual logic implemented by connection classes and there is no interface
+     * binding a connection class to implement any of these.
+     *
+     * @param string $selector Type of selector.
+     * @param mixed  $value    Value to be used by the selector.
+     *
+     * @return ClientInterface
+     */
+    public function getClientBy($selector, $value)
+    {
+        $selector = strtolower($selector);
+
+        if (!in_array($selector, ['id', 'key', 'slot', 'role', 'alias', 'command'])) {
+            throw new InvalidArgumentException("Invalid selector type: `$selector`");
+        }
+
+        if (!method_exists($this->connection, $method = "getConnectionBy$selector")) {
+            $class = get_class($this->connection);
+            throw new InvalidArgumentException("Selecting connection by $selector is not supported by $class");
+        }
+
+        if (!$connection = $this->connection->$method($value)) {
+            throw new InvalidArgumentException("Cannot find a connection by $selector matching `$value`");
+        }
+
+        return new static($connection, $this->getOptions());
+    }
+
+    /**
+     * Opens the underlying connection and connects to the server.
+     */
+    public function connect()
+    {
+        $this->connection->connect();
+    }
+
+    /**
+     * Closes the underlying connection and disconnects from the server.
+     */
+    public function disconnect()
+    {
+        $this->connection->disconnect();
+    }
+
+    /**
+     * Closes the underlying connection and disconnects from the server.
+     *
+     * This is the same as `Client::disconnect()` as it does not actually send
+     * the `QUIT` command to Redis, but simply closes the connection.
+     */
+    public function quit()
+    {
+        $this->disconnect();
+    }
+
+    /**
+     * Returns the current state of the underlying connection.
+     *
+     * @return bool
+     */
+    public function isConnected()
+    {
+        return $this->connection->isConnected();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getConnection()
+    {
+        return $this->connection;
+    }
+
+    /**
+     * Applies the configured serializer and compression to given value.
+     *
+     * @param  mixed  $value
+     * @return string
+     */
+    public function pack($value)
+    {
+        return $this->connection instanceof RelayConnection
+            ? $this->connection->pack($value)
+            : $value;
+    }
+
+    /**
+     * Deserializes and decompresses to given value.
+     *
+     * @param  mixed  $value
+     * @return string
+     */
+    public function unpack($value)
+    {
+        return $this->connection instanceof RelayConnection
+            ? $this->connection->unpack($value)
+            : $value;
+    }
+
+    /**
+     * Executes a command without filtering its arguments, parsing the response,
+     * applying any prefix to keys or throwing exceptions on Redis errors even
+     * regardless of client options.
+     *
+     * It is possible to identify Redis error responses from normal responses
+     * using the second optional argument which is populated by reference.
+     *
+     * @param array $arguments Command arguments as defined by the command signature.
+     * @param bool  $error     Set to TRUE when Redis returned an error response.
+     *
+     * @return mixed
+     */
+    public function executeRaw(array $arguments, &$error = null)
+    {
+        $error = false;
+        $commandID = array_shift($arguments);
+
+        $response = $this->connection->executeCommand(
+            new RawCommand($commandID, $arguments)
+        );
+
+        if ($response instanceof ResponseInterface) {
+            if ($response instanceof ErrorResponseInterface) {
+                $error = true;
+            }
+
+            return (string) $response;
+        }
+
+        return $response;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function __call($commandID, $arguments)
+    {
+        return $this->executeCommand(
+            $this->createCommand($commandID, $arguments)
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createCommand($commandID, $arguments = [])
+    {
+        return $this->commands->create($commandID, $arguments);
+    }
+
+    /**
+     * @param  string             $name
+     * @return ContainerInterface
+     */
+    public function __get(string $name)
+    {
+        return ContainerFactory::create($this, $name);
+    }
+
+    /**
+     * @param  string $name
+     * @param  mixed  $value
+     * @return mixed
+     */
+    public function __set(string $name, $value)
+    {
+        throw new RuntimeException('Not allowed');
+    }
+
+    /**
+     * @param  string $name
+     * @return mixed
+     */
+    public function __isset(string $name)
+    {
+        throw new RuntimeException('Not allowed');
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function executeCommand(CommandInterface $command)
+    {
+        $response = $this->connection->executeCommand($command);
+
+        if ($response instanceof ResponseInterface) {
+            if ($response instanceof ErrorResponseInterface) {
+                $response = $this->onErrorResponse($command, $response);
+            }
+
+            return $response;
+        }
+
+        return $command->parseResponse($response);
+    }
+
+    /**
+     * Handles -ERR responses returned by Redis.
+     *
+     * @param CommandInterface       $command  Redis command that generated the error.
+     * @param ErrorResponseInterface $response Instance of the error response.
+     *
+     * @return mixed
+     * @throws ServerException
+     */
+    protected function onErrorResponse(CommandInterface $command, ErrorResponseInterface $response)
+    {
+        if ($command instanceof ScriptCommand && $response->getErrorType() === 'NOSCRIPT') {
+            $response = $this->executeCommand($command->getEvalCommand());
+
+            if (!$response instanceof ResponseInterface) {
+                $response = $command->parseResponse($response);
+            }
+
+            return $response;
+        }
+
+        if ($this->options->exceptions) {
+            throw new ServerException($response->getMessage());
+        }
+
+        return $response;
+    }
+
+    /**
+     * Executes the specified initializer method on `$this` by adjusting the
+     * actual invocation depending on the arity (0, 1 or 2 arguments). This is
+     * simply an utility method to create Redis contexts instances since they
+     * follow a common initialization path.
+     *
+     * @param string $initializer Method name.
+     * @param array  $argv        Arguments for the method.
+     *
+     * @return mixed
+     */
+    private function sharedContextFactory($initializer, $argv = null)
+    {
+        switch (count($argv)) {
+            case 0:
+                return $this->$initializer();
+
+            case 1:
+                return is_array($argv[0])
+                    ? $this->$initializer($argv[0])
+                    : $this->$initializer(null, $argv[0]);
+
+            case 2:
+                [$arg0, $arg1] = $argv;
+
+                return $this->$initializer($arg0, $arg1);
+
+            default:
+                return $this->$initializer($this, $argv);
+        }
+    }
+
+    /**
+     * Creates a new pipeline context and returns it, or returns the results of
+     * a pipeline executed inside the optionally provided callable object.
+     *
+     * @param mixed ...$arguments Array of options, a callable for execution, or both.
+     *
+     * @return Pipeline|array
+     */
+    public function pipeline(...$arguments)
+    {
+        return $this->sharedContextFactory('createPipeline', func_get_args());
+    }
+
+    /**
+     * Actual pipeline context initializer method.
+     *
+     * @param array|null $options  Options for the context.
+     * @param mixed      $callable Optional callable used to execute the context.
+     *
+     * @return Pipeline|array
+     */
+    protected function createPipeline(?array $options = null, $callable = null)
+    {
+        if (isset($options['atomic']) && $options['atomic']) {
+            $class = Atomic::class;
+        } elseif (isset($options['fire-and-forget']) && $options['fire-and-forget']) {
+            $class = FireAndForget::class;
+        } else {
+            $class = Pipeline::class;
+        }
+
+        if ($this->connection instanceof RelayConnection) {
+            if (isset($options['atomic']) && $options['atomic']) {
+                $class = RelayAtomic::class;
+            } elseif (isset($options['fire-and-forget']) && $options['fire-and-forget']) {
+                throw new NotSupportedException('The "relay" extension does not support fire-and-forget pipelines.');
+            } else {
+                $class = RelayPipeline::class;
+            }
+        }
+
+        /*
+         * @var ClientContextInterface
+         */
+        $pipeline = new $class($this);
+
+        if (isset($callable)) {
+            return $pipeline->execute($callable);
+        }
+
+        return $pipeline;
+    }
+
+    /**
+     * Creates a new transaction context and returns it, or returns the results
+     * of a transaction executed inside the optionally provided callable object.
+     *
+     * @param mixed ...$arguments Array of options, a callable for execution, or both.
+     *
+     * @return MultiExecTransaction|array
+     */
+    public function transaction(...$arguments)
+    {
+        return $this->sharedContextFactory('createTransaction', func_get_args());
+    }
+
+    /**
+     * Actual transaction context initializer method.
+     *
+     * @param array|null $options  Options for the context.
+     * @param mixed      $callable Optional callable used to execute the context.
+     *
+     * @return MultiExecTransaction|array
+     */
+    protected function createTransaction(?array $options = null, $callable = null)
+    {
+        $transaction = new MultiExecTransaction($this, $options);
+
+        if (isset($callable)) {
+            return $transaction->execute($callable);
+        }
+
+        return $transaction;
+    }
+
+    /**
+     * Creates a new publish/subscribe context and returns it, or starts its loop
+     * inside the optionally provided callable object.
+     *
+     * @param mixed ...$arguments Array of options, a callable for execution, or both.
+     *
+     * @return PubSubConsumer|null
+     */
+    public function pubSubLoop(...$arguments)
+    {
+        return $this->sharedContextFactory('createPubSub', func_get_args());
+    }
+
+    /**
+     * Actual publish/subscribe context initializer method.
+     *
+     * @param array|null $options  Options for the context.
+     * @param mixed      $callable Optional callable used to execute the context.
+     *
+     * @return PubSubConsumer|null
+     */
+    protected function createPubSub(?array $options = null, $callable = null)
+    {
+        if ($this->connection instanceof RelayConnection) {
+            $pubsub = new RelayPubSubConsumer($this, $options);
+        } else {
+            $pubsub = new PubSubConsumer($this, $options);
+        }
+
+        if (!isset($callable)) {
+            return $pubsub;
+        }
+
+        foreach ($pubsub as $message) {
+            if (call_user_func($callable, $pubsub, $message) === false) {
+                $pubsub->stop();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Creates a new monitor consumer and returns it.
+     *
+     * @return MonitorConsumer
+     */
+    public function monitor()
+    {
+        return new MonitorConsumer($this);
+    }
+
+    /**
+     * @return Traversable<string, static>
+     */
+    #[ReturnTypeWillChange]
+    public function getIterator()
+    {
+        $clients = [];
+        $connection = $this->getConnection();
+
+        if (!$connection instanceof Traversable) {
+            return new ArrayIterator([
+                (string) $connection => new static($connection, $this->getOptions()),
+            ]);
+        }
+
+        foreach ($connection as $node) {
+            $clients[(string) $node] = new static($node, $this->getOptions());
+        }
+
+        return new ArrayIterator($clients);
+    }
+}

src/ClientConfiguration.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+class ClientConfiguration
+{
+    /**
+     * @var array{modules: array}|string[][]
+     */
+    private static $config = [
+        'modules' => [
+            ['name' => 'Json', 'commandPrefix' => 'JSON'],
+            ['name' => 'BloomFilter', 'commandPrefix' => 'BF'],
+            ['name' => 'CuckooFilter', 'commandPrefix' => 'CF'],
+            ['name' => 'CountMinSketch', 'commandPrefix' => 'CMS'],
+            ['name' => 'TDigest', 'commandPrefix' => 'TDIGEST'],
+            ['name' => 'TopK', 'commandPrefix' => 'TOPK'],
+            ['name' => 'Search', 'commandPrefix' => 'FT'],
+            ['name' => 'TimeSeries', 'commandPrefix' => 'TS'],
+        ],
+    ];
+
+    /**
+     * Returns available modules with configuration.
+     *
+     * @return array|string[][]
+     */
+    public static function getModules(): array
+    {
+        return self::$config['modules'];
+    }
+}

src/ClientContextInterface.php

@@ -0,0 +1,396 @@
+<?php
+
+/*
+ * This file is part of the Predis package.
+ *
+ * (c) 2009-2020 Daniele Alessandri
+ * (c) 2021-2025 Till Krüss
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Predis;
+
+use Predis\Command\Argument\Geospatial\ByInterface;
+use Predis\Command\Argument\Geospatial\FromInterface;
+use Predis\Command\Argument\Search\AggregateArguments;
+use Predis\Command\Argument\Search\AlterArguments;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\DropArguments;
+use Predis\Command\Argument\Search\ExplainArguments;
+use Predis\Command\Argument\Search\ProfileArguments;
+use Predis\Command\Argument\Search\SchemaFields\FieldInterface;
+use Predis\Command\Argument\Search\SearchArguments;
+use Predis\Command\Argument\Search\SugAddArguments;
+use Predis\Command\Argument\Search\SugGetArguments;
+use Predis\Command\Argument\Search\SynUpdateArguments;
+use Predis\Command\Argument\Server\LimitOffsetCount;
+use Predis\Command\Argument\Server\To;
+use Predis\Command\Argument\TimeSeries\AddArguments;
+use Predis\Command\Argument\TimeSeries\AlterArguments as TSAlterArguments;
+use Predis\Command\Argument\TimeSeries\CreateArguments as TSCreateArguments;
+use Predis\Command\Argument\TimeSeries\DecrByArguments;
+use Predis\Command\Argument\TimeSeries\GetArguments;
+use Predis\Command\Argument\TimeSeries\IncrByArguments;
+use Predis\Command\Argument\TimeSeries\InfoArguments;
+use Predis\Command\Argument\TimeSeries\MGetArguments;
+use Predis\Command\Argument\TimeSeries\MRangeArguments;
+use Predis\Command\Argument\TimeSeries\RangeArguments;
+use Predis\Command\CommandInterface;
+use Predis\Command\Redis\Container\ACL;
+use Predis\Command\Redis\Container\CLUSTER;
+use Predis\Command\Redis\Container\FunctionContainer;
+use Predis\Command\Redis\Container\Json\JSONDEBUG;
+use Predis\Command\Redis\Container\Search\FTCONFIG;
+use Predis\Command\Redis\Container\Search\FTCURSOR;
+use Predis\Command\Redis\HGETEX;
+use Predis\Command\Redis\HSETEX;
+
+/**
+ * Interface defining a client-side context such as a pipeline or transaction.
+ *
+ * @method $this copy(string $source, string $destination, int $db = -1, bool $replace = false)
+ * @method $this del(array|string $keys)
+ * @method $this dump($key)
+ * @method $this exists($key)
+ * @method $this expire($key, $seconds, string $expireOption = '')
+ * @method $this expireat($key, $timestamp, string $expireOption = '')
+ * @method $this expiretime(string $key)
+ * @method $this keys($pattern)
+ * @method $this move($key, $db)
+ * @method $this object($subcommand, $key)
+ * @method $this persist($key)
+ * @method $this pexpire($key, $milliseconds)
+ * @method $this pexpireat($key, $timestamp)
+ * @method $this pttl($key)
+ * @method $this randomkey()
+ * @method $this rename($key, $target)
+ * @method $this renamenx($key, $target)
+ * @method $this scan($cursor, ?array $options = null)
+ * @method $this sort($key, ?array $options = null)
+ * @method $this sort_ro(string $key, ?string $byPattern = null, ?LimitOffsetCount $limit = null, array $getPatterns = [], ?string $sorting = null, bool $alpha = false)
+ * @method $this ttl($key)
+ * @method $this type($key)
+ * @method $this append($key, $value)
+ * @method $this bfadd(string $key, $item)
+ * @method $this bfexists(string $key, $item)
+ * @method $this bfinfo(string $key, string $modifier = '')
+ * @method $this bfinsert(string $key, int $capacity = -1, float $error = -1, int $expansion = -1, bool $noCreate = false, bool $nonScaling = false, string ...$item)
+ * @method $this bfloadchunk(string $key, int $iterator, $data)
+ * @method $this bfmadd(string $key, ...$item)
+ * @method $this bfmexists(string $key, ...$item)
+ * @method $this bfreserve(string $key, float $errorRate, int $capacity, int $expansion = -1, bool $nonScaling = false)
+ * @method $this bfscandump(string $key, int $iterator)
+ * @method $this bitcount(string $key, $start = null, $end = null, string $index = 'byte')
+ * @method $this bitop($operation, $destkey, $key)
+ * @method $this bitfield($key, $subcommand, ...$subcommandArg)
+ * @method $this bitfield_ro(string $key, ?array $encodingOffsetMap = null)
+ * @method $this bitpos($key, $bit, $start = null, $end = null, string $index = 'byte')
+ * @method $this blmpop(int $timeout, array $keys, string $modifier = 'left', int $count = 1)
+ * @method $this bzpopmax(array $keys, int $timeout)
+ * @method $this bzpopmin(array $keys, int $timeout)
+ * @method $this bzmpop(int $timeout, array $keys, string $modifier = 'min', int $count = 1)
+ * @method $this cfadd(string $key, $item)
+ * @method $this cfaddnx(string $key, $item)
+ * @method $this cfcount(string $key, $item)
+ * @method $this cfdel(string $key, $item)
+ * @method $this cfexists(string $key, $item)
+ * @method $this cfloadchunk(string $key, int $iterator, $data)
+ * @method $this cfmexists(string $key, ...$item)
+ * @method $this cfinfo(string $key)
+ * @method $this cfinsert(string $key, int $capacity = -1, bool $noCreate = false, string ...$item)
+ * @method $this cfinsertnx(string $key, int $capacity = -1, bool $noCreate = false, string ...$item)
+ * @method $this cfreserve(string $key, int $capacity, int $bucketSize = -1, int $maxIterations = -1, int $expansion = -1)
+ * @method $this cfscandump(string $key, int $iterator)
+ * @method $this cmsincrby(string $key, string|int...$itemIncrementDictionary)
+ * @method $this cmsinfo(string $key)
+ * @method $this cmsinitbydim(string $key, int $width, int $depth)
+ * @method $this cmsinitbyprob(string $key, float $errorRate, float $probability)
+ * @method $this cmsmerge(string $destination, array $sources, array $weights = [])
+ * @method $this cmsquery(string $key, string ...$item)
+ * @method $this decr($key)
+ * @method $this decrby($key, $decrement)
+ * @method $this failover(?To $to = null, bool $abort = false, int $timeout = -1)
+ * @method $this fcall(string $function, array $keys, ...$args)
+ * @method $this fcall_ro(string $function, array $keys, ...$args)
+ * @method $this ft_list()
+ * @method $this ftaggregate(string $index, string $query, ?AggregateArguments $arguments = null)
+ * @method $this ftaliasadd(string $alias, string $index)
+ * @method $this ftaliasdel(string $alias)
+ * @method $this ftaliasupdate(string $alias, string $index)
+ * @method $this ftalter(string $index, FieldInterface[] $schema, ?AlterArguments $arguments = null)
+ * @method $this ftcreate(string $index, FieldInterface[] $schema, ?CreateArguments $arguments = null)
+ * @method $this ftdictadd(string $dict, ...$term)
+ * @method $this ftdictdel(string $dict, ...$term)
+ * @method $this ftdictdump(string $dict)
+ * @method $this ftdropindex(string $index, ?DropArguments $arguments = null)
+ * @method $this ftexplain(string $index, string $query, ?ExplainArguments $arguments = null)
+ * @method $this ftinfo(string $index)
+ * @method $this ftprofile(string $index, ProfileArguments $arguments)
+ * @method $this ftsearch(string $index, string $query, ?SearchArguments $arguments = null)
+ * @method $this ftspellcheck(string $index, string $query, ?SearchArguments $arguments = null)
+ * @method $this ftsugadd(string $key, string $string, float $score, ?SugAddArguments $arguments = null)
+ * @method $this ftsugdel(string $key, string $string)
+ * @method $this ftsugget(string $key, string $prefix, ?SugGetArguments $arguments = null)
+ * @method $this ftsuglen(string $key)
+ * @method $this ftsyndump(string $index)
+ * @method $this ftsynupdate(string $index, string $synonymGroupId, ?SynUpdateArguments $arguments = null, string ...$terms)
+ * @method $this fttagvals(string $index, string $fieldName)
+ * @method $this get($key)
+ * @method $this getbit($key, $offset)
+ * @method $this getex(string $key, $modifier = '', $value = false)
+ * @method $this getrange($key, $start, $end)
+ * @method $this getdel(string $key)
+ * @method $this getset($key, $value)
+ * @method $this incr($key)
+ * @method $this incrby($key, $increment)
+ * @method $this incrbyfloat($key, $increment)
+ * @method $this mget(array $keys)
+ * @method $this mset(array $dictionary)
+ * @method $this msetnx(array $dictionary)
+ * @method $this psetex($key, $milliseconds, $value)
+ * @method $this set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
+ * @method $this setbit($key, $offset, $value)
+ * @method $this setex($key, $seconds, $value)
+ * @method $this setnx($key, $value)
+ * @method $this setrange($key, $offset, $value)
+ * @method $this strlen($key)
+ * @method $this hdel($key, array $fields)
+ * @method $this hexists($key, $field)
+ * @method $this hexpire(string $key, int $seconds, array $fields, string $flag = null)
+ * @method $this hexpireat(string $key, int $unixTimeSeconds, array $fields, string $flag = null)
+ * @method $this hexpiretime(string $key, array $fields)
+ * @method $this hpersist(string $key, array $fields)
+ * @method $this hpexpire(string $key, int $milliseconds, array $fields, string $flag = null)
+ * @method $this hpexpireat(string $key, int $unixTimeMilliseconds, array $fields, string $flag = null)
+ * @method $this hpexpiretime(string $key, array $fields)
+ * @method $this hget($key, $field)
+ * @method $this hgetex(string $key, array $fields, string $modifier = HGETEX::NULL)
+ * @method $this hgetall($key)
+ * @method $this hgetdel(string $key, array $fields)
+ * @method $this hincrby($key, $field, $increment)
+ * @method $this hincrbyfloat($key, $field, $increment)
+ * @method $this hkeys($key)
+ * @method $this hlen($key)
+ * @method $this hmget($key, array $fields)
+ * @method $this hmset($key, array $dictionary)
+ * @method $this hrandfield(string $key, int $count = 1, bool $withValues = false)
+ * @method $this hscan($key, $cursor, ?array $options = null)
+ * @method $this hset($key, $field, $value)
+ * @method $this hsetex(string $key, array $fieldValueMap, string $setModifier = HSETEX::SET_NULL, string $ttlModifier = HSETEX::TTL_NULL, int|bool $ttlModifierValue = false)
+ * @method $this hsetnx($key, $field, $value)
+ * @method $this httl(string $key, array $fields)
+ * @method $this hpttl(string $key, array $fields)
+ * @method $this hvals($key)
+ * @method $this hstrlen($key, $field)
+ * @method $this jsonarrappend(string $key, string $path = '$', ...$value)
+ * @method $this jsonarrindex(string $key, string $path, string $value, int $start = 0, int $stop = 0)
+ * @method $this jsonarrinsert(string $key, string $path, int $index, string ...$value)
+ * @method $this jsonarrlen(string $key, string $path = '$')
+ * @method $this jsonarrpop(string $key, string $path = '$', int $index = -1)
+ * @method $this jsonarrtrim(string $key, string $path, int $start, int $stop)
+ * @method $this jsonclear(string $key, string $path = '$')
+ * @method $this jsondel(string $key, string $path = '$')
+ * @method $this jsonforget(string $key, string $path = '$')
+ * @method $this jsonget(string $key, string $indent = '', string $newline = '', string $space = '', string ...$paths)
+ * @method $this jsonnumincrby(string $key, string $path, int $value)
+ * @method $this jsonmerge(string $key, string $path, string $value)
+ * @method $this jsonmget(array $keys, string $path)
+ * @method $this jsonmset(string ...$keyPathValue)
+ * @method $this jsonobjkeys(string $key, string $path = '$')
+ * @method $this jsonobjlen(string $key, string $path = '$')
+ * @method $this jsonresp(string $key, string $path = '$')
+ * @method $this jsonset(string $key, string $path, string $value, ?string $subcommand = null)
+ * @method $this jsonstrappend(string $key, string $path, string $value)
+ * @method $this jsonstrlen(string $key, string $path = '$')
+ * @method $this jsontoggle(string $key, string $path)
+ * @method $this jsontype(string $key, string $path = '$')
+ * @method $this blmove(string $source, string $destination, string $where, string $to, int $timeout)
+ * @method $this blpop(array|string $keys, $timeout)
+ * @method $this brpop(array|string $keys, $timeout)
+ * @method $this brpoplpush($source, $destination, $timeout)
+ * @method $this lcs(string $key1, string $key2, bool $len = false, bool $idx = false, int $minMatchLen = 0, bool $withMatchLen = false)
+ * @method $this lindex($key, $index)
+ * @method $this linsert($key, $whence, $pivot, $value)
+ * @method $this llen($key)
+ * @method $this lmove(string $source, string $destination, string $where, string $to)
+ * @method $this lmpop(array $keys, string $modifier = 'left', int $count = 1)
+ * @method $this lpop($key)
+ * @method $this lpush($key, array $values)
+ * @method $this lpushx($key, array $values)
+ * @method $this lrange($key, $start, $stop)
+ * @method $this lrem($key, $count, $value)
+ * @method $this lset($key, $index, $value)
+ * @method $this ltrim($key, $start, $stop)
+ * @method $this rpop($key)
+ * @method $this rpoplpush($source, $destination)
+ * @method $this rpush($key, array $values)
+ * @method $this rpushx($key, array $values)
+ * @method $this sadd($key, array $members)
+ * @method $this scard($key)
+ * @method $this sdiff(array|string $keys)
+ * @method $this sdiffstore($destination, array|string $keys)
+ * @method $this sinter(array|string $keys)
+ * @method $this sintercard(array $keys, int $limit = 0)
+ * @method $this sinterstore($destination, array|string $keys)
+ * @method $this sismember($key, $member)
+ * @method $this smembers($key)
+ * @method $this smismember(string $key, string ...$members)
+ * @method $this smove($source, $destination, $member)
+ * @method $this spop($key, $count = null)
+ * @method $this srandmember($key, $count = null)
+ * @method $this srem($key, $member)
+ * @method $this sscan($key, $cursor, ?array $options = null)
+ * @method $this sunion(array|string $keys)
+ * @method $this sunionstore($destination, array|string $keys)
+ * @method $this tdigestadd(string $key, float ...$value)
+ * @method $this tdigestbyrank(string $key, int ...$rank)
+ * @method $this tdigestbyrevrank(string $key, int ...$reverseRank)
+ * @method $this tdigestcdf(string $key, int ...$value)
+ * @method $this tdigestcreate(string $key, int $compression = 0)
+ * @method $this tdigestinfo(string $key)
+ * @method $this tdigestmax(string $key)
+ * @method $this tdigestmerge(string $destinationKey, array $sourceKeys, int $compression = 0, bool $override = false)
+ * @method $this tdigestquantile(string $key, float ...$quantile)
+ * @method $this tdigestmin(string $key)
+ * @method $this tdigestrank(string $key, ...$value)
+ * @method $this tdigestreset(string $key)
+ * @method $this tdigestrevrank(string $key, float ...$value)
+ * @method $this tdigesttrimmed_mean(string $key, float $lowCutQuantile, float $highCutQuantile)
+ * @method $this topkadd(string $key, ...$items)
+ * @method $this topkincrby(string $key, ...$itemIncrement)
+ * @method $this topkinfo(string $key)
+ * @method $this topklist(string $key, bool $withCount = false)
+ * @method $this topkquery(string $key, ...$items)
+ * @method $this topkreserve(string $key, int $topK, int $width = 8, int $depth = 7, float $decay = 0.9)
+ * @method $this tsadd(string $key, int $timestamp, float $value, ?AddArguments $arguments = null)
+ * @method $this tsalter(string $key, ?TSAlterArguments $arguments = null)
+ * @method $this tscreate(string $key, ?TSCreateArguments $arguments = null)
+ * @method $this tscreaterule(string $sourceKey, string $destKey, string $aggregator, int $bucketDuration, int $alignTimestamp = 0)
+ * @method $this tsdecrby(string $key, float $value, ?DecrByArguments $arguments = null)
+ * @method $this tsdel(string $key, int $fromTimestamp, int $toTimestamp)
+ * @method $this tsdeleterule(string $sourceKey, string $destKey)
+ * @method $this tsget(string $key, ?GetArguments $arguments = null)
+ * @method $this tsincrby(string $key, float $value, ?IncrByArguments $arguments = null)
+ * @method $this tsinfo(string $key, ?InfoArguments $arguments = null)
+ * @method $this tsmadd(mixed ...$keyTimestampValue)
+ * @method $this tsmget(MGetArguments $arguments, string ...$filterExpression)
+ * @method $this tsmrange($fromTimestamp, $toTimestamp, MRangeArguments $arguments)
+ * @method $this tsmrevrange($fromTimestamp, $toTimestamp, MRangeArguments $arguments)
+ * @method $this tsqueryindex(string ...$filterExpression)
+ * @method $this tsrange(string $key, $fromTimestamp, $toTimestamp, ?RangeArguments $arguments = null)
+ * @method $this tsrevrange(string $key, $fromTimestamp, $toTimestamp, ?RangeArguments $arguments = null)
+ * @method $this zadd($key, array $membersAndScoresDictionary)
+ * @method $this zcard($key)
+ * @method $this zcount($key, $min, $max)
+ * @method $this zdiff(array $keys, bool $withScores = false)
+ * @method $this zdiffstore(string $destination, array $keys)
+ * @method $this zincrby($key, $increment, $member)
+ * @method $this zintercard(array $keys, int $limit = 0)
+ * @method $this zinterstore(string $destination, array $keys, int[] $weights = [], string $aggregate = 'sum')
+ * @method $this zinter(array $keys, int[] $weights = [], string $aggregate = 'sum', bool $withScores = false)
+ * @method $this zmpop(array $keys, string $modifier = 'min', int $count = 1)
+ * @method $this zmscore(string $key, string ...$member)
+ * @method $this zrandmember(string $key, int $count = 1, bool $withScores = false)
+ * @method $this zrange($key, $start, $stop, ?array $options = null)
+ * @method $this zrangebyscore($key, $min, $max, ?array $options = null)
+ * @method $this zrangestore(string $destination, string $source, int|string $min, string|int $max, string|bool $by = false, bool $reversed = false, bool $limit = false, int $offset = 0, int $count = 0)
+ * @method $this zrank($key, $member)
+ * @method $this zrem($key, $member)
+ * @method $this zremrangebyrank($key, $start, $stop)
+ * @method $this zremrangebyscore($key, $min, $max)
+ * @method $this zrevrange($key, $start, $stop, ?array $options = null)
+ * @method $this zrevrangebyscore($key, $max, $min, ?array $options = null)
+ * @method $this zrevrank($key, $member)
+ * @method $this zunion(array $keys, int[] $weights = [], string $aggregate = 'sum', bool $withScores = false)
+ * @method $this zunionstore(string $destination, array $keys, int[] $weights = [], string $aggregate = 'sum')
+ * @method $this zscore($key, $member)
+ * @method $this zscan($key, $cursor, ?array $options = null)
+ * @method $this zrangebylex($key, $start, $stop, ?array $options = null)
+ * @method $this zrevrangebylex($key, $start, $stop, ?array $options = null)
+ * @method $this zremrangebylex($key, $min, $max)
+ * @method $this zlexcount($key, $min, $max)
+ * @method $this pexpiretime(string $key)
+ * @method $this pfadd($key, array $elements)
+ * @method $this pfmerge($destinationKey, array|string $sourceKeys)
+ * @method $this pfcount(array|string $keys)
+ * @method $this pubsub($subcommand, $argument)
+ * @method $this publish($channel, $message)
+ * @method $this discard()
+ * @method $this exec()
+ * @method $this multi()
+ * @method $this unwatch()
+ * @method $this waitaof(int $numLocal, int $numReplicas, int $timeout)
+ * @method $this watch($key)
+ * @method $this eval($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method $this eval_ro(string $script, array $keys, ...$argument)
+ * @method $this evalsha($script, $numkeys, $keyOrArg1 = null, $keyOrArgN = null)
+ * @method $this evalsha_ro(string $sha1, array $keys, ...$argument)
+ * @method $this script($subcommand, $argument = null)
+ * @method $this shutdown(?bool $noSave = null, bool $now = false, bool $force = false, bool $abort = false)
+ * @method $this auth($password)
+ * @method $this echo($message)
+ * @method $this ping($message = null)
+ * @method $this select($database)
+ * @method $this bgrewriteaof()
+ * @method $this bgsave()
+ * @method $this client($subcommand, $argument = null)
+ * @method $this config($subcommand, $argument = null)
+ * @method $this dbsize()
+ * @method $this flushall()
+ * @method $this flushdb()
+ * @method $this info($section = null)
+ * @method $this lastsave()
+ * @method $this save()
+ * @method $this slaveof($host, $port)
+ * @method $this slowlog($subcommand, $argument = null)
+ * @method $this time()
+ * @method $this command()
+ * @method $this geoadd($key, $longitude, $latitude, $member)
+ * @method $this geohash($key, array $members)
+ * @method $this geopos($key, array $members)
+ * @method $this geodist($key, $member1, $member2, $unit = null)
+ * @method $this georadius($key, $longitude, $latitude, $radius, $unit, ?array $options = null)
+ * @method $this georadiusbymember($key, $member, $radius, $unit, ?array $options = null)
+ * @method $this geosearch(string $key, FromInterface $from, ByInterface $by, ?string $sorting = null, int $count = -1, bool $any = false, bool $withCoord = false, bool $withDist = false, bool $withHash = false)
+ * @method $this geosearchstore(string $destination, string $source, FromInterface $from, ByInterface $by, ?string $sorting = null, int $count = -1, bool $any = false, bool $storeDist = false)
+ *
+ * Container commands
+ * @property CLUSTER           $cluster
+ * @property FunctionContainer $function
+ * @property FTCONFIG          $ftconfig
+ * @property FTCURSOR          $ftcursor
+ * @property JSONDEBUG         $jsondebug
+ * @property ACL               $acl
+ */
+interface ClientContextInterface
+{
+    /**
+     * Sends the specified command instance to Redis.
+     *
+     * @param CommandInterface $command Command instance.
+     *
+     * @return mixed
+     */
+    public function executeCommand(CommandInterface $command);
+
+    /**
+     * Sends the specified command with its arguments to Redis.
+     *
+     * @param string $method    Command ID.
+     * @param array  $arguments Arguments for the command.
+     *
+     * @return mixed
+     */
+    public function __call($method, $arguments);
+
+    /**
+     * Starts the execution of the context.
+     *
+     * @param mixed $callable Optional callback for execution.
+     *
+     * @return array
+     */
+    public function execute($callable = null);
+}