granicus.if.org Git - postgresql/blob - src/backend/parser/parse_func.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * parse_func.c
   4  *              handle function calls in parser
   5  *
   6  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.215 2009/06/04 18:33:07 tgl Exp $
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include "catalog/pg_proc.h"
  18 #include "catalog/pg_type.h"
  19 #include "funcapi.h"
  20 #include "nodes/makefuncs.h"
  21 #include "nodes/nodeFuncs.h"
  22 #include "parser/parse_agg.h"
  23 #include "parser/parse_coerce.h"
  24 #include "parser/parse_func.h"
  25 #include "parser/parse_relation.h"
  26 #include "parser/parse_target.h"
  27 #include "parser/parse_type.h"
  28 #include "utils/builtins.h"
  29 #include "utils/lsyscache.h"
  30 #include "utils/syscache.h"
  31
  32
  33 static Oid      FuncNameAsType(List *funcname);
  34 static Node *ParseComplexProjection(ParseState *pstate, char *funcname,
  35                                            Node *first_arg, int location);
  36 static void unknown_attribute(ParseState *pstate, Node *relref, char *attname,
  37                                   int location);
  38
  39
  40 /*
  41  *      Parse a function call
  42  *
  43  *      For historical reasons, Postgres tries to treat the notations tab.col
  44  *      and col(tab) as equivalent: if a single-argument function call has an
  45  *      argument of complex type and the (unqualified) function name matches
  46  *      any attribute of the type, we take it as a column projection.  Conversely
  47  *      a function of a single complex-type argument can be written like a
  48  *      column reference, allowing functions to act like computed columns.
  49  *
  50  *      Hence, both cases come through here.  The is_column parameter tells us
  51  *      which syntactic construct is actually being dealt with, but this is
  52  *      intended to be used only to deliver an appropriate error message,
  53  *      not to affect the semantics.  When is_column is true, we should have
  54  *      a single argument (the putative table), unqualified function name
  55  *      equal to the column name, and no aggregate or variadic decoration.
  56  *
  57  *      The argument expressions (in fargs) must have been transformed already.
  58  */
  59 Node *
  60 ParseFuncOrColumn(ParseState *pstate, List *funcname, List *fargs,
  61                                   bool agg_star, bool agg_distinct, bool func_variadic,
  62                                   WindowDef *over, bool is_column, int location)
  63 {
  64         Oid                     rettype;
  65         Oid                     funcid;
  66         ListCell   *l;
  67         ListCell   *nextl;
  68         Node       *first_arg = NULL;
  69         int                     nargs;
  70         int                     nargsplusdefs;
  71         Oid                     actual_arg_types[FUNC_MAX_ARGS];
  72         Oid                *declared_arg_types;
  73         List       *argdefaults;
  74         Node       *retval;
  75         bool            retset;
  76         int                     nvargs;
  77         FuncDetailCode fdresult;
  78
  79         /*
  80          * Most of the rest of the parser just assumes that functions do not have
  81          * more than FUNC_MAX_ARGS parameters.  We have to test here to protect
  82          * against array overruns, etc.  Of course, this may not be a function,
  83          * but the test doesn't hurt.
  84          */
  85         if (list_length(fargs) > FUNC_MAX_ARGS)
  86                 ereport(ERROR,
  87                                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
  88                                  errmsg_plural("cannot pass more than %d argument to a function",
  89                                                            "cannot pass more than %d arguments to a function",
  90                                                            FUNC_MAX_ARGS,
  91                                                            FUNC_MAX_ARGS),
  92                                  parser_errposition(pstate, location)));
  93
  94         /*
  95          * Extract arg type info in preparation for function lookup.
  96          *
  97          * If any arguments are Param markers of type VOID, we discard them from
  98          * the parameter list.  This is a hack to allow the JDBC driver to not
  99          * have to distinguish "input" and "output" parameter symbols while
 100          * parsing function-call constructs.  We can't use foreach() because we
 101          * may modify the list ...
 102          */
 103         nargs = 0;
 104         for (l = list_head(fargs); l != NULL; l = nextl)
 105         {
 106                 Node       *arg = lfirst(l);
 107                 Oid                     argtype = exprType(arg);
 108
 109                 nextl = lnext(l);
 110
 111                 if (argtype == VOIDOID && IsA(arg, Param) &&!is_column)
 112                 {
 113                         fargs = list_delete_ptr(fargs, arg);
 114                         continue;
 115                 }
 116
 117                 actual_arg_types[nargs++] = argtype;
 118         }
 119
 120         if (fargs)
 121         {
 122                 first_arg = linitial(fargs);
 123                 Assert(first_arg != NULL);
 124         }
 125
 126         /*
 127          * Check for column projection: if function has one argument, and that
 128          * argument is of complex type, and function name is not qualified, then
 129          * the "function call" could be a projection.  We also check that there
 130          * wasn't any aggregate or variadic decoration.
 131          */
 132         if (nargs == 1 && !agg_star && !agg_distinct && over == NULL &&
 133                 !func_variadic && list_length(funcname) == 1)
 134         {
 135                 Oid                     argtype = actual_arg_types[0];
 136
 137                 if (argtype == RECORDOID || ISCOMPLEX(argtype))
 138                 {
 139                         retval = ParseComplexProjection(pstate,
 140                                                                                         strVal(linitial(funcname)),
 141                                                                                         first_arg,
 142                                                                                         location);
 143                         if (retval)
 144                                 return retval;
 145
 146                         /*
 147                          * If ParseComplexProjection doesn't recognize it as a projection,
 148                          * just press on.
 149                          */
 150                 }
 151         }
 152
 153         /*
 154          * Okay, it's not a column projection, so it must really be a function.
 155          * func_get_detail looks up the function in the catalogs, does
 156          * disambiguation for polymorphic functions, handles inheritance, and
 157          * returns the funcid and type and set or singleton status of the
 158          * function's return value.  It also returns the true argument types to
 159          * the function.  In the case of a variadic function call, the reported
 160          * "true" types aren't really what is in pg_proc: the variadic argument is
 161          * replaced by a suitable number of copies of its element type.  We'll fix
 162          * it up below.  We may also have to deal with default arguments.
 163          */
 164         fdresult = func_get_detail(funcname, fargs, nargs, actual_arg_types,
 165                                                            !func_variadic, true,
 166                                                            &funcid, &rettype, &retset, &nvargs,
 167                                                            &declared_arg_types, &argdefaults);
 168         if (fdresult == FUNCDETAIL_COERCION)
 169         {
 170                 /*
 171                  * We interpreted it as a type coercion. coerce_type can handle these
 172                  * cases, so why duplicate code...
 173                  */
 174                 return coerce_type(pstate, linitial(fargs),
 175                                                    actual_arg_types[0], rettype, -1,
 176                                                    COERCION_EXPLICIT, COERCE_EXPLICIT_CALL, location);
 177         }
 178         else if (fdresult == FUNCDETAIL_NORMAL)
 179         {
 180                 /*
 181                  * Normal function found; was there anything indicating it must be an
 182                  * aggregate?
 183                  */
 184                 if (agg_star)
 185                         ereport(ERROR,
 186                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 187                            errmsg("%s(*) specified, but %s is not an aggregate function",
 188                                           NameListToString(funcname),
 189                                           NameListToString(funcname)),
 190                                          parser_errposition(pstate, location)));
 191                 if (agg_distinct)
 192                         ereport(ERROR,
 193                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 194                         errmsg("DISTINCT specified, but %s is not an aggregate function",
 195                                    NameListToString(funcname)),
 196                                          parser_errposition(pstate, location)));
 197                 if (over)
 198                         ereport(ERROR,
 199                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 200                                          errmsg("OVER specified, but %s is not a window function nor an aggregate function",
 201                                                         NameListToString(funcname)),
 202                                          parser_errposition(pstate, location)));
 203         }
 204         else if (!(fdresult == FUNCDETAIL_AGGREGATE ||
 205                            fdresult == FUNCDETAIL_WINDOWFUNC))
 206         {
 207                 /*
 208                  * Oops.  Time to die.
 209                  *
 210                  * If we are dealing with the attribute notation rel.function, give an
 211                  * error message that is appropriate for that case.
 212                  */
 213                 if (is_column)
 214                 {
 215                         Assert(nargs == 1);
 216                         Assert(list_length(funcname) == 1);
 217                         unknown_attribute(pstate, first_arg, strVal(linitial(funcname)),
 218                                                           location);
 219                 }
 220
 221                 /*
 222                  * Else generate a detailed complaint for a function
 223                  */
 224                 if (fdresult == FUNCDETAIL_MULTIPLE)
 225                         ereport(ERROR,
 226                                         (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
 227                                          errmsg("function %s is not unique",
 228                                                         func_signature_string(funcname, nargs,
 229                                                                                                   actual_arg_types)),
 230                                          errhint("Could not choose a best candidate function. "
 231                                                          "You might need to add explicit type casts."),
 232                                          parser_errposition(pstate, location)));
 233                 else
 234                         ereport(ERROR,
 235                                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
 236                                          errmsg("function %s does not exist",
 237                                                         func_signature_string(funcname, nargs,
 238                                                                                                   actual_arg_types)),
 239                         errhint("No function matches the given name and argument types. "
 240                                         "You might need to add explicit type casts."),
 241                                          parser_errposition(pstate, location)));
 242         }
 243
 244         /*
 245          * If there are default arguments, we have to include their types in
 246          * actual_arg_types for the purpose of checking generic type consistency.
 247          * However, we do NOT put them into the generated parse node, because
 248          * their actual values might change before the query gets run.  The
 249          * planner has to insert the up-to-date values at plan time.
 250          */
 251         nargsplusdefs = nargs;
 252         foreach(l, argdefaults)
 253         {
 254                 Node    *expr = (Node *) lfirst(l);
 255
 256                 /* probably shouldn't happen ... */
 257                 if (nargsplusdefs >= FUNC_MAX_ARGS)
 258                         ereport(ERROR,
 259                                         (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
 260                                          errmsg_plural("cannot pass more than %d argument to a function",
 261                                                                    "cannot pass more than %d arguments to a function",
 262                                                                    FUNC_MAX_ARGS,
 263                                                                    FUNC_MAX_ARGS),
 264                                          parser_errposition(pstate, location)));
 265
 266                 actual_arg_types[nargsplusdefs++] = exprType(expr);
 267         }
 268
 269         /*
 270          * enforce consistency with polymorphic argument and return types,
 271          * possibly adjusting return type or declared_arg_types (which will be
 272          * used as the cast destination by make_fn_arguments)
 273          */
 274         rettype = enforce_generic_type_consistency(actual_arg_types,
 275                                                                                            declared_arg_types,
 276                                                                                            nargsplusdefs,
 277                                                                                            rettype,
 278                                                                                            false);
 279
 280         /* perform the necessary typecasting of arguments */
 281         make_fn_arguments(pstate, fargs, actual_arg_types, declared_arg_types);
 282
 283         /*
 284          * If it's a variadic function call, transform the last nvargs arguments
 285          * into an array --- unless it's an "any" variadic.
 286          */
 287         if (nvargs > 0 && declared_arg_types[nargs - 1] != ANYOID)
 288         {
 289                 ArrayExpr *newa = makeNode(ArrayExpr);
 290                 int     non_var_args = nargs - nvargs;
 291                 List    *vargs;
 292
 293                 Assert(non_var_args >= 0);
 294                 vargs = list_copy_tail(fargs, non_var_args);
 295                 fargs = list_truncate(fargs, non_var_args);
 296
 297                 newa->elements = vargs;
 298                 /* assume all the variadic arguments were coerced to the same type */
 299                 newa->element_typeid = exprType((Node *) linitial(vargs));
 300                 newa->array_typeid = get_array_type(newa->element_typeid);
 301                 if (!OidIsValid(newa->array_typeid))
 302                         ereport(ERROR,
 303                                         (errcode(ERRCODE_UNDEFINED_OBJECT),
 304                                          errmsg("could not find array type for data type %s",
 305                                                         format_type_be(newa->element_typeid)),
 306                                          parser_errposition(pstate, exprLocation((Node *) vargs))));
 307                 newa->multidims = false;
 308                 newa->location = exprLocation((Node *) vargs);
 309
 310                 fargs = lappend(fargs, newa);
 311         }
 312
 313         /* build the appropriate output structure */
 314         if (fdresult == FUNCDETAIL_NORMAL)
 315         {
 316                 FuncExpr   *funcexpr = makeNode(FuncExpr);
 317
 318                 funcexpr->funcid = funcid;
 319                 funcexpr->funcresulttype = rettype;
 320                 funcexpr->funcretset = retset;
 321                 funcexpr->funcformat = COERCE_EXPLICIT_CALL;
 322                 funcexpr->args = fargs;
 323                 funcexpr->location = location;
 324
 325                 retval = (Node *) funcexpr;
 326         }
 327         else if (fdresult == FUNCDETAIL_AGGREGATE && !over)
 328         {
 329                 /* aggregate function */
 330                 Aggref     *aggref = makeNode(Aggref);
 331
 332                 aggref->aggfnoid = funcid;
 333                 aggref->aggtype = rettype;
 334                 aggref->args = fargs;
 335                 aggref->aggstar = agg_star;
 336                 aggref->aggdistinct = agg_distinct;
 337                 aggref->location = location;
 338
 339                 /*
 340                  * Reject attempt to call a parameterless aggregate without (*)
 341                  * syntax.      This is mere pedantry but some folks insisted ...
 342                  */
 343                 if (fargs == NIL && !agg_star)
 344                         ereport(ERROR,
 345                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 346                                          errmsg("%s(*) must be used to call a parameterless aggregate function",
 347                                                         NameListToString(funcname)),
 348                                          parser_errposition(pstate, location)));
 349
 350                 if (retset)
 351                         ereport(ERROR,
 352                                         (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
 353                                          errmsg("aggregates cannot return sets"),
 354                                          parser_errposition(pstate, location)));
 355
 356                 /* parse_agg.c does additional aggregate-specific processing */
 357                 transformAggregateCall(pstate, aggref);
 358
 359                 retval = (Node *) aggref;
 360         }
 361         else
 362         {
 363                 /* window function */
 364                 WindowFunc *wfunc = makeNode(WindowFunc);
 365
 366                 /*
 367                  * True window functions must be called with a window definition.
 368                  */
 369                 if (!over)
 370                         ereport(ERROR,
 371                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 372                                          errmsg("window function call requires an OVER clause"),
 373                                          parser_errposition(pstate, location)));
 374
 375                 wfunc->winfnoid = funcid;
 376                 wfunc->wintype = rettype;
 377                 wfunc->args = fargs;
 378                 /* winref will be set by transformWindowFuncCall */
 379                 wfunc->winstar = agg_star;
 380                 wfunc->winagg = (fdresult == FUNCDETAIL_AGGREGATE);
 381                 wfunc->location = location;
 382
 383                 /*
 384                  * agg_star is allowed for aggregate functions but distinct isn't
 385                  */
 386                 if (agg_distinct)
 387                         ereport(ERROR,
 388                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 389                                          errmsg("DISTINCT is not implemented for window functions"),
 390                                          parser_errposition(pstate, location)));
 391
 392                 /*
 393                  * Reject attempt to call a parameterless aggregate without (*)
 394                  * syntax.      This is mere pedantry but some folks insisted ...
 395                  */
 396                 if (wfunc->winagg && fargs == NIL && !agg_star)
 397                         ereport(ERROR,
 398                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
 399                                          errmsg("%s(*) must be used to call a parameterless aggregate function",
 400                                                         NameListToString(funcname)),
 401                                          parser_errposition(pstate, location)));
 402
 403                 if (retset)
 404                         ereport(ERROR,
 405                                         (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
 406                                          errmsg("window functions cannot return sets"),
 407                                          parser_errposition(pstate, location)));
 408
 409                 /* parse_agg.c does additional window-func-specific processing */
 410                 transformWindowFuncCall(pstate, wfunc, over);
 411
 412                 retval = (Node *) wfunc;
 413         }
 414
 415         return retval;
 416 }
 417
 418
 419 /* func_match_argtypes()
 420  *
 421  * Given a list of candidate functions (having the right name and number
 422  * of arguments) and an array of input datatype OIDs, produce a shortlist of
 423  * those candidates that actually accept the input datatypes (either exactly
 424  * or by coercion), and return the number of such candidates.
 425  *
 426  * Note that can_coerce_type will assume that UNKNOWN inputs are coercible to
 427  * anything, so candidates will not be eliminated on that basis.
 428  *
 429  * NB: okay to modify input list structure, as long as we find at least
 430  * one match.  If no match at all, the list must remain unmodified.
 431  */
 432 int
 433 func_match_argtypes(int nargs,
 434                                         Oid *input_typeids,
 435                                         FuncCandidateList raw_candidates,
 436                                         FuncCandidateList *candidates)          /* return value */
 437 {
 438         FuncCandidateList current_candidate;
 439         FuncCandidateList next_candidate;
 440         int                     ncandidates = 0;
 441
 442         *candidates = NULL;
 443
 444         for (current_candidate = raw_candidates;
 445                  current_candidate != NULL;
 446                  current_candidate = next_candidate)
 447         {
 448                 next_candidate = current_candidate->next;
 449                 if (can_coerce_type(nargs, input_typeids, current_candidate->args,
 450                                                         COERCION_IMPLICIT))
 451                 {
 452                         current_candidate->next = *candidates;
 453                         *candidates = current_candidate;
 454                         ncandidates++;
 455                 }
 456         }
 457
 458         return ncandidates;
 459 }       /* func_match_argtypes() */
 460
 461
 462 /* func_select_candidate()
 463  *              Given the input argtype array and more than one candidate
 464  *              for the function, attempt to resolve the conflict.
 465  *
 466  * Returns the selected candidate if the conflict can be resolved,
 467  * otherwise returns NULL.
 468  *
 469  * Note that the caller has already determined that there is no candidate
 470  * exactly matching the input argtypes, and has pruned away any "candidates"
 471  * that aren't actually coercion-compatible with the input types.
 472  *
 473  * This is also used for resolving ambiguous operator references.  Formerly
 474  * parse_oper.c had its own, essentially duplicate code for the purpose.
 475  * The following comments (formerly in parse_oper.c) are kept to record some
 476  * of the history of these heuristics.
 477  *
 478  * OLD COMMENTS:
 479  *
 480  * This routine is new code, replacing binary_oper_select_candidate()
 481  * which dates from v4.2/v1.0.x days. It tries very hard to match up
 482  * operators with types, including allowing type coercions if necessary.
 483  * The important thing is that the code do as much as possible,
 484  * while _never_ doing the wrong thing, where "the wrong thing" would
 485  * be returning an operator when other better choices are available,
 486  * or returning an operator which is a non-intuitive possibility.
 487  * - thomas 1998-05-21
 488  *
 489  * The comments below came from binary_oper_select_candidate(), and
 490  * illustrate the issues and choices which are possible:
 491  * - thomas 1998-05-20
 492  *
 493  * current wisdom holds that the default operator should be one in which
 494  * both operands have the same type (there will only be one such
 495  * operator)
 496  *
 497  * 7.27.93 - I have decided not to do this; it's too hard to justify, and
 498  * it's easy enough to typecast explicitly - avi
 499  * [the rest of this routine was commented out since then - ay]
 500  *
 501  * 6/23/95 - I don't complete agree with avi. In particular, casting
 502  * floats is a pain for users. Whatever the rationale behind not doing
 503  * this is, I need the following special case to work.
 504  *
 505  * In the WHERE clause of a query, if a float is specified without
 506  * quotes, we treat it as float8. I added the float48* operators so
 507  * that we can operate on float4 and float8. But now we have more than
 508  * one matching operator if the right arg is unknown (eg. float
 509  * specified with quotes). This break some stuff in the regression
 510  * test where there are floats in quotes not properly casted. Below is
 511  * the solution. In addition to requiring the operator operates on the
 512  * same type for both operands [as in the code Avi originally
 513  * commented out], we also require that the operators be equivalent in
 514  * some sense. (see equivalentOpersAfterPromotion for details.)
 515  * - ay 6/95
 516  */
 517 FuncCandidateList
 518 func_select_candidate(int nargs,
 519                                           Oid *input_typeids,
 520                                           FuncCandidateList candidates)
 521 {
 522         FuncCandidateList current_candidate;
 523         FuncCandidateList last_candidate;
 524         Oid                *current_typeids;
 525         Oid                     current_type;
 526         int                     i;
 527         int                     ncandidates;
 528         int                     nbestMatch,
 529                                 nmatch;
 530         Oid                     input_base_typeids[FUNC_MAX_ARGS];
 531         TYPCATEGORY     slot_category[FUNC_MAX_ARGS],
 532                                 current_category;
 533         bool            current_is_preferred;
 534         bool            slot_has_preferred_type[FUNC_MAX_ARGS];
 535         bool            resolved_unknowns;
 536
 537         /* protect local fixed-size arrays */
 538         if (nargs > FUNC_MAX_ARGS)
 539                 ereport(ERROR,
 540                                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
 541                                  errmsg_plural("cannot pass more than %d argument to a function",
 542                                                            "cannot pass more than %d arguments to a function",
 543                                                            FUNC_MAX_ARGS,
 544                                                            FUNC_MAX_ARGS)));
 545
 546         /*
 547          * If any input types are domains, reduce them to their base types. This
 548          * ensures that we will consider functions on the base type to be "exact
 549          * matches" in the exact-match heuristic; it also makes it possible to do
 550          * something useful with the type-category heuristics. Note that this
 551          * makes it difficult, but not impossible, to use functions declared to
 552          * take a domain as an input datatype.  Such a function will be selected
 553          * over the base-type function only if it is an exact match at all
 554          * argument positions, and so was already chosen by our caller.
 555          */
 556         for (i = 0; i < nargs; i++)
 557                 input_base_typeids[i] = getBaseType(input_typeids[i]);
 558
 559         /*
 560          * Run through all candidates and keep those with the most matches on
 561          * exact types. Keep all candidates if none match.
 562          */
 563         ncandidates = 0;
 564         nbestMatch = 0;
 565         last_candidate = NULL;
 566         for (current_candidate = candidates;
 567                  current_candidate != NULL;
 568                  current_candidate = current_candidate->next)
 569         {
 570                 current_typeids = current_candidate->args;
 571                 nmatch = 0;
 572                 for (i = 0; i < nargs; i++)
 573                 {
 574                         if (input_base_typeids[i] != UNKNOWNOID &&
 575                                 current_typeids[i] == input_base_typeids[i])
 576                                 nmatch++;
 577                 }
 578
 579                 /* take this one as the best choice so far? */
 580                 if ((nmatch > nbestMatch) || (last_candidate == NULL))
 581                 {
 582                         nbestMatch = nmatch;
 583                         candidates = current_candidate;
 584                         last_candidate = current_candidate;
 585                         ncandidates = 1;
 586                 }
 587                 /* no worse than the last choice, so keep this one too? */
 588                 else if (nmatch == nbestMatch)
 589                 {
 590                         last_candidate->next = current_candidate;
 591                         last_candidate = current_candidate;
 592                         ncandidates++;
 593                 }
 594                 /* otherwise, don't bother keeping this one... */
 595         }
 596
 597         if (last_candidate)                     /* terminate rebuilt list */
 598                 last_candidate->next = NULL;
 599
 600         if (ncandidates == 1)
 601                 return candidates;
 602
 603         /*
 604          * Still too many candidates? Now look for candidates which have either
 605          * exact matches or preferred types at the args that will require
 606          * coercion. (Restriction added in 7.4: preferred type must be of same
 607          * category as input type; give no preference to cross-category
 608          * conversions to preferred types.)  Keep all candidates if none match.
 609          */
 610         for (i = 0; i < nargs; i++) /* avoid multiple lookups */
 611                 slot_category[i] = TypeCategory(input_base_typeids[i]);
 612         ncandidates = 0;
 613         nbestMatch = 0;
 614         last_candidate = NULL;
 615         for (current_candidate = candidates;
 616                  current_candidate != NULL;
 617                  current_candidate = current_candidate->next)
 618         {
 619                 current_typeids = current_candidate->args;
 620                 nmatch = 0;
 621                 for (i = 0; i < nargs; i++)
 622                 {
 623                         if (input_base_typeids[i] != UNKNOWNOID)
 624                         {
 625                                 if (current_typeids[i] == input_base_typeids[i] ||
 626                                         IsPreferredType(slot_category[i], current_typeids[i]))
 627                                         nmatch++;
 628                         }
 629                 }
 630
 631                 if ((nmatch > nbestMatch) || (last_candidate == NULL))
 632                 {
 633                         nbestMatch = nmatch;
 634                         candidates = current_candidate;
 635                         last_candidate = current_candidate;
 636                         ncandidates = 1;
 637                 }
 638                 else if (nmatch == nbestMatch)
 639                 {
 640                         last_candidate->next = current_candidate;
 641                         last_candidate = current_candidate;
 642                         ncandidates++;
 643                 }
 644         }
 645
 646         if (last_candidate)                     /* terminate rebuilt list */
 647                 last_candidate->next = NULL;
 648
 649         if (ncandidates == 1)
 650                 return candidates;
 651
 652         /*
 653          * Still too many candidates? Try assigning types for the unknown columns.
 654          *
 655          * NOTE: for a binary operator with one unknown and one non-unknown input,
 656          * we already tried the heuristic of looking for a candidate with the
 657          * known input type on both sides (see binary_oper_exact()). That's
 658          * essentially a special case of the general algorithm we try next.
 659          *
 660          * We do this by examining each unknown argument position to see if we can
 661          * determine a "type category" for it.  If any candidate has an input
 662          * datatype of STRING category, use STRING category (this bias towards
 663          * STRING is appropriate since unknown-type literals look like strings).
 664          * Otherwise, if all the candidates agree on the type category of this
 665          * argument position, use that category.  Otherwise, fail because we
 666          * cannot determine a category.
 667          *
 668          * If we are able to determine a type category, also notice whether any of
 669          * the candidates takes a preferred datatype within the category.
 670          *
 671          * Having completed this examination, remove candidates that accept the
 672          * wrong category at any unknown position.      Also, if at least one
 673          * candidate accepted a preferred type at a position, remove candidates
 674          * that accept non-preferred types.
 675          *
 676          * If we are down to one candidate at the end, we win.
 677          */
 678         resolved_unknowns = false;
 679         for (i = 0; i < nargs; i++)
 680         {
 681                 bool            have_conflict;
 682
 683                 if (input_base_typeids[i] != UNKNOWNOID)
 684                         continue;
 685                 resolved_unknowns = true;               /* assume we can do it */
 686                 slot_category[i] = TYPCATEGORY_INVALID;
 687                 slot_has_preferred_type[i] = false;
 688                 have_conflict = false;
 689                 for (current_candidate = candidates;
 690                          current_candidate != NULL;
 691                          current_candidate = current_candidate->next)
 692                 {
 693                         current_typeids = current_candidate->args;
 694                         current_type = current_typeids[i];
 695                         get_type_category_preferred(current_type,
 696                                                                                 &current_category,
 697                                                                                 &current_is_preferred);
 698                         if (slot_category[i] == TYPCATEGORY_INVALID)
 699                         {
 700                                 /* first candidate */
 701                                 slot_category[i] = current_category;
 702                                 slot_has_preferred_type[i] = current_is_preferred;
 703                         }
 704                         else if (current_category == slot_category[i])
 705                         {
 706                                 /* more candidates in same category */
 707                                 slot_has_preferred_type[i] |= current_is_preferred;
 708                         }
 709                         else
 710                         {
 711                                 /* category conflict! */
 712                                 if (current_category == TYPCATEGORY_STRING)
 713                                 {
 714                                         /* STRING always wins if available */
 715                                         slot_category[i] = current_category;
 716                                         slot_has_preferred_type[i] = current_is_preferred;
 717                                 }
 718                                 else
 719                                 {
 720                                         /*
 721                                          * Remember conflict, but keep going (might find STRING)
 722                                          */
 723                                         have_conflict = true;
 724                                 }
 725                         }
 726                 }
 727                 if (have_conflict && slot_category[i] != TYPCATEGORY_STRING)
 728                 {
 729                         /* Failed to resolve category conflict at this position */
 730                         resolved_unknowns = false;
 731                         break;
 732                 }
 733         }
 734
 735         if (resolved_unknowns)
 736         {
 737                 /* Strip non-matching candidates */
 738                 ncandidates = 0;
 739                 last_candidate = NULL;
 740                 for (current_candidate = candidates;
 741                          current_candidate != NULL;
 742                          current_candidate = current_candidate->next)
 743                 {
 744                         bool            keepit = true;
 745
 746                         current_typeids = current_candidate->args;
 747                         for (i = 0; i < nargs; i++)
 748                         {
 749                                 if (input_base_typeids[i] != UNKNOWNOID)
 750                                         continue;
 751                                 current_type = current_typeids[i];
 752                                 get_type_category_preferred(current_type,
 753                                                                                         &current_category,
 754                                                                                         &current_is_preferred);
 755                                 if (current_category != slot_category[i])
 756                                 {
 757                                         keepit = false;
 758                                         break;
 759                                 }
 760                                 if (slot_has_preferred_type[i] && !current_is_preferred)
 761                                 {
 762                                         keepit = false;
 763                                         break;
 764                                 }
 765                         }
 766                         if (keepit)
 767                         {
 768                                 /* keep this candidate */
 769                                 last_candidate = current_candidate;
 770                                 ncandidates++;
 771                         }
 772                         else
 773                         {
 774                                 /* forget this candidate */
 775                                 if (last_candidate)
 776                                         last_candidate->next = current_candidate->next;
 777                                 else
 778                                         candidates = current_candidate->next;
 779                         }
 780                 }
 781                 if (last_candidate)             /* terminate rebuilt list */
 782                         last_candidate->next = NULL;
 783         }
 784
 785         if (ncandidates == 1)
 786                 return candidates;
 787
 788         return NULL;                            /* failed to select a best candidate */
 789 }       /* func_select_candidate() */
 790
 791
 792 /* func_get_detail()
 793  *
 794  * Find the named function in the system catalogs.
 795  *
 796  * Attempt to find the named function in the system catalogs with
 797  * arguments exactly as specified, so that the normal case (exact match)
 798  * is as quick as possible.
 799  *
 800  * If an exact match isn't found:
 801  *      1) check for possible interpretation as a type coercion request
 802  *      2) apply the ambiguous-function resolution rules
 803  *
 804  * Note: we rely primarily on nargs/argtypes as the argument description.
 805  * The actual expression node list is passed in fargs so that we can check
 806  * for type coercion of a constant.  Some callers pass fargs == NIL
 807  * indicating they don't want that check made.
 808  */
 809 FuncDetailCode
 810 func_get_detail(List *funcname,
 811                                 List *fargs,
 812                                 int nargs,
 813                                 Oid *argtypes,
 814                                 bool expand_variadic,
 815                                 bool expand_defaults,
 816                                 Oid *funcid,    /* return value */
 817                                 Oid *rettype,   /* return value */
 818                                 bool *retset,   /* return value */
 819                                 int *nvargs,    /* return value */
 820                                 Oid **true_typeids,             /* return value */
 821                                 List **argdefaults)             /* optional return value */
 822 {
 823         FuncCandidateList raw_candidates;
 824         FuncCandidateList best_candidate;
 825
 826         /* initialize output arguments to silence compiler warnings */
 827         *funcid = InvalidOid;
 828         *rettype = InvalidOid;
 829         *retset = false;
 830         *nvargs = 0;
 831         *true_typeids = NULL;
 832         if (argdefaults)
 833           *argdefaults = NIL;
 834
 835         /* Get list of possible candidates from namespace search */
 836         raw_candidates = FuncnameGetCandidates(funcname, nargs,
 837                                                                                    expand_variadic, expand_defaults);
 838
 839         /*
 840          * Quickly check if there is an exact match to the input datatypes (there
 841          * can be only one)
 842          */
 843         for (best_candidate = raw_candidates;
 844                  best_candidate != NULL;
 845                  best_candidate = best_candidate->next)
 846         {
 847                 if (memcmp(argtypes, best_candidate->args, nargs * sizeof(Oid)) == 0)
 848                         break;
 849         }
 850
 851         if (best_candidate == NULL)
 852         {
 853                 /*
 854                  * If we didn't find an exact match, next consider the possibility
 855                  * that this is really a type-coercion request: a single-argument
 856                  * function call where the function name is a type name.  If so, and
 857                  * if the coercion path is RELABELTYPE or COERCEVIAIO, then go ahead
 858                  * and treat the "function call" as a coercion.
 859                  *
 860                  * This interpretation needs to be given higher priority than
 861                  * interpretations involving a type coercion followed by a function
 862                  * call, otherwise we can produce surprising results. For example, we
 863                  * want "text(varchar)" to be interpreted as a simple coercion, not as
 864                  * "text(name(varchar))" which the code below this point is entirely
 865                  * capable of selecting.
 866                  *
 867                  * We also treat a coercion of a previously-unknown-type literal
 868                  * constant to a specific type this way.
 869                  *
 870                  * The reason we reject COERCION_PATH_FUNC here is that we expect the
 871                  * cast implementation function to be named after the target type.
 872                  * Thus the function will be found by normal lookup if appropriate.
 873                  *
 874                  * The reason we reject COERCION_PATH_ARRAYCOERCE is mainly that you
 875                  * can't write "foo[] (something)" as a function call.  In theory
 876                  * someone might want to invoke it as "_foo (something)" but we have
 877                  * never supported that historically, so we can insist that people
 878                  * write it as a normal cast instead.  Lack of historical support is
 879                  * also the reason for not considering composite-type casts here.
 880                  *
 881                  * NB: it's important that this code does not exceed what coerce_type
 882                  * can do, because the caller will try to apply coerce_type if we
 883                  * return FUNCDETAIL_COERCION.  If we return that result for something
 884                  * coerce_type can't handle, we'll cause infinite recursion between
 885                  * this module and coerce_type!
 886                  */
 887                 if (nargs == 1 && fargs != NIL)
 888                 {
 889                         Oid                     targetType = FuncNameAsType(funcname);
 890
 891                         if (OidIsValid(targetType))
 892                         {
 893                                 Oid                     sourceType = argtypes[0];
 894                                 Node       *arg1 = linitial(fargs);
 895                                 bool            iscoercion;
 896
 897                                 if (sourceType == UNKNOWNOID && IsA(arg1, Const))
 898                                 {
 899                                         /* always treat typename('literal') as coercion */
 900                                         iscoercion = true;
 901                                 }
 902                                 else
 903                                 {
 904                                         CoercionPathType cpathtype;
 905                                         Oid                     cfuncid;
 906
 907                                         cpathtype = find_coercion_pathway(targetType, sourceType,
 908                                                                                                           COERCION_EXPLICIT,
 909                                                                                                           &cfuncid);
 910                                         iscoercion = (cpathtype == COERCION_PATH_RELABELTYPE ||
 911                                                                   cpathtype == COERCION_PATH_COERCEVIAIO);
 912                                 }
 913
 914                                 if (iscoercion)
 915                                 {
 916                                         /* Treat it as a type coercion */
 917                                         *funcid = InvalidOid;
 918                                         *rettype = targetType;
 919                                         *retset = false;
 920                                         *nvargs = 0;
 921                                         *true_typeids = argtypes;
 922                                         return FUNCDETAIL_COERCION;
 923                                 }
 924                         }
 925                 }
 926
 927                 /*
 928                  * didn't find an exact match, so now try to match up candidates...
 929                  */
 930                 if (raw_candidates != NULL)
 931                 {
 932                         FuncCandidateList current_candidates;
 933                         int                     ncandidates;
 934
 935                         ncandidates = func_match_argtypes(nargs,
 936                                                                                           argtypes,
 937                                                                                           raw_candidates,
 938                                                                                           &current_candidates);
 939
 940                         /* one match only? then run with it... */
 941                         if (ncandidates == 1)
 942                                 best_candidate = current_candidates;
 943
 944                         /*
 945                          * multiple candidates? then better decide or throw an error...
 946                          */
 947                         else if (ncandidates > 1)
 948                         {
 949                                 best_candidate = func_select_candidate(nargs,
 950                                                                                                            argtypes,
 951                                                                                                            current_candidates);
 952
 953                                 /*
 954                                  * If we were able to choose a best candidate, we're done.
 955                                  * Otherwise, ambiguous function call.
 956                                  */
 957                                 if (!best_candidate)
 958                                         return FUNCDETAIL_MULTIPLE;
 959                         }
 960                 }
 961         }
 962
 963         if (best_candidate)
 964         {
 965                 HeapTuple       ftup;
 966                 Form_pg_proc pform;
 967                 FuncDetailCode result;
 968
 969                 /*
 970                  * If expanding variadics or defaults, the "best candidate" might
 971                  * represent multiple equivalently good functions; treat this case
 972                  * as ambiguous.
 973                  */
 974                 if (!OidIsValid(best_candidate->oid))
 975                         return FUNCDETAIL_MULTIPLE;
 976
 977                 *funcid = best_candidate->oid;
 978                 *nvargs = best_candidate->nvargs;
 979                 *true_typeids = best_candidate->args;
 980
 981                 ftup = SearchSysCache(PROCOID,
 982                                                           ObjectIdGetDatum(best_candidate->oid),
 983                                                           0, 0, 0);
 984                 if (!HeapTupleIsValid(ftup))    /* should not happen */
 985                         elog(ERROR, "cache lookup failed for function %u",
 986                                  best_candidate->oid);
 987                 pform = (Form_pg_proc) GETSTRUCT(ftup);
 988                 *rettype = pform->prorettype;
 989                 *retset = pform->proretset;
 990                 /* fetch default args if caller wants 'em */
 991                 if (argdefaults)
 992                 {
 993                         if (best_candidate->ndargs > 0)
 994                         {
 995                                 Datum           proargdefaults;
 996                                 bool            isnull;
 997                                 char       *str;
 998                                 List       *defaults;
 999                                 int                     ndelete;
1000
1001                                 /* shouldn't happen, FuncnameGetCandidates messed up */
1002                                 if (best_candidate->ndargs > pform->pronargdefaults)
1003                                         elog(ERROR, "not enough default arguments");
1004
1005                                 proargdefaults = SysCacheGetAttr(PROCOID, ftup,
1006                                                                                                  Anum_pg_proc_proargdefaults,
1007                                                                                                  &isnull);
1008                                 Assert(!isnull);
1009                                 str = TextDatumGetCString(proargdefaults);
1010                                 defaults = (List *) stringToNode(str);
1011                                 Assert(IsA(defaults, List));
1012                                 pfree(str);
1013                                 /* Delete any unused defaults from the returned list */
1014                                 ndelete = list_length(defaults) - best_candidate->ndargs;
1015                                 while (ndelete-- > 0)
1016                                         defaults = list_delete_first(defaults);
1017                                 *argdefaults = defaults;
1018                         }
1019                         else
1020                                 *argdefaults = NIL;
1021                 }
1022                 if (pform->proisagg)
1023                         result = FUNCDETAIL_AGGREGATE;
1024                 else if (pform->proiswindow)
1025                         result = FUNCDETAIL_WINDOWFUNC;
1026                 else
1027                         result = FUNCDETAIL_NORMAL;
1028                 ReleaseSysCache(ftup);
1029                 return result;
1030         }
1031
1032         return FUNCDETAIL_NOTFOUND;
1033 }
1034
1035
1036 /*
1037  * make_fn_arguments()
1038  *
1039  * Given the actual argument expressions for a function, and the desired
1040  * input types for the function, add any necessary typecasting to the
1041  * expression tree.  Caller should already have verified that casting is
1042  * allowed.
1043  *
1044  * Caution: given argument list is modified in-place.
1045  *
1046  * As with coerce_type, pstate may be NULL if no special unknown-Param
1047  * processing is wanted.
1048  */
1049 void
1050 make_fn_arguments(ParseState *pstate,
1051                                   List *fargs,
1052                                   Oid *actual_arg_types,
1053                                   Oid *declared_arg_types)
1054 {
1055         ListCell   *current_fargs;
1056         int                     i = 0;
1057
1058         foreach(current_fargs, fargs)
1059         {
1060                 /* types don't match? then force coercion using a function call... */
1061                 if (actual_arg_types[i] != declared_arg_types[i])
1062                 {
1063                         lfirst(current_fargs) = coerce_type(pstate,
1064                                                                                                 lfirst(current_fargs),
1065                                                                                                 actual_arg_types[i],
1066                                                                                                 declared_arg_types[i], -1,
1067                                                                                                 COERCION_IMPLICIT,
1068                                                                                                 COERCE_IMPLICIT_CAST,
1069                                                                                                 -1);
1070                 }
1071                 i++;
1072         }
1073 }
1074
1075 /*
1076  * FuncNameAsType -
1077  *        convenience routine to see if a function name matches a type name
1078  *
1079  * Returns the OID of the matching type, or InvalidOid if none.  We ignore
1080  * shell types and complex types.
1081  */
1082 static Oid
1083 FuncNameAsType(List *funcname)
1084 {
1085         Oid                     result;
1086         Type            typtup;
1087
1088         typtup = LookupTypeName(NULL, makeTypeNameFromNameList(funcname), NULL);
1089         if (typtup == NULL)
1090                 return InvalidOid;
1091
1092         if (((Form_pg_type) GETSTRUCT(typtup))->typisdefined &&
1093                 !OidIsValid(typeTypeRelid(typtup)))
1094                 result = typeTypeId(typtup);
1095         else
1096                 result = InvalidOid;
1097
1098         ReleaseSysCache(typtup);
1099         return result;
1100 }
1101
1102 /*
1103  * ParseComplexProjection -
1104  *        handles function calls with a single argument that is of complex type.
1105  *        If the function call is actually a column projection, return a suitably
1106  *        transformed expression tree.  If not, return NULL.
1107  */
1108 static Node *
1109 ParseComplexProjection(ParseState *pstate, char *funcname, Node *first_arg,
1110                                            int location)
1111 {
1112         TupleDesc       tupdesc;
1113         int                     i;
1114
1115         /*
1116          * Special case for whole-row Vars so that we can resolve (foo.*).bar even
1117          * when foo is a reference to a subselect, join, or RECORD function. A
1118          * bonus is that we avoid generating an unnecessary FieldSelect; our
1119          * result can omit the whole-row Var and just be a Var for the selected
1120          * field.
1121          *
1122          * This case could be handled by expandRecordVariable, but it's more
1123          * efficient to do it this way when possible.
1124          */
1125         if (IsA(first_arg, Var) &&
1126                 ((Var *) first_arg)->varattno == InvalidAttrNumber)
1127         {
1128                 RangeTblEntry *rte;
1129
1130                 rte = GetRTEByRangeTablePosn(pstate,
1131                                                                          ((Var *) first_arg)->varno,
1132                                                                          ((Var *) first_arg)->varlevelsup);
1133                 /* Return a Var if funcname matches a column, else NULL */
1134                 return scanRTEForColumn(pstate, rte, funcname, location);
1135         }
1136
1137         /*
1138          * Else do it the hard way with get_expr_result_type().
1139          *
1140          * If it's a Var of type RECORD, we have to work even harder: we have to
1141          * find what the Var refers to, and pass that to get_expr_result_type.
1142          * That task is handled by expandRecordVariable().
1143          */
1144         if (IsA(first_arg, Var) &&
1145                 ((Var *) first_arg)->vartype == RECORDOID)
1146                 tupdesc = expandRecordVariable(pstate, (Var *) first_arg, 0);
1147         else if (get_expr_result_type(first_arg, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
1148                 return NULL;                    /* unresolvable RECORD type */
1149         Assert(tupdesc);
1150
1151         for (i = 0; i < tupdesc->natts; i++)
1152         {
1153                 Form_pg_attribute att = tupdesc->attrs[i];
1154
1155                 if (strcmp(funcname, NameStr(att->attname)) == 0 &&
1156                         !att->attisdropped)
1157                 {
1158                         /* Success, so generate a FieldSelect expression */
1159                         FieldSelect *fselect = makeNode(FieldSelect);
1160
1161                         fselect->arg = (Expr *) first_arg;
1162                         fselect->fieldnum = i + 1;
1163                         fselect->resulttype = att->atttypid;
1164                         fselect->resulttypmod = att->atttypmod;
1165                         return (Node *) fselect;
1166                 }
1167         }
1168
1169         return NULL;                            /* funcname does not match any column */
1170 }
1171
1172 /*
1173  * helper routine for delivering "column does not exist" error message
1174  */
1175 static void
1176 unknown_attribute(ParseState *pstate, Node *relref, char *attname,
1177                                   int location)
1178 {
1179         RangeTblEntry *rte;
1180
1181         if (IsA(relref, Var) &&
1182                 ((Var *) relref)->varattno == InvalidAttrNumber)
1183         {
1184                 /* Reference the RTE by alias not by actual table name */
1185                 rte = GetRTEByRangeTablePosn(pstate,
1186                                                                          ((Var *) relref)->varno,
1187                                                                          ((Var *) relref)->varlevelsup);
1188                 ereport(ERROR,
1189                                 (errcode(ERRCODE_UNDEFINED_COLUMN),
1190                                  errmsg("column %s.%s does not exist",
1191                                                 rte->eref->aliasname, attname),
1192                                  parser_errposition(pstate, location)));
1193         }
1194         else
1195         {
1196                 /* Have to do it by reference to the type of the expression */
1197                 Oid                     relTypeId = exprType(relref);
1198
1199                 if (ISCOMPLEX(relTypeId))
1200                         ereport(ERROR,
1201                                         (errcode(ERRCODE_UNDEFINED_COLUMN),
1202                                          errmsg("column \"%s\" not found in data type %s",
1203                                                         attname, format_type_be(relTypeId)),
1204                                          parser_errposition(pstate, location)));
1205                 else if (relTypeId == RECORDOID)
1206                         ereport(ERROR,
1207                                         (errcode(ERRCODE_UNDEFINED_COLUMN),
1208                            errmsg("could not identify column \"%s\" in record data type",
1209                                           attname),
1210                                          parser_errposition(pstate, location)));
1211                 else
1212                         ereport(ERROR,
1213                                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1214                                          errmsg("column notation .%s applied to type %s, "
1215                                                         "which is not a composite type",
1216                                                         attname, format_type_be(relTypeId)),
1217                                          parser_errposition(pstate, location)));
1218         }
1219 }
1220
1221 /*
1222  * funcname_signature_string
1223  *              Build a string representing a function name, including arg types.
1224  *              The result is something like "foo(integer)".
1225  *
1226  * This is typically used in the construction of function-not-found error
1227  * messages.
1228  */
1229 const char *
1230 funcname_signature_string(const char *funcname,
1231                                                   int nargs, const Oid *argtypes)
1232 {
1233         StringInfoData argbuf;
1234         int                     i;
1235
1236         initStringInfo(&argbuf);
1237
1238         appendStringInfo(&argbuf, "%s(", funcname);
1239
1240         for (i = 0; i < nargs; i++)
1241         {
1242                 if (i)
1243                         appendStringInfoString(&argbuf, ", ");
1244                 appendStringInfoString(&argbuf, format_type_be(argtypes[i]));
1245         }
1246
1247         appendStringInfoChar(&argbuf, ')');
1248
1249         return argbuf.data;                     /* return palloc'd string buffer */
1250 }
1251
1252 /*
1253  * func_signature_string
1254  *              As above, but function name is passed as a qualified name list.
1255  */
1256 const char *
1257 func_signature_string(List *funcname, int nargs, const Oid *argtypes)
1258 {
1259         return funcname_signature_string(NameListToString(funcname),
1260                                                                          nargs, argtypes);
1261 }
1262
1263 /*
1264  * LookupFuncName
1265  *              Given a possibly-qualified function name and a set of argument types,
1266  *              look up the function.
1267  *
1268  * If the function name is not schema-qualified, it is sought in the current
1269  * namespace search path.
1270  *
1271  * If the function is not found, we return InvalidOid if noError is true,
1272  * else raise an error.
1273  */
1274 Oid
1275 LookupFuncName(List *funcname, int nargs, const Oid *argtypes, bool noError)
1276 {
1277         FuncCandidateList clist;
1278
1279         clist = FuncnameGetCandidates(funcname, nargs, false, false);
1280
1281         while (clist)
1282         {
1283                 if (memcmp(argtypes, clist->args, nargs * sizeof(Oid)) == 0)
1284                         return clist->oid;
1285                 clist = clist->next;
1286         }
1287
1288         if (!noError)
1289                 ereport(ERROR,
1290                                 (errcode(ERRCODE_UNDEFINED_FUNCTION),
1291                                  errmsg("function %s does not exist",
1292                                                 func_signature_string(funcname, nargs, argtypes))));
1293
1294         return InvalidOid;
1295 }
1296
1297 /*
1298  * LookupTypeNameOid
1299  *              Convenience routine to look up a type, silently accepting shell types
1300  */
1301 static Oid
1302 LookupTypeNameOid(const TypeName *typename)
1303 {
1304         Oid                     result;
1305         Type            typtup;
1306
1307         typtup = LookupTypeName(NULL, typename, NULL);
1308         if (typtup == NULL)
1309                 ereport(ERROR,
1310                                 (errcode(ERRCODE_UNDEFINED_OBJECT),
1311                                  errmsg("type \"%s\" does not exist",
1312                                                 TypeNameToString(typename))));
1313         result = typeTypeId(typtup);
1314         ReleaseSysCache(typtup);
1315         return result;
1316 }
1317
1318 /*
1319  * LookupFuncNameTypeNames
1320  *              Like LookupFuncName, but the argument types are specified by a
1321  *              list of TypeName nodes.
1322  */
1323 Oid
1324 LookupFuncNameTypeNames(List *funcname, List *argtypes, bool noError)
1325 {
1326         Oid                     argoids[FUNC_MAX_ARGS];
1327         int                     argcount;
1328         int                     i;
1329         ListCell   *args_item;
1330
1331         argcount = list_length(argtypes);
1332         if (argcount > FUNC_MAX_ARGS)
1333                 ereport(ERROR,
1334                                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
1335                                  errmsg_plural("functions cannot have more than %d argument",
1336                                                            "functions cannot have more than %d arguments",
1337                                                            FUNC_MAX_ARGS,
1338                                                            FUNC_MAX_ARGS)));
1339
1340         args_item = list_head(argtypes);
1341         for (i = 0; i < argcount; i++)
1342         {
1343                 TypeName   *t = (TypeName *) lfirst(args_item);
1344
1345                 argoids[i] = LookupTypeNameOid(t);
1346                 args_item = lnext(args_item);
1347         }
1348
1349         return LookupFuncName(funcname, argcount, argoids, noError);
1350 }
1351
1352 /*
1353  * LookupAggNameTypeNames
1354  *              Find an aggregate function given a name and list of TypeName nodes.
1355  *
1356  * This is almost like LookupFuncNameTypeNames, but the error messages refer
1357  * to aggregates rather than plain functions, and we verify that the found
1358  * function really is an aggregate.
1359  */
1360 Oid
1361 LookupAggNameTypeNames(List *aggname, List *argtypes, bool noError)
1362 {
1363         Oid                     argoids[FUNC_MAX_ARGS];
1364         int                     argcount;
1365         int                     i;
1366         ListCell   *lc;
1367         Oid                     oid;
1368         HeapTuple       ftup;
1369         Form_pg_proc pform;
1370
1371         argcount = list_length(argtypes);
1372         if (argcount > FUNC_MAX_ARGS)
1373                 ereport(ERROR,
1374                                 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
1375                                  errmsg_plural("functions cannot have more than %d argument",
1376                                                            "functions cannot have more than %d arguments",
1377                                                            FUNC_MAX_ARGS,
1378                                                            FUNC_MAX_ARGS)));
1379
1380         i = 0;
1381         foreach(lc, argtypes)
1382         {
1383                 TypeName   *t = (TypeName *) lfirst(lc);
1384
1385                 argoids[i] = LookupTypeNameOid(t);
1386                 i++;
1387         }
1388
1389         oid = LookupFuncName(aggname, argcount, argoids, true);
1390
1391         if (!OidIsValid(oid))
1392         {
1393                 if (noError)
1394                         return InvalidOid;
1395                 if (argcount == 0)
1396                         ereport(ERROR,
1397                                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
1398                                          errmsg("aggregate %s(*) does not exist",
1399                                                         NameListToString(aggname))));
1400                 else
1401                         ereport(ERROR,
1402                                         (errcode(ERRCODE_UNDEFINED_FUNCTION),
1403                                          errmsg("aggregate %s does not exist",
1404                                                         func_signature_string(aggname,
1405                                                                                                   argcount, argoids))));
1406         }
1407
1408         /* Make sure it's an aggregate */
1409         ftup = SearchSysCache(PROCOID,
1410                                                   ObjectIdGetDatum(oid),
1411                                                   0, 0, 0);
1412         if (!HeapTupleIsValid(ftup))    /* should not happen */
1413                 elog(ERROR, "cache lookup failed for function %u", oid);
1414         pform = (Form_pg_proc) GETSTRUCT(ftup);
1415
1416         if (!pform->proisagg)
1417         {
1418                 ReleaseSysCache(ftup);
1419                 if (noError)
1420                         return InvalidOid;
1421                 /* we do not use the (*) notation for functions... */
1422                 ereport(ERROR,
1423                                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1424                                  errmsg("function %s is not an aggregate",
1425                                                 func_signature_string(aggname,
1426                                                                                           argcount, argoids))));
1427         }
1428
1429         ReleaseSysCache(ftup);
1430
1431         return oid;
1432 }