ZINTERSTORE

Syntax text Syntax diagram API methods

ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight
  [weight ...]] [AGGREGATE <SUM | MIN | MAX | COUNT>]

Client:

zinterstore(
    dest: KeyT,
    keys: Union[Sequence[KeyT], Mapping[AnyKeyT, float]],
    aggregate: Optional[str] = None
) → ResponseT

ZINTERSTORE(
    destination: RedisArgument,
    keys: ZKeys,
    options?: ZInterOptions
) → Any

zinterstore(
    dstkey: byte[],
    sets: byte[]...
) → long  // The number of elements in the sorted set at dstkey

zinterstore(
    dstkey: byte[],
    params: ZParams,
    sets: byte[]...
) → long  // The number of elements in the sorted set at dstkey

zinterstore(
    dstkey: String,
    sets: String...
) → long  // The number of elements in the sorted set at dstkey

zinterstore(
    dstkey: String,
    params: ZParams,
    sets: String...
) → long  // The number of elements in the sorted set at dstkey

zinterstore(
    destination: K,  // the destination.
    keys: K...  // the keys.
) → Long  // Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore(
    destination: K,  // the destination.
    storeArgs: ZStoreArgs,  // arguments to define aggregation and weights.
    keys: K...  // the keys.
) → Long  // Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore(
    destination: K,  // the destination.
    keys: K...  // the keys.
) → RedisFuture<Long>  // Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore(
    destination: K,  // the destination.
    storeArgs: ZStoreArgs,  // arguments to define aggregation and weights.
    keys: K...  // the keys.
) → RedisFuture<Long>  // Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore(
    destination: K,  // the destination.
    keys: K...  // the keys.
) → Mono<Long>  // Long integer-reply the number of elements in the resulting sorted set at destination.

zinterstore(
    destination: K,  // the destination.
    storeArgs: ZStoreArgs,  // arguments to define aggregation and weights.
    keys: K...  // the keys.
) → Mono<Long>  // Long integer-reply the number of elements in the resulting sorted set at destination.

ZInterStore(
    ctx: context.Context,
    destination: string,
    store: *ZStore
) → *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.

zinterstore(
    $destination: string,
    $keys: array,
    int[] $weights = []: Any,
    string $aggregate = 'sum': Any
) → int

zinterstore(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_min(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_max(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_weights(
    dstkey: D,
    keys: &'a [(K, W)]
) → (usize)

zinterstore_min_weights(
    dstkey: D,
    keys: &'a [(K, W)]
) → (usize)

zinterstore(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_min(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_max(
    dstkey: D,
    keys: K
) → (usize)

zinterstore_weights(
    dstkey: D,
    keys: &'a [(K, W)]
) → (usize)

zinterstore_min_weights(
    dstkey: D,
    keys: &'a [(K, W)]
) → (usize)

Available since:: Redis Open Source 2.0.0
Time complexity:: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted 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 intersection of numkeys sorted sets given by the specified keys, and stores the result in destination. It is mandatory to provide the number of input keys (numkeys) before passing the input keys and the other (optional) arguments.

By default, the resulting score of an element is the sum of its scores in the sorted sets where it exists. Because intersection requires an element to be a member of every given sorted set, this results in the score of every element in the resulting sorted set to be equal to the number of input sorted sets.

For a description of the WEIGHTS and AGGREGATE options, see ZUNIONSTORE.

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 to intersect.

Optional arguments

WEIGHTS weight [weight ...]

A multiplication factor for each input set; each set's scores are multiplied by its weight before aggregation. Defaults to 1 for every set.

AGGREGATE SUM | MIN | MAX | COUNT

How to combine the scores of members that exist in multiple sets: SUM (the default), MIN, MAX, or COUNT.

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 the destination.

History

Starting with Redis version 8.8.0: Added COUNT aggregate option.