PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
lsyscache.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * lsyscache.c
4 * Convenience routines for common queries in the system catalog cache.
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * src/backend/utils/cache/lsyscache.c
11 *
12 * NOTES
13 * Eventually, the index information should go through here, too.
14 *-------------------------------------------------------------------------
15 */
16#include "postgres.h"
17
18#include "access/hash.h"
19#include "access/htup_details.h"
20#include "bootstrap/bootstrap.h"
21#include "catalog/namespace.h"
22#include "catalog/pg_am.h"
23#include "catalog/pg_amop.h"
24#include "catalog/pg_amproc.h"
25#include "catalog/pg_cast.h"
26#include "catalog/pg_class.h"
29#include "catalog/pg_index.h"
30#include "catalog/pg_language.h"
32#include "catalog/pg_opclass.h"
33#include "catalog/pg_operator.h"
34#include "catalog/pg_proc.h"
36#include "catalog/pg_range.h"
40#include "catalog/pg_type.h"
41#include "miscadmin.h"
42#include "nodes/makefuncs.h"
43#include "utils/array.h"
44#include "utils/builtins.h"
45#include "utils/catcache.h"
46#include "utils/datum.h"
47#include "utils/fmgroids.h"
48#include "utils/lsyscache.h"
49#include "utils/syscache.h"
50#include "utils/typcache.h"
51
52/* Hook for plugins to get control in get_attavgwidth() */
54
55
56/* ---------- AMOP CACHES ---------- */
57
58/*
59 * op_in_opfamily
60 *
61 * Return t iff operator 'opno' is in operator family 'opfamily'.
62 *
63 * This function only considers search operators, not ordering operators.
64 */
65bool
66op_in_opfamily(Oid opno, Oid opfamily)
67{
68 return SearchSysCacheExists3(AMOPOPID,
69 ObjectIdGetDatum(opno),
70 CharGetDatum(AMOP_SEARCH),
71 ObjectIdGetDatum(opfamily));
72}
73
74/*
75 * get_op_opfamily_strategy
76 *
77 * Get the operator's strategy number within the specified opfamily,
78 * or 0 if it's not a member of the opfamily.
79 *
80 * This function only considers search operators, not ordering operators.
81 */
82int
84{
85 HeapTuple tp;
86 Form_pg_amop amop_tup;
87 int result;
88
89 tp = SearchSysCache3(AMOPOPID,
90 ObjectIdGetDatum(opno),
91 CharGetDatum(AMOP_SEARCH),
92 ObjectIdGetDatum(opfamily));
93 if (!HeapTupleIsValid(tp))
94 return 0;
95 amop_tup = (Form_pg_amop) GETSTRUCT(tp);
96 result = amop_tup->amopstrategy;
98 return result;
99}
100
101/*
102 * get_op_opfamily_sortfamily
103 *
104 * If the operator is an ordering operator within the specified opfamily,
105 * return its amopsortfamily OID; else return InvalidOid.
106 */
107Oid
109{
110 HeapTuple tp;
111 Form_pg_amop amop_tup;
112 Oid result;
113
114 tp = SearchSysCache3(AMOPOPID,
115 ObjectIdGetDatum(opno),
116 CharGetDatum(AMOP_ORDER),
117 ObjectIdGetDatum(opfamily));
118 if (!HeapTupleIsValid(tp))
119 return InvalidOid;
120 amop_tup = (Form_pg_amop) GETSTRUCT(tp);
121 result = amop_tup->amopsortfamily;
122 ReleaseSysCache(tp);
123 return result;
124}
125
126/*
127 * get_op_opfamily_properties
128 *
129 * Get the operator's strategy number and declared input data types
130 * within the specified opfamily.
131 *
132 * Caller should already have verified that opno is a member of opfamily,
133 * therefore we raise an error if the tuple is not found.
134 */
135void
136get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op,
137 int *strategy,
138 Oid *lefttype,
139 Oid *righttype)
140{
141 HeapTuple tp;
142 Form_pg_amop amop_tup;
143
144 tp = SearchSysCache3(AMOPOPID,
145 ObjectIdGetDatum(opno),
146 CharGetDatum(ordering_op ? AMOP_ORDER : AMOP_SEARCH),
147 ObjectIdGetDatum(opfamily));
148 if (!HeapTupleIsValid(tp))
149 elog(ERROR, "operator %u is not a member of opfamily %u",
150 opno, opfamily);
151 amop_tup = (Form_pg_amop) GETSTRUCT(tp);
152 *strategy = amop_tup->amopstrategy;
153 *lefttype = amop_tup->amoplefttype;
154 *righttype = amop_tup->amoprighttype;
155 ReleaseSysCache(tp);
156}
157
158/*
159 * get_opfamily_member
160 * Get the OID of the operator that implements the specified strategy
161 * with the specified datatypes for the specified opfamily.
162 *
163 * Returns InvalidOid if there is no pg_amop entry for the given keys.
164 */
165Oid
166get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype,
167 int16 strategy)
168{
169 HeapTuple tp;
170 Form_pg_amop amop_tup;
171 Oid result;
172
173 tp = SearchSysCache4(AMOPSTRATEGY,
174 ObjectIdGetDatum(opfamily),
175 ObjectIdGetDatum(lefttype),
176 ObjectIdGetDatum(righttype),
177 Int16GetDatum(strategy));
178 if (!HeapTupleIsValid(tp))
179 return InvalidOid;
180 amop_tup = (Form_pg_amop) GETSTRUCT(tp);
181 result = amop_tup->amopopr;
182 ReleaseSysCache(tp);
183 return result;
184}
185
186/*
187 * get_ordering_op_properties
188 * Given the OID of an ordering operator (a btree "<" or ">" operator),
189 * determine its opfamily, its declared input datatype, and its
190 * strategy number (BTLessStrategyNumber or BTGreaterStrategyNumber).
191 *
192 * Returns true if successful, false if no matching pg_amop entry exists.
193 * (This indicates that the operator is not a valid ordering operator.)
194 *
195 * Note: the operator could be registered in multiple families, for example
196 * if someone were to build a "reverse sort" opfamily. This would result in
197 * uncertainty as to whether "ORDER BY USING op" would default to NULLS FIRST
198 * or NULLS LAST, as well as inefficient planning due to failure to match up
199 * pathkeys that should be the same. So we want a determinate result here.
200 * Because of the way the syscache search works, we'll use the interpretation
201 * associated with the opfamily with smallest OID, which is probably
202 * determinate enough. Since there is no longer any particularly good reason
203 * to build reverse-sort opfamilies, it doesn't seem worth expending any
204 * additional effort on ensuring consistency.
205 */
206bool
208 Oid *opfamily, Oid *opcintype, int16 *strategy)
209{
210 bool result = false;
211 CatCList *catlist;
212 int i;
213
214 /* ensure outputs are initialized on failure */
215 *opfamily = InvalidOid;
216 *opcintype = InvalidOid;
217 *strategy = 0;
218
219 /*
220 * Search pg_amop to see if the target operator is registered as the "<"
221 * or ">" operator of any btree opfamily.
222 */
223 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
224
225 for (i = 0; i < catlist->n_members; i++)
226 {
227 HeapTuple tuple = &catlist->members[i]->tuple;
228 Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
229
230 /* must be btree */
231 if (aform->amopmethod != BTREE_AM_OID)
232 continue;
233
234 if (aform->amopstrategy == BTLessStrategyNumber ||
235 aform->amopstrategy == BTGreaterStrategyNumber)
236 {
237 /* Found it ... should have consistent input types */
238 if (aform->amoplefttype == aform->amoprighttype)
239 {
240 /* Found a suitable opfamily, return info */
241 *opfamily = aform->amopfamily;
242 *opcintype = aform->amoplefttype;
243 *strategy = aform->amopstrategy;
244 result = true;
245 break;
246 }
247 }
248 }
249
250 ReleaseSysCacheList(catlist);
251
252 return result;
253}
254
255/*
256 * get_equality_op_for_ordering_op
257 * Get the OID of the datatype-specific btree equality operator
258 * associated with an ordering operator (a "<" or ">" operator).
259 *
260 * If "reverse" isn't NULL, also set *reverse to false if the operator is "<",
261 * true if it's ">"
262 *
263 * Returns InvalidOid if no matching equality operator can be found.
264 * (This indicates that the operator is not a valid ordering operator.)
265 */
266Oid
268{
269 Oid result = InvalidOid;
270 Oid opfamily;
271 Oid opcintype;
272 int16 strategy;
273
274 /* Find the operator in pg_amop */
276 &opfamily, &opcintype, &strategy))
277 {
278 /* Found a suitable opfamily, get matching equality operator */
279 result = get_opfamily_member(opfamily,
280 opcintype,
281 opcintype,
283 if (reverse)
284 *reverse = (strategy == BTGreaterStrategyNumber);
285 }
286
287 return result;
288}
289
290/*
291 * get_ordering_op_for_equality_op
292 * Get the OID of a datatype-specific btree "less than" ordering operator
293 * associated with an equality operator. (If there are multiple
294 * possibilities, assume any one will do.)
295 *
296 * This function is used when we have to sort data before unique-ifying,
297 * and don't much care which sorting op is used as long as it's compatible
298 * with the intended equality operator. Since we need a sorting operator,
299 * it should be single-data-type even if the given operator is cross-type.
300 * The caller specifies whether to find an op for the LHS or RHS data type.
301 *
302 * Returns InvalidOid if no matching ordering operator can be found.
303 */
304Oid
305get_ordering_op_for_equality_op(Oid opno, bool use_lhs_type)
306{
307 Oid result = InvalidOid;
308 CatCList *catlist;
309 int i;
310
311 /*
312 * Search pg_amop to see if the target operator is registered as the "="
313 * operator of any btree opfamily.
314 */
315 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
316
317 for (i = 0; i < catlist->n_members; i++)
318 {
319 HeapTuple tuple = &catlist->members[i]->tuple;
320 Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
321
322 /* must be btree */
323 if (aform->amopmethod != BTREE_AM_OID)
324 continue;
325
326 if (aform->amopstrategy == BTEqualStrategyNumber)
327 {
328 /* Found a suitable opfamily, get matching ordering operator */
329 Oid typid;
330
331 typid = use_lhs_type ? aform->amoplefttype : aform->amoprighttype;
332 result = get_opfamily_member(aform->amopfamily,
333 typid, typid,
335 if (OidIsValid(result))
336 break;
337 /* failure probably shouldn't happen, but keep looking if so */
338 }
339 }
340
341 ReleaseSysCacheList(catlist);
342
343 return result;
344}
345
346/*
347 * get_mergejoin_opfamilies
348 * Given a putatively mergejoinable operator, return a list of the OIDs
349 * of the btree opfamilies in which it represents equality.
350 *
351 * It is possible (though at present unusual) for an operator to be equality
352 * in more than one opfamily, hence the result is a list. This also lets us
353 * return NIL if the operator is not found in any opfamilies.
354 *
355 * The planner currently uses simple equal() tests to compare the lists
356 * returned by this function, which makes the list order relevant, though
357 * strictly speaking it should not be. Because of the way syscache list
358 * searches are handled, in normal operation the result will be sorted by OID
359 * so everything works fine. If running with system index usage disabled,
360 * the result ordering is unspecified and hence the planner might fail to
361 * recognize optimization opportunities ... but that's hardly a scenario in
362 * which performance is good anyway, so there's no point in expending code
363 * or cycles here to guarantee the ordering in that case.
364 */
365List *
367{
368 List *result = NIL;
369 CatCList *catlist;
370 int i;
371
372 /*
373 * Search pg_amop to see if the target operator is registered as the "="
374 * operator of any btree opfamily.
375 */
376 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
377
378 for (i = 0; i < catlist->n_members; i++)
379 {
380 HeapTuple tuple = &catlist->members[i]->tuple;
381 Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
382
383 /* must be btree equality */
384 if (aform->amopmethod == BTREE_AM_OID &&
385 aform->amopstrategy == BTEqualStrategyNumber)
386 result = lappend_oid(result, aform->amopfamily);
387 }
388
389 ReleaseSysCacheList(catlist);
390
391 return result;
392}
393
394/*
395 * get_compatible_hash_operators
396 * Get the OID(s) of hash equality operator(s) compatible with the given
397 * operator, but operating on its LHS and/or RHS datatype.
398 *
399 * An operator for the LHS type is sought and returned into *lhs_opno if
400 * lhs_opno isn't NULL. Similarly, an operator for the RHS type is sought
401 * and returned into *rhs_opno if rhs_opno isn't NULL.
402 *
403 * If the given operator is not cross-type, the results should be the same
404 * operator, but in cross-type situations they will be different.
405 *
406 * Returns true if able to find the requested operator(s), false if not.
407 * (This indicates that the operator should not have been marked oprcanhash.)
408 */
409bool
411 Oid *lhs_opno, Oid *rhs_opno)
412{
413 bool result = false;
414 CatCList *catlist;
415 int i;
416
417 /* Ensure output args are initialized on failure */
418 if (lhs_opno)
419 *lhs_opno = InvalidOid;
420 if (rhs_opno)
421 *rhs_opno = InvalidOid;
422
423 /*
424 * Search pg_amop to see if the target operator is registered as the "="
425 * operator of any hash opfamily. If the operator is registered in
426 * multiple opfamilies, assume we can use any one.
427 */
428 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
429
430 for (i = 0; i < catlist->n_members; i++)
431 {
432 HeapTuple tuple = &catlist->members[i]->tuple;
433 Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
434
435 if (aform->amopmethod == HASH_AM_OID &&
436 aform->amopstrategy == HTEqualStrategyNumber)
437 {
438 /* No extra lookup needed if given operator is single-type */
439 if (aform->amoplefttype == aform->amoprighttype)
440 {
441 if (lhs_opno)
442 *lhs_opno = opno;
443 if (rhs_opno)
444 *rhs_opno = opno;
445 result = true;
446 break;
447 }
448
449 /*
450 * Get the matching single-type operator(s). Failure probably
451 * shouldn't happen --- it implies a bogus opfamily --- but
452 * continue looking if so.
453 */
454 if (lhs_opno)
455 {
456 *lhs_opno = get_opfamily_member(aform->amopfamily,
457 aform->amoplefttype,
458 aform->amoplefttype,
460 if (!OidIsValid(*lhs_opno))
461 continue;
462 /* Matching LHS found, done if caller doesn't want RHS */
463 if (!rhs_opno)
464 {
465 result = true;
466 break;
467 }
468 }
469 if (rhs_opno)
470 {
471 *rhs_opno = get_opfamily_member(aform->amopfamily,
472 aform->amoprighttype,
473 aform->amoprighttype,
475 if (!OidIsValid(*rhs_opno))
476 {
477 /* Forget any LHS operator from this opfamily */
478 if (lhs_opno)
479 *lhs_opno = InvalidOid;
480 continue;
481 }
482 /* Matching RHS found, so done */
483 result = true;
484 break;
485 }
486 }
487 }
488
489 ReleaseSysCacheList(catlist);
490
491 return result;
492}
493
494/*
495 * get_op_hash_functions
496 * Get the OID(s) of the standard hash support function(s) compatible with
497 * the given operator, operating on its LHS and/or RHS datatype as required.
498 *
499 * A function for the LHS type is sought and returned into *lhs_procno if
500 * lhs_procno isn't NULL. Similarly, a function for the RHS type is sought
501 * and returned into *rhs_procno if rhs_procno isn't NULL.
502 *
503 * If the given operator is not cross-type, the results should be the same
504 * function, but in cross-type situations they will be different.
505 *
506 * Returns true if able to find the requested function(s), false if not.
507 * (This indicates that the operator should not have been marked oprcanhash.)
508 */
509bool
511 RegProcedure *lhs_procno, RegProcedure *rhs_procno)
512{
513 bool result = false;
514 CatCList *catlist;
515 int i;
516
517 /* Ensure output args are initialized on failure */
518 if (lhs_procno)
519 *lhs_procno = InvalidOid;
520 if (rhs_procno)
521 *rhs_procno = InvalidOid;
522
523 /*
524 * Search pg_amop to see if the target operator is registered as the "="
525 * operator of any hash opfamily. If the operator is registered in
526 * multiple opfamilies, assume we can use any one.
527 */
528 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
529
530 for (i = 0; i < catlist->n_members; i++)
531 {
532 HeapTuple tuple = &catlist->members[i]->tuple;
533 Form_pg_amop aform = (Form_pg_amop) GETSTRUCT(tuple);
534
535 if (aform->amopmethod == HASH_AM_OID &&
536 aform->amopstrategy == HTEqualStrategyNumber)
537 {
538 /*
539 * Get the matching support function(s). Failure probably
540 * shouldn't happen --- it implies a bogus opfamily --- but
541 * continue looking if so.
542 */
543 if (lhs_procno)
544 {
545 *lhs_procno = get_opfamily_proc(aform->amopfamily,
546 aform->amoplefttype,
547 aform->amoplefttype,
549 if (!OidIsValid(*lhs_procno))
550 continue;
551 /* Matching LHS found, done if caller doesn't want RHS */
552 if (!rhs_procno)
553 {
554 result = true;
555 break;
556 }
557 /* Only one lookup needed if given operator is single-type */
558 if (aform->amoplefttype == aform->amoprighttype)
559 {
560 *rhs_procno = *lhs_procno;
561 result = true;
562 break;
563 }
564 }
565 if (rhs_procno)
566 {
567 *rhs_procno = get_opfamily_proc(aform->amopfamily,
568 aform->amoprighttype,
569 aform->amoprighttype,
571 if (!OidIsValid(*rhs_procno))
572 {
573 /* Forget any LHS function from this opfamily */
574 if (lhs_procno)
575 *lhs_procno = InvalidOid;
576 continue;
577 }
578 /* Matching RHS found, so done */
579 result = true;
580 break;
581 }
582 }
583 }
584
585 ReleaseSysCacheList(catlist);
586
587 return result;
588}
589
590/*
591 * get_op_btree_interpretation
592 * Given an operator's OID, find out which btree opfamilies it belongs to,
593 * and what properties it has within each one. The results are returned
594 * as a palloc'd list of OpBtreeInterpretation structs.
595 *
596 * In addition to the normal btree operators, we consider a <> operator to be
597 * a "member" of an opfamily if its negator is an equality operator of the
598 * opfamily. ROWCOMPARE_NE is returned as the strategy number for this case.
599 */
600List *
602{
603 List *result = NIL;
604 OpBtreeInterpretation *thisresult;
605 CatCList *catlist;
606 int i;
607
608 /*
609 * Find all the pg_amop entries containing the operator.
610 */
611 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno));
612
613 for (i = 0; i < catlist->n_members; i++)
614 {
615 HeapTuple op_tuple = &catlist->members[i]->tuple;
616 Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
617 StrategyNumber op_strategy;
618
619 /* must be btree */
620 if (op_form->amopmethod != BTREE_AM_OID)
621 continue;
622
623 /* Get the operator's btree strategy number */
624 op_strategy = (StrategyNumber) op_form->amopstrategy;
625 Assert(op_strategy >= 1 && op_strategy <= 5);
626
627 thisresult = (OpBtreeInterpretation *)
629 thisresult->opfamily_id = op_form->amopfamily;
630 thisresult->strategy = op_strategy;
631 thisresult->oplefttype = op_form->amoplefttype;
632 thisresult->oprighttype = op_form->amoprighttype;
633 result = lappend(result, thisresult);
634 }
635
636 ReleaseSysCacheList(catlist);
637
638 /*
639 * If we didn't find any btree opfamily containing the operator, perhaps
640 * it is a <> operator. See if it has a negator that is in an opfamily.
641 */
642 if (result == NIL)
643 {
644 Oid op_negator = get_negator(opno);
645
646 if (OidIsValid(op_negator))
647 {
648 catlist = SearchSysCacheList1(AMOPOPID,
649 ObjectIdGetDatum(op_negator));
650
651 for (i = 0; i < catlist->n_members; i++)
652 {
653 HeapTuple op_tuple = &catlist->members[i]->tuple;
654 Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
655 StrategyNumber op_strategy;
656
657 /* must be btree */
658 if (op_form->amopmethod != BTREE_AM_OID)
659 continue;
660
661 /* Get the operator's btree strategy number */
662 op_strategy = (StrategyNumber) op_form->amopstrategy;
663 Assert(op_strategy >= 1 && op_strategy <= 5);
664
665 /* Only consider negators that are = */
666 if (op_strategy != BTEqualStrategyNumber)
667 continue;
668
669 /* OK, report it with "strategy" ROWCOMPARE_NE */
670 thisresult = (OpBtreeInterpretation *)
672 thisresult->opfamily_id = op_form->amopfamily;
673 thisresult->strategy = ROWCOMPARE_NE;
674 thisresult->oplefttype = op_form->amoplefttype;
675 thisresult->oprighttype = op_form->amoprighttype;
676 result = lappend(result, thisresult);
677 }
678
679 ReleaseSysCacheList(catlist);
680 }
681 }
682
683 return result;
684}
685
686/*
687 * equality_ops_are_compatible
688 * Return true if the two given equality operators have compatible
689 * semantics.
690 *
691 * This is trivially true if they are the same operator. Otherwise,
692 * we look to see if they can be found in the same btree or hash opfamily.
693 * Either finding allows us to assume that they have compatible notions
694 * of equality. (The reason we need to do these pushups is that one might
695 * be a cross-type operator; for instance int24eq vs int4eq.)
696 */
697bool
699{
700 bool result;
701 CatCList *catlist;
702 int i;
703
704 /* Easy if they're the same operator */
705 if (opno1 == opno2)
706 return true;
707
708 /*
709 * We search through all the pg_amop entries for opno1.
710 */
711 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno1));
712
713 result = false;
714 for (i = 0; i < catlist->n_members; i++)
715 {
716 HeapTuple op_tuple = &catlist->members[i]->tuple;
717 Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
718
719 /* must be btree or hash */
720 if (op_form->amopmethod == BTREE_AM_OID ||
721 op_form->amopmethod == HASH_AM_OID)
722 {
723 if (op_in_opfamily(opno2, op_form->amopfamily))
724 {
725 result = true;
726 break;
727 }
728 }
729 }
730
731 ReleaseSysCacheList(catlist);
732
733 return result;
734}
735
736/*
737 * comparison_ops_are_compatible
738 * Return true if the two given comparison operators have compatible
739 * semantics.
740 *
741 * This is trivially true if they are the same operator. Otherwise,
742 * we look to see if they can be found in the same btree opfamily.
743 * For example, '<' and '>=' ops match if they belong to the same family.
744 *
745 * (This is identical to equality_ops_are_compatible(), except that we
746 * don't bother to examine hash opclasses.)
747 */
748bool
750{
751 bool result;
752 CatCList *catlist;
753 int i;
754
755 /* Easy if they're the same operator */
756 if (opno1 == opno2)
757 return true;
758
759 /*
760 * We search through all the pg_amop entries for opno1.
761 */
762 catlist = SearchSysCacheList1(AMOPOPID, ObjectIdGetDatum(opno1));
763
764 result = false;
765 for (i = 0; i < catlist->n_members; i++)
766 {
767 HeapTuple op_tuple = &catlist->members[i]->tuple;
768 Form_pg_amop op_form = (Form_pg_amop) GETSTRUCT(op_tuple);
769
770 if (op_form->amopmethod == BTREE_AM_OID)
771 {
772 if (op_in_opfamily(opno2, op_form->amopfamily))
773 {
774 result = true;
775 break;
776 }
777 }
778 }
779
780 ReleaseSysCacheList(catlist);
781
782 return result;
783}
784
785
786/* ---------- AMPROC CACHES ---------- */
787
788/*
789 * get_opfamily_proc
790 * Get the OID of the specified support function
791 * for the specified opfamily and datatypes.
792 *
793 * Returns InvalidOid if there is no pg_amproc entry for the given keys.
794 */
795Oid
796get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
797{
798 HeapTuple tp;
799 Form_pg_amproc amproc_tup;
800 RegProcedure result;
801
802 tp = SearchSysCache4(AMPROCNUM,
803 ObjectIdGetDatum(opfamily),
804 ObjectIdGetDatum(lefttype),
805 ObjectIdGetDatum(righttype),
806 Int16GetDatum(procnum));
807 if (!HeapTupleIsValid(tp))
808 return InvalidOid;
809 amproc_tup = (Form_pg_amproc) GETSTRUCT(tp);
810 result = amproc_tup->amproc;
811 ReleaseSysCache(tp);
812 return result;
813}
814
815
816/* ---------- ATTRIBUTE CACHES ---------- */
817
818/*
819 * get_attname
820 * Given the relation id and the attribute number, return the "attname"
821 * field from the attribute relation as a palloc'ed string.
822 *
823 * If no such attribute exists and missing_ok is true, NULL is returned;
824 * otherwise a not-intended-for-user-consumption error is thrown.
825 */
826char *
827get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
828{
829 HeapTuple tp;
830
831 tp = SearchSysCache2(ATTNUM,
833 if (HeapTupleIsValid(tp))
834 {
836 char *result;
837
838 result = pstrdup(NameStr(att_tup->attname));
839 ReleaseSysCache(tp);
840 return result;
841 }
842
843 if (!missing_ok)
844 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
845 attnum, relid);
846 return NULL;
847}
848
849/*
850 * get_attnum
851 *
852 * Given the relation id and the attribute name,
853 * return the "attnum" field from the attribute relation.
854 *
855 * Returns InvalidAttrNumber if the attr doesn't exist (or is dropped).
856 */
858get_attnum(Oid relid, const char *attname)
859{
860 HeapTuple tp;
861
862 tp = SearchSysCacheAttName(relid, attname);
863 if (HeapTupleIsValid(tp))
864 {
866 AttrNumber result;
867
868 result = att_tup->attnum;
869 ReleaseSysCache(tp);
870 return result;
871 }
872 else
873 return InvalidAttrNumber;
874}
875
876/*
877 * get_attgenerated
878 *
879 * Given the relation id and the attribute number,
880 * return the "attgenerated" field from the attribute relation.
881 *
882 * Errors if not found.
883 *
884 * Since not generated is represented by '\0', this can also be used as a
885 * Boolean test.
886 */
887char
889{
890 HeapTuple tp;
891 Form_pg_attribute att_tup;
892 char result;
893
894 tp = SearchSysCache2(ATTNUM,
895 ObjectIdGetDatum(relid),
897 if (!HeapTupleIsValid(tp))
898 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
899 attnum, relid);
900 att_tup = (Form_pg_attribute) GETSTRUCT(tp);
901 result = att_tup->attgenerated;
902 ReleaseSysCache(tp);
903 return result;
904}
905
906/*
907 * get_atttype
908 *
909 * Given the relation OID and the attribute number with the relation,
910 * return the attribute type OID.
911 */
912Oid
914{
915 HeapTuple tp;
916
917 tp = SearchSysCache2(ATTNUM,
918 ObjectIdGetDatum(relid),
920 if (HeapTupleIsValid(tp))
921 {
923 Oid result;
924
925 result = att_tup->atttypid;
926 ReleaseSysCache(tp);
927 return result;
928 }
929 else
930 return InvalidOid;
931}
932
933/*
934 * get_atttypetypmodcoll
935 *
936 * A three-fer: given the relation id and the attribute number,
937 * fetch atttypid, atttypmod, and attcollation in a single cache lookup.
938 *
939 * Unlike the otherwise-similar get_atttype, this routine
940 * raises an error if it can't obtain the information.
941 */
942void
944 Oid *typid, int32 *typmod, Oid *collid)
945{
946 HeapTuple tp;
947 Form_pg_attribute att_tup;
948
949 tp = SearchSysCache2(ATTNUM,
950 ObjectIdGetDatum(relid),
952 if (!HeapTupleIsValid(tp))
953 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
954 attnum, relid);
955 att_tup = (Form_pg_attribute) GETSTRUCT(tp);
956
957 *typid = att_tup->atttypid;
958 *typmod = att_tup->atttypmod;
959 *collid = att_tup->attcollation;
960 ReleaseSysCache(tp);
961}
962
963/*
964 * get_attoptions
965 *
966 * Given the relation id and the attribute number,
967 * return the attribute options text[] datum, if any.
968 */
969Datum
971{
972 HeapTuple tuple;
973 Datum attopts;
974 Datum result;
975 bool isnull;
976
977 tuple = SearchSysCache2(ATTNUM,
978 ObjectIdGetDatum(relid),
980
981 if (!HeapTupleIsValid(tuple))
982 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
983 attnum, relid);
984
985 attopts = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions,
986 &isnull);
987
988 if (isnull)
989 result = (Datum) 0;
990 else
991 result = datumCopy(attopts, false, -1); /* text[] */
992
993 ReleaseSysCache(tuple);
994
995 return result;
996}
997
998/* ---------- PG_CAST CACHE ---------- */
999
1000/*
1001 * get_cast_oid - given two type OIDs, look up a cast OID
1002 *
1003 * If missing_ok is false, throw an error if the cast is not found. If
1004 * true, just return InvalidOid.
1005 */
1006Oid
1007get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok)
1008{
1009 Oid oid;
1010
1011 oid = GetSysCacheOid2(CASTSOURCETARGET, Anum_pg_cast_oid,
1012 ObjectIdGetDatum(sourcetypeid),
1013 ObjectIdGetDatum(targettypeid));
1014 if (!OidIsValid(oid) && !missing_ok)
1015 ereport(ERROR,
1016 (errcode(ERRCODE_UNDEFINED_OBJECT),
1017 errmsg("cast from type %s to type %s does not exist",
1018 format_type_be(sourcetypeid),
1019 format_type_be(targettypeid))));
1020 return oid;
1021}
1022
1023/* ---------- COLLATION CACHE ---------- */
1024
1025/*
1026 * get_collation_name
1027 * Returns the name of a given pg_collation entry.
1028 *
1029 * Returns a palloc'd copy of the string, or NULL if no such collation.
1030 *
1031 * NOTE: since collation name is not unique, be wary of code that uses this
1032 * for anything except preparing error messages.
1033 */
1034char *
1036{
1037 HeapTuple tp;
1038
1039 tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(colloid));
1040 if (HeapTupleIsValid(tp))
1041 {
1043 char *result;
1044
1045 result = pstrdup(NameStr(colltup->collname));
1046 ReleaseSysCache(tp);
1047 return result;
1048 }
1049 else
1050 return NULL;
1051}
1052
1053bool
1055{
1056 HeapTuple tp;
1057 Form_pg_collation colltup;
1058 bool result;
1059
1060 tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(colloid));
1061 if (!HeapTupleIsValid(tp))
1062 elog(ERROR, "cache lookup failed for collation %u", colloid);
1063 colltup = (Form_pg_collation) GETSTRUCT(tp);
1064 result = colltup->collisdeterministic;
1065 ReleaseSysCache(tp);
1066 return result;
1067}
1068
1069/* ---------- CONSTRAINT CACHE ---------- */
1070
1071/*
1072 * get_constraint_name
1073 * Returns the name of a given pg_constraint entry.
1074 *
1075 * Returns a palloc'd copy of the string, or NULL if no such constraint.
1076 *
1077 * NOTE: since constraint name is not unique, be wary of code that uses this
1078 * for anything except preparing error messages.
1079 */
1080char *
1082{
1083 HeapTuple tp;
1084
1085 tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
1086 if (HeapTupleIsValid(tp))
1087 {
1089 char *result;
1090
1091 result = pstrdup(NameStr(contup->conname));
1092 ReleaseSysCache(tp);
1093 return result;
1094 }
1095 else
1096 return NULL;
1097}
1098
1099/*
1100 * get_constraint_index
1101 * Given the OID of a unique, primary-key, or exclusion constraint,
1102 * return the OID of the underlying index.
1103 *
1104 * Returns InvalidOid if the constraint could not be found or is of
1105 * the wrong type.
1106 *
1107 * The intent of this function is to return the index "owned" by the
1108 * specified constraint. Therefore we must check contype, since some
1109 * pg_constraint entries (e.g. for foreign-key constraints) store the
1110 * OID of an index that is referenced but not owned by the constraint.
1111 */
1112Oid
1114{
1115 HeapTuple tp;
1116
1117 tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
1118 if (HeapTupleIsValid(tp))
1119 {
1121 Oid result;
1122
1123 if (contup->contype == CONSTRAINT_UNIQUE ||
1124 contup->contype == CONSTRAINT_PRIMARY ||
1125 contup->contype == CONSTRAINT_EXCLUSION)
1126 result = contup->conindid;
1127 else
1128 result = InvalidOid;
1129 ReleaseSysCache(tp);
1130 return result;
1131 }
1132 else
1133 return InvalidOid;
1134}
1135
1136/*
1137 * get_constraint_type
1138 * Return the pg_constraint.contype value for the given constraint.
1139 *
1140 * No frills.
1141 */
1142char
1144{
1145 HeapTuple tp;
1146 char contype;
1147
1148 tp = SearchSysCache1(CONSTROID, ObjectIdGetDatum(conoid));
1149 if (!HeapTupleIsValid(tp))
1150 elog(ERROR, "cache lookup failed for constraint %u", conoid);
1151
1152 contype = ((Form_pg_constraint) GETSTRUCT(tp))->contype;
1153 ReleaseSysCache(tp);
1154
1155 return contype;
1156}
1157
1158/* ---------- LANGUAGE CACHE ---------- */
1159
1160char *
1161get_language_name(Oid langoid, bool missing_ok)
1162{
1163 HeapTuple tp;
1164
1165 tp = SearchSysCache1(LANGOID, ObjectIdGetDatum(langoid));
1166 if (HeapTupleIsValid(tp))
1167 {
1169 char *result;
1170
1171 result = pstrdup(NameStr(lantup->lanname));
1172 ReleaseSysCache(tp);
1173 return result;
1174 }
1175
1176 if (!missing_ok)
1177 elog(ERROR, "cache lookup failed for language %u",
1178 langoid);
1179 return NULL;
1180}
1181
1182/* ---------- OPCLASS CACHE ---------- */
1183
1184/*
1185 * get_opclass_family
1186 *
1187 * Returns the OID of the operator family the opclass belongs to.
1188 */
1189Oid
1191{
1192 HeapTuple tp;
1193 Form_pg_opclass cla_tup;
1194 Oid result;
1195
1196 tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
1197 if (!HeapTupleIsValid(tp))
1198 elog(ERROR, "cache lookup failed for opclass %u", opclass);
1199 cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
1200
1201 result = cla_tup->opcfamily;
1202 ReleaseSysCache(tp);
1203 return result;
1204}
1205
1206/*
1207 * get_opclass_input_type
1208 *
1209 * Returns the OID of the datatype the opclass indexes.
1210 */
1211Oid
1213{
1214 HeapTuple tp;
1215 Form_pg_opclass cla_tup;
1216 Oid result;
1217
1218 tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
1219 if (!HeapTupleIsValid(tp))
1220 elog(ERROR, "cache lookup failed for opclass %u", opclass);
1221 cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
1222
1223 result = cla_tup->opcintype;
1224 ReleaseSysCache(tp);
1225 return result;
1226}
1227
1228/*
1229 * get_opclass_opfamily_and_input_type
1230 *
1231 * Returns the OID of the operator family the opclass belongs to,
1232 * the OID of the datatype the opclass indexes
1233 */
1234bool
1235get_opclass_opfamily_and_input_type(Oid opclass, Oid *opfamily, Oid *opcintype)
1236{
1237 HeapTuple tp;
1238 Form_pg_opclass cla_tup;
1239
1240 tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
1241 if (!HeapTupleIsValid(tp))
1242 return false;
1243
1244 cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
1245
1246 *opfamily = cla_tup->opcfamily;
1247 *opcintype = cla_tup->opcintype;
1248
1249 ReleaseSysCache(tp);
1250
1251 return true;
1252}
1253
1254/*
1255 * get_opclass_method
1256 *
1257 * Returns the OID of the index access method the opclass belongs to.
1258 */
1259Oid
1261{
1262 HeapTuple tp;
1263 Form_pg_opclass cla_tup;
1264 Oid result;
1265
1266 tp = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
1267 if (!HeapTupleIsValid(tp))
1268 elog(ERROR, "cache lookup failed for opclass %u", opclass);
1269 cla_tup = (Form_pg_opclass) GETSTRUCT(tp);
1270
1271 result = cla_tup->opcmethod;
1272 ReleaseSysCache(tp);
1273 return result;
1274}
1275
1276/* ---------- OPERATOR CACHE ---------- */
1277
1278/*
1279 * get_opcode
1280 *
1281 * Returns the regproc id of the routine used to implement an
1282 * operator given the operator oid.
1283 */
1286{
1287 HeapTuple tp;
1288
1289 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1290 if (HeapTupleIsValid(tp))
1291 {
1293 RegProcedure result;
1294
1295 result = optup->oprcode;
1296 ReleaseSysCache(tp);
1297 return result;
1298 }
1299 else
1300 return (RegProcedure) InvalidOid;
1301}
1302
1303/*
1304 * get_opname
1305 * returns the name of the operator with the given opno
1306 *
1307 * Note: returns a palloc'd copy of the string, or NULL if no such operator.
1308 */
1309char *
1311{
1312 HeapTuple tp;
1313
1314 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1315 if (HeapTupleIsValid(tp))
1316 {
1318 char *result;
1319
1320 result = pstrdup(NameStr(optup->oprname));
1321 ReleaseSysCache(tp);
1322 return result;
1323 }
1324 else
1325 return NULL;
1326}
1327
1328/*
1329 * get_op_rettype
1330 * Given operator oid, return the operator's result type.
1331 */
1332Oid
1334{
1335 HeapTuple tp;
1336
1337 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1338 if (HeapTupleIsValid(tp))
1339 {
1341 Oid result;
1342
1343 result = optup->oprresult;
1344 ReleaseSysCache(tp);
1345 return result;
1346 }
1347 else
1348 return InvalidOid;
1349}
1350
1351/*
1352 * op_input_types
1353 *
1354 * Returns the left and right input datatypes for an operator
1355 * (InvalidOid if not relevant).
1356 */
1357void
1358op_input_types(Oid opno, Oid *lefttype, Oid *righttype)
1359{
1360 HeapTuple tp;
1361 Form_pg_operator optup;
1362
1363 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1364 if (!HeapTupleIsValid(tp)) /* shouldn't happen */
1365 elog(ERROR, "cache lookup failed for operator %u", opno);
1366 optup = (Form_pg_operator) GETSTRUCT(tp);
1367 *lefttype = optup->oprleft;
1368 *righttype = optup->oprright;
1369 ReleaseSysCache(tp);
1370}
1371
1372/*
1373 * op_mergejoinable
1374 *
1375 * Returns true if the operator is potentially mergejoinable. (The planner
1376 * will fail to find any mergejoin plans unless there are suitable btree
1377 * opfamily entries for this operator and associated sortops. The pg_operator
1378 * flag is just a hint to tell the planner whether to bother looking.)
1379 *
1380 * In some cases (currently only array_eq and record_eq), mergejoinability
1381 * depends on the specific input data type the operator is invoked for, so
1382 * that must be passed as well. We currently assume that only one input's type
1383 * is needed to check this --- by convention, pass the left input's data type.
1384 */
1385bool
1386op_mergejoinable(Oid opno, Oid inputtype)
1387{
1388 bool result = false;
1389 HeapTuple tp;
1390 TypeCacheEntry *typentry;
1391
1392 /*
1393 * For array_eq or record_eq, we can sort if the element or field types
1394 * are all sortable. We could implement all the checks for that here, but
1395 * the typcache already does that and caches the results too, so let's
1396 * rely on the typcache.
1397 */
1398 if (opno == ARRAY_EQ_OP)
1399 {
1400 typentry = lookup_type_cache(inputtype, TYPECACHE_CMP_PROC);
1401 if (typentry->cmp_proc == F_BTARRAYCMP)
1402 result = true;
1403 }
1404 else if (opno == RECORD_EQ_OP)
1405 {
1406 typentry = lookup_type_cache(inputtype, TYPECACHE_CMP_PROC);
1407 if (typentry->cmp_proc == F_BTRECORDCMP)
1408 result = true;
1409 }
1410 else
1411 {
1412 /* For all other operators, rely on pg_operator.oprcanmerge */
1413 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1414 if (HeapTupleIsValid(tp))
1415 {
1417
1418 result = optup->oprcanmerge;
1419 ReleaseSysCache(tp);
1420 }
1421 }
1422 return result;
1423}
1424
1425/*
1426 * op_hashjoinable
1427 *
1428 * Returns true if the operator is hashjoinable. (There must be a suitable
1429 * hash opfamily entry for this operator if it is so marked.)
1430 *
1431 * In some cases (currently only array_eq), hashjoinability depends on the
1432 * specific input data type the operator is invoked for, so that must be
1433 * passed as well. We currently assume that only one input's type is needed
1434 * to check this --- by convention, pass the left input's data type.
1435 */
1436bool
1437op_hashjoinable(Oid opno, Oid inputtype)
1438{
1439 bool result = false;
1440 HeapTuple tp;
1441 TypeCacheEntry *typentry;
1442
1443 /* As in op_mergejoinable, let the typcache handle the hard cases */
1444 if (opno == ARRAY_EQ_OP)
1445 {
1446 typentry = lookup_type_cache(inputtype, TYPECACHE_HASH_PROC);
1447 if (typentry->hash_proc == F_HASH_ARRAY)
1448 result = true;
1449 }
1450 else if (opno == RECORD_EQ_OP)
1451 {
1452 typentry = lookup_type_cache(inputtype, TYPECACHE_HASH_PROC);
1453 if (typentry->hash_proc == F_HASH_RECORD)
1454 result = true;
1455 }
1456 else
1457 {
1458 /* For all other operators, rely on pg_operator.oprcanhash */
1459 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1460 if (HeapTupleIsValid(tp))
1461 {
1463
1464 result = optup->oprcanhash;
1465 ReleaseSysCache(tp);
1466 }
1467 }
1468 return result;
1469}
1470
1471/*
1472 * op_strict
1473 *
1474 * Get the proisstrict flag for the operator's underlying function.
1475 */
1476bool
1478{
1479 RegProcedure funcid = get_opcode(opno);
1480
1481 if (funcid == (RegProcedure) InvalidOid)
1482 elog(ERROR, "operator %u does not exist", opno);
1483
1484 return func_strict((Oid) funcid);
1485}
1486
1487/*
1488 * op_volatile
1489 *
1490 * Get the provolatile flag for the operator's underlying function.
1491 */
1492char
1494{
1495 RegProcedure funcid = get_opcode(opno);
1496
1497 if (funcid == (RegProcedure) InvalidOid)
1498 elog(ERROR, "operator %u does not exist", opno);
1499
1500 return func_volatile((Oid) funcid);
1501}
1502
1503/*
1504 * get_commutator
1505 *
1506 * Returns the corresponding commutator of an operator.
1507 */
1508Oid
1510{
1511 HeapTuple tp;
1512
1513 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1514 if (HeapTupleIsValid(tp))
1515 {
1517 Oid result;
1518
1519 result = optup->oprcom;
1520 ReleaseSysCache(tp);
1521 return result;
1522 }
1523 else
1524 return InvalidOid;
1525}
1526
1527/*
1528 * get_negator
1529 *
1530 * Returns the corresponding negator of an operator.
1531 */
1532Oid
1534{
1535 HeapTuple tp;
1536
1537 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1538 if (HeapTupleIsValid(tp))
1539 {
1541 Oid result;
1542
1543 result = optup->oprnegate;
1544 ReleaseSysCache(tp);
1545 return result;
1546 }
1547 else
1548 return InvalidOid;
1549}
1550
1551/*
1552 * get_oprrest
1553 *
1554 * Returns procedure id for computing selectivity of an operator.
1555 */
1558{
1559 HeapTuple tp;
1560
1561 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1562 if (HeapTupleIsValid(tp))
1563 {
1565 RegProcedure result;
1566
1567 result = optup->oprrest;
1568 ReleaseSysCache(tp);
1569 return result;
1570 }
1571 else
1572 return (RegProcedure) InvalidOid;
1573}
1574
1575/*
1576 * get_oprjoin
1577 *
1578 * Returns procedure id for computing selectivity of a join.
1579 */
1582{
1583 HeapTuple tp;
1584
1585 tp = SearchSysCache1(OPEROID, ObjectIdGetDatum(opno));
1586 if (HeapTupleIsValid(tp))
1587 {
1589 RegProcedure result;
1590
1591 result = optup->oprjoin;
1592 ReleaseSysCache(tp);
1593 return result;
1594 }
1595 else
1596 return (RegProcedure) InvalidOid;
1597}
1598
1599/* ---------- FUNCTION CACHE ---------- */
1600
1601/*
1602 * get_func_name
1603 * returns the name of the function with the given funcid
1604 *
1605 * Note: returns a palloc'd copy of the string, or NULL if no such function.
1606 */
1607char *
1609{
1610 HeapTuple tp;
1611
1612 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1613 if (HeapTupleIsValid(tp))
1614 {
1615 Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
1616 char *result;
1617
1618 result = pstrdup(NameStr(functup->proname));
1619 ReleaseSysCache(tp);
1620 return result;
1621 }
1622 else
1623 return NULL;
1624}
1625
1626/*
1627 * get_func_namespace
1628 *
1629 * Returns the pg_namespace OID associated with a given function.
1630 */
1631Oid
1633{
1634 HeapTuple tp;
1635
1636 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1637 if (HeapTupleIsValid(tp))
1638 {
1639 Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
1640 Oid result;
1641
1642 result = functup->pronamespace;
1643 ReleaseSysCache(tp);
1644 return result;
1645 }
1646 else
1647 return InvalidOid;
1648}
1649
1650/*
1651 * get_func_rettype
1652 * Given procedure id, return the function's result type.
1653 */
1654Oid
1656{
1657 HeapTuple tp;
1658 Oid result;
1659
1660 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1661 if (!HeapTupleIsValid(tp))
1662 elog(ERROR, "cache lookup failed for function %u", funcid);
1663
1664 result = ((Form_pg_proc) GETSTRUCT(tp))->prorettype;
1665 ReleaseSysCache(tp);
1666 return result;
1667}
1668
1669/*
1670 * get_func_nargs
1671 * Given procedure id, return the number of arguments.
1672 */
1673int
1675{
1676 HeapTuple tp;
1677 int result;
1678
1679 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1680 if (!HeapTupleIsValid(tp))
1681 elog(ERROR, "cache lookup failed for function %u", funcid);
1682
1683 result = ((Form_pg_proc) GETSTRUCT(tp))->pronargs;
1684 ReleaseSysCache(tp);
1685 return result;
1686}
1687
1688/*
1689 * get_func_signature
1690 * Given procedure id, return the function's argument and result types.
1691 * (The return value is the result type.)
1692 *
1693 * The arguments are returned as a palloc'd array.
1694 */
1695Oid
1696get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
1697{
1698 HeapTuple tp;
1699 Form_pg_proc procstruct;
1700 Oid result;
1701
1702 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1703 if (!HeapTupleIsValid(tp))
1704 elog(ERROR, "cache lookup failed for function %u", funcid);
1705
1706 procstruct = (Form_pg_proc) GETSTRUCT(tp);
1707
1708 result = procstruct->prorettype;
1709 *nargs = (int) procstruct->pronargs;
1710 Assert(*nargs == procstruct->proargtypes.dim1);
1711 *argtypes = (Oid *) palloc(*nargs * sizeof(Oid));
1712 memcpy(*argtypes, procstruct->proargtypes.values, *nargs * sizeof(Oid));
1713
1714 ReleaseSysCache(tp);
1715 return result;
1716}
1717
1718/*
1719 * get_func_variadictype
1720 * Given procedure id, return the function's provariadic field.
1721 */
1722Oid
1724{
1725 HeapTuple tp;
1726 Oid result;
1727
1728 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1729 if (!HeapTupleIsValid(tp))
1730 elog(ERROR, "cache lookup failed for function %u", funcid);
1731
1732 result = ((Form_pg_proc) GETSTRUCT(tp))->provariadic;
1733 ReleaseSysCache(tp);
1734 return result;
1735}
1736
1737/*
1738 * get_func_retset
1739 * Given procedure id, return the function's proretset flag.
1740 */
1741bool
1743{
1744 HeapTuple tp;
1745 bool result;
1746
1747 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1748 if (!HeapTupleIsValid(tp))
1749 elog(ERROR, "cache lookup failed for function %u", funcid);
1750
1751 result = ((Form_pg_proc) GETSTRUCT(tp))->proretset;
1752 ReleaseSysCache(tp);
1753 return result;
1754}
1755
1756/*
1757 * func_strict
1758 * Given procedure id, return the function's proisstrict flag.
1759 */
1760bool
1762{
1763 HeapTuple tp;
1764 bool result;
1765
1766 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1767 if (!HeapTupleIsValid(tp))
1768 elog(ERROR, "cache lookup failed for function %u", funcid);
1769
1770 result = ((Form_pg_proc) GETSTRUCT(tp))->proisstrict;
1771 ReleaseSysCache(tp);
1772 return result;
1773}
1774
1775/*
1776 * func_volatile
1777 * Given procedure id, return the function's provolatile flag.
1778 */
1779char
1781{
1782 HeapTuple tp;
1783 char result;
1784
1785 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1786 if (!HeapTupleIsValid(tp))
1787 elog(ERROR, "cache lookup failed for function %u", funcid);
1788
1789 result = ((Form_pg_proc) GETSTRUCT(tp))->provolatile;
1790 ReleaseSysCache(tp);
1791 return result;
1792}
1793
1794/*
1795 * func_parallel
1796 * Given procedure id, return the function's proparallel flag.
1797 */
1798char
1800{
1801 HeapTuple tp;
1802 char result;
1803
1804 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1805 if (!HeapTupleIsValid(tp))
1806 elog(ERROR, "cache lookup failed for function %u", funcid);
1807
1808 result = ((Form_pg_proc) GETSTRUCT(tp))->proparallel;
1809 ReleaseSysCache(tp);
1810 return result;
1811}
1812
1813/*
1814 * get_func_prokind
1815 * Given procedure id, return the routine kind.
1816 */
1817char
1819{
1820 HeapTuple tp;
1821 char result;
1822
1823 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1824 if (!HeapTupleIsValid(tp))
1825 elog(ERROR, "cache lookup failed for function %u", funcid);
1826
1827 result = ((Form_pg_proc) GETSTRUCT(tp))->prokind;
1828 ReleaseSysCache(tp);
1829 return result;
1830}
1831
1832/*
1833 * get_func_leakproof
1834 * Given procedure id, return the function's leakproof field.
1835 */
1836bool
1838{
1839 HeapTuple tp;
1840 bool result;
1841
1842 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1843 if (!HeapTupleIsValid(tp))
1844 elog(ERROR, "cache lookup failed for function %u", funcid);
1845
1846 result = ((Form_pg_proc) GETSTRUCT(tp))->proleakproof;
1847 ReleaseSysCache(tp);
1848 return result;
1849}
1850
1851/*
1852 * get_func_support
1853 *
1854 * Returns the support function OID associated with a given function,
1855 * or InvalidOid if there is none.
1856 */
1859{
1860 HeapTuple tp;
1861
1862 tp = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1863 if (HeapTupleIsValid(tp))
1864 {
1865 Form_pg_proc functup = (Form_pg_proc) GETSTRUCT(tp);
1866 RegProcedure result;
1867
1868 result = functup->prosupport;
1869 ReleaseSysCache(tp);
1870 return result;
1871 }
1872 else
1873 return (RegProcedure) InvalidOid;
1874}
1875
1876/* ---------- RELATION CACHE ---------- */
1877
1878/*
1879 * get_relname_relid
1880 * Given name and namespace of a relation, look up the OID.
1881 *
1882 * Returns InvalidOid if there is no such relation.
1883 */
1884Oid
1885get_relname_relid(const char *relname, Oid relnamespace)
1886{
1887 return GetSysCacheOid2(RELNAMENSP, Anum_pg_class_oid,
1889 ObjectIdGetDatum(relnamespace));
1890}
1891
1892#ifdef NOT_USED
1893/*
1894 * get_relnatts
1895 *
1896 * Returns the number of attributes for a given relation.
1897 */
1898int
1899get_relnatts(Oid relid)
1900{
1901 HeapTuple tp;
1902
1903 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1904 if (HeapTupleIsValid(tp))
1905 {
1906 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
1907 int result;
1908
1909 result = reltup->relnatts;
1910 ReleaseSysCache(tp);
1911 return result;
1912 }
1913 else
1914 return InvalidAttrNumber;
1915}
1916#endif
1917
1918/*
1919 * get_rel_name
1920 * Returns the name of a given relation.
1921 *
1922 * Returns a palloc'd copy of the string, or NULL if no such relation.
1923 *
1924 * NOTE: since relation name is not unique, be wary of code that uses this
1925 * for anything except preparing error messages.
1926 */
1927char *
1929{
1930 HeapTuple tp;
1931
1932 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1933 if (HeapTupleIsValid(tp))
1934 {
1935 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
1936 char *result;
1937
1938 result = pstrdup(NameStr(reltup->relname));
1939 ReleaseSysCache(tp);
1940 return result;
1941 }
1942 else
1943 return NULL;
1944}
1945
1946/*
1947 * get_rel_namespace
1948 *
1949 * Returns the pg_namespace OID associated with a given relation.
1950 */
1951Oid
1953{
1954 HeapTuple tp;
1955
1956 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1957 if (HeapTupleIsValid(tp))
1958 {
1959 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
1960 Oid result;
1961
1962 result = reltup->relnamespace;
1963 ReleaseSysCache(tp);
1964 return result;
1965 }
1966 else
1967 return InvalidOid;
1968}
1969
1970/*
1971 * get_rel_type_id
1972 *
1973 * Returns the pg_type OID associated with a given relation.
1974 *
1975 * Note: not all pg_class entries have associated pg_type OIDs; so be
1976 * careful to check for InvalidOid result.
1977 */
1978Oid
1980{
1981 HeapTuple tp;
1982
1983 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
1984 if (HeapTupleIsValid(tp))
1985 {
1986 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
1987 Oid result;
1988
1989 result = reltup->reltype;
1990 ReleaseSysCache(tp);
1991 return result;
1992 }
1993 else
1994 return InvalidOid;
1995}
1996
1997/*
1998 * get_rel_relkind
1999 *
2000 * Returns the relkind associated with a given relation.
2001 */
2002char
2004{
2005 HeapTuple tp;
2006
2007 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
2008 if (HeapTupleIsValid(tp))
2009 {
2010 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
2011 char result;
2012
2013 result = reltup->relkind;
2014 ReleaseSysCache(tp);
2015 return result;
2016 }
2017 else
2018 return '\0';
2019}
2020
2021/*
2022 * get_rel_relispartition
2023 *
2024 * Returns the relispartition flag associated with a given relation.
2025 */
2026bool
2028{
2029 HeapTuple tp;
2030
2031 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
2032 if (HeapTupleIsValid(tp))
2033 {
2034 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
2035 bool result;
2036
2037 result = reltup->relispartition;
2038 ReleaseSysCache(tp);
2039 return result;
2040 }
2041 else
2042 return false;
2043}
2044
2045/*
2046 * get_rel_tablespace
2047 *
2048 * Returns the pg_tablespace OID associated with a given relation.
2049 *
2050 * Note: InvalidOid might mean either that we couldn't find the relation,
2051 * or that it is in the database's default tablespace.
2052 */
2053Oid
2055{
2056 HeapTuple tp;
2057
2058 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
2059 if (HeapTupleIsValid(tp))
2060 {
2061 Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
2062 Oid result;
2063
2064 result = reltup->reltablespace;
2065 ReleaseSysCache(tp);
2066 return result;
2067 }
2068 else
2069 return InvalidOid;
2070}
2071
2072/*
2073 * get_rel_persistence
2074 *
2075 * Returns the relpersistence associated with a given relation.
2076 */
2077char
2079{
2080 HeapTuple tp;
2081 Form_pg_class reltup;
2082 char result;
2083
2084 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
2085 if (!HeapTupleIsValid(tp))
2086 elog(ERROR, "cache lookup failed for relation %u", relid);
2087 reltup = (Form_pg_class) GETSTRUCT(tp);
2088 result = reltup->relpersistence;
2089 ReleaseSysCache(tp);
2090
2091 return result;
2092}
2093
2094/*
2095 * get_rel_relam
2096 *
2097 * Returns the relam associated with a given relation.
2098 */
2099Oid
2101{
2102 HeapTuple tp;
2103 Form_pg_class reltup;
2104 Oid result;
2105
2106 tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
2107 if (!HeapTupleIsValid(tp))
2108 elog(ERROR, "cache lookup failed for relation %u", relid);
2109 reltup = (Form_pg_class) GETSTRUCT(tp);
2110 result = reltup->relam;
2111 ReleaseSysCache(tp);
2112
2113 return result;
2114}
2115
2116
2117/* ---------- TRANSFORM CACHE ---------- */
2118
2119Oid
2120get_transform_fromsql(Oid typid, Oid langid, List *trftypes)
2121{
2122 HeapTuple tup;
2123
2124 if (!list_member_oid(trftypes, typid))
2125 return InvalidOid;
2126
2127 tup = SearchSysCache2(TRFTYPELANG, ObjectIdGetDatum(typid),
2128 ObjectIdGetDatum(langid));
2129 if (HeapTupleIsValid(tup))
2130 {
2131 Oid funcid;
2132
2133 funcid = ((Form_pg_transform) GETSTRUCT(tup))->trffromsql;
2134 ReleaseSysCache(tup);
2135 return funcid;
2136 }
2137 else
2138 return InvalidOid;
2139}
2140
2141Oid
2142get_transform_tosql(Oid typid, Oid langid, List *trftypes)
2143{
2144 HeapTuple tup;
2145
2146 if (!list_member_oid(trftypes, typid))
2147 return InvalidOid;
2148
2149 tup = SearchSysCache2(TRFTYPELANG, ObjectIdGetDatum(typid),
2150 ObjectIdGetDatum(langid));
2151 if (HeapTupleIsValid(tup))
2152 {
2153 Oid funcid;
2154
2155 funcid = ((Form_pg_transform) GETSTRUCT(tup))->trftosql;
2156 ReleaseSysCache(tup);
2157 return funcid;
2158 }
2159 else
2160 return InvalidOid;
2161}
2162
2163
2164/* ---------- TYPE CACHE ---------- */
2165
2166/*
2167 * get_typisdefined
2168 *
2169 * Given the type OID, determine whether the type is defined
2170 * (if not, it's only a shell).
2171 */
2172bool
2174{
2175 HeapTuple tp;
2176
2177 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2178 if (HeapTupleIsValid(tp))
2179 {
2180 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2181 bool result;
2182
2183 result = typtup->typisdefined;
2184 ReleaseSysCache(tp);
2185 return result;
2186 }
2187 else
2188 return false;
2189}
2190
2191/*
2192 * get_typlen
2193 *
2194 * Given the type OID, return the length of the type.
2195 */
2196int16
2198{
2199 HeapTuple tp;
2200
2201 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2202 if (HeapTupleIsValid(tp))
2203 {
2204 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2205 int16 result;
2206
2207 result = typtup->typlen;
2208 ReleaseSysCache(tp);
2209 return result;
2210 }
2211 else
2212 return 0;
2213}
2214
2215/*
2216 * get_typbyval
2217 *
2218 * Given the type OID, determine whether the type is returned by value or
2219 * not. Returns true if by value, false if by reference.
2220 */
2221bool
2223{
2224 HeapTuple tp;
2225
2226 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2227 if (HeapTupleIsValid(tp))
2228 {
2229 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2230 bool result;
2231
2232 result = typtup->typbyval;
2233 ReleaseSysCache(tp);
2234 return result;
2235 }
2236 else
2237 return false;
2238}
2239
2240/*
2241 * get_typlenbyval
2242 *
2243 * A two-fer: given the type OID, return both typlen and typbyval.
2244 *
2245 * Since both pieces of info are needed to know how to copy a Datum,
2246 * many places need both. Might as well get them with one cache lookup
2247 * instead of two. Also, this routine raises an error instead of
2248 * returning a bogus value when given a bad type OID.
2249 */
2250void
2251get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
2252{
2253 HeapTuple tp;
2254 Form_pg_type typtup;
2255
2256 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2257 if (!HeapTupleIsValid(tp))
2258 elog(ERROR, "cache lookup failed for type %u", typid);
2259 typtup = (Form_pg_type) GETSTRUCT(tp);
2260 *typlen = typtup->typlen;
2261 *typbyval = typtup->typbyval;
2262 ReleaseSysCache(tp);
2263}
2264
2265/*
2266 * get_typlenbyvalalign
2267 *
2268 * A three-fer: given the type OID, return typlen, typbyval, typalign.
2269 */
2270void
2271get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval,
2272 char *typalign)
2273{
2274 HeapTuple tp;
2275 Form_pg_type typtup;
2276
2277 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2278 if (!HeapTupleIsValid(tp))
2279 elog(ERROR, "cache lookup failed for type %u", typid);
2280 typtup = (Form_pg_type) GETSTRUCT(tp);
2281 *typlen = typtup->typlen;
2282 *typbyval = typtup->typbyval;
2283 *typalign = typtup->typalign;
2284 ReleaseSysCache(tp);
2285}
2286
2287/*
2288 * getTypeIOParam
2289 * Given a pg_type row, select the type OID to pass to I/O functions
2290 *
2291 * Formerly, all I/O functions were passed pg_type.typelem as their second
2292 * parameter, but we now have a more complex rule about what to pass.
2293 * This knowledge is intended to be centralized here --- direct references
2294 * to typelem elsewhere in the code are wrong, if they are associated with
2295 * I/O calls and not with actual subscripting operations! (But see
2296 * bootstrap.c's boot_get_type_io_data() if you need to change this.)
2297 *
2298 * As of PostgreSQL 8.1, output functions receive only the value itself
2299 * and not any auxiliary parameters, so the name of this routine is now
2300 * a bit of a misnomer ... it should be getTypeInputParam.
2301 */
2302Oid
2304{
2305 Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
2306
2307 /*
2308 * Array types get their typelem as parameter; everybody else gets their
2309 * own type OID as parameter.
2310 */
2311 if (OidIsValid(typeStruct->typelem))
2312 return typeStruct->typelem;
2313 else
2314 return typeStruct->oid;
2315}
2316
2317/*
2318 * get_type_io_data
2319 *
2320 * A six-fer: given the type OID, return typlen, typbyval, typalign,
2321 * typdelim, typioparam, and IO function OID. The IO function
2322 * returned is controlled by IOFuncSelector
2323 */
2324void
2326 IOFuncSelector which_func,
2327 int16 *typlen,
2328 bool *typbyval,
2329 char *typalign,
2330 char *typdelim,
2331 Oid *typioparam,
2332 Oid *func)
2333{
2334 HeapTuple typeTuple;
2335 Form_pg_type typeStruct;
2336
2337 /*
2338 * In bootstrap mode, pass it off to bootstrap.c. This hack allows us to
2339 * use array_in and array_out during bootstrap.
2340 */
2342 {
2343 Oid typinput;
2344 Oid typoutput;
2345
2347 typlen,
2348 typbyval,
2349 typalign,
2350 typdelim,
2351 typioparam,
2352 &typinput,
2353 &typoutput);
2354 switch (which_func)
2355 {
2356 case IOFunc_input:
2357 *func = typinput;
2358 break;
2359 case IOFunc_output:
2360 *func = typoutput;
2361 break;
2362 default:
2363 elog(ERROR, "binary I/O not supported during bootstrap");
2364 break;
2365 }
2366 return;
2367 }
2368
2369 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2370 if (!HeapTupleIsValid(typeTuple))
2371 elog(ERROR, "cache lookup failed for type %u", typid);
2372 typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);
2373
2374 *typlen = typeStruct->typlen;
2375 *typbyval = typeStruct->typbyval;
2376 *typalign = typeStruct->typalign;
2377 *typdelim = typeStruct->typdelim;
2378 *typioparam = getTypeIOParam(typeTuple);
2379 switch (which_func)
2380 {
2381 case IOFunc_input:
2382 *func = typeStruct->typinput;
2383 break;
2384 case IOFunc_output:
2385 *func = typeStruct->typoutput;
2386 break;
2387 case IOFunc_receive:
2388 *func = typeStruct->typreceive;
2389 break;
2390 case IOFunc_send:
2391 *func = typeStruct->typsend;
2392 break;
2393 }
2394 ReleaseSysCache(typeTuple);
2395}
2396
2397#ifdef NOT_USED
2398char
2399get_typalign(Oid typid)
2400{
2401 HeapTuple tp;
2402
2403 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2404 if (HeapTupleIsValid(tp))
2405 {
2406 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2407 char result;
2408
2409 result = typtup->typalign;
2410 ReleaseSysCache(tp);
2411 return result;
2412 }
2413 else
2414 return TYPALIGN_INT;
2415}
2416#endif
2417
2418char
2420{
2421 HeapTuple tp;
2422
2423 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2424 if (HeapTupleIsValid(tp))
2425 {
2426 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2427 char result;
2428
2429 result = typtup->typstorage;
2430 ReleaseSysCache(tp);
2431 return result;
2432 }
2433 else
2434 return TYPSTORAGE_PLAIN;
2435}
2436
2437/*
2438 * get_typdefault
2439 * Given a type OID, return the type's default value, if any.
2440 *
2441 * The result is a palloc'd expression node tree, or NULL if there
2442 * is no defined default for the datatype.
2443 *
2444 * NB: caller should be prepared to coerce result to correct datatype;
2445 * the returned expression tree might produce something of the wrong type.
2446 */
2447Node *
2449{
2450 HeapTuple typeTuple;
2452 Datum datum;
2453 bool isNull;
2454 Node *expr;
2455
2456 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2457 if (!HeapTupleIsValid(typeTuple))
2458 elog(ERROR, "cache lookup failed for type %u", typid);
2459 type = (Form_pg_type) GETSTRUCT(typeTuple);
2460
2461 /*
2462 * typdefault and typdefaultbin are potentially null, so don't try to
2463 * access 'em as struct fields. Must do it the hard way with
2464 * SysCacheGetAttr.
2465 */
2466 datum = SysCacheGetAttr(TYPEOID,
2467 typeTuple,
2468 Anum_pg_type_typdefaultbin,
2469 &isNull);
2470
2471 if (!isNull)
2472 {
2473 /* We have an expression default */
2474 expr = stringToNode(TextDatumGetCString(datum));
2475 }
2476 else
2477 {
2478 /* Perhaps we have a plain literal default */
2479 datum = SysCacheGetAttr(TYPEOID,
2480 typeTuple,
2481 Anum_pg_type_typdefault,
2482 &isNull);
2483
2484 if (!isNull)
2485 {
2486 char *strDefaultVal;
2487
2488 /* Convert text datum to C string */
2489 strDefaultVal = TextDatumGetCString(datum);
2490 /* Convert C string to a value of the given type */
2491 datum = OidInputFunctionCall(type->typinput, strDefaultVal,
2492 getTypeIOParam(typeTuple), -1);
2493 /* Build a Const node containing the value */
2494 expr = (Node *) makeConst(typid,
2495 -1,
2496 type->typcollation,
2497 type->typlen,
2498 datum,
2499 false,
2500 type->typbyval);
2501 pfree(strDefaultVal);
2502 }
2503 else
2504 {
2505 /* No default */
2506 expr = NULL;
2507 }
2508 }
2509
2510 ReleaseSysCache(typeTuple);
2511
2512 return expr;
2513}
2514
2515/*
2516 * getBaseType
2517 * If the given type is a domain, return its base type;
2518 * otherwise return the type's own OID.
2519 */
2520Oid
2522{
2523 int32 typmod = -1;
2524
2525 return getBaseTypeAndTypmod(typid, &typmod);
2526}
2527
2528/*
2529 * getBaseTypeAndTypmod
2530 * If the given type is a domain, return its base type and typmod;
2531 * otherwise return the type's own OID, and leave *typmod unchanged.
2532 *
2533 * Note that the "applied typmod" should be -1 for every domain level
2534 * above the bottommost; therefore, if the passed-in typid is indeed
2535 * a domain, *typmod should be -1.
2536 */
2537Oid
2539{
2540 /*
2541 * We loop to find the bottom base type in a stack of domains.
2542 */
2543 for (;;)
2544 {
2545 HeapTuple tup;
2546 Form_pg_type typTup;
2547
2548 tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2549 if (!HeapTupleIsValid(tup))
2550 elog(ERROR, "cache lookup failed for type %u", typid);
2551 typTup = (Form_pg_type) GETSTRUCT(tup);
2552 if (typTup->typtype != TYPTYPE_DOMAIN)
2553 {
2554 /* Not a domain, so done */
2555 ReleaseSysCache(tup);
2556 break;
2557 }
2558
2559 Assert(*typmod == -1);
2560 typid = typTup->typbasetype;
2561 *typmod = typTup->typtypmod;
2562
2563 ReleaseSysCache(tup);
2564 }
2565
2566 return typid;
2567}
2568
2569/*
2570 * get_typavgwidth
2571 *
2572 * Given a type OID and a typmod value (pass -1 if typmod is unknown),
2573 * estimate the average width of values of the type. This is used by
2574 * the planner, which doesn't require absolutely correct results;
2575 * it's OK (and expected) to guess if we don't know for sure.
2576 */
2577int32
2579{
2580 int typlen = get_typlen(typid);
2581 int32 maxwidth;
2582
2583 /*
2584 * Easy if it's a fixed-width type
2585 */
2586 if (typlen > 0)
2587 return typlen;
2588
2589 /*
2590 * type_maximum_size knows the encoding of typmod for some datatypes;
2591 * don't duplicate that knowledge here.
2592 */
2593 maxwidth = type_maximum_size(typid, typmod);
2594 if (maxwidth > 0)
2595 {
2596 /*
2597 * For BPCHAR, the max width is also the only width. Otherwise we
2598 * need to guess about the typical data width given the max. A sliding
2599 * scale for percentage of max width seems reasonable.
2600 */
2601 if (typid == BPCHAROID)
2602 return maxwidth;
2603 if (maxwidth <= 32)
2604 return maxwidth; /* assume full width */
2605 if (maxwidth < 1000)
2606 return 32 + (maxwidth - 32) / 2; /* assume 50% */
2607
2608 /*
2609 * Beyond 1000, assume we're looking at something like
2610 * "varchar(10000)" where the limit isn't actually reached often, and
2611 * use a fixed estimate.
2612 */
2613 return 32 + (1000 - 32) / 2;
2614 }
2615
2616 /*
2617 * Oops, we have no idea ... wild guess time.
2618 */
2619 return 32;
2620}
2621
2622/*
2623 * get_typtype
2624 *
2625 * Given the type OID, find if it is a basic type, a complex type, etc.
2626 * It returns the null char if the cache lookup fails...
2627 */
2628char
2630{
2631 HeapTuple tp;
2632
2633 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2634 if (HeapTupleIsValid(tp))
2635 {
2636 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2637 char result;
2638
2639 result = typtup->typtype;
2640 ReleaseSysCache(tp);
2641 return result;
2642 }
2643 else
2644 return '\0';
2645}
2646
2647/*
2648 * type_is_rowtype
2649 *
2650 * Convenience function to determine whether a type OID represents
2651 * a "rowtype" type --- either RECORD or a named composite type
2652 * (including a domain over a named composite type).
2653 */
2654bool
2656{
2657 if (typid == RECORDOID)
2658 return true; /* easy case */
2659 switch (get_typtype(typid))
2660 {
2661 case TYPTYPE_COMPOSITE:
2662 return true;
2663 case TYPTYPE_DOMAIN:
2664 if (get_typtype(getBaseType(typid)) == TYPTYPE_COMPOSITE)
2665 return true;
2666 break;
2667 default:
2668 break;
2669 }
2670 return false;
2671}
2672
2673/*
2674 * type_is_enum
2675 * Returns true if the given type is an enum type.
2676 */
2677bool
2679{
2680 return (get_typtype(typid) == TYPTYPE_ENUM);
2681}
2682
2683/*
2684 * type_is_range
2685 * Returns true if the given type is a range type.
2686 */
2687bool
2689{
2690 return (get_typtype(typid) == TYPTYPE_RANGE);
2691}
2692
2693/*
2694 * type_is_multirange
2695 * Returns true if the given type is a multirange type.
2696 */
2697bool
2699{
2700 return (get_typtype(typid) == TYPTYPE_MULTIRANGE);
2701}
2702
2703/*
2704 * get_type_category_preferred
2705 *
2706 * Given the type OID, fetch its category and preferred-type status.
2707 * Throws error on failure.
2708 */
2709void
2710get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
2711{
2712 HeapTuple tp;
2713 Form_pg_type typtup;
2714
2715 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2716 if (!HeapTupleIsValid(tp))
2717 elog(ERROR, "cache lookup failed for type %u", typid);
2718 typtup = (Form_pg_type) GETSTRUCT(tp);
2719 *typcategory = typtup->typcategory;
2720 *typispreferred = typtup->typispreferred;
2721 ReleaseSysCache(tp);
2722}
2723
2724/*
2725 * get_typ_typrelid
2726 *
2727 * Given the type OID, get the typrelid (InvalidOid if not a complex
2728 * type).
2729 */
2730Oid
2732{
2733 HeapTuple tp;
2734
2735 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2736 if (HeapTupleIsValid(tp))
2737 {
2738 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2739 Oid result;
2740
2741 result = typtup->typrelid;
2742 ReleaseSysCache(tp);
2743 return result;
2744 }
2745 else
2746 return InvalidOid;
2747}
2748
2749/*
2750 * get_element_type
2751 *
2752 * Given the type OID, get the typelem (InvalidOid if not an array type).
2753 *
2754 * NB: this only succeeds for "true" arrays having array_subscript_handler
2755 * as typsubscript. For other types, InvalidOid is returned independently
2756 * of whether they have typelem or typsubscript set.
2757 */
2758Oid
2760{
2761 HeapTuple tp;
2762
2763 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2764 if (HeapTupleIsValid(tp))
2765 {
2766 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
2767 Oid result;
2768
2769 if (IsTrueArrayType(typtup))
2770 result = typtup->typelem;
2771 else
2772 result = InvalidOid;
2773 ReleaseSysCache(tp);
2774 return result;
2775 }
2776 else
2777 return InvalidOid;
2778}
2779
2780/*
2781 * get_array_type
2782 *
2783 * Given the type OID, get the corresponding "true" array type.
2784 * Returns InvalidOid if no array type can be found.
2785 */
2786Oid
2788{
2789 HeapTuple tp;
2790 Oid result = InvalidOid;
2791
2792 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2793 if (HeapTupleIsValid(tp))
2794 {
2795 result = ((Form_pg_type) GETSTRUCT(tp))->typarray;
2796 ReleaseSysCache(tp);
2797 }
2798 return result;
2799}
2800
2801/*
2802 * get_promoted_array_type
2803 *
2804 * The "promoted" type is what you'd get from an ARRAY(SELECT ...)
2805 * construct, that is, either the corresponding "true" array type
2806 * if the input is a scalar type that has such an array type,
2807 * or the same type if the input is already a "true" array type.
2808 * Returns InvalidOid if neither rule is satisfied.
2809 */
2810Oid
2812{
2813 Oid array_type = get_array_type(typid);
2814
2815 if (OidIsValid(array_type))
2816 return array_type;
2817 if (OidIsValid(get_element_type(typid)))
2818 return typid;
2819 return InvalidOid;
2820}
2821
2822/*
2823 * get_base_element_type
2824 * Given the type OID, get the typelem, looking "through" any domain
2825 * to its underlying array type.
2826 *
2827 * This is equivalent to get_element_type(getBaseType(typid)), but avoids
2828 * an extra cache lookup. Note that it fails to provide any information
2829 * about the typmod of the array.
2830 */
2831Oid
2833{
2834 /*
2835 * We loop to find the bottom base type in a stack of domains.
2836 */
2837 for (;;)
2838 {
2839 HeapTuple tup;
2840 Form_pg_type typTup;
2841
2842 tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
2843 if (!HeapTupleIsValid(tup))
2844 break;
2845 typTup = (Form_pg_type) GETSTRUCT(tup);
2846 if (typTup->typtype != TYPTYPE_DOMAIN)
2847 {
2848 /* Not a domain, so stop descending */
2849 Oid result;
2850
2851 /* This test must match get_element_type */
2852 if (IsTrueArrayType(typTup))
2853 result = typTup->typelem;
2854 else
2855 result = InvalidOid;
2856 ReleaseSysCache(tup);
2857 return result;
2858 }
2859
2860 typid = typTup->typbasetype;
2861 ReleaseSysCache(tup);
2862 }
2863
2864 /* Like get_element_type, silently return InvalidOid for bogus input */
2865 return InvalidOid;
2866}
2867
2868/*
2869 * getTypeInputInfo
2870 *
2871 * Get info needed for converting values of a type to internal form
2872 */
2873void
2874getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
2875{
2876 HeapTuple typeTuple;
2877 Form_pg_type pt;
2878
2879 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2880 if (!HeapTupleIsValid(typeTuple))
2881 elog(ERROR, "cache lookup failed for type %u", type);
2882 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2883
2884 if (!pt->typisdefined)
2885 ereport(ERROR,
2886 (errcode(ERRCODE_UNDEFINED_OBJECT),
2887 errmsg("type %s is only a shell",
2888 format_type_be(type))));
2889 if (!OidIsValid(pt->typinput))
2890 ereport(ERROR,
2891 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2892 errmsg("no input function available for type %s",
2893 format_type_be(type))));
2894
2895 *typInput = pt->typinput;
2896 *typIOParam = getTypeIOParam(typeTuple);
2897
2898 ReleaseSysCache(typeTuple);
2899}
2900
2901/*
2902 * getTypeOutputInfo
2903 *
2904 * Get info needed for printing values of a type
2905 */
2906void
2907getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
2908{
2909 HeapTuple typeTuple;
2910 Form_pg_type pt;
2911
2912 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2913 if (!HeapTupleIsValid(typeTuple))
2914 elog(ERROR, "cache lookup failed for type %u", type);
2915 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2916
2917 if (!pt->typisdefined)
2918 ereport(ERROR,
2919 (errcode(ERRCODE_UNDEFINED_OBJECT),
2920 errmsg("type %s is only a shell",
2921 format_type_be(type))));
2922 if (!OidIsValid(pt->typoutput))
2923 ereport(ERROR,
2924 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2925 errmsg("no output function available for type %s",
2926 format_type_be(type))));
2927
2928 *typOutput = pt->typoutput;
2929 *typIsVarlena = (!pt->typbyval) && (pt->typlen == -1);
2930
2931 ReleaseSysCache(typeTuple);
2932}
2933
2934/*
2935 * getTypeBinaryInputInfo
2936 *
2937 * Get info needed for binary input of values of a type
2938 */
2939void
2940getTypeBinaryInputInfo(Oid type, Oid *typReceive, Oid *typIOParam)
2941{
2942 HeapTuple typeTuple;
2943 Form_pg_type pt;
2944
2945 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2946 if (!HeapTupleIsValid(typeTuple))
2947 elog(ERROR, "cache lookup failed for type %u", type);
2948 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2949
2950 if (!pt->typisdefined)
2951 ereport(ERROR,
2952 (errcode(ERRCODE_UNDEFINED_OBJECT),
2953 errmsg("type %s is only a shell",
2954 format_type_be(type))));
2955 if (!OidIsValid(pt->typreceive))
2956 ereport(ERROR,
2957 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2958 errmsg("no binary input function available for type %s",
2959 format_type_be(type))));
2960
2961 *typReceive = pt->typreceive;
2962 *typIOParam = getTypeIOParam(typeTuple);
2963
2964 ReleaseSysCache(typeTuple);
2965}
2966
2967/*
2968 * getTypeBinaryOutputInfo
2969 *
2970 * Get info needed for binary output of values of a type
2971 */
2972void
2973getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena)
2974{
2975 HeapTuple typeTuple;
2976 Form_pg_type pt;
2977
2978 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2979 if (!HeapTupleIsValid(typeTuple))
2980 elog(ERROR, "cache lookup failed for type %u", type);
2981 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2982
2983 if (!pt->typisdefined)
2984 ereport(ERROR,
2985 (errcode(ERRCODE_UNDEFINED_OBJECT),
2986 errmsg("type %s is only a shell",
2987 format_type_be(type))));
2988 if (!OidIsValid(pt->typsend))
2989 ereport(ERROR,
2990 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2991 errmsg("no binary output function available for type %s",
2992 format_type_be(type))));
2993
2994 *typSend = pt->typsend;
2995 *typIsVarlena = (!pt->typbyval) && (pt->typlen == -1);
2996
2997 ReleaseSysCache(typeTuple);
2998}
2999
3000/*
3001 * get_typmodin
3002 *
3003 * Given the type OID, return the type's typmodin procedure, if any.
3004 */
3005Oid
3007{
3008 HeapTuple tp;
3009
3010 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
3011 if (HeapTupleIsValid(tp))
3012 {
3013 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
3014 Oid result;
3015
3016 result = typtup->typmodin;
3017 ReleaseSysCache(tp);
3018 return result;
3019 }
3020 else
3021 return InvalidOid;
3022}
3023
3024#ifdef NOT_USED
3025/*
3026 * get_typmodout
3027 *
3028 * Given the type OID, return the type's typmodout procedure, if any.
3029 */
3030Oid
3031get_typmodout(Oid typid)
3032{
3033 HeapTuple tp;
3034
3035 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
3036 if (HeapTupleIsValid(tp))
3037 {
3038 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
3039 Oid result;
3040
3041 result = typtup->typmodout;
3042 ReleaseSysCache(tp);
3043 return result;
3044 }
3045 else
3046 return InvalidOid;
3047}
3048#endif /* NOT_USED */
3049
3050/*
3051 * get_typcollation
3052 *
3053 * Given the type OID, return the type's typcollation attribute.
3054 */
3055Oid
3057{
3058 HeapTuple tp;
3059
3060 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
3061 if (HeapTupleIsValid(tp))
3062 {
3063 Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
3064 Oid result;
3065
3066 result = typtup->typcollation;
3067 ReleaseSysCache(tp);
3068 return result;
3069 }
3070 else
3071 return InvalidOid;
3072}
3073
3074
3075/*
3076 * type_is_collatable
3077 *
3078 * Return whether the type cares about collations
3079 */
3080bool
3082{
3083 return OidIsValid(get_typcollation(typid));
3084}
3085
3086
3087/*
3088 * get_typsubscript
3089 *
3090 * Given the type OID, return the type's subscripting handler's OID,
3091 * if it has one.
3092 *
3093 * If typelemp isn't NULL, we also store the type's typelem value there.
3094 * This saves some callers an extra catalog lookup.
3095 */
3097get_typsubscript(Oid typid, Oid *typelemp)
3098{
3099 HeapTuple tp;
3100
3101 tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
3102 if (HeapTupleIsValid(tp))
3103 {
3104 Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp);
3105 RegProcedure handler = typform->typsubscript;
3106
3107 if (typelemp)
3108 *typelemp = typform->typelem;
3109 ReleaseSysCache(tp);
3110 return handler;
3111 }
3112 else
3113 {
3114 if (typelemp)
3115 *typelemp = InvalidOid;
3116 return InvalidOid;
3117 }
3118}
3119
3120/*
3121 * getSubscriptingRoutines
3122 *
3123 * Given the type OID, fetch the type's subscripting methods struct.
3124 * Return NULL if type is not subscriptable.
3125 *
3126 * If typelemp isn't NULL, we also store the type's typelem value there.
3127 * This saves some callers an extra catalog lookup.
3128 */
3129const struct SubscriptRoutines *
3131{
3132 RegProcedure typsubscript = get_typsubscript(typid, typelemp);
3133
3134 if (!OidIsValid(typsubscript))
3135 return NULL;
3136
3137 return (const struct SubscriptRoutines *)
3138 DatumGetPointer(OidFunctionCall0(typsubscript));
3139}
3140
3141
3142/* ---------- STATISTICS CACHE ---------- */
3143
3144/*
3145 * get_attavgwidth
3146 *
3147 * Given the table and attribute number of a column, get the average
3148 * width of entries in the column. Return zero if no data available.
3149 *
3150 * Currently this is only consulted for individual tables, not for inheritance
3151 * trees, so we don't need an "inh" parameter.
3152 *
3153 * Calling a hook at this point looks somewhat strange, but is required
3154 * because the optimizer calls this function without any other way for
3155 * plug-ins to control the result.
3156 */
3157int32
3159{
3160 HeapTuple tp;
3161 int32 stawidth;
3162
3164 {
3165 stawidth = (*get_attavgwidth_hook) (relid, attnum);
3166 if (stawidth > 0)
3167 return stawidth;
3168 }
3169 tp = SearchSysCache3(STATRELATTINH,
3170 ObjectIdGetDatum(relid),
3172 BoolGetDatum(false));
3173 if (HeapTupleIsValid(tp))
3174 {
3175 stawidth = ((Form_pg_statistic) GETSTRUCT(tp))->stawidth;
3176 ReleaseSysCache(tp);
3177 if (stawidth > 0)
3178 return stawidth;
3179 }
3180 return 0;
3181}
3182
3183/*
3184 * get_attstatsslot
3185 *
3186 * Extract the contents of a "slot" of a pg_statistic tuple.
3187 * Returns true if requested slot type was found, else false.
3188 *
3189 * Unlike other routines in this file, this takes a pointer to an
3190 * already-looked-up tuple in the pg_statistic cache. We do this since
3191 * most callers will want to extract more than one value from the cache
3192 * entry, and we don't want to repeat the cache lookup unnecessarily.
3193 * Also, this API allows this routine to be used with statistics tuples
3194 * that have been provided by a stats hook and didn't really come from
3195 * pg_statistic.
3196 *
3197 * sslot: pointer to output area (typically, a local variable in the caller).
3198 * statstuple: pg_statistic tuple to be examined.
3199 * reqkind: STAKIND code for desired statistics slot kind.
3200 * reqop: STAOP value wanted, or InvalidOid if don't care.
3201 * flags: bitmask of ATTSTATSSLOT_VALUES and/or ATTSTATSSLOT_NUMBERS.
3202 *
3203 * If a matching slot is found, true is returned, and *sslot is filled thus:
3204 * staop: receives the actual STAOP value.
3205 * stacoll: receives the actual STACOLL value.
3206 * valuetype: receives actual datatype of the elements of stavalues.
3207 * values: receives pointer to an array of the slot's stavalues.
3208 * nvalues: receives number of stavalues.
3209 * numbers: receives pointer to an array of the slot's stanumbers (as float4).
3210 * nnumbers: receives number of stanumbers.
3211 *
3212 * valuetype/values/nvalues are InvalidOid/NULL/0 if ATTSTATSSLOT_VALUES
3213 * wasn't specified. Likewise, numbers/nnumbers are NULL/0 if
3214 * ATTSTATSSLOT_NUMBERS wasn't specified.
3215 *
3216 * If no matching slot is found, false is returned, and *sslot is zeroed.
3217 *
3218 * Note that the current API doesn't allow for searching for a slot with
3219 * a particular collation. If we ever actually support recording more than
3220 * one collation, we'll have to extend the API, but for now simple is good.
3221 *
3222 * The data referred to by the fields of sslot is locally palloc'd and
3223 * is independent of the original pg_statistic tuple. When the caller
3224 * is done with it, call free_attstatsslot to release the palloc'd data.
3225 *
3226 * If it's desirable to call free_attstatsslot when get_attstatsslot might
3227 * not have been called, memset'ing sslot to zeroes will allow that.
3228 *
3229 * Passing flags=0 can be useful to quickly check if the requested slot type
3230 * exists. In this case no arrays are extracted, so free_attstatsslot need
3231 * not be called.
3232 */
3233bool
3235 int reqkind, Oid reqop, int flags)
3236{
3237 Form_pg_statistic stats = (Form_pg_statistic) GETSTRUCT(statstuple);
3238 int i;
3239 Datum val;
3240 ArrayType *statarray;
3241 Oid arrayelemtype;
3242 int narrayelem;
3243 HeapTuple typeTuple;
3244 Form_pg_type typeForm;
3245
3246 /* initialize *sslot properly */
3247 memset(sslot, 0, sizeof(AttStatsSlot));
3248
3249 for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
3250 {
3251 if ((&stats->stakind1)[i] == reqkind &&
3252 (reqop == InvalidOid || (&stats->staop1)[i] == reqop))
3253 break;
3254 }
3255 if (i >= STATISTIC_NUM_SLOTS)
3256 return false; /* not there */
3257
3258 sslot->staop = (&stats->staop1)[i];
3259 sslot->stacoll = (&stats->stacoll1)[i];
3260
3261 if (flags & ATTSTATSSLOT_VALUES)
3262 {
3263 val = SysCacheGetAttrNotNull(STATRELATTINH, statstuple,
3264 Anum_pg_statistic_stavalues1 + i);
3265
3266 /*
3267 * Detoast the array if needed, and in any case make a copy that's
3268 * under control of this AttStatsSlot.
3269 */
3270 statarray = DatumGetArrayTypePCopy(val);
3271
3272 /*
3273 * Extract the actual array element type, and pass it back in case the
3274 * caller needs it.
3275 */
3276 sslot->valuetype = arrayelemtype = ARR_ELEMTYPE(statarray);
3277
3278 /* Need info about element type */
3279 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(arrayelemtype));
3280 if (!HeapTupleIsValid(typeTuple))
3281 elog(ERROR, "cache lookup failed for type %u", arrayelemtype);
3282 typeForm = (Form_pg_type) GETSTRUCT(typeTuple);
3283
3284 /* Deconstruct array into Datum elements; NULLs not expected */
3285 deconstruct_array(statarray,
3286 arrayelemtype,
3287 typeForm->typlen,
3288 typeForm->typbyval,
3289 typeForm->typalign,
3290 &sslot->values, NULL, &sslot->nvalues);
3291
3292 /*
3293 * If the element type is pass-by-reference, we now have a bunch of
3294 * Datums that are pointers into the statarray, so we need to keep
3295 * that until free_attstatsslot. Otherwise, all the useful info is in
3296 * sslot->values[], so we can free the array object immediately.
3297 */
3298 if (!typeForm->typbyval)
3299 sslot->values_arr = statarray;
3300 else
3301 pfree(statarray);
3302
3303 ReleaseSysCache(typeTuple);
3304 }
3305
3306 if (flags & ATTSTATSSLOT_NUMBERS)
3307 {
3308 val = SysCacheGetAttrNotNull(STATRELATTINH, statstuple,
3309 Anum_pg_statistic_stanumbers1 + i);
3310
3311 /*
3312 * Detoast the array if needed, and in any case make a copy that's
3313 * under control of this AttStatsSlot.
3314 */
3315 statarray = DatumGetArrayTypePCopy(val);
3316
3317 /*
3318 * We expect the array to be a 1-D float4 array; verify that. We don't
3319 * need to use deconstruct_array() since the array data is just going
3320 * to look like a C array of float4 values.
3321 */
3322 narrayelem = ARR_DIMS(statarray)[0];
3323 if (ARR_NDIM(statarray) != 1 || narrayelem <= 0 ||
3324 ARR_HASNULL(statarray) ||
3325 ARR_ELEMTYPE(statarray) != FLOAT4OID)
3326 elog(ERROR, "stanumbers is not a 1-D float4 array");
3327
3328 /* Give caller a pointer directly into the statarray */
3329 sslot->numbers = (float4 *) ARR_DATA_PTR(statarray);
3330 sslot->nnumbers = narrayelem;
3331
3332 /* We'll free the statarray in free_attstatsslot */
3333 sslot->numbers_arr = statarray;
3334 }
3335
3336 return true;
3337}
3338
3339/*
3340 * free_attstatsslot
3341 * Free data allocated by get_attstatsslot
3342 */
3343void
3345{
3346 /* The values[] array was separately palloc'd by deconstruct_array */
3347 if (sslot->values)
3348 pfree(sslot->values);
3349 /* The numbers[] array points into numbers_arr, do not pfree it */
3350 /* Free the detoasted array objects, if any */
3351 if (sslot->values_arr)
3352 pfree(sslot->values_arr);
3353 if (sslot->numbers_arr)
3354 pfree(sslot->numbers_arr);
3355}
3356
3357/* ---------- PG_NAMESPACE CACHE ---------- */
3358
3359/*
3360 * get_namespace_name
3361 * Returns the name of a given namespace
3362 *
3363 * Returns a palloc'd copy of the string, or NULL if no such namespace.
3364 */
3365char *
3367{
3368 HeapTuple tp;
3369
3370 tp = SearchSysCache1(NAMESPACEOID, ObjectIdGetDatum(nspid));
3371 if (HeapTupleIsValid(tp))
3372 {
3374 char *result;
3375
3376 result = pstrdup(NameStr(nsptup->nspname));
3377 ReleaseSysCache(tp);
3378 return result;
3379 }
3380 else
3381 return NULL;
3382}
3383
3384/*
3385 * get_namespace_name_or_temp
3386 * As above, but if it is this backend's temporary namespace, return
3387 * "pg_temp" instead.
3388 */
3389char *
3391{
3393 return pstrdup("pg_temp");
3394 else
3395 return get_namespace_name(nspid);
3396}
3397
3398/* ---------- PG_RANGE CACHES ---------- */
3399
3400/*
3401 * get_range_subtype
3402 * Returns the subtype of a given range type
3403 *
3404 * Returns InvalidOid if the type is not a range type.
3405 */
3406Oid
3408{
3409 HeapTuple tp;
3410
3411 tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
3412 if (HeapTupleIsValid(tp))
3413 {
3414 Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
3415 Oid result;
3416
3417 result = rngtup->rngsubtype;
3418 ReleaseSysCache(tp);
3419 return result;
3420 }
3421 else
3422 return InvalidOid;
3423}
3424
3425/*
3426 * get_range_collation
3427 * Returns the collation of a given range type
3428 *
3429 * Returns InvalidOid if the type is not a range type,
3430 * or if its subtype is not collatable.
3431 */
3432Oid
3434{
3435 HeapTuple tp;
3436
3437 tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
3438 if (HeapTupleIsValid(tp))
3439 {
3440 Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
3441 Oid result;
3442
3443 result = rngtup->rngcollation;
3444 ReleaseSysCache(tp);
3445 return result;
3446 }
3447 else
3448 return InvalidOid;
3449}
3450
3451/*
3452 * get_range_multirange
3453 * Returns the multirange type of a given range type
3454 *
3455 * Returns InvalidOid if the type is not a range type.
3456 */
3457Oid
3459{
3460 HeapTuple tp;
3461
3462 tp = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(rangeOid));
3463 if (HeapTupleIsValid(tp))
3464 {
3465 Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
3466 Oid result;
3467
3468 result = rngtup->rngmultitypid;
3469 ReleaseSysCache(tp);
3470 return result;
3471 }
3472 else
3473 return InvalidOid;
3474}
3475
3476/*
3477 * get_multirange_range
3478 * Returns the range type of a given multirange
3479 *
3480 * Returns InvalidOid if the type is not a multirange.
3481 */
3482Oid
3484{
3485 HeapTuple tp;
3486
3487 tp = SearchSysCache1(RANGEMULTIRANGE, ObjectIdGetDatum(multirangeOid));
3488 if (HeapTupleIsValid(tp))
3489 {
3490 Form_pg_range rngtup = (Form_pg_range) GETSTRUCT(tp);
3491 Oid result;
3492
3493 result = rngtup->rngtypid;
3494 ReleaseSysCache(tp);
3495 return result;
3496 }
3497 else
3498 return InvalidOid;
3499}
3500
3501/* ---------- PG_INDEX CACHE ---------- */
3502
3503/*
3504 * get_index_column_opclass
3505 *
3506 * Given the index OID and column number,
3507 * return opclass of the index column
3508 * or InvalidOid if the index was not found
3509 * or column is non-key one.
3510 */
3511Oid
3512get_index_column_opclass(Oid index_oid, int attno)
3513{
3514 HeapTuple tuple;
3515 Form_pg_index rd_index;
3516 Datum datum;
3517 oidvector *indclass;
3518 Oid opclass;
3519
3520 /* First we need to know the column's opclass. */
3521
3522 tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
3523 if (!HeapTupleIsValid(tuple))
3524 return InvalidOid;
3525
3526 rd_index = (Form_pg_index) GETSTRUCT(tuple);
3527
3528 /* caller is supposed to guarantee this */
3529 Assert(attno > 0 && attno <= rd_index->indnatts);
3530
3531 /* Non-key attributes don't have an opclass */
3532 if (attno > rd_index->indnkeyatts)
3533 {
3534 ReleaseSysCache(tuple);
3535 return InvalidOid;
3536 }
3537
3538 datum = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indclass);
3539 indclass = ((oidvector *) DatumGetPointer(datum));
3540
3541 Assert(attno <= indclass->dim1);
3542 opclass = indclass->values[attno - 1];
3543
3544 ReleaseSysCache(tuple);
3545
3546 return opclass;
3547}
3548
3549/*
3550 * get_index_isreplident
3551 *
3552 * Given the index OID, return pg_index.indisreplident.
3553 */
3554bool
3556{
3557 HeapTuple tuple;
3558 Form_pg_index rd_index;
3559 bool result;
3560
3561 tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
3562 if (!HeapTupleIsValid(tuple))
3563 return false;
3564
3565 rd_index = (Form_pg_index) GETSTRUCT(tuple);
3566 result = rd_index->indisreplident;
3567 ReleaseSysCache(tuple);
3568
3569 return result;
3570}
3571
3572/*
3573 * get_index_isvalid
3574 *
3575 * Given the index OID, return pg_index.indisvalid.
3576 */
3577bool
3579{
3580 bool isvalid;
3581 HeapTuple tuple;
3582 Form_pg_index rd_index;
3583
3584 tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
3585 if (!HeapTupleIsValid(tuple))
3586 elog(ERROR, "cache lookup failed for index %u", index_oid);
3587
3588 rd_index = (Form_pg_index) GETSTRUCT(tuple);
3589 isvalid = rd_index->indisvalid;
3590 ReleaseSysCache(tuple);
3591
3592 return isvalid;
3593}
3594
3595/*
3596 * get_index_isclustered
3597 *
3598 * Given the index OID, return pg_index.indisclustered.
3599 */
3600bool
3602{
3603 bool isclustered;
3604 HeapTuple tuple;
3605 Form_pg_index rd_index;
3606
3607 tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid));
3608 if (!HeapTupleIsValid(tuple))
3609 elog(ERROR, "cache lookup failed for index %u", index_oid);
3610
3611 rd_index = (Form_pg_index) GETSTRUCT(tuple);
3612 isclustered = rd_index->indisclustered;
3613 ReleaseSysCache(tuple);
3614
3615 return isclustered;
3616}
3617
3618/*
3619 * get_publication_oid - given a publication name, look up the OID
3620 *
3621 * If missing_ok is false, throw an error if name not found. If true, just
3622 * return InvalidOid.
3623 */
3624Oid
3625get_publication_oid(const char *pubname, bool missing_ok)
3626{
3627 Oid oid;
3628
3629 oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
3630 CStringGetDatum(pubname));
3631 if (!OidIsValid(oid) && !missing_ok)
3632 ereport(ERROR,
3633 (errcode(ERRCODE_UNDEFINED_OBJECT),
3634 errmsg("publication \"%s\" does not exist", pubname)));
3635 return oid;
3636}
3637
3638/*
3639 * get_publication_name - given a publication Oid, look up the name
3640 *
3641 * If missing_ok is false, throw an error if name not found. If true, just
3642 * return NULL.
3643 */
3644char *
3645get_publication_name(Oid pubid, bool missing_ok)
3646{
3647 HeapTuple tup;
3648 char *pubname;
3649 Form_pg_publication pubform;
3650
3651 tup = SearchSysCache1(PUBLICATIONOID, ObjectIdGetDatum(pubid));
3652
3653 if (!HeapTupleIsValid(tup))
3654 {
3655 if (!missing_ok)
3656 elog(ERROR, "cache lookup failed for publication %u", pubid);
3657 return NULL;
3658 }
3659
3660 pubform = (Form_pg_publication) GETSTRUCT(tup);
3661 pubname = pstrdup(NameStr(pubform->pubname));
3662
3663 ReleaseSysCache(tup);
3664
3665 return pubname;
3666}
3667
3668/*
3669 * get_subscription_oid - given a subscription name, look up the OID
3670 *
3671 * If missing_ok is false, throw an error if name not found. If true, just
3672 * return InvalidOid.
3673 */
3674Oid
3675get_subscription_oid(const char *subname, bool missing_ok)
3676{
3677 Oid oid;
3678
3679 oid = GetSysCacheOid2(SUBSCRIPTIONNAME, Anum_pg_subscription_oid,
3681 if (!OidIsValid(oid) && !missing_ok)
3682 ereport(ERROR,
3683 (errcode(ERRCODE_UNDEFINED_OBJECT),
3684 errmsg("subscription \"%s\" does not exist", subname)));
3685 return oid;
3686}
3687
3688/*
3689 * get_subscription_name - given a subscription OID, look up the name
3690 *
3691 * If missing_ok is false, throw an error if name not found. If true, just
3692 * return NULL.
3693 */
3694char *
3695get_subscription_name(Oid subid, bool missing_ok)
3696{
3697 HeapTuple tup;
3698 char *subname;
3699 Form_pg_subscription subform;
3700
3701 tup = SearchSysCache1(SUBSCRIPTIONOID, ObjectIdGetDatum(subid));
3702
3703 if (!HeapTupleIsValid(tup))
3704 {
3705 if (!missing_ok)
3706 elog(ERROR, "cache lookup failed for subscription %u", subid);
3707 return NULL;
3708 }
3709
3710 subform = (Form_pg_subscription) GETSTRUCT(tup);
3711 subname = pstrdup(NameStr(subform->subname));
3712
3713 ReleaseSysCache(tup);
3714
3715 return subname;
3716}
#define DatumGetArrayTypePCopy(X)
Definition: array.h:262
#define ARR_NDIM(a)
Definition: array.h:290
#define ARR_DATA_PTR(a)
Definition: array.h:322
#define ARR_ELEMTYPE(a)
Definition: array.h:292
#define ARR_DIMS(a)
Definition: array.h:294
#define ARR_HASNULL(a)
Definition: array.h:291
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3631
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
void boot_get_type_io_data(Oid typid, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *typinput, Oid *typoutput)
Definition: bootstrap.c:837
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NameStr(name)
Definition: c.h:700
#define Assert(condition)
Definition: c.h:812
int16_t int16
Definition: c.h:480
regproc RegProcedure
Definition: c.h:604
int32_t int32
Definition: c.h:481
float float4
Definition: c.h:583
#define OidIsValid(objectId)
Definition: c.h:729
int nspid
Oid collid
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1754
#define OidFunctionCall0(functionId)
Definition: fmgr.h:677
int32 type_maximum_size(Oid type_oid, int32 typemod)
Definition: format_type.c:412
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
Oid MyDatabaseId
Definition: globals.c:93
#define HASHSTANDARD_PROC
Definition: hash.h:355
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
long val
Definition: informix.c:689
int i
Definition: isn.c:72
List * lappend(List *list, void *datum)
Definition: list.c:339
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722
List * get_op_btree_interpretation(Oid opno)
Definition: lsyscache.c:601
Oid get_range_subtype(Oid rangeOid)
Definition: lsyscache.c:3407
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1928
void get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op, int *strategy, Oid *lefttype, Oid *righttype)
Definition: lsyscache.c:136
Oid get_func_variadictype(Oid funcid)
Definition: lsyscache.c:1723
Oid get_opclass_method(Oid opclass)
Definition: lsyscache.c:1260
bool get_compatible_hash_operators(Oid opno, Oid *lhs_opno, Oid *rhs_opno)
Definition: lsyscache.c:410
bool get_rel_relispartition(Oid relid)
Definition: lsyscache.c:2027
Oid get_op_opfamily_sortfamily(Oid opno, Oid opfamily)
Definition: lsyscache.c:108
char get_rel_persistence(Oid relid)
Definition: lsyscache.c:2078
char get_func_prokind(Oid funcid)
Definition: lsyscache.c:1818
bool get_index_isvalid(Oid index_oid)
Definition: lsyscache.c:3578
Oid get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok)
Definition: lsyscache.c:1007
void getTypeBinaryOutputInfo(Oid type, Oid *typSend, bool *typIsVarlena)
Definition: lsyscache.c:2973
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:858
RegProcedure get_oprrest(Oid opno)
Definition: lsyscache.c:1557
void free_attstatsslot(AttStatsSlot *sslot)
Definition: lsyscache.c:3344
bool comparison_ops_are_compatible(Oid opno1, Oid opno2)
Definition: lsyscache.c:749
Oid get_constraint_index(Oid conoid)
Definition: lsyscache.c:1113
bool get_func_retset(Oid funcid)
Definition: lsyscache.c:1742
Oid get_element_type(Oid typid)
Definition: lsyscache.c:2759
Oid get_opclass_input_type(Oid opclass)
Definition: lsyscache.c:1212
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2655
bool type_is_range(Oid typid)
Definition: lsyscache.c:2688
char func_parallel(Oid funcid)
Definition: lsyscache.c:1799
Oid get_opclass_family(Oid opclass)
Definition: lsyscache.c:1190
char get_attgenerated(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:888
bool type_is_enum(Oid typid)
Definition: lsyscache.c:2678
Oid get_multirange_range(Oid multirangeOid)
Definition: lsyscache.c:3483
Oid get_typmodin(Oid typid)
Definition: lsyscache.c:3006
char get_typstorage(Oid typid)
Definition: lsyscache.c:2419
bool get_opclass_opfamily_and_input_type(Oid opclass, Oid *opfamily, Oid *opcintype)
Definition: lsyscache.c:1235
RegProcedure get_func_support(Oid funcid)
Definition: lsyscache.c:1858
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2907
bool get_typisdefined(Oid typid)
Definition: lsyscache.c:2173
char * get_opname(Oid opno)
Definition: lsyscache.c:1310
Datum get_attoptions(Oid relid, int16 attnum)
Definition: lsyscache.c:970
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition: lsyscache.c:2271
int32 get_attavgwidth(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:3158
bool get_index_isreplident(Oid index_oid)
Definition: lsyscache.c:3555
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition: lsyscache.c:796
RegProcedure get_oprjoin(Oid opno)
Definition: lsyscache.c:1581
Oid get_equality_op_for_ordering_op(Oid opno, bool *reverse)
Definition: lsyscache.c:267
bool op_strict(Oid opno)
Definition: lsyscache.c:1477
bool op_hashjoinable(Oid opno, Oid inputtype)
Definition: lsyscache.c:1437
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:2003
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
Definition: lsyscache.c:2251
Oid get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
Definition: lsyscache.c:1696
Oid get_publication_oid(const char *pubname, bool missing_ok)
Definition: lsyscache.c:3625
Oid get_rel_namespace(Oid relid)
Definition: lsyscache.c:1952
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1285
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3056
Oid get_op_rettype(Oid opno)
Definition: lsyscache.c:1333
int get_op_opfamily_strategy(Oid opno, Oid opfamily)
Definition: lsyscache.c:83
char * get_collation_name(Oid colloid)
Definition: lsyscache.c:1035
Oid get_rel_type_id(Oid relid)
Definition: lsyscache.c:1979
char * get_language_name(Oid langoid, bool missing_ok)
Definition: lsyscache.c:1161
char * get_namespace_name_or_temp(Oid nspid)
Definition: lsyscache.c:3390
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2874
char func_volatile(Oid funcid)
Definition: lsyscache.c:1780
bool equality_ops_are_compatible(Oid opno1, Oid opno2)
Definition: lsyscache.c:698
get_attavgwidth_hook_type get_attavgwidth_hook
Definition: lsyscache.c:53
bool get_index_isclustered(Oid index_oid)
Definition: lsyscache.c:3601
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition: lsyscache.c:166
Oid get_ordering_op_for_equality_op(Oid opno, bool use_lhs_type)
Definition: lsyscache.c:305
Oid get_transform_tosql(Oid typid, Oid langid, List *trftypes)
Definition: lsyscache.c:2142
bool func_strict(Oid funcid)
Definition: lsyscache.c:1761
Oid get_index_column_opclass(Oid index_oid, int attno)
Definition: lsyscache.c:3512
char * get_constraint_name(Oid conoid)
Definition: lsyscache.c:1081
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Definition: lsyscache.c:827
bool get_ordering_op_properties(Oid opno, Oid *opfamily, Oid *opcintype, int16 *strategy)
Definition: lsyscache.c:207
bool get_func_leakproof(Oid funcid)
Definition: lsyscache.c:1837
const struct SubscriptRoutines * getSubscriptingRoutines(Oid typid, Oid *typelemp)
Definition: lsyscache.c:3130
Node * get_typdefault(Oid typid)
Definition: lsyscache.c:2448
bool get_collation_isdeterministic(Oid colloid)
Definition: lsyscache.c:1054
Oid get_subscription_oid(const char *subname, bool missing_ok)
Definition: lsyscache.c:3675
char * get_subscription_name(Oid subid, bool missing_ok)
Definition: lsyscache.c:3695
Oid get_range_collation(Oid rangeOid)
Definition: lsyscache.c:3433
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1608
Oid get_range_multirange(Oid rangeOid)
Definition: lsyscache.c:3458
Oid get_rel_relam(Oid relid)
Definition: lsyscache.c:2100
char op_volatile(Oid opno)
Definition: lsyscache.c:1493
Oid get_func_namespace(Oid funcid)
Definition: lsyscache.c:1632
bool type_is_collatable(Oid typid)
Definition: lsyscache.c:3081
Oid get_rel_tablespace(Oid relid)
Definition: lsyscache.c:2054
int get_func_nargs(Oid funcid)
Definition: lsyscache.c:1674
void get_type_io_data(Oid typid, IOFuncSelector which_func, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *func)
Definition: lsyscache.c:2325
int16 get_typlen(Oid typid)
Definition: lsyscache.c:2197
Oid get_typ_typrelid(Oid typid)
Definition: lsyscache.c:2731
char get_typtype(Oid typid)
Definition: lsyscache.c:2629
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2832
Oid getTypeIOParam(HeapTuple typeTuple)
Definition: lsyscache.c:2303
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2538
Oid get_transform_fromsql(Oid typid, Oid langid, List *trftypes)
Definition: lsyscache.c:2120
char * get_publication_name(Oid pubid, bool missing_ok)
Definition: lsyscache.c:3645
Oid getBaseType(Oid typid)
Definition: lsyscache.c:2521
bool get_op_hash_functions(Oid opno, RegProcedure *lhs_procno, RegProcedure *rhs_procno)
Definition: lsyscache.c:510
bool get_typbyval(Oid typid)
Definition: lsyscache.c:2222
bool op_mergejoinable(Oid opno, Oid inputtype)
Definition: lsyscache.c:1386
List * get_mergejoin_opfamilies(Oid opno)
Definition: lsyscache.c:366
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3366
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2787
Oid get_func_rettype(Oid funcid)
Definition: lsyscache.c:1655
Oid get_promoted_array_type(Oid typid)
Definition: lsyscache.c:2811
Oid get_atttype(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:913
char get_constraint_type(Oid conoid)
Definition: lsyscache.c:1143
int32 get_typavgwidth(Oid typid, int32 typmod)
Definition: lsyscache.c:2578
bool op_in_opfamily(Oid opno, Oid opfamily)
Definition: lsyscache.c:66
RegProcedure get_typsubscript(Oid typid, Oid *typelemp)
Definition: lsyscache.c:3097
void get_type_category_preferred(Oid typid, char *typcategory, bool *typispreferred)
Definition: lsyscache.c:2710
bool get_attstatsslot(AttStatsSlot *sslot, HeapTuple statstuple, int reqkind, Oid reqop, int flags)
Definition: lsyscache.c:3234
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition: lsyscache.c:1885
Oid get_negator(Oid opno)
Definition: lsyscache.c:1533
Oid get_commutator(Oid opno)
Definition: lsyscache.c:1509
void op_input_types(Oid opno, Oid *lefttype, Oid *righttype)
Definition: lsyscache.c:1358
bool type_is_multirange(Oid typid)
Definition: lsyscache.c:2698
void getTypeBinaryInputInfo(Oid type, Oid *typReceive, Oid *typIOParam)
Definition: lsyscache.c:2940
void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid)
Definition: lsyscache.c:943
#define ATTSTATSSLOT_NUMBERS
Definition: lsyscache.h:43
#define ATTSTATSSLOT_VALUES
Definition: lsyscache.h:42
IOFuncSelector
Definition: lsyscache.h:34
@ IOFunc_output
Definition: lsyscache.h:36
@ IOFunc_input
Definition: lsyscache.h:35
@ IOFunc_send
Definition: lsyscache.h:38
@ IOFunc_receive
Definition: lsyscache.h:37
int32(* get_attavgwidth_hook_type)(Oid relid, AttrNumber attnum)
Definition: lsyscache.h:65
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:301
char * pstrdup(const char *in)
Definition: mcxt.c:1696
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc(Size size)
Definition: mcxt.c:1317
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:466
bool isTempNamespace(Oid namespaceId)
Definition: namespace.c:3649
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
FormData_pg_amproc * Form_pg_amproc
Definition: pg_amproc.h:68
NameData attname
Definition: pg_attribute.h:41
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
NameData relname
Definition: pg_class.h:38
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
FormData_pg_collation * Form_pg_collation
Definition: pg_collation.h:58
FormData_pg_constraint * Form_pg_constraint
FormData_pg_index * Form_pg_index
Definition: pg_index.h:70
FormData_pg_language * Form_pg_language
Definition: pg_language.h:65
#define NIL
Definition: pg_list.h:68
FormData_pg_namespace * Form_pg_namespace
Definition: pg_namespace.h:52
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
int16 pronargs
Definition: pg_proc.h:81
FormData_pg_publication * Form_pg_publication
FormData_pg_range * Form_pg_range
Definition: pg_range.h:58
#define STATISTIC_NUM_SLOTS
Definition: pg_statistic.h:127
FormData_pg_statistic * Form_pg_statistic
Definition: pg_statistic.h:135
NameData subname
FormData_pg_subscription * Form_pg_subscription
FormData_pg_transform * Form_pg_transform
Definition: pg_transform.h:43
char typalign
Definition: pg_type.h:176
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Datum Int16GetDatum(int16 X)
Definition: postgres.h:172
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
static Datum CharGetDatum(char X)
Definition: postgres.h:122
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
@ ROWCOMPARE_NE
Definition: primnodes.h:1460
void * stringToNode(const char *str)
Definition: read.c:90
uint16 StrategyNumber
Definition: stratnum.h:22
#define BTGreaterStrategyNumber
Definition: stratnum.h:33
#define HTEqualStrategyNumber
Definition: stratnum.h:41
#define BTLessStrategyNumber
Definition: stratnum.h:29
#define BTEqualStrategyNumber
Definition: stratnum.h:31
Oid valuetype
Definition: lsyscache.h:52
Datum * values
Definition: lsyscache.h:53
void * numbers_arr
Definition: lsyscache.h:61
float4 * numbers
Definition: lsyscache.h:56
int nnumbers
Definition: lsyscache.h:57
void * values_arr
Definition: lsyscache.h:60
Definition: pg_list.h:54
Definition: nodes.h:129
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:180
int n_members
Definition: catcache.h:178
HeapTupleData tuple
Definition: catcache.h:123
Definition: c.h:680
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:687
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221
HeapTuple SearchSysCache3(int cacheId, Datum key1, Datum key2, Datum key3)
Definition: syscache.c:243
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:600
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
Definition: syscache.c:232
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
Definition: syscache.c:480
HeapTuple SearchSysCache4(int cacheId, Datum key1, Datum key2, Datum key3, Datum key4)
Definition: syscache.c:254
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:631
#define ReleaseSysCacheList(x)
Definition: syscache.h:134
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:127
#define SearchSysCacheExists3(cacheId, key1, key2, key3)
Definition: syscache.h:104
#define GetSysCacheOid1(cacheId, oidcol, key1)
Definition: syscache.h:109
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
Definition: syscache.h:111
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:386
#define TYPECACHE_CMP_PROC
Definition: typcache.h:140
#define TYPECACHE_HASH_PROC
Definition: typcache.h:141
const char * type