From f45ec44c6b6acf2d649348901f7cbd4fe6c5bb8f Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Sun, 14 Mar 1999 15:24:15 +0000 Subject: [PATCH] Patches for the SGML documentation relating to the tutorial code changes. NOTE: I couldn't get ngsmls to find the document type so that the changes could be checked. However, the changes were very minor: Best, Clark --- doc/src/sgml/xfunc.sgml | 226 +++++++++++++++++++++++----------------- 1 file changed, 133 insertions(+), 93 deletions(-) diff --git a/doc/src/sgml/xfunc.sgml b/doc/src/sgml/xfunc.sgml index 3bc1539372..a59d15d08e 100644 --- a/doc/src/sgml/xfunc.sgml +++ b/doc/src/sgml/xfunc.sgml @@ -7,19 +7,20 @@ Consequently, while it is possible to define a new function without defining a new type, the reverse is not true. We therefore describe how to add new functions - to Postgres before describing how to add new - types. - Postgres SQL provides two types of functions: query - language functions (functions written in SQL and - programming language functions (functions written in a - compiled programming language such as C.) Either kind + to Postgres before describing + how to add new types. + Postgres SQL + provides two types of functions: query language functions + (functions written in SQL and programming + language functions (functions written in a compiled + programming language such as C.) Either kind of function can take a base type, a composite type or some combination as arguments (parameters). In addition, both kinds of functions can return a base type or - a composite type. It's easier to define SQL functions, - so we'll start with those. - Examples in this section can also be found in funcs.sql - and C-code/funcs.c. + a composite type. It's easier to define SQL + functions, so we'll start with those. Examples in this section + can also be found in funcs.sql + and funcs.c. @@ -54,8 +55,8 @@ instead of one. - It's almost as easy to define SQL functions that take - base types as arguments. In the example below, notice + It's almost as easy to define SQL functions + that take base types as arguments. In the example below, notice how we refer to the arguments within the function as $1 and $2. @@ -91,7 +92,8 @@ SELECT name, double_salary(EMP) AS dream FROM EMP - WHERE EMP.dept = 'toy'; + WHERE EMP.cubicle ~= '(2,1)'::point; + +-----+-------+ |name | dream | @@ -137,7 +139,7 @@ AS 'SELECT \'None\'::text AS name, 1000 AS salary, 25 AS age, - \'none\'::text AS dept;' + \'(2,2)\'::point AS cubicle' LANGUAGE 'sql'; @@ -153,18 +155,18 @@ -The target list order must be exactly the same as - that in which the attributes appear in the CREATE - TABLE statement (or when you execute a .* query). + The target list order must be exactly the same as + that in which the attributes appear in the CREATE + TABLE statement (or when you execute a .* query). -You must typecast the expressions - (using ::) very carefully or you will see the following error: +You must typecast the expressions (using ::) very carefully +or you will see the following error: - WARN::function declared to return type EMP does not retrieve (EMP.*) + WARN::function declared to return type EMP does not retrieve (EMP.*) @@ -202,11 +204,12 @@ The reason why, in general, we must use the function - Any collection of commands in the SQL query language - can be packaged together and defined as a function. - The commands can include updates (i.e., insert, update - and delete) as well as select queries. However, the - final command must be a select that returns whatever is + Any collection of commands in the SQL query + language can be packaged together and defined as a function. + The commands can include updates (i.e., insert, + update and delete) as well + as select queries. However, the final command + must be a select that returns whatever is specified as the function's returntype. @@ -222,6 +225,7 @@ The reason why, in general, we must use the function +--+ |1 | +--+ + @@ -234,12 +238,13 @@ The reason why, in general, we must use the function Programming Language Functions on Base Types - Internally, Postgres regards a base type as a "blob of - memory." The user-defined functions that you define - over a type in turn define the way that Postgres can - operate on it. That is, Postgres will only store and - retrieve the data from disk and use your user-defined - functions to input, process, and output the data. + Internally, Postgres regards a + base type as a "blob of memory." The user-defined + functions that you define over a type in turn define the + way that Postgres can operate + on it. That is, Postgres will + only store and retrieve the data from disk and use your + user-defined functions to input, process, and output the data. Base types can have one of three internal formats: pass by value, fixed-length @@ -254,14 +259,16 @@ The reason why, in general, we must use the function By-value types can only be 1, 2 or 4 bytes in length (even if your computer supports by-value types of other - sizes). Postgres itself only passes integer types by - value. You should be careful to define your types such - that they will be the same size (in bytes) on all - architectures. For example, the long type is dangerous - because it is 4 bytes on some machines and 8 bytes on - others, whereas int type is 4 bytes on most UNIX - machines (though not on most personal computers). A - reasonable implementation of the int4 type on UNIX + sizes). Postgres itself + only passes integer types by value. You should be careful + to define your types such that they will be the same + size (in bytes) on all architectures. For example, the + long type is dangerous because it + is 4 bytes on some machines and 8 bytes on others, whereas + int type is 4 bytes on most + UNIX machines (though not on most + personal computers). A reasonable implementation of + the int4 type on UNIX machines might be: @@ -277,9 +284,10 @@ The reason why, in general, we must use the function /* 16-byte structure, passed by reference */ - typedef struct { - char data[16]; - } char16; + typedef struct + { + double x, y; + } Point; @@ -308,10 +316,10 @@ The reason why, in general, we must use the function Obviously, the data field is not long enough to hold all possible strings -- it's impossible to declare such - a structure in C. When manipulating variable-length - types, we must be careful to allocate the correct - amount of memory and initialize the length field. For - example, if we wanted to store 40 bytes in a text + a structure in C. When manipulating + variable-length types, we must be careful to allocate + the correct amount of memory and initialize the length field. + For example, if we wanted to store 40 bytes in a text structure, we might use a code fragment like this: #include "postgres.h" @@ -332,23 +340,30 @@ The reason why, in general, we must use the function #include <string.h> #include "postgres.h" + + /* By Value */ + int add_one(int arg) { return(arg + 1); } - text * - concat_text(text *arg1, text *arg2) + + /* By Reference, Fixed Length */ + + Point * + makepoint(Point *pointx, Point *pointy ) { - int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ; - text *new_text = (text *) palloc(new_text_size); - - memset((void *) new_text, 0, new_text_size); - VARSIZE(new_text) = new_text_size; - strncpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ); - strncat(VARDATA(new_text), VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ); - return (new_text); + Point *new_point = (Point *) palloc(sizeof(Point)); + + new_point->x = pointx->x; + new_point->y = pointy->y; + + return new_point; } + + /* By Reference, Variable Length */ + text * copytext(text *t) { @@ -366,6 +381,19 @@ The reason why, in general, we must use the function VARSIZE(t)-VARHDRSZ); /* how many bytes */ return(new_t); } + + text * + concat_text(text *arg1, text *arg2) + { + int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ; + text *new_text = (text *) palloc(new_text_size); + + memset((void *) new_text, 0, new_text_size); + VARSIZE(new_text) = new_text_size; + strncpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1)-VARHDRSZ); + strncat(VARDATA(new_text), VARDATA(arg2), VARSIZE(arg2)-VARHDRSZ); + return (new_text); + } @@ -374,13 +402,16 @@ The reason why, in general, we must use the function CREATE FUNCTION add_one(int4) RETURNS int4 - AS 'PGROOT/tutorial/obj/funcs.so' LANGUAGE 'c'; + AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c'; + CREATE FUNCTION makepoint(point, point) RETURNS point + AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c'; + CREATE FUNCTION concat_text(text, text) RETURNS text - AS 'PGROOT/tutorial/obj/funcs.so' LANGUAGE 'c'; - + AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c'; + CREATE FUNCTION copytext(text) RETURNS text - AS 'PGROOT/tutorial/obj/funcs.so' LANGUAGE 'c'; + AS 'PGROOT/tutorial/funcs.so' LANGUAGE 'c'; @@ -399,11 +430,11 @@ The reason why, in general, we must use the function null fields. In addition, composite types that are part of an inheritance hierarchy may have different fields than other members of the same inheritance hierarchy. - Therefore, Postgres provides a procedural - interface for accessing fields of composite types from - C. - As Postgres processes a set of instances, each instance - will be passed into your function as an opaque structure of type TUPLE. + Therefore, Postgres provides + a procedural interface for accessing fields of composite types + from C. As Postgres processes + a set of instances, each instance will be passed into your + function as an opaque structure of type TUPLE. Suppose we want to write a function to answer the query * SELECT name, c_overpaid(EMP, 1500) AS overpaid @@ -414,9 +445,10 @@ The reason why, in general, we must use the function #include "postgres.h" - #include "libpq-fe.h" /* for TUPLE */ + #include "executor/executor.h" /* for GetAttributeByName() */ + bool - c_overpaid(TUPLE t,/* the current instance of EMP */ + c_overpaid(TupleTableSlot *t, /* the current instance of EMP */ int4 limit) { bool isnull = false; @@ -430,16 +462,17 @@ The reason why, in general, we must use the function - GetAttributeByName is the Postgres system function that + GetAttributeByName is the + Postgres system function that returns attributes out of the current instance. It has three arguments: the argument of type TUPLE passed into the function, the name of the desired attribute, and a return parameter that describes whether the attribute - is null. GetAttributeByName will align data properly - so you can cast its return value to the desired type. - For example, if you have an attribute name which is of - the type name, the GetAttributeByName call would look - like: + is null. GetAttributeByName will + align data properly so you can cast its return value to + the desired type. For example, if you have an attribute + name which is of the type name, the GetAttributeByName + call would look like: char *str; ... @@ -448,8 +481,8 @@ The reason why, in general, we must use the function - The following query lets Postgres know about the - c_overpaid function: + The following query lets Postgres + know about the c_overpaid function: * CREATE FUNCTION c_overpaid(EMP, int4) RETURNS bool AS 'PGROOT/tutorial/obj/funcs.so' LANGUAGE 'c'; @@ -470,24 +503,28 @@ The reason why, in general, we must use the function We now turn to the more difficult task of writing programming language functions. Be warned: this section of the manual will not make you a programmer. You must - have a good understanding of C (including the use of - pointers and the malloc memory manager) before trying - to write C functions for use with Postgres. - While it may be possible to load functions written in - languages other than C into Postgres, this is often - difficult (when it is possible at all) because other - languages, such as FORTRAN and Pascal often do not follow - the same "calling convention" as C. That is, other + have a good understanding of C + (including the use of pointers and the malloc memory manager) + before trying to write C functions for + use with Postgres. While it may + be possible to load functions written in languages other + than C into Postgres, + this is often difficult (when it is possible at all) + because other languages, such as FORTRAN + and Pascal often do not follow the same + "calling convention" as C. That is, other languages do not pass argument and return values between functions in the same way. For this reason, we will assume that your programming language functions are written in C. - The basic rules for building C functions are as follows: + The basic rules for building C functions + are as follows: -Most of the header (include) files for Postgres + Most of the header (include) files for + Postgres should already be installed in PGROOT/include (see Figure 2). You should always include @@ -511,9 +548,11 @@ Most of the header (include) files for Postgres - When allocating memory, use the Postgres + When allocating memory, use the + Postgres routines palloc and pfree instead of the - corresponding C library routines malloc and free. + corresponding C library routines + malloc and free. The memory allocated by palloc will be freed automatically at the end of each transaction, preventing memory leaks. @@ -531,15 +570,16 @@ Most of the header (include) files for Postgres - Most of the internal Postgres types are declared - in postgres.h, so it's a good idea to always - include that file as well. Including postgres.h - will also include elog.h and palloc.h for you. + Most of the internal Postgres + types are declared in postgres.h, so it's a good + idea to always include that file as well. Including + postgres.h will also include elog.h and palloc.h for you. - Compiling and loading your object code so that - it can be dynamically loaded into Postgres + Compiling and loading your object code so that + it can be dynamically loaded into + Postgres always requires special flags. See Appendix A for a detailed explanation of how to do it for your particular operating system. -- 2.40.0