<row>

<entry><structfield>aggfinalmodify</structfield></entry>

<entry><type>char</type></entry>

<entry></entry>

<entry>Whether <structfield>aggfinalfn</structfield> modifies the

transition state value:

<literal>r</literal> if it is read-only,

<literal>s</literal> if the <structfield>aggtransfn</structfield>

cannot be applied after the <structfield>aggfinalfn</structfield>, or

<literal>w</literal> if it writes on the value

</entry>

</row>

<row>

<entry><structfield>aggmfinalmodify</structfield></entry>

<entry><type>char</type></entry>

<entry></entry>

<entry>Like <structfield>aggfinalmodify</structfield>, but for

the <structfield>aggmfinalfn</structfield>

</entry>

</row>

[ , FINALFUNC_MODIFY = { READ_ONLY | SHARABLE | READ_WRITE } ]

[ , MFINALFUNC_MODIFY = { READ_ONLY | SHARABLE | READ_WRITE } ]

[ , FINALFUNC_MODIFY = { READ_ONLY | SHARABLE | READ_WRITE } ]

[ , FINALFUNC_MODIFY = { READ_ONLY | SHARABLE | READ_WRITE } ]

[ , MFINALFUNC_MODIFY = { READ_ONLY | SHARABLE | READ_WRITE } ]

the <literal>MSPACE</>, <literal>MFINALFUNC</>,

<literal>MFINALFUNC_EXTRA</>, <literal>MFINALFUNC_MODIFY</>,

<varlistentry>

<term><literal>FINALFUNC_MODIFY</> = { <literal>READ_ONLY</> | <literal>SHARABLE</> | <literal>READ_WRITE</> }</term>

<listitem>

<para>

This option specifies whether the final function is a pure function

that does not modify its arguments. <literal>READ_ONLY</> indicates

it does not; the other two values indicate that it may change the

transition state value. See <xref linkend="sql-createaggregate-notes"

endterm="sql-createaggregate-notes-title"> below for more detail. The

default is <literal>READ_ONLY</>, except for ordered-set aggregates,

for which the default is <literal>READ_WRITE</>.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><literal>MFINALFUNC_MODIFY</> = { <literal>READ_ONLY</> | <literal>SHARABLE</> | <literal>READ_WRITE</> }</term>

<listitem>

<para>

This option is like <literal>FINALFUNC_MODIFY</>, but it describes

the behavior of the moving-aggregate final function.

</para>

</listitem>

</varlistentry>

<term><literal>PARALLEL =</> { <literal>SAFE</> | <literal>RESTRICTED</> | <literal>UNSAFE</> }</term>

in <xref linkend="sql-createfunction">. An aggregate will not be

<refsect1 id="sql-createaggregate-notes">

<title id="sql-createaggregate-notes-title">Notes</title>

<para>

Ordinarily, Postgres functions are expected to be true functions that

do not modify their input values. However, an aggregate transition

function, <emphasis>when used in the context of an aggregate</>,

is allowed to cheat and modify its transition-state argument in place.

This can provide substantial performance benefits compared to making

a fresh copy of the transition state each time.

</para>

<para>

Likewise, while an aggregate final function is normally expected not to

modify its input values, sometimes it is impractical to avoid modifying

the transition-state argument. Such behavior must be declared using

the <literal>FINALFUNC_MODIFY</> parameter. The <literal>READ_WRITE</>

value indicates that the final function modifies the transition state in

unspecified ways. This value prevents use of the aggregate as a window

function, and it also prevents merging of transition states for aggregate

calls that share the same input values and transition functions.

The <literal>SHARABLE</> value indicates that the transition function

cannot be applied after the final function, but multiple final-function

calls can be performed on the ending transition state value. This value

prevents use of the aggregate as a window function, but it allows merging

of transition states. (That is, the optimization of interest here is not

applying the same final function repeatedly, but applying different final

functions to the same ending transition state value. This is allowed as

long as none of the final functions are marked <literal>READ_WRITE</>.)

</para>

to the aggregate's state. This is why use of an aggregate as a window

function requires that the final function be read-only: it must

Also, because the final function performs the sort, it is not possible

to continue adding input rows by executing the transition function again

later. This means the final function is not <literal>READ_ONLY</>;

it must be declared in <xref linkend="sql-createaggregate">

as <literal>READ_WRITE</>, or as <literal>SHARABLE</> if it's

possible for additional final-function calls to make use of the

already-sorted state.

One reason for checking this is that when it is true, the first input

(While aggregate transition functions are always allowed to modify

the transition value in-place, aggregate final functions are generally

discouraged from doing so; if they do so, the behavior must be declared

when creating the aggregate. See <xref linkend="sql-createaggregate">

for more detail.)

#include "catalog/pg_aggregate_fn.h"

char finalfnModify,

char mfinalfnModify,

values[Anum_pg_aggregate_aggfinalmodify - 1] = CharGetDatum(finalfnModify);

values[Anum_pg_aggregate_aggmfinalmodify - 1] = CharGetDatum(mfinalfnModify);

#include "catalog/pg_aggregate_fn.h"

static char extractModify(DefElem *defel);

char finalfuncModify = 0;

char mfinalfuncModify = 0;

else if (pg_strcasecmp(defel->defname, "finalfunc_modify") == 0)

finalfuncModify = extractModify(defel);

else if (pg_strcasecmp(defel->defname, "mfinalfunc_modify") == 0)

mfinalfuncModify = extractModify(defel);

/*

if (finalfuncModify == 0)

finalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;

if (mfinalfuncModify == 0)

mfinalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;

finalfuncModify,

mfinalfuncModify,

static char

extractModify(DefElem *defel)

{

char *val = defGetString(defel);

if (strcmp(val, "read_only") == 0)

return AGGMODIFY_READ_ONLY;

if (strcmp(val, "sharable") == 0)

return AGGMODIFY_SHARABLE;

if (strcmp(val, "read_write") == 0)

return AGGMODIFY_READ_WRITE;

ereport(ERROR,

(errcode(ERRCODE_SYNTAX_ERROR),

errmsg("parameter \"%s\" must be READ_ONLY, SHARABLE, or READ_WRITE",

defel->defname)));

return 0; /* keep compiler quiet */

}