rm

package
v0.0.0-...-3a5c53b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 17, 2016 License: Apache-2.0 Imports: 13 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// The command may modify the data set (it may also read from it).
	CF_WRITE CmdFlag = "write"

	// The command returns data from keys but never writes.
	CF_READONLY = "readonly"

	// The command is an administrative command (may change replication or perform similar tasks).
	CF_ADMIN = "admin"

	// The command may use additional memory and should be denied during out of memory conditions.
	CF_DENY_OOM = "deny-oom"

	// Don't allow this command in Lua scripts.
	CF_DENY_SCRIPT = "deny-script"

	// Allow this command while the server is loading data.
	// Only commands not interacting with the data set
	// should be allowed to run in this mode. If not sure
	// don't use this flag.
	CF_ALLOW_LOADING = "allow-loading"

	// The command publishes things on Pub/Sub channels.
	CF_PUBSUB = "pubsub"

	// The command may have different outputs even starting from the same input arguments and key values.
	CF_RANDOM = "random"

	// The command is allowed to run on slaves that don't
	// serve stale data. Don't use if you don't know what
	// this means.
	CF_ALLOW_STALE = "allow-stale"

	// Don't propoagate the command on monitor. Use this if the command has sensible data among the arguments.
	// The command time complexity is not greater
	CF_NO_MONITOR = "no-monitor"

	//The command time complexity is not greater
	//than O(log(N)) where N is the size of the collection or
	//anything else representing the normal scalability
	//issue with the command.
	CF_FAST = "fast"

	//The command implements the interface to return
	//the arguments that are keys. Used when start/stop/step
	//is not enough because of the command syntax.
	CF_GETKEYS_API = "getkeys-api"

	//The command should not register in Redis Cluster
	//since is not designed to work with it because, for
	//example, is unable to report the position of the
	//keys, programmatically creates key names, or any
	//other reason.
	CF_NO_CLUSTER = "no-cluster"
)
View Source 
const (
	// Return the type of the key. If the key pointer is NULL then `REDISMODULE_KEYTYPE_EMPTY` is returned.
	KEYTYPE_EMPTY = iota
	KEYTYPE_STRING
	KEYTYPE_LIST
	KEYTYPE_HASH
	KEYTYPE_SET
	KEYTYPE_ZSET
	KEYTYPE_MODULE
)

Key types.

View Source 
const (
	REPLY_UNKNOWN = iota - 1
	REPLY_STRING
	REPLY_ERROR
	REPLY_INTEGER
	REPLY_ARRAY
	REPLY_NULL
)

Reply types.

View Source 
const (
	ZADD_XX = 1 << iota
	ZADD_NX
	ZADD_ADDED
	ZADD_UPDATED
	ZADD_NOP
)

Sorted set API flags.

View Source 
const (
	HASH_NONE = 0
	// Set if non-exists
	HASH_NX = 1 << iota
	// Set if exists
	HASH_XX
	// Use *char as args, ! do not use this flag
	HASH_CFIELDS
	// Check field exists
	HASH_EXISTS
)

Hash API flags.

View Source 
const APIVER_1 = C.REDISMODULE_APIVER_1

API versions.

View Source 
const ERR = C.REDISMODULE_ERR
View Source 
const ERRORMSG_WRONGTYPE = "WRONGTYPE Operation against a key holding the wrong kind of value"
Error messages.

const ERRORMSG_WRONGTYPE = C.REDISMODULE_ERRORMSG_WRONGTYPE

View Source 
const LIST_HEAD = C.REDISMODULE_LIST_HEAD
View Source 
const LIST_TAIL = C.REDISMODULE_LIST_TAIL
View Source 
const NO_EXPIRE = C.REDISMODULE_NO_EXPIRE

Expire

View Source 
const OK = C.REDISMODULE_OK

Error status return values.

View Source 
const POSTPONED_ARRAY_LEN = C.REDISMODULE_POSTPONED_ARRAY_LEN

Postponed array length.

View Source 
const READ = C.REDISMODULE_READ

API flags and constants

View Source 
const WRITE = C.REDISMODULE_WRITE

Variables

View Source 
var LogDebug = func(format string, args ...interface{}) {
	fmt.Fprintf(os.Stdout, format+"\n", args...)
}
View Source 
var LogError = func(format string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, format+"\n", args...)
}

Functions

func Alloc 

func Alloc(bytes int) unsafe.Pointer

Use like malloc(). Memory allocated with this function is reported in Redis INFO memory, used for keys eviction according to maxmemory settings and in general is taken into account as memory allocated by Redis. You should avoid to use malloc(). void *RM_Alloc(size_t bytes);

func BuildCommandFlag 

func BuildCommandFlag(f ...CmdFlag) string

func Free 

func Free(ptr unsafe.Pointer)

Use like free() for memory obtained by `RedisModule_Alloc()` and `RedisModule_Realloc()`. However you should never try to free with `RedisModule_Free()` memory allocated with malloc() inside your module. void RM_Free(void *ptr);

func IsDebugEnabled 

func IsDebugEnabled() bool

func NullPointer 

func NullPointer() unsafe.Pointer

func Realloc 

func Realloc(ptr unsafe.Pointer, bytes int) unsafe.Pointer

Use like realloc() for memory obtained with `RedisModule_Alloc()`. void* RM_Realloc(void *ptr, size_t bytes);

func RedisModule_OnLoad 

func RedisModule_OnLoad(ctx uintptr, argv uintptr, argc int) C.int

func Run 

func Run()

Handler main invoke

func Strdup 

func Strdup(str unsafe.Pointer) unsafe.Pointer

Like strdup() but returns memory allocated with `RedisModule_Alloc()`. char *RM_Strdup(const char *str);

Types

type CallReply 

