xfunc.sgml 85.8 KB
Newer Older
1
<!--
2
$PostgreSQL: pgsql/doc/src/sgml/xfunc.sgml,v 1.89 2004/11/15 06:32:14 neilc Exp $
3 4
-->

5 6
 <sect1 id="xfunc">
  <title>User-Defined Functions</title>
7

Peter Eisentraut's avatar
Peter Eisentraut committed
8 9 10 11
  <indexterm zone="xfunc">
   <primary>function</primary>
   <secondary>user-defined</secondary>
  </indexterm>
12

13
  <para>
Peter Eisentraut's avatar
Peter Eisentraut committed
14 15
   <productname>PostgreSQL</productname> provides four kinds of
   functions:
16 17 18 19

   <itemizedlist>
    <listitem>
     <para>
20 21
      query language functions (functions written in
      <acronym>SQL</acronym>) (<xref linkend="xfunc-sql">)
22 23 24 25
     </para>
    </listitem>
    <listitem>
     <para>
26 27 28
      procedural language functions (functions written in, for
      example, <application>PL/Tcl</> or <application>PL/pgSQL</>)
      (<xref linkend="xfunc-pl">)
Peter Eisentraut's avatar
Peter Eisentraut committed
29 30 31 32
     </para>
    </listitem>
    <listitem>
     <para>
33
      internal functions (<xref linkend="xfunc-internal">)
34 35 36 37
     </para>
    </listitem>
    <listitem>
     <para>
38
      C-language functions (<xref linkend="xfunc-c">)
39 40 41
     </para>
    </listitem>
   </itemizedlist>
Peter Eisentraut's avatar
Peter Eisentraut committed
42
  </para>
43

Peter Eisentraut's avatar
Peter Eisentraut committed
44
  <para>
45
   Every kind
46
   of  function  can take base types, composite types, or
47
   combinations of these as arguments (parameters).   In  addition, 
48
   every kind of function can return a base type or
49 50 51
   a composite type.
  </para>

52 53 54 55 56 57
  <para>
   Many kinds of functions can take or return certain pseudo-types
   (such as polymorphic types), but the available facilities vary.
   Consult the description of each kind of function for more details.
  </para>

58
  <para>
59
   It's easiest to define <acronym>SQL</acronym>
60
   functions, so we'll start by discussing those.
61 62
   Most of the concepts presented for <acronym>SQL</acronym> functions
   will carry over to the other types of functions.
63
  </para>
Peter Eisentraut's avatar
Peter Eisentraut committed
64 65 66

  <para>
   Throughout this chapter, it can be useful to look at the reference
67 68 69 70 71 72
   page of the <xref linkend="sql-createfunction"> command to
   understand the examples better.  Some examples from this chapter
   can be found in <filename>funcs.sql</filename> and
   <filename>funcs.c</filename> in the <filename>src/tutorial</>
   directory in the <productname>PostgreSQL</productname> source
   distribution.
Peter Eisentraut's avatar
Peter Eisentraut committed
73
  </para>
Peter Eisentraut's avatar
Peter Eisentraut committed
74
  </sect1>
75

76
  <sect1 id="xfunc-sql">
77 78
   <title>Query Language (<acronym>SQL</acronym>) Functions</title>

Peter Eisentraut's avatar
Peter Eisentraut committed
79 80 81 82 83
   <indexterm zone="xfunc-sql">
    <primary>function</primary>
    <secondary>user-defined</secondary>
    <tertiary>in SQL</tertiary>
   </indexterm>
84

85
   <para>
Peter Eisentraut's avatar
Peter Eisentraut committed
86
    SQL functions execute an arbitrary list of SQL statements, returning
87
    the result of the last query in the list.
Tom Lane's avatar
Tom Lane committed
88
    In the simple (non-set)
89
    case, the first row of the last query's result will be returned.
90
    (Bear in mind that <quote>the first row</quote> of a multirow
Tom Lane's avatar
Tom Lane committed
91 92
    result is not well-defined unless you use <literal>ORDER BY</>.)
    If the last query happens
93
    to return no rows at all, the null value will be returned.
94 95 96
   </para>

   <para>
Peter Eisentraut's avatar
Peter Eisentraut committed
97 98 99 100 101 102
    <indexterm><primary>SETOF</><seealso>function</></> Alternatively,
    an SQL function may be declared to return a set, by specifying the
    function's return type as <literal>SETOF
    <replaceable>sometype</></literal>.<indexterm><primary>SETOF</></>
    In this case all rows of the last query's result are returned.
    Further details appear below.
103 104 105
   </para>

   <para>
106 107 108 109
    The body of an SQL function must be a list of SQL
    statements separated by semicolons.  A semicolon after the last
    statement is optional.  Unless the function is declared to return
    <type>void</>, the last statement must be a <command>SELECT</>.
