38.6. Function Overloading

38.6. Function Overloading
Prev	Up	Chapter 38. Extending SQL	Home	Next

38.6. Function Overloading #

+ More than one function can be defined with the same SQL name, so long + as the arguments they take are different. In other words, + function names can be overloaded. Whether or not + you use it, this capability entails security precautions when calling + functions in databases where some users mistrust other users; see + Section 10.3. 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. +

+ 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 + Chapter 10, but it is unwise to design a system that subtly + relies on this behavior. +

+ A function that takes a single argument of a composite type should + generally not have the same name as any attribute (field) of that type. + Recall that attribute(table) + is considered equivalent + to table.attribute. + In the case that there is an + ambiguity between a function on a composite type and an attribute of + the composite type, the attribute will always be used. It is possible + to override that choice by schema-qualifying the function name + (that is, schema.func(table) +) but it's better to + avoid the problem by not choosing conflicting names. +

+ Another possible conflict is between variadic and non-variadic functions. + For instance, it is possible to create both foo(numeric) and + foo(VARIADIC numeric[]). In this case it is unclear which one + should be matched to a call providing a single numeric argument, such as + foo(10.1). The rule is that the function appearing + earlier in the search path is used, or if the two functions are in the + same schema, the non-variadic one is preferred. +

+ 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. For instance: +

+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. +

Prev	Up	Next
38.5. Query Language (SQL) Functions	Home	38.7. Function Volatility Categories