Revise aggregate functions per earlier discussions in pghackers.

There's now only one transition value and transition function.
NULL handling in aggregates is a lot cleaner.  Also, use Numeric
accumulators instead of integer accumulators for sum/avg on integer
datatypes --- this avoids overflow at the cost of being a little slower.
Implement VARIANCE() and STDDEV() aggregates in the standard backend.

Also, enable new LIKE selectivity estimators by default.  Unrelated
change, but as long as I had to force initdb anyway...

doc/src/sgml/catalogs.sgml

 .\" This is -*-nroff-*-
 .\" XXX standard disclaimer belongs here....
-.\" $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.6 2000/06/09 01:43:56 momjian Exp $
+.\" $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.7 2000/07/17 03:04:40 tgl Exp $
 .TH "SYSTEM CATALOGS" INTRO 03/13/94 PostgreSQL PostgreSQL
 .SH "Section 7 - System Catalogs"
 .de LS
@@ -91,20 +91,16 @@ The following catalogs relate to the class/type system.
  * see DEFINE AGGREGATE for an explanation of transition functions
  */
 pg_aggregate
-    NameData      aggname	/* aggregate name (e.g., "count") */
+    NameData    aggname		/* aggregate name (e.g., "count") */
     oid         aggowner	/* usesysid of creator */
-    regproc     aggtransfn1	/* first transition function */
-    regproc     aggtransfn2	/* second transition function */
+    regproc     aggtransfn	/* transition function */
     regproc     aggfinalfn	/* final function */
     oid         aggbasetype	/* type of data on which aggregate
 				   operates */
-    oid         aggtranstype1	/* type returned by aggtransfn1 */
-    oid         aggtranstype2	/* type returned by aggtransfn2 */
-    oid         aggfinaltype	/* type returned by aggfinalfn */
-    text        agginitval1	/* external format of initial
-				   (starting) value of aggtransfn1 */
-    text        agginitval2	/* external format of initial
-				   (starting) value of aggtransfn2 */
+    oid         aggtranstype	/* type of aggregate's transition
+				   (state) data */
+    oid         aggfinaltype	/* type of aggregate's final result */
+    text        agginitval	/* external format of initial state value */
 .fi
 .nf M
 pg_am

doc/src/sgml/ref/drop_aggregate.sgml

 <!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/drop_aggregate.sgml,v 1.7 2000/05/18 14:24:32 momjian Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/drop_aggregate.sgml,v 1.8 2000/07/17 03:04:41 tgl Exp $
 Postgres documentation
 -->
 
@@ -49,7 +49,7 @@ DROP AGGREGATE <replaceable class="PARAMETER">name</replaceable> <replaceable cl
        <para>
 	The type of an existing aggregate function.
 	(Refer to the <citetitle>PostgreSQL User's Guide</citetitle> for
-	further information about data types).
+	further information about data types.)
 	<comment>This should become a cross-reference rather than a
 	 hard-coded chapter number</comment>
        </para>
@@ -80,7 +80,7 @@ DROP
      </varlistentry>
      <varlistentry>
       <term><computeroutput>
-NOTICE RemoveAggregate: aggregate '<replaceable class="parameter">agg</replaceable>' for '<replaceable class="parameter">type</replaceable>' does not exist
+ERROR: RemoveAggregate: aggregate '<replaceable class="parameter">agg</replaceable>' for '<replaceable class="parameter">type</replaceable>' does not exist
        </computeroutput></term>
       <listitem>
        <para>

doc/src/sgml/xaggr.sgml

 <!--
-$Header: /cvsroot/pgsql/doc/src/sgml/xaggr.sgml,v 1.7 2000/03/31 03:27:41 thomas Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/xaggr.sgml,v 1.8 2000/07/17 03:04:40 tgl Exp $
 -->
 
  <chapter id="xaggr">
@@ -16,39 +16,20 @@ $Header: /cvsroot/pgsql/doc/src/sgml/xaggr.sgml,v 1.7 2000/03/31 03:27:41 thomas
    an initial value for the state, and a state transition
    function.  The state transition function is just an
    ordinary function that could also be used outside the
-   context of the aggregate.
+   context of the aggregate.  A <firstterm>final function</firstterm>
+   can also be specified, in case the desired output of the aggregate
+   is different from the data that needs to be kept in the running
+   state value.
   </para>
 
   <para>
-   Actually, in order to make it easier to construct useful
-   aggregates from existing functions, an aggregate can have
-   one or two separate state values, one or two transition
-   functions to update those state values, and a
-   <firstterm>final function</firstterm> that computes the
-   actual aggregate result from the ending state values.
+   Thus, in addition to the input and result datatypes seen by a user
+   of the aggregate, there is an internal state-value datatype that
+   may be different from both the input and result types.
   </para>
 
   <para>
-   Thus there can be as many as four datatypes involved:
-   the type of the input data items, the type of the aggregate's
-   result, and the types of the two state values.  Only the
-   input and result datatypes are seen by a user of the aggregate.
-  </para>
-
-  <para>
-   Some state transition functions need to look at each successive
-   input to compute the next state value, while others ignore the
-   specific input value and simply update their internal state.
-   (The most useful example of the second kind is a running count
-   of the number of input items.)  The <productname>Postgres</productname>
-   aggregate machinery defines <acronym>sfunc1</acronym> for
-   an aggregate as a function that is passed both the old state
-   value and the current input value, while <acronym>sfunc2</acronym>
-   is a function that is passed only the old state value.
-  </para>
-
-  <para>
-   If we define an aggregate that  uses  only <acronym>sfunc1</acronym>,
+   If we define an aggregate that does not use a final function,
    we have an aggregate that computes a running function of
    the attribute values from each instance.  "Sum"  is  an
    example  of  this  kind  of aggregate.  "Sum" starts at
@@ -60,10 +41,10 @@ $Header: /cvsroot/pgsql/doc/src/sgml/xaggr.sgml,v 1.7 2000/03/31 03:27:41 thomas
    
    <programlisting>
 CREATE AGGREGATE complex_sum (
-    sfunc1 = complex_add,
+    sfunc = complex_add,
     basetype = complex,
-    stype1 = complex,
-    initcond1 = '(0,0)'
+    stype = complex,
+    initcond = '(0,0)'
 );
 
 SELECT complex_sum(a) FROM test_complex;
@@ -81,67 +62,48 @@ SELECT complex_sum(a) FROM test_complex;
   </para>
 
   <para>
-   If we define only <acronym>sfunc2</acronym>, we are 
-   specifying  an  aggregate  
-   that computes a running function that is independent  of  
-   the  attribute  values  from  each  instance.
-   "Count"  is  the  most  common  example of this kind of
-   aggregate.  "Count" starts at zero and adds one to  its
-   running  total for each instance, ignoring the instance
-   value.  Here, we use the built-in 
-   <acronym>int4inc</acronym> routine to do
-   the work for us.  This routine increments (adds one to)
-   its argument.
-   
-   <programlisting>
-CREATE AGGREGATE my_count (
-    sfunc2 = int4inc, -- add one
-    basetype = int4,
-    stype2 = int4,
-    initcond2 = '0'
-);
-
-SELECT my_count(*) as emp_count from EMP;
-
-         +----------+
-         |emp_count |
-         +----------+
-         |5         |
-         +----------+
-   </programlisting>
+   The above definition of "Sum" will return zero (the initial
+   state condition) if there are no non-null input values.
+   Perhaps we want to return NULL in that case instead --- SQL92
+   expects "Sum" to behave that way.  We can do this simply by
+   omitting the "initcond" phrase, so that the initial state
+   condition is NULL.  Ordinarily this would mean that the sfunc
+   would need to check for a NULL state-condition input, but for
+   "Sum" and some other simple aggregates like "Max" and "Min",
+   it's sufficient to insert the first non-null input value into
+   the state variable and then start applying the transition function
+   at the second non-null input value.  <productname>Postgres</productname>
+   will do that automatically if the initial condition is NULL and
+   the transition function is marked "strict" (ie, not to be called
+   for NULL inputs).
   </para>
   
   <para>
-   "Average" is an example of an aggregate  that  requires
-   both  a function to compute the running sum and a function 
-   to compute the running count.   When  all  of  the
-   instances have been processed, the final answer for the
-   aggregate is the running sum  divided  by  the  running
-   count.   We use the <acronym>int4pl</acronym> and
-   <acronym>int4inc</acronym> routines we used
-   before as well as the <productname>Postgres</productname>  integer  division  
-   routine,  <acronym>int4div</acronym>,  to  compute the division of the sum by
-   the count.
-   
+   Another bit of default behavior for a "strict" transition function
+   is that the previous state value is retained unchanged whenever a
+   NULL input value is encountered.  Thus, NULLs are ignored.  If you
+   need some other behavior for NULL inputs, just define your transition
+   function as non-strict, and code it to test for NULL inputs and do
+   whatever is needed.
+  </para>
+  
+  <para>
+   "Average" is a more complex example of an aggregate.  It requires
+   two pieces of running state: the sum of the inputs and the count
+   of the number of inputs.  The final result is obtained by dividing
+   these quantities.  Average is typically implemented by using a
+   two-element array as the transition state value.  For example,
+   the built-in implementation of <function>avg(float8)</function>
+   looks like:
+
    <programlisting>
-CREATE AGGREGATE my_average (
-    sfunc1 = int4pl,     --  sum
-    basetype = int4,
-    stype1 = int4,
-    sfunc2 = int4inc,    -- count
-    stype2 = int4,
-    finalfunc = int4div, -- division
-    initcond1 = '0',
-    initcond2 = '0'
+CREATE AGGREGATE avg (
+    sfunc = float8_accum,
+    basetype = float8,
+    stype = _float8,
+    finalfunc = float8_avg,
+    initcond = '{0,0}'
 );
-
-SELECT my_average(salary) as emp_average FROM EMP;
-
-         +------------+
-         |emp_average |
-         +------------+
-         |1640        |
-         +------------+
    </programlisting>
   </para>
 

src/backend/commands/define.c

@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.44 2000/07/03 23:09:33 wieck Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.45 2000/07/17 03:04:44 tgl Exp $
  *
  * DESCRIPTION
  *	  The "DefineFoo" routines take the parse tree and pick out the
@@ -484,16 +484,12 @@ DefineOperator(char *oprName,
  */
 void
 DefineAggregate(char *aggName, List *parameters)
-
 {
-	char	   *stepfunc1Name = NULL;
-	char	   *stepfunc2Name = NULL;
+	char	   *transfuncName = NULL;
 	char	   *finalfuncName = NULL;
 	char	   *baseType = NULL;
-	char	   *stepfunc1Type = NULL;
-	char	   *stepfunc2Type = NULL;
-	char	   *init1 = NULL;
-	char	   *init2 = NULL;
+	char	   *transType = NULL;
+	char	   *initval = NULL;
 	List	   *pl;
 
 	foreach(pl, parameters)
@@ -501,47 +497,28 @@ DefineAggregate(char *aggName, List *parameters)
 		DefElem    *defel = (DefElem *) lfirst(pl);
 
 		/*
-		 * sfunc1
+		 * sfunc1, stype1, and initcond1 are accepted as obsolete spellings
+		 * for sfunc, stype, initcond.
 		 */
-		if (!strcasecmp(defel->defname, "sfunc1"))
-			stepfunc1Name = defGetString(defel);
-		else if (!strcasecmp(defel->defname, "basetype"))
-			baseType = defGetString(defel);
-		else if (!strcasecmp(defel->defname, "stype1"))
-		{
-			stepfunc1Type = defGetString(defel);
-
-			/*
-			 * sfunc2
-			 */
-		}
-		else if (!strcasecmp(defel->defname, "sfunc2"))
-			stepfunc2Name = defGetString(defel);
-		else if (!strcasecmp(defel->defname, "stype2"))
-		{
-			stepfunc2Type = defGetString(defel);
-
-			/*
-			 * final
-			 */
-		}
-		else if (!strcasecmp(defel->defname, "finalfunc"))
-		{
+		if (strcasecmp(defel->defname, "sfunc") == 0)
+			transfuncName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "sfunc1") == 0)
+			transfuncName = defGetString(defel);
+		else if (strcasecmp(defel->defname, "finalfunc") == 0)
 			finalfuncName = defGetString(defel);
-
-			/*
-			 * initial conditions
-			 */
-		}
-		else if (!strcasecmp(defel->defname, "initcond1"))
-			init1 = defGetString(defel);
-		else if (!strcasecmp(defel->defname, "initcond2"))
-			init2 = defGetString(defel);
+		else if (strcasecmp(defel->defname, "basetype") == 0)
+			baseType = defGetString(defel);
+		else if (strcasecmp(defel->defname, "stype") == 0)
+			transType = defGetString(defel);
+		else if (strcasecmp(defel->defname, "stype1") == 0)
+			transType = defGetString(defel);
+		else if (strcasecmp(defel->defname, "initcond") == 0)
+			initval = defGetString(defel);
+		else if (strcasecmp(defel->defname, "initcond1") == 0)
+			initval = defGetString(defel);
 		else
-		{
 			elog(NOTICE, "DefineAggregate: attribute \"%s\" not recognized",
 				 defel->defname);
-		}
 	}
 
 	/*
@@ -549,31 +526,20 @@ DefineAggregate(char *aggName, List *parameters)
 	 */
 	if (baseType == NULL)
 		elog(ERROR, "Define: \"basetype\" unspecified");