110 111 112
   </para>

   <para>
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    The syntax of the <command>CREATE FUNCTION</command> command requires
    the function body to be written as a string constant.  It is usually
    most convenient to use dollar quoting (see <xref
    linkend="sql-syntax-dollar-quoting">) for the string constant.
    If you choose to use regular single-quoted string constant syntax,
    you must escape single quote marks (<literal>'</>) and backslashes
    (<literal>\</>) used in the body of the function, typically by
    doubling them (see <xref linkend="sql-syntax-strings">).
   </para>

   <para>
    Arguments to the SQL function are referenced in the function
    body using the syntax <literal>$<replaceable>n</></>: <literal>$1</>
    refers to the first argument, <literal>$2</> to the second, and so on.
    If an argument is of a composite type, then the dot notation,
128
    e.g., <literal>$1.name</literal>, may be used to access attributes
129
    of the argument.
130 131 132
   </para>

   <sect2>
133 134 135 136 137 138 139
    <title><acronym>SQL</acronym> Functions on Base Types</title>

    <para>
     The simplest possible <acronym>SQL</acronym> function has no arguments and
     simply returns a base type, such as <type>integer</type>:
     
<screen>
140 141 142 143 144
CREATE FUNCTION one() RETURNS integer AS $$
    SELECT 1 AS result;
$$ LANGUAGE SQL;

-- Alternative syntax:
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
CREATE FUNCTION one() RETURNS integer AS '
    SELECT 1 AS result;
' LANGUAGE SQL;

SELECT one();

 one
-----
   1
</screen>
    </para>

    <para>
     Notice that we defined a column alias within the function body for the result of the function
     (with  the  name <literal>result</>),  but this column alias is not visible
     outside the function.  Hence,  the  result  is labeled <literal>one</>
     instead of <literal>result</>.
    </para>

    <para>
     It is almost as easy to define <acronym>SQL</acronym> functions  
     that take base types as arguments.  In the example below, notice
     how we refer to the arguments within the function as <literal>$1</>
     and <literal>$2</>.

<screen>
171
CREATE FUNCTION add_em(integer, integer) RETURNS integer AS $$
172
    SELECT $1 + $2;
173
$$ LANGUAGE SQL;
174 175 176 177 178 179 180 181

SELECT add_em(1, 2) AS answer;

 answer
--------
      3
</screen>
    </para>
182 183

    <para>
184 185
     Here is a more useful function, which might be used to debit a
     bank account:
186

Peter Eisentraut's avatar
Peter Eisentraut committed
187
<programlisting>
188
CREATE FUNCTION tf1 (integer, numeric) RETURNS integer AS $$
Peter Eisentraut's avatar
Peter Eisentraut committed
189
    UPDATE bank 
190 191 192
        SET balance = balance - $2
        WHERE accountno = $1;
    SELECT 1;
193
$$ LANGUAGE SQL;
Peter Eisentraut's avatar
Peter Eisentraut committed
194
</programlisting>
195 196 197 198

     A user could execute this function to debit account 17 by $100.00 as
     follows:

Peter Eisentraut's avatar
Peter Eisentraut committed
199
<programlisting>
200
SELECT tf1(17, 100.0);
Peter Eisentraut's avatar
Peter Eisentraut committed
201
</programlisting>
202 203 204
    </para>

    <para>
205
     In practice one would probably like a more useful result from the
206
     function than a constant 1, so a more likely definition
207
     is
Peter Eisentraut's avatar
Peter Eisentraut committed
208 209

<programlisting>
210
CREATE FUNCTION tf1 (integer, numeric) RETURNS numeric AS $$
211 212 213 214
    UPDATE bank 
        SET balance = balance - $2
        WHERE accountno = $1;
    SELECT balance FROM bank WHERE accountno = $1;
215
$$ LANGUAGE SQL;
Peter Eisentraut's avatar
Peter Eisentraut committed
216
</programlisting>
217 218 219 220 221 222 223

     which adjusts the balance and returns the new balance.
    </para>

    <para>
     Any collection of commands in the  <acronym>SQL</acronym>
     language can be packaged together and defined as a function.
224 225
     Besides <command>SELECT</command> queries,
     the commands can include data modification (i.e.,
226
     <command>INSERT</command>, <command>UPDATE</command>, and
227
     <command>DELETE</command>).  However, the final command 
228
     must be a <command>SELECT</command> that returns whatever is
229 230 231
     specified as the function's return type.  Alternatively, if you
     want to define a SQL function that performs actions but has no
     useful value to return, you can define it as returning <type>void</>.
232
     In that case, the function body must not end with a <command>SELECT</command>.
233
     For example:
234

235
<screen>
236
CREATE FUNCTION clean_emp() RETURNS void AS $$
237 238
    DELETE FROM emp
        WHERE salary &lt;= 0;
239
$$ LANGUAGE SQL;
240

241
SELECT clean_emp();
242

243 244 245 246
 clean_emp
-----------

(1 row)
Peter Eisentraut's avatar
Peter Eisentraut committed
247
</screen>
248 249
    </para>
   </sect2>
250

251 252
   <sect2>
    <title><acronym>SQL</acronym> Functions on Composite Types</title>
253

254
    <para>
255
     When writing  functions with arguments of composite
256
     types, we must  not  only  specify  which
Peter Eisentraut's avatar
Peter Eisentraut committed
257
     argument  we  want (as we did above with <literal>$1</> and <literal>$2</literal>) but
258 259
     also the desired attribute (field) of  that  argument.   For  example,
     suppose that 
260
     <type>emp</type> is a table containing employee data, and therefore
261
     also the name of the composite type of each row of the table.  Here
262
     is a function <function>double_salary</function> that computes what someone's
263 264
     salary would be if it were doubled:

265 266 267
<screen>
CREATE TABLE emp (
    name        text,
268
    salary      numeric,
269 270 271 272
    age         integer,
    cubicle     point
);

273
CREATE FUNCTION double_salary(emp) RETURNS numeric AS $$
Peter Eisentraut's avatar
Peter Eisentraut committed
274
    SELECT $1.salary * 2 AS salary;
275
$$ LANGUAGE SQL;
276

277
SELECT name, double_salary(emp.*) AS dream
278 279
    FROM emp
    WHERE emp.cubicle ~= point '(2,1)';
280

Peter Eisentraut's avatar
Peter Eisentraut committed
281 282 283 284
 name | dream
------+-------
 Sam  |  2400
</screen>
285
    </para>
Peter Eisentraut's avatar
Peter Eisentraut committed
286

287
    <para>
288 289
     Notice the use of the syntax <literal>$1.salary</literal>
     to select one field of the argument row value.  Also notice
290 291 292 293 294
     how the calling <command>SELECT</> command uses <literal>*</>
     to select
     the entire current row of a table as a composite value.  The table
     row can alternatively be referenced using just the table name,
     like this:
295
<screen>
296
SELECT name, double_salary(emp) AS dream
297 298 299
    FROM emp
    WHERE emp.cubicle ~= point '(2,1)';
</screen>
300 301 302 303 304 305 306 307 308 309 310
     but this usage is deprecated since it's easy to get confused.
    </para>

    <para>
     Sometimes it is handy to construct a composite argument value
     on-the-fly.  This can be done with the <literal>ROW</> construct.
     For example, we could adjust the data being passed to the function:
<screen>
SELECT name, double_salary(row(name, salary*1.1, age, cubicle)) AS dream
    FROM emp;
</screen>
311
    </para>
Peter Eisentraut's avatar
Peter Eisentraut committed
312

313
    <para>
314 315
     It is also possible to build a function that returns a composite type.
     This is an example of a function 
316
     that returns a single <type>emp</type> row:
317

Peter Eisentraut's avatar
Peter Eisentraut committed
318
<programlisting>
319 320
CREATE FUNCTION new_emp() RETURNS emp AS $$
    SELECT text 'None' AS name,
321 322
        1000 AS salary,
        25 AS age,
323 324
        point '(2,2)' AS cubicle;
$$ LANGUAGE SQL;
Peter Eisentraut's avatar
Peter Eisentraut committed
325 326
</programlisting>

327
     In this example we have specified each of  the  attributes
328
     with  a  constant value, but any computation
329
     could have been substituted for these constants.
330 331 332
    </para>

    <para>
333
     Note two important things about defining the function:
334 335 336 337

     <itemizedlist>
      <listitem>
       <para>
338
	The select list order in the query must be exactly the same as
339
	that in which the columns appear in the table associated
340 341
	with the composite type.  (Naming the columns, as we did above,
	is irrelevant to the system.)
342 343 344 345
       </para>
      </listitem>
      <listitem>
       <para>
346
	You must typecast the expressions to match the
Peter Eisentraut's avatar
Peter Eisentraut committed
347 348 349
	definition of the composite type, or you will get errors like this:
<screen>
<computeroutput>
350
ERROR:  function declared to return emp returns varchar instead of text at column 1
Peter Eisentraut's avatar
Peter Eisentraut committed
351 352
</computeroutput>
</screen>
353 354
       </para>
      </listitem>
355 356 357 358
     </itemizedlist>
    </para>     

    <para>
359 360 361
     A function that returns a row (composite type) can be used as a table
     function, as described below.  It can also be called in the context
     of an SQL expression, but only when you
362
     extract a single attribute out of the row or pass the entire row into
363 364
     another function that accepts the same composite type.
    </para>
365

366
    <para>
367
     This is an example of extracting an attribute out of a row type:
368

Peter Eisentraut's avatar
Peter Eisentraut committed
369
<screen>
370 371
SELECT (new_emp()).name;

372 373
 name
------
Peter Eisentraut's avatar
Peter Eisentraut committed
374
 None
375 376 377 378 379 380
</screen>

     We need the extra parentheses to keep the parser from getting confused:

<screen>
SELECT new_emp().name;
381
ERROR:  syntax error at or near "." at character 17
Peter Eisentraut's avatar
Peter Eisentraut committed
382
</screen>
383 384 385
    </para>

    <para>
386 387
     Another option is to use
     functional notation for extracting an attribute.  The  simple  way 
388
     to explain this is that we can use the
389
     notations <literal>attribute(table)</>  and  <literal>table.attribute</>
390
     interchangeably.
391

392
<screen>
393 394 395 396 397 398 399
SELECT name(new_emp());

 name
------
 None
</screen>

400
<screen>
401 402 403 404 405 406 407
-- This is the same as:
-- SELECT emp.name AS youngster FROM emp WHERE emp.age &lt; 30

SELECT name(emp) AS youngster
    FROM emp
    WHERE age(emp) &lt; 30;

408 409 410 411 412 413
 youngster
-----------
 Sam
</screen>
    </para>

414
    <para>
415 416 417
     The other way to use a function returning a row result is to declare a
     second function accepting a row type argument and pass the
     result of the first function to it:
418

419
<screen>
420
CREATE FUNCTION getname(emp) RETURNS text AS $$
Peter Eisentraut's avatar
Peter Eisentraut committed
421
    SELECT $1.name;
422
$$ LANGUAGE SQL;
423

424 425 426 427 428 429 430 431 432 433
SELECT getname(new_emp());
 getname
---------
 None
(1 row)
</screen>
    </para>     
   </sect2>

   <sect2>
434
    <title><acronym>SQL</acronym> Functions as Table Sources</title>
435 436

    <para>
437
     All SQL functions may be used in the <literal>FROM</> clause of a query,
438
     but it is particularly useful for functions returning composite types.
439
     If the function is defined to return a base type, the table function
440
     produces a one-column table.  If the function is defined to return
441
     a composite type, the table function produces a column for each attribute
442 443 444 445 446
     of the composite type.
    </para>

    <para>
     Here is an example:
447

448
<screen>
449
CREATE TABLE foo (fooid int, foosubid int, fooname text);
450 451 452
INSERT INTO foo VALUES (1, 1, 'Joe');
INSERT INTO foo VALUES (1, 2, 'Ed');
INSERT INTO foo VALUES (2, 1, 'Mary');
453

454
CREATE FUNCTION getfoo(int) RETURNS foo AS $$
455
    SELECT * FROM foo WHERE fooid = $1;
456
$$ LANGUAGE SQL;
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

SELECT *, upper(fooname) FROM getfoo(1) AS t1;

 fooid | foosubid | fooname | upper
-------+----------+---------+-------
     1 |        1 | Joe     | JOE
(2 rows)
</screen>

     As the example shows, we can work with the columns of the function's
     result just the same as if they were columns of a regular table.
    </para>

    <para>
     Note that we only got one row out of the function.  This is because
472
     we did not use <literal>SETOF</>.  This is described in the next section.
473 474 475 476 477 478 479
    </para>
   </sect2>

   <sect2>
    <title><acronym>SQL</acronym> Functions Returning Sets</title>

    <para>
480 481
     When an SQL function is declared as returning <literal>SETOF
     <replaceable>sometype</></literal>, the function's final
482
     <command>SELECT</> query is executed to completion, and each row it
483
     outputs is returned as an element of the result set.
484 485 486
    </para>

    <para>
487 488
     This feature is normally used when calling the function in the <literal>FROM</>
     clause.  In this case each row returned by the function becomes
489 490 491 492
     a row of the table seen by the query.  For example, assume that
     table <literal>foo</> has the same contents as above, and we say:

<programlisting>
493
CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
494
    SELECT * FROM foo WHERE fooid = $1;
495
$$ LANGUAGE SQL;
496

497 498 499
SELECT * FROM getfoo(1) AS t1;
</programlisting>

500
     Then we would get:
501 502 503 504 505 506 507 508
<screen>
 fooid | foosubid | fooname
-------+----------+---------
     1 |        1 | Joe
     1 |        2 | Ed
(2 rows)
</screen>
    </para>
509 510

    <para>
511 512
     Currently, functions returning sets may also be called in the select list
     of a query.  For each row that the query
513 514 515 516
     generates by itself, the function returning set is invoked, and an output
     row is generated for each element of the function's result set. Note,
     however, that this capability is deprecated and may be removed in future
     releases. The following is an example function returning a set from the
517
     select list:
518

519
<screen>
520 521 522
CREATE FUNCTION listchildren(text) RETURNS SETOF text AS $$
    SELECT name FROM nodes WHERE parent = $1
$$ LANGUAGE SQL;
523

524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
SELECT * FROM nodes;
   name    | parent
-----------+--------
 Top       |
 Child1    | Top
 Child2    | Top
 Child3    | Top
 SubChild1 | Child1
 SubChild2 | Child1
(6 rows)

SELECT listchildren('Top');
 listchildren
--------------
 Child1
 Child2
 Child3
(3 rows)

SELECT name, listchildren(name) FROM nodes;
  name  | listchildren
--------+--------------
 Top    | Child1
 Top    | Child2
 Top    | Child3
 Child1 | SubChild1
 Child1 | SubChild2
(5 rows)
Peter Eisentraut's avatar
Peter Eisentraut committed
552
</screen>
553

Peter Eisentraut's avatar
Peter Eisentraut committed
554 555 556
     In the last <command>SELECT</command>,
     notice that no output row appears for <literal>Child2</>, <literal>Child3</>, etc.
     This happens because <function>listchildren</function> returns an empty set
557
     for those arguments, so no result rows are generated.
558 559
    </para>
   </sect2>
560 561 562 563 564 565

   <sect2>
    <title>Polymorphic <acronym>SQL</acronym> Functions</title>

    <para>
     <acronym>SQL</acronym> functions may be declared to accept and
Peter Eisentraut's avatar
Peter Eisentraut committed
566 567 568 569 570 571
     return the polymorphic types <type>anyelement</type> and
     <type>anyarray</type>.  See <xref
     linkend="extend-types-polymorphic"> for a more detailed
     explanation of polymorphic functions. Here is a polymorphic
     function <function>make_array</function> that builds up an array
     from two arbitrary data type elements:
572
<screen>
573
CREATE FUNCTION make_array(anyelement, anyelement) RETURNS anyarray AS $$
574
    SELECT ARRAY[$1, $2];
575
$$ LANGUAGE SQL;
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594

SELECT make_array(1, 2) AS intarray, make_array('a'::text, 'b') AS textarray;
 intarray | textarray
----------+-----------
 {1,2}    | {a,b}
(1 row)
</screen>
    </para>

    <para>
     Notice the use of the typecast <literal>'a'::text</literal>
     to specify that the argument is of type <type>text</type>. This is
     required if the argument is just a string literal, since otherwise
     it would be treated as type
     <type>unknown</type>, and array of <type>unknown</type> is not a valid
     type.
     Without the typecast, you will get errors like this:
<screen>
<computeroutput>
Peter Eisentraut's avatar
Peter Eisentraut committed
595
ERROR:  could not determine "anyarray"/"anyelement" type because input has type "unknown"
596 597 598 599 600 601 602 603
</computeroutput>
</screen>
    </para>

    <para>
     It is permitted to have polymorphic arguments with a deterministic
     return type, but the converse is not. For example:
<screen>
604
CREATE FUNCTION is_greater(anyelement, anyelement) RETURNS boolean AS $$
605
    SELECT $1 > $2;
606
$$ LANGUAGE SQL;
607 608 609 610 611 612 613

SELECT is_greater(1, 2);
 is_greater
------------
 f
(1 row)

614
CREATE FUNCTION invalid_func() RETURNS anyelement AS $$
615
    SELECT 1;
616
$$ LANGUAGE SQL;
Peter Eisentraut's avatar
Peter Eisentraut committed
617 618
ERROR:  cannot determine result data type
DETAIL:  A function returning "anyarray" or "anyelement" must have at least one argument of either type.
619 620 621
</screen>
    </para>
   </sect2>
622 623
  </sect1>

624
  <sect1 id="xfunc-pl">
625 626 627
   <title>Procedural Language Functions</title>

   <para>
628 629
    Procedural languages aren't built into the
    <productname>PostgreSQL</productname> server; they are offered
Peter Eisentraut's avatar
Peter Eisentraut committed
630
    by loadable modules. Please refer to the documentation of the
631 632
    procedural language in question for details about the syntax and how the
    function body is interpreted for each language.
633
   </para>
634

635
   <para>
636 637
    There are currently four procedural languages available in the
    standard <productname>PostgreSQL</productname> distribution:
Peter Eisentraut's avatar
Peter Eisentraut committed
638
    <application>PL/pgSQL</application>, <application>PL/Tcl</application>,
639 640 641 642 643 644
    <application>PL/Perl</application>, and
    <application>PL/Python</application>.
    Refer to <xref linkend="xplang"> for more information.
    Other languages can be defined by users.
    The basics of developing a new procedural language are covered in <xref
    linkend="plhandler">.
645 646
   </para>
  </sect1>
647

648
  <sect1 id="xfunc-internal">
649
   <title>Internal Functions</title>
650

651 652
   <indexterm zone="xfunc-internal"><primary>function</><secondary>internal</></>

653
   <para>
654
    Internal functions are functions written in C that have been statically
Peter Eisentraut's avatar
Peter Eisentraut committed
655 656 657
    linked into the <productname>PostgreSQL</productname> server.
    The <quote>body</quote> of the function definition
    specifies the C-language name of the function, which need not be the
658
    same as the name being declared for SQL use.
Peter Eisentraut's avatar
Peter Eisentraut committed
659 660 661
    (For reasons of backwards compatibility, an empty body
    is accepted as meaning that the C-language function name is the
    same as the SQL name.)
662
   </para>
663 664

   <para>
Peter Eisentraut's avatar
Peter Eisentraut committed
665
    Normally, all internal functions present in the
666
    server are declared during the initialization of the database cluster (<command>initdb</command>),
Peter Eisentraut's avatar
Peter Eisentraut committed
667 668
    but a user could use <command>CREATE FUNCTION</command>
    to create additional alias names for an internal function.
669
    Internal functions are declared in <command>CREATE FUNCTION</command>
Peter Eisentraut's avatar
Peter Eisentraut committed
670 671 672 673
    with language name <literal>internal</literal>.  For instance, to
    create an alias for the <function>sqrt</function> function:
<programlisting>
CREATE FUNCTION square_root(double precision) RETURNS double precision
674
    AS 'dsqrt'
675 676
    LANGUAGE internal
    STRICT;
Peter Eisentraut's avatar
Peter Eisentraut committed
677 678
</programlisting>
    (Most internal functions expect to be declared <quote>strict</quote>.)
679
   </para>
Peter Eisentraut's avatar
Peter Eisentraut committed
680 681 682 683 684 685 686 687

   <note>
    <para>
     Not all <quote>predefined</quote> functions are
     <quote>internal</quote> in the above sense.  Some predefined
     functions are written in SQL.
    </para>
   </note>
688 689
  </sect1>

690
  <sect1 id="xfunc-c">
691
   <title>C-Language Functions</title>
692

Peter Eisentraut's avatar
Peter Eisentraut committed
693 694 695 696 697 698
   <indexterm zone="xfunc-sql">
    <primary>function</primary>
    <secondary>user-defined</secondary>
    <tertiary>in C</tertiary>
   </indexterm>

699
   <para>
700 701 702
    User-defined functions can be written in C (or a language that can
    be made compatible with C, such as C++).  Such functions are
    compiled into dynamically loadable objects (also called shared
703 704
    libraries) and are loaded by the server on demand.  The dynamic
    loading feature is what distinguishes <quote>C language</> functions
705
    from <quote>internal</> functions &mdash; the actual coding conventions
706 707 708
    are essentially the same for both.  (Hence, the standard internal
    function library is a rich source of coding examples for user-defined
    C functions.)
709 710 711 712
   </para>

   <para>
    Two different calling conventions are currently used for C functions.
713
    The newer <quote>version 1</quote> calling convention is indicated by writing
714 715
    a <literal>PG_FUNCTION_INFO_V1()</literal> macro call for the function,
    as illustrated below.  Lack of such a macro indicates an old-style
716
    (<quote>version 0</quote>) function.  The language name specified in <command>CREATE FUNCTION</command>
717
    is <literal>C</literal> in either case.  Old-style functions are now deprecated
718 719 720 721 722 723 724
    because of portability problems and lack of functionality, but they
    are still supported for compatibility reasons.
   </para>

  <sect2 id="xfunc-c-dynload">
   <title>Dynamic Loading</title>

Peter Eisentraut's avatar
Peter Eisentraut committed
725 726 727 728
   <indexterm zone="xfunc-c-dynload">
    <primary>dynamic loading</primary>
   </indexterm>

729 730
   <para>
    The first time a user-defined function in a particular
731
    loadable object file is called in a session,
732 733
    the dynamic loader loads that object file into memory so that the
    function can be called.  The <command>CREATE FUNCTION</command>
734
    for a user-defined C function must therefore specify two pieces of
735 736 737 738
    information for the function: the name of the loadable
    object file, and the C name (link symbol) of the specific function to call
    within that object file.  If the C name is not explicitly specified then
    it is assumed to be the same as the SQL function name.
739 740 741
   </para>

   <para>
742 743 744 745 746 747 748
    The following algorithm is used to locate the shared object file
    based on the name given in the <command>CREATE FUNCTION</command>
    command:

    <orderedlist>
     <listitem>
      <para>
749
       If the name is an absolute path, the given file is loaded.
750 751 752 753 754 755
      </para>
     </listitem>

     <listitem>
      <para>
       If the name starts with the string <literal>$libdir</literal>,
756 757
       that part is replaced by the <productname>PostgreSQL</> package
	library directory
758
       name, which is determined at build time.<indexterm><primary>$libdir</></>
759 760 761 762 763 764
      </para>
     </listitem>

     <listitem>
      <para>
       If the name does not contain a directory part, the file is
765
       searched for in the path specified by the configuration variable
766
       <xref linkend="guc-dynamic-library-path">.<indexterm><primary>dynamic_library_path</></>
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
      </para>
     </listitem>

     <listitem>
      <para>
       Otherwise (the file was not found in the path, or it contains a
       non-absolute directory part), the dynamic loader will try to
       take the name as given, which will most likely fail.  (It is
       unreliable to depend on the current working directory.)
      </para>
     </listitem>
    </orderedlist>

    If this sequence does not work, the platform-specific shared
    library file name extension (often <filename>.so</filename>) is
    appended to the given name and this sequence is tried again.  If
    that fails as well, the load will fail.
   </para>
785

Peter Eisentraut's avatar
Peter Eisentraut committed
786 787 788 789 790 791 792
   <para>
    The user ID the <productname>PostgreSQL</productname> server runs
    as must be able to traverse the path to the file you intend to
    load.  Making the file or a higher-level directory not readable
    and/or not executable by the <systemitem>postgres</systemitem>
    user is a common mistake.
   </para>
793 794

   <para>
795
    In any case, the file name that is given in the
796 797 798
    <command>CREATE FUNCTION</command> command is recorded literally
    in the system catalogs, so if the file needs to be loaded again
    the same procedure is applied.
799 800
   </para>

801 802
   <note>
    <para>
Bruce Momjian's avatar
Bruce Momjian committed
803
     <productname>PostgreSQL</productname> will not compile a C function
804 805 806 807 808 809 810
     automatically.  The object file must be compiled before it is referenced
     in a <command>CREATE
     FUNCTION</> command.  See <xref linkend="dfunc"> for additional
     information.
    </para>
   </note>

Peter Eisentraut's avatar
Peter Eisentraut committed
811 812 813 814 815 816 817 818
   <para>
    After it is used for the first time, a dynamically loaded object
    file is retained in memory.  Future calls in the same session to
    the function(s) in that file will only incur the small overhead of
    a symbol table lookup.  If you need to force a reload of an object
    file, for example after recompiling it, use the <command>LOAD</>
    command or begin a fresh session.
   </para>
819

820
   <para>
821 822 823
    It is recommended to locate shared libraries either relative to
    <literal>$libdir</literal> or through the dynamic library path.
    This simplifies version upgrades if the new installation is at a
824 825 826
    different location.  The actual directory that
    <literal>$libdir</literal> stands for can be found out with the
    command <literal>pg_config --pkglibdir</literal>.
827 828
   </para>

Peter Eisentraut's avatar
Peter Eisentraut committed
829 830 831 832 833 834 835 836 837
   <para>
    Before <productname>PostgreSQL</productname> release 7.2, only
    exact absolute paths to object files could be specified in
    <command>CREATE FUNCTION</>.  This approach is now deprecated
    since it makes the function definition unnecessarily unportable.
    It's best to specify just the shared library name with no path nor
    extension, and let the search mechanism provide that information
    instead.
   </para>
838 839
  </sect2>

Peter Eisentraut's avatar
Peter Eisentraut committed
840
   <sect2 id="xfunc-c-basetype">
841
    <title>Base Types in C-Language Functions</title>
842

Peter Eisentraut's avatar
Peter Eisentraut committed
843 844 845 846 847
    <indexterm zone="xfunc-c-basetype">
     <primary>data type</primary>
     <secondary>internal organisation</secondary>
    </indexterm>

848
    <para>
849
     To know how to write C-language functions, you need to know how
850 851 852 853 854 855 856 857 858
     <productname>PostgreSQL</productname> internally represents base
     data types and how they can be passed to and from functions.
     Internally, <productname>PostgreSQL</productname> regards a base
     type as a <quote>blob of memory</quote>.  The user-defined
     functions that you define over a type in turn define the way that
     <productname>PostgreSQL</productname> can operate on it.  That
     is, <productname>PostgreSQL</productname> will only store and
     retrieve the data from disk and use your user-defined functions
     to input, process, and output the data.
859 860 861
    </para>

    <para>
862
     Base types can have one of three internal formats:
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883

     <itemizedlist>
      <listitem>
       <para>
	pass by value, fixed-length
       </para>
      </listitem>
      <listitem>
       <para>
	pass by reference, fixed-length
       </para>
      </listitem>
      <listitem>
       <para>
	pass by reference, variable-length
       </para>
      </listitem>
     </itemizedlist>
    </para>

    <para>
884
     By-value  types  can  only be 1, 2, or 4 bytes in length
Peter Eisentraut's avatar
Peter Eisentraut committed
885
     (also 8 bytes, if <literal>sizeof(Datum)</literal> is 8 on your machine).
886
     You should be careful 
887 888
     to define your types such that  they  will  be  the  same  
     size (in bytes) on all architectures.  For example, the 
889
     <literal>long</literal> type is dangerous because  it  
890
     is 4 bytes on some machines and 8 bytes on others, whereas 
Peter Eisentraut's avatar
Peter Eisentraut committed
891 892 893
     <type>int</type>  type  is  4  bytes  on  most  
     Unix machines.  A reasonable implementation of  
     the  <type>int4</type>  type  on  Unix
894 895
     machines might be:
     
896
<programlisting>
897 898
/* 4-byte integer, passed by value */
typedef int int4;
899
</programlisting>
900
    </para>
901

902
    <para>
903 904
     On  the  other hand, fixed-length types of any size may
     be passed by-reference.  For example, here is a  sample
Peter Eisentraut's avatar
Peter Eisentraut committed
905
     implementation of a <productname>PostgreSQL</productname> type:
906
     
907
<programlisting>
908 909 910 911 912
/* 16-byte structure, passed by reference */
typedef struct
{
    double  x, y;
} Point;
913
</programlisting>
914

915
     Only  pointers  to  such types can be used when passing
916
     them in and out of <productname>PostgreSQL</productname> functions.
917
     To return a value of such a type, allocate the right amount of
918 919 920 921 922
     memory with <literal>palloc</literal>, fill in the allocated memory,
     and return a pointer to it.  (You can also return an input value
     that has the same type as the return value directly by returning
     the pointer to the input value.  <emphasis>Never</> modify the
     contents of a pass-by-reference input value, however.)
923 924 925
    </para>

    <para>
926 927 928 929 930
     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
931 932 933 934 935 936 937 938
     length field contains the total length of the structure,
     that is,  it  includes  the  size  of  the  length  field
     itself.
    </para>

    <para>
     As an example, we can define the type <type>text</type> as
     follows:
939

940
<programlisting>
941 942 943 944
typedef struct {
    int4 length;
    char data[1];
} text;
945
</programlisting>
946

947 948 949 950 951
     Obviously,  the  data  field declared here is not long enough to hold
     all possible strings.  Since it's impossible to declare a variable-size
     structure in <acronym>C</acronym>, we rely on the knowledge that the
     <acronym>C</acronym> compiler won't range-check array subscripts.  We
     just allocate the necessary amount of space and then access the array as
952 953 954 955 956
     if it were declared the right length.  (This is a common trick, which
     you can read about in many textbooks about C.)
    </para>

    <para>
957
     When manipulating 
958
     variable-length types, we must  be  careful  to  allocate  
959
     the  correct amount  of memory and set the length field correctly.
960
     For example, if we wanted to  store  40  bytes  in  a <structname>text</>
961 962
     structure, we might use a code fragment like this:

963
<programlisting>
964 965 966 967 968 969
#include "postgres.h"
...
char buffer[40]; /* our source data */
...
text *destination = (text *) palloc(VARHDRSZ + 40);
destination-&gt;length = VARHDRSZ + 40;
970
memcpy(destination-&gt;data, buffer, 40);
971
...
972
</programlisting>
973 974 975 976

     <literal>VARHDRSZ</> is the same as <literal>sizeof(int4)</>, but
     it's considered good style to use the macro <literal>VARHDRSZ</>
     to refer to the size of the overhead for a variable-length type.
977 978
    </para>

979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
    <para>
     <xref linkend="xfunc-c-type-table"> specifies which C type
     corresponds to which SQL type when writing a C-language function
     that uses a built-in type of <productname>PostgreSQL</>.
     The <quote>Defined In</quote> column gives the header file that
     needs to be included to get the type definition.  (The actual
     definition may be in a different file that is included by the
     listed file.  It is recommended that users stick to the defined
     interface.)  Note that you should always include
     <filename>postgres.h</filename> first in any source file, because
     it declares a number of things that you will need anyway.
    </para>

     <table tocentry="1" id="xfunc-c-type-table">
      <title>Equivalent C Types for Built-In SQL Types</title>
      <tgroup cols="3">
       <thead>
	<row>
	 <entry>
	  SQL Type
	 </entry>
	 <entry>
	  C Type
	 </entry>
	 <entry>
	  Defined In
	 </entry>
	</row>
       </thead>
       <tbody>
	<row>
	 <entry><type>abstime</type></entry>
	 <entry><type>AbsoluteTime</type></entry>
	 <entry><filename>utils/nabstime.h</filename></entry>
	</row>
	<row>
	 <entry><type>boolean</type></entry>
	 <entry><type>bool</type></entry>
	 <entry><filename>postgres.h</filename> (maybe compiler built-in)</entry>
	</row>
	<row>
	 <entry><type>box</type></entry>
	 <entry><type>BOX*</type></entry>
	 <entry><filename>utils/geo_decls.h</filename></entry>
	</row>
	<row>
	 <entry><type>bytea</type></entry>
	 <entry><type>bytea*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>"char"</type></entry>
	 <entry><type>char</type></entry>
	 <entry>(compiler built-in)</entry>
	</row>
	<row>
	 <entry><type>character</type></entry>
	 <entry><type>BpChar*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>cid</type></entry>
	 <entry><type>CommandId</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>date</type></entry>
	 <entry><type>DateADT</type></entry>
	 <entry><filename>utils/date.h</filename></entry>
	</row>
	<row>
	 <entry><type>smallint</type> (<type>int2</type>)</entry>
	 <entry><type>int2</type> or <type>int16</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>int2vector</type></entry>
	 <entry><type>int2vector*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>integer</type> (<type>int4</type>)</entry>
	 <entry><type>int4</type> or <type>int32</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>real</type> (<type>float4</type>)</entry>
	 <entry><type>float4*</type></entry>
	<entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>double precision</type> (<type>float8</type>)</entry>
	 <entry><type>float8*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>interval</type></entry>
	 <entry><type>Interval*</type></entry>
	 <entry><filename>utils/timestamp.h</filename></entry>
	</row>
	<row>
	 <entry><type>lseg</type></entry>
	 <entry><type>LSEG*</type></entry>
	 <entry><filename>utils/geo_decls.h</filename></entry>
	</row>
	<row>
	 <entry><type>name</type></entry>
	 <entry><type>Name</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>oid</type></entry>
	 <entry><type>Oid</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>oidvector</type></entry>
	 <entry><type>oidvector*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>path</type></entry>
	 <entry><type>PATH*</type></entry>
	 <entry><filename>utils/geo_decls.h</filename></entry>
	</row>
	<row>
	 <entry><type>point</type></entry>
	 <entry><type>POINT*</type></entry>
	 <entry><filename>utils/geo_decls.h</filename></entry>
	</row>
	<row>
	 <entry><type>regproc</type></entry>
	 <entry><type>regproc</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>reltime</type></entry>
	 <entry><type>RelativeTime</type></entry>
	 <entry><filename>utils/nabstime.h</filename></entry>
	</row>
	<row>
	 <entry><type>text</type></entry>
	 <entry><type>text*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>tid</type></entry>
	 <entry><type>ItemPointer</type></entry>
	 <entry><filename>storage/itemptr.h</filename></entry>
	</row>
	<row>
	 <entry><type>time</type></entry>
	 <entry><type>TimeADT</type></entry>
	 <entry><filename>utils/date.h</filename></entry>
	</row>
	<row>
	 <entry><type>time with time zone</type></entry>
	 <entry><type>TimeTzADT</type></entry>
	 <entry><filename>utils/date.h</filename></entry>
	</row>
	<row>
	 <entry><type>timestamp</type></entry>
	 <entry><type>Timestamp*</type></entry>
	 <entry><filename>utils/timestamp.h</filename></entry>
	</row>
	<row>
	 <entry><type>tinterval</type></entry>
	 <entry><type>TimeInterval</type></entry>
	 <entry><filename>utils/nabstime.h</filename></entry>
	</row>
	<row>
	 <entry><type>varchar</type></entry>
	 <entry><type>VarChar*</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
	<row>
	 <entry><type>xid</type></entry>
	 <entry><type>TransactionId</type></entry>
	 <entry><filename>postgres.h</filename></entry>
	</row>
       </tbody>
      </tgroup>
     </table>

1163
    <para>
1164
     Now that we've gone over all of the possible structures
1165 1166 1167 1168 1169
     for base types, we can show some examples of real functions.
    </para>
   </sect2>

   <sect2>
1170
    <title>Calling Conventions Version 0 for C-Language Functions</title>
1171 1172

    <para>
1173
     We present the <quote>old style</quote> calling convention first &mdash; although
1174
     this approach is now deprecated, it's easier to get a handle on
1175
     initially.  In the version-0 method, the arguments and result
1176 1177 1178 1179 1180 1181 1182
     of the C function are just declared in normal C style, but being
     careful to use the C representation of each SQL data type as shown
     above.
    </para>

    <para>
     Here are some examples:
1183

1184
<programlisting>
1185
#include "postgres.h"
1186
#include &lt;string.h&gt;
1187

1188
/* by value */
1189
         
1190 1191 1192
int
add_one(int arg)
{
1193
    return arg + 1;
1194 1195
}

1196
/* by reference, fixed length */
1197

1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
float8 *
add_one_float8(float8 *arg)
{
    float8    *result = (float8 *) palloc(sizeof(float8));

    *result = *arg + 1.0;
       
    return result;
}

1208
Point *
1209
makepoint(Point *pointx, Point *pointy)
1210 1211 1212 1213 1214 1215 1216 1217 1218
{
    Point     *new_point = (Point *) palloc(sizeof(Point));

    new_point->x = pointx->x;
    new_point->y = pointy->y;
       
    return new_point;
}

1219
/* by reference, variable length */
1220 1221 1222 1223 1224 1225 1226 1227

text *
copytext(text *t)
{
    /*
     * VARSIZE is the total size of the struct in bytes.
     */
    text *new_t = (text *) palloc(VARSIZE(t));
1228
    VARATT_SIZEP(new_t) = VARSIZE(t);
1229 1230 1231 1232 1233
    /*
     * VARDATA is a pointer to the data region of the struct.
     */
    memcpy((void *) VARDATA(new_t), /* destination */
           (void *) VARDATA(t),     /* source */
1234 1235
           VARSIZE(t)-VARHDRSZ);    /* how many bytes */
    return new_t;
1236 1237 1238 1239 1240 1241 1242 1243
}

text *
concat_text(text *arg1, text *arg2)
{
    int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
    text *new_text = (text *) palloc(new_text_size);

1244
    VARATT_SIZEP(new_text) = new_text_size;
1245 1246 1247
    memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ);
    memcpy(VARDATA(new_text) + (VARSIZE(arg1)-VARHDRSZ),
           VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ);
1248
    return new_text;
1249
}
1250
</programlisting>
1251
    </para>
