The procedure for adding a new native function is described here. Note that you cannot add native functions to a binary distribution because the procedure involves modifying MySQL source code. You must compile MySQL yourself from a source distribution. Also note that if you migrate to another version of MySQL (for example, when a new version is released), you need to repeat the procedure with the new version.
To add a new native MySQL function, follow these steps:
Add one line to
lex.h that defines the
function name in the
If the function prototype is simple (just takes zero, one,
two or three arguments), you should in
N is the number of
arguments) as the second argument in the
sql_functions array and add a function
that creates a function object in
item_create.cc. Take a look at
create_funcs_abs() for an example of
If the function prototype is complicated (for example, if it
takes a variable number of arguments), you should add two
sql_yacc.yy. One indicates the
preprocessor symbol that yacc should
define (this should be added at the beginning of the file).
Then define the function parameters and add an
「item」 with these parameters to the
simple_expr parsing rule. For an example,
check all occurrences of
sql_yacc.yy to see how this is done.
item_func.h, declare a class
Item_str_func, depending on whether your
function returns a number or a string.
item_func.cc, add one of the
following declarations, depending on whether you are
defining a numeric or string function:
double Item_func_newname::val() longlong Item_func_newname::val_int() String *Item_func_newname::Str(String *str)
If you inherit your object from any of the standard items
Item_num_func), you probably only
have to define one of these functions and let the parent
object take care of the other functions. For example, the
Item_str_func class defines a
val() function that executes
atof() on the value returned by
You should probably also define the following object function:
This function should at least calculate
max_length based on the given arguments.
max_length is the maximum number of
characters the function may return. This function should
maybe_null = 0 if the main
function can't return a
NULL value. The
function can check whether any of the function arguments can
NULL by checking the arguments'
maybe_null variable. You can take a look
a typical example of how to do this.
All functions must be thread-safe. In other words, don't use any global or static variables in the functions without protecting them with mutexes)
If you want to return
::str() you should set
null_value to 1 and return 0.
::str() object functions, there are some
additional considerations to be aware of:
String *str argument provides a
string buffer that may be used to hold the result. (For more
information about the
String type, take a
look at the
::str() function should return the
string that holds the result or
if the result is
All current string functions try to avoid allocating any memory unless absolutely necessary!