Redis strings are the smallest building block

Thu, 28 Jan 2027 00:00:00 +0000

A Redis string is one binary-safe byte sequence attached to a key. It can hold text, a serialized document, or a decimal counter. This is a public data type, not a claim that every Redis structure is implemented by assembling strings. Hashes, lists, and other types have their own commands, representations, and update rules.

Bytes first, interpretation second

SET and GET preserve bytes, including zero bytes and invalid UTF-8. STRLEN measures bytes, and GETRANGE uses inclusive byte offsets, not character positions. A range can therefore split a multibyte character. Client-side automatic decoding is a separate choice: disable it when reading arbitrary binary payloads, then decode only fields whose encoding the application actually knows.

Storing JSON text does not turn the value into a Redis hash or enable field-level hash commands. Likewise, integer commands interpret the stored bytes rather than assigning a permanent numeric schema. Applications must own serialization, type expectations, and key naming. The documented default string limit is 512 MiB, but that ceiling is not a sensible payload-size target.

Atomic increments have a boundary

INCR treats a missing key as zero and increments a base-10 signed 64-bit integer. Invalid representations and overflow are errors, not wrapping arithmetic. INCRBY changes the step; INCRBYFLOAT follows different floating-point semantics and is not a substitute when an exact integer sequence matters.

A single INCR avoids the lost-update window of GET followed by SET. However, if the server executes an increment and its reply is lost, retrying can increment twice. Command atomicity does not make requests idempotent. Nor does it establish durable, globally unique IDs across deletion, expiry, replication failure, or failover. The concurrent exercise below tests one running instance only.

When it breaks

HGET against a JSON string returns WRONGTYPE. Ordinary SET has the opposite hazard: it can replace an existing hash with a string, destroying that hash’s fields. Separate namespaces by value contract, and check the commands used by every writer. A name that once held a hash is not permanently constrained to that type.

Successful plain SET also discards the key’s previous expiration. Assign an initial value and lifetime together with SET EX or SET PX, or use SET KEEPTTL when intentionally retaining an existing deadline. Separate SET and EXPIRE calls leave a crash window containing a persistent value; attaching expiration afterward is not equivalent to one atomic write.

Large blobs increase transfer volume, client buffering, and the cost of commands that copy or modify their contents. Consider the largest value and its update frequency, not just key count. If a document changes by independent attributes, a hash may fit better. This does not mean every hash is smaller or every string access is slow.

Check it quickly

Use a POSIX environment with a C compiler, make, curl, tar, and Python 3.10 or newer. This ran on macOS with Python 3.14.4, Redis 8.10.1, and redis-py 8.1.0. Build Redis core with libc and install the client into a temporary virtual environment; optional Redis modules and system-wide installation are unnecessary.

redis_lab=$(mktemp -d)
curl --fail --location --output "$redis_lab/redis.tar.gz" https://download.redis.io/releases/redis-8.10.1.tar.gz
tar -xzf "$redis_lab/redis.tar.gz" -C "$redis_lab"
make -C "$redis_lab/redis-8.10.1" build redis -j2 MALLOC=libc
export REDIS_SERVER="$redis_lab/redis-8.10.1/src/redis-server"
python3 -m venv "$redis_lab/venv"
"$redis_lab/venv/bin/python" -m pip install redis==8.1.0

Run the Python block with "$redis_lab/venv/bin/python" in the same shell. It starts its own Redis with a private Unix socket under /tmp, no TCP listener, no snapshot schedule, and no append-only persistence. The program closes its client, terminates only its own process, and removes its temporary runtime directory. Downloading dependencies needs network access; executing the experiment does not.

from concurrent.futures import ThreadPoolExecutor
from threading import Barrier

from contextlib import contextmanager
import os
from pathlib import Path
import subprocess
from tempfile import TemporaryDirectory
import time

import redis
from redis.backoff import NoBackoff
from redis.retry import Retry