1252

1253
    <para>
1254 1255
     Supposing that the above code has been prepared in file
     <filename>funcs.c</filename> and compiled into a shared object,
1256
     we could define the functions to <productname>PostgreSQL</productname>
1257
     with commands like this:
1258
     
1259
<programlisting>
1260 1261 1262
CREATE FUNCTION add_one(integer) RETURNS integer
     AS '<replaceable>DIRECTORY</replaceable>/funcs', 'add_one'
     LANGUAGE C STRICT;
1263

1264 1265 1266 1267
-- note overloading of SQL function name "add_one"
CREATE FUNCTION add_one(double precision) RETURNS double precision
     AS '<replaceable>DIRECTORY</replaceable>/funcs', 'add_one_float8'
     LANGUAGE C STRICT;
1268

1269
CREATE FUNCTION makepoint(point, point) RETURNS point
1270 1271
     AS '<replaceable>DIRECTORY</replaceable>/funcs', 'makepoint'
     LANGUAGE C STRICT;
1272 1273
                         
CREATE FUNCTION copytext(text) RETURNS text
1274 1275
     AS '<replaceable>DIRECTORY</replaceable>/funcs', 'copytext'
     LANGUAGE C STRICT;
1276 1277

CREATE FUNCTION concat_text(text, text) RETURNS text
1278 1279
     AS '<replaceable>DIRECTORY</replaceable>/funcs', 'concat_text',
     LANGUAGE C STRICT;
