More than one function may be defined with the same SQL name, so long
as the arguments they take are different. In other words,
function names can be overloaded. When a
query is executed, the server will determine which function to
call from the data types and the number of the provided arguments.
Overloading can also be used to simulate functions with a variable
number of arguments, up to a finite maximum number.
A function may also have the same name as an attribute. In the case
that there is an ambiguity between a function on a complex type and
an attribute of the complex type, the attribute will always be used.
When creating a family of overloaded functions, one should be
careful not to create ambiguities. For instance, given the
functions
CREATE FUNCTION test(int, real) RETURNS ...
CREATE FUNCTION test(smallint, double precision) RETURNS ...
it is not immediately clear which function would be called with
some trivial input like test(1, 1.5). The
currently implemented resolution rules are described in the
User's Guide, but it is unwise to design a
system that subtly relies on this behavior.
When overloading C language functions, there is an additional
constraint: The C name of each function in the family of
overloaded functions must be different from the C names of all
other functions, either internal or dynamically loaded. If this
rule is violated, the behavior is not portable. You might get a
run-time linker error, or one of the functions will get called
(usually the internal one). The alternative form of the
AS clause for the SQL CREATE
FUNCTION command decouples the SQL function name from
the function name in the C source code. E.g.,
CREATE FUNCTION test(int) RETURNS int
AS 'filename', 'test_1arg'
LANGUAGE C;
CREATE FUNCTION test(int, int) RETURNS int
AS 'filename', 'test_2arg'
LANGUAGE C;
The names of the C functions here reflect one of many possible conventions.
Prior to PostgreSQL 7.0, this
alternative syntax did not exist. There is a trick to get around
the problem, by defining a set of C functions with different names
and then define a set of identically-named SQL function wrappers
that take the appropriate argument types and call the matching C
function.
