itamarhaber

-- @desc:   The fastest, type-agnostic way to copy a Redis key
-- @usage:  redis-cli --eval copy_key.lua <source> <dest> , [NX]

local s = KEYS[1]
local d = KEYS[2]

if redis.call("EXISTS", d) == 1 then
  if type(ARGV[1]) == "string" and ARGV[1]:upper() == "NX" then
    return nil
  else

itamarhaber

SHOBJ_CFLAGS ?= -fno-common -g -ggdb
SHOBJ_LDFLAGS ?= -shared -Bsymbolic
CFLAGS = -Wall -g -fPIC -lc -lm -Og -std=gnu99  
CC=gcc

all: example.so

example.so: example.o
	$(LD) -o $@ example.o $(SHOBJ_LDFLAGS) $(LIBS) -lc 

itamarhaber

--/*
-- Examples:
-- $ redis-cli --eval hashslot.lua , key
-- (integer) 12539
-- $ redis-cli --eval hashslot.lua , key2
-- (integer) 4998
-- $ redis-cli --eval hashslot.lua , key3
-- (integer) 935
-- $ redis-cli --eval hashslot.lua , "id:{key}"
-- (integer) 12539

itamarhaber

Reading Building a sliding window rate limiter with Redis, and w/o addressing the actual logic (which may or may not work).

Optimize by:

1. Lua seems a much better choice: idiompotent, portable, server-side, less bandwidth, atomic...
2. The call to ZRANGEBYSCORE seems to be unused, should be commented out if so
3. Looking at the use of ZRANGE, it appears that ZCARD it what's actually needed

The (untested) Lua snippet:

itamarhaber

                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 999.999.999 (3f9e2322/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 16142
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        

itamarhaber

--[[
Sets a bitmap range

Bitmaps are stored as Strings in Redis. A range spans one or more bytes,
so we can call `SETRANGE` when entire bytes need to be set instead of flipping
individual bits. Also, to avoid multiple internal memory allocations in
Redis, we traverse in reverse.

Expected input:
  KEYS[1] - bitfield key

itamarhaber

#!/bin/bash
# Why? Education & zero redis-cli dependecy
# (it is a shame, however, that this functionality isn't a part of redis-cli... PR on the way)
HOST=127.0.0.1
PORT=6379

if [ $# -lt "2" ]
then
    echo "Call a Redis command with its last argument being file contents"
    echo "Usage: $0 <Redis command> <keys and arguments for command> <payload>"

itamarhaber

-- DUMPs a Redis key in TCL-compatible binary string encoding

local b = redis.call("DUMP",KEYS[1])
local s = ""

for i = 1, string.len(b), 1 do 
   s = s .. string.format("\\x%02X",string.byte(b,i))
end

return s

itamarhaber

Luainsider - manage your Redis Lua scripts like a pro

A methodology, approach and apparatus for semi-persisting and aliasing Redis Lua scripts.

FAIR WARNING: this is WIP (i.e. could blow in your face)

Description

itamarhaber

Redis 6.0 GA Apr 30, 2020

• Access Control List (ACL)
• Redis Serialization Protocol 3 (RESP3)
• Client Side Caching (CSC)
• SSL (#WontFix)
• Better expiry!!!
• Diskless replication!11
• more!!!111one (https://raw.githubusercontent.com/redis/redis/6.0/00-RELEASENOTES)