-	if (stepfunc1Name != NULL)
-	{
-		if (stepfunc1Type == NULL)
-			elog(ERROR, "Define: \"stype1\" unspecified");
-	}
-	if (stepfunc2Name != NULL)
-	{
-		if (stepfunc2Type == NULL)
-			elog(ERROR, "Define: \"stype2\" unspecified");
-	}
+	if (transType == NULL)
+		elog(ERROR, "Define: \"stype\" unspecified");
+	if (transfuncName == NULL)
+		elog(ERROR, "Define: \"sfunc\" unspecified");
 
 	/*
 	 * Most of the argument-checking is done inside of AggregateCreate
 	 */
-	AggregateCreate(aggName,	/* aggregate name */
-					stepfunc1Name,		/* first step function name */
-					stepfunc2Name,		/* second step function name */
-					finalfuncName,		/* final function name */
-					baseType,	/* type of object being aggregated */
-					stepfunc1Type,		/* return type of first function */
-					stepfunc2Type,		/* return type of second function */
-					init1,		/* first initial condition */
-					init2);		/* second initial condition */
-
-	/* XXX free palloc'd memory */
+	AggregateCreate(aggName,		/* aggregate name */
+					transfuncName,	/* step function name */
+					finalfuncName,	/* final function name */
+					baseType,		/* type of data being aggregated */
+					transType,		/* transition data type */
+					initval);		/* initial condition */
 }
 
 /*

src/backend/commands/user.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.63 2000/07/05 23:11:11 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.64 2000/07/17 03:04:44 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -26,6 +26,7 @@
 #include "commands/user.h"
 #include "libpq/crypt.h"
 #include "miscadmin.h"
+#include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/syscache.h"

src/backend/executor/execQual.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.73 2000/07/12 02:37:00 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.74 2000/07/17 03:04:51 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -40,6 +40,7 @@
 #include "executor/execdebug.h"
 #include "executor/functions.h"
 #include "executor/nodeSubplan.h"
+#include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/fcache2.h"

src/backend/executor/execScan.c

@@ -12,16 +12,19 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.12 2000/07/12 02:37:01 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execScan.c,v 1.13 2000/07/17 03:04:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include <sys/types.h>
 #include <sys/file.h>
+
 #include "postgres.h"
 
 #include "executor/executor.h"
+#include "utils/memutils.h"
+
 
 /* ----------------------------------------------------------------
  *		ExecScan

src/backend/executor/nodeHash.c

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
- *	$Id: nodeHash.c,v 1.49 2000/07/12 02:37:03 tgl Exp $
+ *	$Id: nodeHash.c,v 1.50 2000/07/17 03:04:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -30,6 +30,8 @@
 #include "miscadmin.h"
 #include "parser/parse_expr.h"
 #include "parser/parse_type.h"
+#include "utils/memutils.h"
+
 
 static int	hashFunc(Datum key, int len, bool byVal);
 

src/backend/executor/nodeHashjoin.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.31 2000/07/12 02:37:03 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.32 2000/07/17 03:04:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -20,6 +20,8 @@
 #include "executor/nodeHash.h"
 #include "executor/nodeHashjoin.h"
 #include "optimizer/clauses.h"
+#include "utils/memutils.h"
+
 
 static TupleTableSlot *ExecHashJoinOuterGetTuple(Plan *node, Plan *parent,
 						  HashJoinState *hjstate);

src/backend/executor/nodeNestloop.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.17 2000/07/12 02:37:03 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.18 2000/07/17 03:04:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -18,10 +18,13 @@
  *		ExecInitNestLoop - initialize the join
  *		ExecEndNestLoop  - shut down the join
  */
+
 #include "postgres.h"
 
 #include "executor/execdebug.h"
 #include "executor/nodeNestloop.h"
+#include "utils/memutils.h"
+
 
 /* ----------------------------------------------------------------
  *		ExecNestLoop(node)

src/backend/executor/nodeResult.c

@@ -34,7 +34,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeResult.c,v 1.14 2000/07/12 02:37:04 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/nodeResult.c,v 1.15 2000/07/17 03:04:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -43,6 +43,8 @@
 
 #include "executor/executor.h"
 #include "executor/nodeResult.h"
+#include "utils/memutils.h"
+
 
 /* ----------------------------------------------------------------
  *		ExecResult(node)

src/backend/libpq/be-fsstubs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.49 2000/07/07 21:12:53 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.50 2000/07/17 03:04:54 tgl Exp $
  *
  * NOTES
  *	  This should be moved to a more appropriate place.  It is here
@@ -43,6 +43,8 @@
 #include "libpq/be-fsstubs.h"
 #include "libpq/libpq-fs.h"
 #include "storage/large_object.h"
+#include "utils/memutils.h"
+
 
 /* [PA] is Pascal Andr <andre@via.ecp.fr> */
 

src/backend/nodes/copyfuncs.c

@@ -19,7 +19,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.116 2000/07/12 02:37:04 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.117 2000/07/17 03:04:58 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -843,7 +843,6 @@ _copyAggref(Aggref *from)
 	newnode->basetype = from->basetype;
 	newnode->aggtype = from->aggtype;
 	Node_Copy(from, newnode, target);
-	newnode->usenulls = from->usenulls;
 	newnode->aggstar = from->aggstar;
 	newnode->aggdistinct = from->aggdistinct;
 	newnode->aggno = from->aggno;		/* probably not needed */

src/backend/nodes/equalfuncs.c

@@ -24,7 +24,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.68 2000/07/12 02:37:04 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.69 2000/07/17 03:05:01 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -257,8 +257,6 @@ _equalAggref(Aggref *a, Aggref *b)
 		return false;
 	if (!equal(a->target, b->target))
 		return false;
-	if (a->usenulls != b->usenulls)
-		return false;
 	if (a->aggstar != b->aggstar)
 		return false;
 	if (a->aggdistinct != b->aggdistinct)

src/backend/nodes/outfuncs.c

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- *	$Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.122 2000/07/15 00:01:37 tgl Exp $
+ *	$Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.123 2000/07/17 03:05:01 tgl Exp $
  *
  * NOTES
  *	  Every (plan) node in POSTGRES has an associated "out" routine which
@@ -729,12 +729,10 @@ _outAggref(StringInfo str, Aggref *node)
 	appendStringInfo(str, " AGGREG :aggname ");
 	_outToken(str, node->aggname);
 	appendStringInfo(str, " :basetype %u :aggtype %u :target ",
-					 node->basetype,
-					 node->aggtype);
+					 node->basetype, node->aggtype);
 	_outNode(str, node->target);
 
