Loading...
Searching...
No Matches
parse_func.c File Reference
#include "postgres.h"#include "access/htup_details.h"#include "catalog/pg_aggregate.h"#include "catalog/pg_proc.h"#include "catalog/pg_type.h"#include "funcapi.h"#include "lib/stringinfo.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "parser/parse_agg.h"#include "parser/parse_clause.h"#include "parser/parse_coerce.h"#include "parser/parse_expr.h"#include "parser/parse_func.h"#include "parser/parse_relation.h"#include "parser/parse_target.h"#include "parser/parse_type.h"#include "utils/builtins.h"#include "utils/lsyscache.h"#include "utils/syscache.h"
Include dependency graph for parse_func.c:
Go to the source code of this file.
Enumerations | |
| enum | FuncLookupError { FUNCLOOKUP_NOSUCHFUNC , FUNCLOOKUP_AMBIGUOUS } |
Enumeration Type Documentation
◆ FuncLookupError
| Enumerator | |
|---|---|
| FUNCLOOKUP_NOSUCHFUNC | |
| FUNCLOOKUP_AMBIGUOUS | |
Definition at line 39 of file parse_func.c.
40{
43} FuncLookupError;
Function Documentation
◆ check_srf_call_placement()
| void check_srf_call_placement | ( | ParseState * | pstate, |
| Node * | last_srf, | ||
| int | location | ||
| ) |
Definition at line 2639 of file parse_func.c.
2640{
2643
2644 /*
2645 * Check to see if the set-returning function is in an invalid place
2646 * within the query. Basically, we don't allow SRFs anywhere except in
2647 * the targetlist (which includes GROUP BY/ORDER BY expressions), VALUES,
2648 * and functions in FROM.
2649 *
2650 * For brevity we support two schemes for reporting an error here: set
2651 * "err" to a custom message, or set "errkind" true if the error context
2652 * is sufficiently identified by what ParseExprKindName will return, *and*
2653 * what it will return is just a SQL keyword. (Otherwise, use a custom
2654 * message to avoid creating translation problems.)
2655 */
2659 {
2662 break;
2664 /* Accept SRF here; caller must throw error if wanted */
2665 break;
2669 break;
2671 /* can't get here, but just in case, throw an error */
2673 break;
2675 /* okay, but we don't allow nested SRFs here */
2676 /* errmsg is chosen to match transformRangeFunction() */
2677 /* errposition should point to the inner SRF */
2682 parser_errposition(pstate,
2684 break;
2687 break;
2690 break;
2693 break;
2696 break;
2699 /* okay, these are effectively GROUP BY/ORDER BY */
2701 break;
2706 break;
2709 /* okay */
2711 break;
2714 /* disallowed because it would be ambiguous what to do */
2716 break;
2719 /* okay */
2721 break;
2723 /* okay */
2725 break;
2729 break;
2733 break;
2735 /* SRFs are presently not supported by nodeValuesscan.c */
2737 break;
2739 /* okay, since we process this like a SELECT tlist */
2741 break;
2744 break;
2748 break;
2752 break;
2755 break;
2758 break;
2761 break;
2764 break;
2767 break;
2770 break;
2773 break;
2776 break;
2779 break;
2782 break;
2785 break;
2788 break;
2791 break;
2794 break;
2795
2796 /*
2797 * There is intentionally no default: case here, so that the
2798 * compiler will warn if we add a new ParseExprKind without
2799 * extending this switch. If we do see an unrecognized value at
2800 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
2801 * which is sane anyway.
2802 */
2803 }
2808 parser_errposition(pstate, location)));
2812 /* translator: %s is name of a SQL construct, eg GROUP BY */
2815 parser_errposition(pstate, location)));
2816}
int int errmsg_internal(const char *fmt,...) pg_attribute_printf(1
int parser_errposition(ParseState *pstate, int location)
Definition parse_node.c:106
References _, Assert, ereport, err(), errcode(), errmsg, errmsg_internal(), ERROR, EXPR_KIND_ALTER_COL_TRANSFORM, EXPR_KIND_CALL_ARGUMENT, EXPR_KIND_CHECK_CONSTRAINT, EXPR_KIND_COLUMN_DEFAULT, EXPR_KIND_COPY_WHERE, EXPR_KIND_CYCLE_MARK, EXPR_KIND_DISTINCT_ON, EXPR_KIND_DOMAIN_CHECK, EXPR_KIND_EXECUTE_PARAMETER, EXPR_KIND_FILTER, EXPR_KIND_FOR_PORTION, EXPR_KIND_FROM_FUNCTION, EXPR_KIND_FROM_SUBSELECT, EXPR_KIND_FUNCTION_DEFAULT, EXPR_KIND_GENERATED_COLUMN, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_INDEX_EXPRESSION, EXPR_KIND_INDEX_PREDICATE, EXPR_KIND_INSERT_TARGET, EXPR_KIND_JOIN_ON, EXPR_KIND_JOIN_USING, EXPR_KIND_LIMIT, EXPR_KIND_MERGE_RETURNING, EXPR_KIND_MERGE_WHEN, EXPR_KIND_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_OTHER, EXPR_KIND_PARTITION_BOUND, EXPR_KIND_PARTITION_EXPRESSION, EXPR_KIND_POLICY, EXPR_KIND_PROPGRAPH_PROPERTY, EXPR_KIND_RETURNING, EXPR_KIND_SELECT_TARGET, EXPR_KIND_STATS_EXPRESSION, EXPR_KIND_TRIGGER_WHEN, EXPR_KIND_UPDATE_SOURCE, EXPR_KIND_UPDATE_TARGET, EXPR_KIND_VALUES, EXPR_KIND_VALUES_SINGLE, EXPR_KIND_WHERE, EXPR_KIND_WINDOW_FRAME_GROUPS, EXPR_KIND_WINDOW_FRAME_RANGE, EXPR_KIND_WINDOW_FRAME_ROWS, EXPR_KIND_WINDOW_ORDER, EXPR_KIND_WINDOW_PARTITION, exprLocation(), fb(), ParseState::p_expr_kind, ParseState::p_hasTargetSRFs, ParseState::p_last_srf, ParseExprKindName(), and parser_errposition().
Referenced by make_op(), and ParseFuncOrColumn().
◆ func_get_detail()
| FuncDetailCode func_get_detail | ( | List * | funcname, |
| List * | fargs, | ||
| List * | fargnames, | ||
| int | nargs, | ||
| Oid * | argtypes, | ||
| bool | expand_variadic, | ||
| bool | expand_defaults, | ||
| bool | include_out_arguments, | ||
| int * | fgc_flags, | ||
| Oid * | funcid, | ||
| Oid * | rettype, | ||
| bool * | retset, | ||
| int * | nvargs, | ||
| Oid * | vatype, | ||
| Oid ** | true_typeids, | ||
| List ** | argdefaults | ||
| ) |
Definition at line 1516 of file parse_func.c.
1532{
1535
1536 /* initialize output arguments to silence compiler warnings */
1537 *funcid = InvalidOid;
1538 *rettype = InvalidOid;
1539 *retset = false;
1540 *nvargs = 0;
1545
1546 /* Get list of possible candidates from namespace search */
1550 fgc_flags);
1551
1552 /*
1553 * Quickly check if there is an exact match to the input datatypes (there
1554 * can be only one)
1555 */
1559 {
1560 /* if nargs==0, argtypes can be null; don't pass that to memcmp */
1561 if (nargs == 0 ||
1563 break;
1564 }
1565
1567 {
1568 /*
1569 * If we didn't find an exact match, next consider the possibility
1570 * that this is really a type-coercion request: a single-argument
1571 * function call where the function name is a type name. If so, and
1572 * if the coercion path is RELABELTYPE or COERCEVIAIO, then go ahead
1573 * and treat the "function call" as a coercion.
1574 *
1575 * This interpretation needs to be given higher priority than
1576 * interpretations involving a type coercion followed by a function
1577 * call, otherwise we can produce surprising results. For example, we
1578 * want "text(varchar)" to be interpreted as a simple coercion, not as
1579 * "text(name(varchar))" which the code below this point is entirely
1580 * capable of selecting.
1581 *
1582 * We also treat a coercion of a previously-unknown-type literal
1583 * constant to a specific type this way.
1584 *
1585 * The reason we reject COERCION_PATH_FUNC here is that we expect the
1586 * cast implementation function to be named after the target type.
1587 * Thus the function will be found by normal lookup if appropriate.
1588 *
1589 * The reason we reject COERCION_PATH_ARRAYCOERCE is mainly that you
1590 * can't write "foo[] (something)" as a function call. In theory
1591 * someone might want to invoke it as "_foo (something)" but we have
1592 * never supported that historically, so we can insist that people
1593 * write it as a normal cast instead.
1594 *
1595 * We also reject the specific case of COERCEVIAIO for a composite
1596 * source type and a string-category target type. This is a case that
1597 * find_coercion_pathway() allows by default, but experience has shown
1598 * that it's too commonly invoked by mistake. So, again, insist that
1599 * people use cast syntax if they want to do that.
1600 *
1601 * NB: it's important that this code does not exceed what coerce_type
1602 * can do, because the caller will try to apply coerce_type if we
1603 * return FUNCDETAIL_COERCION. If we return that result for something
1604 * coerce_type can't handle, we'll cause infinite recursion between
1605 * this module and coerce_type!
1606 */
1608 {
1610
1612 {
1616
1618 {
1619 /* always treat typename('literal') as coercion */
1621 }
1622 else
1623 {
1626
1628 COERCION_EXPLICIT,
1629 &cfuncid);
1631 {
1634 break;
1640 else
1642 break;
1643 default:
1645 break;
1646 }
1647 }
1648
1650 {
1651 /* Treat it as a type coercion */
1652 *funcid = InvalidOid;
1653 *rettype = targetType;
1654 *retset = false;
1655 *nvargs = 0;
1657 *true_typeids = argtypes;
1659 }
1660 }
1661 }
1662
1663 /*
1664 * didn't find an exact match, so now try to match up candidates...
1665 */
1667 {
1670
1672 argtypes,
1673 raw_candidates,
1674 ¤t_candidates);
1675
1676 /* one match only? then run with it... */
1679
1680 /*
1681 * multiple candidates? then better decide or throw an error...
1682 */
1684 {
1686 argtypes,
1687 current_candidates);
1688
1689 /*
1690 * If we were able to choose a best candidate, we're done.
1691 * Otherwise, ambiguous function call.
1692 */
1695 }
1696 }
1697 }
1698
1700 {
1704
1705 /*
1706 * If processing named args or expanding variadics or defaults, the
1707 * "best candidate" might represent multiple equivalently good
1708 * functions; treat this case as ambiguous.
1709 */
1712
1713 /*
1714 * We disallow VARIADIC with named arguments unless the last argument
1715 * (the one with VARIADIC attached) actually matched the variadic
1716 * parameter. This is mere pedantry, really, but some folks insisted.
1717 */
1719 best_candidate->argnumbers[nargs - 1] != nargs - 1)
1720 {
1723 }
1724
1725 *funcid = best_candidate->oid;
1726 *nvargs = best_candidate->nvargs;
1728
1729 /*
1730 * If processing named args, return actual argument positions into
1731 * NamedArgExpr nodes in the fargs list. This is a bit ugly but not
1732 * worth the extra notation needed to do it differently.
1733 */
1735 {
1738
1740 {
1742
1745 i++;
1746 }
1747 }
1748
1753 best_candidate->oid);
1755 *rettype = pform->prorettype;
1756 *retset = pform->proretset;
1758 /* fetch default args if caller wants 'em */
1760 {
1763 List *defaults;
1764
1765 /* shouldn't happen, FuncnameGetCandidates messed up */
1768
1770 Anum_pg_proc_proargdefaults);
1774
1775 /* Delete any unused defaults from the returned list */
1777 {
1778 /*
1779 * This is a bit tricky in named notation, since the supplied
1780 * arguments could replace any subset of the defaults. We
1781 * work by making a bitmapset of the argnumbers of defaulted
1782 * arguments, then scanning the defaults list and selecting
1783 * the needed items. (This assumes that defaulted arguments
1784 * should be supplied in their positional order.)
1785 */
1791
1800 {
1803 i++;
1804 }
1808 }
1809 else
1810 {
1811 /*
1812 * Defaults for positional notation are lots easier; just
1813 * remove any unwanted ones from the front.
1814 */
1816
1820 *argdefaults = defaults;
1821 }
1822 }
1823
1825 {
1828 break;
1831 break;
1834 break;
1837 break;
1838 default:
1841 break;
1842 }
1843
1846 }
1847
1849}
FuncCandidateList FuncnameGetCandidates(List *names, int nargs, List *argnames, bool expand_variadic, bool expand_defaults, bool include_out_arguments, bool missing_ok, int *fgc_flags)
Definition namespace.c:1199
CoercionPathType find_coercion_pathway(Oid targetTypeId, Oid sourceTypeId, CoercionContext ccontext, Oid *funcid)
Definition parse_coerce.c:3158
FuncCandidateList func_select_candidate(int nargs, Oid *input_typeids, FuncCandidateList candidates)
Definition parse_func.c:1123
int func_match_argtypes(int nargs, Oid *input_typeids, FuncCandidateList raw_candidates, FuncCandidateList *candidates)
Definition parse_func.c:1037
Definition bitmapset.h:50
Definition primnodes.h:325
Definition htup.h:63
Definition pg_list.h:54
Definition primnodes.h:821
Definition nodes.h:135
Definition namespace.h:30
Datum SysCacheGetAttrNotNull(SysCacheIdentifier cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition syscache.c:626
HeapTuple SearchSysCache1(SysCacheIdentifier cacheId, Datum key1)
Definition syscache.c:221
Definition pg_list.h:46
References NamedArgExpr::argnumber, Assert, bms_add_member(), bms_free(), bms_is_member(), castNode, COERCION_EXPLICIT, COERCION_PATH_COERCEVIAIO, COERCION_PATH_RELABELTYPE, elog, ERROR, fb(), FGC_VARIADIC_FAIL, find_coercion_pathway(), Form_pg_proc, func_match_argtypes(), func_select_candidate(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_COERCION, FUNCDETAIL_MULTIPLE, FUNCDETAIL_NORMAL, FUNCDETAIL_NOTFOUND, FUNCDETAIL_PROCEDURE, FUNCDETAIL_WINDOWFUNC, funcname, FuncNameAsType(), FuncnameGetCandidates(), GETSTRUCT(), HeapTupleIsValid, i, InvalidOid, IsA, ISCOMPLEX, lappend(), lfirst, linitial, list_delete_first_n(), list_length(), NIL, ObjectIdGetDatum(), OidIsValid, pfree(), ReleaseSysCache(), result, SearchSysCache1(), str, stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and TypeCategory().
Referenced by generate_function_name(), lookup_agg_function(), and ParseFuncOrColumn().
◆ func_lookup_failure_details()
Definition at line 930 of file parse_func.c.
931{
932 /*
933 * If not FGC_NAME_VISIBLE, we shouldn't raise the question of whether the
934 * arguments are wrong. If the function name was not schema-qualified,
935 * it's helpful to distinguish between doesn't-exist-anywhere and
936 * not-in-search-path; but if it was, there's really nothing to add to the
937 * basic "function/procedure %s does not exist" message.
938 *
939 * Note: we passed missing_ok = false to FuncnameGetCandidates, so there's
940 * no need to consider FGC_SCHEMA_EXISTS here: we'd have already thrown an
941 * error if an explicitly-given schema doesn't exist.
942 */
944 {
946 return 0; /* schema-qualified name */
948 {
951 else
953 }
954 else
955 {
958 else
960 }
961 }
962
963 /*
964 * Next, complain if nothing had the right number of arguments. (This
965 * takes precedence over wrong-argnames cases because we won't even look
966 * at the argnames unless there's a workable number of arguments.)
967 */
969 {
972 else
974 }
975
976 /*
977 * If there are argnames, and we failed to match them, again we should
978 * mention that and not bring up the argument types.
979 */
981 {
984 else
986 }
987
988 /*
989 * We could have matched all the given argnames and still not have had a
990 * valid call, either because of improper use of mixed notation, or
991 * because of missing arguments, or because the user misused VARIADIC. The
992 * rules about named-argument matching are finicky enough that it's worth
993 * trying to be specific about the problem. (The messages here are chosen
994 * with full knowledge of the steps that namespace.c uses while checking a
995 * potential match.)
996 */
999 "an argument was specified both positionally and by name.");
1000
1003 "not all required arguments were supplied.");
1004
1006 return errhint("This call would be correct if the variadic array were labeled VARIADIC and placed last.");
1007
1010
1011 /*
1012 * Otherwise, the problem must be incorrect argument types.
1013 */
1016 else
1019}
int errhint(const char *fmt,...) pg_attribute_printf(1
int errdetail(const char *fmt,...) pg_attribute_printf(1
References errdetail(), errhint(), fb(), FGC_ARGCOUNT_MATCH, FGC_ARGNAMES_ALL, FGC_ARGNAMES_MATCH, FGC_ARGNAMES_NONDUP, FGC_ARGNAMES_VALID, FGC_NAME_EXISTS, FGC_NAME_VISIBLE, FGC_SCHEMA_GIVEN, FGC_VARIADIC_FAIL, and NIL.
Referenced by ParseFuncOrColumn().
◆ func_match_argtypes()
| int func_match_argtypes | ( | int | nargs, |
| Oid * | input_typeids, | ||
| FuncCandidateList | raw_candidates, | ||
| FuncCandidateList * | candidates | ||
| ) |
Definition at line 1037 of file parse_func.c.
1041{
1045
1047
1051 {
1054 COERCION_IMPLICIT))
1055 {
1058 ncandidates++;
1059 }
1060 }
1061
1063} /* func_match_argtypes() */
bool can_coerce_type(int nargs, const Oid *input_typeids, const Oid *target_typeids, CoercionContext ccontext)
Definition parse_coerce.c:558
References can_coerce_type(), COERCION_IMPLICIT, fb(), and _FuncCandidateList::next.
Referenced by func_get_detail(), and oper_select_candidate().
◆ func_select_candidate()
| FuncCandidateList func_select_candidate | ( | int | nargs, |
| Oid * | input_typeids, | ||
| FuncCandidateList | candidates | ||
| ) |
Definition at line 1123 of file parse_func.c.
1126{
1128 first_candidate,
1129 last_candidate;
1135 nmatch,
1136 nunknowns;
1139 current_category;
1143
1144 /* protect local fixed-size arrays */
1149 "cannot pass more than %d arguments to a function",
1150 FUNC_MAX_ARGS,
1151 FUNC_MAX_ARGS)));
1152
1153 /*
1154 * If any input types are domains, reduce them to their base types. This
1155 * ensures that we will consider functions on the base type to be "exact
1156 * matches" in the exact-match heuristic; it also makes it possible to do
1157 * something useful with the type-category heuristics. Note that this
1158 * makes it difficult, but not impossible, to use functions declared to
1159 * take a domain as an input datatype. Such a function will be selected
1160 * over the base-type function only if it is an exact match at all
1161 * argument positions, and so was already chosen by our caller.
1162 *
1163 * While we're at it, count the number of unknown-type arguments for use
1164 * later.
1165 */
1166 nunknowns = 0;
1168 {
1171 else
1172 {
1173 /* no need to call getBaseType on UNKNOWNOID */
1175 nunknowns++;
1176 }
1177 }
1178
1179 /*
1180 * Run through all candidates and keep those with the most matches on
1181 * exact types. Keep all candidates if none match.
1182 */
1183 ncandidates = 0;
1184 nbestMatch = 0;
1189 {
1191 nmatch = 0;
1193 {
1196 nmatch++;
1197 }
1198
1199 /* take this one as the best choice so far? */
1201 {
1202 nbestMatch = nmatch;
1205 ncandidates = 1;
1206 }
1207 /* no worse than the last choice, so keep this one too? */
1209 {
1212 ncandidates++;
1213 }
1214 /* otherwise, don't bother keeping this one... */
1215 }
1216
1219
1222
1223 /*
1224 * Still too many candidates? Now look for candidates which have either
1225 * exact matches or preferred types at the args that will require
1226 * coercion. (Restriction added in 7.4: preferred type must be of same
1227 * category as input type; give no preference to cross-category
1228 * conversions to preferred types.) Keep all candidates if none match.
1229 */
1232 ncandidates = 0;
1233 nbestMatch = 0;
1238 {
1240 nmatch = 0;
1242 {
1244 {
1247 nmatch++;
1248 }
1249 }
1250
1252 {
1253 nbestMatch = nmatch;
1256 ncandidates = 1;
1257 }
1259 {
1262 ncandidates++;
1263 }
1264 }
1265
1268
1271
1272 /*
1273 * Still too many candidates? Try assigning types for the unknown inputs.
1274 *
1275 * If there are no unknown inputs, we have no more heuristics that apply,
1276 * and must fail.
1277 */
1280
1281 /*
1282 * The next step examines each unknown argument position to see if we can
1283 * determine a "type category" for it. If any candidate has an input
1284 * datatype of STRING category, use STRING category (this bias towards
1285 * STRING is appropriate since unknown-type literals look like strings).
1286 * Otherwise, if all the candidates agree on the type category of this
1287 * argument position, use that category. Otherwise, fail because we
1288 * cannot determine a category.
1289 *
1290 * If we are able to determine a type category, also notice whether any of
1291 * the candidates takes a preferred datatype within the category.
1292 *
1293 * Having completed this examination, remove candidates that accept the
1294 * wrong category at any unknown position. Also, if at least one
1295 * candidate accepted a preferred type at a position, remove candidates
1296 * that accept non-preferred types. If just one candidate remains, return
1297 * that one. However, if this rule turns out to reject all candidates,
1298 * keep them all instead.
1299 */
1302 {
1304
1306 continue;
1314 {
1318 ¤t_category,
1319 ¤t_is_preferred);
1321 {
1322 /* first candidate */
1325 }
1327 {
1328 /* more candidates in same category */
1330 }
1331 else
1332 {
1333 /* category conflict! */
1335 {
1336 /* STRING always wins if available */
1339 }
1340 else
1341 {
1342 /*
1343 * Remember conflict, but keep going (might find STRING)
1344 */
1346 }
1347 }
1348 }
1350 {
1351 /* Failed to resolve category conflict at this position */
1353 break;
1354 }
1355 }
1356
1358 {
1359 /* Strip non-matching candidates */
1360 ncandidates = 0;
1366 {
1368
1371 {
1373 continue;
1376 ¤t_category,
1377 ¤t_is_preferred);
1379 {
1381 break;
1382 }
1384 {
1386 break;
1387 }
1388 }
1390 {
1391 /* keep this candidate */
1393 ncandidates++;
1394 }
1395 else
1396 {
1397 /* forget this candidate */
1400 else
1402 }
1403 }
1404
1405 /* if we found any matches, restrict our attention to those */
1407 {
1409 /* terminate rebuilt list */
1411 }
1412
1415 }
1416
1417 /*
1418 * Last gasp: if there are both known- and unknown-type inputs, and all
1419 * the known types are the same, assume the unknown inputs are also that
1420 * type, and see if that gives us a unique match. If so, use that match.
1421 *
1422 * NOTE: for a binary operator with one unknown and one non-unknown input,
1423 * we already tried this heuristic in binary_oper_exact(). However, that
1424 * code only finds exact matches, whereas here we will handle matches that
1425 * involve coercion, polymorphic type resolution, etc.
1426 */
1428 {
1430
1432 {
1434 continue;
1438 {
1439 /* oops, not all match */
1441 break;
1442 }
1443 }
1444
1446 {
1447 /* okay, just one known type, apply the heuristic */
1450 ncandidates = 0;
1455 {
1458 COERCION_IMPLICIT))
1459 {
1461 break; /* not unique, give up */
1463 }
1464 }
1466 {
1467 /* successfully identified a unique match */
1470 }
1471 }
1472 }
1473
1475} /* func_select_candidate() */
int int int errmsg_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...) pg_attribute_printf(1
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition lsyscache.c:2943
References can_coerce_type(), COERCION_IMPLICIT, ereport, errcode(), errmsg_plural(), ERROR, fb(), FUNC_MAX_ARGS, get_type_category_preferred(), getBaseType(), i, IsPreferredType(), and TypeCategory().
Referenced by func_get_detail(), and oper_select_candidate().
◆ func_signature_string()
| const char * func_signature_string | ( | List * | funcname, |
| int | nargs, | ||
| List * | argnames, | ||
| const Oid * | argtypes | ||
| ) |
Definition at line 2156 of file parse_func.c.
2158{
2160 nargs, argnames, argtypes);
2161}
const char * funcname_signature_string(const char *funcname, int nargs, List *argnames, const Oid *argtypes)
Definition parse_func.c:2119
References funcname, funcname_signature_string(), and NameListToString().
Referenced by findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeSubscriptingFunction(), findTypeTypmodinFunction(), findTypeTypmodoutFunction(), get_ts_parser_func(), get_ts_template_func(), interpret_func_support(), lookup_agg_function(), LookupFuncName(), LookupFuncWithArgs(), and ParseFuncOrColumn().
◆ funcname_signature_string()
| const char * funcname_signature_string | ( | const char * | funcname, |
| int | nargs, | ||
| List * | argnames, | ||
| const Oid * | argtypes | ||
| ) |
Definition at line 2119 of file parse_func.c.
2121{
2126
2128
2130
2133
2135 {
2139 {
2142 }
2144 }
2145
2147
2149}
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition stringinfo.c:145
void appendStringInfoString(StringInfo str, const char *s)
Definition stringinfo.c:230
Definition stringinfo.h:47
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), fb(), format_type_be(), funcname, i, initStringInfo(), lfirst, list_head(), list_length(), and lnext().
Referenced by func_signature_string(), and IsThereFunctionInNamespace().
◆ FuncNameAsType()
Definition at line 2007 of file parse_func.c.
2008{
2011
2012 /*
2013 * temp_ok=false protects the <refsect1 id="sql-createfunction-security">
2014 * contract for writing SECURITY DEFINER functions safely.
2015 */
2020
2024 else
2026
2029}
Type LookupTypeNameExtended(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool temp_ok, bool missing_ok)
Definition parse_type.c:73
References fb(), Form_pg_type, funcname, GETSTRUCT(), InvalidOid, LookupTypeNameExtended(), makeTypeNameFromNameList(), OidIsValid, ReleaseSysCache(), result, typeTypeId(), and typeTypeRelid().
Referenced by func_get_detail().
◆ LookupFuncName()
Definition at line 2272 of file parse_func.c.
2273{
2276
2278 funcname, nargs, argtypes,
2279 false, missing_ok,
2280 &lookupError);
2281
2284
2286 {
2288 /* Let the caller deal with it when missing_ok is true */
2289 if (missing_ok)
2291
2292 if (nargs < 0)
2297 else
2302 NIL, argtypes))));
2303 break;
2304
2306 /* Raise an error regardless of missing_ok */
2312 break;
2313 }
2314
2316}
static Oid LookupFuncNameInternal(ObjectType objtype, List *funcname, int nargs, const Oid *argtypes, bool include_out_arguments, bool missing_ok, FuncLookupError *lookupError)
Definition parse_func.c:2175
const char * func_signature_string(List *funcname, int nargs, List *argnames, const Oid *argtypes)
Definition parse_func.c:2156
References ereport, errcode(), errhint(), errmsg, ERROR, fb(), func_signature_string(), FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, funcname, InvalidOid, LookupFuncNameInternal(), NameListToString(), NIL, OBJECT_FUNCTION, and OidIsValid.
Referenced by call_pltcl_start_proc(), CreateConversionCommand(), CreateEventTrigger(), CreateProceduralLanguage(), CreateTriggerFiringOn(), DefineOperator(), findRangeCanonicalFunction(), findRangeSubtypeDiffFunction(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeSubscriptingFunction(), findTypeTypmodinFunction(), findTypeTypmodoutFunction(), get_ts_parser_func(), get_ts_template_func(), interpret_func_support(), lookup_am_handler_func(), lookup_fdw_connection_func(), lookup_fdw_handler_func(), lookup_fdw_validator_func(), transformRangeTableSample(), ValidateJoinEstimator(), and ValidateRestrictionEstimator().
◆ LookupFuncNameInternal()
|
static |
Definition at line 2175 of file parse_func.c.
2179{
2183
2184 /* NULL argtypes allowed for nullary functions only */
2186
2187 /* Always set *lookupError, to forestall uninitialized-variable warnings */
2189
2190 /* Get list of candidate objects */
2192 include_out_arguments, missing_ok,
2193 &fgc_flags);
2194
2195 /* Scan list for a match to the arg types (if specified) and the objtype */
2197 {
2198 /* Check arg type match, if specified */
2199 if (nargs >= 0)
2200 {
2201 /* if nargs==0, argtypes can be null; don't pass that to memcmp */
2202 if (nargs > 0 &&
2204 continue;
2205 }
2206
2207 /* Check for duplicates reported by FuncnameGetCandidates */
2209 {
2212 }
2213
2214 /* Check objtype match, if specified */
2215 switch (objtype)
2216 {
2219 /* Ignore procedures */
2221 continue;
2222 break;
2224 /* Ignore non-procedures */
2226 continue;
2227 break;
2229 /* no restriction */
2230 break;
2231 default:
2233 }
2234
2235 /* Check for multiple matches */
2237 {
2240 }
2241
2242 /* OK, we have a candidate */
2244 }
2245
2247}
References Assert, fb(), FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, funcname, FuncnameGetCandidates(), get_func_prokind(), InvalidOid, NIL, OBJECT_AGGREGATE, OBJECT_FUNCTION, OBJECT_PROCEDURE, OBJECT_ROUTINE, OidIsValid, and result.
Referenced by LookupFuncName(), and LookupFuncWithArgs().
◆ LookupFuncWithArgs()
| Oid LookupFuncWithArgs | ( | ObjectType | objtype, |
| ObjectWithArgs * | func, | ||
| bool | missing_ok | ||
| ) |
Definition at line 2334 of file parse_func.c.
2335{
2338 int nargs;
2341 Oid oid;
2343
2345 objtype == OBJECT_FUNCTION ||
2346 objtype == OBJECT_PROCEDURE ||
2347 objtype == OBJECT_ROUTINE);
2348
2351 {
2356 "procedures cannot have more than %d arguments",
2357 FUNC_MAX_ARGS,
2358 FUNC_MAX_ARGS)));
2359 else
2363 "functions cannot have more than %d arguments",
2364 FUNC_MAX_ARGS,
2365 FUNC_MAX_ARGS)));
2366 }
2367
2368 /*
2369 * First, perform a lookup considering only input arguments (traditional
2370 * Postgres rules).
2371 */
2372 i = 0;
2374 {
2376
2380 i++;
2381 }
2382
2383 /*
2384 * Set nargs for LookupFuncNameInternal. It expects -1 to mean no args
2385 * were specified.
2386 */
2388
2389 /*
2390 * In args_unspecified mode, also tell LookupFuncNameInternal to consider
2391 * the object type, since there seems no reason not to. However, if we
2392 * have an argument list, disable the objtype check, because we'd rather
2393 * complain about "object is of wrong type" than "object doesn't exist".
2394 * (Note that with args, FuncnameGetCandidates will have ensured there's
2395 * only one argtype match, so we're not risking an ambiguity failure via
2396 * this choice.)
2397 */
2399 func->objname, nargs, argoids,
2400 false, missing_ok,
2401 &lookupError);
2402
2403 /*
2404 * If PROCEDURE or ROUTINE was specified, and we have an argument list
2405 * that contains no parameter mode markers, and we didn't already discover
2406 * that there's ambiguity, perform a lookup considering all arguments.
2407 * (Note: for a zero-argument procedure, or in args_unspecified mode, the
2408 * normal lookup is sufficient; so it's OK to require non-NIL objfuncargs
2409 * to perform this lookup.)
2410 */
2414 {
2416
2417 /*
2418 * Check for non-default parameter mode markers. If there are any,
2419 * then the command does not conform to SQL-spec syntax, so we may
2420 * assume that the traditional Postgres lookup method of considering
2421 * only input parameters is sufficient. (Note that because the spec
2422 * doesn't have OUT arguments for functions, we also don't need this
2423 * hack in FUNCTION or AGGREGATE mode.)
2424 */
2426 {
2428
2430 {
2432 break;
2433 }
2434 }
2435
2437 {
2439
2440 /* Without mode marks, objargs surely includes all params */
2442
2443 /* For objtype == OBJECT_PROCEDURE, we can ignore non-procedures */
2446 true, missing_ok,
2447 &lookupError);
2448
2449 /* Combine results, handling ambiguity */
2451 {
2453 {
2454 /* oops, we got hits both ways, on different objects */
2455 oid = InvalidOid;
2457 }
2458 else
2459 oid = poid;
2460 }
2462 oid = InvalidOid;
2463 }
2464 }
2465
2467 {
2468 /*
2469 * Even if we found the function, perform validation that the objtype
2470 * matches the prokind of the found function. For historical reasons
2471 * we allow the objtype of FUNCTION to include aggregates and window
2472 * functions; but we draw the line if the object is a procedure. That
2473 * is a new enough feature that this historical rule does not apply.
2474 *
2475 * (This check is partially redundant with the objtype check in
2476 * LookupFuncNameInternal; but not entirely, since we often don't tell
2477 * LookupFuncNameInternal to apply that check at all.)
2478 */
2479 switch (objtype)
2480 {
2482 /* Only complain if it's a procedure. */
2489 break;
2490
2492 /* Reject if found object is not a procedure. */
2499 break;
2500
2502 /* Reject if found object is not an aggregate. */
2509 break;
2510
2511 default:
2512 /* OBJECT_ROUTINE accepts anything. */
2513 break;
2514 }
2515
2516 return oid; /* All good */
2517 }
2518 else
2519 {
2520 /* Deal with cases where the lookup failed */
2522 {
2524 /* Suppress no-such-func errors when missing_ok is true */
2525 if (missing_ok)
2526 break;
2527
2528 switch (objtype)
2529 {
2536 else
2542 break;
2543
2555 else
2561 break;
2562
2563 default:
2564 /* FUNCTION and ROUTINE */
2570 else
2576 break;
2577 }
2578 break;
2579
2581 switch (objtype)
2582 {
2588 func->args_unspecified ?
2590 break;
2596 func->args_unspecified ?
2598 break;
2604 func->args_unspecified ?
2606 break;
2612 func->args_unspecified ?
2614 break;
2615
2616 default:
2618 break;
2619 }
2620 break;
2621 }
2622
2624 }
2625}
Oid LookupTypeNameOid(ParseState *pstate, const TypeName *typeName, bool missing_ok)
Definition parse_type.c:232
Definition parsenodes.h:3696
Definition parsenodes.h:286
References ObjectWithArgs::args_unspecified, Assert, ereport, errcode(), errhint(), errmsg, errmsg_plural(), ERROR, fb(), FUNC_MAX_ARGS, FUNC_PARAM_DEFAULT, func_signature_string(), FUNCLOOKUP_AMBIGUOUS, FUNCLOOKUP_NOSUCHFUNC, get_func_prokind(), i, InvalidOid, lfirst_node, list_length(), LookupFuncNameInternal(), LookupTypeNameOid(), FunctionParameter::mode, NameListToString(), NIL, ObjectWithArgs::objargs, OBJECT_AGGREGATE, OBJECT_FUNCTION, OBJECT_PROCEDURE, OBJECT_ROUTINE, ObjectWithArgs::objfuncargs, ObjectWithArgs::objname, and OidIsValid.
Referenced by AlterFunction(), AlterOpFamilyAdd(), CreateCast(), CreateTransform(), DefineOpClass(), and get_object_address().
◆ make_fn_arguments()
| void make_fn_arguments | ( | ParseState * | pstate, |
| List * | fargs, | ||
| Oid * | actual_arg_types, | ||
| Oid * | declared_arg_types | ||
| ) |
Definition at line 1951 of file parse_func.c.
1955{
1958
1960 {
1961 /* types don't match? then force coercion using a function call... */
1963 {
1965
1966 /*
1967 * If arg is a NamedArgExpr, coerce its input expr instead --- we
1968 * want the NamedArgExpr to stay at the top level of the list.
1969 */
1971 {
1973
1974 node = coerce_type(pstate,
1978 COERCION_IMPLICIT,
1979 COERCE_IMPLICIT_CAST,
1980 -1);
1982 }
1983 else
1984 {
1985 node = coerce_type(pstate,
1986 node,
1989 COERCION_IMPLICIT,
1990 COERCE_IMPLICIT_CAST,
1991 -1);
1993 }
1994 }
1995 i++;
1996 }
1997}
Node * coerce_type(ParseState *pstate, Node *node, Oid inputTypeId, Oid targetTypeId, int32 targetTypeMod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition parse_coerce.c:158
Definition primnodes.h:190
References COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, fb(), i, IsA, and lfirst.
Referenced by build_edge_vertex_link_quals(), make_op(), make_scalar_array_op(), ParseFuncOrColumn(), recheck_cast_function_args(), and transformForPortionOfClause().
◆ ParseComplexProjection()
|
static |
Definition at line 2038 of file parse_func.c.
2040{
2041 TupleDesc tupdesc;
2043
2044 /*
2045 * Special case for whole-row Vars so that we can resolve (foo.*).bar even
2046 * when foo is a reference to a subselect, join, or RECORD function. A
2047 * bonus is that we avoid generating an unnecessary FieldSelect; our
2048 * result can omit the whole-row Var and just be a Var for the selected
2049 * field.
2050 *
2051 * This case could be handled by expandRecordVariable, but it's more
2052 * efficient to do it this way when possible.
2053 */
2056 {
2058
2062 /* Return a Var if funcname matches a column, else NULL */
2065 funcname, location);
2066 }
2067
2068 /*
2069 * Else do it the hard way with get_expr_result_tupdesc().
2070 *
2071 * If it's a Var of type RECORD, we have to work even harder: we have to
2072 * find what the Var refers to, and pass that to get_expr_result_tupdesc.
2073 * That task is handled by expandRecordVariable().
2074 */
2078 else
2080 if (!tupdesc)
2082
2084 {
2086
2088 !att->attisdropped)
2089 {
2090 /* Success, so generate a FieldSelect expression */
2092
2095 fselect->resulttype = att->atttypid;
2096 fselect->resulttypmod = att->atttypmod;
2097 /* save attribute's collation for parse_collate.c */
2098 fselect->resultcollid = att->attcollation;
2100 }
2101 }
2102
2104}
TupleDesc get_expr_result_tupdesc(Node *expr, bool noError)
Definition funcapi.c:553
ParseNamespaceItem * GetNSItemByRangeTablePosn(ParseState *pstate, int varno, int sublevels_up)
Definition parse_relation.c:514
Node * scanNSItemForColumn(ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, const char *colname, int location)
Definition parse_relation.c:684
TupleDesc expandRecordVariable(ParseState *pstate, Var *var, int levelsup)
Definition parse_target.c:1527
Definition primnodes.h:1161
Definition parse_node.h:313
Definition tupdesc.h:149
Definition primnodes.h:263
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:178
References expandRecordVariable(), fb(), funcname, get_expr_result_tupdesc(), GetNSItemByRangeTablePosn(), i, InvalidAttrNumber, IsA, makeNode, NameStr, TupleDescData::natts, scanNSItemForColumn(), and TupleDescAttr().
Referenced by ParseFuncOrColumn().
◆ ParseFuncOrColumn()
| Node * ParseFuncOrColumn | ( | ParseState * | pstate, |
| List * | funcname, | ||
| List * | fargs, | ||
| Node * | last_srf, | ||
| FuncCall * | fn, | ||
| bool | proc_call, | ||
| int | location | ||
| ) |
Definition at line 92 of file parse_func.c.
94{
106 Oid rettype;
107 Oid funcid;
108 ListCell *l;
110 int nargs;
114 List *argnames;
116 Node *retval;
117 bool retset;
118 int nvargs;
124
125 /*
126 * If there's an aggregate filter, transform it using transformWhereClause
127 */
130 EXPR_KIND_FILTER,
131 "FILTER");
132
133 /*
134 * Most of the rest of the parser just assumes that functions do not have
135 * more than FUNC_MAX_ARGS parameters. We have to test here to protect
136 * against array overruns, etc. Of course, this may not be a function,
137 * but the test doesn't hurt.
138 */
143 "cannot pass more than %d arguments to a function",
144 FUNC_MAX_ARGS,
145 FUNC_MAX_ARGS),
146 parser_errposition(pstate, location)));
147
148 /*
149 * Extract arg type info in preparation for function lookup.
150 *
151 * If any arguments are Param markers of type VOID, we discard them from
152 * the parameter list. This is a hack to allow the JDBC driver to not have
153 * to distinguish "input" and "output" parameter symbols while parsing
154 * function-call constructs. Don't do this if dealing with column syntax,
155 * nor if we had WITHIN GROUP (because in that case it's critical to keep
156 * the argument count unchanged).
157 */
158 nargs = 0;
160 {
163
165 !is_column && !agg_within_group)
166 {
168 continue;
169 }
170
171 actual_arg_types[nargs++] = argtype;
172 }
173
174 /*
175 * Check for named arguments; if there are any, build a list of names.
176 *
177 * We allow mixed notation (some named and some not), but only with all
178 * the named parameters after all the unnamed ones. So the name list
179 * corresponds to the last N actual parameters and we don't need any extra
180 * bookkeeping to match things up.
181 */
182 argnames = NIL;
184 {
186
188 {
191
192 /* Reject duplicate arg names */
194 {
199 na->name),
201 }
203 }
204 else
205 {
211 }
212 }
213
215 {
218 }
219
220 /*
221 * Decide whether it's legitimate to consider the construct to be a column
222 * projection. For that, there has to be a single argument of complex
223 * type, the function name must not be qualified, and there cannot be any
224 * syntactic decoration that'd require it to be a function (such as
225 * aggregate or variadic decoration, or named arguments).
226 */
229 !agg_star && !agg_distinct && over == NULL &&
230 !func_variadic && argnames == NIL &&
234
235 /*
236 * If it's column syntax, check for column projection case first.
237 */
239 {
240 retval = ParseComplexProjection(pstate,
242 first_arg,
243 location);
244 if (retval)
245 return retval;
246
247 /*
248 * If ParseComplexProjection doesn't recognize it as a projection,
249 * just press on.
250 */
251 }
252
253 /*
254 * func_get_detail looks up the function in the catalogs, does
255 * disambiguation for polymorphic functions, handles inheritance, and
256 * returns the funcid and type and set or singleton status of the
257 * function's return value. It also returns the true argument types to
258 * the function.
259 *
260 * Note: for a named-notation or variadic function call, the reported
261 * "true" types aren't really what is in pg_proc: the types are reordered
262 * to match the given argument order of named arguments, and a variadic
263 * argument is replaced by a suitable number of copies of its element
264 * type. We'll fix up the variadic case below. We may also have to deal
265 * with default arguments.
266 */
267
269
271 actual_arg_types,
273 &fgc_flags,
274 &funcid, &rettype, &retset,
275 &nvargs, &vatype,
277
279
280 /*
281 * Check for various wrong-kind-of-routine cases.
282 */
283
284 /* If this is a CALL, reject things that aren't procedures */
294 argnames,
295 actual_arg_types)),
297 parser_errposition(pstate, location)));
298 /* Conversely, if not a CALL, reject procedures */
304 argnames,
305 actual_arg_types)),
307 parser_errposition(pstate, location)));
308
312 {
313 /*
314 * In these cases, complain if there was anything indicating it must
315 * be an aggregate or window function.
316 */
317 if (agg_star)
323 parser_errposition(pstate, location)));
324 if (agg_distinct)
329 parser_errposition(pstate, location)));
330 if (agg_within_group)
335 parser_errposition(pstate, location)));
341 parser_errposition(pstate, location)));
342 if (agg_filter)
347 parser_errposition(pstate, location)));
348 if (over)
353 parser_errposition(pstate, location)));
354 }
355
356 /*
357 * So far so good, so do some fdresult-type-specific processing.
358 */
360 {
361 /* Nothing special to do for these cases. */
362 }
364 {
365 /*
366 * It's an aggregate; fetch needed info from the pg_aggregate entry.
367 */
371
379
380 /* Now check various disallowed cases. */
382 {
385
386 if (!agg_within_group)
391 parser_errposition(pstate, location)));
392 if (over)
397 parser_errposition(pstate, location)));
398 /* gram.y rejects DISTINCT + WITHIN GROUP */
399 Assert(!agg_distinct);
400 /* gram.y rejects VARIADIC + WITHIN GROUP */
401 Assert(!func_variadic);
402
403 /*
404 * Since func_get_detail was working with an undifferentiated list
405 * of arguments, it might have selected an aggregate that doesn't
406 * really match because it requires a different division of direct
407 * and aggregated arguments. Check that the number of direct
408 * arguments is actually OK; if not, throw an "undefined function"
409 * error, similarly to the case where a misplaced ORDER BY is used
410 * in a regular aggregate call.
411 */
415
417 {
418 /* Test is simple if aggregate isn't variadic */
424 argnames,
425 actual_arg_types)),
426 errhint_plural("There is an ordered-set aggregate %s, but it requires %d direct argument, not %d.",
427 "There is an ordered-set aggregate %s, but it requires %d direct arguments, not %d.",
428 catDirectArgs,
431 parser_errposition(pstate, location)));
432 }
433 else
434 {
435 /*
436 * If it's variadic, we have two cases depending on whether
437 * the agg was "... ORDER BY VARIADIC" or "..., VARIADIC ORDER
438 * BY VARIADIC". It's the latter if catDirectArgs equals
439 * pronargs; to save a catalog lookup, we reverse-engineer
440 * pronargs from the info we got from func_get_detail.
441 */
443
444 pronargs = nargs;
445 if (nvargs > 1)
446 pronargs -= nvargs - 1;
448 {
449 /* VARIADIC isn't part of direct args, so still easy */
455 argnames,
456 actual_arg_types)),
457 errhint_plural("There is an ordered-set aggregate %s, but it requires %d direct argument, not %d.",
458 "There is an ordered-set aggregate %s, but it requires %d direct arguments, not %d.",
459 catDirectArgs,
462 parser_errposition(pstate, location)));
463 }
464 else
465 {
466 /*
467 * Both direct and aggregated args were declared variadic.
468 * For a standard ordered-set aggregate, it's okay as long
469 * as there aren't too few direct args. For a
470 * hypothetical-set aggregate, we assume that the
471 * hypothetical arguments are those that matched the
472 * variadic parameter; there must be just as many of them
473 * as there are aggregated arguments.
474 */
476 {
482 argnames,
483 actual_arg_types)),
484 errhint("To use the hypothetical-set aggregate %s, the number of hypothetical direct arguments (here %d) must match the number of ordering columns (here %d).",
487 parser_errposition(pstate, location)));
488 }
489 else
490 {
496 argnames,
497 actual_arg_types)),
498 errhint_plural("There is an ordered-set aggregate %s, but it requires at least %d direct argument.",
499 "There is an ordered-set aggregate %s, but it requires at least %d direct arguments.",
500 catDirectArgs,
502 catDirectArgs),
503 parser_errposition(pstate, location)));
504 }
505 }
506 }
507
508 /* Check type matching of hypothetical arguments */
512 }
513 else
514 {
515 /* Normal aggregate, so it can't have WITHIN GROUP */
516 if (agg_within_group)
521 parser_errposition(pstate, location)));
522
523 /* It also can't treat nulls as a window function */
528 parser_errposition(pstate, location)));
529 }
530 }
532 {
533 /*
534 * True window functions must be called with a window definition.
535 */
536 if (!over)
541 parser_errposition(pstate, location)));
542 /* And, per spec, WITHIN GROUP isn't allowed */
543 if (agg_within_group)
548 parser_errposition(pstate, location)));
549 }
551 {
552 /*
553 * We interpreted it as a type coercion. coerce_type can handle these
554 * cases, so why duplicate code...
555 */
557 actual_arg_types[0], rettype, -1,
559 }
561 {
562 /*
563 * We found multiple possible functional matches. If we are dealing
564 * with attribute notation, return failure, letting the caller report
565 * "no such column" (we already determined there wasn't one). If
566 * dealing with function notation, report "ambiguous function",
567 * regardless of whether there's also a column by this name.
568 */
571
577 actual_arg_types)),
580 parser_errposition(pstate, location)));
581 else
586 actual_arg_types)),
589 parser_errposition(pstate, location)));
590 }
591 else
592 {
593 /*
594 * Not found as a function. If we are dealing with attribute
595 * notation, return failure, letting the caller report "no such
596 * column" (we already determined there wasn't one).
597 */
600
601 /*
602 * Check for column projection interpretation, since we didn't before.
603 */
605 {
606 retval = ParseComplexProjection(pstate,
608 first_arg,
609 location);
610 if (retval)
611 return retval;
612 }
613
614 /*
615 * No function, and no column either. Since we're dealing with
616 * function notation, report "function/procedure does not exist".
617 * Depending on what was returned in fgc_flags, we can add some color
618 * to that with detail or hint messages.
619 */
621 {
622 /* It's agg(x, ORDER BY y,z) ... perhaps misplaced ORDER BY */
627 actual_arg_types)),
630 "after all regular arguments of the aggregate."),
631 parser_errposition(pstate, location)));
632 }
638 actual_arg_types)),
640 proc_call),
641 parser_errposition(pstate, location)));
642 else
647 actual_arg_types)),
649 proc_call),
650 parser_errposition(pstate, location)));
651 }
652
653 /*
654 * If there are default arguments, we have to include their types in
655 * actual_arg_types for the purpose of checking generic type consistency.
656 * However, we do NOT put them into the generated parse node, because
657 * their actual values might change before the query gets run. The
658 * planner has to insert the up-to-date values at plan time.
659 */
660 nargsplusdefs = nargs;
662 {
664
665 /* probably shouldn't happen ... */
670 "cannot pass more than %d arguments to a function",
671 FUNC_MAX_ARGS,
672 FUNC_MAX_ARGS),
673 parser_errposition(pstate, location)));
674
676 }
677
678 /*
679 * enforce consistency with polymorphic argument and return types,
680 * possibly adjusting return type or declared_arg_types (which will be
681 * used as the cast destination by make_fn_arguments)
682 */
684 declared_arg_types,
685 nargsplusdefs,
686 rettype,
687 false);
688
689 /* perform the necessary typecasting of arguments */
691
692 /*
693 * If the function isn't actually variadic, forget any VARIADIC decoration
694 * on the call. (Perhaps we should throw an error instead, but
695 * historically we've allowed people to write that.)
696 */
698 {
699 Assert(nvargs == 0);
700 func_variadic = false;
701 }
702
703 /*
704 * If it's a variadic function call, transform the last nvargs arguments
705 * into an array --- unless it's an "any" variadic.
706 */
708 {
712
716
718 /* assume all the variadic arguments were coerced to the same type */
727 /* array_collid will be set by parse_collate.c */
730
732
733 /* We could not have had VARIADIC marking before ... */
734 Assert(!func_variadic);
735 /* ... but now, it's a VARIADIC call */
736 func_variadic = true;
737 }
738
739 /*
740 * If an "any" variadic is called with explicit VARIADIC marking, insist
741 * that the variadic parameter be of some array type.
742 */
744 {
746
751 parser_errposition(pstate,
753 }
754
755 /* if it returns a set, check that's OK */
756 if (retset)
758
759 /* build the appropriate output structure */
761 {
763
764 funcexpr->funcid = funcid;
765 funcexpr->funcresulttype = rettype;
766 funcexpr->funcretset = retset;
767 funcexpr->funcvariadic = func_variadic;
768 funcexpr->funcformat = funcformat;
769 /* funccollid and inputcollid will be set by parse_collate.c */
771 funcexpr->location = location;
772
773 retval = (Node *) funcexpr;
774 }
776 {
777 /* aggregate function */
779
780 aggref->aggfnoid = funcid;
781 aggref->aggtype = rettype;
782 /* aggcollid and inputcollid will be set by parse_collate.c */
784 /* aggargtypes will be set by transformAggregateCall */
785 /* aggdirectargs and args will be set by transformAggregateCall */
786 /* aggorder and aggdistinct will be set by transformAggregateCall */
787 aggref->aggfilter = agg_filter;
788 aggref->aggstar = agg_star;
789 aggref->aggvariadic = func_variadic;
790 aggref->aggkind = aggkind;
791 aggref->aggpresorted = false;
792 /* agglevelsup will be set by transformAggregateCall */
794 aggref->aggno = -1; /* planner will set aggno and aggtransno */
795 aggref->aggtransno = -1;
796 aggref->location = location;
797
798 /*
799 * Reject attempt to call a parameterless aggregate without (*)
800 * syntax. This is mere pedantry but some folks insisted ...
801 */
807 parser_errposition(pstate, location)));
808
809 if (retset)
813 parser_errposition(pstate, location)));
814
815 /*
816 * We might want to support named arguments later, but disallow it for
817 * now. We'd need to figure out the parsed representation (should the
818 * NamedArgExprs go above or below the TargetEntry nodes?) and then
819 * teach the planner to reorder the list properly. Or maybe we could
820 * make transformAggregateCall do that? However, if you'd also like
821 * to allow default arguments for aggregates, we'd need to do it in
822 * planning to avoid semantic problems.
823 */
828 parser_errposition(pstate, location)));
829
830 /* parse_agg.c does additional aggregate-specific processing */
832
833 retval = (Node *) aggref;
834 }
835 else
836 {
837 /* window function */
839
842
843 wfunc->winfnoid = funcid;
844 wfunc->wintype = rettype;
845 /* wincollid and inputcollid will be set by parse_collate.c */
847 /* winref will be set by transformWindowFuncCall */
848 wfunc->winstar = agg_star;
850 wfunc->aggfilter = agg_filter;
851 wfunc->ignore_nulls = ignore_nulls;
852 wfunc->runCondition = NIL;
853 wfunc->location = location;
854
855 /*
856 * agg_star is allowed for aggregate functions but distinct isn't
857 */
858 if (agg_distinct)
862 parser_errposition(pstate, location)));
863
864 /*
865 * Reject attempt to call a parameterless aggregate without (*)
866 * syntax. This is mere pedantry but some folks insisted ...
867 */
873 parser_errposition(pstate, location)));
874
875 /*
876 * ordered aggs not allowed in windows yet
877 */
882 parser_errposition(pstate, location)));
883
884 /*
885 * FILTER is not yet supported with true window functions
886 */
887 if (!wfunc->winagg && agg_filter)
891 parser_errposition(pstate, location)));
892
893 /*
894 * Window functions can't either take or return sets
895 */
901 parser_errposition(pstate,
903
904 if (retset)
908 parser_errposition(pstate, location)));
909
910 /* parse_agg.c does additional window-func-specific processing */
911 transformWindowFuncCall(pstate, wfunc, over);
912
913 retval = (Node *) wfunc;
914 }
915
916 /* if it returns a set, remember it for error checks at higher levels */
917 if (retset)
918 pstate->p_last_srf = retval;
919
920 return retval;
921}
int int int errhint_plural(const char *fmt_singular, const char *fmt_plural, unsigned long n,...) pg_attribute_printf(1
void transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc, WindowDef *windef)
Definition parse_agg.c:894
void transformAggregateCall(ParseState *pstate, Aggref *agg, List *args, List *aggorder, bool agg_distinct)
Definition parse_agg.c:113
Node * transformWhereClause(ParseState *pstate, Node *clause, ParseExprKind exprKind, const char *constructName)
Definition parse_clause.c:1998
Oid enforce_generic_type_consistency(const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
Definition parse_coerce.c:2132
FuncDetailCode func_get_detail(List *funcname, List *fargs, List *fargnames, int nargs, Oid *argtypes, bool expand_variadic, bool expand_defaults, bool include_out_arguments, int *fgc_flags, Oid *funcid, Oid *rettype, bool *retset, int *nvargs, Oid *vatype, Oid **true_typeids, List **argdefaults)
Definition parse_func.c:1516
static Node * ParseComplexProjection(ParseState *pstate, const char *funcname, Node *first_arg, int location)
Definition parse_func.c:2038
void make_fn_arguments(ParseState *pstate, List *fargs, Oid *actual_arg_types, Oid *declared_arg_types)
Definition parse_func.c:1951
static void unify_hypothetical_args(ParseState *pstate, List *fargs, int numAggregatedArgs, Oid *actual_arg_types, Oid *declared_arg_types)
Definition parse_func.c:1867
void check_srf_call_placement(ParseState *pstate, Node *last_srf, int location)
Definition parse_func.c:2639
static int func_lookup_failure_details(int fgc_flags, List *argnames, bool proc_call)
Definition parse_func.c:930
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition parse_node.c:156
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition parse_node.c:140
END_CATALOG_STRUCT typedef FormData_pg_aggregate * Form_pg_aggregate
Definition pg_aggregate.h:113
Definition primnodes.h:460
Definition primnodes.h:1406
Definition primnodes.h:780
Definition primnodes.h:392
Definition parse_node.h:363
Definition parsenodes.h:593
Definition primnodes.h:595
References Aggref::aggfilter, WindowFunc::aggfilter, Aggref::aggfnoid, AGGSPLIT_SIMPLE, arg, WindowFunc::args, FuncExpr::args, Assert, cancel_parser_errposition_callback(), check_srf_call_placement(), COERCE_EXPLICIT_CALL, coerce_type(), COERCION_EXPLICIT, elog, enforce_generic_type_consistency(), ereport, errcode(), errdetail(), errhint(), errhint_plural(), errmsg, errmsg_plural(), ERROR, EXPR_KIND_FILTER, exprLocation(), exprType(), fb(), fn(), foreach_delete_current, Form_pg_aggregate, format_type_be(), func_get_detail(), func_lookup_failure_details(), FUNC_MAX_ARGS, func_signature_string(), FUNCDETAIL_AGGREGATE, FUNCDETAIL_COERCION, FUNCDETAIL_MULTIPLE, FUNCDETAIL_NORMAL, FUNCDETAIL_PROCEDURE, FUNCDETAIL_WINDOWFUNC, FuncExpr::funcid, funcname, get_array_type(), get_base_element_type(), GETSTRUCT(), HeapTupleIsValid, WindowFunc::ignore_nulls, InvalidOid, IsA, ISCOMPLEX, lappend(), lfirst, linitial, list_copy_tail(), list_length(), list_truncate(), llast, Aggref::location, WindowFunc::location, FuncExpr::location, make_fn_arguments(), makeNode, NameListToString(), NIL, NO_NULLTREATMENT, ObjectIdGetDatum(), OidIsValid, ParseState::p_last_srf, ParseComplexProjection(), parser_errposition(), pronargs, ReleaseSysCache(), SearchSysCache1(), setup_parser_errposition_callback(), strVal, transformAggregateCall(), transformWhereClause(), transformWindowFuncCall(), unify_hypothetical_args(), and WindowFunc::winfnoid.
Referenced by sql_fn_post_column_ref(), transformCallStmt(), transformColumnRef(), transformFuncCall(), and transformIndirection().
◆ unify_hypothetical_args()
|
static |
Definition at line 1867 of file parse_func.c.
1872{
1874 numNonHypotheticalArgs;
1876
1879 /* safety check (should only trigger with a misdeclared agg) */
1882
1883 /* Check each hypothetical arg and corresponding aggregated arg */
1885 {
1891
1892 /* A mismatch means AggregateCreate didn't check properly ... */
1895
1896 /* No need to unify if make_fn_arguments will coerce */
1898 continue;
1899
1900 /*
1901 * Select common type, giving preference to the aggregated argument's
1902 * type (we'd rather coerce the direct argument once than coerce all
1903 * the aggregated values).
1904 */
1907 "WITHIN GROUP",
1908 NULL);
1911 commontype);
1912
1913 /*
1914 * Perform the coercions. We don't need to worry about NamedArgExprs
1915 * here because they aren't supported with aggregates.
1916 */
1921 COERCION_IMPLICIT,
1922 COERCE_IMPLICIT_CAST,
1923 -1);
1929 COERCION_IMPLICIT,
1930 COERCE_IMPLICIT_CAST,
1931 -1);
1933 }
1934}
int32 select_common_typmod(ParseState *pstate, List *exprs, Oid common_type)
Definition parse_coerce.c:1645
Oid select_common_type(ParseState *pstate, List *exprs, const char *context, Node **which_expr)
Definition parse_coerce.c:1343
References COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, elog, ERROR, fb(), lfirst, list_length(), list_make2, list_nth_cell(), select_common_type(), and select_common_typmod().
Referenced by ParseFuncOrColumn().