type CallReply uintptr

func CreateCallReply 

func CreateCallReply(ptr unsafe.Pointer) CallReply

func (CallReply) CallReplyArrayElement 

func (reply CallReply) CallReplyArrayElement(idx int) CallReply

Return the 'idx'-th nested call reply element of an array reply, or NULL if the reply type is wrong or the index is out of range. RedisModuleCallReply *RM_CallReplyArrayElement(RedisModuleCallReply *reply, size_t idx);

func (CallReply) CallReplyInteger 

func (reply CallReply) CallReplyInteger() int64

Return the long long of an integer reply. long long RM_CallReplyInteger(RedisModuleCallReply *reply);

func (CallReply) CallReplyLength 

func (reply CallReply) CallReplyLength() int

Return the reply type length, where applicable. size_t RM_CallReplyLength(RedisModuleCallReply *reply);

func (CallReply) CallReplyProto 

func (reply CallReply) CallReplyProto(len *uint64) unsafe.Pointer

Return a pointer, and a length, to the protocol returned by the command that returned the reply object. const char *RM_CallReplyProto(RedisModuleCallReply *reply, size_t *len);

func (CallReply) CallReplyStringPtr 

func (reply CallReply) CallReplyStringPtr(len *int) unsafe.Pointer

Return the pointer and length of a string or error reply. const char *RM_CallReplyStringPtr(RedisModuleCallReply *reply, size_t *len);

func (CallReply) CallReplyType 

func (reply CallReply) CallReplyType() int

Return the reply type. int RM_CallReplyType(RedisModuleCallReply *reply);

func (CallReply) CreateStringFromCallReply 

func (reply CallReply) CreateStringFromCallReply() String

Return a new string object from a call reply of type string, error or integer. Otherwise (wrong reply type) return NULL. RedisModuleString *RM_CreateStringFromCallReply(RedisModuleCallReply *reply);

func (CallReply) FreeCallReply 

func (reply CallReply) FreeCallReply()

Wrapper for the recursive free reply function. This is needed in order to have the first level function to return on nested replies, but only if called by the module API. void RM_FreeCallReply(RedisModuleCallReply *reply);

func (CallReply) IsNull 

func (v CallReply) IsNull() bool

type CmdContext 

type CmdContext struct {
	Ctx  Ctx
	Args []String
}

type CmdFlag 

type CmdFlag string

type CmdFunc 

type CmdFunc func(args CmdContext) int

type Command 

type Command struct {
	Usage  string
	Desc   string
	Name   string
	Action CmdFunc `json:"-"`
	// Use BuildCommandFLags to generate this flags
	Flags    string
	FirstKey int
	LastKey  int
	KeyStep  int
}

type Ctx 

type Ctx uintptr

func (Ctx) AutoMemory 

func (ctx Ctx) AutoMemory()

Enable automatic memory management. See API.md for more information.

The function must be called as the first function of a command implementation that wants to use automatic memory. void RM_AutoMemory(RedisModuleCtx *ctx);

func (Ctx) Call 

func (ctx Ctx) Call(cmdname string, format string, args ...interface{}) CallReply

Exported API to call any Redis command from modules. On success a RedisModuleCallReply object is returned, otherwise NULL is returned and errno is set to the following values:

EINVAL: command non existing, wrong arity, wrong format specifier. EPERM: operation in Cluster instance with key in non local slot. RedisModuleCallReply *RM_Call(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...);

func (Ctx) CreateCommand 

func (c Ctx) CreateCommand(cmd Command) int

func (Ctx) CreateDataType 

func (c Ctx) CreateDataType(dt DataType) ModuleType

func (Ctx) CreateString 

func (ctx Ctx) CreateString(ptr string, len int) String

Create a new module string object. The returned string must be freed with `RedisModule_FreeString()`, unless automatic memory is enabled.

The string is created by copying the `len` bytes starting at `ptr`. No reference is retained to the passed buffer. RedisModuleString *RM_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len);

func (Ctx) CreateStringFromLongLong 

func (ctx Ctx) CreateStringFromLongLong(ll int64) String

Like `RedisModule_CreatString()`, but creates a string starting from a long long integer instead of taking a buffer and its length.

The returned string must be released with `RedisModule_FreeString()` or by enabling automatic memory management. RedisModuleString *RM_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll);

func (Ctx) CreateStringFromString 

func (ctx Ctx) CreateStringFromString(str String) String

Like `RedisModule_CreatString()`, but creates a string starting from an existing RedisModuleString.

The returned string must be released with `RedisModule_FreeString()` or by enabling automatic memory management. RedisModuleString *RM_CreateStringFromString(RedisModuleCtx *ctx, const RedisModuleString *str);

func (Ctx) FreeString 

func (ctx Ctx) FreeString(str String)

Free a module string object obtained with one of the Redis modules API calls that return new string objects.

It is possible to call this function even when automatic memory management is enabled. In that case the string will be released ASAP and removed from the pool of string to release at the end. void RM_FreeString(RedisModuleCtx *ctx, RedisModuleString *str);

func (Ctx) GetClientId 

func (ctx Ctx) GetClientId() uint64

Return the ID of the current client calling the currently active module command. The returned ID has a few guarantees:

  1. The ID is different for each different client, so if the same client executes a module command multiple times, it can be recognized as having the same ID, otherwise the ID will be different.
  2. The ID increases monotonically. Clients connecting to the server later are guaranteed to get IDs greater than any past ID previously seen.

Valid IDs are from 1 to 2^64-1. If 0 is returned it means there is no way to fetch the ID in the context the function was currently called. unsigned long long RM_GetClientId(RedisModuleCtx *ctx);

func (Ctx) GetSelectedDb 

func (ctx Ctx) GetSelectedDb() int