-	appendStringInfo(str, " :usenulls %s :aggstar %s :aggdistinct %s ",
-					 node->usenulls ? "true" : "false",
+	appendStringInfo(str, " :aggstar %s :aggdistinct %s ",
 					 node->aggstar ? "true" : "false",
 					 node->aggdistinct ? "true" : "false");
 	/* aggno is not dumped */

src/backend/nodes/readfuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.92 2000/07/12 02:37:06 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.93 2000/07/17 03:05:01 tgl Exp $
  *
  * NOTES
  *	  Most of the read functions for plan nodes are tested. (In fact, they
@@ -1117,10 +1117,6 @@ _readAggref()
 	token = lsptok(NULL, &length);		/* eat :target */
 	local_node->target = nodeRead(true);		/* now read it */
 
-	token = lsptok(NULL, &length);		/* eat :usenulls */
-	token = lsptok(NULL, &length);		/* get usenulls */
-	local_node->usenulls = (token[0] == 't') ? true : false;
-
 	token = lsptok(NULL, &length);		/* eat :aggstar */
 	token = lsptok(NULL, &length);		/* get aggstar */
 	local_node->aggstar = (token[0] == 't') ? true : false;

src/backend/parser/parse_agg.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.38 2000/06/15 03:32:19 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.39 2000/07/17 03:05:02 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -189,18 +189,16 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
 {
 	HeapTuple	theAggTuple;
 	Form_pg_aggregate aggform;
-	Oid			fintype;
-	Oid			xfn1;
-	Oid			vartype;
 	Aggref	   *aggref;
-	bool		usenulls = false;
 
 	theAggTuple = SearchSysCacheTuple(AGGNAME,
 									  PointerGetDatum(aggname),
 									  ObjectIdGetDatum(basetype),
 									  0, 0);
+	/* shouldn't happen --- caller should have checked already */
 	if (!HeapTupleIsValid(theAggTuple))
-		elog(ERROR, "Aggregate %s does not exist", aggname);
+		agg_error("ParseAgg", aggname, basetype);
+	aggform = (Form_pg_aggregate) GETSTRUCT(theAggTuple);
 
 	/*
 	 * There used to be a really ugly hack for count(*) here.
@@ -209,43 +207,18 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
 	 * does the right thing.  (It didn't use to do the right thing,
 	 * because the optimizer had the wrong ideas about semantics of
 	 * queries without explicit variables.	Fixed as of Oct 1999 --- tgl.)
-	 *
-	 * Since "1" never evaluates as null, we currently have no need of the
-	 * "usenulls" flag, but it should be kept around; in fact, we should
-	 * extend the pg_aggregate table to let usenulls be specified as an
-	 * attribute of user-defined aggregates.  In the meantime, usenulls is
-	 * just always set to "false".
 	 */
 
-	aggform = (Form_pg_aggregate) GETSTRUCT(theAggTuple);
-	fintype = aggform->aggfinaltype;
-	xfn1 = aggform->aggtransfn1;
-
-	/* only aggregates with transfn1 need a base type */
-	if (OidIsValid(xfn1))
-	{
-		basetype = aggform->aggbasetype;
-		vartype = exprType(lfirst(args));
-		if ((basetype != vartype)
-			&& (!IS_BINARY_COMPATIBLE(basetype, vartype)))
-		{
-			Type		tp1,
-						tp2;
-
-			tp1 = typeidType(basetype);
-			tp2 = typeidType(vartype);
-			elog(ERROR, "Aggregate type mismatch"
-				 "\n\t%s() works on %s, not on %s",
-				 aggname, typeTypeName(tp1), typeTypeName(tp2));
-		}
-	}
+	/*
+	 * We assume caller has already checked that given args are compatible
+	 * with the agg's basetype.
+	 */
 
 	aggref = makeNode(Aggref);
 	aggref->aggname = pstrdup(aggname);
 	aggref->basetype = aggform->aggbasetype;
-	aggref->aggtype = fintype;
+	aggref->aggtype = aggform->aggfinaltype;
 	aggref->target = lfirst(args);
-	aggref->usenulls = usenulls;
 	aggref->aggstar = agg_star;
 	aggref->aggdistinct = agg_distinct;
 
@@ -268,10 +241,9 @@ agg_error(char *caller, char *aggname, Oid basetypeID)
 	 */
 
 	if (basetypeID == InvalidOid)
-		elog(ERROR, "%s: aggregate '%s' for all types does not exist", caller, aggname);
+		elog(ERROR, "%s: aggregate '%s' for all types does not exist",
+			 caller, aggname);
 	else
-	{
-		elog(ERROR, "%s: aggregate '%s' for '%s' does not exist", caller, aggname,
-			 typeidTypeName(basetypeID));
-	}
+		elog(ERROR, "%s: aggregate '%s' for '%s' does not exist",
+			 caller, aggname, typeidTypeName(basetypeID));
 }

src/backend/postmaster/postmaster.c

@@ -11,7 +11,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.156 2000/07/12 22:59:04 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.157 2000/07/17 03:05:04 tgl Exp $
  *
  * NOTES
  *
@@ -33,6 +33,7 @@
  *
  *-------------------------------------------------------------------------
  */
+
 #include "postgres.h"
 
 #include <unistd.h>
@@ -80,6 +81,7 @@
 #include "tcop/tcopprot.h"
 #include "utils/exc.h"
 #include "utils/guc.h"
+#include "utils/memutils.h"
 
 
 #define INVALID_SOCK	(-1)

src/backend/storage/lmgr/lock.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.70 2000/06/28 03:32:07 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.71 2000/07/17 03:05:08 tgl Exp $
  *
  * NOTES
  *	  Outside modules can create a lock table and acquire/release
@@ -20,7 +20,7 @@
  *	Interface:
  *
  *	LockAcquire(), LockRelease(), LockMethodTableInit(),
- *	LockMethodTableRename(), LockReleaseAll, LockOwners()
+ *	LockMethodTableRename(), LockReleaseAll,
  *	LockResolveConflicts(), GrantLock()
  *
  *	NOTE: This module is used to define new lock tables.  The
@@ -35,9 +35,11 @@
 #include <signal.h>
 
 #include "postgres.h"
+
 #include "access/xact.h"
 #include "miscadmin.h"
 #include "storage/proc.h"
+#include "utils/memutils.h"
 #include "utils/ps_status.h"
 
 static int	WaitOnLock(LOCKMETHOD lockmethod, LOCK *lock, LOCKMODE lockmode);
@@ -1722,181 +1724,6 @@ nxtl:	;
 	return false;
 }
 
-#ifdef NOT_USED
-/*
- * Return an array with the pids of all processes owning a lock.
- * This works only for user locks because normal locks have no
- * pid information in the corresponding XIDLookupEnt.
- */
-ArrayType  *
-LockOwners(LOCKMETHOD lockmethod, LOCKTAG *locktag)
-{
-	XIDLookupEnt *xidLook = NULL;
-	SPINLOCK	masterLock;
-	LOCK	   *lock;
-	SHMEM_OFFSET lock_offset;
-	int			count = 0;
-	LOCKMETHODTABLE *lockMethodTable;
-	HTAB	   *xidTable;
-	bool		found;
-	int			ndims,
-				nitems,
-				hdrlen,
-				size;
-	int			lbounds[1],
-				hbounds[1];
-	ArrayType  *array;
-	int		   *data_ptr;
-
-	/* Assume that no one will modify the result */
-	static int	empty_array[] = {20, 1, 0, 0, 0};
-
-#ifdef LOCK_DEBUG
-	if (lockmethod == USER_LOCKMETHOD && Trace_userlocks)
-        elog(DEBUG, "LockOwners: user lock tag [%u]", locktag->objId.blkno);
-#endif
-
-	/* This must be changed when short term locks will be used */
-	locktag->lockmethod = lockmethod;
-
-	Assert((lockmethod >= MIN_LOCKMETHOD) && (lockmethod < NumLockMethods));
-	lockMethodTable = LockMethodTable[lockmethod];
-	if (!lockMethodTable)
-	{
-		elog(NOTICE, "lockMethodTable is null in LockOwners");
-		return (ArrayType *) &empty_array;
-	}
-
-	if (LockingIsDisabled)
-		return (ArrayType *) &empty_array;
-
-	masterLock = lockMethodTable->ctl->masterLock;
-	SpinAcquire(masterLock);
-
-	/*
-	 * Find a lock with this tag
-	 */
-	Assert(lockMethodTable->lockHash->hash == tag_hash);
-	lock = (LOCK *) hash_search(lockMethodTable->lockHash, (Pointer) locktag,
-								HASH_FIND, &found);
-
-	/*
-	 * let the caller print its own error message, too. Do not elog(WARN).
-	 */
-	if (!lock)
-	{
-		SpinRelease(masterLock);
-		elog(NOTICE, "LockOwners: locktable corrupted");
-		return (ArrayType *) &empty_array;
-	}
-
-	if (!found)
-	{
-		SpinRelease(masterLock);
-        elog(NOTICE, "LockOwners: no such lock");
-		return (ArrayType *) &empty_array;
-	}
-	LOCK_PRINT("LockOwners: found", lock, 0);
-	Assert((lock->nHolding > 0) && (lock->nActive > 0));
-	Assert(lock->nActive <= lock->nHolding);
-	lock_offset = MAKE_OFFSET(lock);
-
-	/* Construct a 1-dimensional array */
-	ndims = 1;
-	hdrlen = ARR_OVERHEAD(ndims);
-	lbounds[0] = 0;
-	hbounds[0] = lock->nActive;
-	size = hdrlen + sizeof(int) * hbounds[0];
-	array = (ArrayType *) palloc(size);
-	MemSet(array, 0, size);
-	memmove((char *) array, (char *) &size, sizeof(int));
-	memmove((char *) ARR_NDIM_PTR(array), (char *) &ndims, sizeof(int));
-	memmove((char *) ARR_DIMS(array), (char *) hbounds, ndims * sizeof(int));
-	memmove((char *) ARR_LBOUND(array), (char *) lbounds, ndims * sizeof(int));
-	SET_LO_FLAG(false, array);
-	data_ptr = (int *) ARR_DATA_PTR(array);
-
-	xidTable = lockMethodTable->xidHash;
-	hash_seq(NULL);
-	nitems = 0;
-	while ((xidLook = (XIDLookupEnt *) hash_seq(xidTable)) &&
-		   (xidLook != (XIDLookupEnt *) TRUE))
-	{
-		if (count++ > 1000)
-		{
-			elog(NOTICE, "LockOwners: possible loop, giving up");
-			break;
-		}
-
-		if (xidLook->tag.pid == 0)
-		{
-			XID_PRINT("LockOwners: no pid", xidLook);
-			continue;
-		}
-
-		if (!xidLook->tag.lock)
-		{
-			XID_PRINT("LockOwners: NULL LOCK", xidLook);
-			continue;
-		}
-
-		if (xidLook->tag.lock != lock_offset)
-		{
-			XID_PRINT("LockOwners: different lock", xidLook);
-			continue;
-		}
-
-		if (LOCK_LOCKMETHOD(*lock) != lockmethod)
-		{
-			XID_PRINT("LockOwners: other table", xidLook);
-			continue;
-		}
-
-		if (xidLook->nHolding <= 0)
-		{
-			XID_PRINT("LockOwners: not holding", xidLook);
-			continue;
-		}
-
-		if (nitems >= hbounds[0])
-		{
-			elog(NOTICE, "LockOwners: array size exceeded");
-			break;
-		}
-
-		/*
-		 * Check that the holding process is still alive by sending him an
-		 * unused (ignored) signal. If the kill fails the process is not
-		 * alive.
-		 */
-		if ((xidLook->tag.pid != MyProcPid) \
-			&&(kill(xidLook->tag.pid, SIGCHLD)) != 0)
-		{
-			/* Return a negative pid to signal that process is dead */
-			data_ptr[nitems++] = -(xidLook->tag.pid);
-			XID_PRINT("LockOwners: not alive", xidLook);
-			/* XXX - TODO: remove this entry and update lock stats */
-			continue;
-		}
-
-		/* Found a process holding the lock */
-		XID_PRINT("LockOwners: holding", xidLook);
-		data_ptr[nitems++] = xidLook->tag.pid;
-	}
-
-	SpinRelease(masterLock);
-
-	/* Adjust the actual size of the array */
-	hbounds[0] = nitems;
-	size = hdrlen + sizeof(int) * hbounds[0];
-	memmove((char *) array, (char *) &size, sizeof(int));
-	memmove((char *) ARR_DIMS(array), (char *) hbounds, ndims * sizeof(int));
-
-	return array;
-}
-
-#endif /* NOT_USED */
-
 #ifdef LOCK_DEBUG
 /*
  * Dump all locks in the proc->lockQueue. Must have already acquired

src/backend/storage/smgr/md.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.73 2000/07/10 04:32:00 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.74 2000/07/17 03:05:11 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -22,8 +22,9 @@
 #include "catalog/catalog.h"
 #include "miscadmin.h"
 #include "storage/smgr.h"
-#include "utils/inval.h"		/* ImmediateSharedRelationCacheInvalidate()
-								 * */
+#include "utils/inval.h"
+#include "utils/memutils.h"
+
 
 #undef DIAGNOSTIC
 

src/backend/tcop/postgres.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.169 2000/07/12 17:38:45 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.170 2000/07/17 03:05:14 tgl Exp $
  *
  * NOTES
  *	  this is the "main" module of the postgres backend and
@@ -56,6 +56,7 @@
 #include "storage/proc.h"
 #include "utils/exc.h"
 #include "utils/guc.h"
+#include "utils/memutils.h"
 #include "utils/ps_status.h"
 #include "utils/temprel.h"
 #ifdef MULTIBYTE
@@ -1411,7 +1412,7 @@ PostgresMain(int argc, char *argv[], int real_argc, char *real_argv[])
 	if (!IsUnderPostmaster)
 	{
 		puts("\nPOSTGRES backend interactive interface ");
-		puts("$Revision: 1.169 $ $Date: 2000/07/12 17:38:45 $\n");
+		puts("$Revision: 1.170 $ $Date: 2000/07/17 03:05:14 $\n");
 	}
 
 	/*

src/backend/tcop/pquery.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.36 2000/07/12 02:37:15 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.37 2000/07/17 03:05:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -19,8 +19,10 @@
 #include "executor/execdefs.h"
 #include "executor/executor.h"
 #include "tcop/pquery.h"
+#include "utils/memutils.h"
 #include "utils/ps_status.h"
 
+
 static char *CreateOperationTag(int operationType);
 
 

src/backend/utils/adt/float.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.64 2000/07/12 22:59:08 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.65 2000/07/17 03:05:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -17,7 +17,7 @@
  *		Basic float4 ops:
  *		 float4in, float4out, float4abs, float4um
  *		Basic float8 ops:
- *		 float8in, float8inAd, float8out, float8outAd, float8abs, float8um
+ *		 float8in, float8out, float8abs, float8um
  *		Arithmetic operators:
  *		 float4pl, float4mi, float4mul, float4div
  *		 float8pl, float8mi, float8mul, float8div
@@ -64,6 +64,7 @@
 #endif
 
 #include "fmgr.h"
+#include "utils/array.h"
 #include "utils/builtins.h"
 
 static void CheckFloat8Val(double val);
@@ -90,7 +91,6 @@ static void CheckFloat8Val(double val);
 
 #ifndef atof
 extern double atof(const char *p);
-
 #endif
 
 #ifndef HAVE_CBRT
@@ -100,9 +100,8 @@ static double cbrt(double x);
 #else
 #if !defined(nextstep)
 extern double cbrt(double x);
-
-#endif
 #endif
+#endif /* HAVE_CBRT */
 
 #ifndef HAVE_RINT
 #define rint my_rint
@@ -110,10 +109,9 @@ static double rint(double x);
 
 #else
 extern double rint(double x);
+#endif /* HAVE_RINT */
 
-#endif
-
-#endif
+#endif /* NeXT check */
 
 /* ========== USER I/O ROUTINES ========== */
 
@@ -453,7 +451,6 @@ float8smaller(float64 arg1, float64 arg2)
  *		float4mi		- returns a pointer to arg1 - arg2
  *		float4mul		- returns a pointer to arg1 * arg2
  *		float4div		- returns a pointer to arg1 / arg2
- *		float4inc		- returns a poniter to arg1 + 1.0
  */
 float32
 float4pl(float32 arg1, float32 arg2)
@@ -527,29 +524,11 @@ float4div(float32 arg1, float32 arg2)
 	return result;
 }
 