1280
</programlisting>
1281
    </para>
1282

1283
    <para>
1284
     Here, <replaceable>DIRECTORY</replaceable> stands for the
1285 1286 1287 1288 1289 1290 1291 1292
     directory of the shared library file (for instance the
     <productname>PostgreSQL</productname> tutorial directory, which
     contains the code for the examples used in this section).
     (Better style would be to use just <literal>'funcs'</> in the
     <literal>AS</> clause, after having added
     <replaceable>DIRECTORY</replaceable> to the search path.  In any
     case, we may omit the system-specific extension for a shared
     library, commonly <literal>.so</literal> or
1293
     <literal>.sl</literal>.)
1294 1295 1296
    </para>

    <para>
1297 1298
     Notice that we have specified the functions as <quote>strict</quote>,
     meaning that
1299 1300
     the system should automatically assume a null result if any input
     value is null.  By doing this, we avoid having to check for null inputs
1301
     in the function code.  Without this, we'd have to check for null values
1302
     explicitly, by checking for a null pointer for each
1303 1304 1305 1306 1307
     pass-by-reference argument.  (For pass-by-value arguments, we don't
     even have a way to check!)
    </para>

    <para>
1308
     Although this calling convention is simple to use,
1309
     it is not very portable; on some architectures there are problems
