Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit24e2885

Browse files
committed
Introduce "anycompatible" family of polymorphic types.
This patch adds the pseudo-types anycompatible, anycompatiblearray,anycompatiblenonarray, and anycompatiblerange. They work much likeanyelement, anyarray, anynonarray, and anyrange respectively, exceptthat the actual input values need not match precisely in type.Instead, if we can find a common supertype (using the same rulesas for UNION/CASE type resolution), then the parser automaticallypromotes the input values to that type. For example,"myfunc(anycompatible, anycompatible)" can match a call with oneinteger and one bigint argument, with the integer automaticallypromoted to bigint. With anyelement in the definition, the userwould have had to cast the integer explicitly.The new types also provide a second, independent set of type variablesfor function matching; thus with "myfunc(anyelement, anyelement,anycompatible) returns anycompatible" the first two arguments areconstrained to be the same type, but the third can be some othertype, and the result has the type of the third argument. The needfor more than one set of type variables was foreseen back when wefirst invented the polymorphic types, but we never did anythingabout it.Pavel Stehule, revised a bit by meDiscussion:https://postgr.es/m/CAFj8pRDna7VqNi8gR+Tt2Ktmz0cq5G93guc3Sbn_NVPLdXAkqA@mail.gmail.com
1 parentfab13dc commit24e2885

33 files changed

+2046
-131
lines changed

‎doc/src/sgml/datatype.sgml

Lines changed: 58 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -4798,6 +4798,22 @@ SELECT * FROM pg_attribute
47984798
<primary>anyrange</primary>
47994799
</indexterm>
48004800

4801+
<indexterm zone="datatype-pseudo">
4802+
<primary>anycompatible</primary>
4803+
</indexterm>
4804+
4805+
<indexterm zone="datatype-pseudo">
4806+
<primary>anycompatiblearray</primary>
4807+
</indexterm>
4808+
4809+
<indexterm zone="datatype-pseudo">
4810+
<primary>anycompatiblenonarray</primary>
4811+
</indexterm>
4812+
4813+
<indexterm zone="datatype-pseudo">
4814+
<primary>anycompatiblerange</primary>
4815+
</indexterm>
4816+
48014817
<indexterm zone="datatype-pseudo">
48024818
<primary>void</primary>
48034819
</indexterm>
@@ -4822,6 +4838,10 @@ SELECT * FROM pg_attribute
48224838
<primary>fdw_handler</primary>
48234839
</indexterm>
48244840

4841+
<indexterm zone="datatype-pseudo">
4842+
<primary>table_am_handler</primary>
4843+
</indexterm>
4844+
48254845
<indexterm zone="datatype-pseudo">
48264846
<primary>index_am_handler</primary>
48274847
</indexterm>
@@ -4903,6 +4923,35 @@ SELECT * FROM pg_attribute
49034923
<xref linkend="rangetypes"/>).</entry>
49044924
</row>
49054925

4926+
<row>
4927+
<entry><type>anycompatible</type></entry>
4928+
<entry>Indicates that a function accepts any data type,
4929+
with automatic promotion of multiple arguments to a common data type
4930+
(see <xref linkend="extend-types-polymorphic"/>).</entry>
4931+
</row>
4932+
4933+
<row>
4934+
<entry><type>anycompatiblearray</type></entry>
4935+
<entry>Indicates that a function accepts any array data type,
4936+
with automatic promotion of multiple arguments to a common data type
4937+
(see <xref linkend="extend-types-polymorphic"/>).</entry>
4938+
</row>
4939+
4940+
<row>
4941+
<entry><type>anycompatiblenonarray</type></entry>
4942+
<entry>Indicates that a function accepts any non-array data type,
4943+
with automatic promotion of multiple arguments to a common data type
4944+
(see <xref linkend="extend-types-polymorphic"/>).</entry>
4945+
</row>
4946+
4947+
<row>
4948+
<entry><type>anycompatiblerange</type></entry>
4949+
<entry>Indicates that a function accepts any range data type,
4950+
with automatic promotion of multiple arguments to a common data type
4951+
(see <xref linkend="extend-types-polymorphic"/> and
4952+
<xref linkend="rangetypes"/>).</entry>
4953+
</row>
4954+
49064955
<row>
49074956
<entry><type>cstring</type></entry>
49084957
<entry>Indicates that a function accepts or returns a null-terminated C string.</entry>
@@ -4924,6 +4973,11 @@ SELECT * FROM pg_attribute
49244973
<entry>A foreign-data wrapper handler is declared to return <type>fdw_handler</type>.</entry>
49254974
</row>
49264975