-float32
-float4inc(float32 arg1)
-{
-	float32		result;
-	double		val;
-
-	if (!arg1)
-		return (float32) NULL;
-
-	val = *arg1 + (float32data) 1.0;
-
-	CheckFloat4Val(val);
-	result = (float32) palloc(sizeof(float32data));
-	*result = val;
-	return result;
-}
-
 /*
  *		float8pl		- returns a pointer to arg1 + arg2
  *		float8mi		- returns a pointer to arg1 - arg2
  *		float8mul		- returns a pointer to arg1 * arg2
  *		float8div		- returns a pointer to arg1 / arg2
- *		float8inc		- returns a pointer to arg1 + 1.0
  */
 float64
 float8pl(float64 arg1, float64 arg2)
@@ -622,22 +601,6 @@ float8div(float64 arg1, float64 arg2)
 	return result;
 }
 
-float64
-float8inc(float64 arg1)
-{
-	float64		result;
-	double		val;
-
-	if (!arg1)
-		return (float64) NULL;
-
-	val = *arg1 + (float64data) 1.0;
-	CheckFloat8Val(val);
-	result = (float64) palloc(sizeof(float64data));
-	*result = val;
-	return result;
-}
-
 
 /*
  *		====================
@@ -1572,10 +1535,181 @@ setseed(float64 seed)
 }	/* setseed() */
 
 
+
 /*
- *		====================
- *		ARITHMETIC OPERATORS
- *		====================
+ *		=========================
+ *		FLOAT AGGREGATE OPERATORS
+ *		=========================
+ *
+ *		float8_accum	- accumulate for AVG(), STDDEV(), etc
+ *		float4_accum	- same, but input data is float4
+ *		float8_avg		- produce final result for float AVG()
+ *		float8_variance	- produce final result for float VARIANCE()
+ *		float8_stddev	- produce final result for float STDDEV()
+ *
+ * The transition datatype for all these aggregates is a 3-element array
+ * of float8, holding the values N, sum(X), sum(X*X) in that order.
+ *
+ * Note that we represent N as a float to avoid having to build a special
+ * datatype.  Given a reasonable floating-point implementation, there should
+ * be no accuracy loss unless N exceeds 2 ^ 52 or so (by which time the
+ * user will have doubtless lost interest anyway...)
+ */
+
+static float8 *
+check_float8_array(ArrayType *transarray, const char *caller)
+{
+	/*
+	 * We expect the input to be a 3-element float array; verify that.
+	 * We don't need to use deconstruct_array() since the array data
+	 * is just going to look like a C array of 3 float8 values.
+	 */
+	if (ARR_SIZE(transarray) != (ARR_OVERHEAD(1) + 3 * sizeof(float8)) ||
+		ARR_NDIM(transarray) != 1 ||
+		ARR_DIMS(transarray)[0] != 3)
+		elog(ERROR, "%s: expected 3-element float8 array", caller);
+	return (float8 *) ARR_DATA_PTR(transarray);
+}
+
+Datum
+float8_accum(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	float8		newval = PG_GETARG_FLOAT8(1);
+	float8	   *transvalues;
+	float8		N,
+				sumX,
+				sumX2;
+	Datum		transdatums[3];
+	ArrayType  *result;
+
+	transvalues = check_float8_array(transarray, "float8_accum");
+	N = transvalues[0];
+	sumX = transvalues[1];
+	sumX2 = transvalues[2];
+
+	N += 1.0;
+	sumX += newval;
+	sumX2 += newval * newval;
+
+	transdatums[0] = Float8GetDatumFast(N);
+	transdatums[1] = Float8GetDatumFast(sumX);
+	transdatums[2] = Float8GetDatumFast(sumX2);
+
+	result = construct_array(transdatums, 3,
+							 false /* float8 byval */, sizeof(float8), 'd');
+
+	PG_RETURN_ARRAYTYPE_P(result);
+}
+
+Datum
+float4_accum(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	float4		newval4 = PG_GETARG_FLOAT4(1);
+	float8	   *transvalues;
+	float8		N,
+				sumX,
+				sumX2,
+				newval;
+	Datum		transdatums[3];
+	ArrayType  *result;
+
+	transvalues = check_float8_array(transarray, "float4_accum");
+	N = transvalues[0];
+	sumX = transvalues[1];
+	sumX2 = transvalues[2];
+
+	/* Do arithmetic in float8 for best accuracy */
+	newval = newval4;
+
+	N += 1.0;
+	sumX += newval;
+	sumX2 += newval * newval;
+
+	transdatums[0] = Float8GetDatumFast(N);
+	transdatums[1] = Float8GetDatumFast(sumX);
+	transdatums[2] = Float8GetDatumFast(sumX2);
+
+	result = construct_array(transdatums, 3,
+							 false /* float8 byval */, sizeof(float8), 'd');
+
+	PG_RETURN_ARRAYTYPE_P(result);
+}
+
+Datum
+float8_avg(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	float8	   *transvalues;
+	float8		N,
+				sumX;
+
+	transvalues = check_float8_array(transarray, "float8_avg");
+	N = transvalues[0];
+	sumX = transvalues[1];
+	/* ignore sumX2 */
+
+	/* SQL92 defines AVG of no values to be NULL */
+	if (N == 0.0)
+		PG_RETURN_NULL();
+
+	PG_RETURN_FLOAT8(sumX / N);
+}
+
+Datum
+float8_variance(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	float8	   *transvalues;
+	float8		N,
+				sumX,
+				sumX2;
+
+	transvalues = check_float8_array(transarray, "float8_variance");
+	N = transvalues[0];
+	sumX = transvalues[1];
+	sumX2 = transvalues[2];
+
+	/* We define VARIANCE of no values to be NULL, of 1 value to be 0 */
+	if (N == 0.0)
+		PG_RETURN_NULL();
+
+	if (N <= 1.0)
+		PG_RETURN_FLOAT8(0.0);
+
+	PG_RETURN_FLOAT8((N * sumX2 - sumX * sumX) / (N * (N - 1.0)));
+}
+
+Datum
+float8_stddev(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	float8	   *transvalues;
+	float8		N,
+				sumX,
+				sumX2;
+
+	transvalues = check_float8_array(transarray, "float8_stddev");
+	N = transvalues[0];
+	sumX = transvalues[1];
+	sumX2 = transvalues[2];
+
+	/* We define STDDEV of no values to be NULL, of 1 value to be 0 */
+	if (N == 0.0)
+		PG_RETURN_NULL();
+
+	if (N <= 1.0)
+		PG_RETURN_FLOAT8(0.0);
+
+	PG_RETURN_FLOAT8(sqrt((N * sumX2 - sumX * sumX) / (N * (N - 1.0))));
+}
+
+
+/*
+ *		====================================
+ *		MIXED-PRECISION ARITHMETIC OPERATORS
+ *		====================================
  */
 
 /*

src/backend/utils/adt/int.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.40 2000/07/12 22:59:08 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.41 2000/07/17 03:05:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -650,14 +650,6 @@ int2div(PG_FUNCTION_ARGS)
 	PG_RETURN_INT16(arg1 / arg2);
 }
 
-Datum
-int2inc(PG_FUNCTION_ARGS)
-{
-	int16		arg = PG_GETARG_INT16(0);
-
-	PG_RETURN_INT16(arg + 1);
-}
-
 Datum
 int24pl(PG_FUNCTION_ARGS)
 {

src/backend/utils/adt/timestamp.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.33 2000/07/12 22:59:09 petere Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.34 2000/07/17 03:05:18 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,6 +29,7 @@
 #include "access/hash.h"
 #include "access/xact.h"
 #include "miscadmin.h"
+#include "utils/array.h"
 #include "utils/builtins.h"
 
 
@@ -882,10 +883,6 @@ overlaps_timestamp(PG_FUNCTION_ARGS)
 
 /*----------------------------------------------------------
  *	"Arithmetic" operators on date/times.
- *		timestamp_foo	returns foo as an object (pointer) that
- *						can be passed between languages.
- *		timestamp_xx		is an internal routine which returns the
- *						actual value.
  *---------------------------------------------------------*/
 
 Datum
@@ -1150,7 +1147,6 @@ interval_larger(PG_FUNCTION_ARGS)
 	PG_RETURN_INTERVAL_P(result);
 }
 
-
 Datum
 interval_pl(PG_FUNCTION_ARGS)
 {
@@ -1232,6 +1228,90 @@ interval_div(PG_FUNCTION_ARGS)
 	PG_RETURN_INTERVAL_P(result);
 }
 