1310 1311
     with passing data types that are smaller than <type>int</type> this way.  Also, there is
     no simple way to return a null result, nor to cope with null arguments
1312
     in any way other than making the function strict.  The version-1
1313
     convention, presented next, overcomes these objections.
1314 1315
    </para>
   </sect2>
1316

1317
   <sect2>
1318
    <title>Calling Conventions Version 1 for C-Language Functions</title>
1319 1320

    <para>
1321
     The version-1 calling convention relies on macros to suppress most
1322
     of the complexity of passing arguments and results.  The C declaration
1323
     of a version-1 function is always
1324 1325 1326
<programlisting>
Datum funcname(PG_FUNCTION_ARGS)
</programlisting>
1327
     In addition, the macro call
1328 1329 1330
<programlisting>
PG_FUNCTION_INFO_V1(funcname);
</programlisting>
1331 1332 1333 1334 1335 1336
     must appear in the same source file.  (Conventionally. it's
     written just before the function itself.)  This macro call is not
     needed for <literal>internal</>-language functions, since
     <productname>PostgreSQL</> assumes that all internal functions
     use the version-1 convention.  It is, however, required for
     dynamically-loaded functions.
1337 1338 1339
    </para>

    <para>
1340 1341
     In a version-1 function, each actual argument is fetched using a
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function>
1342 1343
     macro that corresponds to the argument's data type, and the
     result is returned using a
Tom Lane's avatar
Tom Lane committed
1344
     <function>PG_RETURN_<replaceable>xxx</replaceable>()</function>
1345
     macro for the return type.
1346 1347 1348 1349 1350
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function>
     takes as its argument the number of the function argument to
     fetch, where the count starts at 0.
     <function>PG_RETURN_<replaceable>xxx</replaceable>()</function>
     takes as its argument the actual value to return.
1351 1352 1353
    </para>

    <para>
Tom Lane's avatar
Tom Lane committed
1354
     Here we show the same functions as above, coded in version-1 style:
1355

1356
<programlisting>
1357
#include "postgres.h"
1358
#include &lt;string.h&gt;
1359 1360
#include "fmgr.h"

1361
/* by value */
1362 1363

PG_FUNCTION_INFO_V1(add_one);
1364 1365 1366 1367 1368 1369 1370 1371 1372
         
Datum
add_one(PG_FUNCTION_ARGS)
{
    int32   arg = PG_GETARG_INT32(0);

    PG_RETURN_INT32(arg + 1);
}

1373
/* b reference, fixed length */
1374

1375 1376
PG_FUNCTION_INFO_V1(add_one_float8);

1377 1378 1379
Datum
add_one_float8(PG_FUNCTION_ARGS)
{
1380
    /* The macros for FLOAT8 hide its pass-by-reference nature. */
1381 1382 1383 1384 1385
    float8   arg = PG_GETARG_FLOAT8(0);

    PG_RETURN_FLOAT8(arg + 1.0);
}

1386 1387
PG_FUNCTION_INFO_V1(makepoint);

1388 1389 1390
Datum
makepoint(PG_FUNCTION_ARGS)
{
1391
    /* Here, the pass-by-reference nature of Point is not hidden. */
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
    Point     *pointx = PG_GETARG_POINT_P(0);
    Point     *pointy = PG_GETARG_POINT_P(1);
    Point     *new_point = (Point *) palloc(sizeof(Point));

    new_point->x = pointx->x;
    new_point->y = pointy->y;
       
    PG_RETURN_POINT_P(new_point);
}

1402
/* by reference, variable length */
1403

1404 1405
PG_FUNCTION_INFO_V1(copytext);

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
Datum
copytext(PG_FUNCTION_ARGS)
{
    text     *t = PG_GETARG_TEXT_P(0);
    /*
     * VARSIZE is the total size of the struct in bytes.
     */
    text     *new_t = (text *) palloc(VARSIZE(t));
    VARATT_SIZEP(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 */
1420
           VARSIZE(t)-VARHDRSZ);    /* how many bytes */
1421 1422 1423
    PG_RETURN_TEXT_P(new_t);
}

1424 1425
PG_FUNCTION_INFO_V1(concat_text);

1426 1427 1428 1429 1430 1431 1432 1433 1434
Datum
concat_text(PG_FUNCTION_ARGS)
{
    text  *arg1 = PG_GETARG_TEXT_P(0);
    text  *arg2 = PG_GETARG_TEXT_P(1);
    int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
    text *new_text = (text *) palloc(new_text_size);

    VARATT_SIZEP(new_text) = new_text_size;
1435 1436 1437
    memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ);
    memcpy(VARDATA(new_text) + (VARSIZE(arg1)-VARHDRSZ),
           VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ);
1438 1439
    PG_RETURN_TEXT_P(new_text);
}
1440
</programlisting>
1441 1442 1443 1444
    </para>

    <para>
     The <command>CREATE FUNCTION</command> commands are the same as
Tom Lane's avatar
Tom Lane committed
1445
     for the version-0 equivalents.
1446 1447 1448
    </para>

    <para>
1449
     At first glance, the version-1 coding conventions may appear to
1450
     be just pointless obscurantism.  They do, however, offer a number
1451
     of improvements, because the macros can hide unnecessary detail.
Peter Eisentraut's avatar
Peter Eisentraut committed
1452 1453
     An example is that in coding <function>add_one_float8</>, we no longer need to
     be aware that <type>float8</type> is a pass-by-reference type.  Another
1454 1455 1456
     example is that the <literal>GETARG</> macros for variable-length types allow
     for more efficient fetching of <quote>toasted</quote> (compressed or
     out-of-line) values.
1457 1458 1459
    </para>

    <para>
1460
     One big improvement in version-1 functions is better handling of null
Peter Eisentraut's avatar
Peter Eisentraut committed
1461
     inputs and results.  The macro <function>PG_ARGISNULL(<replaceable>n</>)</function>
1462 1463
     allows a function to test whether each input is null.  (Of course, doing
     this is only necessary in functions not declared <quote>strict</>.)
1464 1465
     As with the
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function> macros,
1466 1467 1468
     the input arguments are counted beginning at zero.  Note that one
     should refrain from executing
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function> until
1469 1470
     one has verified that the argument isn't null.
     To return a null result, execute <function>PG_RETURN_NULL()</function>;
Peter Eisentraut's avatar
Peter Eisentraut committed
1471
     this works in both strict and nonstrict functions.
1472 1473
    </para>

1474
    <para>
1475
     Other options provided in the new-style interface are two
1476 1477 1478
     variants of the
     <function>PG_GETARG_<replaceable>xxx</replaceable>()</function>
     macros. The first of these,
1479 1480
     <function>PG_GETARG_<replaceable>xxx</replaceable>_COPY()</function>,
     guarantees to return a copy of the specified argument that is
1481
     safe for writing into. (The normal macros will sometimes return a
1482
     pointer to a value that is physically stored in a table, which
1483
     must not be written to. Using the
1484 1485 1486 1487
     <function>PG_GETARG_<replaceable>xxx</replaceable>_COPY()</function>
     macros guarantees a writable result.)
    The second variant consists of the
    <function>PG_GETARG_<replaceable>xxx</replaceable>_SLICE()</function>
1488 1489
    macros which take three arguments. The first is the number of the
    function argument (as above). The second and third are the offset and
1490 1491
    length of the segment to be returned. Offsets are counted from
    zero, and a negative length requests that the remainder of the
1492
    value be returned. These macros provide more efficient access to
1493
    parts of large values in the case where they have storage type
1494
    <quote>external</quote>. (The storage type of a column can be specified using
Peter Eisentraut's avatar
Peter Eisentraut committed
1495
    <literal>ALTER TABLE <replaceable>tablename</replaceable> ALTER
1496
    COLUMN <replaceable>colname</replaceable> SET STORAGE
1497
    <replaceable>storagetype</replaceable></literal>. <replaceable>storagetype</replaceable> is one of
Peter Eisentraut's avatar
Peter Eisentraut committed
1498 1499
    <literal>plain</>, <literal>external</>, <literal>extended</literal>,
     or <literal>main</>.)
1500 1501
    </para>

1502
    <para>
1503 1504 1505 1506
     Finally, the version-1 function call conventions make it possible
     to return set results (<xref linkend="xfunc-c-return-set">) and
     implement trigger functions (<xref linkend="triggers">) and
     procedural-language call handlers (<xref
1507
     linkend="plhandler">).  Version-1 code is also more
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
     portable than version-0, because it does not break restrictions
     on function call protocol in the C standard.  For more details
     see <filename>src/backend/utils/fmgr/README</filename> in the
     source distribution.
    </para>
   </sect2>

   <sect2>
    <title>Writing Code</title>

    <para>
     Before we turn to the more advanced topics, we should discuss
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
     some coding rules for <productname>PostgreSQL</productname>
     C-language functions.  While it may be possible to load functions
     written in languages other than C into
     <productname>PostgreSQL</productname>, this is usually difficult
     (when it is possible at all) because other languages, such as
     C++, FORTRAN, or 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 C-language functions are
     actually written in C.
1530 1531 1532 1533 1534 1535 1536 1537 1538
    </para>

    <para>
     The basic rules for writing and building C functions are as follows:

     <itemizedlist>
      <listitem>
       <para>
        Use <literal>pg_config
Peter Eisentraut's avatar
Peter Eisentraut committed
1539
        --includedir-server</literal><indexterm><primary>pg_config</><secondary>with user-defined C functions</></>
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
        to find out where the <productname>PostgreSQL</> server header
        files are installed on your system (or the system that your
        users will be running on).  This option is new with
        <productname>PostgreSQL</> 7.2.  For
        <productname>PostgreSQL</> 7.1 you should use the option
        <option>--includedir</option>.  (<command>pg_config</command>
        will exit with a non-zero status if it encounters an unknown
        option.)  For releases prior to 7.1 you will have to guess,
        but since that was before the current calling conventions were
        introduced, it is unlikely that you want to support those
        releases.
       </para>
      </listitem>

      <listitem>
       <para>
        When allocating memory, use the
        <productname>PostgreSQL</productname> functions
Peter Eisentraut's avatar
Peter Eisentraut committed
1558
        <function>palloc</function><indexterm><primary>palloc</></> and <function>pfree</function><indexterm><primary>pfree</></>
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
        instead of the corresponding C library functions
        <function>malloc</function> and <function>free</function>.
        The memory allocated by <function>palloc</function> will be
        freed automatically at the end of each transaction, preventing
        memory leaks.
       </para>
      </listitem>

      <listitem>
       <para>
        Always zero the bytes of your structures using
1570 1571 1572 1573
	<function>memset</function>.  Without this, it's difficult to
	support hash indexes or hash joins, as you must pick out only
	the significant bits of your data structure to compute a hash.
        Even if you initialize all fields of your structure, there may be
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
        alignment padding (holes in the structure) that may contain
        garbage values.
       </para>
      </listitem>

      <listitem>
       <para>
        Most of the internal <productname>PostgreSQL</productname>
        types are declared in <filename>postgres.h</filename>, while
        the function manager interfaces
        (<symbol>PG_FUNCTION_ARGS</symbol>, etc.)  are in
        <filename>fmgr.h</filename>, so you will need to include at
        least these two files.  For portability reasons it's best to
        include <filename>postgres.h</filename> <emphasis>first</>,
        before any other system or user header files.  Including
        <filename>postgres.h</filename> will also include
        <filename>elog.h</filename> and <filename>palloc.h</filename>
        for you.
       </para>
      </listitem>

      <listitem>
       <para>
        Symbol names defined within object files must not conflict
        with each other or with symbols defined in the
        <productname>PostgreSQL</productname> server executable.  You
        will have to rename your functions or variables if you get
        error messages to this effect.
       </para>
      </listitem>

      <listitem>
       <para>
        Compiling and linking your code so that it can be dynamically
        loaded into <productname>PostgreSQL</productname> always
        requires special flags.  See <xref linkend="dfunc"> for a
        detailed explanation of how to do it for your particular
        operating system.
       </para>
      </listitem>
     </itemizedlist>
