ZDIFFSTORE

Syntax text Syntax diagram API methods

ZDIFFSTORE destination numkeys key [key ...]

Client:

zdiffstore(
    dest: KeyT,
    keys: KeysT
) → ResponseT

ZDIFFSTORE(
    destination: RedisArgument,
    inputKeys: RedisVariadicArgument
) → Any

zdiffStore(
    dstkey: byte[],
    keys: byte[]...
) → long  // 1 if the new element was added, 0 if the element was already a member of the sorted set and the score was updated

zdiffstore(
    dstkey: byte[],
    keys: byte[]...
) → long  // 1 if the new element was added, 0 if the element was already a member of the sorted set and the score was updated

zdiffStore(
    dstkey: String,
    keys: String...
) → long  // 1 if the new element was added, 0 if the element was already a member of the sorted set and the score was updated

zdiffstore(
    dstkey: String,
    keys: String...
) → long  // 1 if the new element was added, 0 if the element was already a member of the sorted set and the score was updated

zdiffstore(
    destKey: K,  // the dest key.
    srcKeys: K...  // the src keys.
) → Long  // Long the number of elements in the resulting sorted set at destination. @since 6.1

zdiffstore(
    destKey: K,  // the dest key.
    srcKeys: K...  // the src keys.
) → RedisFuture<Long>  // Long the number of elements in the resulting sorted set at destination. @since 6.1

zdiffstore(
    destKey: K,  // the dest key.
    srcKeys: K...  // the src keys.
) → Mono<Long>  // Long the number of elements in the resulting sorted set at destination. @since 6.1

ZDiffStore(
    ctx: context.Context,
    destination: string,
    keys: ...string
) → *IntCmd

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    first: RedisKey,
    second: RedisKey,
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    keys: RedisKey[],  // The keys of the sorted sets.
    weights: double[]?,  // The optional weights per set that correspond to keys.
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    first: RedisKey,
    second: RedisKey,
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    keys: RedisKey[],  // The keys of the sorted sets.
    weights: double[]?,  // The optional weights per set that correspond to keys.
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    first: RedisKey,
    second: RedisKey,
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    keys: RedisKey[],  // The keys of the sorted sets.
    weights: double[]?,  // The optional weights per set that correspond to keys.
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    first: RedisKey,
    second: RedisKey,
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

SortedSetCombineAndStore(
    operation: SetOperation,  // The operation to perform.
    destination: RedisKey,  // The key to store the results in.
    keys: RedisKey[],  // The keys of the sorted sets.
    weights: double[]?,  // The optional weights per set that correspond to keys.
    aggregate: Aggregate,  // The aggregation method (defaults to sum).
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The number of elements in the resulting sorted set at destination.

zdiffstore(
    $destination: string,
    $keys: array
) → int

Available since:: Redis Open Source 6.2.0
Time complexity:: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
ACL categories:: @write, @sortedset, @slow,
Compatibility:: Redis Software and Redis Cloud compatibility

Note:

This command's behavior varies in clustered Redis environments. See the multi-key operations page for more information.

Computes the difference between the first and all successive input sorted sets and stores the result in destination. The total number of input keys is specified by numkeys.

Keys that do not exist are considered to be empty sets.

If destination already exists, it is overwritten.

Required arguments

destination

The key to store the resulting sorted set in.

numkeys

The number of keys that follow.

key [key ...]

One or more sorted-set keys. The difference is the members of the first set that are not present in any of the subsequent sets.

Examples

Redis Software and Redis Cloud compatibility

Redis Software	Redis Cloud	Notes
✅ Standard ✅ Active-Active	✅ Standard ✅ Active-Active

Return information

RESP2 RESP3

Integer reply: the number of members in the resulting sorted set at destination.