SETBIT key offset value

    Time complexity: O(1)

    Sets or clears the bit at offset in the string value stored at key.

    The bit is either set or cleared depending on value, which can be either 0 or 1.

    When key does not exist, a new string value is created. The string is grown to make sure it can hold a bit at offset. The offset argument is required to be greater than or equal to 0, and smaller than 232 (this limits bitmaps to 512MB). When the string at key is grown, added bits are set to 0.

    Warning: When setting the last possible bit (offset equal to 232 -1) and the string value stored at key does not yet hold a string value, or holds a small string value, Redis needs to allocate all intermediate memory which can block the server for some time. On a 2010 MacBook Pro, setting bit number 232 -1 (512MB allocation) takes ~300ms, setting bit number 230 -1 (128MB allocation) takes ~80ms, setting bit number 228 -1 (32MB allocation) takes ~30ms and setting bit number 226 -1 (8MB allocation) takes ~8ms. Note that once this first allocation is done, subsequent calls to SETBIT for the same key will not have the allocation overhead.

    redis> SETBIT mykey 7 1

    redis> SETBIT mykey 7 0 

    1. (integer) 1

    redis> GET mykey

    redis>

    There are cases when you need to set all the bits of single bitmap at once, for example when initializing it to a default non-zero value. It is possible to do this with multiple calls to the command, one for each bit that needs to be set. However, so as an optimization you can use a single SET command to set the entire bitmap.

    Bitmaps are not an actual data type, but a set of bit-oriented operations defined on the String type (for more information refer to the ). This means that bitmaps can be used with string commands, and most importantly with SET and .

    For example, after setting a few bits, getting the string value of the bitmap would look like this:

    2. > SETBIT bitmapsarestrings 3 1
    3. > SETBIT bitmapsarestrings 5 1
    4. > SETBIT bitmapsarestrings 10 1
    5. > SETBIT bitmapsarestrings 11 1
    6. > SETBIT bitmapsarestrings 14 1
    7. > GET bitmapsarestrings
    8. "42"

    By getting the string representation of a bitmap, the client can then parse the response's bytes by extracting the bit values using native bit operations in its native programming language. Symmetrically, it is also possible to set an entire bitmap by performing the bits-to-bytes encoding in the client and calling SET with the resultant string.

    excels at setting single bits, and can be called several times when multiple bits need to be set. To optimize this operation you can replace multiple SETBIT calls with a single call to the variadic command and the use of fields of type u1.

    For example, the example above could be replaced by:

    It is also possible to use the GETRANGE and string commands to efficiently access a range of bit offsets in a bitmap. Below is a sample implementation in idiomatic Redis Lua scripting that can be run with the EVAL command:

    1. --[[
    2. Sets a bitmap range
    4. Bitmaps are stored as Strings in Redis. A range spans one or more bytes,
    5. so we can call [SETRANGE](/commands/setrange) when entire bytes need to be set instead of flipping
    6. individual bits. Also, to avoid multiple internal memory allocations in
    7. Redis, we traverse in reverse.
    8. Expected input:
    9.   KEYS[1] - bitfield key
    10.   ARGV[1] - start offset (0-based, inclusive)
    11.   ARGV[3] - value (should be 0 or 1, no error checking)
    12. ]]--
    15. local function tobits(str)
    16.   local r = ''
    17.   for i = 1, string.len(str) do
    18.     local c = string.byte(str, i)
    19.     local b = ' '
    20.     for j = 0, 7 do
    21.       b = tostring(bit.band(c, 1)) .. b
    22.       c = bit.rshift(c, 1)
    23.     end
    24.     r = r .. b
    25.   end
    26.   return r
    27. end
    29. -- Main
    30. local k = KEYS[1]
    31. local s, e, v = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
    33. -- First treat the dangling bits in the last byte
    34. local ms, me = s % 8, (e + 1) % 8
    35.   local t = math.max(e - me + 1, s)
    37.     redis.call('SETBIT', k, i, v)
    38.   end
    39.   e = t
    40. end
    42. -- Then the danglings in the first byte
    43. if ms > 0 then
    44.   local t = math.min(s - ms + 7, e)
    45.   for i = s, t, 1 do
    46.     redis.call('SETBIT', k, i, v)
    47.   end
    48.   s = t + 1
    49. end
    51. -- Set a range accordingly, if at all
    52. local rs, re = s / 8, (e + 1) / 8
    53. local rl = re - rs
    54. if rl > 0 then
    55.   local b = '\255'
    56.   if 0 == v then
    57.     b = '\0'
    58.   end
    59. end