box: add takes_raw_args lua function option

Closes #3349

@TarantoolBot document
Title: Document that takes_raw_args function option

A new function option was added - `takes_raw_args`:

```lua
box.schema.func.create('my_func', {takes_raw_args = true})
```

If set for a Lua function, the functions arguments will be passed
wrapped in a msgpack object (see `msgpack.object()`) when the function
is called over IPROTO or by `box.func.NAME:call()`:

```lua
local msgpack = require('msgpack')
local my_func = function(mp)
    assert(msgpack.is_object(mp))
    local args = mp:decode() -- array of arguments
end
```

Using this option might improve performance in case a function forwards
most of its arguments to another instance or writes them to a database,
because it eliminates msgpack decoding in Lua.

Author: locker

changelogs/unreleased/gh-3349-func-takes-raw-args.md

@@ -0,0 +1,4 @@
+## feature/core
+
+* Added `takes_raw_args` Lua function option for wrapping arguments in
+  `msgpack.object` to skip decoding (gh-3349).

src/box/func_def.c

@@ -40,17 +40,21 @@ const char *func_aggregate_strs[] = {"none", "group"};
 
 const struct func_opts func_opts_default = {
 	/* .is_multikey = */ false,
+	/* .takes_raw_args = */ false,
 };
 
 const struct opt_def func_opts_reg[] = {
 	OPT_DEF("is_multikey", OPT_BOOL, struct func_opts, is_multikey),
+	OPT_DEF("takes_raw_args", OPT_BOOL, struct func_opts, takes_raw_args),
 };
 
 int
 func_opts_cmp(struct func_opts *o1, struct func_opts *o2)
 {
 	if (o1->is_multikey != o2->is_multikey)
 		return o1->is_multikey - o2->is_multikey;
+	if (o1->takes_raw_args != o2->takes_raw_args)
+		return o1->takes_raw_args - o2->takes_raw_args;
 	return 0;
 }
 

src/box/func_def.h

@@ -68,6 +68,10 @@ struct func_opts {
 	 * packed in array.
 	 */
 	bool is_multikey;
+	/**
+	 * True if the function expects a msgpack object for args.
+	 */
+	bool takes_raw_args;
 };
 
 extern const struct func_opts func_opts_default;

src/box/lua/call.c

@@ -341,9 +341,22 @@ struct execute_lua_ctx {
 	int lua_ref;
 	const char *name;
 	uint32_t name_len;
+	bool takes_raw_args;
 	struct port *args;
 };
 
+static inline void
+push_lua_args(lua_State *L, struct execute_lua_ctx *ctx)
+{
+	if (ctx->takes_raw_args) {
+		uint32_t size;
+		const char *data = port_get_msgpack(ctx->args, &size);
+		luamp_push(L, data, data + size);
+	} else {
+		port_dump_lua(ctx->args, L, true);
+	}
+}
+
 /**
  * Find a lua function by name and execute it. Used for body-less
  * UDFs, which may not yet be defined when a function definition
@@ -367,7 +380,7 @@ execute_lua_call(lua_State *L)
 
 	/* Push the rest of args (a tuple). */
 	int top = lua_gettop(L);
-	port_dump_lua(ctx->args, L, true);
+	push_lua_args(L, ctx);
 	int arg_count = lua_gettop(L) - top;
 
 	lua_call(L, arg_count + oc - 1, LUA_MULTRET);
@@ -389,7 +402,7 @@ execute_lua_call_by_ref(lua_State *L)
 
 	/* Push the rest of args (a tuple). */
 	int top = lua_gettop(L);
-	port_dump_lua(ctx->args, L, true);
+	push_lua_args(L, ctx);
 	int arg_count = lua_gettop(L) - top;
 
 	lua_call(L, arg_count, LUA_MULTRET);
@@ -413,7 +426,7 @@ execute_lua_eval(lua_State *L)
 
 	/* Unpack arguments */
 	int top = lua_gettop(L);
-	port_dump_lua(ctx->args, L, true);
+	push_lua_args(L, ctx);
 	int arg_count = lua_gettop(L) - top;
 
 	/* Call compiled code */
@@ -661,6 +674,7 @@ box_lua_call(const char *name, uint32_t name_len,
 	ctx.name = name;
 	ctx.name_len = name_len;
 	ctx.args = args;
+	ctx.takes_raw_args = false;
 	return box_process_lua(HANDLER_CALL, &ctx, ret);
 }
 
@@ -672,6 +686,7 @@ box_lua_eval(const char *expr, uint32_t expr_len,
 	ctx.name = expr;
 	ctx.name_len = expr_len;
 	ctx.args = args;
+	ctx.takes_raw_args = false;
 	return box_process_lua(HANDLER_EVAL, &ctx, ret);
 }
 
@@ -853,7 +868,12 @@ func_lua_call(struct func *func, struct port *args, struct port *ret)
 {
 	assert(func != NULL && func->def->language == FUNC_LANGUAGE_LUA);
 	assert(func->vtab == &func_lua_vtab);
-	return box_lua_call(func->def->name, func->def->name_len, args, ret);
+	struct execute_lua_ctx ctx;
+	ctx.name = func->def->name;
+	ctx.name_len = func->def->name_len;
+	ctx.args = args;
+	ctx.takes_raw_args = func->def->opts.takes_raw_args;
+	return box_process_lua(HANDLER_CALL, &ctx, ret);
 }
 
 static struct func_vtab func_lua_vtab = {
@@ -888,6 +908,7 @@ func_persistent_lua_call(struct func *base, struct port *args, struct port *ret)
 	struct execute_lua_ctx ctx;
 	ctx.lua_ref = func->lua_ref;
 	ctx.args = args;
+	ctx.takes_raw_args = base->def->opts.takes_raw_args;
 	return box_process_lua(HANDLER_CALL_BY_REF, &ctx, ret);
 
 }