4976+
<row>
4977+
<entry><type>table_am_handler</type></entry>
4978+
<entry>A table access method handler is declared to return <type>table_am_handler</type>.</entry>
4979+
</row>
4980+
49274981
<row>
49284982
<entry><type>index_am_handler</type></entry>
49294983
<entry>An index access method handler is declared to return <type>index_am_handler</type>.</entry>
@@ -4970,7 +5024,7 @@ SELECT * FROM pg_attribute
49705024

49715025
<para>
49725026
Functions coded in C (whether built-in or dynamically loaded) can be
4973-
declared to accept or return any of these pseudo datatypes. It is up to
5027+
declared to accept or return any of these pseudo-types. It is up to
49745028
the function author to ensure that the function will behave safely
49755029
when a pseudo-type is used as an argument type.
49765030
</para>
@@ -4981,10 +5035,9 @@ SELECT * FROM pg_attribute
49815035
languages forbid use of a pseudo-type as an argument type, and allow
49825036
only <type>void</type> and <type>record</type> as a result type (plus
49835037
<type>trigger</type> or <type>event_trigger</type> when the function is used
4984-
as a trigger or event trigger). Some also
4985-
support polymorphic functions using the types <type>anyelement</type>,
4986-
<type>anyarray</type>, <type>anynonarray</type>, <type>anyenum</type>, and
4987-
<type>anyrange</type>.
5038+
as a trigger or event trigger). Some also support polymorphic functions
5039+
using the polymorphic pseudo-types, which are shown above and discussed
5040+
in detail in <xref linkend="extend-types-polymorphic"/>.
49885041
</para>
49895042

49905043
<para>

‎doc/src/sgml/extend.sgml

Lines changed: 167 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -229,21 +229,114 @@
229229
</indexterm>
230230

231231
<para>
232-
Five pseudo-types of special interest are <type>anyelement</type>,
233-
<type>anyarray</type>, <type>anynonarray</type>, <type>anyenum</type>,
234-
and <type>anyrange</type>,
235-
which are collectively called <firstterm>polymorphic types</firstterm>.
236-
Any function declared using these types is said to be
237-
a <firstterm>polymorphic function</firstterm>. A polymorphic function can
238-
operate on many different data types, with the specific data type(s)
239-
being determined by the data types actually passed to it in a particular
240-
call.
232+
Some pseudo-types of special interest are the <firstterm>polymorphic
233+
types</firstterm>, which are used to declare <firstterm>polymorphic
234+
functions</firstterm>. This powerful feature allows a single function
235+
definition to operate on many different data types, with the specific
236+
data type(s) being determined by the data types actually passed to it
237+
in a particular call. The polymorphic types are shown in
238+
<xref linkend="extend-types-polymorphic-table"/>. Some examples of
239+
their use appear in <xref linkend="xfunc-sql-polymorphic-functions"/>.
241240
</para>
242241

