PostgreSQL: How to create a pairing function?

Question

How do I create a user defined function in PostgreSQL that acts like the C function pair defined below?

Also, which type of function should I use and why?

(A) query language (SQL) function
(B) procedural language function
(C) internal function
(D) C-language function
(E) None of the above

Bonus points for implementations in both SQL & PL/pgSQL languages.

#include <stdio.h>
#include <math.h>

int pair(int x, int y)
{
    int z;
    if (x < y) {
        z = x * (y-1);
        y = y - x - 2;
    } else {
        z = (x-1) * y;
        y = x - y - 2;
    }
    return z + pow(y, 2) / 4;
}

// TESTING

void test(int x, int y, int z)
{
    printf("%s", pair(x, y) == z ? "." : "F");
}

int main(void)
{
    test(1, 2, 1);
    test(1, 3, 2);
    test(1, 4, 3);
    test(1, 5, 5);
    test(1, 6, 7);
    test(1, 7, 10);
    test(1, 8, 13);
    test(1, 9, 17);

    test(2, 3, 4);
    test(2, 4, 6);
    test(2, 5, 8);
    test(2, 6, 11);
    test(2, 7, 14);
    test(2, 8, 18);
    test(2, 9, 22);

    printf("\n");

    return 0;
}

Answer 1

Use an SQL CASE statement:

CASE WHEN x < y THEN
   x * (y - 1) + ((y - x - 2)^2)::int / 4
ELSE
   (x - 1) * y + ((x - y - 2)^2)::int / 4
END

The operator ^ as well as the function power() return double precision. So I cast to int to match your question.

Wrapped into a plain SQL function (with operator ^):

CREATE OR REPLACE FUNCTION pair1(x int, y int)
  RETURNS int AS
$func$
SELECT CASE WHEN x < y THEN
          x * (y - 1) + ((y - x - 2)^2)::int / 4
       ELSE
          (x - 1) * y + ((x - y - 2)^2)::int / 4
       END
$func$  LANGUAGE sql IMMUTABLE;

In Postgres 9.1 or older you have tro reference input columns with positional parameters $1, $2 instead.

The same as PL/pgSQL function (with function power()):

CREATE OR REPLACE FUNCTION pair2(x int, y int)
  RETURNS int AS
$func$
BEGIN
RETURN CASE WHEN x < y THEN
          x * (y - 1) + power(y - x - 2, 2)::int / 4
       ELSE
          (x - 1) * y + power(x - y - 2, 2)::int / 4
       END;
END
$func$  LANGUAGE plpgsql IMMUTABLE;

SQL Fiddle demo.

I depends, but generally I would use a simple SQL function. And don't forget to declare it IMMUTABLE. This allows various performance optimizations in bigger queries and using it in functional indexes. Example with more details:
Does PostgreSQL support "accent insensitive" collations?

Answer 2

SQL is simpler. If x < y it will return the first element of the array else the second

create or replace function pair(x int, y int)
returns double precision as $$
select (array[
    x * (y - 1) + power(y - x - 2, 2) / 4,
    (x - 1) * y + power(x - y - 2, 2) / 4
    ])[(not x < y)::int + 1]
;
$$ language sql;

select
    pair(1, 2) = 1,
    pair(1, 3) = 2,
    pair(1, 4) = 3,
    pair(1, 5) = 5,
    pair(1, 6) = 7,
    pair(1, 7) = 10,
    pair(1, 8) = 13,
    pair(1, 9) = 17,
    pair(2, 3) = 4,
    pair(2, 4) = 6,
    pair(2, 5) = 8,
    pair(2, 6) = 11,
    pair(2, 7) = 14,
    pair(2, 8) = 18,
    pair(2, 9) = 22
;

A boolean casted to integer yields 1 or 0. As Postgresql array index starts at 1 then 1 is added to the result of the casting.