-<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.183 2008/11/21 19:31:58 mha Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.184 2008/12/18 18:20:33 tgl Exp $ -->
<!--
Documentation of the system catalogs, directed toward PostgreSQL developers
-->
<entry><structfield>pronargs</structfield></entry>
<entry><type>int2</type></entry>
<entry></entry>
- <entry>Number of arguments</entry>
+ <entry>Number of input arguments</entry>
+ </row>
+
+ <row>
+ <entry><structfield>pronargdefaults</structfield></entry>
+ <entry><type>int2</type></entry>
+ <entry></entry>
+ <entry>Number of arguments that have defaults</entry>
</row>
<row>
</entry>
</row>
+ <row>
+ <entry><structfield>proargdefaults</structfield></entry>
+ <entry><type>text</type></entry>
+ <entry></entry>
+ <entry>
+ Expression trees (in <function>nodeToString()</function> representation)
+ for default values. This is a list with
+ <structfield>pronargdefaults</> elements, corresponding to the last
+ <replaceable>N</> <emphasis>input</> arguments (i.e., the last
+ <replaceable>N</> <structfield>proargtypes</> positions).
+ If none of the arguments have defaults, this field will be null
+ </entry>
+ </row>
+
<row>
<entry><structfield>prosrc</structfield></entry>
<entry><type>text</type></entry>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.461 2008/12/04 17:51:26 petere Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/func.sgml,v 1.462 2008/12/18 18:20:33 tgl Exp $ -->
<chapter id="functions">
<title>Functions and Operators</title>
<row>
<entry><literal><function>pg_get_function_identity_arguments</function>(<parameter>func_oid</parameter>)</literal></entry>
<entry><type>text</type></entry>
- <entry>get argument list to identify a function (without argument names, default values)</entry>
+ <entry>get argument list to identify a function (without default values)</entry>
</row>
<row>
<entry><literal><function>pg_get_function_result</function>(<parameter>func_oid</parameter>)</literal></entry>
of a function, in the form it would need to appear in within
<command>CREATE FUNCTION</>.
<function>pg_get_function_result</function> similarly returns the
- appropriate <literal>RETURNS</> clause for the function.
+ appropriate <literal>RETURNS</> clause for the function.
<function>pg_get_function_identity_arguments</function> returns the
argument list necessary to identify a function, in the form it
would need to appear in within <command>ALTER FUNCTION</>, for
- instance. This form omits default values and argument names, for
- example.
+ instance. This form omits default values.
</para>
<para>
<!--
-$PostgreSQL: pgsql/doc/src/sgml/ref/create_function.sgml,v 1.82 2008/12/04 17:51:26 petere Exp $
+$PostgreSQL: pgsql/doc/src/sgml/ref/create_function.sgml,v 1.83 2008/12/18 18:20:33 tgl Exp $
-->
<refentry id="SQL-CREATEFUNCTION">
<refsynopsisdiv>
<synopsis>
CREATE [ OR REPLACE ] FUNCTION
- <replaceable class="parameter">name</replaceable> ( [ [ <replaceable class="parameter">argmode</replaceable> ] [ <replaceable class="parameter">argname</replaceable> ] <replaceable class="parameter">argtype</replaceable> [ { DEFAULT | = } <replaceable class="parameter">defexpr</replaceable>] [, ...] ] )
+ <replaceable class="parameter">name</replaceable> ( [ [ <replaceable class="parameter">argmode</replaceable> ] [ <replaceable class="parameter">argname</replaceable> ] <replaceable class="parameter">argtype</replaceable> [ { DEFAULT | = } <replaceable class="parameter">defexpr</replaceable> ] [, ...] ] )
[ RETURNS <replaceable class="parameter">rettype</replaceable>
| RETURNS TABLE ( <replaceable class="parameter">colname</replaceable> <replaceable class="parameter">coltype</replaceable> [, ...] ) ]
{ LANGUAGE <replaceable class="parameter">langname</replaceable>
[ WITH ( <replaceable class="parameter">attribute</replaceable> [, ...] ) ]
</synopsis>
</refsynopsisdiv>
-
+
<refsect1 id="sql-createfunction-description">
<title>Description</title>
<listitem>
<para>
- The data type(s) of the function's arguments (optionally
+ The data type(s) of the function's arguments (optionally
schema-qualified), if any. The argument types can be base, composite,
or domain types, or can reference the type of a table column.
</para>
<listitem>
<para>
An expression to be used as default value if the parameter is
- not specified. The expression has to be convertable to the
- argument type of the parameter. All parameters after a
- parameter with default value have to be parameters with default
- values as well.
+ not specified. The expression has to be coercible to the
+ argument type of the parameter.
+ Only input (including <literal>INOUT</>) parameters can have a default
+ value. All input parameters following a
+ parameter with a default value must have default values as well.
</para>
</listitem>
</varlistentry>
<listitem>
<para>
- The return data type (optionally schema-qualified). The return type
+ The return data type (optionally schema-qualified). The return type
can be a base, composite, or domain type,
or can reference the type of a table column.
Depending on the implementation language it might also be allowed
</programlisting>
</para>
+ <para>
+ Functions that have different argument type lists will not be considered
+ to conflict at creation time, but if defaults are provided they might
+ conflict in use. For example, consider
+<programlisting>
+CREATE FUNCTION foo(int) ...
+CREATE FUNCTION foo(int, int default 42) ...
+</programlisting>
+ A call <literal>foo(10)</> will fail due to the ambiguity about which
+ function should be called.
+ </para>
+
<para>
When repeated <command>CREATE FUNCTION</command> calls refer to
the same object file, the file is only loaded once per session.
</refsect1>
-
<refsect1 id="sql-createfunction-compat">
<title>Compatibility</title>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/typeconv.sgml,v 1.57 2008/07/30 19:35:12 tgl Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/typeconv.sgml,v 1.58 2008/12/18 18:20:33 tgl Exp $ -->
<chapter Id="typeconv">
<title>Type Conversion</title>
function might have effective argument types identical to some non-variadic
function. In that case the function appearing earlier in the search path is
used, or if the two functions are in the same schema, the non-variadic one is
-selected.
+preferred.
+</para>
+</step>
+<step performance="optional">
+<para>
+Functions that have default values for parameters are considered to match any
+call that omits zero or more of the defaultable parameter positions. If more
+than one such function matches a call, the one appearing earliest in the
+search path is used. If there are two or more such functions in the same
+schema with identical parameter types in the non-defaulted positions (which is
+possible if they have different sets of defaultable parameters), the system
+will not be able to determine which to prefer, and so an <quote>ambiguous
+function call</> error will result if no better match to the call can be
+found.
</para>
</step>
</substeps>
-<!-- $PostgreSQL: pgsql/doc/src/sgml/xfunc.sgml,v 1.135 2008/12/07 23:46:39 alvherre Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/xfunc.sgml,v 1.136 2008/12/18 18:20:33 tgl Exp $ -->
<sect1 id="xfunc">
<title>User-Defined Functions</title>
</para>
</sect2>
- <sect2 id="xfunc-parameter-defaults">
- <title><acronym>SQL</> Functions with Parameters Default Values</title>
+ <sect2 id="xfunc-sql-parameter-defaults">
+ <title><acronym>SQL</> Functions with Default Values for Arguments</title>
<indexterm>
- <primary>default values</primary>
+ <primary>function</primary>
+ <secondary>default values for arguments</secondary>
</indexterm>
<para>
- Functions can be declared with parameters with default values or
- expressions. The default expressions are used as parameter value
- if the parameter is not explicitly specified in a function call.
- All parameters after a a parameter with default value have to be
- parameters with default values as well.
+ Functions can be declared with default values for some or all input
+ arguments. The default values are inserted whenever the function is
+ called with insufficiently many actual arguments. Since arguments
+ can only be omitted from the end of the actual argument list, all
+ parameters after a parameter with a default value have to have
+ default values as well.
</para>
<para>
For example:
<screen>
-CREATE FUNCTION foo(a int DEFAULT 1, b int DEFAULT 2, c int DEFAULT 3)
+CREATE FUNCTION foo(a int, b int DEFAULT 2, c int DEFAULT 3)
RETURNS int
LANGUAGE SQL
AS $$
15
(1 row)
-SELECT foo();
- foo
------
- 6
-(1 row)
+SELECT foo(); -- fails since there is no default for the first argument
+ERROR: function foo() does not exist
</screen>
- Instead of the key word <literal>DEFAULT</literal>,
- the <literal>=</literal> sign can also be used.
+ The <literal>=</literal> sign can also be used in place of the
+ key word <literal>DEFAULT</literal>,
</para>
</sect2>
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.114 2008/12/15 18:09:40 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.115 2008/12/18 18:20:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* retrieve a list of the possible matches.
*
* If nargs is -1, we return all functions matching the given name,
- * regardless of argument count. (expand_variadic must be false in this case.)
+ * regardless of argument count. (expand_variadic and expand_defaults must be
+ * false in this case.)
*
* If expand_variadic is true, then variadic functions having the same number
* or fewer arguments will be retrieved, with the variadic argument and any
* If expand_variadic is false, variadic arguments are not treated specially,
* and the returned nvargs will always be zero.
*
- * If expand_variadic is true, functions with argument default values
- * will also be retrieved. If expand_variadic is false, default
- * values will not be taken into account and functions that do not
- * have exactly nargs arguments in total will not be considered.
+ * If expand_defaults is true, functions that could match after insertion of
+ * default argument values will also be retrieved. In this case the returned
+ * structs could have nargs > passed-in nargs, and ndargs is set to the number
+ * of additional args (which can be retrieved from the function's
+ * proargdefaults entry).
+ *
+ * It is not possible for nvargs and ndargs to both be nonzero in the same
+ * list entry, since default insertion allows matches to functions with more
+ * than nargs arguments while the variadic transformation requires the same
+ * number or less.
*
* We search a single namespace if the function name is qualified, else
- * all namespaces in the search path. The return list will never contain
- * multiple entries with identical argument lists --- in the multiple-
- * namespace case, we arrange for entries in earlier namespaces to mask
- * identical entries in later namespaces. We also arrange for non-variadic
- * functions to mask variadic ones if the expanded argument list is the same.
+ * all namespaces in the search path. In the multiple-namespace case,
+ * we arrange for entries in earlier namespaces to mask identical entries in
+ * later namespaces.
+ *
+ * When expanding variadics, we arrange for non-variadic functions to mask
+ * variadic ones if the expanded argument list is the same. It is still
+ * possible for there to be conflicts between different variadic functions,
+ * however.
+ *
+ * It is guaranteed that the return list will never contain multiple entries
+ * with identical argument lists. When expand_defaults is true, the entries
+ * could have more than nargs positions, but we still guarantee that they are
+ * distinct in the first nargs positions. However, if either expand_variadic
+ * or expand_defaults is true, there might be multiple candidate functions
+ * that expand to identical argument lists. Rather than throw error here,
+ * we report such situations by setting oid = 0 in the ambiguous entries.
+ * The caller might end up discarding such an entry anyway, but if it selects
+ * such an entry it should react as though the call were ambiguous.
*/
FuncCandidateList
-FuncnameGetCandidates(List *names, int nargs, bool expand_variadic)
+FuncnameGetCandidates(List *names, int nargs,
+ bool expand_variadic, bool expand_defaults)
{
FuncCandidateList resultList = NULL;
- bool any_variadic = false;
+ bool any_special = false;
char *schemaname;
char *funcname;
Oid namespaceId;
int i;
/* check for caller error */
- Assert(nargs >= 0 || !expand_variadic);
+ Assert(nargs >= 0 || !(expand_variadic | expand_defaults));
/* deconstruct the name list */
DeconstructQualifiedName(names, &schemaname, &funcname);
int effective_nargs;
int pathpos = 0;
bool variadic;
+ bool use_defaults;
Oid va_elem_type;
- List *defaults = NIL;
FuncCandidateList newResult;
- /*
- * Check if function has some parameter defaults if some
- * parameters are missing.
- */
- if (pronargs > nargs && expand_variadic)
- {
- bool isnull;
- Datum proargdefaults;
- char *str;
-
- /* skip when not enough default expressions */
- if (nargs + procform->pronargdefaults < pronargs)
- continue;
-
- proargdefaults = SysCacheGetAttr(PROCOID, proctup,
- Anum_pg_proc_proargdefaults, &isnull);
- Assert(!isnull);
- str = TextDatumGetCString(proargdefaults);
- defaults = (List *) stringToNode(str);
-
- Assert(IsA(defaults, List));
-
- /*
- * If we don't have to use all default parameters, we skip
- * some cells from the left.
- */
- defaults = list_copy_tail(defaults, procform->pronargdefaults - pronargs + nargs);
-
- pfree(str);
- }
-
/*
* Check if function is variadic, and get variadic element type if so.
* If expand_variadic is false, we should just ignore variadic-ness.
{
va_elem_type = procform->provariadic;
variadic = OidIsValid(va_elem_type);
+ any_special |= variadic;
}
else
{
variadic = false;
}
- Assert(!variadic || !defaults);
+ /*
+ * Check if function can match by using parameter defaults.
+ */
+ if (pronargs > nargs && expand_defaults)
+ {
+ /* Ignore if not enough default expressions */
+ if (nargs + procform->pronargdefaults < pronargs)
+ continue;
+ use_defaults = true;
+ any_special = true;
+ }
+ else
+ use_defaults = false;
/* Ignore if it doesn't match requested argument count */
- if (nargs >= 0 &&
- (variadic ? (pronargs > nargs) : (defaults ? (pronargs < nargs) : (pronargs != nargs))))
+ if (nargs >= 0 && pronargs != nargs && !variadic && !use_defaults)
continue;
- Assert(!variadic || (pronargs <= nargs));
- Assert(!defaults || (pronargs > nargs));
-
if (OidIsValid(namespaceId))
{
/* Consider only procs in specified namespace */
newResult->pathpos = pathpos;
newResult->oid = HeapTupleGetOid(proctup);
newResult->nargs = effective_nargs;
- newResult->argdefaults = defaults;
memcpy(newResult->args, procform->proargtypes.values,
pronargs * sizeof(Oid));
if (variadic)
}
else
newResult->nvargs = 0;
-
- any_variadic = variadic || defaults;
+ newResult->ndargs = use_defaults ? pronargs - nargs : 0;
/*
* Does it have the same arguments as something we already accepted?
- * If so, decide which one to keep. We can skip this check for the
- * single-namespace case if no variadic match has been made, since
- * then the unique index on pg_proc guarantees all the matches have
- * different argument lists.
+ * If so, decide what to do to avoid returning duplicate argument
+ * lists. We can skip this check for the single-namespace case if no
+ * special (variadic or defaults) match has been made, since then the
+ * unique index on pg_proc guarantees all the matches have different
+ * argument lists.
*/
- if (any_variadic || !OidIsValid(namespaceId))
+ if (resultList != NULL &&
+ (any_special || !OidIsValid(namespaceId)))
{
- if (defaults)
- effective_nargs = nargs;
-
/*
* If we have an ordered list from SearchSysCacheList (the normal
* case), then any conflicting proc must immediately adjoin this
* one in the list, so we only need to look at the newest result
* item. If we have an unordered list, we have to scan the whole
* result list. Also, if either the current candidate or any
- * previous candidate is a variadic match, we can't assume that
+ * previous candidate is a special match, we can't assume that
* conflicts are adjacent.
+ *
+ * We ignore defaulted arguments in deciding what is a match.
*/
- if (resultList)
+ FuncCandidateList prevResult;
+
+ if (catlist->ordered && !any_special)
{
- FuncCandidateList prevResult;
+ /* ndargs must be 0 if !any_special */
+ if (effective_nargs == resultList->nargs &&
+ memcmp(newResult->args,
+ resultList->args,
+ effective_nargs * sizeof(Oid)) == 0)
+ prevResult = resultList;
+ else
+ prevResult = NULL;
+ }
+ else
+ {
+ int cmp_nargs = newResult->nargs - newResult->ndargs;
- if (catlist->ordered && !any_variadic)
+ for (prevResult = resultList;
+ prevResult;
+ prevResult = prevResult->next)
{
- if (effective_nargs == resultList->nargs &&
+ if (cmp_nargs == prevResult->nargs - prevResult->ndargs &&
memcmp(newResult->args,
- resultList->args,
- effective_nargs * sizeof(Oid)) == 0)
- prevResult = resultList;
- else
- prevResult = NULL;
+ prevResult->args,
+ cmp_nargs * sizeof(Oid)) == 0)
+ break;
}
- else
+ }
+
+ if (prevResult)
+ {
+ /*
+ * We have a match with a previous result. Decide which one
+ * to keep, or mark it ambiguous if we can't decide. The
+ * logic here is preference > 0 means prefer the old result,
+ * preference < 0 means prefer the new, preference = 0 means
+ * ambiguous.
+ */
+ int preference;
+
+ if (pathpos != prevResult->pathpos)
{
- for (prevResult = resultList;
- prevResult;
- prevResult = prevResult->next)
- {
- if (!defaults)
- {
- if (effective_nargs == prevResult->nargs &&
- memcmp(newResult->args,
- prevResult->args,
- effective_nargs * sizeof(Oid)) == 0)
- break;
- }
- else
- {
- if (memcmp(newResult->args,
- prevResult->args,
- effective_nargs * sizeof(Oid)) == 0)
- break;
- }
- }
+ /*
+ * Prefer the one that's earlier in the search path.
+ */
+ preference = pathpos - prevResult->pathpos;
}
- if (prevResult)
+ else if (variadic && prevResult->nvargs == 0)
{
/*
- * We have a match with a previous result. Prefer the
- * one that's earlier in the search path.
+ * With variadic functions we could have, for example,
+ * both foo(numeric) and foo(variadic numeric[]) in
+ * the same namespace; if so we prefer the
+ * non-variadic match on efficiency grounds.
*/
- if (pathpos > prevResult->pathpos)
- {
- pfree(newResult);
- continue; /* keep previous result */
- }
- else if (pathpos == prevResult->pathpos)
+ preference = 1;
+ }
+ else if (!variadic && prevResult->nvargs > 0)
+ {
+ preference = -1;
+ }
+ else
+ {
+ /*----------
+ * We can't decide. This can happen with, for example,
+ * both foo(numeric, variadic numeric[]) and
+ * foo(variadic numeric[]) in the same namespace, or
+ * both foo(int) and foo (int, int default something)
+ * in the same namespace.
+ *----------
+ */
+ preference = 0;
+ }
+
+ if (preference > 0)
+ {
+ /* keep previous result */
+ pfree(newResult);
+ continue;
+ }
+ else if (preference < 0)
+ {
+ /* remove previous result from the list */
+ if (prevResult == resultList)
+ resultList = prevResult->next;
+ else
{
- /*
- * With variadic functions we could have, for example,
- * both foo(numeric) and foo(variadic numeric[]) in
- * the same namespace; if so we prefer the
- * non-variadic match on efficiency grounds. It's
- * also possible to have conflicting variadic
- * functions, such as foo(numeric, variadic numeric[])
- * and foo(variadic numeric[]). If you're silly
- * enough to do that, we throw an error. (XXX It'd be
- * better to detect such conflicts when the functions
- * are created.)
- */
- if (variadic)
- {
- if (prevResult->nvargs > 0)
- ereport(ERROR,
- (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
- errmsg("variadic function %s conflicts with another",
- func_signature_string(names, pronargs,
- procform->proargtypes.values))));
- /* else, previous result wasn't variadic */
- pfree(newResult);
- continue; /* keep previous result */
- }
+ FuncCandidateList prevPrevResult;
- if (defaults)
+ for (prevPrevResult = resultList;
+ prevPrevResult;
+ prevPrevResult = prevPrevResult->next)
{
- if (prevResult->argdefaults != NIL)
- ereport(ERROR,
- (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
- errmsg("functions with parameter defaults %s and %s are ambiguous",
- func_signature_string(names, pronargs, procform->proargtypes.values),
- func_signature_string(names, prevResult->nargs, prevResult->args))));
- /* else, previous result didn't have defaults */
- pfree(newResult);
- continue; /* keep previous result */
+ if (prevResult == prevPrevResult->next)
+ {
+ prevPrevResult->next = prevResult->next;
+ break;
+ }
}
-
- /* non-variadic can replace a previous variadic */
- Assert(prevResult->nvargs > 0);
+ Assert(prevPrevResult); /* assert we found it */
}
- /* replace previous result */
- prevResult->pathpos = pathpos;
- prevResult->oid = newResult->oid;
- prevResult->nvargs = newResult->nvargs;
- prevResult->argdefaults = newResult->argdefaults;
+ pfree(prevResult);
+ /* fall through to add newResult to list */
+ }
+ else
+ {
+ /* mark old result as ambiguous, discard new */
+ prevResult->oid = InvalidOid;
pfree(newResult);
- continue; /* args are same, of course */
+ continue;
}
}
}
visible = false;
clist = FuncnameGetCandidates(list_make1(makeString(proname)),
- nargs, false);
+ nargs, false, false);
for (; clist; clist = clist->next)
{
newResult->oid = HeapTupleGetOid(opertup);
newResult->nargs = 2;
newResult->nvargs = 0;
+ newResult->ndargs = 0;
newResult->args[0] = operform->oprleft;
newResult->args[1] = operform->oprright;
newResult->next = resultList;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.98 2008/12/04 17:51:26 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.99 2008/12/18 18:20:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
PointerGetDatum(NULL), /* allParamTypes */
PointerGetDatum(NULL), /* parameterModes */
PointerGetDatum(NULL), /* parameterNames */
+ NIL, /* parameterDefaults */
PointerGetDatum(NULL), /* proconfig */
1, /* procost */
- 0, /* prorows */
- NULL); /* parameterDefaults */
+ 0); /* prorows */
/*
* Okay to create the pg_aggregate entry.
* function's return value. it also returns the true argument types to
* the function.
*/
- fdresult = func_get_detail(fnName, NIL, nargs, input_types, false,
+ fdresult = func_get_detail(fnName, NIL, nargs, input_types, false, false,
&fnOid, rettype, &retset, &nvargs,
&true_oid_array, NULL);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.155 2008/12/04 17:51:26 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.156 2008/12/18 18:20:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
+#include "nodes/nodeFuncs.h"
#include "parser/parse_type.h"
#include "tcop/pquery.h"
#include "tcop/tcopprot.h"
Datum allParameterTypes,
Datum parameterModes,
Datum parameterNames,
+ List *parameterDefaults,
Datum proconfig,
float4 procost,
- float4 prorows,
- List *parameterDefaults)
+ float4 prorows)
{
Oid retval;
int parameterCount;
values[Anum_pg_proc_proargnames - 1] = parameterNames;
else
nulls[Anum_pg_proc_proargnames - 1] = true;
- if (parameterDefaults != PointerGetDatum(NULL))
- {
- Assert(list_length(parameterDefaults) > 0);
+ if (parameterDefaults != NIL)
values[Anum_pg_proc_proargdefaults - 1] = CStringGetTextDatum(nodeToString(parameterDefaults));
- }
else
nulls[Anum_pg_proc_proargdefaults - 1] = true;
values[Anum_pg_proc_prosrc - 1] = CStringGetTextDatum(prosrc);
errhint("Use DROP FUNCTION first.")));
}
+ /*
+ * If there are existing defaults, check compatibility: redefinition
+ * must not remove any defaults nor change their types. (Removing
+ * a default might cause a function to fail to satisfy an existing
+ * call. Changing type would only be possible if the associated
+ * parameter is polymorphic, and in such cases a change of default
+ * type might alter the resolved output type of existing calls.)
+ */
+ if (oldproc->pronargdefaults != 0)
+ {
+ Datum proargdefaults;
+ bool isnull;
+ List *oldDefaults;
+ ListCell *oldlc;
+ ListCell *newlc;
+
+ if (list_length(parameterDefaults) < oldproc->pronargdefaults)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+ errmsg("cannot remove parameter defaults from existing function"),
+ errhint("Use DROP FUNCTION first.")));
+
+ proargdefaults = SysCacheGetAttr(PROCNAMEARGSNSP, oldtup,
+ Anum_pg_proc_proargdefaults,
+ &isnull);
+ Assert(!isnull);
+ oldDefaults = (List *) stringToNode(TextDatumGetCString(proargdefaults));
+ Assert(IsA(oldDefaults, List));
+ Assert(list_length(oldDefaults) == oldproc->pronargdefaults);
+
+ /* new list can have more defaults than old, advance over 'em */
+ newlc = list_head(parameterDefaults);
+ for (i = list_length(parameterDefaults) - oldproc->pronargdefaults;
+ i > 0;
+ i--)
+ newlc = lnext(newlc);
+
+ foreach(oldlc, oldDefaults)
+ {
+ Node *oldDef = (Node *) lfirst(oldlc);
+ Node *newDef = (Node *) lfirst(newlc);
+
+ if (exprType(oldDef) != exprType(newDef))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+ errmsg("cannot change data type of existing parameter default value"),
+ errhint("Use DROP FUNCTION first.")));
+ newlc = lnext(newlc);
+ }
+ }
+
/* Can't change aggregate status, either */
if (oldproc->proisagg != isAgg)
{
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.102 2008/12/04 17:51:26 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.103 2008/12/18 18:20:33 tgl Exp $
*
* DESCRIPTION
* These routines take the parse tree and pick out the
#include "commands/defrem.h"
#include "commands/proclang.h"
#include "miscadmin.h"
+#include "optimizer/var.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_type.h"
-#include "parser/parse_utilcmd.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
*/
static void
examine_parameter_list(List *parameters, Oid languageOid,
+ const char *queryString,
oidvector **parameterTypes,
ArrayType **allParameterTypes,
ArrayType **parameterModes,
ArrayType **parameterNames,
List **parameterDefaults,
- Oid *requiredResultType,
- const char *queryString)
+ Oid *requiredResultType)
{
int parameterCount = list_length(parameters);
Oid *inTypes;
int outCount = 0;
int varCount = 0;
bool have_names = false;
+ bool have_defaults = false;
ListCell *x;
int i;
- bool have_defaults = false;
ParseState *pstate;
*requiredResultType = InvalidOid; /* default result */
paramNames = (Datum *) palloc0(parameterCount * sizeof(Datum));
*parameterDefaults = NIL;
+ /* may need a pstate for parse analysis of default exprs */
pstate = make_parsestate(NULL);
pstate->p_sourcetext = queryString;
{
FunctionParameter *fp = (FunctionParameter *) lfirst(x);
TypeName *t = fp->argType;
+ bool isinput = false;
Oid toid;
Type typtup;
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("VARIADIC parameter must be the last input parameter")));
inTypes[inCount++] = toid;
+ isinput = true;
}
/* handle output parameters */
if (fp->defexpr)
{
- if (fp->mode != FUNC_PARAM_IN && fp->mode != FUNC_PARAM_INOUT)
+ Node *def;
+
+ if (!isinput)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("only IN and INOUT parameters can have default values")));
+ errmsg("only input parameters can have default values")));
+
+ def = transformExpr(pstate, fp->defexpr);
+ def = coerce_to_specific_type(pstate, def, toid, "DEFAULT");
+
+ /*
+ * Make sure no variables are referred to.
+ */
+ if (list_length(pstate->p_rtable) != 0 ||
+ contain_var_clause(def))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
+ errmsg("cannot use table references in parameter default value")));
+
+ /*
+ * No subplans or aggregates, either...
+ */
+ if (pstate->p_hasSubLinks)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot use subquery in parameter default value")));
+ if (pstate->p_hasAggs)
+ ereport(ERROR,
+ (errcode(ERRCODE_GROUPING_ERROR),
+ errmsg("cannot use aggregate function in parameter default value")));
- *parameterDefaults = lappend(*parameterDefaults,
- coerce_to_specific_type(NULL,
- transformExpr(pstate, fp->defexpr),
- toid,
- "DEFAULT"));
+ *parameterDefaults = lappend(*parameterDefaults, def);
have_defaults = true;
}
else
{
- if (have_defaults)
+ if (isinput && have_defaults)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("parameter without default value specified after parameter with default value")));
+ errmsg("input parameters after one with a default value must also have defaults")));
}
i++;
ArrayType *allParameterTypes;
ArrayType *parameterModes;
ArrayType *parameterNames;
+ List *parameterDefaults;
Oid requiredResultType;
bool isStrict,
security;
HeapTuple languageTuple;
Form_pg_language languageStruct;
List *as_clause;
- List *defaults = NULL;
/* Convert list of names to a name and namespace */
namespaceId = QualifiedNameGetCreationNamespace(stmt->funcname,
* Convert remaining parameters of CREATE to form wanted by
* ProcedureCreate.
*/
- examine_parameter_list(stmt->parameters, languageOid,
+ examine_parameter_list(stmt->parameters, languageOid, queryString,
¶meterTypes,
&allParameterTypes,
¶meterModes,
¶meterNames,
- &defaults,
- &requiredResultType,
- queryString);
+ ¶meterDefaults,
+ &requiredResultType);
if (stmt->returnType)
{
PointerGetDatum(allParameterTypes),
PointerGetDatum(parameterModes),
PointerGetDatum(parameterNames),
+ parameterDefaults,
PointerGetDatum(proconfig),
procost,
- prorows,
- defaults);
+ prorows);
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.81 2008/12/04 17:51:26 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.82 2008/12/18 18:20:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
PointerGetDatum(NULL),
PointerGetDatum(NULL),
PointerGetDatum(NULL),
+ NIL,
PointerGetDatum(NULL),
1,
- 0,
- NULL);
+ 0);
}
/*
PointerGetDatum(NULL),
PointerGetDatum(NULL),
PointerGetDatum(NULL),
+ NIL,
PointerGetDatum(NULL),
1,
- 0,
- NULL);
+ 0);
}
}
else
errmsg("language \"%s\" does not exist", name)));
AlterLanguageOwner_internal(tup, rel, newOwnerId);
-
+
ReleaseSysCache(tup);
-
+
heap_close(rel, RowExclusiveLock);
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.246 2008/10/22 20:17:51 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.247 2008/12/18 18:20:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Simplify constant expressions.
*
+ * Note: one essential effect here is to insert the current actual values
+ * of any default arguments for functions. To ensure that happens, we
+ * *must* process all expressions here. Previous PG versions sometimes
+ * skipped const-simplification if it didn't seem worth the trouble, but
+ * we can't do that anymore.
+ *
* Note: this also flattens nested AND and OR expressions into N-argument
* form. All processing of a qual expression after this point must be
* careful to maintain AND/OR flatness --- that is, do not generate a tree
* with AND directly under AND, nor OR directly under OR.
- *
- * Because this is a relatively expensive process, we skip it when the
- * query is trivial, such as "SELECT 2+2;" or "INSERT ... VALUES()". The
- * expression will only be evaluated once anyway, so no point in
- * pre-simplifying; we can't execute it any faster than the executor can,
- * and we will waste cycles copying the tree. Notice however that we
- * still must do it for quals (to get AND/OR flatness); and if we are in a
- * subquery we should not assume it will be done only once.
- *
- * For VALUES lists we never do this at all, again on the grounds that we
- * should optimize for one-time evaluation.
*/
- if (kind != EXPRKIND_VALUES &&
- (root->parse->jointree->fromlist != NIL ||
- kind == EXPRKIND_QUAL ||
- root->query_level > 1))
- expr = eval_const_expressions(root, expr);
+ expr = eval_const_expressions(root, expr);
/*
* If it's a qual or havingQual, canonicalize it.
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.270 2008/10/21 20:42:53 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.271 2008/12/18 18:20:34 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
#include "optimizer/var.h"
#include "parser/analyze.h"
#include "parser/parse_coerce.h"
+#include "parser/parse_func.h"
#include "rewrite/rewriteManip.h"
#include "tcop/tcopprot.h"
#include "utils/acl.h"
bool *haveNull, bool *forceFalse);
static Expr *simplify_boolean_equality(List *args);
static Expr *simplify_function(Oid funcid,
- Oid result_type, int32 result_typmod, List *args,
+ Oid result_type, int32 result_typmod, List **args,
bool allow_inline,
eval_const_expressions_context *context);
+static List *add_function_defaults(List *args, Oid result_type,
+ HeapTuple func_tuple);
static Expr *evaluate_function(Oid funcid,
Oid result_type, int32 result_typmod, List *args,
HeapTuple func_tuple,
*/
simple = simplify_function(expr->funcid,
expr->funcresulttype, exprTypmod(node),
- args,
+ &args,
true, context);
if (simple) /* successfully simplified it */
return (Node *) simple;
*/
simple = simplify_function(expr->opfuncid,
expr->opresulttype, -1,
- args,
+ &args,
true, context);
if (simple) /* successfully simplified it */
return (Node *) simple;
*/
simple = simplify_function(expr->opfuncid,
expr->opresulttype, -1,
- args,
+ &args,
false, context);
if (simple) /* successfully simplified it */
{
{
CoerceViaIO *expr = (CoerceViaIO *) node;
Expr *arg;
+ List *args;
Oid outfunc;
bool outtypisvarlena;
Oid infunc;
*/
arg = (Expr *) eval_const_expressions_mutator((Node *) expr->arg,
context);
+ args = list_make1(arg);
/*
* CoerceViaIO represents calling the source type's output function
simple = simplify_function(outfunc,
CSTRINGOID, -1,
- list_make1(arg),
+ &args,
true, context);
if (simple) /* successfully simplified output fn */
{
* Input functions may want 1 to 3 arguments. We always supply
* all three, trusting that nothing downstream will complain.
*/
- List *args;
-
args = list_make3(simple,
makeConst(OIDOID, -1, sizeof(Oid),
ObjectIdGetDatum(intypioparam),
simple = simplify_function(infunc,
expr->resulttype, -1,
- args,
+ &args,
true, context);
if (simple) /* successfully simplified input fn */
return (Node *) simple;
*
* Returns a simplified expression if successful, or NULL if cannot
* simplify the function call.
+ *
+ * This function is also responsible for adding any default argument
+ * expressions onto the function argument list; which is a bit grotty,
+ * but it avoids an extra fetch of the function's pg_proc tuple. For this
+ * reason, the args list is pass-by-reference, and it may get modified
+ * even if simplification fails.
*/
static Expr *
simplify_function(Oid funcid, Oid result_type, int32 result_typmod,
- List *args,
+ List **args,
bool allow_inline,
eval_const_expressions_context *context)
{
if (!HeapTupleIsValid(func_tuple))
elog(ERROR, "cache lookup failed for function %u", funcid);
- newexpr = evaluate_function(funcid, result_type, result_typmod, args,
+ /* While we have the tuple, check if we need to add defaults */
+ if (((Form_pg_proc) GETSTRUCT(func_tuple))->pronargs > list_length(*args))
+ *args = add_function_defaults(*args, result_type, func_tuple);
+
+ newexpr = evaluate_function(funcid, result_type, result_typmod, *args,
func_tuple, context);
if (!newexpr && allow_inline)
- newexpr = inline_function(funcid, result_type, args,
+ newexpr = inline_function(funcid, result_type, *args,
func_tuple, context);
ReleaseSysCache(func_tuple);
return newexpr;
}
+/*
+ * add_function_defaults: add missing function arguments from its defaults
+ *
+ * It is possible for some of the defaulted arguments to be polymorphic;
+ * therefore we can't assume that the default expressions have the correct
+ * data types already. We have to re-resolve polymorphics and do coercion
+ * just like the parser did.
+ */
+static List *
+add_function_defaults(List *args, Oid result_type, HeapTuple func_tuple)
+{
+ Form_pg_proc funcform = (Form_pg_proc) GETSTRUCT(func_tuple);
+ Datum proargdefaults;
+ bool isnull;
+ char *str;
+ List *defaults;
+ int ndelete;
+ int nargs;
+ Oid actual_arg_types[FUNC_MAX_ARGS];
+ Oid declared_arg_types[FUNC_MAX_ARGS];
+ Oid rettype;
+ ListCell *lc;
+
+ /* The error cases here shouldn't happen, but check anyway */
+ proargdefaults = SysCacheGetAttr(PROCOID, func_tuple,
+ Anum_pg_proc_proargdefaults,
+ &isnull);
+ if (isnull)
+ elog(ERROR, "not enough default arguments");
+ str = TextDatumGetCString(proargdefaults);
+ defaults = (List *) stringToNode(str);
+ Assert(IsA(defaults, List));
+ pfree(str);
+ /* Delete any unused defaults from the list */
+ ndelete = list_length(args) + list_length(defaults) - funcform->pronargs;
+ if (ndelete < 0)
+ elog(ERROR, "not enough default arguments");
+ while (ndelete-- > 0)
+ defaults = list_delete_first(defaults);
+ /* And form the combined argument list */
+ args = list_concat(args, defaults);
+ Assert(list_length(args) == funcform->pronargs);
+
+ /*
+ * The rest of this should be a no-op if there are no polymorphic
+ * arguments, but we do it anyway to be sure.
+ */
+ if (list_length(args) > FUNC_MAX_ARGS)
+ elog(ERROR, "too many function arguments");
+ nargs = 0;
+ foreach(lc, args)
+ {
+ actual_arg_types[nargs++] = exprType((Node *) lfirst(lc));
+ }
+ memcpy(declared_arg_types, funcform->proargtypes.values,
+ funcform->pronargs * sizeof(Oid));
+ rettype = enforce_generic_type_consistency(actual_arg_types,
+ declared_arg_types,
+ nargs,
+ funcform->prorettype,
+ false);
+ /* let's just check we got the same answer as the parser did ... */
+ if (rettype != result_type)
+ elog(ERROR, "function's resolved result type changed during planning");
+
+ /* perform any necessary typecasting of arguments */
+ make_fn_arguments(NULL, args, actual_arg_types, declared_arg_types);
+
+ return args;
+}
+
/*
* evaluate_function: try to pre-evaluate a function call
*
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.644 2008/12/17 09:15:02 heikki Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.645 2008/12/18 18:20:34 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*
* COMMENT ON [ [ DATABASE | DOMAIN | INDEX | SEQUENCE | TABLE | TYPE | VIEW |
* CONVERSION | LANGUAGE | OPERATOR CLASS | LARGE OBJECT |
- * CAST | COLUMN | SCHEMA | TABLESPACE | ROLE |
+ * CAST | COLUMN | SCHEMA | TABLESPACE | ROLE |
* TEXT SEARCH PARSER | TEXT SEARCH DICTIONARY |
* TEXT SEARCH TEMPLATE |
* TEXT SEARCH CONFIGURATION ] <objname> |
*/
func_args_with_defaults:
'(' func_args_with_defaults_list ')' { $$ = $2; }
- | '(' ')' { $$ = NIL; }
+ | '(' ')' { $$ = NIL; }
;
func_args_with_defaults_list:
- func_arg_with_default { $$ = list_make1( $1); }
- | func_args_with_defaults_list ',' func_arg_with_default { $$ = lappend($1, $3); }
+ func_arg_with_default { $$ = list_make1($1); }
+ | func_args_with_defaults_list ',' func_arg_with_default
+ { $$ = lappend($1, $3); }
;
-
/*
* The style with arg_class first is SQL99 standard, but Oracle puts
* param_name first; accept both since it's likely people will try both
func_arg_with_default:
func_arg
- {
+ {
$$ = $1;
}
| func_arg DEFAULT a_expr
n->name = $1;
n->argType = $2;
n->mode = FUNC_PARAM_TABLE;
+ n->defexpr = NULL;
$$ = n;
}
;
n->replace = false;
$$ = (Node*)n;
}
- | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name WITH any_name
+ | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name WITH any_name
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
n->cfgname = $5;
n->replace = true;
$$ = (Node*)n;
}
- | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name WITH any_name
+ | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name WITH any_name
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
n->cfgname = $5;
n->replace = true;
$$ = (Node*)n;
}
- | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
+ | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
n->cfgname = $5;
n->missing_ok = false;
$$ = (Node*)n;
}
- | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
+ | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list
{
AlterTSConfigurationStmt *n = makeNode(AlterTSConfigurationStmt);
n->cfgname = $5;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.208 2008/12/04 17:51:26 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.209 2008/12/18 18:20:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
ListCell *nextl;
Node *first_arg = NULL;
int nargs;
+ int nargsplusdefs;
Oid actual_arg_types[FUNC_MAX_ARGS];
Oid *declared_arg_types;
+ List *argdefaults;
Node *retval;
bool retset;
int nvargs;
FuncDetailCode fdresult;
- List *argdefaults;
/*
* Most of the rest of the parser just assumes that functions do not have
* disambiguation for polymorphic functions, handles inheritance, and
* returns the funcid and type and set or singleton status of the
* function's return value. It also returns the true argument types to
- * the function. (In the case of a variadic function call, the reported
+ * the function. In the case of a variadic function call, the reported
* "true" types aren't really what is in pg_proc: the variadic argument is
* replaced by a suitable number of copies of its element type. We'll fix
- * it up below.)
+ * it up below. We may also have to deal with default arguments.
*/
fdresult = func_get_detail(funcname, fargs, nargs, actual_arg_types,
- !func_variadic,
+ !func_variadic, true,
&funcid, &rettype, &retset, &nvargs,
&declared_arg_types, &argdefaults);
if (fdresult == FUNCDETAIL_COERCION)
parser_errposition(pstate, location)));
}
- /* add stored expressions as called values for arguments with defaults */
- if (argdefaults)
+ /*
+ * If there are default arguments, we have to include their types in
+ * actual_arg_types for the purpose of checking generic type consistency.
+ * However, we do NOT put them into the generated parse node, because
+ * their actual values might change before the query gets run. The
+ * planner has to insert the up-to-date values at plan time.
+ */
+ nargsplusdefs = nargs;
+ foreach(l, argdefaults)
{
- ListCell *lc;
+ Node *expr = (Node *) lfirst(l);
- foreach(lc, argdefaults)
- {
- Node *expr = (Node *) lfirst(lc);
-
- fargs = lappend(fargs, expr);
- actual_arg_types[nargs++] = exprType(expr);
- }
- }
+ /* probably shouldn't happen ... */
+ if (nargsplusdefs >= FUNC_MAX_ARGS)
+ ereport(ERROR,
+ (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
+ errmsg("cannot pass more than %d arguments to a function",
+ FUNC_MAX_ARGS),
+ parser_errposition(pstate, location)));
+ actual_arg_types[nargsplusdefs++] = exprType(expr);
+ }
/*
* enforce consistency with polymorphic argument and return types,
*/
rettype = enforce_generic_type_consistency(actual_arg_types,
declared_arg_types,
- nargs,
+ nargsplusdefs,
rettype,
false);
int nargs,
Oid *argtypes,
bool expand_variadic,
+ bool expand_defaults,
Oid *funcid, /* return value */
Oid *rettype, /* return value */
bool *retset, /* return value */
int *nvargs, /* return value */
Oid **true_typeids, /* return value */
- List **argdefaults) /* return value */
+ List **argdefaults) /* optional return value */
{
FuncCandidateList raw_candidates;
FuncCandidateList best_candidate;
/* Get list of possible candidates from namespace search */
- raw_candidates = FuncnameGetCandidates(funcname, nargs, expand_variadic);
+ raw_candidates = FuncnameGetCandidates(funcname, nargs,
+ expand_variadic, expand_defaults);
/*
* Quickly check if there is an exact match to the input datatypes (there
Form_pg_proc pform;
FuncDetailCode result;
+ /*
+ * If expanding variadics or defaults, the "best candidate" might
+ * represent multiple equivalently good functions; treat this case
+ * as ambiguous.
+ */
+ if (!OidIsValid(best_candidate->oid))
+ return FUNCDETAIL_MULTIPLE;
+
*funcid = best_candidate->oid;
*nvargs = best_candidate->nvargs;
*true_typeids = best_candidate->args;
- if (argdefaults)
- *argdefaults = best_candidate->argdefaults;
ftup = SearchSysCache(PROCOID,
ObjectIdGetDatum(best_candidate->oid),
pform = (Form_pg_proc) GETSTRUCT(ftup);
*rettype = pform->prorettype;
*retset = pform->proretset;
+ /* fetch default args if caller wants 'em */
+ if (argdefaults)
+ {
+ if (best_candidate->ndargs > 0)
+ {
+ Datum proargdefaults;
+ bool isnull;
+ char *str;
+ List *defaults;
+ int ndelete;
+
+ /* shouldn't happen, FuncnameGetCandidates messed up */
+ if (best_candidate->ndargs > pform->pronargdefaults)
+ elog(ERROR, "not enough default arguments");
+
+ proargdefaults = SysCacheGetAttr(PROCOID, ftup,
+ Anum_pg_proc_proargdefaults,
+ &isnull);
+ Assert(!isnull);
+ str = TextDatumGetCString(proargdefaults);
+ defaults = (List *) stringToNode(str);
+ Assert(IsA(defaults, List));
+ pfree(str);
+ /* Delete any unused defaults from the returned list */
+ ndelete = list_length(defaults) - best_candidate->ndargs;
+ while (ndelete-- > 0)
+ defaults = list_delete_first(defaults);
+ *argdefaults = defaults;
+ }
+ else
+ *argdefaults = NIL;
+ }
result = pform->proisagg ? FUNCDETAIL_AGGREGATE : FUNCDETAIL_NORMAL;
ReleaseSysCache(ftup);
return result;
{
FuncCandidateList clist;
- clist = FuncnameGetCandidates(funcname, nargs, false);
+ clist = FuncnameGetCandidates(funcname, nargs, false, false);
while (clist)
{
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.108 2008/07/16 01:30:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.109 2008/12/18 18:20:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* pg_proc entries in the current search path.
*/
names = stringToQualifiedNameList(pro_name_or_oid);
- clist = FuncnameGetCandidates(names, -1, false);
+ clist = FuncnameGetCandidates(names, -1, false, false);
if (clist == NULL)
ereport(ERROR,
* qualify it.
*/
clist = FuncnameGetCandidates(list_make1(makeString(proname)),
- -1, false);
+ -1, false, false);
if (clist != NULL && clist->next == NULL &&
clist->oid == proid)
nspname = NULL;
*/
parseNameAndArgTypes(pro_name_or_oid, false, &names, &nargs, argtypes);
- clist = FuncnameGetCandidates(names, nargs, false);
+ clist = FuncnameGetCandidates(names, nargs, false, false);
for (; clist; clist = clist->next)
{
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.288 2008/12/04 17:51:27 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.289 2008/12/18 18:20:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static char *pg_get_expr_worker(text *expr, Oid relid, char *relname,
int prettyFlags);
static int print_function_arguments(StringInfo buf, HeapTuple proctup,
- bool print_table_args,
- bool full);
+ bool print_table_args, bool print_defaults);
static void print_function_rettype(StringInfo buf, HeapTuple proctup);
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
int prettyFlags);
* pg_get_function_identity_arguments
* Get a formatted list of arguments for a function.
* This is everything that would go between the parentheses in
- * ALTER FUNCTION, etc. skip names and defaults/
+ * ALTER FUNCTION, etc. In particular, don't print defaults.
*/
Datum
pg_get_function_identity_arguments(PG_FUNCTION_ARGS)
PG_RETURN_TEXT_P(string_to_text(buf.data));
}
-
-
/*
* pg_get_function_result
* Get a nicely-formatted version of the result type of a function.
{
/* It might be a table function; try to print the arguments */
appendStringInfoString(&rbuf, "TABLE(");
- ntabargs = print_function_arguments(&rbuf, proctup, true, true);
+ ntabargs = print_function_arguments(&rbuf, proctup, true, false);
if (ntabargs > 0)
appendStringInfoString(&rbuf, ")");
else
* Common code for pg_get_function_arguments and pg_get_function_result:
* append the desired subset of arguments to buf. We print only TABLE
* arguments when print_table_args is true, and all the others when it's false.
+ * We print argument defaults only if print_defaults is true.
* Function return value is the number of arguments printed.
- * When full is false, then don't print argument names and argument defaults.
*/
static int
print_function_arguments(StringInfo buf, HeapTuple proctup,
- bool print_table_args,
- bool full)
+ bool print_table_args, bool print_defaults)
{
+ Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(proctup);
int numargs;
Oid *argtypes;
char **argnames;
char *argmodes;
int argsprinted;
+ int inputargno;
+ int nlackdefaults;
+ ListCell *nextargdefault = NULL;
int i;
- Datum proargdefaults;
- List *argdefaults;
- int nargdefaults;
- bool isnull;
- List *dcontext = NIL;
numargs = get_func_arg_info(proctup,
&argtypes, &argnames, &argmodes);
- proargdefaults = SysCacheGetAttr(PROCOID, proctup,
- Anum_pg_proc_proargdefaults, &isnull);
- if (!isnull)
- {
- char *str;
-
- str = TextDatumGetCString(proargdefaults);
- argdefaults = (List *) stringToNode(str);
- Assert(IsA(argdefaults, List));
- nargdefaults = list_length(argdefaults);
-
- /* we will need deparse context */
- //dcontext = deparse_context_for("", InvalidOid);
- dcontext = NULL;
- pfree(str);
- }
- else
+ nlackdefaults = numargs;
+ if (print_defaults && proc->pronargdefaults > 0)
{
- argdefaults = NIL;
- nargdefaults = 0;
+ Datum proargdefaults;
+ bool isnull;
+
+ proargdefaults = SysCacheGetAttr(PROCOID, proctup,
+ Anum_pg_proc_proargdefaults,
+ &isnull);
+ if (!isnull)
+ {
+ char *str;
+ List *argdefaults;
+
+ str = TextDatumGetCString(proargdefaults);
+ argdefaults = (List *) stringToNode(str);
+ Assert(IsA(argdefaults, List));
+ pfree(str);
+ nextargdefault = list_head(argdefaults);
+ /* nlackdefaults counts only *input* arguments lacking defaults */
+ nlackdefaults = proc->pronargs - list_length(argdefaults);
+ }
}
argsprinted = 0;
+ inputargno = 0;
for (i = 0; i < numargs; i++)
{
Oid argtype = argtypes[i];
char *argname = argnames ? argnames[i] : NULL;
char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
const char *modename;
-
- if (print_table_args != (argmode == PROARGMODE_TABLE))
- continue;
+ bool isinput;
switch (argmode)
{
case PROARGMODE_IN:
modename = "";
+ isinput = true;
break;
case PROARGMODE_INOUT:
modename = "INOUT ";
+ isinput = true;
break;
case PROARGMODE_OUT:
modename = "OUT ";
+ isinput = false;
break;
case PROARGMODE_VARIADIC:
modename = "VARIADIC ";
+ isinput = true;
break;
case PROARGMODE_TABLE:
modename = "";
+ isinput = false;
break;
default:
elog(ERROR, "invalid parameter mode '%c'", argmode);
modename = NULL; /* keep compiler quiet */
+ isinput = false;
break;
}
+ if (isinput)
+ inputargno++; /* this is a 1-based counter */
+
+ if (print_table_args != (argmode == PROARGMODE_TABLE))
+ continue;
+
if (argsprinted)
appendStringInfoString(buf, ", ");
appendStringInfoString(buf, modename);
- if (argname && argname[0] && full)
+ if (argname && argname[0])
appendStringInfo(buf, "%s ", argname);
appendStringInfoString(buf, format_type_be(argtype));
-
- /* search given default expression, expect less numargs */
- if (nargdefaults > 0 && i >= (numargs - nargdefaults) && full)
+ if (print_defaults && isinput && inputargno > nlackdefaults)
{
Node *expr;
- expr = (Node *) list_nth(argdefaults, i - (numargs - nargdefaults));
- appendStringInfo(buf, " DEFAULT %s", deparse_expression(expr, dcontext, false, false));
- }
+ Assert(nextargdefault != NULL);
+ expr = (Node *) lfirst(nextargdefault);
+ nextargdefault = lnext(nextargdefault);
+ appendStringInfo(buf, " DEFAULT %s",
+ deparse_expression(expr, NIL, false, false));
+ }
argsprinted++;
}
elog(ERROR, "cache lookup failed for function %u", funcid);
procform = (Form_pg_proc) GETSTRUCT(proctup);
proname = NameStr(procform->proname);
- Assert(nargs >= procform->pronargs);
/*
* The idea here is to schema-qualify only if the parser would fail to
* specified argtypes.
*/
p_result = func_get_detail(list_make1(makeString(proname)),
- NIL, nargs, argtypes, false,
+ NIL, nargs, argtypes, false, true,
&p_funcid, &p_rettype,
&p_retset, &p_nvargs, &p_true_typeids, NULL);
if ((p_result == FUNCDETAIL_NORMAL || p_result == FUNCDETAIL_AGGREGATE) &&
* by PostgreSQL
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.507 2008/12/11 07:34:08 petere Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.508 2008/12/18 18:20:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (g_fout->remoteVersion >= 70300)
do_sql_command(g_conn, "SET statement_timeout = 0");
-
+
/*
* Start serializable transaction to dump consistent data.
*/
* is never qualified.
*
* This is used only with pre-8.4 servers, so we aren't expecting to see
- * VARIADIC or TABLE arguments.
+ * VARIADIC or TABLE arguments, nor are there any defaults for arguments.
*
* Any or all of allargtypes, argmodes, argnames may be NULL.
*/
}
}
- /* funcargs and funciargs are supported from 8.4 */
- if (funciargs)
+ if (funcargs)
{
- funcsig = format_function_arguments(finfo, funciargs);
+ /* 8.4 or later; we rely on server-side code for most of the work */
funcfullsig = format_function_arguments(finfo, funcargs);
+ funcsig = format_function_arguments(finfo, funciargs);
}
else
{
+ /* pre-8.4, do it ourselves */
funcsig = format_function_arguments_old(finfo, nallargs, allargtypes,
argmodes, argnames);
funcfullsig = funcsig;
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/namespace.h,v 1.56 2008/12/04 17:51:27 petere Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/namespace.h,v 1.57 2008/12/18 18:20:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* found by namespace lookup. Each function/operator is identified
* by OID and by argument types; the list must be pruned by type
* resolution rules that are embodied in the parser, not here.
+ * See FuncnameGetCandidates's comments for more info.
*/
typedef struct _FuncCandidateList
{
Oid oid; /* the function or operator's OID */
int nargs; /* number of arg types returned */
int nvargs; /* number of args to become variadic array */
- List *argdefaults; /* list of parameter defaults */
+ int ndargs; /* number of defaulted args */
Oid args[1]; /* arg types --- VARIABLE LENGTH ARRAY */
} *FuncCandidateList; /* VARIABLE LENGTH STRUCT */
extern bool TypeIsVisible(Oid typid);
extern FuncCandidateList FuncnameGetCandidates(List *names, int nargs,
- bool expand_variadic);
+ bool expand_variadic,
+ bool expand_defaults);
extern bool FunctionIsVisible(Oid funcid);
extern Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright);
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/pg_attribute.h,v 1.142 2008/12/04 17:51:27 petere Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/pg_attribute.h,v 1.143 2008/12/18 18:20:34 tgl Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
{ 1255, {"proretset"}, 16, -1, 1, 11, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
{ 1255, {"provolatile"}, 18, -1, 1, 12, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0 }, \
{ 1255, {"pronargs"}, 21, -1, 2, 13, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
-{ 1255, {"pronargdefaults"}, 21, -1, 2, 14, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
+{ 1255, {"pronargdefaults"}, 21, -1, 2, 14, 0, -1, -1, true, 'p', 's', true, false, false, true, 0 }, \
{ 1255, {"prorettype"}, 26, -1, 4, 15, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0 }, \
{ 1255, {"proargtypes"}, 30, -1, -1, 16, 1, -1, -1, false, 'p', 'i', true, false, false, true, 0 }, \
{ 1255, {"proallargtypes"}, 1028, -1, -1, 17, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0 }, \
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/pg_proc.h,v 1.530 2008/12/04 17:51:27 petere Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/pg_proc.h,v 1.531 2008/12/18 18:20:34 tgl Exp $
*
* NOTES
* The script catalog/genbki.sh reads this file and generates .bki
bool proretset; /* returns a set? */
char provolatile; /* see PROVOLATILE_ categories below */
int2 pronargs; /* number of arguments */
- int2 pronargdefaults;/* number of arguments defaults */
+ int2 pronargdefaults; /* number of arguments with defaults */
Oid prorettype; /* OID of result type */
+
/* VARIABLE LENGTH FIELDS: */
oidvector proargtypes; /* parameter types (excludes OUT params) */
Oid proallargtypes[1]; /* all param types (NULL if IN only) */
char proargmodes[1]; /* parameter modes (NULL if IN only) */
text proargnames[1]; /* parameter names (NULL if no names) */
- text proargdefaults; /* list of argument defaults */
+ text proargdefaults; /* list of expression trees for argument
+ * defaults (NULL if none) */
text prosrc; /* procedure source text */
bytea probin; /* secondary procedure info (can be NULL) */
text proconfig[1]; /* procedure-local GUC settings */
DESCR("unary plus");
DATA(insert OID = 1912 ( int4up PGNSP PGUID 12 1 0 0 f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4up _null_ _null_ _null_ ));
DESCR("unary plus");
-DATA(insert OID = 1913 ( float4up PGNSP PGUID 12 1 0 0 f f t f i 1 0 700 "700" _null_ _null_ _null_ _null_ float4up _null_ _null_ _null_ ));
+DATA(insert OID = 1913 ( float4up PGNSP PGUID 12 1 0 0 f f t f i 1 0 700 "700" _null_ _null_ _null_ _null_ float4up _null_ _null_ _null_ ));
DESCR("unary plus");
-DATA(insert OID = 1914 ( float8up PGNSP PGUID 12 1 0 0 f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ float8up _null_ _null_ _null_ ));
+DATA(insert OID = 1914 ( float8up PGNSP PGUID 12 1 0 0 f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ float8up _null_ _null_ _null_ ));
DESCR("unary plus");
-DATA(insert OID = 1915 ( numeric_uplus PGNSP PGUID 12 1 0 0 f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_uplus _null_ _null_ _null_ ));
+DATA(insert OID = 1915 ( numeric_uplus PGNSP PGUID 12 1 0 0 f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_uplus _null_ _null_ _null_ ));
DESCR("unary plus");
DATA(insert OID = 1922 ( has_table_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 25 25" _null_ _null_ _null_ _null_ has_table_privilege_name_name _null_ _null_ _null_ ));
DESCR("get the prepared statements for this session");
DATA(insert OID = 2511 ( pg_cursor PGNSP PGUID 12 1 1000 0 f f t t s 0 0 2249 "" "{25,25,16,16,16,1184}" "{o,o,o,o,o,o}" "{name,statement,is_holdable,is_binary,is_scrollable,creation_time}" _null_ pg_cursor _null_ _null_ _null_ ));
DESCR("get the open cursors for this session");
-DATA(insert OID = 2599 ( pg_timezone_abbrevs PGNSP PGUID 12 1 1000 0 f f t t s 0 0 2249 "" "{25,1186,16}" "{o,o,o}" "{abbrev,utc_offset,is_dst}" _null_ pg_timezone_abbrevs _null_ _null_ _null_ ));
+DATA(insert OID = 2599 ( pg_timezone_abbrevs PGNSP PGUID 12 1 1000 0 f f t t s 0 0 2249 "" "{25,1186,16}" "{o,o,o}" "{abbrev,utc_offset,is_dst}" _null_ pg_timezone_abbrevs _null_ _null_ _null_ ));
DESCR("get the available time zone abbreviations");
DATA(insert OID = 2856 ( pg_timezone_names PGNSP PGUID 12 1 1000 0 f f t t s 0 0 2249 "" "{25,25,1186,16}" "{o,o,o,o}" "{name,abbrev,utc_offset,is_dst}" _null_ pg_timezone_names _null_ _null_ _null_ ));
DESCR("get the available time zone names");
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/pg_proc_fn.h,v 1.3 2008/12/12 22:56:00 alvherre Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/pg_proc_fn.h,v 1.4 2008/12/18 18:20:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Datum allParameterTypes,
Datum parameterModes,
Datum parameterNames,
+ List *parameterDefaults,
Datum proconfig,
float4 procost,
- float4 prorows,
- List *parameterDefaults);
+ float4 prorows);
extern bool function_parse_error_transpose(const char *prosrc);
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.382 2008/12/06 23:22:46 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.383 2008/12/18 18:20:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
FUNC_PARAM_IN = 'i', /* input only */
FUNC_PARAM_OUT = 'o', /* output only */
FUNC_PARAM_INOUT = 'b', /* both */
- FUNC_PARAM_VARIADIC = 'v', /* variadic */
+ FUNC_PARAM_VARIADIC = 'v', /* variadic (always input) */
FUNC_PARAM_TABLE = 't' /* table function output column */
} FunctionParameterMode;
NodeTag type;
char *name; /* parameter name, or NULL if not given */
TypeName *argType; /* TypeName for parameter type */
- FunctionParameterMode mode; /* IN/OUT/INOUT */
- Node *defexpr; /* Default expression, or NULL if not given */
+ FunctionParameterMode mode; /* IN/OUT/etc */
+ Node *defexpr; /* raw default expr, or NULL if not given */
} FunctionParameter;
typedef struct AlterFunctionStmt
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/parser/parse_func.h,v 1.61 2008/12/04 17:51:27 petere Exp $
+ * $PostgreSQL: pgsql/src/include/parser/parse_func.h,v 1.62 2008/12/18 18:20:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool is_column, int location);
extern FuncDetailCode func_get_detail(List *funcname, List *fargs,
- int nargs, Oid *argtypes, bool expand_variadic,
+ int nargs, Oid *argtypes,
+ bool expand_variadic, bool expand_defaults,
Oid *funcid, Oid *rettype,
bool *retset, int *nvargs, Oid **true_typeids,
List **argdefaults);
FROM pg_proc as p1
WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
p1.pronargs < 0 OR
+ p1.pronargdefaults < 0 OR
+ p1.pronargdefaults > p1.pronargs OR
array_lower(p1.proargtypes, 1) != 0 OR
array_upper(p1.proargtypes, 1) != p1.pronargs-1 OR
0::oid = ANY (p1.proargtypes) OR
(0 rows)
-- pronargdefaults should be 0 iff proargdefaults is null
-SELECT p.oid, p.proname
-FROM pg_proc AS p
-WHERE pronargdefaults <> 0 OR proargdefaults IS NOT NULL;
+SELECT p1.oid, p1.proname
+FROM pg_proc AS p1
+WHERE (pronargdefaults <> 0) != (proargdefaults IS NOT NULL);
oid | proname
-----+---------
(0 rows)
integer
(1 row)
--- test functions with parameter defaults
+-- test functions with default parameters
-- test basic functionality
create function dfunc(a int = 1, int = 2) returns int as $$
select $1 + $2;
30
(1 row)
+select dfunc(10, 20, 30); -- fail
+ERROR: function dfunc(integer, integer, integer) does not exist
+LINE 1: select dfunc(10, 20, 30);
+ ^
+HINT: No function matches the given name and argument types. You might need to add explicit type casts.
drop function dfunc(); -- fail
ERROR: function dfunc() does not exist
drop function dfunc(int); -- fail
ERROR: function dfunc(integer) does not exist
drop function dfunc(int, int); -- ok
--- fail, gap in arguments with defaults
+-- fail: defaults must be at end of argument list
create function dfunc(a int = 1, b int) returns int as $$
select $1 + $2;
$$ language sql;
-ERROR: parameter without default value specified after parameter with default value
--- check implicit coercion
+ERROR: input parameters after one with a default value must also have defaults
+-- however, this should work:
+create function dfunc(a int = 1, out sum int, b int = 2) as $$
+ select $1 + $2;
+$$ language sql;
+select dfunc();
+ dfunc
+-------
+ 3
+(1 row)
+
+-- verify it lists properly
+\df dfunc
+ List of functions
+ Schema | Name | Result data type | Argument data types
+--------+-------+------------------+-----------------------------------------------------------
+ public | dfunc | integer | a integer DEFAULT 1, OUT sum integer, b integer DEFAULT 2
+(1 row)
+
+drop function dfunc(int, int);
+-- check implicit coercion
create function dfunc(a int DEFAULT 1.0, int DEFAULT '-1') returns int as $$
select $1 + $2;
$$ language sql;
create function dfunc(a text DEFAULT 'Hello', b text DEFAULT 'World') returns text as $$
select $1 || ', ' || $2;
$$ language sql;
-select dfunc(); -- fail; which dfunc should be called? int or text
-ERROR: functions with parameter defaults dfunc(text, text) and dfunc(integer, integer) are ambiguous
+select dfunc(); -- fail: which dfunc should be called? int or text
+ERROR: function dfunc() is not unique
+LINE 1: select dfunc();
+ ^
+HINT: Could not choose a best candidate function. You might need to add explicit type casts.
select dfunc('Hi'); -- ok
dfunc
-----------
drop function dfunc(int, int);
drop function dfunc(text, text);
create function dfunc(int = 1, int = 2) returns int as $$
- select 2;
+ select 2;
$$ language sql;
create function dfunc(int = 1, int = 2, int = 3, int = 4) returns int as $$
select 4;
$$ language sql;
-- Now, dfunc(nargs = 2) and dfunc(nargs = 4) are ambiguous when called
--- with 0 or 1 arguments. For 2 arguments, a normall call of
--- dfunc(nargs = 2) takes place.
+-- with 0 to 2 arguments.
select dfunc(); -- fail
-ERROR: functions with parameter defaults dfunc(integer, integer, integer, integer) and dfunc(integer, integer) are ambiguous
+ERROR: function dfunc() is not unique
+LINE 1: select dfunc();
+ ^
+HINT: Could not choose a best candidate function. You might need to add explicit type casts.
select dfunc(1); -- fail
-ERROR: functions with parameter defaults dfunc(integer, integer, integer, integer) and dfunc(integer, integer) are ambiguous
-select dfunc(1, 2); -- ok
- dfunc
--------
- 2
-(1 row)
-
+ERROR: function dfunc(integer) is not unique
+LINE 1: select dfunc(1);
+ ^
+HINT: Could not choose a best candidate function. You might need to add explicit type casts.
+select dfunc(1, 2); -- fail
+ERROR: function dfunc(integer, integer) is not unique
+LINE 1: select dfunc(1, 2);
+ ^
+HINT: Could not choose a best candidate function. You might need to add explicit type casts.
select dfunc(1, 2, 3); -- ok
dfunc
-------
drop function dfunc(int, int, int, int);
-- default values are not allowed for output parameters
create function dfunc(out int = 20) returns int as $$
- select 1;
+ select 1;
$$ language sql;
-ERROR: only IN and INOUT parameters can have default values
+ERROR: only input parameters can have default values
-- polymorphic parameter test
create function dfunc(anyelement = 'World'::text) returns text as $$
select 'Hello, ' || $1::text;
(1 row)
drop function dfunc(anyelement);
--- check null values
-create function dfunc(int = null, int = null, int = null) returns int[] as $$
- select array[$1, $2, $3];
-$$ language sql;
-select dfunc(1);
- dfunc
----------------
- {1,NULL,NULL}
+-- check defaults for variadics
+create function dfunc(a variadic int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
+select dfunc(); -- fail
+ERROR: function dfunc() does not exist
+LINE 1: select dfunc();
+ ^
+HINT: No function matches the given name and argument types. You might need to add explicit type casts.
+select dfunc(10);
+ dfunc
+-------
+ 1
(1 row)
-select dfunc(1, 2);
- dfunc
-------------
- {1,2,NULL}
+select dfunc(10,20);
+ dfunc
+-------
+ 2
(1 row)
-select dfunc(1, 2, 3);
- dfunc
----------
- {1,2,3}
+create or replace function dfunc(a variadic int[] default array[]::int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
+select dfunc(); -- now ok
+ dfunc
+-------
+
(1 row)
-drop function dfunc(int, int, int);
--- The conflict detection algorithm doesn't consider the actual parameter
--- types. It detects any possible conflict for n arguments for some
--- function. This is unwanted behavior, but solving it needs a move of
--- coercion routines.
+select dfunc(10);
+ dfunc
+-------
+ 1
+(1 row)
+
+select dfunc(10,20);
+ dfunc
+-------
+ 2
+(1 row)
+
+-- can't remove the default once it exists
+create or replace function dfunc(a variadic int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
+ERROR: cannot remove parameter defaults from existing function
+HINT: Use DROP FUNCTION first.
+\df dfunc
+ List of functions
+ Schema | Name | Result data type | Argument data types
+--------+-------+------------------+--------------------------------------
+ public | dfunc | integer | VARIADIC a integer[] DEFAULT ARRAY[]
+(1 row)
+
+drop function dfunc(a variadic int[]);
+-- Ambiguity should be reported only if there's not a better match available
create function dfunc(int = 1, int = 2, int = 3) returns int as $$
select 3;
$$ language sql;
create function dfunc(int = 1, int = 2) returns int as $$
select 2;
$$ language sql;
--- for n = 1 dfunc(narg=2) and dfunc(narg=3) are ambiguous
-select dfunc(1); -- fail
-ERROR: functions with parameter defaults dfunc(integer, integer, integer) and dfunc(integer, integer) are ambiguous
create function dfunc(text) returns text as $$
select $1;
$$ language sql;
--- Will fail, it detects ambiguity between dfunc(int, int, int) and
--- dfunc(int, int), but dfunc(text) isn't in conflict with either.
+-- dfunc(narg=2) and dfunc(narg=3) are ambiguous
+select dfunc(1); -- fail
+ERROR: function dfunc(integer) is not unique
+LINE 1: select dfunc(1);
+ ^
+HINT: Could not choose a best candidate function. You might need to add explicit type casts.
+-- but this works since the ambiguous functions aren't preferred anyway
select dfunc('Hi');
-ERROR: functions with parameter defaults dfunc(integer, integer, integer) and dfunc(integer, integer) are ambiguous
+ dfunc
+-------
+ Hi
+(1 row)
+
drop function dfunc(int, int, int);
drop function dfunc(int, int);
drop function dfunc(text);
FROM pg_proc as p1
WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
p1.pronargs < 0 OR
+ p1.pronargdefaults < 0 OR
+ p1.pronargdefaults > p1.pronargs OR
array_lower(p1.proargtypes, 1) != 0 OR
array_upper(p1.proargtypes, 1) != p1.pronargs-1 OR
0::oid = ANY (p1.proargtypes) OR
WHERE prosrc IS NULL OR prosrc = '' OR prosrc = '-';
-- pronargdefaults should be 0 iff proargdefaults is null
-SELECT p.oid, p.proname
-FROM pg_proc AS p
-WHERE pronargdefaults <> 0 OR proargdefaults IS NOT NULL;
+SELECT p1.oid, p1.proname
+FROM pg_proc AS p1
+WHERE (pronargdefaults <> 0) != (proargdefaults IS NOT NULL);
-- probin should be non-empty for C functions, null everywhere else
SELECT p1.oid, p1.proname
select pg_typeof(array[1.2,55.5]); -- numeric[]
select pg_typeof(myleast(10, 1, 20, 33)); -- polymorphic input
--- test functions with parameter defaults
+-- test functions with default parameters
+
-- test basic functionality
create function dfunc(a int = 1, int = 2) returns int as $$
select $1 + $2;
select dfunc();
select dfunc(10);
select dfunc(10, 20);
+select dfunc(10, 20, 30); -- fail
drop function dfunc(); -- fail
drop function dfunc(int); -- fail
drop function dfunc(int, int); -- ok
--- fail, gap in arguments with defaults
+-- fail: defaults must be at end of argument list
create function dfunc(a int = 1, b int) returns int as $$
select $1 + $2;
$$ language sql;
--- check implicit coercion
+-- however, this should work:
+create function dfunc(a int = 1, out sum int, b int = 2) as $$
+ select $1 + $2;
+$$ language sql;
+
+select dfunc();
+
+-- verify it lists properly
+\df dfunc
+
+drop function dfunc(int, int);
+
+-- check implicit coercion
create function dfunc(a int DEFAULT 1.0, int DEFAULT '-1') returns int as $$
select $1 + $2;
$$ language sql;
select dfunc();
+
create function dfunc(a text DEFAULT 'Hello', b text DEFAULT 'World') returns text as $$
select $1 || ', ' || $2;
$$ language sql;
-select dfunc(); -- fail; which dfunc should be called? int or text
+select dfunc(); -- fail: which dfunc should be called? int or text
select dfunc('Hi'); -- ok
select dfunc('Hi', 'City'); -- ok
select dfunc(0); -- ok
drop function dfunc(text, text);
create function dfunc(int = 1, int = 2) returns int as $$
- select 2;
+ select 2;
$$ language sql;
create function dfunc(int = 1, int = 2, int = 3, int = 4) returns int as $$
$$ language sql;
-- Now, dfunc(nargs = 2) and dfunc(nargs = 4) are ambiguous when called
--- with 0 or 1 arguments. For 2 arguments, a normall call of
--- dfunc(nargs = 2) takes place.
+-- with 0 to 2 arguments.
select dfunc(); -- fail
select dfunc(1); -- fail
-select dfunc(1, 2); -- ok
+select dfunc(1, 2); -- fail
select dfunc(1, 2, 3); -- ok
select dfunc(1, 2, 3, 4); -- ok
-- default values are not allowed for output parameters
create function dfunc(out int = 20) returns int as $$
- select 1;
+ select 1;
$$ language sql;
-- polymorphic parameter test
drop function dfunc(anyelement);
--- check null values
-create function dfunc(int = null, int = null, int = null) returns int[] as $$
- select array[$1, $2, $3];
-$$ language sql;
+-- check defaults for variadics
-select dfunc(1);
-select dfunc(1, 2);
-select dfunc(1, 2, 3);
+create function dfunc(a variadic int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
-drop function dfunc(int, int, int);
+select dfunc(); -- fail
+select dfunc(10);
+select dfunc(10,20);
+
+create or replace function dfunc(a variadic int[] default array[]::int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
+
+select dfunc(); -- now ok
+select dfunc(10);
+select dfunc(10,20);
+
+-- can't remove the default once it exists
+create or replace function dfunc(a variadic int[]) returns int as
+$$ select array_upper($1, 1) $$ language sql;
--- The conflict detection algorithm doesn't consider the actual parameter
--- types. It detects any possible conflict for n arguments for some
--- function. This is unwanted behavior, but solving it needs a move of
--- coercion routines.
+\df dfunc
+
+drop function dfunc(a variadic int[]);
+
+-- Ambiguity should be reported only if there's not a better match available
create function dfunc(int = 1, int = 2, int = 3) returns int as $$
select 3;
select 2;
$$ language sql;
--- for n = 1 dfunc(narg=2) and dfunc(narg=3) are ambiguous
-select dfunc(1); -- fail
-
create function dfunc(text) returns text as $$
select $1;
$$ language sql;
--- Will fail, it detects ambiguity between dfunc(int, int, int) and
--- dfunc(int, int), but dfunc(text) isn't in conflict with either.
+-- dfunc(narg=2) and dfunc(narg=3) are ambiguous
+select dfunc(1); -- fail
+
+-- but this works since the ambiguous functions aren't preferred anyway
select dfunc('Hi');
drop function dfunc(int, int, int);
projects / postgresql / commitdiff