+/*
+ * interval_accum and interval_avg implement the AVG(interval) aggregate.
+ *
+ * The transition datatype for this aggregate is a 2-element array of
+ * intervals, where the first is the running sum and the second contains
+ * the number of values so far in its 'time' field.  This is a bit ugly
+ * but it beats inventing a specialized datatype for the purpose.
+ */
+
+Datum
+interval_accum(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	Interval   *newval = PG_GETARG_INTERVAL_P(1);
+	Datum	   *transdatums;
+	int			ndatums;
+	Interval	sumX,
+				N;
+	Interval   *newsum;
+	ArrayType  *result;
+
+	/* We assume the input is array of interval */
+	deconstruct_array(transarray,
+					  false, 12, 'd',
+					  &transdatums, &ndatums);
+	if (ndatums != 2)
+		elog(ERROR, "interval_accum: expected 2-element interval array");
+	/*
+	 * XXX memcpy, instead of just extracting a pointer, to work around
+	 * buggy array code: it won't ensure proper alignment of Interval
+	 * objects on machines where double requires 8-byte alignment.
+	 * That should be fixed, but in the meantime...
+	 */
+	memcpy(&sumX, DatumGetIntervalP(transdatums[0]), sizeof(Interval));
+	memcpy(&N, DatumGetIntervalP(transdatums[1]), sizeof(Interval));
+
+	newsum = DatumGetIntervalP(DirectFunctionCall2(interval_pl,
+												   IntervalPGetDatum(&sumX),
+												   IntervalPGetDatum(newval)));
+	N.time += 1;
+
+	transdatums[0] = IntervalPGetDatum(newsum);
+	transdatums[1] = IntervalPGetDatum(&N);
+
+	result = construct_array(transdatums, 2,
+							 false, 12, 'd');
+
+	PG_RETURN_ARRAYTYPE_P(result);
+}
+
+Datum
+interval_avg(PG_FUNCTION_ARGS)
+{
+	ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
+	Datum	   *transdatums;
+	int			ndatums;
+	Interval	sumX,
+				N;
+
+	/* We assume the input is array of interval */
+	deconstruct_array(transarray,
+					  false, 12, 'd',
+					  &transdatums, &ndatums);
+	if (ndatums != 2)
+		elog(ERROR, "interval_avg: expected 2-element interval array");
+	/*
+	 * XXX memcpy, instead of just extracting a pointer, to work around
+	 * buggy array code: it won't ensure proper alignment of Interval
+	 * objects on machines where double requires 8-byte alignment.
+	 * That should be fixed, but in the meantime...
+	 */
+	memcpy(&sumX, DatumGetIntervalP(transdatums[0]), sizeof(Interval));
+	memcpy(&N, DatumGetIntervalP(transdatums[1]), sizeof(Interval));
+
+	/* SQL92 defines AVG of no values to be NULL */
+	if (N.time == 0)
+		PG_RETURN_NULL();
+
+	return DirectFunctionCall2(interval_div,
+							   IntervalPGetDatum(&sumX),
+							   Float8GetDatum(N.time));
+}
+
+
 /* timestamp_age()
  * Calculate time difference while retaining year/month fields.
  * Note that this does not result in an accurate absolute time span

src/bin/pg_dump/pg_dump.c

@@ -22,7 +22,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.158 2000/07/11 13:07:17 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.159 2000/07/17 03:05:20 tgl Exp $
  *
  * Modifications - 6/10/96 - dave@bensoft.com - version 1.13.dhb
  *
@@ -1421,22 +1421,16 @@ clearAggInfo(AggInfo *agginfo, int numArgs)
 			free(agginfo[i].oid);
 		if (agginfo[i].aggname)
 			free(agginfo[i].aggname);
-		if (agginfo[i].aggtransfn1)
-			free(agginfo[i].aggtransfn1);
-		if (agginfo[i].aggtransfn2)
-			free(agginfo[i].aggtransfn2);
+		if (agginfo[i].aggtransfn)
+			free(agginfo[i].aggtransfn);
 		if (agginfo[i].aggfinalfn)
 			free(agginfo[i].aggfinalfn);
-		if (agginfo[i].aggtranstype1)
-			free(agginfo[i].aggtranstype1);
+		if (agginfo[i].aggtranstype)
+			free(agginfo[i].aggtranstype);
 		if (agginfo[i].aggbasetype)
 			free(agginfo[i].aggbasetype);
-		if (agginfo[i].aggtranstype2)
-			free(agginfo[i].aggtranstype2);
-		if (agginfo[i].agginitval1)
-			free(agginfo[i].agginitval1);
-		if (agginfo[i].agginitval2)
-			free(agginfo[i].agginitval2);
+		if (agginfo[i].agginitval)
+			free(agginfo[i].agginitval);
 		if (agginfo[i].usename)
 			free(agginfo[i].usename);
 	}
@@ -1463,22 +1457,19 @@ getAggregates(int *numAggs)
 
 	int			i_oid;
 	int			i_aggname;
-	int			i_aggtransfn1;
-	int			i_aggtransfn2;
+	int			i_aggtransfn;
 	int			i_aggfinalfn;
-	int			i_aggtranstype1;
+	int			i_aggtranstype;
 	int			i_aggbasetype;
-	int			i_aggtranstype2;
-	int			i_agginitval1;
-	int			i_agginitval2;
+	int			i_agginitval;
 	int			i_usename;
 
 	/* find all user-defined aggregates */
 
 	appendPQExpBuffer(query,
-		   "SELECT pg_aggregate.oid, aggname, aggtransfn1, aggtransfn2, "
-				"aggfinalfn, aggtranstype1, aggbasetype, aggtranstype2, "
-		  "agginitval1, agginitval2, usename from pg_aggregate, pg_user "
+					  "SELECT pg_aggregate.oid, aggname, aggtransfn, "
+					  "aggfinalfn, aggtranstype, aggbasetype, "
+					  "agginitval, usename from pg_aggregate, pg_user "
 					  "where aggowner = usesysid");
 
 	res = PQexec(g_conn, query->data);
@@ -1497,28 +1488,22 @@ getAggregates(int *numAggs)
 
 	i_oid = PQfnumber(res, "oid");
 	i_aggname = PQfnumber(res, "aggname");
-	i_aggtransfn1 = PQfnumber(res, "aggtransfn1");
-	i_aggtransfn2 = PQfnumber(res, "aggtransfn2");
+	i_aggtransfn = PQfnumber(res, "aggtransfn");
 	i_aggfinalfn = PQfnumber(res, "aggfinalfn");
-	i_aggtranstype1 = PQfnumber(res, "aggtranstype1");
+	i_aggtranstype = PQfnumber(res, "aggtranstype");
 	i_aggbasetype = PQfnumber(res, "aggbasetype");
-	i_aggtranstype2 = PQfnumber(res, "aggtranstype2");
-	i_agginitval1 = PQfnumber(res, "agginitval1");
-	i_agginitval2 = PQfnumber(res, "agginitval2");
+	i_agginitval = PQfnumber(res, "agginitval");
 	i_usename = PQfnumber(res, "usename");
 
 	for (i = 0; i < ntups; i++)
 	{
 		agginfo[i].oid = strdup(PQgetvalue(res, i, i_oid));
 		agginfo[i].aggname = strdup(PQgetvalue(res, i, i_aggname));
-		agginfo[i].aggtransfn1 = strdup(PQgetvalue(res, i, i_aggtransfn1));
-		agginfo[i].aggtransfn2 = strdup(PQgetvalue(res, i, i_aggtransfn2));
+		agginfo[i].aggtransfn = strdup(PQgetvalue(res, i, i_aggtransfn));
 		agginfo[i].aggfinalfn = strdup(PQgetvalue(res, i, i_aggfinalfn));
-		agginfo[i].aggtranstype1 = strdup(PQgetvalue(res, i, i_aggtranstype1));
+		agginfo[i].aggtranstype = strdup(PQgetvalue(res, i, i_aggtranstype));
 		agginfo[i].aggbasetype = strdup(PQgetvalue(res, i, i_aggbasetype));
-		agginfo[i].aggtranstype2 = strdup(PQgetvalue(res, i, i_aggtranstype2));
-		agginfo[i].agginitval1 = strdup(PQgetvalue(res, i, i_agginitval1));
-		agginfo[i].agginitval2 = strdup(PQgetvalue(res, i, i_agginitval2));
+		agginfo[i].agginitval = strdup(PQgetvalue(res, i, i_agginitval));
 		agginfo[i].usename = strdup(PQgetvalue(res, i, i_usename));
 	}
 
@@ -2902,69 +2887,32 @@ dumpAggs(Archive *fout, AggInfo *agginfo, int numAggs,
 	PQExpBuffer q = createPQExpBuffer();
 	PQExpBuffer delq = createPQExpBuffer();
 	PQExpBuffer aggSig = createPQExpBuffer();
-	PQExpBuffer sfunc1 = createPQExpBuffer();
-	PQExpBuffer sfunc2 = createPQExpBuffer();
-	PQExpBuffer basetype = createPQExpBuffer();
-	PQExpBuffer finalfunc = createPQExpBuffer();
-	char		comma1[2],
-				comma2[2];
+	PQExpBuffer details = createPQExpBuffer();
 
 	for (i = 0; i < numAggs; i++)
 	{
-
-		resetPQExpBuffer(sfunc1);
-		resetPQExpBuffer(sfunc2);
-		resetPQExpBuffer(basetype);
-		resetPQExpBuffer(finalfunc);
+		resetPQExpBuffer(details);
 
 		/* skip all the builtin oids */
 		if (atoi(agginfo[i].oid) < g_last_builtin_oid)
 			continue;
 
-		appendPQExpBuffer(basetype,
+		appendPQExpBuffer(details,
 						  "BASETYPE = %s, ",
 						  fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggbasetype), false));
 
-		if (!(strcmp(agginfo[i].aggtransfn1, "-") == 0))
-		{
-			appendPQExpBuffer(sfunc1,
-							  "SFUNC1 = %s, STYPE1 = %s",
-							  agginfo[i].aggtransfn1,
-							  fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggtranstype1), false));
-			if (agginfo[i].agginitval1)
-				appendPQExpBuffer(sfunc1, ", INITCOND1 = '%s'",
-								  agginfo[i].agginitval1);
+		appendPQExpBuffer(details,
+						  "SFUNC = %s, STYPE = %s",
+						  agginfo[i].aggtransfn,
+						  fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggtranstype), false));
 
-		}
-
-		if (!(strcmp(agginfo[i].aggtransfn2, "-") == 0))
-		{
-			appendPQExpBuffer(sfunc2,
-							  "SFUNC2 = %s, STYPE2 = %s",
-							  agginfo[i].aggtransfn2,
-							  fmtId(findTypeByOid(tinfo, numTypes, agginfo[i].aggtranstype2), false));
-			if (agginfo[i].agginitval2)
-				appendPQExpBuffer(sfunc2, ", INITCOND2 = '%s'",
-								  agginfo[i].agginitval2);
-		}
+		if (agginfo[i].agginitval)
+			appendPQExpBuffer(details, ", INITCOND = '%s'",
+							  agginfo[i].agginitval);
 
 		if (!(strcmp(agginfo[i].aggfinalfn, "-") == 0))