Return the currently selected DB. int RM_GetSelectedDb(RedisModuleCtx *ctx);

func (Ctx) Init 

func (ctx Ctx) Init(name string, version int, apiVersion int) int

func (Ctx) IsKeysPositionRequest 

func (ctx Ctx) IsKeysPositionRequest() int

Return non-zero if a module command, that was declared with the flag "getkeys-api", is called in a special way to get the keys positions and not to get executed. Otherwise zero is returned. int RM_IsKeysPositionRequest(RedisModuleCtx *ctx);

func (Ctx) IsNull 

func (v Ctx) IsNull() bool

func (Ctx) KeyAtPos 

func (ctx Ctx) KeyAtPos(pos int)

When a module command is called in order to obtain the position of keys, since it was flagged as "getkeys-api" during the registration, the command implementation checks for this special call using the `RedisModule_IsKeysPositionRequest()` API and uses this function in order to report keys, like in the following example: 

if (`RedisModule_IsKeysPositionRequest(ctx))` {
    `RedisModule_KeyAtPos(ctx`,1);
    `RedisModule_KeyAtPos(ctx`,2);
}

Note: in the example below the get keys API would not be needed since
keys are at fixed positions. This interface is only used for commands
with a more complex structure.

void RM_KeyAtPos(RedisModuleCtx *ctx, int pos);

func (Ctx) Load 

func (c Ctx) Load(mod *Module, args []String) int

func (Ctx) Log 

func (ctx Ctx) Log(l LogLevel, format string, args ...interface{})

Produces a log message to the standard Redis log, the format accepts printf-alike specifiers, while level is a string describing the log level to use when emitting the log, and must be one of the following:

* "debug" * "verbose" * "notice" * "warning"

If the specified log level is invalid, verbose is used by default. There is a fixed limit to the length of the log line this function is able to emit, this limti is not specified but is guaranteed to be more than a few lines of text. void RM_Log(RedisModuleCtx *ctx, const char *levelstr, const char *fmt, ...);

func (Ctx) LogDebug 

func (ctx Ctx) LogDebug(format string, args ...interface{})

func (Ctx) LogNotice 

func (ctx Ctx) LogNotice(format string, args ...interface{})

func (Ctx) LogVerbose 

func (ctx Ctx) LogVerbose(format string, args ...interface{})

func (Ctx) LogWarn 

func (ctx Ctx) LogWarn(format string, args ...interface{})

func (Ctx) OpenKey 

func (ctx Ctx) OpenKey(keyname String, mode int) Key

Return an handle representing a Redis key, so that it is possible to call other APIs with the key handle as argument to perform operations on the key.

The return value is the handle repesenting the key, that must be closed with `RM_CloseKey()`.

If the key does not exist and WRITE mode is requested, the handle is still returned, since it is possible to perform operations on a yet not existing key (that will be created, for example, after a list push operation). If the mode is just READ instead, and the key does not exist, NULL is returned. However it is still safe to call `RedisModule_CloseKey()` and `RedisModule_KeyType()` on a NULL value. void *RM_OpenKey(RedisModuleCtx *ctx, robj *keyname, int mode);

func (Ctx) PoolAlloc 

func (ctx Ctx) PoolAlloc(bytes int) unsafe.Pointer

Return heap allocated memory that will be freed automatically when the module callback function returns. Mostly suitable for small allocations that are short living and must be released when the callback returns anyway. The returned memory is aligned to the architecture word size if at least word size bytes are requested, otherwise it is just aligned to the next power of two, so for example a 3 bytes request is 4 bytes aligned while a 2 bytes request is 2 bytes aligned.

There is no realloc style function since when this is needed to use the pool allocator is not a good idea.

The function returns NULL if `bytes` is 0. void *RM_PoolAlloc(RedisModuleCtx *ctx, size_t bytes);

func (Ctx) Replicate 

func (ctx Ctx) Replicate(cmdname string, format string, args ...interface{}) int

Replicate the specified command and arguments to slaves and AOF, as effect of execution of the calling command implementation.

The replicated commands are always wrapped into the MULTI/EXEC that contains all the commands replicated in a given module command execution. However the commands replicated with `RedisModule_Call()` are the first items, the ones replicated with `RedisModule_Replicate()` will all follow before the EXEC.

Modules should try to use one interface or the other.

This command follows exactly the same interface of `RedisModule_Call()`, so a set of format specifiers must be passed, followed by arguments matching the provided format specifiers.

Please refer to `RedisModule_Call()` for more information.

The command returns `REDISMODULE_ERR` if the format specifiers are invalid or the command name does not belong to a known command. int RM_Replicate(RedisModuleCtx *ctx, const char *cmdname, const char *fmt, ...);

func (Ctx) ReplicateVerbatim 

func (ctx Ctx) ReplicateVerbatim() int

This function will replicate the command exactly as it was invoked by the client. Note that this function will not wrap the command into a MULTI/EXEC stanza, so it should not be mixed with other replication commands.

Basically this form of replication is useful when you want to propagate the command to the slaves and AOF file exactly as it was called, since the command can just be re-executed to deterministically re-create the new state starting from the old one.

The function always returns `REDISMODULE_OK`. int RM_ReplicateVerbatim(RedisModuleCtx *ctx);

func (Ctx) ReplySetArrayLength 

func (ctx Ctx) ReplySetArrayLength(len int64)

When `RedisModule_ReplyWithArray()` is used with the argument `REDISMODULE_POSTPONED_ARRAY_LEN`, because we don't know beforehand the number of items we are going to output as elements of the array, this function will take care to set the array length.

Since it is possible to have multiple array replies pending with unknown length, this function guarantees to always set the latest array length that was created in a postponed way.

For example in order to output an array like [1,[10,20,30]] we could write: 

`RedisModule_ReplyWithArray(ctx`,`REDISMODULE_POSTPONED_ARRAY_LEN`);
`RedisModule_ReplyWithLongLong(ctx`,1);
`RedisModule_ReplyWithArray(ctx`,`REDISMODULE_POSTPONED_ARRAY_LEN`);
`RedisModule_ReplyWithLongLong(ctx`,10);
`RedisModule_ReplyWithLongLong(ctx`,20);
`RedisModule_ReplyWithLongLong(ctx`,30);
`RedisModule_ReplySetArrayLength(ctx`,3); // Set len of 10,20,30 array.
`RedisModule_ReplySetArrayLength(ctx`,2); // Set len of top array

Note that in the above example there is no reason to postpone the array length, since we produce a fixed number of elements, but in the practice the code may use an interator or other ways of creating the output so that is not easy to calculate in advance the number of elements. void RM_ReplySetArrayLength(RedisModuleCtx *ctx, long len);

func (Ctx) ReplyWithArray 

func (ctx Ctx) ReplyWithArray(len int64) int

Reply with an array type of 'len' elements. However 'len' other calls to `ReplyWith*` style functions must follow in order to emit the elements of the array.

When producing arrays with a number of element that is not known beforehand the function can be called with the special count `REDISMODULE_POSTPONED_ARRAY_LEN`, and the actual number of elements can be later set with `RedisModule_ReplySetArrayLength()` (which will set the latest "open" count if there are multiple ones).

The function always returns `REDISMODULE_OK`. int RM_ReplyWithArray(RedisModuleCtx *ctx, long len);

func (Ctx) ReplyWithCallReply 

func (ctx Ctx) ReplyWithCallReply(reply CallReply) int

Reply exactly what a Redis command returned us with `RedisModule_Call()`. This function is useful when we use `RedisModule_Call()` in order to execute some command, as we want to reply to the client exactly the same reply we obtained by the command.

The function always returns `REDISMODULE_OK`. int RM_ReplyWithCallReply(RedisModuleCtx *ctx, RedisModuleCallReply *reply);

func (Ctx) ReplyWithDouble 

func (ctx Ctx) ReplyWithDouble(d float64) int

Send a string reply obtained converting the double 'd' into a bulk string. This function is basically equivalent to converting a double into a string into a C buffer, and then calling the function `RedisModule_ReplyWithStringBuffer()` with the buffer and length.

The function always returns `REDISMODULE_OK`. int RM_ReplyWithDouble(RedisModuleCtx *ctx, double d);

func (Ctx) ReplyWithError 

func (ctx Ctx) ReplyWithError(err string) int

The function always returns `REDISMODULE_OK`. int RM_ReplyWithError(RedisModuleCtx *ctx, const char *err);

func (Ctx) ReplyWithLongLong 

func (ctx Ctx) ReplyWithLongLong(ll int64) int

Send an integer reply to the client, with the specified long long value. The function always returns `REDISMODULE_OK`. int RM_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll);

func (Ctx) ReplyWithNull 

func (ctx Ctx) ReplyWithNull() int

Reply to the client with a NULL. In the RESP protocol a NULL is encoded as the string "$-1\r\n".

The function always returns `REDISMODULE_OK`. int RM_ReplyWithNull(RedisModuleCtx *ctx);

func (Ctx) ReplyWithOK 

func (ctx Ctx) ReplyWithOK() int

func (Ctx) ReplyWithSimpleString 

func (ctx Ctx) ReplyWithSimpleString(msg string) int

Reply with a simple string (+... \r\n in RESP protocol). This replies are suitable only when sending a small non-binary string with small overhead, like "OK" or similar replies.

The function always returns `REDISMODULE_OK`. int RM_ReplyWithSimpleString(RedisModuleCtx *ctx, const char *msg);

func (Ctx) ReplyWithString 

func (ctx Ctx) ReplyWithString(str String) int

Reply with a bulk string, taking in input a RedisModuleString object.

The function always returns `REDISMODULE_OK`. int RM_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str);

func (Ctx) ReplyWithStringBuffer 

func (ctx Ctx) ReplyWithStringBuffer(buf []byte, len int) int

Reply with a bulk string, taking in input a C buffer pointer and length.

The function always returns `REDISMODULE_OK`. int RM_ReplyWithStringBuffer(RedisModuleCtx *ctx, const char *buf, size_t len);

func (Ctx) SelectDb 

func (ctx Ctx) SelectDb(newid int) int

Change the currently selected DB. Returns an error if the id is out of range.

Note that the client will retain the currently selected DB even after the Redis command implemented by the module calling this function returns.

If the module command wishes to change something in a different DB and returns back to the original one, it should call `RedisModule_GetSelectedDb()` before in order to restore the old DB number before returning. int RM_SelectDb(RedisModuleCtx *ctx, int newid);

func (Ctx) SetModuleAttribs 

func (ctx Ctx) SetModuleAttribs(name string, ver int, apiver int)

Called by `RM_Init()` to setup the `ctx->module` structure.

This is an internal function, Redis modules developers don't need to use it. void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver);

func (Ctx) WrongArity 

func (ctx Ctx) WrongArity() int

int RM_WrongArity(RedisModuleCtx *ctx);

type DataType 

type DataType struct {
	Desc string
	// A 9 characters data type name that MUST be unique in the Redis
	// Modules ecosystem. Be creative... and there will be no collisions. Use
	// the charset A-Z a-z 9-0, plus the two "-_" characters. A good
	// idea is to use, for example `<typename>-<vendor>`. For example
	// "tree-AntZ" may mean "Tree data structure by @antirez". To use both
	// lower case and upper case letters helps in order to prevent collisions.
	//
	// Note: the module name "AAAAAAAAA" is reserved and produces an error, it
	// happens to be pretty lame as well.
	Name string
	// Encoding version, which is, the version of the serialization
	// that a module used in order to persist data. As long as the "name"
	// matches, the RDB loading will be dispatched to the type callbacks
	// whatever 'encver' is used, however the module can understand if
	// the encoding it must load are of an older version of the module.
	// For example the module "tree-AntZ" initially used encver=0. Later
	// after an upgrade, it started to serialize data in a different format
	// and to register the type with encver=1. However this module may
	// still load old data produced by an older version if the rdb_load
	// callback is able to check the encver value and act accordingly.
	// The encver must be a positive value between 0 and 1023.
	EncVer int
	// A callback function pointer that loads data from RDB files.
	RdbLoad func(rdb IO, encver int) unsafe.Pointer `json:"-"`
	// A callback function pointer that saves data to RDB files.
	RdbSave func(rdb IO, value unsafe.Pointer) `json:"-"`
	// A callback function pointer that rewrites data as commands.
	AofRewrite func(aof IO, key String, value unsafe.Pointer) `json:"-"`
	// A callback function pointer that is used for `DEBUG DIGEST`.
	Digest func(digest Digest, value unsafe.Pointer) `json:"-"`
	// A callback function pointer that can free a type value.
	Free func(value unsafe.Pointer) `json:"-"`
}

type Digest 

type Digest uintptr

type HashKey 

type HashKey Key

type IO 

type IO uintptr

func (IO) EmitAOF 

func (io IO) EmitAOF(cmdname string, format string, args ...interface{})

Emits a command into the AOF during the AOF rewriting process. This function is only called in the context of the aof_rewrite method of data types exported by a module. The command works exactly like `RedisModule_Call()` in the way the parameters are passed, but it does not return anything as the error handling is performed by Redis itself. void RM_EmitAOF(RedisModuleIO *io, const char *cmdname, const char *fmt, ...);

func (IO) IsNull 

func (v IO) IsNull() bool

func (IO) LoadDouble 

func (io IO) LoadDouble() float64

In the context of the rdb_save method of a module data type, loads back the double value saved by `RedisModule_SaveDouble()`. double RM_LoadDouble(RedisModuleIO *io);

func (IO) LoadSigned 

func (io IO) LoadSigned() int64

Like `RedisModule_LoadUnsigned()` but for signed 64 bit values. int64_t RM_LoadSigned(RedisModuleIO *io);

func (IO) LoadString 

func (io IO) LoadString() String

In the context of the rdb_load method of a module data type, loads a string from the RDB file, that was previously saved with `RedisModule_SaveString()` functions family.

The returned string is a newly allocated RedisModuleString object, and the user should at some point free it with a call to `RedisModule_FreeString()`.

If the data structure does not store strings as RedisModuleString objects, the similar function `RedisModule_LoadStringBuffer()` could be used instead. RedisModuleString *RM_LoadString(RedisModuleIO *io);

func (IO) LoadStringBuffer 

func (io IO) LoadStringBuffer(lenptr *uint64) unsafe.Pointer

Like `RedisModule_LoadString()` but returns an heap allocated string that was allocated with `RedisModule_Alloc()`, and can be resized or freed with `RedisModule_Realloc()` or `RedisModule_Free()`.

The size of the string is stored at '*lenptr' if not NULL. The returned string is not automatically NULL termianted, it is loaded exactly as it was stored inisde the RDB file. char *RM_LoadStringBuffer(RedisModuleIO *io, size_t *lenptr);

func (IO) LoadUnsigned 

func (io IO) LoadUnsigned() uint64

Load an unsigned 64 bit value from the RDB file. This function should only be called in the context of the rdb_load method of modules implementing new data types. uint64_t RM_LoadUnsigned(RedisModuleIO *io);

func (IO) SaveDouble 

func (io IO) SaveDouble(value float64)

In the context of the rdb_save method of a module data type, saves a double value to the RDB file. The double can be a valid number, a NaN or infinity. It is possible to load back the value with `RedisModule_LoadDouble()`. void RM_SaveDouble(RedisModuleIO *io, double value);

func (IO) SaveSigned 

func (io IO) SaveSigned(value int64)

Like `RedisModule_SaveUnsigned()` but for signed 64 bit values. void RM_SaveSigned(RedisModuleIO *io, int64_t value);

func (IO) SaveString 

func (io IO) SaveString(s String)

In the context of the rdb_save method of a module type, saves a string into the RDB file taking as input a RedisModuleString.

The string can be later loaded with `RedisModule_LoadString()` or other Load family functions expecting a serialized string inside the RDB file. void RM_SaveString(RedisModuleIO *io, RedisModuleString *s);

func (IO) SaveStringBuffer 

func (io IO) SaveStringBuffer(str []byte, len int)

Like `RedisModule_SaveString()` but takes a raw C pointer and length as input. void RM_SaveStringBuffer(RedisModuleIO *io, const char *str, size_t len);

func (IO) SaveUnsigned 

func (io IO) SaveUnsigned(value uint64)

Save an unsigned 64 bit value into the RDB file. This function should only be called in the context of the rdb_save method of modules implementing new data types. void RM_SaveUnsigned(RedisModuleIO *io, uint64_t value);

type Key 

type Key uintptr

func (Key) CloseKey 

func (key Key) CloseKey()

Close a key handle. void RM_CloseKey(RedisModuleKey *key);

func (Key) DeleteKey 

func (key Key) DeleteKey() int

If the key is open for writing, remove it, and setup the key to accept new writes as an empty key (that will be created on demand). On success `REDISMODULE_OK` is returned. If the key is not open for writing `REDISMODULE_ERR` is returned. int RM_DeleteKey(RedisModuleKey *key);

func (Key) GetExpire 

func (key Key) GetExpire() uint64

Return the key expire value, as milliseconds of remaining TTL. If no TTL is associated with the key or if the key is empty, `REDISMODULE_NO_EXPIRE` is returned. mstime_t RM_GetExpire(RedisModuleKey *key);

func (Key) HashDel 

func (key Key) HashDel(field String) int

`RedisModule_HashSet(key`,`REDISMODULE_HASH_NONE`,argv[1], `REDISMODULE_HASH_DELETE`,NULL);

func (Key) HashExists 

func (key Key) HashExists(field String) bool

func (Key) HashGet 

func (key Key) HashGet(flags int, args ...interface{}) int

Get fields from an hash value. This function is called using a variable number of arguments, alternating a field name (as a StringRedisModule pointer) with a pointer to a StringRedisModule pointer, that is set to the value of the field if the field exist, or NULL if the field did not exist. At the end of the field/value-ptr pairs, NULL must be specified as last argument to signal the end of the arguments in the variadic function.

This is an example usage: 

RedisModuleString *first, *second;
`RedisModule_HashGet(mykey`,`REDISMODULE_HASH_NONE`,argv[1],&first,
                argv[2],&second,NULL);

As with `RedisModule_HashSet()` the behavior of the command can be specified passing flags different than `REDISMODULE_HASH_NONE`:

`REDISMODULE_HASH_CFIELD`: field names as null terminated C strings.

`REDISMODULE_HASH_EXISTS`: instead of setting the value of the field expecting a RedisModuleString pointer to pointer, the function just reports if the field esists or not and expects an integer pointer as the second element of each pair.

Example of `REDISMODULE_HASH_CFIELD`: 

RedisModuleString *username, *hashedpass;
`RedisModule_HashGet(mykey`,"username",&username,"hp",&hashedpass, NULL);

Example of `REDISMODULE_HASH_EXISTS`: 

int exists;
`RedisModule_HashGet(mykey`,argv[1],&exists,NULL);

The function returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` if the key is not an hash value.

Memory management:

The returned RedisModuleString objects should be released with `RedisModule_FreeString()`, or by enabling automatic memory management. int RM_HashGet(RedisModuleKey *key, int flags, ...); args is RedisModuleString** RedisModuleString* or char* if flags include CFIELD

func (Key) HashSet 

func (key Key) HashSet(flags int, args ...interface{}) int

Return value:

The number of fields updated (that may be less than the number of fields specified because of the XX or NX options).

In the following case the return value is always zero:

* The key was not open for writing. * The key was associated with a non Hash value. int RM_HashSet(RedisModuleKey *key, int flags, ...);

func (Key) IsEmpty 

func (key Key) IsEmpty() bool

func (Key) IsNull 

func (v Key) IsNull() bool

func (Key) KeyType 

func (key Key) KeyType() int

Return the type of the key. If the key pointer is NULL then `REDISMODULE_KEYTYPE_EMPTY` is returned. int RM_KeyType(RedisModuleKey *key);

func (Key) ListPop 

func (key Key) ListPop(where int) String

Pop an element from the list, and returns it as a module string object that the user should be free with `RM_FreeString()` or by enabling automatic memory. 'where' specifies if the element should be popped from head or tail. The command returns NULL if: 1) The list is empty. 2) The key was not open for writing. 3) The key is not a list. RedisModuleString *RM_ListPop(RedisModuleKey *key, int where);

func (Key) ListPush 

func (key Key) ListPush(where int, ele String) int

Push an element into a list, on head or tail depending on 'where' argumnet. If the key pointer is about an empty key opened for writing, the key is created. On error (key opened for read-only operations or of the wrong type) `REDISMODULE_ERR` is returned, otherwise `REDISMODULE_OK` is returned. int RM_ListPush(RedisModuleKey *key, int where, RedisModuleString *ele);

func (Key) ModuleTypeGetType 

func (key Key) ModuleTypeGetType() ModuleType

Assuming `RedisModule_KeyType()` returned `REDISMODULE_KEYTYPE_MODULE` on the key, returns the moduel type pointer of the value stored at key.

If the key is NULL, is not associated with a module type, or is empty, then NULL is returned instead. moduleType *RM_ModuleTypeGetType(RedisModuleKey *key);

func (Key) ModuleTypeGetValue 

func (key Key) ModuleTypeGetValue() unsafe.Pointer

Assuming `RedisModule_KeyType()` returned `REDISMODULE_KEYTYPE_MODULE` on the key, returns the module type low-level value stored at key, as it was set by the user via `RedisModule_ModuleTypeSet()`.

If the key is NULL, is not associated with a module type, or is empty, then NULL is returned instead. void *RM_ModuleTypeGetValue(RedisModuleKey *key);

func (Key) ModuleTypeSetValue 

func (key Key) ModuleTypeSetValue(mt ModuleType, value unsafe.Pointer) int

If the key is open for writing, set the specified module type object as the value of the key, deleting the old value if any. On success `REDISMODULE_OK` is returned. If the key is not open for writing or there is an active iterator, `REDISMODULE_ERR` is returned. int RM_ModuleTypeSetValue(RedisModuleKey *key, moduleType *mt, void *value);

func (Key) SetExpire 

func (key Key) SetExpire(expire uint64) int

Set a new expire for the key. If the special expire `REDISMODULE_NO_EXPIRE` is set, the expire is cancelled if there was one (the same as the PERSIST command).

Note that the expire must be provided as a positive integer representing the number of milliseconds of TTL the key should have.

The function returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if the key was not open for writing or is an empty key. int RM_SetExpire(RedisModuleKey *key, mstime_t expire);

func (Key) StringDMA 

func (key Key) StringDMA(len *uint64, mode int) unsafe.Pointer

Prepare the key associated string value for DMA access, and returns a pointer and size (by reference), that the user can use to read or modify the string in-place accessing it directly via pointer.

The 'mode' is composed by bitwise OR-ing the following flags:

`REDISMODULE_READ` -- Read access `REDISMODULE_WRITE` -- Write access

If the DMA is not requested for writing, the pointer returned should only be accessed in a read-only fashion.

On error (wrong type) NULL is returned.

DMA access rules:

1. No other key writing function should be called since the moment the pointer is obtained, for all the time we want to use DMA access to read or modify the string.

2. Each time `RM_StringTruncate()` is called, to continue with the DMA access, `RM_StringDMA()` should be called again to re-obtain a new pointer and length.

3. If the returned pointer is not NULL, but the length is zero, no byte can be touched (the string is empty, or the key itself is empty) so a `RM_StringTruncate()` call should be used if there is to enlarge the string, and later call StringDMA() again to get the pointer. char *RM_StringDMA(RedisModuleKey *key, size_t *len, int mode);

func (Key) StringSet 

func (key Key) StringSet(str String) int

If the key is open for writing, set the specified string 'str' as the value of the key, deleting the old value if any. On success `REDISMODULE_OK` is returned. If the key is not open for writing or there is an active iterator, `REDISMODULE_ERR` is returned. int RM_StringSet(RedisModuleKey *key, RedisModuleString *str);

func (Key) StringTruncate 

func (key Key) StringTruncate(newlen int) int

If the string is open for writing and is of string type, resize it, padding with zero bytes if the new length is greater than the old one.

After this call, `RM_StringDMA()` must be called again to continue DMA access with the new pointer.

The function returns `REDISMODULE_OK` on success, and `REDISMODULE_ERR` on error, that is, the key is not open for writing, is not a string or resizing for more than 512 MB is requested.

If the key is empty, a string key is created with the new string value unless the new length value requested is zero. int RM_StringTruncate(RedisModuleKey *key, size_t newlen);

func (Key) ValueLength 

func (key Key) ValueLength() int

Return the length of the value associated with the key. For strings this is the length of the string. For all the other types is the number of elements (just counting keys for hashes).

If the key pointer is NULL or the key is empty, zero is returned. size_t RM_ValueLength(RedisModuleKey *key);

func (Key) ZsetAdd 

func (key Key) ZsetAdd(score float64, ele String, flagsptr *int32) int

Add a new element into a sorted set, with the specified 'score'. If the element already exists, the score is updated.

A new sorted set is created at value if the key is an empty open key setup for writing.

Additional flags can be passed to the function via a pointer, the flags are both used to receive input and to communicate state when the function returns. 'flagsptr' can be NULL if no special flags are used.

The input flags are:

`REDISMODULE_ZADD_XX`: Element must already exist. Do nothing otherwise. `REDISMODULE_ZADD_NX`: Element must not exist. Do nothing otherwise.

The output flags are:

`REDISMODULE_ZADD_ADDED`: The new element was added to the sorted set. `REDISMODULE_ZADD_UPDATED`: The score of the element was updated. `REDISMODULE_ZADD_NOP`: No operation was performed because XX or NX flags.

On success the function returns `REDISMODULE_OK`. On the following errors `REDISMODULE_ERR` is returned:

* The key was not opened for writing. * The key is of the wrong type. * 'score' double value is not a number (NaN). int RM_ZsetAdd(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr);

func (Key) ZsetFirstInLexRange 

func (key Key) ZsetFirstInLexRange(min String, max String) int

Setup a sorted set iterator seeking the first element in the specified lexicographical range. Returns `REDISMODULE_OK` if the iterator was correctly initialized otherwise `REDISMODULE_ERR` is returned in the following conditions:

1. The value stored at key is not a sorted set or the key is empty. 2. The lexicographical range 'min' and 'max' format is invalid.

'min' and 'max' should be provided as two RedisModuleString objects in the same format as the parameters passed to the ZRANGEBYLEX command. The function does not take ownership of the objects, so they can be released ASAP after the iterator is setup. int RM_ZsetFirstInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max);

func (Key) ZsetFirstInScoreRange 

func (key Key) ZsetFirstInScoreRange(min float64, max float64, minex int, maxex int) int

Setup a sorted set iterator seeking the first element in the specified range. Returns `REDISMODULE_OK` if the iterator was correctly initialized otherwise `REDISMODULE_ERR` is returned in the following conditions:

1. The value stored at key is not a sorted set or the key is empty.

The range is specified according to the two double values 'min' and 'max'. Both can be infinite using the following two macros:

`REDISMODULE_POSITIVE_INFINITE` for positive infinite value `REDISMODULE_NEGATIVE_INFINITE` for negative infinite value

'minex' and 'maxex' parameters, if true, respectively setup a range where the min and max value are exclusive (not included) instead of inclusive. int RM_ZsetFirstInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex);

func (Key) ZsetIncrby 

func (key Key) ZsetIncrby(score float64, ele String, flagsptr *int32, newscore *float64) int

This function works exactly like `RM_ZsetAdd()`, but instead of setting a new score, the score of the existing element is incremented, or if the element does not already exist, it is added assuming the old score was zero.

The input and output flags, and the return value, have the same exact meaning, with the only difference that this function will return `REDISMODULE_ERR` even when 'score' is a valid double number, but adding it to the existing score resuts into a NaN (not a number) condition.

This function has an additional field 'newscore', if not NULL is filled with the new score of the element after the increment, if no error is returned. int RM_ZsetIncrby(RedisModuleKey *key, double score, RedisModuleString *ele, int *flagsptr, double *newscore);

func (Key) ZsetLastInLexRange 

func (key Key) ZsetLastInLexRange(min String, max String) int

Exactly like `RedisModule_ZsetFirstInLexRange()` but the last element of the range is selected for the start of the iteration instead. int RM_ZsetLastInLexRange(RedisModuleKey *key, RedisModuleString *min, RedisModuleString *max);

func (Key) ZsetLastInScoreRange 

func (key Key) ZsetLastInScoreRange(min float64, max float64, minex int, maxex int) int

Exactly like `RedisModule_ZsetFirstInScoreRange()` but the last element of the range is selected for the start of the iteration instead. int RM_ZsetLastInScoreRange(RedisModuleKey *key, double min, double max, int minex, int maxex);

func (Key) ZsetRangeCurrentElement 

func (key Key) ZsetRangeCurrentElement(score *float64) String

Return the current sorted set element of an active sorted set iterator or NULL if the range specified in the iterator does not include any element. RedisModuleString *RM_ZsetRangeCurrentElement(RedisModuleKey *key, double *score);

func (Key) ZsetRangeEndReached 

func (key Key) ZsetRangeEndReached() int

Return the "End of range" flag value to signal the end of the iteration. int RM_ZsetRangeEndReached(RedisModuleKey *key);

func (Key) ZsetRangeNext 

func (key Key) ZsetRangeNext() int

Go to the next element of the sorted set iterator. Returns 1 if there was a next element, 0 if we are already at the latest element or the range does not include any item at all. int RM_ZsetRangeNext(RedisModuleKey *key);

func (Key) ZsetRangePrev 

func (key Key) ZsetRangePrev() int

Go to the previous element of the sorted set iterator. Returns 1 if there was a previous element, 0 if we are already at the first element or the range does not include any item at all. int RM_ZsetRangePrev(RedisModuleKey *key);

func (Key) ZsetRangeStop 

func (key Key) ZsetRangeStop()

Stop a sorted set iteration. void RM_ZsetRangeStop(RedisModuleKey *key);

func (Key) ZsetRem 

func (key Key) ZsetRem(ele String, deleted *int32) int

Remove the specified element from the sorted set. The function returns `REDISMODULE_OK` on success, and `REDISMODULE_ERR` on one of the following conditions:

* The key was not opened for writing. * The key is of the wrong type.

The return value does NOT indicate the fact the element was really removed (since it existed) or not, just if the function was executed with success.

In order to know if the element was removed, the additional argument 'deleted' must be passed, that populates the integer by reference setting it to 1 or 0 depending on the outcome of the operation. The 'deleted' argument can be NULL if the caller is not interested to know if the element was really removed.

Empty keys will be handled correctly by doing nothing. int RM_ZsetRem(RedisModuleKey *key, RedisModuleString *ele, int *deleted);

func (Key) ZsetScore 

func (key Key) ZsetScore(ele String, score *float64) int

On success retrieve the double score associated at the sorted set element 'ele' and returns `REDISMODULE_OK`. Otherwise `REDISMODULE_ERR` is returned to signal one of the following conditions:

* There is no such element 'ele' in the sorted set. * The key is not a sorted set. * The key is an open empty key. int RM_ZsetScore(RedisModuleKey *key, RedisModuleString *ele, double *score);

type ListKey 

type ListKey Key

type LogLevel 

type LogLevel int
const (
	LOG_DEBUG LogLevel = iota
	LOG_VERBOSE
	LOG_NOTICE
	LOG_WARNING
)

type Module 

type Module struct {
	Name      string
	Version   int
	SemVer    string
	Commands  []Command  `json:",omitempty"`
	DataTypes []DataType `json:",omitempty"`

	BeforeInit func(Ctx, []String) error `json:"-"`
	AfterInit  func(Ctx, []String) error `json:"-"`
	// When module unload
	// ! Very unstable, try to avoid this
	OnUnload func() `json:"-"`

	// Compilation date
	Compiled time.Time
	// List of all authors who contributed
	//Authors []Author
	// Copyright of the binary if any
	Copyright string `json:",omitempty"`
	// Name of Author (Note: Use App.Authors, this is deprecated)
	Author  string `json:",omitempty"`
	Website string `json:",omitempty"`
	// Email of Author (Note: Use App.Authors, this is deprecated)
	Email string `json:",omitempty"`
	// Long description for this module
	Desc string `json:",omitempty"`
	// Will log more things
	Debug bool
}
var Mod *Module

This module will be loaded

func NewMod 

func NewMod() *Module

type ModuleType 

type ModuleType uintptr

func GetModuleDataType 

func GetModuleDataType(name string) ModuleType

func (ModuleType) IsNull 

func (v ModuleType) IsNull() bool

type String 

type String uintptr

func CreateString 

func CreateString(ptr unsafe.Pointer) String

func NullString 

func NullString() String

func (String) Compare 

func (str String) Compare(b String) int

func (String) IsNull 

func (v String) IsNull() bool

func (String) String 

func (str String) String() string

Given a string module object, this function returns the string pointer and length of the string. The returned pointer and length should only be used for read only accesses and never modified. const char *RM_StringPtrLen(RedisModuleString *str, size_t *len);

func (String) StringToDouble 

func (str String) StringToDouble(d *float64) int

Convert the string into a double, storing it at `*d`. Returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if the string is not a valid string representation of a double value. int RM_StringToDouble(RedisModuleString *str, double *d);

func (String) StringToLongLong 

func (str String) StringToLongLong(ll *int64) int

Convert the string into a long long integer, storing it at `*ll`. Returns `REDISMODULE_OK` on success. If the string can't be parsed as a valid, strict long long (no spaces before/after), `REDISMODULE_ERR` is returned. int RM_StringToLongLong(RedisModuleString *str, long long *ll);

type StringKey 

type StringKey Key

type ZsetKey 

type ZsetKey Key

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.