Update of contrib stuff from massimo.

contrib/array/Makefile

+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for array iterator functions.
+#
+#-------------------------------------------------------------------------
+
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	array_iterator
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/array/array_iterator.doc

-From: Massimo Dal Zotto <dz@cs.unitn.it>
-Date: Mon, 6 May 1996 01:03:37 +0200 (MET DST)
-Subject: [PG95]: new operators for arrays
+Array iterator functions, by Massimo Dal Zotto <dz@cs.unitn.it>
 
-- -----BEGIN PGP SIGNED MESSAGE-----
+This loadable module defines a new class of functions which take
+an array and a scalar value, iterate a scalar operator over the
+elements of the array and the value, and compute a result as
+the logical OR or AND of the iteration results.
+For example array_int4eq returns true if some of the elements
+of an array of int4 is equal to the given value:
 
-Hi,
+	array_int4eq({1,2,3}, 1)  -->  true
+	array_int4eq({1,2,3}, 4)  -->  false
 
-I have written an extension to Postgres95 which allows to use qualification
-clauses based on the values of single elements of arrays.
-For example I can now select rows having some or all element of an array
+If we have defined T array types and O scalar operators we can
+define T x O x 2 array functions, each of them has a name like
+"array_[all_]<basetype><operation>" and takes an array of type T
+iterating the operator O over all the elements. Note however
+that some of the possible combination are invalid, for example
+the array_int4_like because there is no like operator for int4.
+
+We can then define new operators based on these functions and use
+them to write queries with qualification clauses based on the
+values of some of the elements of an array.
+For example to select rows having some or all element of an array
 attribute equal to a given value or matching a regular expression:
 
-select * from t where t.foo *= 'bar';
-select * from t where t.foo **~ '^ba[rz]';
+	create table t(id int4[], txt text[]);
+
+	-- select tuples with some id element equal to 123
+	select * from t where t.id *= 123;
+
+	-- select tuples with some txt element matching '[a-z]'
+	select * from t where t.txt *~ '[a-z]';
+
+	-- select tuples with all txt elements matching '^[A-Z]'
+	select * from t where t.txt[1:3] **~ '^[A-Z]';
 
-The scheme is quite general, each operator which operates on a base type can
-be iterated over the elements of an array. It seem to work well but defining
-each new operators requires writing a different C function. Furthermore in
-each function there are two hardcoded OIDs which reference a base type and
-a procedure. Not very portable. Can anyone suggest a better and more portable
-way to do it ?  Do you think this could be a useful feature for next release ?
-Here is my code, it can be compiled and loaded as a dynamic module without
-need to recompile the backend. I have defined only the few operators I needed,
-the list can be extended. Feddback is welcome.
+The scheme is quite general, each operator which operates on a base type
+can be iterated over the elements of an array. It seem to work well but
+defining each new operators requires writing a different C function.
+Furthermore in each function there are two hardcoded OIDs which reference
+a base type and a procedure. Not very portable. Can anyone suggest a
+better and more portable way to do it ?
 
+See also array_iterator.sql for an example on how to use this module.

contrib/array/array_iterator.h

+#ifndef ARRAY_ITERATOR_H
+#define ARRAY_ITERATOR_H
+
+static int32 array_iterator(Oid elemtype, Oid proc, int and, 
+			    ArrayType *array, Datum value);
+int32 array_texteq(ArrayType *array, char* value);
+int32 array_all_texteq(ArrayType *array, char* value);
+int32 array_textregexeq(ArrayType *array, char* value);
+int32 array_all_textregexeq(ArrayType *array, char* value);
+int32 array_char16eq(ArrayType *array, char* value);
+int32 array_all_char16eq(ArrayType *array, char* value);
+int32 array_char16regexeq(ArrayType *array, char* value);
+int32 array_all_char16regexeq(ArrayType *array, char* value);
+int32 array_int4eq(ArrayType *array, int4 value);
+int32 array_all_int4eq(ArrayType *array, int4 value);
+int32 array_int4ne(ArrayType *array, int4 value);
+int32 array_all_int4ne(ArrayType *array, int4 value);
+int32 array_int4gt(ArrayType *array, int4 value);
+int32 array_all_int4gt(ArrayType *array, int4 value);
+int32 array_int4ge(ArrayType *array, int4 value);
+int32 array_all_int4ge(ArrayType *array, int4 value);
+int32 array_int4lt(ArrayType *array, int4 value);
+int32 array_all_int4lt(ArrayType *array, int4 value);
+int32 array_int4le(ArrayType *array, int4 value);
+int32 array_all_int4le(ArrayType *array, int4 value);
+
+#endif

contrib/array/array_iterator.sql.in

