@valkey/valkey-glide
    Preparing search index...

    Class Batch

    Batch implementation for standalone GlideClient. Batches allow the execution of a group of commands in a single step.

    An array of command responses is returned by the client exec command, in the order they were given. Each element in the array represents a command given to the batch. The response for each command depends on the executed Valkey command. Specific response types are documented alongside each method.

    Indicates whether the batch is atomic or non-atomic. If true, the batch will be executed as an atomic transaction. If false, the batch will be executed as a non-atomic pipeline.

    Standalone Batches are executed on the primary node.

    // Example of Atomic Batch (Transaction)
    const transaction = new Batch(true) // Atomic (Transactional)
        .set("key", "value")
        .get("key");
    const result = await client.exec(transaction, true);
    // result contains: OK and "value"
    console.log(result); // ["OK", "value"]

    // Example of Non-Atomic Batch (Pipeline)
    const pipeline = new Batch(false) // Non-Atomic (Pipeline)
        .set("key1", "value1")
        .set("key2", "value2")
        .get("key1")
        .get("key2");
    const result = await client.exec(pipeline, true);
    // result contains: OK, OK, "value1", "value2"
    console.log(result); // ["OK", "OK", "value1", "value2"]

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    commands isAtomic setCommandsIndexes

    Methods

    addAndReturn append bitcount bitfield bitfieldReadOnly bitop bitpos blmove blmpop blpop brpop bzmpop bzpopmax bzpopmin clientGetName clientId configGet configResetStat configRewrite configSet copy customCommand dbsize decr decrBy del dump echo exists expire expireAt expireTime fcall fcallReadonly flushall flushdb functionDelete functionDump functionFlush functionList functionLoad functionRestore functionStats geoadd geodist geohash geopos geosearch geosearchstore get getbit getdel getex getrange hdel hexists hexpire hexpireat hexpiretime hget hgetall hgetex hincrBy hincrByFloat hkeys hlen hmget hpersist hpexpire hpexpireat hpexpiretime hpttl hrandfield hrandfieldCount hrandfieldWithValues hscan hset hsetex hsetnx hstrlen httl hvals incr incrBy incrByFloat info lastsave lcs lcsIdx lcsLen lindex linsert llen lmove lmpop lolwut lpop lpopCount lpos lpush lpushx lrange lrem lset ltrim mget move mset msetnx objectEncoding objectFreq objectIdletime objectRefcount persist pexpire pexpireAt pexpireTime pfadd pfcount pfmerge ping pttl publish pubsubChannels pubsubNumPat pubsubNumSub randomKey rename renamenx restore rpop rpopCount rpush rpushx sadd scard sdiff sdiffstore select set setbit setrange sinter sintercard sinterstore sismember smembers smismember smove sort sortReadOnly sortStore spop spopCount srandmember srandmemberCount srem sscan strlen sunion sunionstore time touch ttl type unlink wait xack xadd xautoclaim xautoclaimJustId xclaim xclaimJustId xdel xgroupCreate xgroupCreateConsumer xgroupDelConsumer xgroupDestroy xgroupSetId xinfoConsumers xinfoGroups xinfoStream xlen xpending xpendingWithOptions xrange xread xreadgroup xrevrange xtrim zadd zaddIncr zcard zcount zdiff zdiffstore zdiffWithScores zincrby zinter zintercard zinterstore zinterWithScores zlexcount zmpop zmscore zpopmax zpopmin zrandmember zrandmemberWithCount zrandmemberWithCountWithScores zrange zrangeStore zrangeWithScores zrank zrankWithScore zrem zremRangeByLex zremRangeByRank zremRangeByScore zrevrank zrevrankWithScore zscan zscore zunion zunionstore zunionWithScores

    Constructors

    • Parameters

      • isAtomic: boolean

        Determines whether the batch is atomic or non-atomic. If true, the batch will be executed as an atomic transaction. If false, the batch will be executed as a non-atomic pipeline.

      Returns Batch

    Properties

    commands: Command[] = []
    isAtomic: boolean

    Determines whether the batch is atomic or non-atomic. If true, the batch will be executed as an atomic transaction. If false, the batch will be executed as a non-atomic pipeline.

    setCommandsIndexes: number[] = []

    Array of command indexes indicating commands that need to be converted into a Set within the batch.

    Methods

    • Adds a command to the batch and returns the batch instance.

      Parameters

      • command: Command

        The command to add.

      • shouldConvertToSet: boolean = false

        Indicates if the command should be converted to a Set.

      Returns Batch

      The updated batch instance.

    • Counts the number of set bits (population counting) in the string stored at key. The options argument can optionally be provided to count the number of bits in a specific string interval.

      Parameters

      • key: GlideString

        The key for the string to count the set bits of.

      • Optionaloptions: BitOffsetOptions

        The offset options - see BitOffsetOptions.

        Command Response - If options is provided, returns the number of set bits in the string interval specified by options. If options is not provided, returns the number of set bits in the string stored at key. Otherwise, if key is missing, returns 0 as it is treated as an empty string.

      Returns Batch

      https://valkey.io/commands/bitcount/|valkey.io for more details.

    • Returns the position of the first bit matching the given bit value. The optional starting offset start is a zero-based index, with 0 being the first byte of the list, 1 being the next byte and so on. The offset can also be a negative number indicating an offset starting at the end of the list, with -1 being the last byte of the list, -2 being the penultimate, and so on.

      Parameters

      • key: GlideString

        The key of the string.

      • bit: number

        The bit value to match. Must be 0 or 1.

      • Optionaloptions: BitOffsetOptions

        (Optional) The BitOffsetOptions.

        Command Response - The position of the first occurrence of bit in the binary value of the string held at key. If start was provided, the search begins at the offset indicated by start.

      Returns Batch

      https://valkey.io/commands/bitpos/|valkey.io for details.

    • Blocks the connection until it pops atomically and removes the left/right-most element to the list stored at source depending on whereFrom, and pushes the element at the first/last element of the list stored at destination depending on whereTo. BLMOVE is the blocking variant of lmove.

      Parameters

      • source: GlideString

        The key to the source list.

      • destination: GlideString

        The key to the destination list.

      • whereFrom: ListDirection

        The ListDirection to remove the element from.

      • whereTo: ListDirection

        The ListDirection to add the element to.

      • timeout: number

        The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely.

        Command Response - The popped element, or null if source does not exist or if the operation timed-out.

      Returns Batch

      https://valkey.io/commands/blmove/|valkey.io for details.

      When in cluster mode, both source and destination must map to the same hash slot.

    • Blocks the connection until it pops one or more elements from the first non-empty list from the provided key. BLMPOP is the blocking variant of lmpop.

      Parameters

      • keys: GlideString[]

        An array of keys to lists.

      • direction: ListDirection

        The direction based on which elements are popped from - see ListDirection.

      • timeout: number

        The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely.

      • Optionalcount: number

        (Optional) The maximum number of popped elements.

        Command Response - A Record which stores the key name where elements were popped out and the array of popped elements. If no member could be popped and the timeout expired, returns null.

      Returns Batch

      https://valkey.io/commands/blmpop/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Blocking list pop primitive. Pop an element from the head of the first list that is non-empty, with the given keys being checked in the order that they are given. Blocks the connection when there are no elements to pop from any of the given lists.

      Parameters

      • keys: GlideString[]

        The keys of the lists to pop from.

      • timeout: number

        The timeout in seconds.

        Command Response - An array containing the key from which the element was popped and the value of the popped element, formatted as [key, value]. If no element could be popped and the timeout expired, returns null.

      Returns Batch

      https://valkey.io/commands/blpop/|valkey.io for details.

      BLPOP is a blocking command, see Blocking Commands for more details and best practices.

    • Blocking list pop primitive. Pop an element from the tail of the first list that is non-empty, with the given keys being checked in the order that they are given. Blocks the connection when there are no elements to pop from any of the given lists.

      Parameters

      • keys: GlideString[]

        The keys of the lists to pop from.

      • timeout: number

        The timeout in seconds.

        Command Response - An array containing the key from which the element was popped and the value of the popped element, formatted as [key, value]. If no element could be popped and the timeout expired, returns null.

      Returns Batch

      https://valkey.io/commands/brpop/|valkey.io for details.

      BRPOP is a blocking command, see Blocking Commands for more details and best practices.

    • Pops a member-score pair from the first non-empty sorted set, with the given keys being checked in the order they are provided. Blocks the connection when there are no members to pop from any of the given sorted sets. BZMPOP is the blocking variant of zmpop.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

      • modifier: ScoreFilter

        The element pop criteria - either ScoreFilter.MIN or ScoreFilter.MAX to pop the member with the lowest/highest score accordingly.

      • timeout: number

        The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely.

      • Optionalcount: number

        (Optional) The number of elements to pop. If not supplied, only one element will be popped.

        Command Response - A two-element array containing the key name of the set from which the element was popped, and a GlideRecord<number> of the popped elements - see GlideRecord. If no member could be popped, returns null.

      Returns Batch

      https://valkey.io/commands/bzmpop/|valkey.io for details.

      BZMPOP is a client blocking command, see Valkey Glide Wiki for more details and best practices.

    • Blocks the connection until it removes and returns a member with the highest score from the first non-empty sorted set, with the given key being checked in the order they are provided. BZPOPMAX is the blocking variant of zpopmax.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

      • timeout: number

        The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely. Since 6.0.0: timeout is interpreted as a double instead of an integer.

        Command Response - An array containing the key where the member was popped out, the member, itself, and the member score. If no member could be popped and the timeout expired, returns null.

      Returns Batch

      https://valkey.io/commands/bzpopmax/|valkey.io for details.

    • Blocks the connection until it removes and returns a member with the lowest score from the first non-empty sorted set, with the given key being checked in the order they are provided. BZPOPMIN is the blocking variant of zpopmin.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

      • timeout: number

        The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely. Since Valkey version 6.0.0: timeout is interpreted as a double instead of an integer.

        Command Response - An array containing the key where the member was popped out, the member, itself, and the member score. If no member could be popped and the timeout expired, returns null.

      Returns Batch

      https://valkey.io/commands/bzpopmin/|valkey.io for details.

    • Reads the configuration parameters of the running server. Starting from server version 7, command supports multiple parameters.

      Parameters

      • parameters: string[]

        A list of configuration parameter names to retrieve values for.

        Command Response - A map of values corresponding to the configuration parameters.

      Returns Batch

      https://valkey.io/commands/config-get/|valkey.io for details.

    • Sets configuration parameters to the specified values. Starting from server version 7, command supports multiple parameters.

      Parameters

      • parameters: Record<string, GlideString>

        A map consisting of configuration parameters and their respective values to set.

        Command Response - "OK" when the configuration was set properly. Otherwise, the command fails with an error.

      Returns Batch

      https://valkey.io/commands/config-set/|valkey.io for details.

    • Copies the value stored at the source to the destination key. If destinationDB is specified, the value will be copied to the database specified, otherwise the current database will be used. When replace is true, removes the destination key first if it already exists, otherwise performs no action.

      Parameters

      • source: GlideString

        The key to the source value.

      • destination: GlideString

        The key where the value should be copied to.

      • Optionaloptions: { destinationDB?: number; replace?: boolean }

      Returns Batch

      https://valkey.io/commands/copy/|valkey.io for details.

      Since Valkey version 6.2.0. destinationDB parameter for cluster mode is supported since Valkey 9.0.0 and above

    • Executes a single command, without checking inputs. Every part of the command, including subcommands, should be added as a separate value in args.

      Parameters

      Returns Batch

      Glide Wiki for details on the restrictions and limitations of the custom command API.

      Command Response - A response from Valkey with an Object.

    • Serialize the value stored at key in a Valkey-specific format and return it to the user.

      Parameters

      • key: GlideString

        The key to serialize.

        Command Response - The serialized value of the data stored at key. If key does not exist, null will be returned.

      Returns Batch

      https://valkey.io/commands/dump/|valkey.io for details.

      To execute a batch with a dump command, the exec command requires Decoder.Bytes to handle the response.

    • Sets a timeout on key in seconds. After the timeout has expired, the key will automatically be deleted. If key already has an existing expire set, the time to live is updated to the new value. If seconds is non-positive number, the key will be deleted rather than expired. The timeout will only be cleared by commands that delete or overwrite the contents of key.

      Parameters

      • key: GlideString

        The key to set timeout on it.

      • seconds: number

        The timeout in seconds.

      • Optionaloptions: { expireOption?: ExpireOptions }

        (Optional) Additional parameters:

        • (Optional) expireOption: the expire option - see ExpireOptions.

        Command Response - true if the timeout was set. false if the timeout was not set. e.g. key doesn't exist, or operation skipped due to the provided arguments.

      Returns Batch

      https://valkey.io/commands/expire/|valkey.io for details.

    • Sets a timeout on key. It takes an absolute Unix timestamp (seconds since January 1, 1970) instead of specifying the number of seconds. A timestamp in the past will delete the key immediately. After the timeout has expired, the key will automatically be deleted. If key already has an existing expire set, the time to live is updated to the new value. The timeout will only be cleared by commands that delete or overwrite the contents of key.

      Parameters

      • key: GlideString

        The key to set timeout on it.

      • unixSeconds: number

        The timeout in an absolute Unix timestamp.

      • Optionaloptions: { expireOption?: ExpireOptions }

        (Optional) Additional parameters:

        • (Optional) expireOption: the expire option - see ExpireOptions.

        Command Response - true if the timeout was set. false if the timeout was not set. e.g. key doesn't exist, or operation skipped due to the provided arguments.

      Returns Batch

      https://valkey.io/commands/expireat/|valkey.io for details.

    • Returns the absolute Unix timestamp (since January 1, 1970) at which the given key will expire, in seconds. To get the expiration with millisecond precision, use pexpiretime.

      Parameters

      • key: GlideString

        The key to determine the expiration value of.

        Command Response - The expiration Unix timestamp in seconds, -2 if key does not exist or -1 if key exists but has no associated expire.

      Returns Batch

      https://valkey.io/commands/expiretime/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Returns the GeoHash strings representing the positions of all the specified members in the sorted set stored at key.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • members: GlideString[]

        The array of members whose GeoHash strings are to be retrieved.

        Command Response - An array of GeoHash strings representing the positions of the specified members stored at key. If a member does not exist in the sorted set, a null value is returned for that member.

      Returns Batch

      https://valkey.io/commands/geohash/|valkey.io for details.

    • Returns the positions (longitude, latitude) of all the specified members of the geospatial index represented by the sorted set at key.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • members: GlideString[]

        The members for which to get the positions.

        Command Response - A 2D Array which represents positions (longitude and latitude) corresponding to the given members. The order of the returned positions matches the order of the input members. If a member does not exist, its position will be null.

      Returns Batch

      https://valkey.io/commands/geopos/|valkey.io for more details.

    • Returns the members of a sorted set populated with geospatial information using geoadd, which are within the borders of the area specified by a given shape.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • searchFrom: SearchOrigin

        The query's center point options, could be one of:

        • MemberOrigin to use the position of the given existing member in the sorted set.

        • CoordOrigin to use the given longitude and latitude coordinates.

      • searchBy: GeoSearchShape

        The query's shape options, could be one of:

        • GeoCircleShape to search inside circular area according to given radius.

        • GeoBoxShape to search inside an axis-aligned rectangle, determined by height and width.

      • OptionalresultOptions: GeoSearchResultOptions

        The optional inputs to request additional information and configure sorting/limiting the results, see GeoSearchResultOptions.

        Command Response - By default, returns an Array of members (locations) names. If any of withCoord, withDist or withHash are set to true in GeoSearchResultOptions, a 2D Array returned, where each sub-array represents a single item in the following order:

        • The member (location) name.
        • The distance from the center as a floating point number, in the same unit specified for searchBy.
        • The geohash of the location as a integer number.
        • The coordinates as a two item array of floating point numbers.

      Returns Batch

      https://valkey.io/commands/geosearch/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Returns the bit value at offset in the string value stored at key. offset must be greater than or equal to zero.

      Parameters

      • key: GlideString

        The key of the string.

      • offset: number

        The index of the bit to return.

        Command Response - The bit at the given offset of the string. Returns 0 if the key is empty or if the offset exceeds the length of the string.

      Returns Batch

      https://valkey.io/commands/getbit/|valkey.io for details.

    • Get the value of key and optionally set its expiration. GETEX is similar to get.

      Parameters

      • key: GlideString

        The key to retrieve from the database.

      • Optionaloptions: { duration: number; type: TimeUnit } | "persist"

        (Optional) set expiriation to the given key. "persist" will retain the time to live associated with the key. Equivalent to PERSIST in the VALKEY API. Otherwise, a TimeUnit and duration of the expire time should be specified.

        Command Response - If key exists, returns the value of key as a string. Otherwise, return null.

      Returns Batch

      https://valkey.io/commands/getex/|valkey.io for more details.

      Since Valkey version 6.2.0.

    • Returns the substring of the string value stored at key, determined by the byte offsets start and end (both are inclusive). Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last character, -2 the penultimate and so forth. If key does not exist, an empty string is returned. If start or end are out of range, returns the substring within the valid range of the string.

      Parameters

      • key: GlideString

        The key of the string.

      • start: number

        The starting byte offset.

      • end: number

        The ending byte offset.

        Command Response - substring extracted from the value stored at key.

      Returns Batch

      https://valkey.io/commands/getrange/|valkey.io for details.

    • Removes the specified fields from the hash stored at key. Specified fields that do not exist within this hash are ignored.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The fields to remove from the hash stored at key.

        Command Response - the number of fields that were removed from the hash, not including specified but non existing fields. If key does not exist, it is treated as an empty hash and it returns 0.

      Returns Batch

      https://valkey.io/commands/hdel/|valkey.io for details.

    • Sets expiration time for hash fields in seconds. Creates the hash if it doesn't exist.

      Parameters

      • key: GlideString

        The key of the hash.

      • seconds: number

        The expiration time in seconds.

      • fields: GlideString[]

        The fields to set expiration for.

      • Optionaloptions: HExpireOptions

        Optional arguments for the HEXPIRE command. See HExpireOptions.

        Command Response - An array of numbers indicating the result for each field: - 1 if expiration was set successfully - 0 if the specified condition (NX, XX, GT, LT) was not met - -2 if the field does not exist or the key does not exist - 2 when called with 0 seconds (field deleted)

      Returns Batch

      https://valkey.io/commands/hexpire/|valkey.io for details.

    • Sets expiration time for hash fields using an absolute Unix timestamp in seconds. Creates the hash if it doesn't exist.

      Parameters

      • key: GlideString

        The key of the hash.

      • unixTimestampSeconds: number

        The expiration time as a Unix timestamp in seconds.

      • fields: GlideString[]

        The fields to set expiration for.

      • Optionaloptions: HExpireOptions

        Optional arguments for the HEXPIREAT command. See HExpireOptions.

        Command Response - An array of numbers indicating the result for each field: - 1 if expiration was set successfully - 0 if the specified condition (NX, XX, GT, LT) was not met - -2 if the field does not exist or the key does not exist - 2 when called with 0 seconds (field deleted)

      Returns Batch

      https://valkey.io/commands/hexpireat/|valkey.io for details.

    • Returns the absolute Unix timestamp (in seconds) at which hash fields will expire.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The list of fields to get the expiration timestamp for.

        Command Response - An array of expiration timestamps in seconds for the specified fields: - For fields with a timeout, returns the absolute Unix timestamp in seconds. - For fields without a timeout, returns -1. - For fields that do not exist, returns -2.

      Returns Batch

      https://valkey.io/commands/hexpiretime/|valkey.io for details.

    • Gets hash fields and optionally sets their expiration.

      Parameters

      Returns Batch

      // Get fields without setting expiration
      batch.hgetex("myHash", ["field1", "field2"]);

      // Get fields and set 30 second expiration
      batch.hgetex(
          "myHash",
          ["field1", "field2"],
          { expiry: { type: TimeUnit.Seconds, count: 30 } }
      );

      // Get fields and remove expiration (make persistent)
      batch.hgetex(
          "myHash",
          ["field1", "field2"],
          { expiry: "PERSIST" }
      );

      // Get fields and set millisecond precision expiration
      batch.hgetex(
          "myHash",
          ["field3"],
          { expiry: { type: TimeUnit.Milliseconds, count: 5000 } }
      );

      Command Response - An array of values associated with the given fields, in the same order as they are requested. For every field that does not exist in the hash, a null value is returned. If key does not exist, returns an array of null values.

      Valkey 9.0.0

      https://valkey.io/commands/hgetex/

    • Increments the number stored at field in the hash stored at key by increment. By using a negative increment value, the value stored at field in the hash stored at key is decremented. If field or key does not exist, it is set to 0 before performing the operation.

      Parameters

      • key: GlideString

        The key of the hash.

      • field: GlideString

        The field in the hash stored at key to increment its value.

        Command Response - the value of field in the hash stored at key after the increment.

      • amount: number

        The amount to increment.

      Returns Batch

      https://valkey.io/commands/hincrby/|valkey.io for details.

    • Increment the string representing a floating point number stored at field in the hash stored at key by increment. By using a negative increment value, the value stored at field in the hash stored at key is decremented. If field or key does not exist, it is set to 0 before performing the operation.

      Parameters

      • key: GlideString

        The key of the hash.

      • field: GlideString

        The field in the hash stored at key to increment its value.

        Command Response - the value of field in the hash stored at key after the increment.

      • amount: number

        The amount to increment.

      Returns Batch

      https://valkey.io/commands/hincrbyfloat/|valkey.io for details.

    • Returns the values associated with the specified fields in the hash stored at key.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The fields in the hash stored at key to retrieve from the database.

        Command Response - a list of values associated with the given fields, in the same order as they are requested. For every field that does not exist in the hash, a null value is returned. If key does not exist, it is treated as an empty hash and it returns a list of null values.

      Returns Batch

      https://valkey.io/commands/hmget/|valkey.io for details.

    • Removes the expiration time associated with each specified field, causing them to persist.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The fields in the hash to remove expiration from.

        Command Response - An array of numbers indicating the result for each field: - 1 if the field's expiration was removed successfully. - -1 if the field exists but has no associated expiration. - -2 if the field does not exist or the key does not exist.

      Returns Batch

      https://valkey.io/commands/hpersist/|valkey.io for details.

    • Sets expiration time for hash fields using an absolute Unix timestamp in milliseconds. Creates the hash if it doesn't exist.

      Parameters

      • key: GlideString

        The key of the hash.

      • unixTimestampMilliseconds: number

        The expiration time as a Unix timestamp in milliseconds.

      • fields: GlideString[]

        The fields to set expiration for.

      • Optionaloptions: HExpireOptions

        Optional arguments for the HPEXPIREAT command. See HExpireOptions.

        Command Response - An array of boolean values indicating whether expiration was set for each field. true if expiration was set, false if the field doesn't exist or the condition wasn't met.

      Returns Batch

      https://valkey.io/commands/hpexpireat/|valkey.io for details.

    • Returns the absolute Unix timestamp (in milliseconds) at which hash fields will expire.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The list of fields to get the expiration timestamp for.

        Command Response - An array of expiration timestamps in milliseconds for the specified fields: - For fields with a timeout, returns the absolute Unix timestamp in milliseconds. - For fields without a timeout, returns -1. - For fields that do not exist, returns -2.

      Returns Batch

      https://valkey.io/commands/hpexpiretime/|valkey.io for details.

    • Returns the remaining time to live of hash fields that have a timeout, in milliseconds.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The list of fields to get the TTL for.

        Command Response - An array of TTL values in milliseconds for the specified fields: - For fields with a timeout, returns the remaining TTL in milliseconds. - For fields without a timeout, returns -1. - For fields that do not exist, returns -2.

      Returns Batch

      https://valkey.io/commands/hpttl/|valkey.io for details.

    • Retrieves up to count random field names from the hash value stored at key.

      Parameters

      • key: GlideString

        The key of the hash.

      • count: number

        The number of field names to return. If count is positive, returns unique elements. If negative, allows for duplicates.

        Command Response - An array of random field names from the hash stored at key, or an empty array when the key does not exist.

      Returns Batch

      https://valkey.io/commands/hrandfield/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Retrieves up to count random field names along with their values from the hash value stored at key.

      Parameters

      • key: GlideString

        The key of the hash.

      • count: number

        The number of field names to return. If count is positive, returns unique elements. If negative, allows for duplicates.

        Command Response - A 2D array of [fieldName, value] arrays, where fieldName is a random field name from the hash and value is the associated value of the field name. If the hash does not exist or is empty, the response will be an empty array.

      Returns Batch

      https://valkey.io/commands/hrandfield/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Iterates incrementally over a hash.

      Parameters

      • key: GlideString

        The key of the set.

      • cursor: string

        The cursor that points to the next iteration of results. A value of "0" indicates the start of the search.

      • Optionaloptions: HScanOptions

        (Optional) The HScanOptions.

        Command Response - An array of the cursor and the subset of the hash held by key. The first element is always the cursor for the next iteration of results. "0" will be the cursor returned on the last iteration of the hash. The second element is always an array of the subset of the hash held in key. The array in the second element is a flattened series of string pairs, where the value is at even indices and the value is at odd indices. If options.noValues is set to true, the second element will only contain the fields without the values.

      Returns Batch

      https://valkey.io/commands/hscan/|valkey.io for more details.

    • Sets hash fields with expiration times and optional conditional changes.

      Parameters

      Returns Batch

      // Set fields with 60 second expiration, only if none exist
      batch.hsetex(
          "myHash",
          { field1: "value1", field2: "value2" },
          {
              fieldConditionalChange: HashFieldConditionalChange.ONLY_IF_NONE_EXIST,
              expiry: { type: TimeUnit.Seconds, count: 60 }
          }
      );

      // Set fields and keep existing TTL
      batch.hsetex(
          "myHash",
          { field3: "value3" },
          { expiry: "KEEPTTL" }
      );

      // Set fields with Unix timestamp expiration
      batch.hsetex(
          "myHash",
          { field4: "value4" },
          { expiry: { type: TimeUnit.UnixSeconds, count: Math.floor(Date.now() / 1000) + 3600 } }
      );

      Command Response - The number of fields that were added to the hash.

      Valkey 9.0.0

      https://valkey.io/commands/hsetex/

    • Returns the remaining time to live of hash fields that have a timeout, in seconds.

      Parameters

      • key: GlideString

        The key of the hash.

      • fields: GlideString[]

        The fields in the hash stored at key to retrieve the TTL for.

        Command Response - An array of TTL values in seconds for the specified fields. - For fields with a timeout, returns the remaining time in seconds. - For fields that exist but have no associated expire, returns -1. - For fields that do not exist, returns -2.

      Returns Batch

      https://valkey.io/commands/httl/|valkey.io for details.

    • Increment the string representing a floating point number stored at key by amount. By using a negative amount value, the result is that the value stored at key is decremented. If key does not exist, it is set to 0 before performing the operation.

      Parameters

      • key: GlideString

        The key to increment its value.

      • amount: number

        The amount to increment.

        Command Response - the value of key after the increment.

      Returns Batch

      https://valkey.io/commands/incrbyfloat/|valkey.io for details.

    • Gets information and statistics about the server.

      Starting from server version 7, command supports multiple section arguments.

      Parameters

      • Optionalsections: InfoOptions[]

        (Optional) A list of InfoOptions values specifying which sections of information to retrieve. When no parameter is provided, Default is assumed.

        Command Response - A string containing the information for the sections requested.

      Returns Batch

      https://valkey.io/commands/info/|valkey.io for details.

    • Returns all the longest common subsequences combined between strings stored at key1 and key2.

      Parameters

      • key1: GlideString

        The key that stores the first string.

      • key2: GlideString

        The key that stores the second string.

        Command Response - A String containing all the longest common subsequence combined between the 2 strings. An empty String is returned if the keys do not exist or have no common subsequences.

      Returns Batch

      https://valkey.io/commands/lcs/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Returns the indices and lengths of the longest common subsequences between strings stored at key1 and key2.

      Parameters

      • key1: GlideString

        The key that stores the first string.

      • key2: GlideString

        The key that stores the second string.

      • Optionaloptions: { minMatchLen?: number; withMatchLen?: boolean }

        (Optional) Additional parameters:

        • (Optional) withMatchLen: if true, include the length of the substring matched for the each match.
        • (Optional) minMatchLen: the minimum length of matches to include in the result.

        Command Response - A GlideRecord containing the indices of the longest common subsequences between the 2 strings and the lengths of the longest common subsequences. The resulting map contains two keys, "matches" and "len": - "len" is mapped to the total length of the all longest common subsequences between the 2 strings stored as an integer. This value doesn't count towards the minMatchLen filter. - "matches" is mapped to a three dimensional array of integers that stores pairs of indices that represent the location of the common subsequences in the strings held by key1 and key2.

        See example of BaseClient.lcsIdx|lcsIdx for more details.

      Returns Batch

      https://valkey.io/commands/lcs/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Returns the element at index index in the list stored at key. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth.

      Parameters

      • key: GlideString

        The key of the list.

      • index: number

        The index of the element in the list to retrieve. Command Response - The element at index in the list stored at key. If index is out of range or if key does not exist, null is returned.

      Returns Batch

      https://valkey.io/commands/lindex/|valkey.io for details.

    • Pops one or more elements from the first non-empty list from the provided keys.

      Parameters

      • keys: GlideString[]

        An array of keys to lists.

      • direction: ListDirection

        The direction based on which elements are popped from - see ListDirection.

      • Optionalcount: number

        (Optional) The maximum number of popped elements.

        Command Response - A Record which stores the key name where elements were popped out and the array of popped elements. If no member could be popped, returns null.

      Returns Batch

      https://valkey.io/commands/lmpop/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Removes and returns up to count elements of the list stored at key, depending on the list's length.

      Parameters

      • key: GlideString

        The key of the list.

      • count: number

        The count of the elements to pop from the list.

        Command Response - A list of the popped elements will be returned depending on the list's length. If key does not exist null will be returned.

      Returns Batch

      https://valkey.io/commands/lpop/|valkey.io for details.

    • Returns the index of the first occurrence of element inside the list specified by key. If no match is found, null is returned. If the count option is specified, then the function returns an array of indices of matching elements within the list.

      Parameters

      • key: GlideString

        The name of the list.

      • element: GlideString

        The value to search for within the list.

      • Optionaloptions: LPosOptions

        (Optional) The LPOS options - see LPosOptions.

        Command Response - The index of element, or null if element is not in the list. If the count option is specified, then the function returns an array of indices of matching elements within the list.

      Returns Batch

      https://valkey.io/commands/lpos/|valkey.io for details.

      Since Valkey version 6.0.6.

    • Inserts all the specified values at the head of the list stored at key. elements are inserted one after the other to the head of the list, from the leftmost element to the rightmost element. If key does not exist, it is created as empty list before performing the push operations.

      Parameters

      • key: GlideString

        The key of the list.

      • elements: GlideString[]

        The elements to insert at the head of the list stored at key.

        Command Response - the length of the list after the push operations.

      Returns Batch

      https://valkey.io/commands/lpush/|valkey.io for details.

    • Returns the specified elements of the list stored at key. The offsets start and end are zero-based indexes, with 0 being the first element of the list, 1 being the next element and so on. These offsets can also be negative numbers indicating offsets starting at the end of the list, with -1 being the last element of the list, -2 being the penultimate, and so on.

      Parameters

      • key: GlideString

        The key of the list.

      • start: number

        The starting point of the range.

      • end: number

        The end of the range.

        Command Response - list of elements in the specified range. If start exceeds the end of the list, or if start is greater than end, an empty list will be returned. If end exceeds the actual end of the list, the range will stop at the actual end of the list. If key does not exist an empty list will be returned.

      Returns Batch

      https://valkey.io/commands/lrange/|valkey.io for details.

    • Removes the first count occurrences of elements equal to element from the list stored at key.

      Parameters

      • key: GlideString

        The key of the list.

      • count: number

        The count of the occurrences of elements equal to element to remove. If count is positive : Removes elements equal to element moving from head to tail. If count is negative : Removes elements equal to element moving from tail to head. If count is 0 or count is greater than the occurrences of elements equal to element: Removes all elements equal to element.

      • element: GlideString

        The element to remove from the list.

        Command Response - the number of the removed elements. If key does not exist, 0 is returned.

      Returns Batch

    • Sets the list element at index to element. The index is zero-based, so 0 means the first element, 1 the second element and so on. Negative indices can be used to designate elements starting at the tail of the list. Here, -1 means the last element, -2 means the penultimate and so forth.

      Parameters

      • key: GlideString

        The key of the list.

      • index: number

        The index of the element in the list to be set.

      • element: GlideString

        The new element to set at the specified index.

        Command Response - Always "OK".

      Returns Batch

      https://valkey.io/commands/lset/|valkey.io for details.

    • Trim an existing list so that it will contain only the specified range of elements specified. The offsets start and end are zero-based indexes, with 0 being the first element of the list, 1 being the next element and so on. These offsets can also be negative numbers indicating offsets starting at the end of the list, with -1 being the last element of the list, -2 being the penultimate, and so on.

      Parameters

      • key: GlideString

        The key of the list.

      • start: number

        The starting point of the range.

      • end: number

        The end of the range.

        Command Response - always "OK". If start exceeds the end of the list, or if start is greater than end, the list is emptied and the key is removed. If end exceeds the actual end of the list, it will be treated like the last element of the list. If key does not exist the command will be ignored.

      Returns Batch

      https://valkey.io/commands/ltrim/|valkey.io for details.

    • Move key from the currently selected database to the database specified by dbIndex.

      Parameters

      • key: GlideString

        The key to move.

      • dbIndex: number

        The index of the database to move key to.

        Command Response - true if key was moved, or false if the key already exists in the destination database or does not exist in the source database.

      Returns Batch

      Move is available for cluster mode since Valkey 9.0.0 and above.

      https://valkey.io/commands/move/|valkey.io for details.

    • Removes the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

      Parameters

      • key: GlideString

        The key to remove the existing timeout on.

        Command Response - false if key does not exist or does not have an associated timeout, true if the timeout has been removed.

      Returns Batch

      https://valkey.io/commands/persist/|valkey.io for details.

    • Sets a timeout on key in milliseconds. After the timeout has expired, the key will automatically be deleted. If key already has an existing expire set, the time to live is updated to the new value. If milliseconds is non-positive number, the key will be deleted rather than expired. The timeout will only be cleared by commands that delete or overwrite the contents of key.

      Parameters

      • key: GlideString

        The key to set timeout on it.

      • milliseconds: number

        The timeout in milliseconds.

      • Optionaloptions: { expireOption?: ExpireOptions }

        (Optional) Additional parameters:

        • (Optional) expireOption: the expire option - see ExpireOptions.

        Command Response - true if the timeout was set. false if the timeout was not set. e.g. key doesn't exist, or operation skipped due to the provided arguments.

      Returns Batch

      https://valkey.io/commands/pexpire/|valkey.io for details.

    • Sets a timeout on key. It takes an absolute Unix timestamp (milliseconds since January 1, 1970) instead of specifying the number of milliseconds. A timestamp in the past will delete the key immediately. After the timeout has expired, the key will automatically be deleted. If key already has an existing expire set, the time to live is updated to the new value. The timeout will only be cleared by commands that delete or overwrite the contents of key.

      Parameters

      • key: GlideString

        The key to set timeout on it.

      • unixMilliseconds: number

        The timeout in an absolute Unix timestamp.

      • Optionaloptions: { expireOption?: ExpireOptions }

        (Optional) Additional parameters:

        • (Optional) expireOption: the expire option - see ExpireOptions.

        Command Response - true if the timeout was set. false if the timeout was not set. e.g. key doesn't exist, or operation skipped due to the provided arguments.

      Returns Batch

      https://valkey.io/commands/pexpireat/|valkey.io for details.

    • Returns the absolute Unix timestamp (since January 1, 1970) at which the given key will expire, in milliseconds.

      Parameters

      • key: GlideString

        The key to determine the expiration value of.

        Command Response - The expiration Unix timestamp in seconds, -2 if key does not exist or -1 if key exists but has no associated expire.

      Returns Batch

      https://valkey.io/commands/pexpiretime/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Adds all elements to the HyperLogLog data structure stored at the specified key. Creates a new structure if the key does not exist. When no elements are provided, and key exists and is a HyperLogLog, then no operation is performed.

      Parameters

      • key: GlideString

        The key of the HyperLogLog data structure to add elements into.

      • elements: GlideString[]

        An array of members to add to the HyperLogLog stored at key. Command Response - If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is altered, then returns true. Otherwise, returns false.

      Returns Batch

      https://valkey.io/commands/pfadd/|valkey.io for details.

    • Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or calculates the combined cardinality of multiple keys by merging their HyperLogLogs temporarily.

      Parameters

      • keys: GlideString[]

        The keys of the HyperLogLog data structures to be analyzed. Command Response - The approximated cardinality of given HyperLogLog data structures. The cardinality of a key that does not exist is 0.

      Returns Batch

      https://valkey.io/commands/pfcount/|valkey.io for details.

    • Merges multiple HyperLogLog values into a unique value. If the destination variable exists, it is treated as one of the source HyperLogLog data sets, otherwise a new HyperLogLog is created.

      Parameters

      • destination: GlideString

        The key of the destination HyperLogLog where the merged data sets will be stored.

      • sourceKeys: GlideString[]

        The keys of the HyperLogLog structures to be merged. Command Response - A simple "OK" response.

      Returns Batch

      https://valkey.io/commands/pfmerge/|valkey.io for details.

    • Pings the server.

      Parameters

      • Optionalmessage: GlideString

        (Optional) A message to include in the PING command.

        • If not provided, the server will respond with "PONG".
        • If provided, the server will respond with a copy of the message.

        Command Response - "PONG" if message is not provided, otherwise return a copy of message.

      Returns Batch

      https://valkey.io/commands/ping/|valkey.io for details.

    • Lists the currently active channels. The command is routed to all nodes, and aggregates the response to a single array.

      Parameters

      • Optionalpattern: GlideString

        A glob-style pattern to match active channels. If not provided, all active channels are returned. Command Response - A list of currently active channels matching the given pattern. If no pattern is specified, all active channels are returned.

      Returns Batch

      https://valkey.io/commands/pubsub-channels/|valkey.io for more details.

    • Returns the number of unique patterns that are subscribed to by clients.

      Note: This is the total number of unique patterns all the clients are subscribed to, not the count of clients subscribed to patterns. The command is routed to all nodes, and aggregates the response to the sum of all pattern subscriptions.

      Returns Batch

      https://valkey.io/commands/pubsub-numpat/|valkey.io for more details.

      Command Response - The number of unique patterns.

    • Create a key associated with a value that is obtained by deserializing the provided serialized value (obtained via dump).

      Parameters

      • key: GlideString

        The key to create.

      • ttl: number

        The expiry time (in milliseconds). If 0, the key will persist.

      • value: Buffer

        The serialized value to deserialize and assign to key.

      • Optionaloptions: RestoreOptions

        (Optional) Restore options RestoreOptions.

        Command Response - Return "OK" if the key was successfully restored with a value.

      Returns Batch

      https://valkey.io/commands/restore/|valkey.io for details.

      options.idletime and options.frequency modifiers cannot be set at the same time.

    • Removes and returns up to count elements from the list stored at key, depending on the list's length.

      Parameters

      • key: GlideString

        The key of the list.

      • count: number

        The count of the elements to pop from the list.

        Command Response - A list of popped elements will be returned depending on the list's length. If key does not exist null will be returned.

      Returns Batch

      https://valkey.io/commands/rpop/|valkey.io for details.

    • Inserts all the specified values at the tail of the list stored at key. elements are inserted one after the other to the tail of the list, from the leftmost element to the rightmost element. If key does not exist, it is created as empty list before performing the push operations.

      Parameters

      • key: GlideString

        The key of the list.

      • elements: GlideString[]

        The elements to insert at the tail of the list stored at key.

        Command Response - the length of the list after the push operations.

      Returns Batch

      https://valkey.io/commands/rpush/|valkey.io for details.

    • Adds the specified members to the set stored at key. Specified members that are already a member of this set are ignored. If key does not exist, a new set is created before adding members.

      Parameters

      • key: GlideString

        The key to store the members to its set.

      • members: GlideString[]

        A list of members to add to the set stored at key.

        Command Response - the number of members that were added to the set, not including all the members already present in the set.

      Returns Batch

      https://valkey.io/commands/sadd/|valkey.io for details.

    • Change the currently selected database.

      WARNING: This command is NOT RECOMMENDED for production use. Upon reconnection, the client will revert to the database_id specified in the client configuration (default: 0), NOT the database selected via this command.

      RECOMMENDED APPROACH: Use the databaseId parameter in client configuration instead of using SELECT in batch operations.

      Parameters

      • index: number

        The index of the database to select.

        Command Response - A simple "OK" response.

      Returns Batch

      https://valkey.io/commands/select/|valkey.io for details.

    • Sets or clears the bit at offset in the string value stored at key. The offset is a zero-based index, with 0 being the first element of the list, 1 being the next element, and so on. The offset must be less than 2^32 and greater than or equal to 0. If a key is non-existent then the bit at offset is set to value and the preceding bits are set to 0.

      Parameters

      • key: GlideString

        The key of the string.

      • offset: number

        The index of the bit to be set.

      • value: number

        The bit value to set at offset. The value must be 0 or 1.

        Command Response - The bit value that was previously stored at offset.

      Returns Batch

      https://valkey.io/commands/setbit/|valkey.io for details.

    • Overwrites part of the string stored at key, starting at the specified byte offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero bytes to make offset fit. Creates the key if it doesn't exist.

      Parameters

      • key: GlideString

        The key of the string to update.

      • offset: number

        The byte position in the string where value should be written.

      • value: GlideString

        The string written with offset.

        Command Response - The length of the string stored at key after it was modified.

      Returns Batch

      https://valkey.io/commands/setrange/|valkey.io for details.

    • Gets the intersection of all the given sets. When in cluster mode, all keys must map to the same hash slot.

      Parameters

      • keys: GlideString[]

        The keys of the sets to get the intersection.

        Command Response - A set of members which are present in all given sets. If one or more sets do not exist, an empty set will be returned.

      Returns Batch

      https://valkey.io/commands/sinter/|valkey.io for details.

    • Gets the cardinality of the intersection of all the given sets.

      Parameters

      • keys: GlideString[]

        The keys of the sets.

      • Optionaloptions: { limit?: number }

        (Optional) Additional parameters:

        • (Optional) limit: the limit for the intersection cardinality value. If not specified, or set to 0, no limit is used.

        Command Response - The cardinality of the intersection result. If one or more sets do not exist, 0 is returned.

      Returns Batch

      https://valkey.io/commands/sintercard/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Sorts the elements in the list, set, or sorted set at key and returns the result.

      The sortReadOnly command can be used to sort elements based on different criteria and apply transformations on sorted elements.

      This command is routed depending on the client's ReadFrom strategy.

      Parameters

      • key: GlideString

        The key of the list, set, or sorted set to be sorted.

      • Optionaloptions: SortOptions

        (Optional) SortOptions.

        Command Response - An Array of sorted elements

      Returns Batch

      Since Valkey version 7.0.0.

    • Removes and returns up to count random members from the set value store at key, depending on the set's length.

      Parameters

      • key: GlideString

        The key of the set.

      • count: number

        The count of the elements to pop from the set.

        Command Response - A list of popped elements will be returned depending on the set's length. If key does not exist, empty list will be returned.

      Returns Batch

      https://valkey.io/commands/spop/|valkey.io for details.

    • Returns one or more random elements from the set value stored at key.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • count: number

        The number of members to return. If count is positive, returns unique members. If count is negative, allows for duplicates members. Command Response - A list of members from the set. If the set does not exist or is empty, an empty list will be returned.

      Returns Batch

      https://valkey.io/commands/srandmember/|valkey.io for more details.

    • Removes the specified members from the set stored at key. Specified members that are not a member of this set are ignored.

      Parameters

      • key: GlideString

        The key to remove the members from its set.

      • members: GlideString[]

        A list of members to remove from the set stored at key.

        Command Response - the number of members that were removed from the set, not including non existing members. If key does not exist, it is treated as an empty set and this command returns 0.

      Returns Batch

      https://valkey.io/commands/srem/|valkey.io for details.

    • Iterates incrementally over a set.

      Parameters

      • key: GlideString

        The key of the set.

      • cursor: GlideString

        The cursor that points to the next iteration of results. A value of "0" indicates the start of the search.

      • Optionaloptions: BaseScanOptions

        The (Optional) BaseScanOptions.

        Command Response - An array of the cursor and the subset of the set held by key. The first element is always the cursor and for the next iteration of results. The cursor will be "0" on the last iteration of the set. The second element is always an array of the subset of the set held in key.

      Returns Batch

      https://valkey.io/commands/sscan for details.

    • Blocks the current client until all the previous write commands are successfully transferred and acknowledged by at least numreplicas of replicas. If timeout is reached, the command returns the number of replicas that were not yet reached.

      Parameters

      • numreplicas: number

        The number of replicas to reach.

      • timeout: number

        The timeout value specified in milliseconds. A value of 0 will block indefinitely.

        Command Response - The number of replicas reached by all the writes performed in the context of the current connection.

      Returns Batch

      https://valkey.io/commands/wait/|valkey.io for more details.

    • Returns the number of messages that were successfully acknowledged by the consumer group member of a stream. This command should be called on a pending message so that such message does not get processed again.

      Parameters

      • key: GlideString

        The key of the stream.

      • group: GlideString

        The consumer group name.

      • ids: string[]

        An array of entry ids.

        Command Response - The number of messages that were successfully acknowledged.

      Returns Batch

      https://valkey.io/commands/xack/|valkey.io for details.

    • Transfers ownership of pending stream entries that match the specified criteria.

      Parameters

      • key: GlideString

        The key of the stream.

      • group: GlideString

        The consumer group name.

      • consumer: GlideString

        The group consumer.

      • minIdleTime: number

        The minimum idle time for the message to be claimed.

      • start: string

        Filters the claimed entries to those that have an ID equal or greater than the specified value.

      • Optionaloptions: { count?: number }

        (Optional) Additional parameters:

        • (Optional) count: the number of claimed entries. Default value is 100.

        Command Response - An array containing the following elements:

        • A stream ID to be used as the start argument for the next call to XAUTOCLAIM. This ID is equivalent to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was scanned.

        • A mapping of the claimed entries.

        • If you are using Valkey 7.0.0 or above, the response list will also include a list containing the message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are deleted from the Pending Entries List.

          The response comes in format [GlideString, GlideRecord<[GlideString, GlideString][]>, GlideString[]?], see GlideRecord.

      Returns Batch

      https://valkey.io/commands/xautoclaim/|valkey.io for more details.

      Since Valkey version 6.2.0.

    • Transfers ownership of pending stream entries that match the specified criteria.

      Parameters

      • key: GlideString

        The key of the stream.

      • group: GlideString

        The consumer group name.

      • consumer: GlideString

        The group consumer.

      • minIdleTime: number

        The minimum idle time for the message to be claimed.

      • start: string

        Filters the claimed entries to those that have an ID equal or greater than the specified value.

      • Optionaloptions: { count?: number }

        (Optional) Additional parameters:

        • (Optional) count: limits the number of claimed entries to the specified value. Default value is 100.

        Command Response - An array containing the following elements:

        • A stream ID to be used as the start argument for the next call to XAUTOCLAIM. This ID is equivalent to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was scanned.
        • A list of the IDs for the claimed entries.
        • If you are using Valkey 7.0.0 or above, the response list will also include a list containing the message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are deleted from the Pending Entries List.

      Returns Batch

      https://valkey.io/commands/xautoclaim/|valkey.io for more details.

      Since Valkey version 6.2.0.

    • Removes the specified entries by id from a stream, and returns the number of entries deleted.

      Parameters

      • key: GlideString

        The key of the stream.

      • ids: string[]

        An array of entry ids.

        Command Response - The number of entries removed from the stream. This number may be less than the number of entries in ids, if the specified ids don't exist in the stream.

      Returns Batch

      https://valkey.io/commands/xdel/|valkey.io for more details.

    • Sets the last delivered ID for a consumer group.

      Parameters

      • key: GlideString

        The key of the stream.

      • groupName: GlideString

        The consumer group name.

      • id: string

        The stream entry ID that should be set as the last delivered ID for the consumer group.

      • Optionaloptions: { entriesRead?: number }

        (Optional) Additional parameters:

        • (Optional) entriesRead: the number of stream entries already read by the group. This option can only be specified if you are using Valkey version 7.0.0 or above.

        Command Response - "OK".

      Returns Batch

      https://valkey.io/commands/xgroup-setid|valkey.io for more details.

    • Returns information about the stream stored at key.

      Parameters

      • key: GlideString

        The key of the stream.

      • OptionalfullOptions: number | boolean

        If true, returns verbose information with a limit of the first 10 PEL entries. If number is specified, returns verbose information limiting the returned PEL entries. If 0 is specified, returns verbose information with no limit.

        Command Response - Detailed stream information for the given key. See example of BaseClient.xinfoStream for more details. The response comes in format GlideRecord<StreamEntries | GlideRecord<StreamEntries | GlideRecord<StreamEntries>[]>[]>, see GlideRecord.

      Returns Batch

    • Returns stream entries matching a given range of entry IDs.

      Parameters

      • key: GlideString

        The key of the stream.

      • start: Boundary<string>

        The starting stream entry ID bound for the range. - Use value to specify a stream entry ID. - Use isInclusive: false to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0. - Use InfBoundary.NegativeInfinity to start with the minimum available ID.

      • end: Boundary<string>

        The ending stream ID bound for the range. - Use value to specify a stream entry ID. - Use isInclusive: false to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0. - Use InfBoundary.PositiveInfinity to end with the maximum available ID.

      • Optionalcount: number

        An optional argument specifying the maximum count of stream entries to return. If count is not provided, all stream entries in the range will be returned.

        Command Response - A list of stream entry ids, to an array of entries, or null if count is non-positive. The response comes in format GlideRecord<[GlideString, GlideString][]> | null, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/xrange/|valkey.io for more details.

    • Returns stream entries matching a given range of entry IDs in reverse order. Equivalent to xrange but returns the entries in reverse order.

      Parameters

      • key: GlideString

        The key of the stream.

      • end: Boundary<string>

        The ending stream entry ID bound for the range. - Use value to specify a stream entry ID. - Use isInclusive: false to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0. - Use InfBoundary.PositiveInfinity to end with the maximum available ID.

      • start: Boundary<string>

        The ending stream ID bound for the range. - Use value to specify a stream entry ID. - Use isInclusive: false to specify an exclusive bounded stream entry ID. This is only available starting with Valkey version 6.2.0. - Use InfBoundary.NegativeInfinity to start with the minimum available ID.

      • Optionalcount: number

        An optional argument specifying the maximum count of stream entries to return. If count is not provided, all stream entries in the range will be returned.

        Command Response - A list of stream entry ids, to an array of entries, or null if count is non-positive. The response comes in format GlideRecord<[GlideString, GlideString][]> | null, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/xrevrange/|valkey.io for more details.

    • Increments the score of member in the sorted set stored at key by increment. If member does not exist in the sorted set, it is added with increment as its score (as if its previous score was 0.0). If key does not exist, a new sorted set with the specified member as its sole member is created.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • member: GlideString

        A member in the sorted set to increment.

      • increment: number

        The score to increment the member.

      • Optionaloptions: ZAddOptions

        (Optional) The ZADD options - see ZAddOptions.

        Command Response - The score of the member. If there was a conflict with the options, the operation aborts and null is returned.

      Returns Batch

      https://valkey.io/commands/zadd/|valkey.io for details.

    • Returns the number of members in the sorted set stored at key with scores between minScore and maxScore.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • minScore: Boundary<number>

        The minimum score to count from. Can be positive/negative infinity, or specific score and inclusivity.

      • maxScore: Boundary<number>

        The maximum score to count up to. Can be positive/negative infinity, or specific score and inclusivity.

        Command Response - The number of members in the specified score range. If key does not exist, it is treated as an empty sorted set, and the command returns 0. If minScore is greater than maxScore, 0 is returned.

      Returns Batch

      https://valkey.io/commands/zcount/|valkey.io for details.

    • Returns the difference between the first sorted set and all the successive sorted sets. To get the elements with their scores, see zdiffWithScores.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

        Command Response - An array of elements representing the difference between the sorted sets. If the first key does not exist, it is treated as an empty sorted set, and the command returns an empty array.

      Returns Batch

      https://valkey.io/commands/zdiff/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Calculates the difference between the first sorted set and all the successive sorted sets in keys and stores the difference as a sorted set to destination, overwriting it if it already exists. Non-existent keys are treated as empty sets.

      Parameters

      • destination: GlideString

        The key for the resulting sorted set.

      • keys: GlideString[]

        The keys of the sorted sets to compare.

        Command Response - The number of members in the resulting sorted set stored at destination.

      Returns Batch

      https://valkey.io/commands/zdiffstore/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Returns the difference between the first sorted set and all the successive sorted sets, with the associated scores.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

        Command Response - A list of elements and their scores representing the difference between the sorted sets. If the first key does not exist, it is treated as an empty sorted set, and the command returns an empty array. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zdiff/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Increments the score of member in the sorted set stored at key by increment. If member does not exist in the sorted set, it is added with increment as its score. If key does not exist, a new sorted set is created with the specified member as its sole member.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • increment: number

        The score increment.

      • member: GlideString

        A member of the sorted set.

        Command Response - The new score of member.

      Returns Batch

      https://valkey.io/commands/zincrby/|valkey.io for details.

    • Returns the cardinality of the intersection of the sorted sets specified by keys.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets to intersect.

      • Optionaloptions: { limit?: number }

        (Optional) Additional parameters:

        • (Optional) limit: the limit for the intersection cardinality value. If not specified, or set to 0, no limit is used.

        Command Response - The cardinality of the intersection of the given sorted sets.

      Returns Batch

      https://valkey.io/commands/zintercard/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Computes the intersection of sorted sets given by the specified keys and stores the result in destination. If destination already exists, it is overwritten. Otherwise, a new sorted set will be created.

      Parameters

      • destination: GlideString

        The key of the destination sorted set.

      • keys: GlideString[] | KeyWeight[]

        The keys of the sorted sets with possible formats:

        • GlideString[] - for keys only.
        • KeyWeight[] - for weighted keys with score multipliers.
      • Optionaloptions: { aggregationType?: AggregationType }

        (Optional) Additional parameters:

        • (Optional) aggregationType: the aggregation strategy to apply when combining the scores of elements. See AggregationType. If aggregationType is not specified, defaults to AggregationType.SUM.

        Command Response - The number of elements in the resulting sorted set stored at destination.

      Returns Batch

      https://valkey.io/commands/zinterstore/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Computes the intersection of sorted sets given by the specified keys and returns a list of intersecting elements with scores. To get the elements only, see zinter. To store the result in a key as a sorted set, see zinterStore.

      Parameters

      • keys: GlideString[] | KeyWeight[]

        The keys of the sorted sets with possible formats:

        • GlideString[] - for keys only.
        • KeyWeight[] - for weighted keys with score multipliers.
      • Optionaloptions: { aggregationType?: AggregationType }

        (Optional) Additional parameters:

        • (Optional) aggregationType: the aggregation strategy to apply when combining the scores of elements. See AggregationType. If aggregationType is not specified, defaults to AggregationType.SUM.

        Command Response - A list of elements and their scores representing the intersection of the sorted sets. If a key does not exist, it is treated as an empty sorted set, and the command returns an empty result. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zinter/|valkey.io for details.

      Since Valkey version 6.2.0.

    • Pops member-score pairs from the first non-empty sorted set, with the given keys being checked in the order they are provided.

      Parameters

      • keys: GlideString[]

        The keys of the sorted sets.

      • modifier: ScoreFilter

        The element pop criteria - either ScoreFilter.MIN or ScoreFilter.MAX to pop the member with the lowest/highest score accordingly.

      • Optionalcount: number

        (Optional) The number of elements to pop. If not supplied, only one element will be popped.

        Command Response - A two-element array containing the key name of the set from which the was popped, and a GlideRecord<number> of the popped elements - see GlideRecord. If no member could be popped, returns null.

      Returns Batch

      https://valkey.io/commands/zmpop/|valkey.io for details.

      Since Valkey version 7.0.0.

    • Removes and returns the members with the highest scores from the sorted set stored at key. If count is provided, up to count members with the highest scores are removed and returned. Otherwise, only one member with the highest score is removed and returned.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • Optionalcount: number

        Specifies the quantity of members to pop. If not specified, pops one member.

        Command Response - A list of the removed members and their scores, ordered from the one with the lowest score to the one with the highest. If key doesn't exist, it will be treated as an empty sorted set and the command returns an empty map. If count is higher than the sorted set's cardinality, returns all members and their scores. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zpopmax/|valkey.io for more details.

    • Removes and returns the members with the lowest scores from the sorted set stored at key. If count is provided, up to count members with the lowest scores are removed and returned. Otherwise, only one member with the lowest score is removed and returned.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • Optionalcount: number

        Specifies the quantity of members to pop. If not specified, pops one member.

        Command Response - A list of the removed members and their scores, ordered from the one with the lowest score to the one with the highest. If key doesn't exist, it will be treated as an empty sorted set and the command returns an empty map. If count is higher than the sorted set's cardinality, returns all members and their scores. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zpopmin/|valkey.io for more details.

    • Returns the specified range of elements in the sorted set stored at key. ZRANGE can perform different types of range queries: by index (rank), by the score, or by lexicographical order.

      To get the elements with their scores, see zrangeWithScores.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • rangeQuery: RangeByScore | RangeByLex | RangeByIndex

        The range query object representing the type of range query to perform.

      • reverse: boolean = false

        If true, reverses the sorted set, with index 0 as the element with the highest score.

        Command Response - A list of elements within the specified range. If key does not exist, it is treated as an empty sorted set, and the command returns an empty array.

      Returns Batch

      https://valkey.io/commands/zrange/|valkey.io for details.

    • Returns the specified range of elements with their scores in the sorted set stored at key. Similar to ZRange but with a WITHSCORE flag.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • rangeQuery: RangeByScore | RangeByIndex

        The range query object representing the type of range query to perform.

      • reverse: boolean = false

        If true, reverses the sorted set, with index 0 as the element with the highest score.

        Command Response - A list of elements and their scores within the specified range. If key does not exist, it is treated as an empty sorted set, and the command returns an empty list. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zrange/|valkey.io for details.

    • Returns the rank of member in the sorted set stored at key with its score, where scores are ordered from the lowest to highest.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • member: GlideString

        The member whose rank is to be retrieved.

        Command Response - A list containing the rank and score of member in the sorted set. If key doesn't exist, or if member is not present in the set, null will be returned.

      Returns Batch

      https://valkey.io/commands/zrank/|valkey.io for more details.

      Since Valkey version 7.2.0.

    • Removes the specified members from the sorted set stored at key. Specified members that are not a member of this set are ignored.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • members: GlideString[]

        A list of members to remove from the sorted set.

        Command Response - The number of members that were removed from the sorted set, not including non-existing members. If key does not exist, it is treated as an empty sorted set, and this command returns 0.

      Returns Batch

      https://valkey.io/commands/zrem/|valkey.io for details.

    • Removes all elements in the sorted set stored at key with rank between start and end. Both start and end are zero-based indexes with 0 being the element with the lowest score. These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • start: number

        The starting point of the range.

      • end: number

        The end of the range.

        Command Response - The number of members removed. If start exceeds the end of the sorted set, or if start is greater than end, 0 returned. If end exceeds the actual end of the sorted set, the range will stop at the actual end of the sorted set. If key does not exist 0 will be returned.

      Returns Batch

      https://valkey.io/commands/zremrangebyrank/|valkey.io for details.

    • Removes all elements in the sorted set stored at key with a score between minScore and maxScore.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • minScore: Boundary<number>

        The minimum score to remove from. Can be negative infinity, or specific score and inclusivity.

      • maxScore: Boundary<number>

        The maximum score to remove to. Can be positive infinity, or specific score and inclusivity.

        Command Response - the number of members removed. If key does not exist, it is treated as an empty sorted set, and the command returns 0. If minScore is greater than maxScore, 0 is returned.

      Returns Batch

      https://valkey.io/commands/zremrangebyscore/|valkey.io for details.

    • Returns the rank of member in the sorted set stored at key, where scores are ordered from the highest to lowest, starting from 0. To get the rank of member with its score, see zrevrankWithScore.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • member: GlideString

        The member whose rank is to be retrieved.

        Command Response - The rank of member in the sorted set, where ranks are ordered from high to low based on scores. If key doesn't exist, or if member is not present in the set, null will be returned.

      Returns Batch

      https://valkey.io/commands/zrevrank/|valkey.io for details.

    • Returns the rank of member in the sorted set stored at key with its score, where scores are ordered from the highest to lowest, starting from 0.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • member: GlideString

        The member whose rank is to be retrieved.

        Command Response - A list containing the rank and score of member in the sorted set, where ranks are ordered from high to low based on scores. If key doesn't exist, or if member is not present in the set, null will be returned.

      Returns Batch

      https://valkey.io/commands/zrevrank/|valkey.io for details.

      Since Valkey version 7.2.0.

    • Iterates incrementally over a sorted set.

      Parameters

      • key: GlideString

        The key of the sorted set.

      • cursor: string

        The cursor that points to the next iteration of results. A value of "0" indicates the start of the search.

      • Optionaloptions: ZScanOptions

        (Optional) The zscan options - see ZScanOptions

        Command Response - An Array of the cursor and the subset of the sorted set held by key. The first element is always the cursor for the next iteration of results. 0 will be the cursor returned on the last iteration of the sorted set. The second element is always an Array of the subset of the sorted set held in key. The Array in the second element is a flattened series of String pairs, where the value is at even indices and the score is at odd indices. If options.noScores is to true, the second element will only contain the members without scores.

      Returns Batch

      https://valkey.io/commands/zscan/|valkey.io for more details.

    • Computes the union of sorted sets given by the specified keys and stores the result in destination. If destination already exists, it is overwritten. Otherwise, a new sorted set will be created. To get the result directly, see zunionWithScores.

      Parameters

      • destination: GlideString

        The key of the destination sorted set.

      • keys: GlideString[] | KeyWeight[]

        The keys of the sorted sets with possible formats:

        • GlideString[] - for keys only.
        • KeyWeight[] - for weighted keys with their score multipliers.
      • Optionaloptions: { aggregationType?: AggregationType }

        (Optional) Additional parameters:

        • (Optional) aggregationType: the aggregation strategy to apply when combining the scores of elements. See AggregationType. If aggregationType is not specified, defaults to AggregationType.SUM.

        Command Response - The number of elements in the resulting sorted set stored at destination.

      Returns Batch

      https://valkey.io/commands/zunionstore/|valkey.io for details.

    • Computes the intersection of sorted sets given by the specified keys and returns a list of union elements with scores. To get the elements only, see zunion.

      Parameters

      • keys: GlideString[] | KeyWeight[]

        The keys of the sorted sets with possible formats:

        • GlideString[] - for keys only.
        • KeyWeight[] - for weighted keys with their score multipliers.
      • Optionaloptions: { aggregationType?: AggregationType }

        (Optional) Additional parameters:

        • (Optional) aggregationType: the aggregation strategy to apply when combining the scores of elements. See AggregationType. If aggregationType is not specified, defaults to AggregationType.SUM.

        Command Response - A list of elements and their scores representing the intersection of the sorted sets. The response comes in format GlideRecord<number>, see GlideRecord.

      Returns Batch

      https://valkey.io/commands/zunion/|valkey.io for details.

      Since Valkey version 6.2.0.

    Settings

    Member Visibility

    On This Page

    Batch Response:
    Constructors
    Properties
    Methods
    addAndReturnappendbitcountbitfieldbitfieldReadOnlybitopbitposblmoveblmpopblpopbrpopbzmpopbzpopmaxbzpopminclientGetNameclientIdconfigGetconfigResetStatconfigRewriteconfigSetcopycustomCommanddbsizedecrdecrBydeldumpechoexistsexpireexpireAtexpireTimefcallfcallReadonlyflushallflushdbfunctionDeletefunctionDumpfunctionFlushfunctionListfunctionLoadfunctionRestorefunctionStatsgeoaddgeodistgeohashgeoposgeosearchgeosearchstoregetgetbitgetdelgetexgetrangehdelhexistshexpirehexpireathexpiretimehgethgetallhgetexhincrByhincrByFloathkeyshlenhmgethpersisthpexpirehpexpireathpexpiretimehpttlhrandfieldhrandfieldCounthrandfieldWithValueshscanhsethsetexhsetnxhstrlenhttlhvalsincrincrByincrByFloatinfolastsavelcslcsIdxlcsLenlindexlinsertllenlmovelmpoplolwutlpoplpopCountlposlpushlpushxlrangelremlsetltrimmgetmovemsetmsetnxobjectEncodingobjectFreqobjectIdletimeobjectRefcountpersistpexpirepexpireAtpexpireTimepfaddpfcountpfmergepingpttlpublishpubsubChannelspubsubNumPatpubsubNumSubrandomKeyrenamerenamenxrestorerpoprpopCountrpushrpushxsaddscardsdiffsdiffstoreselectsetsetbitsetrangesintersintercardsinterstoresismembersmemberssmismembersmovesortsortReadOnlysortStorespopspopCountsrandmembersrandmemberCountsremsscanstrlensunionsunionstoretimetouchttltypeunlinkwaitxackxaddxautoclaimxautoclaimJustIdxclaimxclaimJustIdxdelxgroupCreatexgroupCreateConsumerxgroupDelConsumerxgroupDestroyxgroupSetIdxinfoConsumersxinfoGroupsxinfoStreamxlenxpendingxpendingWithOptionsxrangexreadxreadgroupxrevrangextrimzaddzaddIncrzcardzcountzdiffzdiffstorezdiffWithScoreszincrbyzinterzintercardzinterstorezinterWithScoreszlexcountzmpopzmscorezpopmaxzpopminzrandmemberzrandmemberWithCountzrandmemberWithCountWithScoreszrangezrangeStorezrangeWithScoreszrankzrankWithScorezremzremRangeByLexzremRangeByRankzremRangeByScorezrevrankzrevrankWithScorezscanzscorezunionzunionstorezunionWithScores