BITOP

Syntax text Syntax diagram API methods

BITOP <AND | OR | XOR | NOT | DIFF | DIFF1 | ANDOR | ONE> destkey key [key ...]

Client:

bitop(
    operation: str,
    dest: KeyT,
    *keys: KeyT
) → ResponseT

BITOP(
    operation: BitOperations,
    destKey: RedisArgument,
    key: RedisVariadicArgument
) → Any

bitop(
    op: BitOP,
    destKey: byte[],
    srcKeys: byte[]...
) → long  // OK

bitop(
    op: BitOP,
    destKey: String,
    srcKeys: String...
) → long  // OK

bitopAnd(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Long  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopNot(
    destination: K,  // result key of the operation.
    source: K  // operation input key names.
) → Long  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopOr(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Long  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopXor(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Long  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopDiff(
    destination: K,  // result key of the operation.
    sourceKey: K,  // the source key (X) for comparison.
    keys: K...  // one or more additional keys (Y1, Y2, ...). At least one key is required.
) → Long  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopAnd(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → RedisFuture<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopNot(
    destination: K,  // result key of the operation.
    source: K  // operation input key names.
) → RedisFuture<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopOr(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → RedisFuture<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopXor(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → RedisFuture<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopDiff(
    destination: K,  // result key of the operation.
    sourceKey: K,  // the source key (X) for comparison.
    keys: K...  // one or more additional keys (Y1, Y2, ...). At least one key is required.
) → RedisFuture<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopAnd(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Mono<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopNot(
    destination: K,  // result key of the operation.
    source: K  // operation input key names.
) → Mono<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopOr(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Mono<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopXor(
    destination: K,  // result key of the operation.
    keys: K...  // operation input key names.
) → Mono<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitopDiff(
    destination: K,  // result key of the operation.
    sourceKey: K,  // the source key (X) for comparison.
    keys: K...  // one or more additional keys (Y1, Y2, ...). At least one key is required.
) → Mono<Long>  // Long integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitOp(
    ctx: context.Context,
    op: Any,
    destKey: string,
    keys: ...string
) → *IntCmd

BitOpAnd(
    ctx: context.Context,
    destKey: string,
    keys: ...string
) → *IntCmd

BitOpOr(
    ctx: context.Context,
    destKey: string,
    keys: ...string
) → *IntCmd

BitOpXor(
    ctx: context.Context,
    destKey: string,
    keys: ...string
) → *IntCmd

BitOpNot(
    ctx: context.Context,
    destKey: string,
    key: string
) → *IntCmd

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    keys: RedisKey[],  // The keys to get the bit values from.
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

StringBitOperationAsync(
    operation: Bitwise,
    destination: RedisKey,
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags
) → Task<long>

StringBitOperationAsync(
    operation: Bitwise,
    destination: RedisKey,
    keys: RedisKey[],
    flags: CommandFlags
) → Task<long>

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

StringBitOperationAsync(
    operation: Bitwise,
    destination: RedisKey,
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags
) → Task<long>

StringBitOperationAsync(
    operation: Bitwise,
    destination: RedisKey,
    keys: RedisKey[],
    flags: CommandFlags
) → Task<long>

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    keys: RedisKey[],  // The keys to get the bit values from.
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

StringBitOperation(
    operation: Bitwise,  // The operation to perform.
    destination: RedisKey,  // The destination key to store the result in.
    first: RedisKey,
    second: RedisKey,
    flags: CommandFlags  // The flags to use for this operation.
) → long  // The size of the string stored in the destination key, that is equal to the size of the longest input string.

bitop(
    $operation: Any,
    $destkey: Any,
    $key: Any
) → int

bit_and(
    dstkey: D,
    srckeys: S
) → (usize)

bit_or(
    dstkey: D,
    srckeys: S
) → (usize)

bit_xor(
    dstkey: D,
    srckeys: S
) → (usize)

bit_not(
    dstkey: D,
    srckey: S
) → (usize)

bit_diff(
    dstkey: D,
    srckeys: S
) → (usize)

bit_and(
    dstkey: D,
    srckeys: S
) → (usize)

bit_or(
    dstkey: D,
    srckeys: S
) → (usize)

bit_xor(
    dstkey: D,
    srckeys: S
) → (usize)

bit_not(
    dstkey: D,
    srckey: S
) → (usize)

bit_diff(
    dstkey: D,
    srckeys: S
) → (usize)

Available since:: Redis Open Source 2.6.0
Time complexity:: O(N)
ACL categories:: @write, @bitmap, @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.

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

The BITOP command supports eight bitwise operations: AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR, and ONE. The valid forms to call the command are:

BITOP AND destkey srckey1 srckey2 srckey3 ... srckeyN

A bit in destkey is set only if it is set in all source bitmaps.
BITOP OR destkey srckey1 srckey2 srckey3 ... srckeyN

A bit in destkey is set only if it is set in at least one source bitmap.
BITOP XOR destkey srckey1 srckey2 srckey3 ... srckeyN

Mostly used with two source bitmaps, a bit in destkey is set only if its value differs between the two source bitmaps.
BITOP NOT destkey srckey

NOT is a unary operator and only supports a single source bitmap; set the bit to the inverse of its value in the source bitmap.
BITOP DIFF destkey X [Y1 Y2 ...] ¹

A bit in destkey is set if it is set in X, but not in any of Y1, Y2, ... .
BITOP DIFF1 destkey X [Y1 Y2 ...] ¹

A bit in destkey is set if it is set in one or more of Y1, Y2, ..., but not in X.
BITOP ANDOR destkey X [Y1 Y2 ...] ¹

A bit in destkey is set if it is set in X and also in one or more of Y1, Y2, ....
BITOP ONE destkey X1 [X2 X3 ...] ¹

A bit in destkey is set if it is set in exactly one of X1, X2, ....

The result of each operation is always stored at destkey.

Added in Redis 8.2.

Handling of strings with different lengths

When an operation is performed between strings having different lengths, all the strings shorter than the longest string in the set are treated as if they were zero-padded up to the length of the longest string.

The same holds true for non-existent keys, that are considered as a stream of zero bytes up to the length of the longest string.

Examples

Basic usage example using the AND operator:

Suppose you want to expose people to a book-related ad. The target audience is people who love to read books and are interested in fantasy, adventure, or science fiction. Assume you have the following bitmaps:

LRB - people who love to read books.
B:F - people interested in fantasy.
B:A - people interested in adventure.
B:SF - people interested in science fiction.

To create a bitmap representing the target audience, use the following command:

BITOP ANDOR TA LRB B:F B:A B:SF

Pattern: real time metrics using bitmaps

BITOP is a good complement to the pattern documented in the BITCOUNT command documentation. Different bitmaps can be combined in order to obtain a target bitmap where the population counting operation is performed.

See the article called "Fast easy realtime metrics using Redis bitmaps" for an interesting use cases.

Performance considerations

BITOP is a potentially slow command as it runs in O(N) time. Care should be taken when running it against long input strings.

For real-time metrics and statistics involving large inputs a good approach is to use a replica (with replica-read-only option enabled) where the bit-wise operations are performed to avoid blocking the master instance.

Redis Software and Redis Cloud compatibility

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

Return information

RESP2 RESP3

Integer reply: the size of the string stored in the destination key is equal to the size of the longest input string.

Products

Tools

Get Redis

Connect

Learn

Latest

See how it works