242+
<table id="extend-types-polymorphic-table">
243+
<title>Polymorphic Types</title>
244+
<tgroup cols="3">
245+
<thead>
246+
<row>
247+
<entry>Name</entry>
248+
<entry>Family</entry>
249+
<entry>Description</entry>
250+
</row>
251+
</thead>
252+
253+
<tbody>
254+
<row>
255+
<entry><type>anyelement</type></entry>
256+
<entry>Simple</entry>
257+
<entry>Indicates that a function accepts any data type</entry>
258+
</row>
259+
260+
<row>
261+
<entry><type>anyarray</type></entry>
262+
<entry>Simple</entry>
263+
<entry>Indicates that a function accepts any array data type</entry>
264+
</row>
265+
266+
<row>
267+
<entry><type>anynonarray</type></entry>
268+
<entry>Simple</entry>
269+
<entry>Indicates that a function accepts any non-array data type</entry>
270+
</row>
271+
272+
<row>
273+
<entry><type>anyenum</type></entry>
274+
<entry>Simple</entry>
275+
<entry>Indicates that a function accepts any enum data type
276+
(see <xref linkend="datatype-enum"/>)
277+
</entry>
278+
</row>
279+
280+
<row>
281+
<entry><type>anyrange</type></entry>
282+
<entry>Simple</entry>
283+
<entry>Indicates that a function accepts any range data type
284+
(see <xref linkend="rangetypes"/>)
285+
</entry>
286+
</row>
287+
288+
<row>
289+
<entry><type>anycompatible</type></entry>
290+
<entry>Common</entry>
291+
<entry>Indicates that a function accepts any data type,
292+
with automatic promotion of multiple arguments to a common data type
293+
</entry>
294+
</row>
295+
296+
<row>
297+
<entry><type>anycompatiblearray</type></entry>
298+
<entry>Common</entry>
299+
<entry>Indicates that a function accepts any array data type,
300+
with automatic promotion of multiple arguments to a common data type
301+
</entry>
302+
</row>
303+
304+
<row>
305+
<entry><type>anycompatiblenonarray</type></entry>
306+
<entry>Common</entry>
307+
<entry>Indicates that a function accepts any non-array data type,
308+
with automatic promotion of multiple arguments to a common data type
309+
</entry>
310+
</row>
311+
312+
<row>
313+
<entry><type>anycompatiblerange</type></entry>
314+
<entry>Common</entry>
315+
<entry>Indicates that a function accepts any range data type,
316+
with automatic promotion of multiple arguments to a common data type
317+
</entry>
318+
</row>
319+
</tbody>
320+
</tgroup>
321+
</table>
322+
243323
<para>
244324
Polymorphic arguments and results are tied to each other and are resolved
245-
to a specific data type when a query calling a polymorphic function is
246-
parsed. Each position (either argument or return value) declared as
325+
to specific data types when a query calling a polymorphic function is
326+
parsed. When there is more than one polymorphic argument, the actual
327+
data types of the input values must match up as described below. If the
328+
function's result type is polymorphic, or it has output parameters of
329+
polymorphic types, the types of those results are deduced from the
330+
actual types of the polymorphic inputs as described below.
331+
</para>
332+
333+
<para>
334+
For the <quote>simple</quote> family of polymorphic types, the
335+
matching and deduction rules work like this:
336+
</para>
337+
338+
<para>
339+
Each position (either argument or return value) declared as
247340
<type>anyelement</type> is allowed to have any specific actual
248341
data type, but in any given call they must all be the
249342
<emphasis>same</emphasis> actual type. Each
@@ -280,7 +373,8 @@
280373
<para>
281374
When the return value of a function is declared as a polymorphic type,
282375
there must be at least one argument position that is also polymorphic,
283-
and the actual data type supplied as the argument determines the actual
376+
and the actual data type(s) supplied for the polymorphic arguments
377+
determine the actual
284378
result type for that call. For example, if there were not already
285379
an array subscripting mechanism, one could define a function that
286380
implements subscripting as <literal>subscript(anyarray, integer)
@@ -294,8 +388,9 @@
294388
<para>
295389
In most cases, the parser can infer the actual data type for a
296390
polymorphic result type from arguments that are of a different
297-
polymorphic type; for example <type>anyarray</type> can be deduced
298-
from <type>anyelement</type> or vice versa. The exception is that a
391+
polymorphic type in the same family; for example <type>anyarray</type>
392+
can be deduced from <type>anyelement</type> or vice versa.
393+
An exception is that a
299394
polymorphic result of type <type>anyrange</type> requires an argument
300395
of type <type>anyrange</type>; it cannot be deduced
301396
from <type>anyarray</type> or <type>anyelement</type> arguments. This
@@ -311,14 +406,70 @@
311406
both actual arguments have to be the same enum type.
312407
</para>
313408

409+
<para>
410+
For the <quote>common</quote> family of polymorphic types, the
411+
matching and deduction rules work approximately the same as for
412+
the <quote>simple</quote> family, with one major difference: the
413+
actual types of the arguments need not be identical, so long as they
414+
can be implicitly cast to a single common type. The common type is
415+
selected following the same rules as for <literal>UNION</literal> and
416+
related constructs (see <xref linkend="typeconv-union-case"/>).
417+
Selection of the common type considers the actual types
418+
of <type>anycompatible</type> and <type>anycompatiblenonarray</type>
419+
inputs, the array element types of <type>anycompatiblearray</type>
420+
inputs, and the range subtypes of <type>anycompatiblerange</type>
421+
inputs. If <type>anycompatiblenonarray</type> is present then the
422+
common type is required to be a non-array type. Once a common type is
423+
identified, arguments in <type>anycompatible</type>
424+
and <type>anycompatiblenonarray</type> positions are automatically
425+
cast to that type, and arguments in <type>anycompatiblearray</type>
426+
positions are automatically cast to the array type for that type.
427+
</para>
428+
429+
<para>
430+
Since there is no way to select a range type knowing only its subtype,
431+
use of <type>anycompatiblerange</type> requires that all arguments
432+
declared with that type have the same actual range type, and that that
433+
type's subtype agree with the selected common type, so that no casting
434+
of the range values is required. As with <type>anyrange</type>, use
435+
of <type>anycompatiblerange</type> as a function result type requires
436+
that there be an <type>anycompatiblerange</type> argument.
437+
</para>
438+
439+
<para>
440+
Notice that there is no <type>anycompatibleenum</type> type. Such a
441+
type would not be very useful, since there normally are not any
442+
implicit casts to enum types, meaning that there would be no way to
443+
resolve a common type for dissimilar enum inputs.
444+
</para>
445+
446+
<para>
447+
The <quote>simple</quote> and <quote>common</quote> polymorphic
448+
families represent two independent sets of type variables. Consider
449+
for example
450+
<programlisting>
451+
CREATE FUNCTION myfunc(a anyelement, b anyelement,
452+
c anycompatible, d anycompatible)
453+
RETURNS anycompatible AS ...
454+
</programlisting>
455+
In an actual call of this function, the first two inputs must have
456+
exactly the same type. The last two inputs must be promotable to a
457+
common type, but this type need not have anything to do with the type
458+
of the first two inputs. The result will have the common type of the
459+
last two inputs.
460+
</para>
461+
314462
<para>
315463
A variadic function (one taking a variable number of arguments, as in
316464
<xref linkend="xfunc-sql-variadic-functions"/>) can be
317465
polymorphic: this is accomplished by declaring its last parameter as
318-
<literal>VARIADIC</literal> <type>anyarray</type>. For purposes of argument
466+
<literal>VARIADIC</literal> <type>anyarray</type> or
467+
<literal>VARIADIC</literal> <type>anycompatiblearray</type>.
468+
For purposes of argument
319469
matching and determining the actual result type, such a function behaves
320470
the same as if you had written the appropriate number of
321-
<type>anynonarray</type> parameters.
471+
<type>anynonarray</type> or <type>anycompatiblenonarray</type>
472+
parameters.
322473
</para>
323474
</sect2>
324475
</sect1>

