Internally, Postgres regards a
base type as a "blob of memory." The user-defined functions that
you define over a type in turn define the way that Postgres can operate on it. That is,
Postgres will only store and
retrieve the data from disk and use your user-defined functions to
input, process, and output the data. Base types can have one of
three internal formats:

pass by value, fixed-length

pass by reference, fixed-length

pass by reference, variable-length

By-value types can only be 1, 2 or 4 bytes in length (even if
your computer supports by-value types of other sizes). Postgres itself only passes integer types by
value. You should be careful to define your types such that they
will be the same size (in bytes) on all architectures. For example,
the long type is dangerous because it
is 4 bytes on some machines and 8 bytes on others, whereas
int type is 4 bytes on most
UNIX machines (though not on most
personal computers). A reasonable implementation of the
int4 type on UNIX machines might be:

/* 4-byte integer, passed by value */
typedef int int4;

On the other hand, fixed-length types of any size may be passed
by-reference. For example, here is a sample implementation of a
Postgres type:

Only pointers to such types can be used when passing them in and
out of Postgres functions.
Finally, all variable-length types must also be passed by
reference. All variable-length types must begin with a length field
of exactly 4 bytes, and all data to be stored within that type must
be located in the memory immediately following that length field.
The length field is the total length of the structure (i.e., it
includes the size of the length field itself). We can define the
text type as follows:

typedef struct {
int4 length;
char data[1];
} text;

Obviously, the data field is not long enough to hold all
possible strings -- it's impossible to declare such a structure in
C. When manipulating variable-length
types, we must be careful to allocate the correct amount of memory
and initialize the length field. For example, if we wanted to store
40 bytes in a text structure, we might use a code fragment like
this:

Composite types do not have a fixed layout like C structures.
Instances of a composite type may contain null fields. In addition,
composite types that are part of an inheritance hierarchy may have
different fields than other members of the same inheritance
hierarchy. Therefore, Postgres
provides a procedural interface for accessing fields of composite
types from C. As Postgres
processes a set of instances, each instance will be passed into
your function as an opaque structure of type TUPLE. Suppose we want to write a function to
answer the query

* SELECT name, c_overpaid(EMP, 1500) AS overpaid
FROM EMP
WHERE name = 'Bill' or name = 'Sam';

GetAttributeByName is the
Postgres system function that
returns attributes out of the current instance. It has three
arguments: the argument of type TUPLE passed into the function, the
name of the desired attribute, and a return parameter that
describes whether the attribute is null. GetAttributeByName will align data properly so you
can cast its return value to the desired type. For example, if you
have an attribute name which is of the type name, the GetAttributeByName call would look like:

We now turn to the more difficult task of writing programming
language functions. Be warned: this section of the manual will not
make you a programmer. You must have a good understanding of
C (including the use of pointers and
the malloc memory manager) before trying to write C functions for use with Postgres. While it may be possible to load
functions written in languages other than C into Postgres,
this is often difficult (when it is possible at all) because other
languages, such as FORTRAN and
Pascal often do not follow the same
"calling convention" as C. That is,
other languages do not pass argument and return values between
functions in the same way. For this reason, we will assume that
your programming language functions are written in C. The basic rules for building C functions are as follows:

Most of the header (include) files for Postgres should already be installed in
PGROOT/include (see Figure 2). You
should always include

-I$PGROOT/include

on your cc command lines. Sometimes, you may find that you
require header files that are in the server source itself (i.e.,
you need a file we neglected to install in include). In those cases
you may need to add one or more of

When allocating memory, use the Postgres routines palloc and pfree instead
of the corresponding C library
routines malloc and free. The memory allocated by palloc will
be freed automatically at the end of each transaction,
preventing memory leaks.

Always zero the bytes of your structures using memset or
bzero. Several routines (such as the hash access method, hash
join and the sort algorithm) compute functions of the raw bits
contained in your structure. Even if you initialize all fields
of your structure, there may be several bytes of alignment
padding (holes in the structure) that may contain garbage
values.

Most of the internal Postgres types are declared in postgres.h,
so it's a good idea to always include that file as well.
Including postgres.h will also include elog.h and palloc.h for
you.

Compiling and loading your object code so that it can be
dynamically loaded into Postgres always requires special flags.
See Appendix A for a detailed explanation of how to do it for
your particular operating system.

Submit correction

If you see anything in the documentation that is not correct, does not match
your experience with the particular feature or requires further clarification,
please use
this form
to report a documentation issue.