1615 1616 1617
    </para>
   </sect2>

1618 1619
&dfunc;

1620 1621 1622 1623 1624 1625 1626 1627
   <sect2 id="xfunc-c-pgxs">
    <title>Extension build infrastructure</title>

   <indexterm zone="xfunc-c-pgxs">
    <primary>pgxs</primary>
   </indexterm>

   <para>
1628 1629 1630 1631
    If you are thinking about distributing your
    <productname>PostgreSQL</> extension modules, setting up a
    portable build system for them can be fairly difficult.  Therefore
    the <productname>PostgreSQL</> installation provides a build
1632 1633 1634 1635
    infrastructure for extensions, called <acronym>PGXS</acronym>, so
    that simple extension modules can be built simply against an
    already installed server.  Note that this infrastructure is not
    intended to be a universal build system framework that can be used
1636 1637 1638 1639
    to build all software interfacing to <productname>PostgreSQL</>;
    it simply automates common build rules for simple server extension
    modules.  For more complicated packages, you need to write your
    own build system.
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
   </para>

   <para>
    To use the infrastructure for your extension, you must write a
    simple makefile.  In that makefile, you need to set some variables
    and finally include the global <acronym>PGXS</acronym> makefile.
    Here is an example that builds an extension module named
    <literal>isbn_issn</literal> consisting of a shared library, an
    SQL script, and a documentation text file:
<programlisting>
MODULES = isbn_issn
DATA_built = isbn_issn.sql
DOCS = README.isbn_issn

PGXS := $(shell pg_config --pgxs)
include $(PGXS)
</programlisting>
    The last two lines should always be the same.  Earlier in the
    file, you assign variables or add custom
    <application>make</application> rules.
   </para>

   <para>
    The following variables can be set:

    <variablelist>
     <varlistentry>
      <term><varname>MODULES</varname></term>
      <listitem>
       <para>
        list of shared objects to be build from source file with same
        stem (do not include suffix in this list)
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>DATA</varname></term>
      <listitem>
       <para>
        random files to install into <literal><replaceable>prefix</replaceable>/share/contrib</literal>
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>DATA_built</varname></term>
      <listitem>
       <para>
        random files to install into
        <literal><replaceable>prefix</replaceable>/share/contrib</literal>,
        which need to be built first
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>DOCS</varname></term>
      <listitem>
       <para>
        random files to install under
        <literal><replaceable>prefix</replaceable>/doc/contrib</literal>
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>SCRIPTS</varname></term>
      <listitem>
       <para>
        script files (not binaries) to install into
        <literal><replaceable>prefix</replaceable>/bin</literal>
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>SCRIPTS_built</varname></term>
      <listitem>
       <para>
        script files (not binaries) to install into
        <literal><replaceable>prefix</replaceable>/bin</literal>,
        which need to be built first
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>REGRESS</varname></term>
      <listitem>
       <para>
        list of regression test cases (without suffix)
       </para>
      </listitem>
     </varlistentry>
    </variablelist>

    or at most one of these two:

    <variablelist>
     <varlistentry>
      <term><varname>PROGRAM</varname></term>
      <listitem>
       <para>
        a binary program to build (list objects files in <varname>OBJS</varname>)
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>MODULE_big</varname></term>
      <listitem>
       <para>
        a shared object to build (list object files in <varname>OBJS</varname>)
       </para>
      </listitem>
     </varlistentry>
    </variablelist>

    The following can also be set:

    <variablelist>

     <varlistentry>
      <term><varname>EXTRA_CLEAN</varname></term>
      <listitem>
       <para>
        extra files to remove in <literal>make clean</literal>
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>PG_CPPFLAGS</varname></term>
      <listitem>
       <para>
        will be added to <varname>CPPFLAGS</varname>
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>PG_LIBS</varname></term>
      <listitem>
       <para>
        will be added to <varname>PROGRAM</varname> link line
       </para>
      </listitem>
     </varlistentry>

     <varlistentry>
      <term><varname>SHLIB_LINK</varname></term>
      <listitem>
       <para>
        will be added to <varname>MODULE_big</varname> link line
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
   </para>

   <para>
    Put this makefile as <literal>Makefile</literal> in the directory
    which holds your extension. Then you can do
    <literal>make</literal> to compile, and later <literal>make
    install</literal> to install your module.  The extension is
    compiled and installed for the
    <productname>PostgreSQL</productname> installation that
    corresponds to the first <command>pg_config</command> command
    found in your path.
   </para>
  </sect2>


1814
   <sect2>
1815
    <title>Composite-Type Arguments in C-Language Functions</title>
1816

1817
    <para>
1818 1819 1820 1821 1822 1823 1824
     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,
     <productname>PostgreSQL</productname> provides a function
     interface for accessing fields of composite types from C.
1825 1826 1827
    </para>

    <para>
1828
     Suppose we want to write a function to answer the query
1829

1830 1831
<programlisting>
SELECT name, c_overpaid(emp, 1500) AS overpaid
1832 1833
    FROM emp
    WHERE name = 'Bill' OR name = 'Sam';
1834
</programlisting>
1835

1836 1837
     Using call conventions version 0, we can define
     <function>c_overpaid</> as:
1838
     
1839
<programlisting>
1840 1841 1842 1843
#include "postgres.h"
#include "executor/executor.h"  /* for GetAttributeByName() */

bool
1844
c_overpaid(HeapTupleHeader t, /* the current row of emp */
1845
           int32 limit)
1846
{
1847 1848 1849 1850
    bool isnull;
    int32 salary;

    salary = DatumGetInt32(GetAttributeByName(t, "salary", &amp;isnull));
1851
    if (isnull)
1852
        return false;
1853 1854
    return salary &gt; limit;
}
1855 1856 1857
</programlisting>

     In version-1 coding, the above would look like this:
1858

1859 1860 1861
<programlisting>
#include "postgres.h"
#include "executor/executor.h"  /* for GetAttributeByName() */
1862 1863

PG_FUNCTION_INFO_V1(c_overpaid);
1864 1865 1866 1867

Datum
c_overpaid(PG_FUNCTION_ARGS)
{
1868
    HeapTupleHeader  t = PG_GETARG_HEAPTUPLEHEADER(0);
1869 1870 1871 1872 1873 1874 1875
    int32            limit = PG_GETARG_INT32(1);
    bool isnull;
    int32 salary;

    salary = DatumGetInt32(GetAttributeByName(t, "salary", &amp;isnull));
    if (isnull)
        PG_RETURN_BOOL(false);
1876
    /* Alternatively, we might prefer to do PG_RETURN_NULL() for null salary. */
1877 1878

    PG_RETURN_BOOL(salary &gt; limit);
1879
}
1880
</programlisting>
1881
    </para>
1882

1883
    <para>
1884
     <function>GetAttributeByName</function> is the 
1885
     <productname>PostgreSQL</productname> system function that
1886
     returns attributes out of the specified row.  It has
1887 1888
     three arguments: the argument of type <type>HeapTupleHeader</type> passed
     into 
1889
     the  function, the name of the desired attribute, and a
1890
     return parameter that tells whether  the  attribute
Peter Eisentraut's avatar
Peter Eisentraut committed
1891 1892
     is  null.   <function>GetAttributeByName</function> returns a <type>Datum</type>
     value that you can convert to the proper data type by using the
1893
     appropriate <function>DatumGet<replaceable>XXX</replaceable>()</function> macro.
1894
    </para>
1895

1896 1897 1898 1899 1900
    <para>
     There is also <function>GetAttributeByNum</function>, which selects
     the target attribute by column number instead of name.
    </para>

1901
    <para>
1902 1903
     The following command declares the function
     <function>c_overpaid</function> in SQL:
1904

1905
<programlisting>
Peter Eisentraut's avatar
Peter Eisentraut committed
1906
CREATE FUNCTION c_overpaid(emp, integer) RETURNS boolean
1907
    AS '<replaceable>DIRECTORY</replaceable>/funcs', 'c_overpaid'
1908
    LANGUAGE C STRICT;
1909
</programlisting>
1910 1911 1912

     Notice we have used <literal>STRICT</> so that we did not have to
     check whether the input arguments were NULL.
1913 1914 1915 1916
    </para>
   </sect2>

   <sect2>
1917
    <title>Returning Rows (Composite Types) from C-Language Functions</title>
1918 1919

    <para>
1920 1921 1922 1923
     To return a row or composite-type value from a C-language
     function, you can use a special API that provides macros and
     functions to hide most of the complexity of building composite
     data types.  To use this API, the source file must include:
1924 1925 1926 1927 1928 1929
<programlisting>
#include "funcapi.h"
</programlisting>
    </para>

    <para>
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
     There are two ways you can build a composite data value (henceforth
     a <quote>tuple</>): you can build it from an array of Datum values,
     or from an array of C strings that can be passed to the input
     conversion functions of the tuple's column datatypes.  In either
     case, you first need to obtain or construct a <structname>TupleDesc</>
     descriptor for the tuple structure.  When working with Datums, you
     pass the <structname>TupleDesc</> to <function>BlessTupleDesc</>,
     and then call <function>heap_formtuple</> for each row.  When working
     with C strings, you pass the <structname>TupleDesc</> to
     <function>TupleDescGetAttInMetadata</>, and then call
     <function>BuildTupleFromCStrings</> for each row.  In the case of a
     function returning a set of tuples, the setup steps can all be done
     once during the first call of the function.
1943 1944 1945
    </para>

    <para>
1946 1947 1948
     Several helper functions are available for setting up the initial
     <structname>TupleDesc</>.  If you want to use a named composite type,
     you can fetch the information from the system catalogs.  Use
1949
<programlisting>
1950
TupleDesc RelationNameGetTupleDesc(const char *relname)
1951
</programlisting>
1952
     to get a <structname>TupleDesc</> for a named relation, or
1953 1954 1955
<programlisting>
TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases)
</programlisting>
1956
     to get a <structname>TupleDesc</> based on a type OID. This can
1957
     be used to get a <structname>TupleDesc</> for a base or
1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
     composite type.  When writing a function that returns
     <structname>record</>, the expected <structname>TupleDesc</> 
     must be passed in by the caller.
    </para>

    <para>
     Once you have a <structname>TupleDesc</>, call
<programlisting>
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
</programlisting>
     if you plan to work with Datums, or
1969 1970 1971
<programlisting>
AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc)
</programlisting>
1972 1973
     if you plan to work with C strings.  If you are writing a function
     returning set, you can save the results of these functions in the
1974
     <structname>FuncCallContext</> structure &mdash; use the
1975 1976
     <structfield>tuple_desc</> or <structfield>attinmeta</> field
     respectively.
1977 1978 1979
    </para>

    <para>
1980
     When working with Datums, use
1981
<programlisting>
1982
HeapTuple heap_formtuple(TupleDesc tupdesc, Datum *values, char *nulls)
1983
</programlisting>
1984
     to build a <structname>HeapTuple</> given user data in Datum form.
1985 1986 1987
    </para>

    <para>
1988
     When working with C strings, use
1989 1990 1991
<programlisting>
HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
</programlisting>
1992 1993 1994
     to build a <structname>HeapTuple</> given user data
     in C string form.  <literal>values</literal> is an array of C strings,
     one for each attribute of the return row. Each C string should be in