@@ -1023,6 +1044,9 @@ lbox_func_new(struct lua_State *L, struct func *func)
 	lua_pushstring(L, "is_multikey");
 	lua_pushboolean(L, func->def->opts.is_multikey);
 	lua_settable(L, top);
+	lua_pushstring(L, "takes_raw_args");
+	lua_pushboolean(L, func->def->opts.takes_raw_args);
+	lua_settable(L, top);
 	lua_pushstring(L, "is_sandboxed");
 	if (func->def->body != NULL)
 		lua_pushboolean(L, func->def->is_sandboxed);

src/box/lua/schema.lua

@@ -2601,6 +2601,7 @@ box.schema.func.create = function(name, opts)
                               is_deterministic = 'boolean',
                               is_sandboxed = 'boolean',
                               is_multikey = 'boolean',
+                              takes_raw_args = 'boolean',
                               comment = 'string',
                               param_list = 'table', returns = 'string',
                               exports = 'table', opts = 'table' })
@@ -2625,6 +2626,9 @@ box.schema.func.create = function(name, opts)
     if opts.is_multikey then
         opts.opts.is_multikey = opts.is_multikey
     end
+    if opts.takes_raw_args then
+        opts.opts.takes_raw_args = opts.takes_raw_args
+    end
     _func:auto_increment{session.euid(), name, opts.setuid, opts.language,
                          opts.body, opts.routine_type, opts.param_list,
                          opts.returns, opts.aggregate, opts.sql_data_access,

test/box-luatest/func_test.lua

@@ -1,3 +1,4 @@
+local net = require('net.box')
 local server = require('test.luatest_helpers.server')
 local t = require('luatest')
 local g = t.group()
@@ -42,3 +43,73 @@ g.test_legacy_opts = function()
         return ret
     end))
 end
+
+g.before_test('test_msgpack_object_args', function()
+    local echo_code = "function(...) return ... end"
+    local check_code = "function(o) return require('msgpack').is_object(o) end"
+    local decode_code = "function(o) return o:decode() end"
+    g.server:eval("echo = " .. echo_code)
+    g.server:eval("echo_mp = " .. echo_code)
+    g.server:eval("check = " .. check_code)
+    g.server:eval("decode = " .. decode_code)
+    g.server:exec(function(check_code, decode_code)
+        box.schema.func.create('echo')
+        box.schema.func.create('echo_mp', {takes_raw_args = true})
+        box.schema.func.create('check', {takes_raw_args = true})
+        box.schema.func.create('decode', {takes_raw_args = true})
+        box.schema.func.create(
+            'check_persistent', {body = check_code, takes_raw_args = true})
+        box.schema.func.create(
+            'decode_persistent', {body = decode_code, takes_raw_args = true})
+    end, {check_code, decode_code})
+end)
+
+g.after_test('test_msgpack_object_args', function()
+    g.server:exec(function()
+        box.schema.func.drop('echo')
+        box.schema.func.drop('echo_mp')
+        box.schema.func.drop('check')
+        box.schema.func.drop('decode')
+        box.schema.func.drop('check_persistent')
+        box.schema.func.drop('decode_persistent')
+    end)
+    g.server:eval("echo = nil")
+    g.server:eval("echo_mp = nil")
+    g.server:eval("check = nil")
+    g.server:eval("decode = nil")
+end)
+
+g.test_msgpack_object_args = function()
+    local args = {'foo', 'bar', {foo = 'bar'}}
+
+    -- remote call
+    local c = net:connect(g.server.net_box_uri)
+    t.assert_equals({c:call('echo', args)}, args)
+    t.assert_equals(c:call('echo_mp', args), args)
+    t.assert(c:call('check', args))
+    t.assert_equals(c:call('decode', args), args)
+    t.assert(c:call('check_persistent', args))
+    t.assert_equals(c:call('decode_persistent', args), args)
+    c:close()
+
+    -- local call
+    local call = function(name, args)
+        return g.server:exec(function(name, args)
+            return box.func[name]:call(args)
+        end, {name, args})
+    end
+    t.assert_equals({call('echo', args)}, args)
+    t.assert_equals(call('echo_mp', args), args)
+    t.assert(call('check', args))
+    t.assert_equals(call('decode', args), args)
+    t.assert(call('check_persistent', args))
+    t.assert_equals(call('decode_persistent', args), args)
+
+    -- info
+    t.assert_not(g.server:eval('return box.func.echo.takes_raw_args'))
+    t.assert(g.server:eval('return box.func.echo_mp.takes_raw_args'))
+    t.assert(g.server:eval('return box.func.check.takes_raw_args'))
+    t.assert(g.server:eval('return box.func.decode.takes_raw_args'))
+    t.assert(g.server:eval('return box.func.check_persistent.takes_raw_args'))
+    t.assert(g.server:eval('return box.func.decode_persistent.takes_raw_args'))
+end

test/box/function1.result

@@ -98,6 +98,7 @@ box.func["function1.args"]
     lua: true
     sql: false
   id: 66
+  takes_raw_args: false
   setuid: false
   is_multikey: false
   is_deterministic: false
@@ -589,6 +590,7 @@ func
     lua: true
     sql: false
   id: 66
+  takes_raw_args: false
   setuid: false
   is_multikey: false
   is_deterministic: false
@@ -661,6 +663,7 @@ func
     lua: true
     sql: false
   id: 66
+  takes_raw_args: false
   setuid: false
   is_multikey: false
   is_deterministic: false