memcached

Produces a Memcached text-protocol set command string ready to send over a TCP socket. flags is an arbitrary integer stored with the item; exptime is the TTL in seconds (0 = no expiry).

use plugin memcached::{encode_set}

let cmd = encode_set("session:abc", "user_data", 0, 3600)
print(cmd)

Produces a get <key>\r\n command string.

use plugin memcached::{encode_get}

let cmd = encode_get("session:abc")
print(cmd)

Produces a delete <key>\r\n command string.

use plugin memcached::{encode_delete}

let cmd = encode_delete("session:abc")
print(cmd)

Produces an incr <key> <amount>\r\n command string for atomically incrementing a numeric value stored at key.

use plugin memcached::{encode_incr}

let cmd = encode_incr("page_views", 1)
print(cmd)

Produces a decr <key> <amount>\r\n command string. The server floors the result at 0.

use plugin memcached::{encode_decr}

let cmd = encode_decr("credits", 5)
print(cmd)

Like encode_set but produces an add command, which only stores the item if the key does not already exist on the server.

use plugin memcached::{encode_add}

let cmd = encode_add("lock:resource", "1", 0, 30)
print(cmd)

Produces a replace command, which only stores the item if the key already exists on the server.

use plugin memcached::{encode_replace}

let cmd = encode_replace("config:theme", "dark", 0, 0)
print(cmd)

Produces an append command that adds value to the end of an existing item's data.

use plugin memcached::{encode_append}

let cmd = encode_append("log:today", " another entry")
print(cmd)

Produces a prepend command that adds value to the beginning of an existing item's data.

use plugin memcached::{encode_prepend}

let cmd = encode_prepend("log:today", "ENTRY: ")
print(cmd)

Produces a single get command for multiple keys, which allows batching lookups in one round trip.

use plugin memcached::{encode_multi_get}

let cmd = encode_multi_get(["user:1", "user:2", "user:3"])
print(cmd)

Produces a touch command to update the expiry time of an existing item without changing its value.

use plugin memcached::{encode_touch}

let cmd = encode_touch("session:abc", 7200)
print(cmd)

Produces a cas (check-and-set) command. The server only stores the new value if cas_unique matches the token returned by a prior gets command, enabling optimistic concurrency.

use plugin memcached::{encode_cas}

let cmd = encode_cas("counter", "42", 0, 0, 12345)
print(cmd)

Returns the flush_all\r\n command string that invalidates all items on the server.

use plugin memcached::{encode_flush_all}

let cmd = encode_flush_all()
print(cmd)

Returns the stats\r\n command string that requests server statistics.

use plugin memcached::{encode_stats, parse_stat_line}

let cmd = encode_stats()
print(cmd)

Returns the version\r\n command string that requests the server's version string.

use plugin memcached::{encode_version}

let cmd = encode_version()
print(cmd)

Parses a VALUE <key> <flags> <bytes> response line into {key, flags, bytes, data}. The optional second argument provides the data payload from the following line.

use plugin memcached::{parse_value_response}

let resp = parse_value_response("VALUE session:abc 0 9", "user_data")
print(resp["key"])
print(resp["bytes"])

Parses a STAT <name> <value> line into {name, value}. Use when processing the multi-line response to a stats command.

use plugin memcached::{parse_stat_line}

let entry = parse_stat_line("STAT curr_items 42")
print("{entry["name"]} = {entry["value"]}")

MemcacheLocal is a local, in-process key-value store that mirrors the Memcached API. It supports TTL, increment/decrement, and multi-get, and is ideal for testing or caching within a single process.

Constructor: MemcacheLocal.new() → MemcacheLocal

Methods: set(key, value, ttl?), get(key), delete(key), incr(key, amount), decr(key, amount), flush(), keys(), multi_get(keys), count(), exists(key), stats()

use plugin memcached::{MemcacheLocal}

let cache = MemcacheLocal.new()
cache.set("user:1", "Alice", 60)
cache.set("user:2", "Bob", 60)

let name = cache.get("user:1")
print(name)

cache.incr("hits", 1)
cache.incr("hits", 1)
print(cache.get("hits"))

let results = cache.multi_get(["user:1", "user:2"])
print(cache.count())

let info = cache.stats()
print("items: {info["curr_items"]}, bytes: {info["bytes"]}")