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