It was unimplemented and will never be. The development continues as a
part of picodata product.

Georgy Moshkin authored 2 years ago and Georgy Moshkin committed 2 years ago

The clarification is about safety of using borrowed arguments in stored
procedures: borrowed arguments aren't if used after calls to tarantool
api.

This will allow reusing this function in other places. It's also pub
so that it can be reused, but is hidden, because we leave a right to
change it.

Since some time around tarantool 2.10 most of the symbols have been
closed, but some of our apis were still relying on them. This commit
fixes these issues.

Don't link against symbols known to be missing in tarantool 2.10. These
are:
- decimal_*
- fiber_channel_*
- ipc_value_*
- tuple_field_raw_by_full_path

Instead use `dlsym` to lookup these symbols at runtime.
The lookup is only done once per symbol.

Also don't use `BoxTuple::data` unless `tuple_field_raw_by_full_path` is
present, otherwise the structure of `BoxTuple` cannot be assumed.

TODO: maybe don't ever use `BoxTuple::data`

remove `#[macro_use]` and `extern crate` directives

add `use <crate>::<macro>` directives

Lua now has a type parameter OnDrop, which determines what happens when
this instance is dropped. There are now 3 variants of Lua:
- type TempLua = Lua<on_drop::Close>;    lua_close will be called in drop
- type StaticLua = Lua<on_drop::Ignore>; nothing happens in drop
- type LuaThread = Lua<on_drop::Unref>;  luaL_unref is called in drop

LuaThread can only be created from a StaticLua, so we don't to think
about what happens when the parent state is closed

tarantool::lua_thread should be used instead of working directly with
tarantool::global_lua whenever possible, to avoid poluting the global
lua stack and introducing race conditions when working from different
fibers

rename hlua to tlua to avoid conflicts when publishing the crate to
crates.io.
flatten the repository structure a bit

It uses the underlying tarantool fiber_channel api: a bounded ring
buffer based channel on top of the fiber cooperative multitasking
runtime.

When the join handle get's dropped there's no way to join the fiber
anymore. But if it is left joinable at this point, the tarantool
internals won't be able to recycle it's memory. So we need to make sure
the join handle is joined explicitly at some point in the code.

- defer functionality is now hidden behind the "defer" feature
- added comments explaining which methods do how many yields

There are now 2 types of fibers
* Immediate - a fiber that starts executing immediately
* Deferred  - a fiber that is scheduled for execution
Both of them come in 2 variants, consider the case of Immediate:
* Immediate<F, T>  - has a fiber function that returns a T
* UnitImmediate<F> - has a fiber function that returns nothing. This is
                     an optimized version of Immediate<F, ()>.
Same with Deferred and UnitDeferred.

All of these fibers are joinable. Non-joinable fibers are not supported
yet.