1995 1996 1997 1998
     the form expected by the input function of the attribute data
     type. In order to return a null value for one of the attributes,
     the corresponding pointer in the <parameter>values</> array
     should be set to <symbol>NULL</>.  This function will need to
1999
     be called again for each row you return.
2000 2001
    </para>

2002
    <para>
2003 2004
     Once you have built a tuple to return from your function, it
     must be converted into a <type>Datum</>. Use
2005
<programlisting>
2006
HeapTupleGetDatum(HeapTuple tuple)
2007
</programlisting>
2008
     to convert a <structname>HeapTuple</> into a valid Datum.  This
2009 2010 2011
     <type>Datum</> can be returned directly if you intend to return
     just a single row, or it can be used as the current return value
     in a set-returning function.
2012 2013 2014
    </para>

    <para>
2015
     An example appears in the next section.
2016 2017
    </para>

2018 2019 2020 2021
   </sect2>

   <sect2 id="xfunc-c-return-set">
    <title>Returning Sets from C-Language Functions</title>
2022

2023 2024 2025 2026 2027 2028 2029
    <para>
     There is also a special API that provides support for returning
     sets (multiple rows) from a C-language function.  A set-returning
     function must follow the version-1 calling conventions.  Also,
     source files must include <filename>funcapi.h</filename>, as
     above.
    </para>
2030 2031

    <para>
2032
     A set-returning function (<acronym>SRF</>) is called
2033 2034
     once for each item it returns.  The <acronym>SRF</> must
     therefore save enough state to remember what it was doing and
2035 2036 2037
     return the next item on each call.
     The structure <structname>FuncCallContext</> is provided to help
     control this process.  Within a function, <literal>fcinfo-&gt;flinfo-&gt;fn_extra</>
2038 2039
     is used to hold a pointer to <structname>FuncCallContext</>
     across calls.
2040 2041 2042
<programlisting>
typedef struct
{
2043
    /*
2044
     * Number of times we've been called before
2045 2046 2047 2048 2049 2050 2051 2052 2053
     * 
     * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
     * incremented for you every time SRF_RETURN_NEXT() is called.
     */
    uint32 call_cntr;

    /*
     * OPTIONAL maximum number of calls
     *
2054
     * max_calls is here for convenience only and setting it is optional.
2055 2056 2057 2058 2059 2060 2061 2062
     * If not set, you must provide alternative means to know when the
     * function is done.
     */
    uint32 max_calls;

    /*
     * OPTIONAL pointer to result slot
     * 
2063 2064
     * This is obsolete and only present for backwards compatibility, viz,
     * user-defined SRFs that use the deprecated TupleDescGetSlot().
2065 2066 2067 2068
     */
    TupleTableSlot *slot;

    /*
2069
     * OPTIONAL pointer to miscellaneous user-provided context information
2070
     * 
2071 2072
     * user_fctx is for use as a pointer to your own data to retain
     * arbitrary context information between calls of your function.
2073 2074 2075 2076
     */
    void *user_fctx;

    /*
2077
     * OPTIONAL pointer to struct containing attribute type input metadata
2078
     * 
2079
     * attinmeta is for use when returning tuples (i.e., composite data types)
2080 2081 2082
     * and is not used when returning base data types. It is only needed
     * if you intend to use BuildTupleFromCStrings() to create the return
     * tuple.
2083 2084 2085 2086
     */
    AttInMetadata *attinmeta;

    /*
2087
     * memory context used for structures that must live for multiple calls
2088 2089 2090
     *
     * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
     * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
2091
     * context for any memory that is to be reused across multiple calls
2092 2093 2094
     * of the SRF.
     */
    MemoryContext multi_call_memory_ctx;
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106

    /*
     * OPTIONAL pointer to struct containing tuple description
     *
     * tuple_desc is for use when returning tuples (i.e. composite data types)
     * and is only needed if you are going to build the tuples with
     * heap_formtuple() rather than with BuildTupleFromCStrings().  Note that
     * the TupleDesc pointer stored here should usually have been run through
     * BlessTupleDesc() first.
     */
    TupleDesc tuple_desc;

2107
} FuncCallContext;
2108
</programlisting>
2109 2110 2111
    </para>

    <para>
2112 2113 2114
     An <acronym>SRF</> uses several functions and macros that
     automatically manipulate the <structname>FuncCallContext</>
     structure (and expect to find it via <literal>fn_extra</>).  Use
2115 2116 2117
<programlisting>
SRF_IS_FIRSTCALL()
</programlisting>
2118
     to determine if your function is being called for the first or a
2119 2120 2121 2122
     subsequent time. On the first call (only) use
<programlisting>
SRF_FIRSTCALL_INIT()
</programlisting>
2123
     to initialize the <structname>FuncCallContext</>. On every function call,
2124 2125 2126 2127
     including the first, use
<programlisting>
SRF_PERCALL_SETUP()
</programlisting>
2128 2129 2130
     to properly set up for using the <structname>FuncCallContext</>
     and clearing any previously returned data left over from the
     previous pass.
2131 2132 2133 2134 2135 2136 2137
    </para>

    <para>
     If your function has data to return, use
<programlisting>
SRF_RETURN_NEXT(funcctx, result)
</programlisting>
2138
     to return it to the caller.  (<literal>result</> must be of type
2139
     <type>Datum</>, either a single value or a tuple prepared as
2140
     described above.)  Finally, when your function is finished
2141
     returning data, use
2142 2143 2144
<programlisting>
SRF_RETURN_DONE(funcctx)
</programlisting>
2145
     to clean up and end the <acronym>SRF</>.
2146 2147
    </para>

2148
    <para>
2149
     The memory context that is current when the <acronym>SRF</> is called is
2150
     a transient context that will be cleared between calls.  This means
2151 2152
     that you do not need to call <function>pfree</> on everything
     you allocated using <function>palloc</>; it will go away anyway.  However, if you want to allocate
2153 2154 2155
     any data structures to live across calls, you need to put them somewhere
     else.  The memory context referenced by
     <structfield>multi_call_memory_ctx</> is a suitable location for any
2156
     data that needs to survive until the <acronym>SRF</> is finished running.  In most
2157 2158 2159 2160
     cases, this means that you should switch into
     <structfield>multi_call_memory_ctx</> while doing the first-call setup.
    </para>

2161 2162 2163 2164
    <para>
     A complete pseudo-code example looks like the following:
<programlisting>
Datum
2165
my_set_returning_function(PG_FUNCTION_ARGS)
2166
{
2167 2168 2169
    FuncCallContext  *funcctx;
    Datum             result;
    MemoryContext     oldcontext;
2170
    <replaceable>further declarations as needed</replaceable>
2171 2172 2173

    if (SRF_IS_FIRSTCALL())
    {
2174 2175
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
2176 2177 2178 2179 2180 2181
        /* One-time setup code appears here: */
        <replaceable>user code</replaceable>
        <replaceable>if returning composite</replaceable>
            <replaceable>build TupleDesc, and perhaps AttInMetadata</replaceable>
        <replaceable>endif returning composite</replaceable>
        <replaceable>user code</replaceable>
2182
        MemoryContextSwitchTo(oldcontext);
2183 2184
    }

2185 2186
    /* Each-time setup code appears here: */
    <replaceable>user code</replaceable>
2187
    funcctx = SRF_PERCALL_SETUP();
2188
    <replaceable>user code</replaceable>
2189 2190 2191 2192

    /* this is just one way we might test whether we are done: */
    if (funcctx-&gt;call_cntr &lt; funcctx-&gt;max_calls)
    {
2193 2194 2195
        /* Here we want to return another item: */
        <replaceable>user code</replaceable>
        <replaceable>obtain result Datum</replaceable>
2196 2197 2198 2199
        SRF_RETURN_NEXT(funcctx, result);
    }
    else
    {
2200 2201
        /* Here we are done returning items and just need to clean up: */
        <replaceable>user code</replaceable>
2202 2203
        SRF_RETURN_DONE(funcctx);
    }
2204 2205 2206 2207 2208
}
</programlisting>
    </para>

    <para>
2209
     A complete example of a simple <acronym>SRF</> returning a composite type looks like:
2210 2211
<programlisting>
PG_FUNCTION_INFO_V1(testpassbyval);
2212

2213 2214 2215
Datum
testpassbyval(PG_FUNCTION_ARGS)
{
2216 2217 2218 2219 2220 2221 2222 2223 2224
    FuncCallContext     *funcctx;
    int                  call_cntr;
    int                  max_calls;
    TupleDesc            tupdesc;
    AttInMetadata       *attinmeta;

     /* stuff done only on the first call of the function */
     if (SRF_IS_FIRSTCALL())
     {
2225 2226
        MemoryContext	oldcontext;

2227
        /* create a function context for cross-call persistence */
2228 2229 2230 2231
        funcctx = SRF_FIRSTCALL_INIT();

        /* switch to memory context appropriate for multiple function calls */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
2232 2233 2234 2235

        /* total number of tuples to be returned */
        funcctx-&gt;max_calls = PG_GETARG_UINT32(0);

2236
        /* Build a tuple description for a __testpassbyval tuple */
2237 2238 2239
        tupdesc = RelationNameGetTupleDesc("__testpassbyval");

        /*
2240
         * generate attribute metadata needed later to produce tuples from raw
2241 2242 2243 2244
         * C strings
         */
        attinmeta = TupleDescGetAttInMetadata(tupdesc);
        funcctx-&gt;attinmeta = attinmeta;
2245 2246

        MemoryContextSwitchTo(oldcontext);
2247 2248
    }

2249 2250
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
2251

2252 2253 2254
    call_cntr = funcctx-&gt;call_cntr;
    max_calls = funcctx-&gt;max_calls;
    attinmeta = funcctx-&gt;attinmeta;
2255
 
2256 2257 2258 2259 2260 2261 2262
    if (call_cntr &lt; max_calls)    /* do when there is more left to send */
    {
        char       **values;
        HeapTuple    tuple;
        Datum        result;

        /*
2263
         * Prepare a values array for building the returned tuple.
2264
         * This should be an array of C strings which will
2265
         * be processed later by the type input functions.
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
         */
        values = (char **) palloc(3 * sizeof(char *));
        values[0] = (char *) palloc(16 * sizeof(char));
        values[1] = (char *) palloc(16 * sizeof(char));
        values[2] = (char *) palloc(16 * sizeof(char));

        snprintf(values[0], 16, "%d", 1 * PG_GETARG_INT32(1));
        snprintf(values[1], 16, "%d", 2 * PG_GETARG_INT32(1));
        snprintf(values[2], 16, "%d", 3 * PG_GETARG_INT32(1));

        /* build a tuple */
        tuple = BuildTupleFromCStrings(attinmeta, values);

        /* make the tuple into a datum */
2280
        result = HeapTupleGetDatum(tuple);
2281

2282
        /* clean up (this is not really necessary) */
2283 2284 2285 2286 2287
        pfree(values[0]);
        pfree(values[1]);
        pfree(values[2]);
        pfree(values);

2288
        SRF_RETURN_NEXT(funcctx, result);
2289 2290 2291
    }
    else    /* do when there is no more left */
    {
2292
        SRF_RETURN_DONE(funcctx);
2293
    }
2294 2295
}
</programlisting>
2296 2297

     The SQL code to declare this function is:
2298
<programlisting>
2299
CREATE TYPE __testpassbyval AS (f1 integer, f2 integer, f3 integer);
2300

2301 2302 2303
CREATE OR REPLACE FUNCTION testpassbyval(integer, integer) RETURNS SETOF __testpassbyval
    AS '<replaceable>filename</>', 'testpassbyval'
    LANGUAGE C IMMUTABLE STRICT;
