在内部，Postgres 把基本类型视为一个“内存块”。你针对某个类型定义的用户自定义函数转而定义了 Postgres 能对它进行操作的方式。也就是说，Postgres 只负责在磁盘上存储和检索数据，而使用你的用户自定义函数来输入、处理和输出数据。 基本类型可以有以下三种内部格式之一：

传值类型的长度只能是 1、2 或 4 字节（即使你的计算机支持其他大小的传值类型）。Postgres 本身只按传值方式传递整数类型。你应当小心地定义类型，使其在所有体系结构上具有相同的大小（以字节计）。例如，long 类型是危险的，因为它在某些机器上是 4 字节而在另一些机器上是 8 字节；而 int 类型在大多数 UNIX 机器上是 4 字节（但在大多数个人电脑上不是）。UNIX 机器上 int4 类型的一个合理实现可以是：

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

另一方面，任何大小的定长类型都可以按传引用方式传递。例如，下面是一个 Postgres 类型的实现示例：

         /* 16-byte structure, passed by reference */
    typedef struct
    {
        double  x, y;
    } Point;

在 Postgres 函数中传入和传出这类类型时只能使用指向它们的指针。 最后，所有变长类型也必须以传引用方式传递。所有变长类型都必须以一个恰好 4 字节的长度字段开始，而该类型中要存储的所有数据都位于紧随该长度字段之后的内存中。长度字段是结构的总长度（即它包含长度字段本身的大小）。我们可以这样定义 text 类型：

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

显然，这里所示的 data 字段不足以容纳所有可能的字符串——在 C 中无法声明这样的结构。操作变长类型时，我们必须小心分配正确数量的内存并初始化长度字段。例如，如果我们想在 text 结构中存储 40 字节，可以使用如下代码片段：

         #include "postgres.h"
         ...
         char buffer[40]; /* our source data */
         ...
         text *destination = (text *) palloc(VARHDRSZ + 40);
         destination->length = VARHDRSZ + 40;
         memmove(destination->data, buffer, 40);
         ...

既然我们已经讲完了基本类型的所有可能结构，我们可以展示一些真实函数的示例。设 funcs.c 内容如下：

         #include <string.h>
         #include "postgres.h"

         /* By Value */
         
         int
         add_one(int arg)
         {
             return(arg + 1);
         }
         
         /* By Reference, Fixed Length */
         
         Point *
         makepoint(Point *pointx, Point *pointy )
         {
             Point     *new_point = (Point *) palloc(sizeof(Point));
        
             new_point->x = pointx->x;
             new_point->y = pointy->y;
                
             return new_point;
         }
        
         /* By Reference, Variable Length */
         
         text *
         copytext(text *t)
         {
             /*
              * VARSIZE is the total size of the struct in bytes.
              */
             text *new_t = (text *) palloc(VARSIZE(t));
             memset(new_t, 0, VARSIZE(t));
             VARSIZE(new_t) = VARSIZE(t);
             /*
              * VARDATA is a pointer to the data region of the struct.
              */
             memcpy((void *) VARDATA(new_t), /* destination */
                    (void *) VARDATA(t),     /* source */
                    VARSIZE(t)-VARHDRSZ);        /* how many bytes */
             return(new_t);
         }
         
         text *
         concat_text(text *arg1, text *arg2)
         {
             int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
             text *new_text = (text *) palloc(new_text_size);

             memset((void *) new_text, 0, new_text_size);
             VARSIZE(new_text) = new_text_size;
             strncpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ);
             strncat(VARDATA(new_text), VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ);
             return (new_text);
         }

在 OSF/1 上我们会输入：

         CREATE FUNCTION add_one(int4) RETURNS int4
              AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c';

         CREATE FUNCTION makepoint(point, point) RETURNS point
              AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c';
    
         CREATE FUNCTION concat_text(text, text) RETURNS text
              AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c';
                                  
         CREATE FUNCTION copytext(text) RETURNS text
              AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c';

在其他系统上，我们可能必须让文件名以 .sl 结尾（表示它是共享库）。

复合类型没有像 C 结构那样的固定布局。复合类型的实例可能包含空字段。此外，属于某个继承层次的复合类型可能具有与同一继承层次其他成员不同的字段。因此，Postgres 提供了一个从 C 访问复合类型字段的过程式接口。当 Postgres 处理一组实例时，每个实例都会作为一个 TUPLE 类型的不透明结构传入你的函数。 假设我们想编写一个函数来回答查询

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

在上面的查询中，我们可以把 c_overpaid 定义为：

         #include "postgres.h"
         #include "executor/executor.h"  /* for GetAttributeByName() */
         
         bool
         c_overpaid(TupleTableSlot *t, /* the current instance of EMP */
                    int4 limit)
         {
             bool isnull = false;
             int4 salary;
             salary = (int4) GetAttributeByName(t, "salary", &isnull);
             if (isnull)
                 return (false);
             return(salary > limit);
         }

GetAttributeByName 是 Postgres 的系统函数，返回当前实例中的属性。它有三个参数：传给函数的 TUPLE 类型参数、所需属性的名称，以及一个描述该属性是否为空的返回参数。GetAttributeByName 会正确地对齐数据，因此你可以把它的返回值转换为期望的类型。例如，如果你有一个 name 类型的属性 name，GetAttributeByName 调用将形如：

         char *str;
         ...
         str = (char *) GetAttributeByName(t, "name", &isnull)

下面的查询让 Postgres 知道 c_overpaid 函数：

         * CREATE FUNCTION c_overpaid(EMP, int4) RETURNS bool
              AS 'PGROOT/tutorial/obj/funcs.so' LANGUAGE 'c';

虽然有办法在 C 函数内构造新实例或修改现有实例，但这些 方法过于复杂，本手册不予讨论。

现在我们转向编写编程语言函数这一更困难的任务。请注意：本手册的这一部分不会使你成为程序员。在尝试为 Postgres 编写 C 函数之前，你必须对 C（包括指针和 malloc 内存管理器的使用）有良好的理解。虽然也许可以把用 C 以外语言编写的函数装载到 Postgres，但这通常很困难（即使在可能的时候），因为其他语言（如 FORTRAN 和 Pascal）往往不遵循与 C 相同的“调用约定”。也就是说，其他语言在函数之间传递参数和返回值的方式不同。因此，我们将假定你的编程语言函数是用 C 编写的。 构建 C 函数的基本规则如下：