PostgreSQL Source Code  git master
parse_oper.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_oper.c
4  * handle operator things for parser
5  *
6  * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/parser/parse_oper.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 
16 #include "postgres.h"
17 
18 #include "access/htup_details.h"
19 #include "catalog/pg_operator.h"
20 #include "catalog/pg_type.h"
21 #include "lib/stringinfo.h"
22 #include "nodes/nodeFuncs.h"
23 #include "parser/parse_coerce.h"
24 #include "parser/parse_func.h"
25 #include "parser/parse_oper.h"
26 #include "parser/parse_type.h"
27 #include "utils/builtins.h"
28 #include "utils/inval.h"
29 #include "utils/lsyscache.h"
30 #include "utils/syscache.h"
31 #include "utils/typcache.h"
32 
33 
34 /*
35  * The lookup key for the operator lookaside hash table. Unused bits must be
36  * zeroes to ensure hashing works consistently --- in particular, oprname
37  * must be zero-padded and any unused entries in search_path must be zero.
38  *
39  * search_path contains the actual search_path with which the entry was
40  * derived (minus temp namespace if any), or else the single specified
41  * schema OID if we are looking up an explicitly-qualified operator name.
42  *
43  * search_path has to be fixed-length since the hashtable code insists on
44  * fixed-size keys. If your search path is longer than that, we just punt
45  * and don't cache anything.
46  */
47 
48 /* If your search_path is longer than this, sucks to be you ... */
49 #define MAX_CACHED_PATH_LEN 16
50 
51 typedef struct OprCacheKey
52 {
54  Oid left_arg; /* Left input OID, or 0 if prefix op */
55  Oid right_arg; /* Right input OID */
57 } OprCacheKey;
58 
59 typedef struct OprCacheEntry
60 {
61  /* the hash lookup key MUST BE FIRST */
63 
64  Oid opr_oid; /* OID of the resolved operator */
66 
67 
68 static Oid binary_oper_exact(List *opname, Oid arg1, Oid arg2);
69 static FuncDetailCode oper_select_candidate(int nargs,
70  Oid *input_typeids,
71  FuncCandidateList candidates,
72  Oid *operOid);
73 static const char *op_signature_string(List *op, char oprkind,
74  Oid arg1, Oid arg2);
75 static void op_error(ParseState *pstate, List *op, char oprkind,
76  Oid arg1, Oid arg2,
77  FuncDetailCode fdresult, int location);
78 static bool make_oper_cache_key(ParseState *pstate, OprCacheKey *key,
79  List *opname, Oid ltypeId, Oid rtypeId,
80  int location);
82 static void make_oper_cache_entry(OprCacheKey *key, Oid opr_oid);
83 static void InvalidateOprCacheCallBack(Datum arg, int cacheid, uint32 hashvalue);
84 
85 
86 /*
87  * LookupOperName
88  * Given a possibly-qualified operator name and exact input datatypes,
89  * look up the operator.
90  *
91  * Pass oprleft = InvalidOid for a prefix op.
92  *
93  * If the operator name is not schema-qualified, it is sought in the current
94  * namespace search path.
95  *
96  * If the operator is not found, we return InvalidOid if noError is true,
97  * else raise an error. pstate and location are used only to report the
98  * error position; pass NULL/-1 if not available.
99  */
100 Oid
101 LookupOperName(ParseState *pstate, List *opername, Oid oprleft, Oid oprright,
102  bool noError, int location)
103 {
104  Oid result;
105 
106  result = OpernameGetOprid(opername, oprleft, oprright);
107  if (OidIsValid(result))
108  return result;
109 
110  /* we don't use op_error here because only an exact match is wanted */
111  if (!noError)
112  {
113  char oprkind;
114 
115  if (!OidIsValid(oprleft))
116  oprkind = 'l';
117  else if (OidIsValid(oprright))
118  oprkind = 'b';
119  else
120  {
121  ereport(ERROR,
122  (errcode(ERRCODE_SYNTAX_ERROR),
123  errmsg("postfix operators are not supported"),
124  parser_errposition(pstate, location)));
125  oprkind = 0; /* keep compiler quiet */
126  }
127 
128  ereport(ERROR,
129  (errcode(ERRCODE_UNDEFINED_FUNCTION),
130  errmsg("operator does not exist: %s",
131  op_signature_string(opername, oprkind,
132  oprleft, oprright)),
133  parser_errposition(pstate, location)));
134  }
135 
136  return InvalidOid;
137 }
138 
139 /*
140  * LookupOperWithArgs
141  * Like LookupOperName, but the argument types are specified by
142  * a ObjectWithArgs node.
143  */
144 Oid
146 {
147  TypeName *oprleft,
148  *oprright;
149  Oid leftoid,
150  rightoid;
151 
152  Assert(list_length(oper->objargs) == 2);
153  oprleft = linitial(oper->objargs);
154  oprright = lsecond(oper->objargs);
155 
156  if (oprleft == NULL)
157  leftoid = InvalidOid;
158  else
159  leftoid = LookupTypeNameOid(NULL, oprleft, noError);
160 
161  if (oprright == NULL)
162  rightoid = InvalidOid;
163  else
164  rightoid = LookupTypeNameOid(NULL, oprright, noError);
165 
166  return LookupOperName(NULL, oper->objname, leftoid, rightoid,
167  noError, -1);
168 }
169 
170 /*
171  * get_sort_group_operators - get default sorting/grouping operators for type
172  *
173  * We fetch the "<", "=", and ">" operators all at once to reduce lookup
174  * overhead (knowing that most callers will be interested in at least two).
175  * However, a given datatype might have only an "=" operator, if it is
176  * hashable but not sortable. (Other combinations of present and missing
177  * operators shouldn't happen, unless the system catalogs are messed up.)
178  *
179  * If an operator is missing and the corresponding needXX flag is true,
180  * throw a standard error message, else return InvalidOid.
181  *
182  * In addition to the operator OIDs themselves, this function can identify
183  * whether the "=" operator is hashable.
184  *
185  * Callers can pass NULL pointers for any results they don't care to get.
186  *
187  * Note: the results are guaranteed to be exact or binary-compatible matches,
188  * since most callers are not prepared to cope with adding any run-time type
189  * coercion steps.
190  */
191 void
193  bool needLT, bool needEQ, bool needGT,
194  Oid *ltOpr, Oid *eqOpr, Oid *gtOpr,
195  bool *isHashable)
196 {
197  TypeCacheEntry *typentry;
198  int cache_flags;
199  Oid lt_opr;
200  Oid eq_opr;
201  Oid gt_opr;
202  bool hashable;
203 
204  /*
205  * Look up the operators using the type cache.
206  *
207  * Note: the search algorithm used by typcache.c ensures that the results
208  * are consistent, ie all from matching opclasses.
209  */
210  if (isHashable != NULL)
213  else
215 
216  typentry = lookup_type_cache(argtype, cache_flags);
217  lt_opr = typentry->lt_opr;
218  eq_opr = typentry->eq_opr;
219  gt_opr = typentry->gt_opr;
220  hashable = OidIsValid(typentry->hash_proc);
221 
222  /* Report errors if needed */
223  if ((needLT && !OidIsValid(lt_opr)) ||
224  (needGT && !OidIsValid(gt_opr)))
225  ereport(ERROR,
226  (errcode(ERRCODE_UNDEFINED_FUNCTION),
227  errmsg("could not identify an ordering operator for type %s",
228  format_type_be(argtype)),
229  errhint("Use an explicit ordering operator or modify the query.")));
230  if (needEQ && !OidIsValid(eq_opr))
231  ereport(ERROR,
232  (errcode(ERRCODE_UNDEFINED_FUNCTION),
233  errmsg("could not identify an equality operator for type %s",
234  format_type_be(argtype))));
235 
236  /* Return results as needed */
237  if (ltOpr)
238  *ltOpr = lt_opr;
239  if (eqOpr)
240  *eqOpr = eq_opr;
241  if (gtOpr)
242  *gtOpr = gt_opr;
243  if (isHashable)
244  *isHashable = hashable;
245 }
246 
247 
248 /* given operator tuple, return the operator OID */
249 Oid
251 {
252  return ((Form_pg_operator) GETSTRUCT(op))->oid;
253 }
254 
255 /* given operator tuple, return the underlying function's OID */
256 Oid
258 {
260 
261  return pgopform->oprcode;
262 }
263 
264 
265 /* binary_oper_exact()
266  * Check for an "exact" match to the specified operand types.
267  *
268  * If one operand is an unknown literal, assume it should be taken to be
269  * the same type as the other operand for this purpose. Also, consider
270  * the possibility that the other operand is a domain type that needs to
271  * be reduced to its base type to find an "exact" match.
272  */
273 static Oid
274 binary_oper_exact(List *opname, Oid arg1, Oid arg2)
275 {
276  Oid result;
277  bool was_unknown = false;
278 
279  /* Unspecified type for one of the arguments? then use the other */
280  if ((arg1 == UNKNOWNOID) && (arg2 != InvalidOid))
281  {
282  arg1 = arg2;
283  was_unknown = true;
284  }
285  else if ((arg2 == UNKNOWNOID) && (arg1 != InvalidOid))
286  {
287  arg2 = arg1;
288  was_unknown = true;
289  }
290 
291  result = OpernameGetOprid(opname, arg1, arg2);
292  if (OidIsValid(result))
293  return result;
294 
295  if (was_unknown)
296  {
297  /* arg1 and arg2 are the same here, need only look at arg1 */
298  Oid basetype = getBaseType(arg1);
299 
300  if (basetype != arg1)
301  {
302  result = OpernameGetOprid(opname, basetype, basetype);
303  if (OidIsValid(result))
304  return result;
305  }
306  }
307 
308  return InvalidOid;
309 }
310 
311 
312 /* oper_select_candidate()
313  * Given the input argtype array and one or more candidates
314  * for the operator, attempt to resolve the conflict.
315  *
316  * Returns FUNCDETAIL_NOTFOUND, FUNCDETAIL_MULTIPLE, or FUNCDETAIL_NORMAL.
317  * In the success case the Oid of the best candidate is stored in *operOid.
318  *
319  * Note that the caller has already determined that there is no candidate
320  * exactly matching the input argtype(s). Incompatible candidates are not yet
321  * pruned away, however.
322  */
323 static FuncDetailCode
325  Oid *input_typeids,
326  FuncCandidateList candidates,
327  Oid *operOid) /* output argument */
328 {
329  int ncandidates;
330 
331  /*
332  * Delete any candidates that cannot actually accept the given input
333  * types, whether directly or by coercion.
334  */
335  ncandidates = func_match_argtypes(nargs, input_typeids,
336  candidates, &candidates);
337 
338  /* Done if no candidate or only one candidate survives */
339  if (ncandidates == 0)
340  {
341  *operOid = InvalidOid;
342  return FUNCDETAIL_NOTFOUND;
343  }
344  if (ncandidates == 1)
345  {
346  *operOid = candidates->oid;
347  return FUNCDETAIL_NORMAL;
348  }
349 
350  /*
351  * Use the same heuristics as for ambiguous functions to resolve the
352  * conflict.
353  */
354  candidates = func_select_candidate(nargs, input_typeids, candidates);
355 
356  if (candidates)
357  {
358  *operOid = candidates->oid;
359  return FUNCDETAIL_NORMAL;
360  }
361 
362  *operOid = InvalidOid;
363  return FUNCDETAIL_MULTIPLE; /* failed to select a best candidate */
364 }
365 
366 
367 /* oper() -- search for a binary operator
368  * Given operator name, types of arg1 and arg2, return oper struct.
369  *
370  * IMPORTANT: the returned operator (if any) is only promised to be
371  * coercion-compatible with the input datatypes. Do not use this if
372  * you need an exact- or binary-compatible match; see compatible_oper.
373  *
374  * If no matching operator found, return NULL if noError is true,
375  * raise an error if it is false. pstate and location are used only to report
376  * the error position; pass NULL/-1 if not available.
377  *
378  * NOTE: on success, the returned object is a syscache entry. The caller
379  * must ReleaseSysCache() the entry when done with it.
380  */
381 Operator
382 oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId,
383  bool noError, int location)
384 {
385  Oid operOid;
387  bool key_ok;
389  HeapTuple tup = NULL;
390 
391  /*
392  * Try to find the mapping in the lookaside cache.
393  */
394  key_ok = make_oper_cache_key(pstate, &key, opname, ltypeId, rtypeId, location);
395 
396  if (key_ok)
397  {
398  operOid = find_oper_cache_entry(&key);
399  if (OidIsValid(operOid))
400  {
401  tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
402  if (HeapTupleIsValid(tup))
403  return (Operator) tup;
404  }
405  }
406 
407  /*
408  * First try for an "exact" match.
409  */
410  operOid = binary_oper_exact(opname, ltypeId, rtypeId);
411  if (!OidIsValid(operOid))
412  {
413  /*
414  * Otherwise, search for the most suitable candidate.
415  */
416  FuncCandidateList clist;
417 
418  /* Get binary operators of given name */
419  clist = OpernameGetCandidates(opname, 'b', false);
420 
421  /* No operators found? Then fail... */
422  if (clist != NULL)
423  {
424  /*
425  * Unspecified type for one of the arguments? then use the other
426  * (XXX this is probably dead code?)
427  */
428  Oid inputOids[2];
429 
430  if (rtypeId == InvalidOid)
431  rtypeId = ltypeId;
432  else if (ltypeId == InvalidOid)
433  ltypeId = rtypeId;
434  inputOids[0] = ltypeId;
435  inputOids[1] = rtypeId;
436  fdresult = oper_select_candidate(2, inputOids, clist, &operOid);
437  }
438  }
439 
440  if (OidIsValid(operOid))
441  tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
442 
443  if (HeapTupleIsValid(tup))
444  {
445  if (key_ok)
446  make_oper_cache_entry(&key, operOid);
447  }
448  else if (!noError)
449  op_error(pstate, opname, 'b', ltypeId, rtypeId, fdresult, location);
450 
451  return (Operator) tup;
452 }
453 
454 /* compatible_oper()
455  * given an opname and input datatypes, find a compatible binary operator
456  *
457  * This is tighter than oper() because it will not return an operator that
458  * requires coercion of the input datatypes (but binary-compatible operators
459  * are accepted). Otherwise, the semantics are the same.
460  */
461 Operator
462 compatible_oper(ParseState *pstate, List *op, Oid arg1, Oid arg2,
463  bool noError, int location)
464 {
465  Operator optup;
466  Form_pg_operator opform;
467 
468  /* oper() will find the best available match */
469  optup = oper(pstate, op, arg1, arg2, noError, location);
470  if (optup == (Operator) NULL)
471  return (Operator) NULL; /* must be noError case */
472 
473  /* but is it good enough? */
474  opform = (Form_pg_operator) GETSTRUCT(optup);
475  if (IsBinaryCoercible(arg1, opform->oprleft) &&
476  IsBinaryCoercible(arg2, opform->oprright))
477  return optup;
478 
479  /* nope... */
480  ReleaseSysCache(optup);
481 
482  if (!noError)
483  ereport(ERROR,
484  (errcode(ERRCODE_UNDEFINED_FUNCTION),
485  errmsg("operator requires run-time type coercion: %s",
486  op_signature_string(op, 'b', arg1, arg2)),
487  parser_errposition(pstate, location)));
488 
489  return (Operator) NULL;
490 }
491 
492 /* compatible_oper_opid() -- get OID of a binary operator
493  *
494  * This is a convenience routine that extracts only the operator OID
495  * from the result of compatible_oper(). InvalidOid is returned if the
496  * lookup fails and noError is true.
497  */
498 Oid
499 compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError)
500 {
501  Operator optup;
502  Oid result;
503 
504  optup = compatible_oper(NULL, op, arg1, arg2, noError, -1);
505  if (optup != NULL)
506  {
507  result = oprid(optup);
508  ReleaseSysCache(optup);
509  return result;
510  }
511  return InvalidOid;
512 }
513 
514 
515 /* left_oper() -- search for a unary left operator (prefix operator)
516  * Given operator name and type of arg, return oper struct.
517  *
518  * IMPORTANT: the returned operator (if any) is only promised to be
519  * coercion-compatible with the input datatype. Do not use this if
520  * you need an exact- or binary-compatible match.
521  *
522  * If no matching operator found, return NULL if noError is true,
523  * raise an error if it is false. pstate and location are used only to report
524  * the error position; pass NULL/-1 if not available.
525  *
526  * NOTE: on success, the returned object is a syscache entry. The caller
527  * must ReleaseSysCache() the entry when done with it.
528  */
529 Operator
530 left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
531 {
532  Oid operOid;
534  bool key_ok;
536  HeapTuple tup = NULL;
537 
538  /*
539  * Try to find the mapping in the lookaside cache.
540  */
541  key_ok = make_oper_cache_key(pstate, &key, op, InvalidOid, arg, location);
542 
543  if (key_ok)
544  {
545  operOid = find_oper_cache_entry(&key);
546  if (OidIsValid(operOid))
547  {
548  tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
549  if (HeapTupleIsValid(tup))
550  return (Operator) tup;
551  }
552  }
553 
554  /*
555  * First try for an "exact" match.
556  */
557  operOid = OpernameGetOprid(op, InvalidOid, arg);
558  if (!OidIsValid(operOid))
559  {
560  /*
561  * Otherwise, search for the most suitable candidate.
562  */
563  FuncCandidateList clist;
564 
565  /* Get prefix operators of given name */
566  clist = OpernameGetCandidates(op, 'l', false);
567 
568  /* No operators found? Then fail... */
569  if (clist != NULL)
570  {
571  /*
572  * The returned list has args in the form (0, oprright). Move the
573  * useful data into args[0] to keep oper_select_candidate simple.
574  * XXX we are assuming here that we may scribble on the list!
575  */
576  FuncCandidateList clisti;
577 
578  for (clisti = clist; clisti != NULL; clisti = clisti->next)
579  {
580  clisti->args[0] = clisti->args[1];
581  }
582 
583  /*
584  * We must run oper_select_candidate even if only one candidate,
585  * otherwise we may falsely return a non-type-compatible operator.
586  */
587  fdresult = oper_select_candidate(1, &arg, clist, &operOid);
588  }
589  }
590 
591  if (OidIsValid(operOid))
592  tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));
593 
594  if (HeapTupleIsValid(tup))
595  {
596  if (key_ok)
597  make_oper_cache_entry(&key, operOid);
598  }
599  else if (!noError)
600  op_error(pstate, op, 'l', InvalidOid, arg, fdresult, location);
601 
602  return (Operator) tup;
603 }
604 
605 /*
606  * op_signature_string
607  * Build a string representing an operator name, including arg type(s).
608  * The result is something like "integer + integer".
609  *
610  * This is typically used in the construction of operator-not-found error
611  * messages.
612  */
613 static const char *
614 op_signature_string(List *op, char oprkind, Oid arg1, Oid arg2)
615 {
616  StringInfoData argbuf;
617 
618  initStringInfo(&argbuf);
619 
620  if (oprkind != 'l')
621  appendStringInfo(&argbuf, "%s ", format_type_be(arg1));
622 
624 
625  appendStringInfo(&argbuf, " %s", format_type_be(arg2));
626 
627  return argbuf.data; /* return palloc'd string buffer */
628 }
629 
630 /*
631  * op_error - utility routine to complain about an unresolvable operator
632  */
633 static void
634 op_error(ParseState *pstate, List *op, char oprkind,
635  Oid arg1, Oid arg2,
636  FuncDetailCode fdresult, int location)
637 {
638  if (fdresult == FUNCDETAIL_MULTIPLE)
639  ereport(ERROR,
640  (errcode(ERRCODE_AMBIGUOUS_FUNCTION),
641  errmsg("operator is not unique: %s",
642  op_signature_string(op, oprkind, arg1, arg2)),
643  errhint("Could not choose a best candidate operator. "
644  "You might need to add explicit type casts."),
645  parser_errposition(pstate, location)));
646  else
647  ereport(ERROR,
648  (errcode(ERRCODE_UNDEFINED_FUNCTION),
649  errmsg("operator does not exist: %s",
650  op_signature_string(op, oprkind, arg1, arg2)),
651  (!arg1 || !arg2) ?
652  errhint("No operator matches the given name and argument type. "
653  "You might need to add an explicit type cast.") :
654  errhint("No operator matches the given name and argument types. "
655  "You might need to add explicit type casts."),
656  parser_errposition(pstate, location)));
657 }
658 
659 /*
660  * make_op()
661  * Operator expression construction.
662  *
663  * Transform operator expression ensuring type compatibility.
664  * This is where some type conversion happens.
665  *
666  * last_srf should be a copy of pstate->p_last_srf from just before we
667  * started transforming the operator's arguments; this is used for nested-SRF
668  * detection. If the caller will throw an error anyway for a set-returning
669  * expression, it's okay to cheat and just pass pstate->p_last_srf.
670  */
671 Expr *
672 make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree,
673  Node *last_srf, int location)
674 {
675  Oid ltypeId,
676  rtypeId;
677  Operator tup;
678  Form_pg_operator opform;
679  Oid actual_arg_types[2];
680  Oid declared_arg_types[2];
681  int nargs;
682  List *args;
683  Oid rettype;
684  OpExpr *result;
685 
686  /* Check it's not a postfix operator */
687  if (rtree == NULL)
688  ereport(ERROR,
689  (errcode(ERRCODE_SYNTAX_ERROR),
690  errmsg("postfix operators are not supported")));
691 
692  /* Select the operator */
693  if (ltree == NULL)
694  {
695  /* prefix operator */
696  rtypeId = exprType(rtree);
697  ltypeId = InvalidOid;
698  tup = left_oper(pstate, opname, rtypeId, false, location);
699  }
700  else
701  {
702  /* otherwise, binary operator */
703  ltypeId = exprType(ltree);
704  rtypeId = exprType(rtree);
705  tup = oper(pstate, opname, ltypeId, rtypeId, false, location);
706  }
707 
708  opform = (Form_pg_operator) GETSTRUCT(tup);
709 
710  /* Check it's not a shell */
711  if (!RegProcedureIsValid(opform->oprcode))
712  ereport(ERROR,
713  (errcode(ERRCODE_UNDEFINED_FUNCTION),
714  errmsg("operator is only a shell: %s",
715  op_signature_string(opname,
716  opform->oprkind,
717  opform->oprleft,
718  opform->oprright)),
719  parser_errposition(pstate, location)));
720 
721  /* Do typecasting and build the expression tree */
722  if (ltree == NULL)
723  {
724  /* prefix operator */
725  args = list_make1(rtree);
726  actual_arg_types[0] = rtypeId;
727  declared_arg_types[0] = opform->oprright;
728  nargs = 1;
729  }
730  else
731  {
732  /* otherwise, binary operator */
733  args = list_make2(ltree, rtree);
734  actual_arg_types[0] = ltypeId;
735  actual_arg_types[1] = rtypeId;
736  declared_arg_types[0] = opform->oprleft;
737  declared_arg_types[1] = opform->oprright;
738  nargs = 2;
739  }
740 
741  /*
742  * enforce consistency with polymorphic argument and return types,
743  * possibly adjusting return type or declared_arg_types (which will be
744  * used as the cast destination by make_fn_arguments)
745  */
746  rettype = enforce_generic_type_consistency(actual_arg_types,
747  declared_arg_types,
748  nargs,
749  opform->oprresult,
750  false);
751 
752  /* perform the necessary typecasting of arguments */
753  make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
754 
755  /* and build the expression node */
756  result = makeNode(OpExpr);
757  result->opno = oprid(tup);
758  result->opfuncid = opform->oprcode;
759  result->opresulttype = rettype;
760  result->opretset = get_func_retset(opform->oprcode);
761  /* opcollid and inputcollid will be set by parse_collate.c */
762  result->args = args;
763  result->location = location;
764 
765  /* if it returns a set, check that's OK */
766  if (result->opretset)
767  {
768  check_srf_call_placement(pstate, last_srf, location);
769  /* ... and remember it for error checks at higher levels */
770  pstate->p_last_srf = (Node *) result;
771  }
772 
773  ReleaseSysCache(tup);
774 
775  return (Expr *) result;
776 }
777 
778 /*
779  * make_scalar_array_op()
780  * Build expression tree for "scalar op ANY/ALL (array)" construct.
781  */
782 Expr *
784  bool useOr,
785  Node *ltree, Node *rtree,
786  int location)
787 {
788  Oid ltypeId,
789  rtypeId,
790  atypeId,
791  res_atypeId;
792  Operator tup;
793  Form_pg_operator opform;
794  Oid actual_arg_types[2];
795  Oid declared_arg_types[2];
796  List *args;
797  Oid rettype;
798  ScalarArrayOpExpr *result;
799 
800  ltypeId = exprType(ltree);
801  atypeId = exprType(rtree);
802 
803  /*
804  * The right-hand input of the operator will be the element type of the
805  * array. However, if we currently have just an untyped literal on the
806  * right, stay with that and hope we can resolve the operator.
807  */
808  if (atypeId == UNKNOWNOID)
809  rtypeId = UNKNOWNOID;
810  else
811  {
812  rtypeId = get_base_element_type(atypeId);
813  if (!OidIsValid(rtypeId))
814  ereport(ERROR,
815  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
816  errmsg("op ANY/ALL (array) requires array on right side"),
817  parser_errposition(pstate, location)));
818  }
819 
820  /* Now resolve the operator */
821  tup = oper(pstate, opname, ltypeId, rtypeId, false, location);
822  opform = (Form_pg_operator) GETSTRUCT(tup);
823 
824  /* Check it's not a shell */
825  if (!RegProcedureIsValid(opform->oprcode))
826  ereport(ERROR,
827  (errcode(ERRCODE_UNDEFINED_FUNCTION),
828  errmsg("operator is only a shell: %s",
829  op_signature_string(opname,
830  opform->oprkind,
831  opform->oprleft,
832  opform->oprright)),
833  parser_errposition(pstate, location)));
834 
835  args = list_make2(ltree, rtree);
836  actual_arg_types[0] = ltypeId;
837  actual_arg_types[1] = rtypeId;
838  declared_arg_types[0] = opform->oprleft;
839  declared_arg_types[1] = opform->oprright;
840 
841  /*
842  * enforce consistency with polymorphic argument and return types,
843  * possibly adjusting return type or declared_arg_types (which will be
844  * used as the cast destination by make_fn_arguments)
845  */
846  rettype = enforce_generic_type_consistency(actual_arg_types,
847  declared_arg_types,
848  2,
849  opform->oprresult,
850  false);
851 
852  /*
853  * Check that operator result is boolean
854  */
855  if (rettype != BOOLOID)
856  ereport(ERROR,
857  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
858  errmsg("op ANY/ALL (array) requires operator to yield boolean"),
859  parser_errposition(pstate, location)));
860  if (get_func_retset(opform->oprcode))
861  ereport(ERROR,
862  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
863  errmsg("op ANY/ALL (array) requires operator not to return a set"),
864  parser_errposition(pstate, location)));
865 
866  /*
867  * Now switch back to the array type on the right, arranging for any
868  * needed cast to be applied. Beware of polymorphic operators here;
869  * enforce_generic_type_consistency may or may not have replaced a
870  * polymorphic type with a real one.
871  */
872  if (IsPolymorphicType(declared_arg_types[1]))
873  {
874  /* assume the actual array type is OK */
875  res_atypeId = atypeId;
876  }
877  else
878  {
879  res_atypeId = get_array_type(declared_arg_types[1]);
880  if (!OidIsValid(res_atypeId))
881  ereport(ERROR,
882  (errcode(ERRCODE_UNDEFINED_OBJECT),
883  errmsg("could not find array type for data type %s",
884  format_type_be(declared_arg_types[1])),
885  parser_errposition(pstate, location)));
886  }
887  actual_arg_types[1] = atypeId;
888  declared_arg_types[1] = res_atypeId;
889 
890  /* perform the necessary typecasting of arguments */
891  make_fn_arguments(pstate, args, actual_arg_types, declared_arg_types);
892 
893  /* and build the expression node */
894  result = makeNode(ScalarArrayOpExpr);
895  result->opno = oprid(tup);
896  result->opfuncid = opform->oprcode;
897  result->useOr = useOr;
898  /* inputcollid will be set by parse_collate.c */
899  result->args = args;
900  result->location = location;
901 
902  ReleaseSysCache(tup);
903 
904  return (Expr *) result;
905 }
906 
907 
908 /*
909  * Lookaside cache to speed operator lookup. Possibly this should be in
910  * a separate module under utils/cache/ ?
911  *
912  * The idea here is that the mapping from operator name and given argument
913  * types is constant for a given search path (or single specified schema OID)
914  * so long as the contents of pg_operator and pg_cast don't change. And that
915  * mapping is pretty expensive to compute, especially for ambiguous operators;
916  * this is mainly because there are a *lot* of instances of popular operator
917  * names such as "=", and we have to check each one to see which is the
918  * best match. So once we have identified the correct mapping, we save it
919  * in a cache that need only be flushed on pg_operator or pg_cast change.
920  * (pg_cast must be considered because changes in the set of implicit casts
921  * affect the set of applicable operators for any given input datatype.)
922  *
923  * XXX in principle, ALTER TABLE ... INHERIT could affect the mapping as
924  * well, but we disregard that since there's no convenient way to find out
925  * about it, and it seems a pretty far-fetched corner-case anyway.
926  *
927  * Note: at some point it might be worth doing a similar cache for function
928  * lookups. However, the potential gain is a lot less since (a) function
929  * names are generally not overloaded as heavily as operator names, and
930  * (b) we'd have to flush on pg_proc updates, which are probably a good
931  * deal more common than pg_operator updates.
932  */
933 
934 /* The operator cache hashtable */
935 static HTAB *OprCacheHash = NULL;
936 
937 
938 /*
939  * make_oper_cache_key
940  * Fill the lookup key struct given operator name and arg types.
941  *
942  * Returns true if successful, false if the search_path overflowed
943  * (hence no caching is possible).
944  *
945  * pstate/location are used only to report the error position; pass NULL/-1
946  * if not available.
947  */
948 static bool
950  Oid ltypeId, Oid rtypeId, int location)
951 {
952  char *schemaname;
953  char *opername;
954 
955  /* deconstruct the name list */
956  DeconstructQualifiedName(opname, &schemaname, &opername);
957 
958  /* ensure zero-fill for stable hashing */
959  MemSet(key, 0, sizeof(OprCacheKey));
960 
961  /* save operator name and input types into key */
962  strlcpy(key->oprname, opername, NAMEDATALEN);
963  key->left_arg = ltypeId;
964  key->right_arg = rtypeId;
965 
966  if (schemaname)
967  {
968  ParseCallbackState pcbstate;
969 
970  /* search only in exact schema given */
971  setup_parser_errposition_callback(&pcbstate, pstate, location);
972  key->search_path[0] = LookupExplicitNamespace(schemaname, false);
974  }
975  else
976  {
977  /* get the active search path */
980  return false; /* oops, didn't fit */
981  }
982 
983  return true;
984 }
985 
986 /*
987  * find_oper_cache_entry
988  *
989  * Look for a cache entry matching the given key. If found, return the
990  * contained operator OID, else return InvalidOid.
991  */
992 static Oid
994 {
995  OprCacheEntry *oprentry;
996 
997  if (OprCacheHash == NULL)
998  {
999  /* First time through: initialize the hash table */
1000  HASHCTL ctl;
1001 
1002  MemSet(&ctl, 0, sizeof(ctl));
1003  ctl.keysize = sizeof(OprCacheKey);
1004  ctl.entrysize = sizeof(OprCacheEntry);
1005  OprCacheHash = hash_create("Operator lookup cache", 256,
1006  &ctl, HASH_ELEM | HASH_BLOBS);
1007 
1008  /* Arrange to flush cache on pg_operator and pg_cast changes */
1011  (Datum) 0);
1014  (Datum) 0);
1015  }
1016 
1017  /* Look for an existing entry */
1018  oprentry = (OprCacheEntry *) hash_search(OprCacheHash,
1019  (void *) key,
1020  HASH_FIND, NULL);
1021  if (oprentry == NULL)
1022  return InvalidOid;
1023 
1024  return oprentry->opr_oid;
1025 }
1026 
1027 /*
1028  * make_oper_cache_entry
1029  *
1030  * Insert a cache entry for the given key.
1031  */
1032 static void
1034 {
1035  OprCacheEntry *oprentry;
1036 
1037  Assert(OprCacheHash != NULL);
1038 
1039  oprentry = (OprCacheEntry *) hash_search(OprCacheHash,
1040  (void *) key,
1041  HASH_ENTER, NULL);
1042  oprentry->opr_oid = opr_oid;
1043 }
1044 
1045 /*
1046  * Callback for pg_operator and pg_cast inval events
1047  */
1048 static void
1049 InvalidateOprCacheCallBack(Datum arg, int cacheid, uint32 hashvalue)
1050 {
1052  OprCacheEntry *hentry;
1053 
1054  Assert(OprCacheHash != NULL);
1055 
1056  /* Currently we just flush all entries; hard to be smarter ... */
1057  hash_seq_init(&status, OprCacheHash);
1058 
1059  while ((hentry = (OprCacheEntry *) hash_seq_search(&status)) != NULL)
1060  {
1061  if (hash_search(OprCacheHash,
1062  (void *) &hentry->key,
1063  HASH_REMOVE, NULL) == NULL)
1064  elog(ERROR, "hash table corrupted");
1065  }
1066 }
#define list_make2(x1, x2)
Definition: pg_list.h:208
Expr * make_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree, Node *last_srf, int location)
Definition: parse_oper.c:672
Oid LookupOperWithArgs(ObjectWithArgs *oper, bool noError)
Definition: parse_oper.c:145
static void InvalidateOprCacheCallBack(Datum arg, int cacheid, uint32 hashvalue)
Definition: parse_oper.c:1049
Oid enforce_generic_type_consistency(const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
Oid LookupExplicitNamespace(const char *nspname, bool missing_ok)
Definition: namespace.c:2892
int errhint(const char *fmt,...)
Definition: elog.c:1068
Expr * make_scalar_array_op(ParseState *pstate, List *opname, bool useOr, Node *ltree, Node *rtree, int location)
Definition: parse_oper.c:783
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
#define HASH_ELEM
Definition: hsearch.h:85
int func_match_argtypes(int nargs, Oid *input_typeids, FuncCandidateList raw_candidates, FuncCandidateList *candidates)
Definition: parse_func.c:910
Oid oprid(Operator op)
Definition: parse_oper.c:250
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2664
Size entrysize
Definition: hsearch.h:72
Definition: nodes.h:528
#define TYPECACHE_EQ_OPR
Definition: typcache.h:130
Oid left_arg
Definition: parse_oper.c:54
int errcode(int sqlerrcode)
Definition: elog.c:610
#define MemSet(start, val, len)
Definition: c.h:950
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
void DeconstructQualifiedName(List *names, char **nspname_p, char **objname_p)
Definition: namespace.c:2808
Oid LookupOperName(ParseState *pstate, List *opername, Oid oprleft, Oid oprright, bool noError, int location)
Definition: parse_oper.c:101
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:919
void make_fn_arguments(ParseState *pstate, List *fargs, Oid *actual_arg_types, Oid *declared_arg_types)
Definition: parse_func.c:1810
unsigned int Oid
Definition: postgres_ext.h:31
Oid oprfuncid(Operator op)
Definition: parse_oper.c:257
OprCacheKey key
Definition: parse_oper.c:62
static const char * op_signature_string(List *op, char oprkind, Oid arg1, Oid arg2)
Definition: parse_oper.c:614
#define OidIsValid(objectId)
Definition: c.h:652
int fetch_search_path_array(Oid *sarray, int sarray_len)
Definition: namespace.c:4422
#define lsecond(l)
Definition: pg_list.h:179
FuncCandidateList OpernameGetCandidates(List *names, char oprkind, bool missing_schema_ok)
Definition: namespace.c:1586
#define list_make1(x1)
Definition: pg_list.h:206
#define NAMEDATALEN
Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright)
Definition: namespace.c:1483
Definition: dynahash.c:218
Oid opresulttype
Definition: primnodes.h:518
Oid args[FLEXIBLE_ARRAY_MEMBER]
Definition: namespace.h:37
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:160
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
#define linitial(l)
Definition: pg_list.h:174
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
Operator left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
Definition: parse_oper.c:530
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
Oid search_path[MAX_CACHED_PATH_LEN]
Definition: parse_oper.c:56
struct OprCacheKey OprCacheKey
int location
Definition: primnodes.h:523
#define RegProcedureIsValid(p)
Definition: c.h:654
FuncDetailCode
Definition: parse_func.h:22
unsigned int uint32
Definition: c.h:375
static Oid find_oper_cache_entry(OprCacheKey *key)
Definition: parse_oper.c:993
#define TYPECACHE_GT_OPR
Definition: typcache.h:132
static Oid binary_oper_exact(List *opname, Oid arg1, Oid arg2)
Definition: parse_oper.c:274
struct OprCacheEntry OprCacheEntry
struct _FuncCandidateList * next
Definition: namespace.h:30
Operator compatible_oper(ParseState *pstate, List *op, Oid arg1, Oid arg2, bool noError, int location)
Definition: parse_oper.c:462
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:144
Definition: ltree.h:29
bool IsBinaryCoercible(Oid srctype, Oid targettype)
char oprname[NAMEDATALEN]
Definition: parse_oper.c:53
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1116
char * NameListToString(List *names)
Definition: namespace.c:3101
bool get_func_retset(Oid funcid)
Definition: lsyscache.c:1654
#define HASH_BLOBS
Definition: hsearch.h:86
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
Definition: inval.c:1434
Node * p_last_srf
Definition: parse_node.h:212
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:326
uintptr_t Datum
Definition: postgres.h:367
static void op_error(ParseState *pstate, List *op, char oprkind, Oid arg1, Oid arg2, FuncDetailCode fdresult, int location)
Definition: parse_oper.c:634
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1164
Oid opfuncid
Definition: primnodes.h:517
static void make_oper_cache_entry(OprCacheKey *key, Oid opr_oid)
Definition: parse_oper.c:1033
Size keysize
Definition: hsearch.h:71
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:331
#define InvalidOid
Definition: postgres_ext.h:36
#define ereport(elevel,...)
Definition: elog.h:144
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
#define makeNode(_type_)
Definition: nodes.h:576
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define Assert(condition)
Definition: c.h:746
void get_sort_group_operators(Oid argtype, bool needLT, bool needEQ, bool needGT, Oid *ltOpr, Oid *eqOpr, Oid *gtOpr, bool *isHashable)
Definition: parse_oper.c:192
static bool make_oper_cache_key(ParseState *pstate, OprCacheKey *key, List *opname, Oid ltypeId, Oid rtypeId, int location)
Definition: parse_oper.c:949
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
static int list_length(const List *l)
Definition: pg_list.h:149
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1401
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1391
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
static FuncDetailCode oper_select_candidate(int nargs, Oid *input_typeids, FuncCandidateList candidates, Oid *operOid)
Definition: parse_oper.c:324
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2709
Oid right_arg
Definition: parse_oper.c:55
FuncCandidateList func_select_candidate(int nargs, Oid *input_typeids, FuncCandidateList candidates)
Definition: parse_func.c:995
int errmsg(const char *fmt,...)
Definition: elog.c:821
Oid compatible_oper_opid(List *op, Oid arg1, Oid arg2, bool noError)
Definition: parse_oper.c:499
#define MAX_CACHED_PATH_LEN
Definition: parse_oper.c:49
#define elog(elevel,...)
Definition: elog.h:214
#define TYPECACHE_LT_OPR
Definition: typcache.h:131
void * arg
void check_srf_call_placement(ParseState *pstate, Node *last_srf, int location)
Definition: parse_func.c:2382
Oid opno
Definition: primnodes.h:516
List * args
Definition: primnodes.h:522
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition: parse_oper.c:382
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2409
Definition: pg_list.h:50
#define TYPECACHE_HASH_PROC
Definition: typcache.h:134
static HTAB * OprCacheHash
Definition: parse_oper.c:935
bool opretset
Definition: primnodes.h:519
Oid LookupTypeNameOid(ParseState *pstate, const TypeName *typeName, bool missing_ok)
Definition: parse_type.c:232