2304
</programlisting>
2305
    </para>
2306

2307
    <para>
2308 2309
     The directory <filename>contrib/tablefunc</> in the source
     distribution contains more examples of set-returning functions.
2310 2311
    </para>
   </sect2>
2312 2313 2314 2315 2316 2317

   <sect2>
    <title>Polymorphic Arguments and Return Types</title>

    <para>
     C-language functions may be declared to accept and
Peter Eisentraut's avatar
Peter Eisentraut committed
2318
     return the polymorphic types
2319
     <type>anyelement</type> and <type>anyarray</type>.
Peter Eisentraut's avatar
Peter Eisentraut committed
2320
     See <xref linkend="extend-types-polymorphic"> for a more detailed explanation
2321 2322 2323 2324 2325 2326 2327 2328
     of polymorphic functions. When function arguments or return types
     are defined as polymorphic types, the function author cannot know
     in advance what data type it will be called with, or
     need to return. There are two routines provided in <filename>fmgr.h</>
     to allow a version-1 C function to discover the actual data types
     of its arguments and the type it is expected to return. The routines are
     called <literal>get_fn_expr_rettype(FmgrInfo *flinfo)</> and
     <literal>get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)</>.
2329
     They return the result or argument type OID, or <symbol>InvalidOid</symbol> if the
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
     information is not available.
     The structure <literal>flinfo</> is normally accessed as
     <literal>fcinfo-&gt;flinfo</>. The parameter <literal>argnum</>
     is zero based.
    </para>

    <para>
     For example, suppose we want to write a function to accept a single
     element of any type, and return a one-dimensional array of that type:

<programlisting>
PG_FUNCTION_INFO_V1(make_array);
Datum
make_array(PG_FUNCTION_ARGS)
{
    ArrayType  *result;
    Oid         element_type = get_fn_expr_argtype(fcinfo-&gt;flinfo, 0);
    Datum       element;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    int         ndims;
    int         dims[MAXDIM];
    int         lbs[MAXDIM];

    if (!OidIsValid(element_type))
        elog(ERROR, "could not determine data type of input");

    /* get the provided element */
    element = PG_GETARG_DATUM(0);

    /* we have one dimension */
    ndims = 1;
    /* and one element */
    dims[0] = 1;
    /* and lower bound is 1 */
    lbs[0] = 1;

    /* get required info about the element type */
    get_typlenbyvalalign(element_type, &amp;typlen, &amp;typbyval, &amp;typalign);

    /* now build the array */
    result = construct_md_array(&amp;element, ndims, dims, lbs,
                                element_type, typlen, typbyval, typalign);

    PG_RETURN_ARRAYTYPE_P(result);
}
</programlisting>
    </para>

    <para>
     The following command declares the function
     <function>make_array</function> in SQL:

<programlisting>
Peter Eisentraut's avatar
Peter Eisentraut committed
2385
CREATE FUNCTION make_array(anyelement) RETURNS anyarray
2386
    AS '<replaceable>DIRECTORY</replaceable>/funcs', 'make_array'
Peter Eisentraut's avatar
Peter Eisentraut committed
2387
    LANGUAGE C STRICT;
2388 2389
</programlisting>

Peter Eisentraut's avatar
Peter Eisentraut committed
2390 2391
     Note the use of <literal>STRICT</literal>; this is essential
     since the code is not bothering to test for a null input.
2392 2393
    </para>
   </sect2>
2394 2395
  </sect1>

2396
  <sect1 id="xfunc-overload">
2397 2398
   <title>Function Overloading</title>

Peter Eisentraut's avatar
Peter Eisentraut committed
2399 2400 2401 2402
   <indexterm zone="xfunc-overload">
    <primary>overloading</primary>
    <secondary>functions</secondary>
   </indexterm>
2403

2404
   <para>
2405
    More than one function may be defined with the same SQL name, so long
Peter Eisentraut's avatar
Peter Eisentraut committed
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423
    as the arguments they take are different.  In other words,
    function names can be <firstterm>overloaded</firstterm>.  When a
    query is executed, the server will determine which function to
    call from the data types and the number of the provided arguments.
    Overloading can also be used to simulate functions with a variable
    number of arguments, up to a finite maximum number.
   </para>

   <para>
    When creating a family of overloaded functions, one should be
    careful not to create ambiguities.  For instance, given the
    functions
<programlisting>
CREATE FUNCTION test(int, real) RETURNS ...
CREATE FUNCTION test(smallint, double precision) RETURNS ...
</programlisting>
    it is not immediately clear which function would be called with
    some trivial input like <literal>test(1, 1.5)</literal>.  The
2424
    currently implemented resolution rules are described in
2425
    <xref linkend="typeconv">, but it is unwise to design a system that subtly
2426
    relies on this behavior.
Peter Eisentraut's avatar
Peter Eisentraut committed
2427
   </para>
2428

2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
   <para>
    A function that takes a single argument of a composite type should
    generally not have the same name as any attribute (field) of that type.
    Recall that <literal>attribute(table)</literal> is considered equivalent
    to <literal>table.attribute</literal>.  In the case that there is an
    ambiguity between a function on a composite type and an attribute of
    the composite type, the attribute will always be used.  It is possible
    to override that choice by schema-qualifying the function name
    (that is, <literal>schema.func(table)</literal>) but it's better to
    avoid the problem by not choosing conflicting names.
   </para>

Peter Eisentraut's avatar
Peter Eisentraut committed
2441
   <para>
2442
    When overloading C-language functions, there is an additional
Peter Eisentraut's avatar
Peter Eisentraut committed
2443 2444 2445 2446 2447 2448 2449 2450
    constraint: The C name of each function in the family of
    overloaded functions must be different from the C names of all
    other functions, either internal or dynamically loaded.  If this
    rule is violated, the behavior is not portable.  You might get a
    run-time linker error, or one of the functions will get called
    (usually the internal one).  The alternative form of the
    <literal>AS</> clause for the SQL <command>CREATE
    FUNCTION</command> command decouples the SQL function name from
2451
    the function name in the C source code.  For instance,
Peter Eisentraut's avatar
Peter Eisentraut committed
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
<programlisting>
CREATE FUNCTION test(int) RETURNS int
    AS '<replaceable>filename</>', 'test_1arg'
    LANGUAGE C;
CREATE FUNCTION test(int, int) RETURNS int
    AS '<replaceable>filename</>', 'test_2arg'
    LANGUAGE C;
</programlisting>
    The names of the C functions here reflect one of many possible conventions.
   </para>
2462
  </sect1>
2463

2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
  <sect1 id="xfunc-volatility">
   <title>Function Volatility Categories</title>

   <indexterm zone="xfunc-volatility">
    <primary>volatility</primary>
    <secondary>functions</secondary>
   </indexterm>

   <para>
    Every function has a <firstterm>volatility</> classification, with
    the possibilities being <literal>VOLATILE</>, <literal>STABLE</>, or
    <literal>IMMUTABLE</>.  <literal>VOLATILE</> is the default if the
    <command>CREATE FUNCTION</command> command does not specify a category.
    The volatility category is a promise to the optimizer about the behavior
    of the function:

   <itemizedlist>
    <listitem>
     <para>
      A <literal>VOLATILE</> function can do anything, including modifying
      the database.  It can return different results on successive calls with
      the same arguments.  The optimizer makes no assumptions about the
      behavior of such functions.  A query using a volatile function will
      re-evaluate the function at every row where its value is needed.
     </para>
    </listitem>
    <listitem>
     <para>
      A <literal>STABLE</> function cannot modify the database and is
      guaranteed to return the same results given the same arguments
      for all calls within a single surrounding query.  This category
      allows the optimizer to optimize away multiple calls of the function
      within a single query.  In particular, it is safe to use an expression
      containing such a function in an indexscan condition.  (Since an
      indexscan will evaluate the comparison value only once, not once at
      each row, it is not valid to use a <literal>VOLATILE</> function in
      an indexscan condition.)
     </para>
    </listitem>
    <listitem>
     <para>
      An <literal>IMMUTABLE</> function cannot modify the database and is
      guaranteed to return the same results given the same arguments forever.
      This category allows the optimizer to pre-evaluate the function when
      a query calls it with constant arguments.  For example, a query like
      <literal>SELECT ... WHERE x = 2 + 2</> can be simplified on sight to
      <literal>SELECT ... WHERE x = 4</>, because the function underlying
      the integer addition operator is marked <literal>IMMUTABLE</>.
     </para>
    </listitem>
   </itemizedlist>
   </para>

   <para>
    For best optimization results, you should label your functions with the
    strictest volatility category that is valid for them.
   </para>

   <para>
    Any function with side-effects <emphasis>must</> be labeled
    <literal>VOLATILE</>, so that calls to it cannot be optimized away.
    Even a function with no side-effects needs to be labeled
    <literal>VOLATILE</> if its value can change within a single query;
    some examples are <literal>random()</>, <literal>currval()</>,
    <literal>timeofday()</>.
   </para>

   <para>
    There is relatively little difference between <literal>STABLE</> and
    <literal>IMMUTABLE</> categories when considering simple interactive
    queries that are planned and immediately executed: it doesn't matter
    a lot whether a function is executed once during planning or once during
    query execution startup.  But there is a big difference if the plan is
    saved and reused later.  Labeling a function <literal>IMMUTABLE</> when
    it really isn't may allow it to be prematurely folded to a constant during
    planning, resulting in a stale value being re-used during subsequent uses
    of the plan.  This is a hazard when using prepared statements or when
    using function languages that cache plans (such as
    <application>PL/pgSQL</>).
   </para>

   <para>
    Because of the snapshotting behavior of MVCC (see <xref linkend="mvcc">)
    a function containing only <command>SELECT</> commands can safely be
    marked <literal>STABLE</>, even if it selects from tables that might be
    undergoing modifications by concurrent queries.
    <productname>PostgreSQL</productname> will execute a <literal>STABLE</>
    function using the snapshot established for the calling query, and so it
    will see a fixed view of the database throughout that query.
    Also note
    that the <function>current_timestamp</> family of functions qualify
    as stable, since their values do not change within a transaction.
   </para>

   <para>
    The same snapshotting behavior is used for <command>SELECT</> commands
    within <literal>IMMUTABLE</> functions.  It is generally unwise to select
    from database tables within an <literal>IMMUTABLE</> function at all,
    since the immutability will be broken if the table contents ever change.
    However, <productname>PostgreSQL</productname> does not enforce that you
    do not do that.
   </para>

   <para>
    A common error is to label a function <literal>IMMUTABLE</> when its
    results depend on a configuration parameter.  For example, a function
    that manipulates timestamps might well have results that depend on the
    <xref linkend="guc-timezone"> setting.  For safety, such functions should
    be labeled <literal>STABLE</> instead.
   </para>

   <note>
    <para>
     Before <productname>PostgreSQL</productname> release 8.0, the requirement
     that <literal>STABLE</> and <literal>IMMUTABLE</> functions cannot modify
     the database was not enforced by the system.  Release 8.0 enforces it
     by requiring SQL functions and procedural language functions of these
     categories to contain no SQL commands other than <command>SELECT</>.
    </para>
   </note>
  </sect1>

2586 2587
<!-- Keep this comment at the end of the file
Local variables:
2588
mode:sgml
2589 2590 2591 2592 2593 2594 2595 2596 2597
sgml-omittag:nil
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
sgml-parent-document:nil
sgml-default-dtd-file:"./reference.ced"
sgml-exposed-tags:nil
2598
sgml-local-catalogs:("/usr/lib/sgml/catalog")
2599 2600 2601
sgml-local-ecat-files:nil
End:
-->