Zen

Source string Source string

169/10000 · 169
English Actions
ER_PROC_LUA
box.error.PROC_LUA
An error occurred inside a Lua procedure.
ER_FIBER_STACK
box.error.FIBER_STACK
The recursion limit was reached when creating a new fiber. This usually indicates that a stored procedure is recursively invoking itself too often.
ER_UPDATE_FIELD
box.error.UPDATE_FIELD
An error occurred during update of a field.
ER_TUPLE_FOUND
box.error.TUPLE_FOUND
A duplicate key exists in a unique index.
Handling errors
Here are some procedures that can make Lua functions more robust when there are errors, particularly database errors.
Invoke a function using ``pcall``.
Take advantage of Lua's mechanisms for `Error handling and exceptions <https://www.lua.org/pil/8.4.html>`_, particularly ``pcall``. That is, instead of invoking with ...
box.space.{space-name}:{function-name}()
... call the function as follows:
if pcall(box.space.{space-name}.{function-name}, box.space.{space-name}) ...
For some Tarantool box functions, ``pcall`` also returns error details, including a file-name and line-number within Tarantool's source code. This can be seen by unpacking, for example:
status, error = pcall(function() box.schema.space.create('') end)
error:unpack()
See the tutorial :ref:`Sum a JSON field for all tuples <c_lua_tutorial-sum_a_json_field>` to see how ``pcall`` can fit in an application.
Examine errors and raise new errors using ``box.error``.
To make a new error and pass it on, the ``box.error`` module provides :doc:`box.error() </reference/reference_lua/box_error/error>`.
To find the last error, the ``box.error`` submodule provides :doc:`/reference/reference_lua/box_error/last`. There is also a way to find the text of the last operating-system error for certain functions -- :ref:`errno.strerror([code]) <errno-strerror>`.
Log.
Put messages in a log using the :ref:`log module <log-module>`.
Filter automatically generated messages using the :ref:`log <cfg_logging-log>` configuration parameter.
Generally, for Tarantool built-in functions which are designed to return objects: the result is an object, or nil, or `a Lua error <https://www.lua.org/pil/8.3.html>`_. For example consider the :ref:`fio_read.lua <cookbook-fio_read>` program in a cookbook:
#!/usr/bin/env tarantool

local fio = require('fio')
local errno = require('errno')
local f = fio.open('/tmp/xxxx.txt', {'O_RDONLY' })
if not f then
error("Failed to open file: "..errno.strerror())
end
local data = f:read(4096)
f:close()
print(data)
After a function call that might fail, like ``fio.open()`` above, it is common to see syntax like ``if not f then ...`` or ``if f == nil then ...``, which check for common failures. But if there had been a syntax error, for example fio.opex instead of fio.open, then there would have been a Lua error and f would not have been changed. If checking for such an obvious error had been a concern, the programmer would probably have used ``pcall()``.

Loading…

User avatar None

New source string

testing_project / Documentation: reference/reference_lua/errcodes — English

Take advantage of Lua's mechanisms for `Error handling and exceptions <https://www.lua.org/pil/8.4.html>`_, particularly ``pcall``. That is, instead of invoking with ...
a year ago
Browse all string changes

Things to check

Ellipsis

The string uses three dots (...) instead of an ellipsis character (…)

Reset

Glossary

English English
No related strings found in the glossary.

String information

Flags
read-only
String age
a year ago
Last updated
a year ago
Source string age
a year ago
Translation file
string 46