‎doc/src/sgml/plpgsql.sgml

Lines changed: 36 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -138,13 +138,11 @@
138138
</para>
139139

140140
<para>
141-
<application>PL/pgSQL</application> functions can also be declared to accept
142-
and return the polymorphic types
143-
<type>anyelement</type>, <type>anyarray</type>, <type>anynonarray</type>,
144-
<type>anyenum</type>, and <type>anyrange</type>. The actual
145-
data types handled by a polymorphic function can vary from call to
146-
call, as discussed in <xref linkend="extend-types-polymorphic"/>.
147-
An example is shown in <xref linkend="plpgsql-declaration-parameters"/>.
141+
<application>PL/pgSQL</application> functions can also be declared to
142+
accept and return the polymorphic types described in
143+
<xref linkend="extend-types-polymorphic"/>, thus allowing the actual data
144+
types handled by the function to vary from call to call.
145+
Examples appear in <xref linkend="plpgsql-declaration-parameters"/>.
148146
</para>
149147

150148
<para>
@@ -519,13 +517,11 @@ $$ LANGUAGE plpgsql;
519517
</para>
520518

521519
<para>
522-
When the return type of a <application>PL/pgSQL</application>
523-
function is declared as a polymorphic type (<type>anyelement</type>,
524-
<type>anyarray</type>, <type>anynonarray</type>, <type>anyenum</type>,
525-
or <type>anyrange</type>), a special parameter <literal>$0</literal>
526-
is created. Its data type is the actual return type of the function,
527-
as deduced from the actual input types (see <xref
528-
linkend="extend-types-polymorphic"/>).
520+
When the return type of a <application>PL/pgSQL</application> function
521+
is declared as a polymorphic type (see
522+
<xref linkend="extend-types-polymorphic"/>), a special
523+
parameter <literal>$0</literal> is created. Its data type is the actual
524+
return type of the function, as deduced from the actual input types.
529525
This allows the function to access its actual return type
530526
as shown in <xref linkend="plpgsql-declaration-type"/>.
531527
<literal>$0</literal> is initialized to null and can be modified by
@@ -563,6 +559,32 @@ END;
563559
$$ LANGUAGE plpgsql;
564560
</programlisting>
565561
</para>
562+
563+
<para>
564+
In practice it might be more useful to declare a polymorphic function
565+
using the <type>anycompatible</type> family of types, so that automatic
566+
promotion of the input arguments to a common type will occur.
567+
For example:
568+
569+
<programlisting>
570+
CREATE FUNCTION add_three_values(v1 anycompatible, v2 anycompatible, v3 anycompatible)
571+
RETURNS anycompatible AS $$
572+
BEGIN
573+
RETURN v1 + v2 + v3;
574+
END;
575+
$$ LANGUAGE plpgsql;
576+
</programlisting>
577+
578+
With this example, a call such as
579+
580+
<programlisting>
581+
SELECT add_three_values(1, 2, 4.7);
582+
</programlisting>
583+
584+
will work, automatically promoting the integer inputs to numeric.
585+
The function using <type>anyelement</type> would require you to
586+
cast the three inputs to the same type manually.
587+
</para>
566588
</sect2>
567589

568590
<sect2 id="plpgsql-declaration-alias">

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp