redis-embeded-lua

node-redis-embeded-lua
==================
~~~js
var redis = require("redis"),
redisClient = redis.createClient();
var redisEmbededLua = require('redis-embeded-lua');

redisEmbededLua.attach(redisClient);

var pack = redisClient.sha1pack(
local r = redis.call('keys', '*')
local count = 0
for k,v in ipairs(r) do
/*
* k: index of Array
* v: the redis key
*/
count = count + 1
end
return 'the dbsize: '..count
);
redisClient.evalScript(pack)
.then(function(ret) {
console.log(ret);
redisClient.unref();
})
.catch(function(e) {
console.error(e.toString());
process.exit(1);
});
~~~
~~~bash
$ npm install redis-embeded-lua
$ vi test.js
$ node ./test.js
the dbsize: 9 # maybe different from your system.
~~~

Usage

$3

~~~js
var pack = redisClient.sha1pack(
/*
* the ARGV is a string array.
* SEE ALSO: examples/insertDB.js
*/
redis.call('set', ARGV[1], ARGV[2])
return 'ok'
);

redisClient.evalScript(pack, 'foo', 'bar')
.then(function(ret) {
console.log('the result:', ret);
redisClient.unref();
})
.catch(function(e) {
console.error(e.toString());
process.exit(1);
});
~~~

$3

~~~js
var pack = redisClient.sha1pack(
/*
* the method 'call':
* the same rules as the printf family of standard C functions
* SEE ALSO, string.format(fmt, ...)
* yes! there are another function 'pcall' as redis.pcall
*/
call('set foo bar_%s', 'hello world')
return call('get foo')
);
~~~

~~~bash
$ vi test.js
$ node ./test.js
the result: bar_hello world
~~~

$3

~~~lua
exports.PI = 3.14
exports.mul = function(a,b)
return a*b
end
~~~
~~~js
var pack = redisClient.sha1pack(
local mathDemo = require('./mathDemo.lua')
call('set radius 9')
local radius = call('get radius')
//area = radius radius PI
return mathDemo.mul(radius*radius, mathDemo.PI)
);
~~~
~~~bash
$ vi mathDemo.lua
$ vi test.js
$ node ./test.js
the result: 254
~~~

$3

~~~js
var redis = require("redis"),
redisClient = redis.createClient();
var redisEmbededLua = require('redis-embeded-lua');

redisEmbededLua.attach(redisClient);

/*
* Actually, evalScript' must be called in a closure;
* because, performance of sha1pack' is expensive.
* Yes, run bussiness in closure' is the original intention'.
*/
var yourBussinessDBCount = (function() {
var pack = redisClient.sha1pack(
local r = call('keys *')
local count = 0
for k,v in ipairs(r) do
count = count + 1
end
return 'the dbsize: '..count
);
return function() {
return redisClient.evalScript(pack);
}
})();

yourBussinessDBCount()
.then(function(ret) {
console.log(ret);
redisClient.unref();
})
.catch(function(e) {
console.error(e.toString());
process.exit(1);
});
~~~
~~~bash
$ vi test.js
$ node ./test.js
the dbsize: 9
~~~

or define class':

~~~js
class YourBussiness() {
constructor(redisClient) {
this.client = redisClient;
redisEmbededLua.attach(this.client);
}
}
YourBussiness.prototype.set = (function() {
var script = redisClient.sha1pack(
call("set %s %s", ARGS[1], ARGS[2])
return
);
return function(key, val) {
return this.client.evalScript(script, key, val);
};
})();

YourBussiness.prototype.get = (function() {
var script = redisClient.sha1pack(
return call('get %s', ARGS[1])
);
return function(key) {
return this.client.evalScript(script, key);
};
})();
~~~

$3

__TIP__: If you use only one db in redis, ignore this section.

Although I don't like the multi-db design of redis,
provide two method using reids-multi-dbs flexible.

If I were you, I would use only #0 db.

method 1:
~~~js
redisClient.configDBName({
DEFAULT : 0,
USERINFO: 1,
STATICS : 11,
TEST : 15
});
var pack = redisClient.sha1pack(
local t = {}
//Luckly, the initial db is always #0
table.insert(t, call('dbsize'))
select('TEST')
table.insert(t, call('dbsize'))
select('STATICS')
table.insert(t, call('dbsize'))
//Certainly, you can use db number directly
select(1)
table.insert(t, call('dbsize'))
return t
);
~~~
~~~bash
$ vi test.js
$ node test.js
[ 6, 1, 1, 3 ]
~~~

method 2:
~~~lua
exports = {
DEFAULT = 0,
USERINFO = 1,
STATICS = 11,
TEST = 15
}
~~~
~~~js
var pack = redisClient.sha1pack(
local db = require('./conf.lua')
local t = {}
select(db.TEST)
table.insert(t, call('dbsize'))
select(db.STATICS)
table.insert(t, call('dbsize'))
select(1)
table.insert(t, call('dbsize'))
return t
);
~~~
~~~bash
$ vi conf.lua
$ vi test.js
$ node test.js
[ 1, 1, 3 ]
~~~

Installation


npm install redis-embeded-lua

---

LUA API

$3

require like nodejs. Only support one level(and in embeded lua).

$3

printf(3) + redis.call + redis-cli

$3

printf(3) + redis.pcall + redis-cli

$3

* select index
`
select(1)
`

* select dbname
redisClient.configDBName(conf), then select(dbname);

`
select('USERINFO')
`

return value
* success: nil
* fail: message

$3

for examples:
~~~
exists('foo')
~~~

return true or false

Instead of the following
~~~lua
if redis.call('exists', 'foo') == 1 then
return true
else
return false
end
~~~

---


JavaScirpt API

$3

* pack: object, return by redisClient.sha1pack(script). required
* arg1 - argn: arguments. optional

return Promise

$3

* script: lua scirpt, string

return object
`JSON
{
text:"lua script...",
sha1:"sha1num"
}
`

$3

* conf object
`JSON
{
DEFAULT: 0,
USERINFO: 1
}
``