Chapter 38. Extending SQL: Functions

Table of Contents
Query Language (SQL) Functions
Procedural Language Functions
Internal Functions
Compiled (C) Language Functions
Function Overloading

As it turns out, part of defining a new type is the definition of functions that describe its behavior. Consequently, while it is possible to define a new function without defining a new type, the reverse is not true. We therefore describe how to add new functions to Postgres before describing how to add new types.

Postgres SQL provides three types of functions:

Every kind of function can take a base type, a composite type or some combination as arguments (parameters). In addition, every kind of function can return a base type or a composite type. It's easiest to define SQL functions, so we'll start with those. Examples in this section can also be found in funcs.sql and funcs.c.

Query Language (SQL) Functions

SQL functions execute an arbitrary list of SQL queries, returning the results of the last query in the list. SQL functions in general return sets. If their returntype is not specified as a setof, then an arbitrary element of the last query's result will be returned.

The body of a SQL function following AS should be a list of queries separated by whitespace characters and bracketed within quotation marks. Note that quotation marks used in the queries must be escaped, by preceding them with two backslashes.

Arguments to the SQL function may be referenced in the queries using a $n syntax: $1 refers to the first argument, $2 to the second, and so on. If an argument is complex, then a dot notation (e.g. "$1.emp") may be used to access attributes of the argument or to invoke functions.


To illustrate a simple SQL function, consider the following, which might be used to debit a bank account:

create function TP1 (int4, float8) returns int4
    as 'update BANK set balance = BANK.balance - $2
        where BANK.acctountno = $1
        select(x = 1)'
    language 'sql';
A user could execute this function to debit account 17 by $100.00 as follows:
select (x = TP1( 17,100.0));

The following more interesting example takes a single argument of type EMP, and retrieves multiple results:

select function hobbies (EMP) returns set of HOBBIES
    as 'select (HOBBIES.all) from HOBBIES
        where $ = HOBBIES.person'
    language 'sql';

SQL Functions on Base Types

The simplest possible SQL function has no arguments and simply returns a base type, such as int4:


SELECT one() AS answer;

     |answer |
     |1      |

Notice that we defined a target list for the function (with the name RESULT), but the target list of the query that invoked the function overrode the function's target list. Hence, the result is labelled answer instead of one.

It's almost as easy to define SQL functions that take base types as arguments. In the example below, notice how we refer to the arguments within the function as $1 and $2:

CREATE FUNCTION add_em(int4, int4) RETURNS int4
    AS 'SELECT $1 + $2;' LANGUAGE 'sql';

SELECT add_em(1, 2) AS answer;

     |answer |
     |3      |

SQL Functions on Composite Types

When specifying functions with arguments of composite types (such as EMP), we must not only specify which argument we want (as we did above with $1 and $2) but also the attributes of that argument. For example, take the function double_salary that computes what your salary would be if it were doubled:

    AS 'SELECT $1.salary * 2 AS salary;' LANGUAGE 'sql';

SELECT name, double_salary(EMP) AS dream
    WHERE EMP.cubicle ~= '(2,1)'::point;

     |name | dream |
     |Sam  | 2400  |

Notice the use of the syntax $1.salary. Before launching into the subject of functions that return composite types, we must first introduce the function notation for projecting attributes. The simple way to explain this is that we can usually use the notation attribute(class) and class.attribute interchangably:

-- this is the same as:
--  SELECT AS youngster FROM EMP WHERE EMP.age < 30
SELECT name(EMP) AS youngster
    WHERE age(EMP) < 30;

     |youngster |
     |Sam       |

As we shall see, however, this is not always the case. This function notation is important when we want to use a function that returns a single instance. We do this by assembling the entire instance within the function, attribute by attribute. This is an example of a function that returns a single EMP instance:

    AS 'SELECT \'None\'::text AS name,
        1000 AS salary,
        25 AS age,
        \'(2,2)\'::point AS cubicle'
    LANGUAGE 'sql';

In this case we have specified each of the attributes with a constant value, but any computation or expression could have been substituted for these constants. Defining a function like this can be tricky. Some of the more important caveats are as follows:

Any collection of commands in the SQL query language can be packaged together and defined as a function. The commands can include updates (i.e., INSERT, UPDATE, and DELETE) as well as SELECT queries. However, the final command must be a SELECT that returns whatever is specified as the function's returntype.

    AS 'DELETE FROM EMP WHERE EMP.salary <= 0;
SELECT 1 AS ignore_this'
    LANGUAGE 'sql';

SELECT clean_EMP();

     |x |
     |1 |