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