@contextmanager
def instance():
 with TemporaryDirectory(prefix="redis-lab-", dir="/tmp") as directory:
 endpoint = str(Path(directory) / "redis.sock")
 process = subprocess.Popen([
 os.environ["REDIS_SERVER"], "--port", "0",
 "--unixsocket", endpoint, "--unixsocketperm", "700",
 "--save", "", "--appendonly", "no", "--dir", directory,
 "--maxmemory-policy", "noeviction",
 ], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
 client = redis.Redis(unix_socket_path=endpoint, decode_responses=False,
 socket_timeout=2, retry=Retry(NoBackoff(), 0))
 try:
 deadline = time.monotonic() + 5
 while True:
 assert process.poll() is None, "Redis exited during startup"
 try:
 if client.ping():
 break
 except redis.ConnectionError:
 if time.monotonic() >= deadline:
 raise
 time.sleep(0.02)
 yield client
 finally:
 client.close()
 if process.poll() is None:
 process.terminate()
 try:
 _, errors = process.communicate(timeout=5)
 except subprocess.TimeoutExpired:
 process.kill()
 process.communicate()
 raise
 assert process.returncode == 0, errors.decode()



with instance() as client:
 payload = b"\x00\xff" + "\u8336".encode("utf-8")
 client.set("binary", payload)
 assert client.get("binary") == payload
 assert client.strlen("binary") == 5
 assert client.getrange("binary", 2, 2) == b"\xe8"
 assert client.getrange("binary", 2, 4).decode("utf-8") == "\u8336"
 print("binary round trip: 5 bytes; GETRANGE addresses bytes")

 start = Barrier(4)

 def increment(_):
 start.wait(timeout=5)
 return [client.incr("counter") for _ in range(50)]

 with ThreadPoolExecutor(max_workers=4) as workers:
 batches = list(workers.map(increment, range(4)))
 values = sorted(value for batch in batches for value in batch)
 assert values == list(range(1, 201))
 assert client.get("counter") == b"200"
 print("4 workers: 200 INCR replies, exactly the integers 1 through 200")

 for key, value in [("invalid", b"3.5"),
 ("overflow", b"9223372036854775807")]:
 client.set(key, value)
 try:
 client.incr(key)
 except redis.ResponseError:
 pass
 else:
 raise AssertionError("INCR must reject this value")
 assert client.get(key) == value
 print("invalid integer and signed 64-bit overflow leave values unchanged")

 client.set("document", b'{"score": 1}')
 assert client.type("document") == b"string"
 try:
 client.hget("document", "score")
 except redis.ResponseError as error:
 assert "WRONGTYPE" in str(error)
 else:
 raise AssertionError("JSON bytes must not become a Redis hash")
 client.hset("object", mapping={"score": 1})
 client.set("object", b"replacement")
 assert client.type("object") == b"string"
 print("JSON is still a string; SET can replace a hash with a string")

 client.set("lease", b"A", px=60000)
 deadline = client.pexpiretime("lease")
 client.set("lease", b"B", keepttl=True)
 assert client.pexpiretime("lease") == deadline
 client.set("lease", b"C")
 assert client.ttl("lease") == -1
 print("SET PX assigns expiry; KEEPTTL keeps it; plain SET removes it")

The first assertion round-trips five bytes. GETRANGE selects one byte from the three-byte Chinese character, while selecting all three bytes permits UTF-8 decoding. Four synchronized worker threads then collect exactly the integers 1 through 200, with a final stored value of 200. This checks concurrent increments without relying on reply arrival order.

Both rejected increments preserve their original values. JSON remains a string, and ordinary SET successfully replaces a separate hash. Finally, the absolute expiration deadline survives KEEPTTL, whereas plain SET produces TTL -1. These results verify byte handling, integer validation, type replacement, and expiration semantics; they are not throughput measurements or evidence of retry safety and crash durability.

Sources