-			appendPQExpBuffer(finalfunc, "FINALFUNC = %s", agginfo[i].aggfinalfn);
-		if (sfunc1->data[0] != '\0' && sfunc2->data[0] != '\0')
-		{
-			comma1[0] = ',';
-			comma1[1] = '\0';
-		}
-		else
-			comma1[0] = '\0';
-
-		if (finalfunc->data[0] != '\0' && (sfunc1->data[0] != '\0' || sfunc2->data[0] != '\0'))
-		{
-			comma2[0] = ',';
-			comma2[1] = '\0';
-		}
-		else
-			comma2[0] = '\0';
+			appendPQExpBuffer(details, ", FINALFUNC = %s",
+							  agginfo[i].aggfinalfn);
 
 		resetPQExpBuffer(aggSig);
 		appendPQExpBuffer(aggSig, "%s %s", agginfo[i].aggname,
@@ -2974,14 +2922,9 @@ dumpAggs(Archive *fout, AggInfo *agginfo, int numAggs,
 		appendPQExpBuffer(delq, "DROP AGGREGATE %s;\n", aggSig->data);
 
 		resetPQExpBuffer(q);
-		appendPQExpBuffer(q, "CREATE AGGREGATE %s ( %s %s%s %s%s %s );\n",
+		appendPQExpBuffer(q, "CREATE AGGREGATE %s ( %s );\n",
 						  agginfo[i].aggname,
-						  basetype->data,
-						  sfunc1->data,
-						  comma1,
-						  sfunc2->data,
-						  comma2,
-						  finalfunc->data);
+						  details->data);
 
 		ArchiveEntry(fout, agginfo[i].oid, aggSig->data, "AGGREGATE", NULL,
 						q->data, delq->data, agginfo[i].usename, NULL, NULL);

src/bin/pg_dump/pg_dump.h

@@ -6,7 +6,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_dump.h,v 1.49 2000/07/04 14:25:28 momjian Exp $
+ * $Id: pg_dump.h,v 1.50 2000/07/17 03:05:20 tgl Exp $
  *
  * Modifications - 6/12/96 - dave@bensoft.com - version 1.13.dhb.2
  *
@@ -133,14 +133,11 @@ typedef struct _aggInfo
 {
 	char	   *oid;
 	char	   *aggname;
-	char	   *aggtransfn1;
-	char	   *aggtransfn2;
+	char	   *aggtransfn;
 	char	   *aggfinalfn;
-	char	   *aggtranstype1;
+	char	   *aggtranstype;
 	char	   *aggbasetype;
-	char	   *aggtranstype2;
-	char	   *agginitval1;
-	char	   *agginitval2;
+	char	   *agginitval;
 	char	   *usename;
 } AggInfo;
 

src/include/c.h

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: c.h,v 1.78 2000/07/12 22:59:12 petere Exp $
+ * $Id: c.h,v 1.79 2000/07/17 03:05:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -587,6 +587,25 @@ extern Datum Float8GetDatum(float8 X);
 
 #define Float64GetDatum(X) PointerGetDatum(X)
 
+/*
+ * Int64GetDatumFast
+ * Float4GetDatumFast
+ * Float8GetDatumFast
+ *
+ * These macros are intended to allow writing code that does not depend on
+ * whether int64, float4, float8 are pass-by-reference types, while not
+ * sacrificing performance when they are.  The argument must be a variable
+ * that will exist and have the same value for as long as the Datum is needed.
+ * In the pass-by-ref case, the address of the variable is taken to use as
+ * the Datum.  In the pass-by-val case, these will be the same as the non-Fast
+ * macros.
+ */
+
+#define Int64GetDatumFast(X)  PointerGetDatum(&(X))
+#define Float4GetDatumFast(X) PointerGetDatum(&(X))
+#define Float8GetDatumFast(X) PointerGetDatum(&(X))
+
+
 /* ----------------------------------------------------------------
  *				Section 5:	IsValid macros for system types
  * ----------------------------------------------------------------

src/include/catalog/catversion.h

@@ -37,7 +37,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: catversion.h,v 1.36 2000/07/07 19:24:41 petere Exp $
+ * $Id: catversion.h,v 1.37 2000/07/17 03:05:23 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -53,6 +53,6 @@
  */
 
 /*							yyyymmddN */
-#define CATALOG_VERSION_NO	200007071
+#define CATALOG_VERSION_NO	200007161
 
 #endif

src/include/catalog/pg_operator.h

@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_operator.h,v 1.76 2000/06/05 07:28:59 tgl Exp $
+ * $Id: pg_operator.h,v 1.77 2000/07/17 03:05:23 tgl Exp $
  *
  * NOTES
  *	  the genbki.sh script reads this file and generates .bki
@@ -323,12 +323,12 @@ DATA(insert OID = 636 (  "-"	   PGUID 0 b t f  18  18  18 0 0  0 0 charmi - - ))
 DATA(insert OID = 637 (  "*"	   PGUID 0 b t f  18  18  18 0 0  0 0 charmul - - ));
 DATA(insert OID = 638 (  "/"	   PGUID 0 b t f  18  18  18 0 0  0 0 chardiv - - ));
 
-DATA(insert OID = 639 (  "~"	   PGUID 0 b t f  19  25  16 0 640	0 0 nameregexeq eqsel eqjoinsel ));
+DATA(insert OID = 639 (  "~"	   PGUID 0 b t f  19  25  16 0 640	0 0 nameregexeq regexeqsel regexeqjoinsel ));
 #define OID_NAME_REGEXEQ_OP		639
-DATA(insert OID = 640 (  "!~"	   PGUID 0 b t f  19  25  16 0 639	0 0 nameregexne neqsel neqjoinsel ));
-DATA(insert OID = 641 (  "~"	   PGUID 0 b t f  25  25  16 0 642	0 0 textregexeq eqsel eqjoinsel ));
+DATA(insert OID = 640 (  "!~"	   PGUID 0 b t f  19  25  16 0 639	0 0 nameregexne regexnesel regexnejoinsel ));
+DATA(insert OID = 641 (  "~"	   PGUID 0 b t f  25  25  16 0 642	0 0 textregexeq regexeqsel regexeqjoinsel ));
 #define OID_TEXT_REGEXEQ_OP		641
-DATA(insert OID = 642 (  "!~"	   PGUID 0 b t f  25  25  16 0 641	0 0 textregexne neqsel neqjoinsel ));
+DATA(insert OID = 642 (  "!~"	   PGUID 0 b t f  25  25  16 0 641	0 0 textregexne regexnesel regexnejoinsel ));
 DATA(insert OID = 643 (  "<>"	   PGUID 0 b t f  19  19  16 643 93 0 0 namene neqsel neqjoinsel ));
 DATA(insert OID = 654 (  "||"	   PGUID 0 b t f  25  25  25   0 0	0 0 textcat - - ));
 
@@ -449,9 +449,9 @@ DATA(insert OID =  974 (  "||"	   PGUID 0 b t f 1042 1042 1042    0  0 0 0 textc
 DATA(insert OID =  979 (  "||"	   PGUID 0 b t f 1043 1043 1043    0  0 0 0 textcat - - ));
 
 DATA(insert OID = 1054 ( "="	   PGUID 0 b t f 1042 1042	 16 1054 1057 1058 1058 bpchareq eqsel eqjoinsel ));
-DATA(insert OID = 1055 ( "~"	   PGUID 0 b t f 1042	25	 16    0 1056  0 0 textregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1055 ( "~"	   PGUID 0 b t f 1042	25	 16    0 1056  0 0 textregexeq regexeqsel regexeqjoinsel ));
 #define OID_BPCHAR_REGEXEQ_OP		1055
-DATA(insert OID = 1056 ( "!~"	   PGUID 0 b t f 1042	25	 16    0 1055  0 0 textregexne neqsel neqjoinsel ));
+DATA(insert OID = 1056 ( "!~"	   PGUID 0 b t f 1042	25	 16    0 1055  0 0 textregexne regexnesel regexnejoinsel ));
 DATA(insert OID = 1057 ( "<>"	   PGUID 0 b t f 1042 1042	 16 1057 1054  0 0 bpcharne neqsel neqjoinsel ));
 DATA(insert OID = 1058 ( "<"	   PGUID 0 b t f 1042 1042	 16 1060 1061  0 0 bpcharlt scalarltsel scalarltjoinsel ));
 DATA(insert OID = 1059 ( "<="	   PGUID 0 b t f 1042 1042	 16 1061 1060  0 0 bpcharle scalarltsel scalarltjoinsel ));
@@ -459,9 +459,9 @@ DATA(insert OID = 1060 ( ">"	   PGUID 0 b t f 1042 1042	 16 1058 1059  0 0 bpcha
 DATA(insert OID = 1061 ( ">="	   PGUID 0 b t f 1042 1042	 16 1059 1058  0 0 bpcharge scalargtsel scalargtjoinsel ));
 
 DATA(insert OID = 1062 ( "="	   PGUID 0 b t t 1043 1043	16	1062 1065 1066 1066 varchareq eqsel eqjoinsel ));
-DATA(insert OID = 1063 ( "~"	   PGUID 0 b t f 1043	25	16 0 1064  0 0 textregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1063 ( "~"	   PGUID 0 b t f 1043	25	16 0 1064  0 0 textregexeq regexeqsel regexeqjoinsel ));
 #define OID_VARCHAR_REGEXEQ_OP		1063
-DATA(insert OID = 1064 ( "!~"	   PGUID 0 b t f 1043	25	16 0 1063  0 0 textregexne neqsel neqjoinsel ));
+DATA(insert OID = 1064 ( "!~"	   PGUID 0 b t f 1043	25	16 0 1063  0 0 textregexne regexnesel regexnejoinsel ));
 DATA(insert OID = 1065 ( "<>"	   PGUID 0 b t f 1043 1043	16 1065 1062  0 0 varcharne neqsel neqjoinsel ));
 DATA(insert OID = 1066 ( "<"	   PGUID 0 b t f 1043 1043	16 1068 1069  0 0 varcharlt scalarltsel scalarltjoinsel ));
 DATA(insert OID = 1067 ( "<="	   PGUID 0 b t f 1043 1043	16 1069 1068  0 0 varcharle scalarltsel scalarltjoinsel ));
@@ -527,32 +527,32 @@ DATA(insert OID = 1158 (  "!"		PGUID 0 r t f	21	  0   23 0 0 0 0 int2fac - - ));
 DATA(insert OID = 1175 (  "!!"		PGUID 0 l t f	 0	 21   23 0 0 0 0 int2fac - - ));
 
 /* LIKE hacks by Keith Parks. */
-DATA(insert OID = 1207 (  "~~"	  PGUID 0 b t f  19   25  16 0 1208 0 0 namelike eqsel eqjoinsel ));
+DATA(insert OID = 1207 (  "~~"	  PGUID 0 b t f  19   25  16 0 1208 0 0 namelike likesel likejoinsel ));
 #define OID_NAME_LIKE_OP		1207
-DATA(insert OID = 1208 (  "!~~"   PGUID 0 b t f  19   25  16 0 1207 0 0 namenlike neqsel neqjoinsel ));
-DATA(insert OID = 1209 (  "~~"	  PGUID 0 b t f  25   25  16 0 1210 0 0 textlike eqsel eqjoinsel ));
+DATA(insert OID = 1208 (  "!~~"   PGUID 0 b t f  19   25  16 0 1207 0 0 namenlike nlikesel nlikejoinsel ));
+DATA(insert OID = 1209 (  "~~"	  PGUID 0 b t f  25   25  16 0 1210 0 0 textlike likesel likejoinsel ));
 #define OID_TEXT_LIKE_OP		1209
-DATA(insert OID = 1210 (  "!~~"   PGUID 0 b t f  25   25  16 0 1209 0 0 textnlike neqsel neqjoinsel ));
-DATA(insert OID = 1211 (  "~~"	  PGUID 0 b t f  1042 25  16 0 1212 0 0 textlike eqsel eqjoinsel ));
+DATA(insert OID = 1210 (  "!~~"   PGUID 0 b t f  25   25  16 0 1209 0 0 textnlike nlikesel nlikejoinsel ));
+DATA(insert OID = 1211 (  "~~"	  PGUID 0 b t f  1042 25  16 0 1212 0 0 textlike likesel likejoinsel ));
 #define OID_BPCHAR_LIKE_OP		1211
-DATA(insert OID = 1212 (  "!~~"   PGUID 0 b t f  1042 25  16 0 1211 0 0 textnlike neqsel neqjoinsel ));
-DATA(insert OID = 1213 (  "~~"	  PGUID 0 b t f  1043 25  16 0 1214 0 0 textlike eqsel eqjoinsel ));
+DATA(insert OID = 1212 (  "!~~"   PGUID 0 b t f  1042 25  16 0 1211 0 0 textnlike nlikesel nlikejoinsel ));
+DATA(insert OID = 1213 (  "~~"	  PGUID 0 b t f  1043 25  16 0 1214 0 0 textlike likesel likejoinsel ));
 #define OID_VARCHAR_LIKE_OP		1213
-DATA(insert OID = 1214 (  "!~~"   PGUID 0 b t f  1043 25  16 0 1213 0 0 textnlike neqsel neqjoinsel ));
+DATA(insert OID = 1214 (  "!~~"   PGUID 0 b t f  1043 25  16 0 1213 0 0 textnlike nlikesel nlikejoinsel ));
 
 /* case-insensitive LIKE hacks */
-DATA(insert OID = 1226 (  "~*"		 PGUID 0 b t f	19	25	16 0 1227  0 0 nameicregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1226 (  "~*"		 PGUID 0 b t f	19	25	16 0 1227  0 0 nameicregexeq icregexeqsel icregexeqjoinsel ));
 #define OID_NAME_ICREGEXEQ_OP		1226
-DATA(insert OID = 1227 (  "!~*"		 PGUID 0 b t f	19	25	16 0 1226  0 0 nameicregexne neqsel neqjoinsel ));
-DATA(insert OID = 1228 (  "~*"		 PGUID 0 b t f	25	25	16 0 1229  0 0 texticregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1227 (  "!~*"		 PGUID 0 b t f	19	25	16 0 1226  0 0 nameicregexne icregexnesel icregexnejoinsel ));
+DATA(insert OID = 1228 (  "~*"		 PGUID 0 b t f	25	25	16 0 1229  0 0 texticregexeq icregexeqsel icregexeqjoinsel ));
 #define OID_TEXT_ICREGEXEQ_OP		1228
-DATA(insert OID = 1229 (  "!~*"		 PGUID 0 b t f	25	25	16 0 1228  0 0 texticregexne neqsel neqjoinsel ));
-DATA(insert OID = 1232 (  "~*"		PGUID 0 b t f  1043  25  16 0 1233	0 0 texticregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1229 (  "!~*"		 PGUID 0 b t f	25	25	16 0 1228  0 0 texticregexne icregexnesel icregexnejoinsel ));
+DATA(insert OID = 1232 (  "~*"		PGUID 0 b t f  1043  25  16 0 1233	0 0 texticregexeq icregexeqsel icregexeqjoinsel ));
 #define OID_VARCHAR_ICREGEXEQ_OP		1232
-DATA(insert OID = 1233 ( "!~*"		PGUID 0 b t f  1043  25  16 0 1232	0 0 texticregexne neqsel neqjoinsel ));
-DATA(insert OID = 1234 (  "~*"		PGUID 0 b t f  1042  25  16 0 1235	0 0 texticregexeq eqsel eqjoinsel ));
+DATA(insert OID = 1233 ( "!~*"		PGUID 0 b t f  1043  25  16 0 1232	0 0 texticregexne icregexnesel icregexnejoinsel ));
+DATA(insert OID = 1234 (  "~*"		PGUID 0 b t f  1042  25  16 0 1235	0 0 texticregexeq icregexeqsel icregexeqjoinsel ));
 #define OID_BPCHAR_ICREGEXEQ_OP		1234
-DATA(insert OID = 1235 ( "!~*"		PGUID 0 b t f  1042  25  16 0 1234	0 0 texticregexne neqsel neqjoinsel ));
+DATA(insert OID = 1235 ( "!~*"		PGUID 0 b t f  1042  25  16 0 1234	0 0 texticregexne icregexnesel icregexnejoinsel ));
 
 /* timestamp operators */
 /* name, owner, prec, kind, isleft, canhash, left, right, result, com, negate, lsortop, rsortop, oprcode, operrest, oprjoin */

src/include/catalog/pg_proc.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: pg_proc.h,v 1.147 2000/07/14 22:17:56 tgl Exp $
+ * $Id: pg_proc.h,v 1.148 2000/07/17 03:05:25 tgl Exp $
  *
  * NOTES
  *	  The script catalog/genbki.sh reads this file and generates .bki
@@ -433,8 +433,8 @@ DATA(insert OID = 206 (  float4um		   PGUID 11 f t t t 1 f 700 "700" 100 0 0 100
 DESCR("negate");
 DATA(insert OID = 207 (  float4abs		   PGUID 11 f t t t 1 f 700 "700" 100 0 0 100  float4abs - ));
 DESCR("absolute value");
-DATA(insert OID = 208 (  float4inc		   PGUID 11 f t t t 1 f 700 "700" 100 0 0 100  float4inc - ));
-DESCR("increment");
+DATA(insert OID = 208 (  float4_accum	   PGUID 12 f t t t 2 f 1022 "1022 700" 100 0 0 100  float4_accum - ));
+DESCR("aggregate transition function");
 DATA(insert OID = 209 (  float4larger	   PGUID 11 f t t t 2 f 700 "700 700" 100 0 0 100  float4larger - ));
 DESCR("larger of two");
 DATA(insert OID = 211 (  float4smaller	   PGUID 11 f t t t 2 f 700 "700 700" 100 0 0 100  float4smaller - ));
@@ -461,8 +461,8 @@ DATA(insert OID = 220 (  float8um		   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100
 DESCR("negate");
 DATA(insert OID = 221 (  float8abs		   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100  float8abs - ));
 DESCR("absolute value");
-DATA(insert OID = 222 (  float8inc		   PGUID 11 f t t t 1 f 701 "701" 100 0 0 100  float8inc - ));
-DESCR("increment");
+DATA(insert OID = 222 (  float8_accum	   PGUID 12 f t t t 2 f 1022 "1022 701" 100 0 0 100  float8_accum - ));
+DESCR("aggregate transition function");
 DATA(insert OID = 223 (  float8larger	   PGUID 11 f t t t 2 f 701 "701 701" 100 0 0 100  float8larger - ));
 DESCR("larger of two");
 DATA(insert OID = 224 (  float8smaller	   PGUID 11 f t t t 2 f 701 "701 701" 100 0 0 100  float8smaller - ));
@@ -1004,8 +1004,6 @@ DESCR("large object export");
 
 DATA(insert OID = 766 (  int4inc		   PGUID 12 f t t t 1 f 23 "23" 100 0 0 100  int4inc - ));
 DESCR("increment");
-DATA(insert OID = 767 (  int2inc		   PGUID 12 f t t t 1 f 21 "21" 100 0 0 100  int2inc - ));
-DESCR("increment");
 DATA(insert OID = 768 (  int4larger		   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4larger - ));
 DESCR("larger of two");
 DATA(insert OID = 769 (  int4smaller	   PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100  int4smaller - ));
@@ -1181,8 +1179,6 @@ DATA(insert OID = 944 (  char			   PGUID 12 f t t t 1 f 18 "25" 100 0 0 100  tex
 DESCR("convert text to char");
 DATA(insert OID = 946 (  text			   PGUID 12 f t t t 1 f 25 "18" 100 0 0 100  char_text - ));
 DESCR("convert char to text");
-DATA(insert OID = 948 (  varchar		   PGUID 12 f t t t 1 f 25 "1043" 100 0 0 100  bpchar_char - ));
-DESCR("convert varchar() to text");
 
 DATA(insert OID = 950 (  istrue			   PGUID 12 f t t f 1 f 16 "16" 100 0 0 100  istrue - ));
 DESCR("bool is true (not false or unknown)");
@@ -2395,8 +2391,6 @@ DATA(insert OID = 1746 ( float8					PGUID 11 f t t t 1 f 701 "1700" 100 0 0 100
 DESCR("(internal)");
 DATA(insert OID = 1764 ( numeric_inc			PGUID 11 f t t t 1 f 1700 "1700" 100 0 0 100	numeric_inc - ));
 DESCR("increment by one");
-DATA(insert OID = 1765 ( numeric_dec			PGUID 11 f t t t 1 f 1700 "1700" 100 0 0 100	numeric_dec - ));
-DESCR("decrement by one");
 DATA(insert OID = 1766 ( numeric_smaller		PGUID 11 f t t t 2 f 1700 "1700 1700" 100 0 0 100  numeric_smaller - ));
 DESCR("smaller of two numbers");
 DATA(insert OID = 1767 ( numeric_larger			PGUID 11 f t t t 2 f 1700 "1700 1700" 100 0 0 100  numeric_larger - ));
@@ -2407,7 +2401,7 @@ DATA(insert OID = 1771 ( numeric_uminus			PGUID 11 f t t t 1 f 1700 "1700" 100 0
 DESCR("negate");
 DATA(insert OID = 1779 ( int8					PGUID 11 f t t t 1 f 20 "1700" 100 0 0 100  numeric_int8 - ));
 DESCR("(internal)");
-DATA(insert OID = 1781 ( numeric				PGUID 11 f t t t 1 f 1700 "20" 100 0 0 100  int8_numeric - ));
+DATA(insert OID = 1781 ( numeric				PGUID 12 f t t t 1 f 1700 "20" 100 0 0 100  int8_numeric - ));
 DESCR("(internal)");
 DATA(insert OID = 1782 ( numeric				PGUID 12 f t t t 1 f 1700 "21" 100 0 0 100  int2_numeric - ));
 DESCR("(internal)");
@@ -2465,6 +2459,38 @@ DESCR("join selectivity of NOT LIKE");
 DATA(insert OID = 1829 ( icregexnejoinsel	PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100	icregexnejoinsel - ));
 DESCR("join selectivity of case-insensitive regex non-match");
 
+/* Aggregate-related functions */
+DATA(insert OID = 1830 (  float8_avg	   PGUID 12 f t t t 1 f 701 "1022" 100 0 0 100  float8_avg - ));
+DESCR("AVG aggregate final function");
+DATA(insert OID = 1831 (  float8_variance  PGUID 12 f t t t 1 f 701 "1022" 100 0 0 100  float8_variance - ));
+DESCR("VARIANCE aggregate final function");
+DATA(insert OID = 1832 (  float8_stddev	   PGUID 12 f t t t 1 f 701 "1022" 100 0 0 100  float8_stddev - ));
+DESCR("STDDEV aggregate final function");
+DATA(insert OID = 1833 (  numeric_accum	   PGUID 12 f t t t 2 f 1231 "1231 1700" 100 0 0 100  numeric_accum - ));
+DESCR("aggregate transition function");
+DATA(insert OID = 1834 (  int2_accum	   PGUID 12 f t t t 2 f 1231 "1231 21" 100 0 0 100  int2_accum - ));
+DESCR("aggregate transition function");
+DATA(insert OID = 1835 (  int4_accum	   PGUID 12 f t t t 2 f 1231 "1231 23" 100 0 0 100  int4_accum - ));
+DESCR("aggregate transition function");
+DATA(insert OID = 1836 (  int8_accum	   PGUID 12 f t t t 2 f 1231 "1231 20" 100 0 0 100  int8_accum - ));
+DESCR("aggregate transition function");
+DATA(insert OID = 1837 (  numeric_avg	   PGUID 12 f t t t 1 f 1700 "1231" 100 0 0 100  numeric_avg - ));
+DESCR("AVG aggregate final function");
+DATA(insert OID = 1838 (  numeric_variance PGUID 12 f t t t 1 f 1700 "1231" 100 0 0 100  numeric_variance - ));
+DESCR("VARIANCE aggregate final function");
+DATA(insert OID = 1839 (  numeric_stddev   PGUID 12 f t t t 1 f 1700 "1231" 100 0 0 100  numeric_stddev - ));
+DESCR("STDDEV aggregate final function");
+DATA(insert OID = 1840 (  int2_sum		   PGUID 12 f t t f 2 f 1700 "1700 21" 100 0 0 100  int2_sum - ));
+DESCR("SUM(int2) transition function");
+DATA(insert OID = 1841 (  int4_sum		   PGUID 12 f t t f 2 f 1700 "1700 23" 100 0 0 100  int4_sum - ));
+DESCR("SUM(int4) transition function");
+DATA(insert OID = 1842 (  int8_sum		   PGUID 12 f t t f 2 f 1700 "1700 20" 100 0 0 100  int8_sum - ));
+DESCR("SUM(int8) transition function");
+DATA(insert OID = 1843 (  interval_accum   PGUID 12 f t t t 2 f 1187 "1187 1186" 100 0 0 100  interval_accum - ));
+DESCR("aggregate transition function");
+DATA(insert OID = 1844 (  interval_avg	   PGUID 12 f t t t 1 f 1186 "1187" 100 0 0 100  interval_avg - ));
+DESCR("AVG aggregate final function");
+
 
 /*
  * prototypes for functions pg_proc.c

src/include/nodes/primnodes.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: primnodes.h,v 1.43 2000/06/12 19:40:49 momjian Exp $
+ * $Id: primnodes.h,v 1.44 2000/07/17 03:05:27 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -301,10 +301,9 @@ typedef struct Iter
  *		basetype		- base type Oid of the aggregate (ie, input type)
  *		aggtype			- type Oid of final result of the aggregate
  *		target			- attribute or expression we are aggregating on
- *		usenulls		- TRUE to accept null values as inputs
  *		aggstar			- TRUE if argument was really '*'
- *		aggdistinct		- TRUE if arguments were labeled DISTINCT
- *		aggno			- workspace for nodeAgg.c executor
+ *		aggdistinct		- TRUE if it's agg(DISTINCT ...)
+ *		aggno			- workspace for executor (see nodeAgg.c)
  * ----------------
  */
 typedef struct Aggref
@@ -314,7 +313,6 @@ typedef struct Aggref
 	Oid			basetype;
 	Oid			aggtype;
 	Node	   *target;
-	bool		usenulls;
 	bool		aggstar;
 	bool		aggdistinct;
 	int			aggno;

src/include/storage/lock.h

@@ -7,18 +7,16 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: lock.h,v 1.38 2000/05/31 00:28:38 petere Exp $
+ * $Id: lock.h,v 1.39 2000/07/17 03:05:30 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 #ifndef LOCK_H_
 #define LOCK_H_
 
-#include "postgres.h"
 #include "storage/ipc.h"
 #include "storage/itemptr.h"
 #include "storage/shmem.h"
-#include "utils/array.h"
 
 extern SPINLOCK LockMgrLock;
 typedef int LOCKMASK;

src/include/utils/array.h

@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: array.h,v 1.25 2000/06/13 07:35:30 tgl Exp $
+ * $Id: array.h,v 1.26 2000/07/17 03:05:32 tgl Exp $
  *
  * NOTES
  *	  XXX the data array should be MAXALIGN'd -- notice that the array
@@ -24,15 +24,27 @@
 #define ARRAY_H
 
 #include "fmgr.h"
-#include "utils/memutils.h"
 
+/*
+ * Arrays are varlena objects, so must meet the varlena convention that
+ * the first int32 of the object contains the total object size in bytes.
+ */
 typedef struct
 {
-	int			size;			/* total array size (in bytes) */
+	int32		size;			/* total array size (varlena requirement) */
 	int			ndim;			/* # of dimensions */
 	int			flags;			/* implementation flags */
 } ArrayType;
 
+/*
+ * fmgr macros for array objects
+ */
+#define DatumGetArrayTypeP(X)         ((ArrayType *) PG_DETOAST_DATUM(X))
+#define DatumGetArrayTypePCopy(X)     ((ArrayType *) PG_DETOAST_DATUM_COPY(X))
+#define PG_GETARG_ARRAYTYPE_P(n)      DatumGetArrayTypeP(PG_GETARG_DATUM(n))
+#define PG_GETARG_ARRAYTYPE_P_COPY(n) DatumGetArrayTypePCopy(PG_GETARG_DATUM(n))
+#define PG_RETURN_ARRAYTYPE_P(x)      PG_RETURN_POINTER(x)
+
 /*
  * bitmask of ArrayType flags field:
  * 1st bit - large object flag
@@ -43,11 +55,9 @@ typedef struct
 #define ARR_CHK_FLAG	(0x2)
 #define ARR_OBJ_MASK	(0x1c)
 
-#define ARR_FLAGS(a)			((ArrayType *) a)->flags
 #define ARR_SIZE(a)				(((ArrayType *) a)->size)
-
 #define ARR_NDIM(a)				(((ArrayType *) a)->ndim)
-#define ARR_NDIM_PTR(a)			(&(((ArrayType *) a)->ndim))
+#define ARR_FLAGS(a)			(((ArrayType *) a)->flags)
 
 #define ARR_IS_LO(a) \
 		(((ArrayType *) a)->flags & ARR_LOB_FLAG)
@@ -102,7 +112,6 @@ typedef struct
 #define RETURN_NULL(type)  do { *isNull = true; return (type) 0; } while (0)
 
 #define NAME_LEN	30
-#define MAX_BUFF_SIZE BLCKSZ
 
 typedef struct
 {
@@ -134,6 +143,12 @@ extern ArrayType *array_assgn(ArrayType *array, int nSubscripts,
 							  bool elmbyval, int elmlen, bool *isNull);
 extern Datum array_map(FunctionCallInfo fcinfo, Oid inpType, Oid retType);
 
+extern ArrayType *construct_array(Datum *elems, int nelems,
+								  bool elmbyval, int elmlen, char elmalign);
+extern void deconstruct_array(ArrayType *array,
+							  bool elmbyval, int elmlen, char elmalign,
+							  Datum **elemsp, int *nelemsp);
+
 extern int _LOtransfer(char **destfd, int size, int nitems, char **srcfd,
 			int isSrcLO, int isDestLO);
 extern char *_array_newLO(int *fd, int flag);

src/include/utils/builtins.h

@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: builtins.h,v 1.123 2000/07/09 21:30:21 petere Exp $
+ * $Id: builtins.h,v 1.124 2000/07/17 03:05:32 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -110,7 +110,6 @@ extern Datum int2mi(PG_FUNCTION_ARGS);
 extern Datum int2mul(PG_FUNCTION_ARGS);
 extern Datum int2div(PG_FUNCTION_ARGS);
 extern Datum int2abs(PG_FUNCTION_ARGS);
-extern Datum int2inc(PG_FUNCTION_ARGS);
 extern Datum int24pl(PG_FUNCTION_ARGS);
 extern Datum int24mi(PG_FUNCTION_ARGS);
 extern Datum int24mul(PG_FUNCTION_ARGS);
@@ -207,12 +206,10 @@ extern float32 float4pl(float32 arg1, float32 arg2);
 extern float32 float4mi(float32 arg1, float32 arg2);
 extern float32 float4mul(float32 arg1, float32 arg2);
 extern float32 float4div(float32 arg1, float32 arg2);
-extern float32 float4inc(float32 arg1);
 extern float64 float8pl(float64 arg1, float64 arg2);
 extern float64 float8mi(float64 arg1, float64 arg2);
 extern float64 float8mul(float64 arg1, float64 arg2);
 extern float64 float8div(float64 arg1, float64 arg2);
-extern float64 float8inc(float64 arg1);
 extern bool float4eq(float32 arg1, float32 arg2);
 extern bool float4ne(float32 arg1, float32 arg2);
 extern bool float4lt(float32 arg1, float32 arg2);
@@ -261,6 +258,11 @@ extern float64 radians(float64 arg1);
 extern float64 dtan(float64 arg1);
 extern float64 drandom(void);
 extern int32 setseed(float64 seed);
+extern Datum float8_accum(PG_FUNCTION_ARGS);
+extern Datum float4_accum(PG_FUNCTION_ARGS);
+extern Datum float8_avg(PG_FUNCTION_ARGS);
+extern Datum float8_variance(PG_FUNCTION_ARGS);
+extern Datum float8_stddev(PG_FUNCTION_ARGS);
 
 extern float64 float48pl(float32 arg1, float64 arg2);
 extern float64 float48mi(float32 arg1, float64 arg2);
@@ -545,7 +547,6 @@ extern Numeric numeric_mul(Numeric num1, Numeric num2);
 extern Numeric numeric_div(Numeric num1, Numeric num2);
 extern Numeric numeric_mod(Numeric num1, Numeric num2);
 extern Numeric numeric_inc(Numeric num);
-extern Numeric numeric_dec(Numeric num);
 extern Numeric numeric_smaller(Numeric num1, Numeric num2);
 extern Numeric numeric_larger(Numeric num1, Numeric num2);
 extern Numeric numeric_sqrt(Numeric num);
@@ -555,14 +556,24 @@ extern Numeric numeric_log(Numeric num1, Numeric num2);
 extern Numeric numeric_power(Numeric num1, Numeric num2);
 extern Datum int4_numeric(PG_FUNCTION_ARGS);
 extern int32 numeric_int4(Numeric num);
-extern Numeric int8_numeric(int64 *val);
+extern Datum int8_numeric(PG_FUNCTION_ARGS);
 extern int64 *numeric_int8(Numeric num);
 extern Datum int2_numeric(PG_FUNCTION_ARGS);
 extern Datum numeric_int2(PG_FUNCTION_ARGS);
-extern Numeric float4_numeric(float32 val);
-extern float32 numeric_float4(Numeric num);
 extern Numeric float8_numeric(float64 val);
 extern float64 numeric_float8(Numeric num);
+extern Numeric float4_numeric(float32 val);
+extern float32 numeric_float4(Numeric num);
+extern Datum numeric_accum(PG_FUNCTION_ARGS);
+extern Datum int2_accum(PG_FUNCTION_ARGS);
+extern Datum int4_accum(PG_FUNCTION_ARGS);
+extern Datum int8_accum(PG_FUNCTION_ARGS);
+extern Datum numeric_avg(PG_FUNCTION_ARGS);
+extern Datum numeric_variance(PG_FUNCTION_ARGS);
+extern Datum numeric_stddev(PG_FUNCTION_ARGS);
+extern Datum int2_sum(PG_FUNCTION_ARGS);
+extern Datum int4_sum(PG_FUNCTION_ARGS);
+extern Datum int8_sum(PG_FUNCTION_ARGS);
 
 /* lztext.c */
 extern lztext  *lztextin(char *str);

src/include/utils/numeric.h

@@ -5,7 +5,7 @@
  *
  *	1998 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/include/utils/numeric.h,v 1.10 2000/06/13 07:35:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/include/utils/numeric.h,v 1.11 2000/07/17 03:05:32 tgl Exp $
  *
  * ----------
  */
@@ -55,7 +55,7 @@
  * all leading and trailing zeroes (except there will be a trailing zero
  * in the last byte, if the number of digits is odd).  In particular,
  * if the value is zero, there will be no digits at all!  The weight is
- * arbitrary in this case, but we normally set it to zero.
+ * arbitrary in that case, but we normally set it to zero.
  * ----------
  */
 typedef struct NumericData
@@ -75,9 +75,11 @@ typedef NumericData *Numeric;
  * fmgr interface macros
  */
 
-#define DatumGetNumeric(X)    ((Numeric) PG_DETOAST_DATUM(X))
-#define NumericGetDatum(X)    PointerGetDatum(X)
-#define PG_GETARG_NUMERIC(n)  DatumGetNumeric(PG_GETARG_DATUM(n))
-#define PG_RETURN_NUMERIC(x)  return NumericGetDatum(x)
+#define DatumGetNumeric(X)        ((Numeric) PG_DETOAST_DATUM(X))
+#define DatumGetNumericCopy(X)    ((Numeric) PG_DETOAST_DATUM_COPY(X))
+#define NumericGetDatum(X)        PointerGetDatum(X)
+#define PG_GETARG_NUMERIC(n)      DatumGetNumeric(PG_GETARG_DATUM(n))
+#define PG_GETARG_NUMERIC_COPY(n) DatumGetNumericCopy(PG_GETARG_DATUM(n))
+#define PG_RETURN_NUMERIC(x)      return NumericGetDatum(x)
 
 #endif	 /* _PG_NUMERIC_H_ */