+-- SQL code to define the new array iterator functions and operators
+
+-- define the array operators *=, **=, *~ and **~ for type _text
+--
+create function array_texteq(_text, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_texteq(_text, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_textregexeq(_text, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_textregexeq(_text, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create operator *= (
+  leftarg=_text, 
+  rightarg=text, 
+  procedure=array_texteq);
+
+create operator **= (
+  leftarg=_text,
+  rightarg=text,
+  procedure=array_all_texteq);
+
+create operator *~ (
+  leftarg=_text,
+  rightarg=text,
+  procedure=array_textregexeq);
+
+create operator **~ (
+  leftarg=_text,
+  rightarg=text,
+  procedure=array_all_textregexeq);
+
+
+-- define the array operators *=, **=, *~ and **~ for type _char16
+--
+create function array_char16eq(_char16, char16) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_char16eq(_char16, char16) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_char16regexeq(_char16, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_char16regexeq(_char16, text) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create operator *= (
+  leftarg=_char16,
+  rightarg=char16,
+  procedure=array_char16eq);
+
+create operator **= (
+  leftarg=_char16,
+  rightarg=char16,
+  procedure=array_all_char16eq);
+
+create operator *~ (
+  leftarg=_char16,
+  rightarg=text,
+  procedure=array_char16regexeq);
+
+create operator **~ (
+  leftarg=_char16,
+  rightarg=text,
+  procedure=array_all_char16regexeq);
+
+
+-- define the array operators *=, **=, *> and **> for type _int4
+--
+create function array_int4eq(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4eq(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_int4ne(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4ne(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_int4gt(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4gt(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_int4ge(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4ge(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_int4lt(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4lt(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_int4le(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function array_all_int4le(_int4, int4) returns bool
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create operator *= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4eq);
+
+create operator **= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4eq);
+
+create operator *<> (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4ne);
+
+create operator **<> (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4ne);
+
+create operator *> (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4gt);
+
+create operator **> (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4gt);
+
+create operator *>= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4ge);
+
+create operator **>= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4ge);
+
+create operator *< (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4lt);
+
+create operator **< (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4lt);
+
+create operator *<= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_int4le);
+
+create operator **<= (
+  leftarg=_int4,
+  rightarg=int4,
+  procedure=array_all_int4le);
+
+-- end of file

contrib/datetime/Makefile

-D=/usr/postgres
-P=$D/lib/datetime_functions.so
-CFLAGS=-fpic -O -I../../src/include -I../../src/backend
+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for new date/time functions.
+#
+#-------------------------------------------------------------------------
 
-all: $P datetime_functions.sql
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
 
-$P:datetime_functions.o 
-	ld -Bshareable -o $P datetime_functions.o 
+include $(SRCDIR)/Makefile.global
 
-datetime_functions.sql: datetime.prot
-	sh datetime.prot $P
-	psql -c "\idatetime_functions.sql" template1
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	datetime_functions
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/datetime/datetime_functions.c

@@ -6,113 +6,208 @@
  * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
  */
 
-#include <time.h>
+#include <stdio.h>		/* for sprintf() */
+#include <string.h>
+#include <limits.h>
+#ifdef HAVE_FLOAT_H
+#include <float.h>
+#endif
 
 #include "postgres.h"
-#include "utils/palloc.h"
+#include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/nabstime.h"
 #include "utils/datetime.h"
+#include "access/xact.h"
 
+#include "datetime_functions.h"
 
-TimeADT    *
-time_difference(TimeADT *time1, TimeADT *time2)
+/* Constant to replace calls to date2j(2000,1,1) */
+#define JDATE_2000	2451545
+
+/*
+ * A modified version of time_in which allows the value 24:00:00 for
+ * time and converts it to TimeADT data type forcing seconds to 0.
+ * This can be Useful if you need to handle TimeADT values limited
+ * to hh:mm like in timetables.
+ */
+
+TimeADT *
+hhmm_in(char *str)
+{
+    TimeADT *time;
+
+    double fsec;
+    struct tm tt, *tm = &tt;
+
+    int nf;
+    char lowstr[MAXDATELEN+1];
+    char *field[MAXDATEFIELDS];
+    int dtype;
+    int ftype[MAXDATEFIELDS];
+
+    if (!PointerIsValid(str))
+        elog(WARN,"Bad (null) time external representation",NULL);
+
+    if ((ParseDateTime( str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
+     || (DecodeTimeOnly( field, ftype, nf, &dtype, tm, &fsec) != 0))
+        elog(WARN,"Bad time external representation '%s'",str);
+
+    if (tm->tm_hour<0 || tm->tm_hour>24 || 
+	(tm->tm_hour==24 && (tm->tm_min!=0 || tm->tm_sec!=0 || fsec!= 0))) {
+        elog(WARN,
+	     "time_in: hour must be limited to values 0 through 24:00 "
+	     "in \"%s\"",
+	     str);
+    }
+    if ((tm->tm_min < 0) || (tm->tm_min > 59))
+	elog(WARN,"Minute must be limited to values 0 through 59 in '%s'",str);
+    if ((tm->tm_sec < 0) || ((tm->tm_sec + fsec) >= 60))
+	elog(WARN,"Second must be limited to values 0 through < 60 in '%s'",
+	     str);
+
+    time = PALLOCTYPE(TimeADT);
+
+    *time = ((((tm->tm_hour*60)+tm->tm_min)*60));
+
+    return(time);
+}
+
+/*
+ * A modified version of time_out which converts from TimeADT data type
+ * omitting the seconds field when it is 0.
+ * Useful if you need to handle TimeADT values limited to hh:mm.
+ */
+
+char *
+hhmm_out(TimeADT *time)
 {
-	TimeADT    *result = (TimeADT *) palloc(sizeof(TimeADT));
+    char *result;
+    struct tm tt, *tm = &tt;
+    char buf[MAXDATELEN+1];
+
+    if (!PointerIsValid(time))
+	return NULL;
+
+    tm->tm_hour = (*time / (60*60));
+    tm->tm_min = (((int) (*time / 60)) % 60);
+    tm->tm_sec = (((int) *time) % 60);
+
+    if (tm->tm_sec == 0) {
+	sprintf(buf, "%02d:%02d", tm->tm_hour, tm->tm_min);
+    } else {
+	sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
+    }
 
-	*result = *time1 - *time2;
-	return (result);
+    result = PALLOC(strlen(buf)+1);
+
+    strcpy( result, buf);
+
+    return(result);
 }
 
-TimeADT    *
-currenttime()
+TimeADT *
+hhmm(TimeADT *time)
 {
-	time_t		current_time;
-	struct tm  *tm;
-	TimeADT    *result = (TimeADT *) palloc(sizeof(TimeADT));
-
-	current_time = time(NULL);
-	tm = localtime(&current_time);
-	*result = ((((tm->tm_hour * 60) + tm->tm_min) * 60) + tm->tm_sec);
-	return (result);
+    TimeADT *result = PALLOCTYPE(TimeADT);
+
+    *result = (((int) *time) / 60 * 60);
+
+    return(result);
 }
 
-DateADT
-currentdate()
+TimeADT *
+time_difference(TimeADT *time1, TimeADT *time2)
 {
-	time_t		current_time;
-	struct tm  *tm;
-	DateADT		result;
+    TimeADT *time = PALLOCTYPE(TimeADT);
 
-	current_time = time(NULL);
-	tm = localtime(&current_time);
+    *time = (*time1 - *time2);
+    return(time);
+}
+
+int4
+time_hours(TimeADT *time)
+{
+    return (((int) *time) / 3600);
+}
 
-	result = date2j(tm->tm_year, tm->tm_mon + 1, tm->tm_mday) -
-		date2j(100, 1, 1);
-	return (result);
+int4
+time_minutes(TimeADT *time)
+{
+    return ((((int) *time) / 60) % 60);
 }
 
 int4
-hours(TimeADT *time)
+time_seconds(TimeADT *time)
 {
-	return (*time / (60 * 60));
+    return (((int) *time) % 60);
 }
 
 int4
-minutes(TimeADT *time)
+as_minutes(TimeADT *time)
 {
-	return (((int) (*time / 60)) % 60);
+    return (((int) *time) / 60);
 }
 
 int4
-seconds(TimeADT *time)
+as_seconds(TimeADT *time)
 {
-	return (((int) *time) % 60);
+    return ((int) *time);
 }
 
 int4
-day(DateADT *date)
+date_day(DateADT val)
 {
-	struct tm	tm;
+    int year, month, day;
 
-	j2date((*date + date2j(2000, 1, 1)),
-		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
+    j2date(val + JDATE_2000, &year, &month, &day);
 
-	return (tm.tm_mday);
+    return (day);
 }
 
 int4
-month(DateADT *date)
+date_month(DateADT val)
 {
-	struct tm	tm;
+    int year, month, day;
 
-	j2date((*date + date2j(2000, 1, 1)),
-		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
+    j2date(val + JDATE_2000, &year, &month, &day);
 
-	return (tm.tm_mon);
+    return (month);
 }
 
 int4
-year(DateADT *date)
+date_year(DateADT val)
 {
-	struct tm	tm;
+    int year, month, day;
 
-	j2date((*date + date2j(2000, 1, 1)),
-		   &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
+    j2date(val + JDATE_2000, &year, &month, &day);
 
-	return (tm.tm_year);
+    return (year);
 }
 
-int4
-asminutes(TimeADT *time)
+TimeADT *
+currenttime()
 {
-	int			seconds = (int) *time;
+    TimeADT *result = PALLOCTYPE(TimeADT);
+    struct tm *tm;
+    time_t current_time;
+
+    current_time = time(NULL);
+    tm = localtime(&current_time);
+    *result = ((((tm->tm_hour*60)+tm->tm_min)*60)+tm->tm_sec);
 
-	return (seconds / 60);
+    return (result);
 }
 
-int4
-asseconds(TimeADT *time)
+DateADT
+currentdate()
 {
-	int			seconds = (int) *time;
+    DateADT date;
+    struct tm tt, *tm = &tt;
 
-	return (seconds);
+    GetCurrentTime(tm);
+    date = (date2j( tm->tm_year, tm->tm_mon, tm->tm_mday) - JDATE_2000);
+    return (date);
 }
+
+/* end of file */

contrib/datetime/datetime_functions.h

+#ifndef DATETIME_FUNCTIONS_H
+#define DATETIME_FUNCTIONS_H
+
+TimeADT *hhmm_in(char *str);
+char *hhmm_out(TimeADT *time);
+TimeADT *hhmm(TimeADT *time);
+TimeADT *time_difference(TimeADT *time1, TimeADT *time2);
+int4 time_hours(TimeADT *time);
+int4 time_minutes(TimeADT *time);
+int4 time_seconds(TimeADT *time);
+int4 as_minutes(TimeADT *time);
+int4 as_seconds(TimeADT *time);
+int4 date_day(DateADT val);
+int4 date_month(DateADT val);
+int4 date_year(DateADT val);
+TimeADT *currenttime(void);
+DateADT currentdate(void);
+
+#endif

contrib/datetime/datetime_functions.sql.in

+-- SQL code to define the new date and time functions and operators
+
+-- Define the new functions
+--
+create function hhmm_in(opaque) returns time
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function hhmm_out(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function hhmm(time) returns time
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function time_difference(time,time) returns time
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function time_hours(time) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function time_minutes(time) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function time_seconds(time) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function as_minutes(time) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function as_seconds(time) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function date_day(date) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function date_month(date) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function date_year(date) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function currenttime() returns time
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function currentdate() returns date
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+
+-- Define a new operator - for time
+--
+create operator - (
+  leftarg=time, 
+  rightarg=time, 
+  procedure=time_difference);
+
+
+-- Define functions to switch from time to hhmm representation
+--
+--   select hhmm_mode();
+--   select time_mode();
+--
+create function hhmm_mode() returns text
+  as 'update pg_type set typinput =''hhmm_in''  where typname=''time'';
+      update pg_type set typoutput=''hhmm_out'' where typname=''time''
+      select ''hhmm_mode''::text'
+  language 'sql';
+
+create function time_mode() returns text
+  as 'update pg_type set typinput =''time_in''  where typname=''time'';
+      update pg_type set typoutput=''time_out'' where typname=''time''
+      select ''time_mode''::text'
+  language 'sql';
+
+
+-- Use these to do the updates manually
+--
+-- update pg_type set typinput ='hhmm_in'  where typname='time';
+-- update pg_type set typoutput='hhmm_out' where typname='time';
+--
+-- update pg_type set typinput ='time_in'  where typname='time';
+-- update pg_type set typoutput='time_out' where typname='time';
+
+-- end of file

contrib/miscutil/Makefile

+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for array iterator functions.
+#
+#-------------------------------------------------------------------------
+
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	misc_utils
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql assert_test.so
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/miscutil/assert_test.c

+/*
+ * assert_test.c --
+ *
+ * This file tests Postgres assert checking.
+ *
+ * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
+ */
+
+#include "postgres.h"
+#include "assert_test.h"
+
+extern int assertTest(int val);
+extern int assertEnable(int val);
+
+int
+assert_enable(int val)
+{
+    return assertEnable(val);
+}
+
+int
+assert_test(int val)
+{
+    return assertTest(val);
+}
+
+/*
+
+-- Enable/disable Postgres assert checking.
+--
+create function assert_enable(int4) returns int4
+    as '/usr/local/pgsql/lib/assert_test.so'
+    language 'C';
+
+-- Test Postgres assert checking.
+--
+create function assert_test(int4) returns int4
+    as '/usr/local/pgsql/lib/assert_test.so'
+    language 'C';
+
+*/
+
+/* end of file */

contrib/miscutil/assert_test.h

+#ifndef ASSERT_TEST_H
+#define ASSERT_TEST_H
+
+int assert_enable(int val);
+int assert_test(int val);
+
+#endif

contrib/miscutil/misc_utils.c

+/*
+ * utils.c --
+ *
+ * This file defines various Postgres utility functions.
+ *
+ * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
+ */
+
+#include <unistd.h>
+
+#include "postgres.h"
+#include "utils/palloc.h"
+
+#include "misc_utils.h"
+
+extern int ExecutorLimit(int limit);
+extern void Async_Unlisten(char *relname, int pid);
+
+int
+query_limit(int limit)
+{
+    return ExecutorLimit(limit);
+}
+
+int
+backend_pid()
+{
+    return getpid();
+}
+
+int
+unlisten(char *relname)
+{
+    Async_Unlisten(relname, getpid());
+    return 0;
+}
+
+int
+max(int x, int y)
+{
+    return ((x > y) ? x : y);
+}
+
+int
+min(int x, int y)
+{
+    return ((x < y) ? x : y);
+}
+
+/* end of file */

contrib/miscutil/misc_utils.h

+#ifndef MISC_UTILS_H
+#define MISC_UTILS_H
+
+int query_limit(int limit);
+int backend_pid(void);
+int unlisten(char *relname);
+int max(int x, int y);
+int min(int x, int y);
+
+#endif

contrib/miscutil/misc_utils.sql.in

+-- SQL code to define the new array iterator functions and operators
+
+-- min(x,y)
+--
+create function min(int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- max(x,y)
+--
+create function max(int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Set the maximum number of tuples returned by a single query
+--
+create function query_limit(int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Return the pid of the backend
+--
+create function backend_pid() returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Unlisten from a relation
+--
+create function unlisten(name) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Unlisten from all relations for this backend
+--
+create function unlisten() returns int4
+  as 'delete from pg_listener where listenerpid = backend_pid();
+      select 0'
+  language 'sql';
+
+-- end of file

contrib/pginterface/README.orig

+
+
+   			      Pginterface 2.0
+
+Attached is a copy of the Postgres support routines I wrote to allow me
+to more cleanly interface to the libpg library, more like a 4gl SQL
+interface.
+
+It has several features that may be useful for others:
+
+I have simplified the C code that calls libpq by wrapping all the
+functionality of libpq in calls to connectdb(), doquery(), fetch(),
+fetchwithnulls() and disconnectdb().  Each call returns a structure or
+value, so if you need to do more work with the result, you can.  Also, I
+have a global variable that allows you to disable the error checking I
+have added to the doquery() routine.
+
+I have added a function called fetch(), which allows you to pass
+pointers as parameters, and on return the variables are filled with the
+data from the binary cursor you opened.  These binary cursors are not
+useful if you are running the query engine on a system with a different
+architecture than the database server.  If you pass a NULL pointer, the
+column is skipped, and you can use libpq to handle it as you wish.
+
+I have used sigprocmask() to block the reception of certain signals
+while the program is executing SQL queries.  This prevents a user
+pressing Control-C from stopping all the back ends.  It blocks SIGHUP,
+SIGINT, and SIGTERM, but does not block SIGQUIT or obviously kill -9. 
+If your platform does not support sigprocmask(), you can remove those
+function calls.  ( Am I correct that abnormal termination can cause
+shared memory resynchronization?)
+
+There is a demo program called pginsert that demonstrates how the
+library can be used.
+
+You can create a library of pginterface.c and halt.c, and just include
+pginterface.h in your source code.
+
+I am willing to maintain this if people find problems or want additional
+functionality. 
+
+Bruce Momjian (root@candle.pha.pa.us)

contrib/pginterface/pginsert.c.orig

+/*
+ * insert.c
+ *
+*/
+
+#include <stdio.h>
+#include <signal.h>
+#include <time.h>
+#include <libpq-fe.h>
+#include "halt.h"
+#include "pginterface.h"
+
+int
+main(int argc, char **argv)
+{
+	char		query[4000];
+	int			row = 1;
+	int			aint;
+	float		afloat;
+	double		adouble;
+	char		achar[11],
+				achar16[17],
+				abpchar[11],
+				avarchar[51],
+				atext[51];
+	time_t		aabstime;
+
+	if (argc != 2)
+		halt("Usage:  %s database\n", argv[0]);
+
+	connectdb(argv[1], NULL, NULL, NULL, NULL);
+
+	on_error_continue();
+	doquery("DROP TABLE testfetch");
+	on_error_stop();
+
+	doquery("\
+		CREATE TABLE testfetch( \
+			aint 	int4, \
+			afloat 	float4, \
+			adouble float8, \
+			achar	char, \
+			achar16	char16, \
+			abpchar char(10), \
+			avarchar varchar(50), \
+			atext	text, \
+			aabstime abstime) \
+		");
+
+	while (1)
+	{
+		sprintf(query, "INSERT INTO testfetch VALUES ( \
+			%d, \
+			2322.12, \
+			'923121.0323'::float8, \
+			'A', \
+			'Betty', \
+			'Charley', \
+			'Doug', \
+			'Ernie', \
+			'now' )", row);
+		doquery(query);
+
+		doquery("BEGIN WORK");
+		doquery("DECLARE c_testfetch BINARY CURSOR FOR \
+					SELECT * FROM testfetch");
+
+		doquery("FETCH ALL IN c_testfetch");
+
+		while (fetch(
+					 &aint,
+					 &afloat,
+					 &adouble,
+					 achar,
+					 achar16,
+					 abpchar,
+					 avarchar,
+					 atext,
+					 &aabstime) != END_OF_TUPLES)
+			printf("int %d\nfloat %f\ndouble %f\nchar %s\nchar16 %s\n\
+bpchar %s\nvarchar %s\ntext %s\nabstime %s",
+				   aint,
+				   afloat,
+				   adouble,
+				   achar,
+				   achar16,
+				   abpchar,
+				   avarchar,
+				   atext,
+				   ctime(&aabstime));
+
+
+		doquery("CLOSE c_testfetch");
+		doquery("COMMIT WORK");
+		printf("--- %-d rows inserted so far\n", row);
+
+		row++;
+	}
+
+	disconnectdb();
+	return 0;
+}

contrib/pginterface/pginterface.c.orig

+/*
+ * pginterface.c
+ *
+*/
+
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <libpq-fe.h>
+#include "halt.h"
+#include "pginterface.h"
+
+static void sig_disconnect();
+static void set_signals();
+
+#define NUL '\0'
+
+/* GLOBAL VARIABLES */
+static PGconn *conn;
+static PGresult *res = NULL;
+
+#define ON_ERROR_STOP	0
+#define ON_ERROR_CONTINUE		1
+
+static int	on_error_state = ON_ERROR_STOP;
+
+/* LOCAL VARIABLES */
+static sigset_t block_sigs,
+			unblock_sigs;
+static int	tuple;
+
+/*
+**
+**		connectdb - returns PGconn structure
+**
+*/
+PGconn	   *
+connectdb(char *dbName,
+		  char *pghost,
+		  char *pgport,
+		  char *pgoptions,
+		  char *pgtty)
+{
+	/* make a connection to the database */
+	conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName);
+	if (PQstatus(conn) == CONNECTION_BAD)
+		halt("Connection to database '%s' failed.\n%s\n", dbName,
+			 PQerrorMessage(conn));
+	set_signals();
+	return conn;
+}
+
+/*
+**
+**		disconnectdb
+**
+*/
+void
+disconnectdb()
+{
+	PQfinish(conn);
+}
+
+/*
+**
+**		doquery - returns PGresult structure
+**
+*/
+PGresult   *
+doquery(char *query)
+{
+	if (res != NULL)
+		PQclear(res);
+
+	sigprocmask(SIG_SETMASK, &block_sigs, NULL);
+	res = PQexec(conn, query);
+	sigprocmask(SIG_SETMASK, &unblock_sigs, NULL);
+
+	if (on_error_state == ON_ERROR_STOP &&
+		(res == NULL ||
+		 PQresultStatus(res) == PGRES_BAD_RESPONSE ||
+		 PQresultStatus(res) == PGRES_NONFATAL_ERROR ||
+		 PQresultStatus(res) == PGRES_FATAL_ERROR))
+	{
+		if (res != NULL)
+			fprintf(stderr, "query error:  %s\n", PQcmdStatus(res));
+		else
+			fprintf(stderr, "connection error:  %s\n", PQerrorMessage(conn));
+		PQfinish(conn);
+		halt("failed request:  %s\n", query);
+	}
+	tuple = 0;
+	return res;
+}
+
+/*
+**
+**		fetch - returns tuple number (starts at 0), or the value END_OF_TUPLES
+**						NULL pointers are skipped
+**
+*/
+int
+fetch(void *param,...)
+{
+	va_list		ap;
+	int			arg,
+				num_fields;
+
+	num_fields = PQnfields(res);
+
+	if (tuple >= PQntuples(res))
+		return END_OF_TUPLES;
+
+	va_start(ap, param);
+	for (arg = 0; arg < num_fields; arg++)
+	{
+		if (param != NULL)
+		{
+			if (PQfsize(res, arg) == -1)
+			{
+				memcpy(param, PQgetvalue(res, tuple, arg), PQgetlength(res, tuple, arg));
+				((char *) param)[PQgetlength(res, tuple, arg)] = NUL;
+			}
+			else
+				memcpy(param, PQgetvalue(res, tuple, arg), PQfsize(res, arg));
+		}
+		param = va_arg(ap, char *);
+	}
+	va_end(ap);
+	return tuple++;
+}
+
+/*
+**
+**		fetchwithnulls - returns tuple number (starts at 0),
+**																						or the value END_OF_TUPLES
+**								Returns true or false into null indicator variables
+**								NULL pointers are skipped
+*/
+int
+fetchwithnulls(void *param,...)
+{
+	va_list		ap;
+	int			arg,
+				num_fields;
+
+	num_fields = PQnfields(res);
+
+	if (tuple >= PQntuples(res))
+		return END_OF_TUPLES;
+
+	va_start(ap, param);
+	for (arg = 0; arg < num_fields; arg++)
+	{
+		if (param != NULL)
+		{
+			if (PQfsize(res, arg) == -1)
+			{
+				memcpy(param, PQgetvalue(res, tuple, arg), PQgetlength(res, tuple, arg));
+				((char *) param)[PQgetlength(res, tuple, arg)] = NUL;
+			}
+			else
+				memcpy(param, PQgetvalue(res, tuple, arg), PQfsize(res, arg));
+		}
+		param = va_arg(ap, char *);
+		if (PQgetisnull(res, tuple, arg) != 0)
+			*(int *) param = 1;
+		else
+			*(int *) param = 0;
+		param = va_arg(ap, char *);
+	}
+	va_end(ap);
+	return tuple++;
+}
+
+/*
+**
+**		on_error_stop
+**
+*/
+void
+on_error_stop()
+{
+	on_error_state = ON_ERROR_STOP;
+}
+
+/*
+**
+**		on_error_continue
+**
+*/
+void
+on_error_continue()
+{
+	on_error_state = ON_ERROR_CONTINUE;
+}
+
+/*
+**
+**		sig_disconnect
+**
+*/
+static void
+sig_disconnect()
+{
+	fprintf(stderr, "exiting...\n");
+	PQfinish(conn);
+	exit(1);
+}
+
+/*
+**
+**		set_signals
+**
+*/
+static void
+set_signals()
+{
+	sigemptyset(&block_sigs);
+	sigemptyset(&unblock_sigs);
+	sigaddset(&block_sigs, SIGTERM);
+	sigaddset(&block_sigs, SIGHUP);
+	sigaddset(&block_sigs, SIGINT);
+/*		sigaddset(&block_sigs,SIGQUIT); no block */
+	sigprocmask(SIG_SETMASK, &unblock_sigs, NULL);
+	signal(SIGTERM, sig_disconnect);
+	signal(SIGHUP, sig_disconnect);
+	signal(SIGINT, sig_disconnect);
+	signal(SIGQUIT, sig_disconnect);
+}

contrib/pginterface/pgnulltest.c.orig

+/*
+ * pgnulltest.c
+ *
+*/
+
+#define TEST_NON_NULLS
+
+#include <stdio.h>
+#include <signal.h>
+#include <time.h>
+#include <halt.h>
+#include <libpq-fe.h>
+#include <pginterface.h>
+
+int
+main(int argc, char **argv)
+{
+	char		query[4000];
+	int			row = 1;
+	int			aint;
+	float		afloat;
+	double		adouble;
+	char		achar[11],
+				achar16[17],
+				abpchar[11],
+				avarchar[51],
+				atext[51];
+	time_t		aabstime;
+	int			aint_null,
+				afloat_null,
+				adouble_null,
+				achar_null,
+				achar16_null,
+				abpchar_null,
+				avarchar_null,
+				atext_null,
+				aabstime_null;
+
+	if (argc != 2)
+		halt("Usage:  %s database\n", argv[0]);
+
+	connectdb(argv[1], NULL, NULL, NULL, NULL);
+
+	on_error_continue();
+	doquery("DROP TABLE testfetch");
+	on_error_stop();
+
+	doquery("\
+        CREATE TABLE testfetch( \
+            aint    int4, \
+            afloat  float4, \
+            adouble float8, \
+            achar   char, \
+            achar16 char16, \
+            abpchar char(10), \
+            avarchar varchar(50), \
+            atext   text, \
+            aabstime abstime) \
+        ");
+
+#ifdef TEST_NON_NULLS
+	sprintf(query, "INSERT INTO testfetch VALUES ( \
+            0, \
+			0, \
+			0, \
+			'', \
+			'', \
+			'', \
+			'', \
+			'', \
+			'');");
+#else
+	sprintf(query, "INSERT INTO testfetch VALUES ( \
+            NULL, \
+			NULL, \
+			NULL, \
+			NULL, \
+			NULL, \
+			NULL, \
+			NULL, \
+			NULL, \
+			NULL);");
+#endif
+	doquery(query);
+
+	doquery("BEGIN WORK");
+	doquery("DECLARE c_testfetch BINARY CURSOR FOR \
+                    SELECT * FROM testfetch");
+
+	doquery("FETCH ALL IN c_testfetch");
+
+	if (fetchwithnulls(
+					   &aint,
+					   &aint_null,
+					   &afloat,
+					   &afloat_null,
+					   &adouble,
+					   &adouble_null,
+					   achar,
+					   &achar_null,
+					   achar16,
+					   &achar16_null,
+					   abpchar,
+					   &abpchar_null,
+					   avarchar,
+					   &avarchar_null,
+					   atext,
+					   &atext_null,
+					   &aabstime,
+					   &aabstime_null) != END_OF_TUPLES)
+		printf("int %d\nfloat %f\ndouble %f\nchar %s\nchar16 %s\n\
+bpchar %s\nvarchar %s\ntext %s\nabstime %s\n",
+			   aint,
+			   afloat,
+			   adouble,
+			   achar,
+			   achar16,
+			   abpchar,
+			   avarchar,
+			   atext,
+			   ctime(&aabstime));
+	printf("NULL:\nint %d\nfloat %d\ndouble %d\nchar %d\nchar16 %d\n\
+bpchar %d\nvarchar %d\ntext %d\nabstime %d\n",
+		   aint_null,
+		   afloat_null,
+		   adouble_null,
+		   achar_null,
+		   achar16_null,
+		   abpchar_null,
+		   avarchar_null,
+		   atext_null,
+		   aabstime_null);
+
+
+	doquery("CLOSE c_testfetch");
+	doquery("COMMIT WORK");
+	printf("--- %-d rows inserted so far\n", row);
+
+	row++;
+
+	disconnectdb();
+	return 0;
+}

contrib/pginterface/pgwordcount.c.orig

+/*
+ * wordcount.c
+ *
+*/
+
+#include <stdio.h>
+#include <signal.h>
+#include <time.h>
+#include "halt.h"
+#include <libpq-fe.h>
+#include "pginterface.h"
+
+int
+main(int argc, char **argv)
+{
+	char		query[4000];
+	int			row = 0;
+	int			count;
+	char		line[4000];
+
+	if (argc != 2)
+		halt("Usage:  %s database\n", argv[0]);
+
+	connectdb(argv[1], NULL, NULL, NULL, NULL);
+	on_error_continue();
+	doquery("DROP TABLE words");
+	on_error_stop();
+
+	doquery("\
+		CREATE TABLE words( \
+			matches	int4, \
+			word	text ) \
+		");
+	doquery("\
+		CREATE INDEX i_words_1 ON words USING btree ( \
+			word text_ops )\
+		");
+
+	while (1)
+	{
+		if (scanf("%s", line) != 1)
+			break;
+		doquery("BEGIN WORK");
+		sprintf(query, "\
+				DECLARE c_words BINARY CURSOR FOR \
+				SELECT count(*) \
+				FROM words \
+				WHERE word = '%s'", line);
+		doquery(query);
+		doquery("FETCH ALL IN c_words");
+
+		while (fetch(&count) == END_OF_TUPLES)
+			count = 0;
+		doquery("CLOSE c_words");
+		doquery("COMMIT WORK");
+
+		if (count == 0)
+			sprintf(query, "\
+				INSERT INTO words \
+				VALUES (1, '%s')", line);
+		else
+			sprintf(query, "\
+				UPDATE words \
+				SET matches = matches + 1 \
+				WHERE word = '%s'", line);
+		doquery(query);
+		row++;
+	}
+
+	disconnectdb();
+	return 0;
+}

contrib/sequence/Makefile

+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for new sequence functions.
+#
+#-------------------------------------------------------------------------
+
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	set_sequence
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/sequence/set_sequence.c

+/*
+ * set_sequence.c --
+ *
+ * Set a new sequence value.
+ *
+ * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
+ */
+
+#include "postgres.h"
+#include "nodes/parsenodes.h"
+#include "commands/sequence.h"
+
+#include "set_sequence.h"
+
+extern int setval(struct varlena *seqin, int4 val);
+
+int
+set_currval(struct varlena *sequence, int4 nextval)
+{
+    return setval(sequence, nextval);
+}
+
+int
+next_id(struct varlena *sequence)
+{
+    return nextval(sequence);
+}
+
+int
+last_id(struct varlena *sequence)
+{
+    return currval(sequence);
+}
+
+int
+set_last_id(struct varlena *sequence, int4 nextval)
+{
+    return setval(sequence, nextval);
+}
+
+/* end of file */

contrib/sequence/set_sequence.h

+#ifndef SET_SEQUENCE_H
+#define SET_SEQUENCE_H
+
+int set_currval(struct varlena *sequence, int4 nextval);
+int next_id(struct varlena *sequence);
+int last_id(struct varlena *sequence);
+int set_last_id(struct varlena *sequence, int4 nextval);
+
+#endif

contrib/sequence/set_sequence.sql.in

+-- SQL code to define new sequence utilities
+
+-- Set a new sequence value
+--
+create function set_currval(text, int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Increment the value of sequence
+--
+--	select next_id('sequence_name');
+--
+create function next_id(text) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Return the last value set for a sequence
+--
+--	select last_id('sequence_name');
+--
+create function last_id(text) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- Set the current value of a sequence
+--
+--	select set_last_id('sequence_name', 1);
+--
+create function set_last_id(text,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'C';
+
+-- end of file

contrib/string/Makefile

+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for new string I/O functions.
+#
+#-------------------------------------------------------------------------
+
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	string_io
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/string/string_io.h

+#ifndef STRING_IO_H
+#define STRING_IO_H
+
+char *string_output(char *data, int size);
+char *string_input(char *str, int size, int hdrsize, int *rtn_size);
+char *c_charout(int32 c);
+char *c_char2out(uint16 s);
+char *c_char4out(uint32 s);
+char *c_char8out(char *s);
+char *c_char16out(char *s);
+char *c_textout(struct varlena *vlena);
+char *c_varcharout(char *s);
+
+#if 0
+struct varlena *c_textin(char *str);
+char *c_char16in(char *str);
+#endif
+
+#endif

contrib/string/string_io.sql.in

+-- SQL code to define the new string I/O functions
+
+-- This is not needed because escapes are handled by the parser
+--
+-- create function c_textin(opaque)
+--   returns text
+--   as 'MODULE_PATHNAME' 
+--   language 'c';
+
+create function c_charout(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_char2out(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_char4out(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_char8out(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_char16out(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_textout(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+create function c_varcharout(opaque) returns int4
+  as 'MODULE_PATHNAME' 
+  language 'c';
+
+
+-- Define a function which sets the new output routines for char types
+--
+--   select c_mode();
+--
+create function c_mode() returns text
+  as 'update pg_type set typoutput=''c_charout''    where typname=''char'';
+      update pg_type set typoutput=''c_char2out''   where typname=''char2'';
+      update pg_type set typoutput=''c_char4out''   where typname=''char4'';
+      update pg_type set typoutput=''c_char8out''   where typname=''char8'';
+      update pg_type set typoutput=''c_char16out''  where typname=''char16'';
+      update pg_type set typoutput=''c_textout''    where typname=''text'';
+      update pg_type set typoutput=''c_textout''    where typname=''bytea'';
+      update pg_type set typoutput=''c_textout''    where typname=''unknown'';
+      update pg_type set typoutput=''c_textout''    where typname=''SET'';
+      update pg_type set typoutput=''c_varcharout'' where typname=''varchar'';
+      update pg_type set typoutput=''c_varcharout'' where typname=''bpchar'';
+      select ''c_mode''::text'
+  language 'sql';
+
+-- Define a function which restores the original routines for char types
+--
+--   select pg_mode();
+--
+create function pg_mode() returns text
+  as 'update pg_type set typoutput=''charout''    where typname=''char'';
+      update pg_type set typoutput=''char2out''   where typname=''char2'';
+      update pg_type set typoutput=''char4out''   where typname=''char4'';
+      update pg_type set typoutput=''char8out''   where typname=''char8'';
+      update pg_type set typoutput=''char16out''  where typname=''char16'';
+      update pg_type set typoutput=''textout''    where typname=''text'';
+      update pg_type set typoutput=''textout''    where typname=''bytea'';
+      update pg_type set typoutput=''textout''    where typname=''unknown'';
+      update pg_type set typoutput=''textout''    where typname=''SET'';
+      update pg_type set typoutput=''varcharout'' where typname=''varchar'';
+      update pg_type set typoutput=''varcharout'' where typname=''bpchar'';
+      select ''pg_mode''::text'
+  language 'sql';
+
+
+-- Use these if you want do the updates manually
+--
+-- update pg_type set typoutput='charout'    where typname='char';
+-- update pg_type set typoutput='char2out'   where typname='char2';
+-- update pg_type set typoutput='char4out'   where typname='char4';
+-- update pg_type set typoutput='char8out'   where typname='char8';
+-- update pg_type set typoutput='char16out'  where typname='char16';
+-- update pg_type set typoutput='textout'    where typname='text';
+-- update pg_type set typoutput='textout'    where typname='bytea';
+-- update pg_type set typoutput='textout'    where typname='unknown';
+-- update pg_type set typoutput='textout'    where typname='SET';
+-- update pg_type set typoutput='varcharout' where typname='varchar';
+-- update pg_type set typoutput='varcharout' where typname='bpchar';
+--
+-- update pg_type set typoutput='c_charout'    where typname='char';
+-- update pg_type set typoutput='c_char2out'   where typname='char2';
+-- update pg_type set typoutput='c_char4out'   where typname='char4';
+-- update pg_type set typoutput='c_char8out'   where typname='char8';
+-- update pg_type set typoutput='c_char16out'  where typname='char16';
+-- update pg_type set typoutput='c_textout'    where typname='text';
+-- update pg_type set typoutput='c_textout'    where typname='bytea';
+-- update pg_type set typoutput='c_textout'    where typname='unknown';
+-- update pg_type set typoutput='c_textout'    where typname='SET';
+-- update pg_type set typoutput='c_varcharout' where typname='varchar';
+-- update pg_type set typoutput='c_varcharout' where typname='bpchar';
+
+-- end of file

contrib/userlock/Makefile

+#-------------------------------------------------------------------------
+#
+# Makefile--
+#    Makefile for new string I/O functions.
+#
+#-------------------------------------------------------------------------
+
+PGDIR = ../..
+SRCDIR = $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+INCLUDE_OPT =	-I ./ \
+		-I $(SRCDIR)/ \
+		-I $(SRCDIR)/include \
+		-I $(SRCDIR)/port/$(PORTNAME)
+
+CFLAGS += $(INCLUDE_OPT)
+
+ifeq ($(PORTNAME), linux)
+  ifdef LINUX_ELF
+    ifeq ($(CC), gcc)
+      CFLAGS += -fPIC
+    endif
+  endif
+endif
+
+ifeq ($(PORTNAME), i386_solaris)
+  CFLAGS+= -fPIC
+endif
+
+MODNAME =	user_locks
+
+MODULE =	$(MODNAME)$(DLSUFFIX)
+
+all:		module sql
+
+module:		$(MODULE)
+
+sql:		$(MODNAME).sql
+
+install:	$(MODULE)
+		cp -p $(MODULE) $(LIBDIR)
+		cd $(LIBDIR); strip $(MODULE)
+
+%.sql: %.sql.in
+		sed "s|MODULE_PATHNAME|$(LIBDIR)/$(MODULE)|" < $< > $@
+
+.SUFFIXES: $(DLSUFFIX)
+
+%$(DLSUFFIX): %.c
+		cc $(CFLAGS) -shared -o $@ $<
+
+depend dep:
+		$(CC) -MM $(INCLUDE_OPT) *.c >depend
+
+clean:
+		rm -f $(MODULE) $(MODNAME).sql
+
+ifeq (depend,$(wildcard depend))
+include depend
+endif

contrib/userlock/user_locks.c

+/*
+ * user_locks.c --
+ *
+ * This loadable module, together with my user-lock.patch applied to the
+ * backend, provides support for user-level long-term cooperative locks.
+ *
+ * Copyright (c) 1996, Massimo Dal Zotto <dz@cs.unitn.it>
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "postgres.h"
+#include "miscadmin.h"
+#include "storage/lock.h"
+#include "storage/lmgr.h"
+#include "storage/proc.h"
+#include "storage/block.h"
+#include "storage/multilev.h"
+#include "utils/elog.h"
+
+#include "user_locks.h"
+
+#define USER_LOCKS_TABLE_ID	0
+
+extern Oid MyDatabaseId;
+
+int
+user_lock(unsigned int id1, unsigned int id2, LOCKT lockt)
+{
+    LOCKTAG tag;
+
+    memset(&tag,0,sizeof(LOCKTAG));
+    tag.relId = 0;
+    tag.dbId = MyDatabaseId;
+    tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
+    tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
+    tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
+
+    return LockAcquire(USER_LOCKS_TABLE_ID, &tag, lockt);
+}
+
+int
+user_unlock(unsigned int id1, unsigned int id2, LOCKT lockt)
+{
+    LOCKTAG tag;
+
+    memset(&tag, 0,sizeof(LOCKTAG));
+    tag.relId = 0;
+    tag.dbId = MyDatabaseId;
+    tag.tupleId.ip_blkid.bi_hi = id2 >> 16;
+    tag.tupleId.ip_blkid.bi_lo = id2 & 0xffff;
+    tag.tupleId.ip_posid = (unsigned short) (id1 & 0xffff);
+    
+    return LockRelease(USER_LOCKS_TABLE_ID, &tag, lockt);
+}
+
+int
+user_write_lock(unsigned int id1, unsigned int id2)
+{
+    return user_lock(id1, id2, WRITE_LOCK);
+}
+
+
+int
+user_write_unlock(unsigned int id1, unsigned int id2)
+{
+    return user_unlock(id1, id2, WRITE_LOCK);
+}
+
+int
+user_write_lock_oid(Oid oid)
+{
+    return user_lock(0, oid, WRITE_LOCK);
+}
+
+int
+user_write_unlock_oid(Oid oid)
+{
+    return user_unlock(0, oid, WRITE_LOCK);
+}
+
+int
+user_unlock_all()
+{
+    PROC	*proc;
+    SHMEM_OFFSET location;
+
+    ShmemPIDLookup(getpid(),&location);
+    if (location == INVALID_OFFSET) {
+	elog(NOTICE, "UserUnlockAll: unable to get proc ptr");
+	return -1;
+    }
+
+    proc = (PROC *) MAKE_PTR(location);
+    return LockReleaseAll(USER_LOCKS_TABLE_ID, &proc->lockQueue);
+}
+
+/* end of file */

contrib/userlock/user_locks.doc

+User locks, by Massimo Dal Zotto <dz@cs.unitn.it>
+
+This loadable module, together with my user-lock.patch applied to the
+backend, provides support for user-level long-term cooperative locks.
+
+For example one can write (this example is written in TclX):
+
+  set rec [sql "select ...,user_write_lock_oid(oid) from table where id=$id"]
+  if {[keylget rec user_write_lock_oid] == 1} {
+      # the write lock has been acquired with the record, start
+      # a long editing session, then update the database and
+      # release the lock.
+      sql "update table set ... where id=$id"
+      sql "select user_write_unlock_oid([keylget rec oid])"
+  } else {
+      # the record has been read but the write lock couldn't be acquired,
+      # so it should not be modified by the application.
+      messageBox "This record is in use by another user, retry later"
+  }
+
+This could also be done by setting a flag in the record itself but in
+this case you have the overhead of the updates to the record and there
+may be some locks not released if the backend or the application crashes
+before resetting the flag.
+It could also be done with a begin/end block but in this case the entire
+table would be locked by postgres and it is not acceptable to do this for
+a long period because other transactions would block completely.
+Note that this type of locks are handled cooperatively by the application
+and do not interfere with the normal locks used by postgres.  So an user
+could still modify an user-locked record if he wanted to ignore the lock.

contrib/userlock/user_locks.h

+#ifndef USER_LOCKS_H
+#define USER_LOCKS_H
+
+int user_lock(unsigned int id1, unsigned int id2, LOCKT lockt);
+int user_unlock(unsigned int id1, unsigned int id2, LOCKT lockt);
+int user_write_lock(unsigned int id1, unsigned int id2);
+int user_write_unlock(unsigned int id1, unsigned int id2);
+int user_write_lock_oid(Oid oid);
+int user_write_unlock_oid(Oid oid);
+int user_unlock_all(void);
+
+#endif

contrib/userlock/user_locks.sql.in

+-- SQL code to define the user locks functions
+
+-- select user_lock(group,id,type);
+--
+create function user_lock(int4,int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_unlock(group,id,type);
+--
+create function user_unlock(int4,int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_lock(group,id);
+--
+create function user_write_lock(int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_unlock(group,id);
+--
+create function user_write_unlock(int4,int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_lock(group,oid);
+--
+create function user_write_lock(int4,oid) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_unlock(group,oid);
+--
+create function user_write_unlock(int4,oid) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_lock_oid(oid);
+--
+create function user_write_lock_oid(oid) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_unlock_oid(oid);
+--
+create function user_write_unlock_oid(oid) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_lock_oid(int4);
+--
+create function user_write_lock_oid(int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_write_unlock_oid(int4);
+--
+create function user_write_unlock_oid(int4) returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- select user_unlock_all();
+--
+create function user_unlock_all() returns int4
+  as 'MODULE_PATHNAME'
+  language 'c';
+
+-- end of file