Extending SQL: Functions

PostgreSQL
Prev |  | Next

# Chapter 38. Extending SQL: Functions

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:

- query language functions (functions written in SQL)

- procedural language functions (functions written in, for example, PLTCL or PLSQL)

- programming language functions (functions written in a compiled programming language such as C)

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.

## Examples

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 $1.name = 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`:

    CREATE FUNCTION one() RETURNS int4
        AS 'SELECT 1 as RESULT' LANGUAGE 'sql';

    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:

    CREATE FUNCTION double_salary(EMP) RETURNS int4
        AS 'SELECT $1.salary * 2 AS salary;' LANGUAGE 'sql';

    SELECT name, double_salary(EMP) AS dream
        FROM EMP
        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 EMP.name AS youngster FROM EMP WHERE EMP.age < 30
    --
    SELECT name(EMP) AS youngster
        FROM EMP
        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:

    CREATE FUNCTION new_emp() RETURNS EMP
        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:

- The target list order must be exactly the same as that in which the attributes appear in the CREATE TABLE statement (or when you execute a .* query).

- You must typecast the expressions (using ::) very carefully or you will see the following error:

      	 WARN::function declared to return type EMP does not retrieve (EMP.*)

- When calling a function that returns an instance, we cannot retrieve the entire instance. We must either project an attribute out of the instance or pass the entire instance into another function.

      SELECT name(new_emp()) AS nobody;

              +-------+
              |nobody |
              +-------+
              |None   |
              +-------+

- The reason why, in general, we must use the function syntax for projecting attributes of function return values is that the parser just doesn't understand the other (dot) syntax for projection when combined with function calls.

      SELECT new_emp().name AS nobody;
      WARN:parser: syntax error at or near "."

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.

    CREATE FUNCTION clean_EMP () RETURNS int4
        AS 'DELETE FROM EMP WHERE EMP.salary <= 0;
    SELECT 1 AS ignore_this'
        LANGUAGE 'sql';

    SELECT clean_EMP();

         +--+
         |x |
         +--+
         |1 |
         +--+

Prev | Home | Next
About the Postgres System Catalogs | Up | Procedural Language Functions