| blob | 48a280d089b70d1606240dd3357ea9afeba5c918 |
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 */
52 /* Hook for plugins to get control in get_attavgwidth() */
56 /* ---------- AMOP CACHES ---------- */
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 */
65 bool
67 {
72 }
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 */
82 int
84 {
85 HeapTuple tp;
86 Form_pg_amop amop_tup;
99 }
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 */
107 Oid
109 {
110 HeapTuple tp;
111 Form_pg_amop amop_tup;
112 Oid result;
124 }
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 */
135 void
140 {
141 HeapTuple tp;
142 Form_pg_amop amop_tup;
156 }
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 */
165 Oid
167 int16 strategy)
168 {
169 HeapTuple tp;
170 Form_pg_amop amop_tup;
171 Oid result;
184 }
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 */
206 bool
209 {
214 /* ensure outputs are initialized on failure */
219 /*
220 * Search pg_amop to see if the target operator is registered as the "<"
221 * or ">" operator of any btree opfamily.
222 */
226 {
230 /* must be btree */
236 {
237 /* Found it ... should have consistent input types */
239 {
240 /* Found a suitable opfamily, return info */
246 }
247 }
248 }
253 }
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 */
266 Oid
268 {
270 Oid opfamily;
271 Oid opcintype;
272 int16 strategy;
274 /* Find the operator in pg_amop */
277 {
278 /* Found a suitable opfamily, get matching equality operator */
280 opcintype,
281 opcintype,
282 BTEqualStrategyNumber);
285 }
288 }
290 /*
291 * get_ordering_op_for_equality_op
292 * Get the OID of a datatype-specific btree 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 */
304 Oid
306 {
311 /*
312 * Search pg_amop to see if the target operator is registered as the "="
313 * operator of any btree opfamily.
314 */
318 {
322 /* must be btree */
327 {
328 /* Found a suitable opfamily, get matching ordering operator */
329 Oid typid;
334 BTLessStrategyNumber);
337 /* failure probably shouldn't happen, but keep looking if so */
338 }
339 }
344 }
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 */
365 List *
367 {
372 /*
373 * Search pg_amop to see if the target operator is registered as the "="
374 * operator of any btree opfamily.
375 */
379 {
383 /* must be btree equality */
387 }
392 }
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 */
409 bool
412 {
417 /* Ensure output args are initialized on failure */
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 */
431 {
437 {
438 /* No extra lookup needed if given operator is single-type */
440 {
447 }
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 */
455 {
459 HTEqualStrategyNumber);
462 /* Matching LHS found, done if caller doesn't want RHS */
464 {
467 }
468 }
470 {
474 HTEqualStrategyNumber);
476 {
477 /* Forget any LHS operator from this opfamily */
481 }
482 /* Matching RHS found, so done */
485 }
486 }
487 }
492 }
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 */
509 bool
512 {
517 /* Ensure output args are initialized on failure */
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 */
531 {
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 */
544 {
548 HASHSTANDARD_PROC);
551 /* Matching LHS found, done if caller doesn't want RHS */
553 {
556 }
557 /* Only one lookup needed if given operator is single-type */
559 {
563 }
564 }
566 {
570 HASHSTANDARD_PROC);
572 {
573 /* Forget any LHS function from this opfamily */
577 }
578 /* Matching RHS found, so done */
581 }
582 }
583 }
588 }
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 */
600 List *
602 {
608 /*
609 * Find all the pg_amop entries containing the operator.
610 */
614 {
617 StrategyNumber op_strategy;
619 /* must be btree */
623 /* Get the operator's btree strategy number */
634 }
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 */
643 {
647 {
652 {
655 StrategyNumber op_strategy;
657 /* must be btree */
661 /* Get the operator's btree strategy number */
665 /* Only consider negators that are = */
669 /* OK, report it with "strategy" ROWCOMPARE_NE */
677 }
680 }
681 }
684 }
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 */
697 bool
699 {
704 /* Easy if they're the same operator */
708 /*
709 * We search through all the pg_amop entries for opno1.
710 */
715 {
719 /* must be btree or hash */
722 {
724 {
727 }
728 }
729 }
734 }
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 */
748 bool
750 {
755 /* Easy if they're the same operator */
759 /*
760 * We search through all the pg_amop entries for opno1.
761 */
766 {
771 {
773 {
776 }
777 }
778 }
783 }
786 /* ---------- AMPROC CACHES ---------- */
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 */
795 Oid
797 {
798 HeapTuple tp;
799 Form_pg_amproc amproc_tup;
800 RegProcedure result;
813 }
816 /* ---------- ATTRIBUTE CACHES ---------- */
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 */
828 {
829 HeapTuple tp;
834 {
841 }
847 }
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 */
857 AttrNumber
859 {
860 HeapTuple tp;
864 {
866 AttrNumber result;
871 }
872 else
874 }
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 */
887 char
889 {
890 HeapTuple tp;
891 Form_pg_attribute att_tup;
904 }
906 /*
907 * get_atttype
908 *
909 * Given the relation OID and the attribute number with the relation,
910 * return the attribute type OID.
911 */
912 Oid
914 {
915 HeapTuple tp;
921 {
923 Oid result;
928 }
929 else
931 }
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 */
942 void
945 {
946 HeapTuple tp;
947 Form_pg_attribute att_tup;
961 }
963 /*
964 * get_attoptions
965 *
966 * Given the relation id and the attribute number,
967 * return the attribute options text[] datum, if any.
968 */
969 Datum
971 {
972 HeapTuple tuple;
973 Datum attopts;
974 Datum result;
990 else
996 }
998 /* ---------- PG_CAST CACHE ---------- */
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 */
1006 Oid
1008 {
1009 Oid oid;
1021 }
1023 /* ---------- COLLATION CACHE ---------- */
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 */
1036 {
1037 HeapTuple tp;
1041 {
1048 }
1049 else
1051 }
1053 bool
1055 {
1056 HeapTuple tp;
1057 Form_pg_collation colltup;
1067 }
1069 /* ---------- CONSTRAINT CACHE ---------- */
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 */
1082 {
1083 HeapTuple tp;
1087 {
1094 }
1095 else
1097 }
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 */
1112 Oid
1114 {
1115 HeapTuple tp;
1119 {
1121 Oid result;
1127 else
1131 }
1132 else
1134 }
1136 /*
1137 * get_constraint_type
1138 * Return the pg_constraint.contype value for the given constraint.
1139 *
1140 * No frills.
1141 */
1142 char
1144 {
1145 HeapTuple tp;
1156 }
1158 /* ---------- LANGUAGE CACHE ---------- */
1162 {
1163 HeapTuple tp;
1167 {
1174 }
1178 langoid);
1180 }
1182 /* ---------- OPCLASS CACHE ---------- */
1184 /*
1185 * get_opclass_family
1186 *
1187 * Returns the OID of the operator family the opclass belongs to.
1188 */
1189 Oid
1191 {
1192 HeapTuple tp;
1193 Form_pg_opclass cla_tup;
1194 Oid result;
1204 }
1206 /*
1207 * get_opclass_input_type
1208 *
1209 * Returns the OID of the datatype the opclass indexes.
1210 */
1211 Oid
1213 {
1214 HeapTuple tp;
1215 Form_pg_opclass cla_tup;
1216 Oid result;
1226 }
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 */
1234 bool
1236 {
1237 HeapTuple tp;
1238 Form_pg_opclass cla_tup;
1252 }
1254 /*
1255 * get_opclass_method
1256 *
1257 * Returns the OID of the index access method the opclass belongs to.
1258 */
1259 Oid
1261 {
1262 HeapTuple tp;
1263 Form_pg_opclass cla_tup;
1264 Oid result;
1274 }
1276 /* ---------- OPERATOR CACHE ---------- */
1278 /*
1279 * get_opcode
1280 *
1281 * Returns the regproc id of the routine used to implement an
1282 * operator given the operator oid.
1283 */
1284 RegProcedure
1286 {
1287 HeapTuple tp;
1291 {
1293 RegProcedure result;
1298 }
1299 else
1301 }
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 */
1311 {
1312 HeapTuple tp;
1316 {
1323 }
1324 else
1326 }
1328 /*
1329 * get_op_rettype
1330 * Given operator oid, return the operator's result type.
1331 */
1332 Oid
1334 {
1335 HeapTuple tp;
1339 {
1341 Oid result;
1346 }
1347 else
1349 }
1351 /*
1352 * op_input_types
1353 *
1354 * Returns the left and right input datatypes for an operator
1355 * (InvalidOid if not relevant).
1356 */
1357 void
1359 {
1360 HeapTuple tp;
1361 Form_pg_operator optup;
1370 }
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 */
1385 bool
1387 {
1389 HeapTuple tp;
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 */
1399 {
1403 }
1405 {
1409 }
1410 else
1411 {
1412 /* For all other operators, rely on pg_operator.oprcanmerge */
1415 {
1420 }
1421 }
1423 }
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 */
1436 bool
1438 {
1440 HeapTuple tp;
1443 /* As in op_mergejoinable, let the typcache handle the hard cases */
1445 {
1449 }
1451 {
1455 }
1456 else
1457 {
1458 /* For all other operators, rely on pg_operator.oprcanhash */
1461 {
1466 }
1467 }
1469 }
1471 /*
1472 * op_strict
1473 *
1474 * Get the proisstrict flag for the operator's underlying function.
1475 */
1476 bool
1478 {
1485 }
1487 /*
1488 * op_volatile
1489 *
1490 * Get the provolatile flag for the operator's underlying function.
1491 */
1492 char
1494 {
1501 }
1503 /*
1504 * get_commutator
1505 *
1506 * Returns the corresponding commutator of an operator.
1507 */
1508 Oid
1510 {
1511 HeapTuple tp;
1515 {
1517 Oid result;
1522 }
1523 else
1525 }
1527 /*
1528 * get_negator
1529 *
1530 * Returns the corresponding negator of an operator.
1531 */
1532 Oid
1534 {
1535 HeapTuple tp;
1539 {
1541 Oid result;
1546 }
1547 else
1549 }
1551 /*
1552 * get_oprrest
1553 *
1554 * Returns procedure id for computing selectivity of an operator.
1555 */
1556 RegProcedure
1558 {
1559 HeapTuple tp;
1563 {
1565 RegProcedure result;
1570 }
1571 else
1573 }
1575 /*
1576 * get_oprjoin
1577 *
1578 * Returns procedure id for computing selectivity of a join.
1579 */
1580 RegProcedure
1582 {
1583 HeapTuple tp;
1587 {
1589 RegProcedure result;
1594 }
1595 else
1597 }
1599 /* ---------- FUNCTION CACHE ---------- */
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 */
1609 {
1610 HeapTuple tp;
1614 {
1621 }
1622 else
1624 }
1626 /*
1627 * get_func_namespace
1628 *
1629 * Returns the pg_namespace OID associated with a given function.
1630 */
1631 Oid
1633 {
1634 HeapTuple tp;
1638 {
1640 Oid result;
1645 }
1646 else
1648 }
1650 /*
1651 * get_func_rettype
1652 * Given procedure id, return the function's result type.
1653 */
1654 Oid
1656 {
1657 HeapTuple tp;
1658 Oid result;
1667 }
1669 /*
1670 * get_func_nargs
1671 * Given procedure id, return the number of arguments.
1672 */
1673 int
1675 {
1676 HeapTuple tp;
1686 }
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 */
1695 Oid
1697 {
1698 HeapTuple tp;
1699 Form_pg_proc procstruct;
1700 Oid result;
1716 }
1718 /*
1719 * get_func_variadictype
1720 * Given procedure id, return the function's provariadic field.
1721 */
1722 Oid
1724 {
1725 HeapTuple tp;
1726 Oid result;
1735 }
1737 /*
1738 * get_func_retset
1739 * Given procedure id, return the function's proretset flag.
1740 */
1741 bool
1743 {
1744 HeapTuple tp;
1754 }
1756 /*
1757 * func_strict
1758 * Given procedure id, return the function's proisstrict flag.
1759 */
1760 bool
1762 {
1763 HeapTuple tp;
1773 }
1775 /*
1776 * func_volatile
1777 * Given procedure id, return the function's provolatile flag.
1778 */
1779 char
1781 {
1782 HeapTuple tp;
1792 }
1794 /*
1795 * func_parallel
1796 * Given procedure id, return the function's proparallel flag.
1797 */
1798 char
1800 {
1801 HeapTuple tp;
1811 }
1813 /*
1814 * get_func_prokind
1815 * Given procedure id, return the routine kind.
1816 */
1817 char
1819 {
1820 HeapTuple tp;
1830 }
1832 /*
1833 * get_func_leakproof
1834 * Given procedure id, return the function's leakproof field.
1835 */
1836 bool
1838 {
1839 HeapTuple tp;
1849 }
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 */
1857 RegProcedure
1859 {
1860 HeapTuple tp;
1864 {
1866 RegProcedure result;
1871 }
1872 else
1874 }
1876 /* ---------- RELATION CACHE ---------- */
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 */
1884 Oid
1886 {
1890 }
1892 #ifdef NOT_USED
1893 /*
1894 * get_relnatts
1895 *
1896 * Returns the number of attributes for a given relation.
1897 */
1898 int
1900 {
1901 HeapTuple tp;
1905 {
1912 }
1913 else
1915 }
1916 #endif
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 */
1929 {
1930 HeapTuple tp;
1934 {
1941 }
1942 else
1944 }
1946 /*
1947 * get_rel_namespace
1948 *
1949 * Returns the pg_namespace OID associated with a given relation.
1950 */
1951 Oid
1953 {
1954 HeapTuple tp;
1958 {
1960 Oid result;
1965 }
1966 else
1968 }
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 */
1978 Oid
1980 {
1981 HeapTuple tp;
1985 {
1987 Oid result;
1992 }
1993 else
1995 }
1997 /*
1998 * get_rel_relkind
1999 *
2000 * Returns the relkind associated with a given relation.
2001 */
2002 char
2004 {
2005 HeapTuple tp;
2009 {
2016 }
2017 else
2019 }
2021 /*
2022 * get_rel_relispartition
2023 *
2024 * Returns the relispartition flag associated with a given relation.
2025 */
2026 bool
2028 {
2029 HeapTuple tp;
2033 {
2040 }
2041 else
2043 }
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 */
2053 Oid
2055 {
2056 HeapTuple tp;
2060 {
2062 Oid result;
2067 }
2068 else
2070 }
2072 /*
2073 * get_rel_persistence
2074 *
2075 * Returns the relpersistence associated with a given relation.
2076 */
2077 char
2079 {
2080 HeapTuple tp;
2081 Form_pg_class reltup;
2092 }
2094 /*
2095 * get_rel_relam
2096 *
2097 * Returns the relam associated with a given relation.
2098 */
2099 Oid
2101 {
2102 HeapTuple tp;
2103 Form_pg_class reltup;
2104 Oid result;
2114 }
2117 /* ---------- TRANSFORM CACHE ---------- */
2119 Oid
2121 {
2122 HeapTuple tup;
2130 {
2131 Oid funcid;
2136 }
2137 else
2139 }
2141 Oid
2143 {
2144 HeapTuple tup;
2152 {
2153 Oid funcid;
2158 }
2159 else
2161 }
2164 /* ---------- TYPE CACHE ---------- */
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 */
2172 bool
2174 {
2175 HeapTuple tp;
2179 {
2186 }
2187 else
2189 }
2191 /*
2192 * get_typlen
2193 *
2194 * Given the type OID, return the length of the type.
2195 */
2196 int16
2198 {
2199 HeapTuple tp;
2203 {
2205 int16 result;
2210 }
2211 else
2213 }
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 */
2221 bool
2223 {
2224 HeapTuple tp;
2228 {
2235 }
2236 else
2238 }
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 */
2250 void
2252 {
2253 HeapTuple tp;
2254 Form_pg_type typtup;
2263 }
2265 /*
2266 * get_typlenbyvalalign
2267 *
2268 * A three-fer: given the type OID, return typlen, typbyval, typalign.
2269 */
2270 void
2273 {
2274 HeapTuple tp;
2275 Form_pg_type typtup;
2285 }
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 */
2302 Oid
2304 {
2307 /*
2308 * Array types get their typelem as parameter; everybody else gets their
2309 * own type OID as parameter.
2310 */
2313 else
2315 }
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 */
2324 void
2326 IOFuncSelector which_func,
2333 {
2334 HeapTuple typeTuple;
2335 Form_pg_type typeStruct;
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;
2347 typlen,
2348 typbyval,
2349 typalign,
2350 typdelim,
2351 typioparam,
2355 {
2365 }
2367 }
2380 {
2393 }
2395 }
2397 #ifdef NOT_USED
2398 char
2400 {
2401 HeapTuple tp;
2405 {
2412 }
2413 else
2415 }
2416 #endif
2418 char
2420 {
2421 HeapTuple tp;
2425 {
2432 }
2433 else
2435 }
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 */
2447 Node *
2449 {
2450 HeapTuple typeTuple;
2451 Form_pg_type type;
2452 Datum datum;
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 */
2467 typeTuple,
2468 Anum_pg_type_typdefaultbin,
2472 {
2473 /* We have an expression default */
2475 }
2476 else
2477 {
2478 /* Perhaps we have a plain literal default */
2480 typeTuple,
2481 Anum_pg_type_typdefault,
2485 {
2488 /* Convert text datum to C string */
2490 /* Convert C string to a value of the given type */
2493 /* Build a Const node containing the value */
2498 datum,
2502 }
2503 else
2504 {
2505 /* No default */
2507 }
2508 }
2513 }
2515 /*
2516 * getBaseType
2517 * If the given type is a domain, return its base type;
2518 * otherwise return the type's own OID.
2519 */
2520 Oid
2522 {
2526 }
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 */
2537 Oid
2539 {
2540 /*
2541 * We loop to find the bottom base type in a stack of domains.
2542 */
2544 {
2545 HeapTuple tup;
2546 Form_pg_type typTup;
2553 {
2554 /* Not a domain, so done */
2557 }
2564 }
2567 }
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 */
2577 int32
2579 {
2581 int32 maxwidth;
2583 /*
2584 * Easy if it's a fixed-width type
2585 */
2589 /*
2590 * type_maximum_size knows the encoding of typmod for some datatypes;
2591 * don't duplicate that knowledge here.
2592 */
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 */
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 */
2614 }
2616 /*
2617 * Oops, we have no idea ... wild guess time.
2618 */
2620 }
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 */
2628 char
2630 {
2631 HeapTuple tp;
2635 {
2642 }
2643 else
2645 }
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 */
2654 bool
2656 {
2660 {
2669 }
2671 }
2673 /*
2674 * type_is_enum
2675 * Returns true if the given type is an enum type.
2676 */
2677 bool
2679 {
2681 }
2683 /*
2684 * type_is_range
2685 * Returns true if the given type is a range type.
2686 */
2687 bool
2689 {
2691 }
2693 /*
2694 * type_is_multirange
2695 * Returns true if the given type is a multirange type.
2696 */
2697 bool
2699 {
2701 }
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 */
2709 void
2711 {
2712 HeapTuple tp;
2713 Form_pg_type typtup;
2722 }
2724 /*
2725 * get_typ_typrelid
2726 *
2727 * Given the type OID, get the typrelid (InvalidOid if not a complex
2728 * type).
2729 */
2730 Oid
2732 {
2733 HeapTuple tp;
2737 {
2739 Oid result;
2744 }
2745 else
2747 }
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 */
2758 Oid
2760 {
2761 HeapTuple tp;
2765 {
2767 Oid result;
2771 else
2775 }
2776 else
2778 }
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 */
2786 Oid
2788 {
2789 HeapTuple tp;
2794 {
2797 }
2799 }
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 */
2810 Oid
2812 {
2820 }
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 */
2831 Oid
2833 {
2834 /*
2835 * We loop to find the bottom base type in a stack of domains.
2836 */
2838 {
2839 HeapTuple tup;
2840 Form_pg_type typTup;
2847 {
2848 /* Not a domain, so stop descending */
2849 Oid result;
2851 /* This test must match get_element_type */
2854 else
2858 }
2862 }
2864 /* Like get_element_type, silently return InvalidOid for bogus input */
2866 }
2868 /*
2869 * getTypeInputInfo
2870 *
2871 * Get info needed for converting values of a type to internal form
2872 */
2873 void
2875 {
2876 HeapTuple typeTuple;
2877 Form_pg_type pt;
2899 }
2901 /*
2902 * getTypeOutputInfo
2903 *
2904 * Get info needed for printing values of a type
2905 */
2906 void
2908 {
2909 HeapTuple typeTuple;
2910 Form_pg_type pt;
2932 }
2934 /*
2935 * getTypeBinaryInputInfo
2936 *
2937 * Get info needed for binary input of values of a type
2938 */
2939 void
2941 {
2942 HeapTuple typeTuple;
2943 Form_pg_type pt;
2965 }
2967 /*
2968 * getTypeBinaryOutputInfo
2969 *
2970 * Get info needed for binary output of values of a type
2971 */
2972 void
2974 {
2975 HeapTuple typeTuple;
2976 Form_pg_type pt;
2998 }
3000 /*
3001 * get_typmodin
3002 *
3003 * Given the type OID, return the type's typmodin procedure, if any.
3004 */
3005 Oid
3007 {
3008 HeapTuple tp;
3012 {
3014 Oid result;
3019 }
3020 else
3022 }
3024 #ifdef NOT_USED
3025 /*
3026 * get_typmodout
3027 *
3028 * Given the type OID, return the type's typmodout procedure, if any.
3029 */
3030 Oid
3032 {
3033 HeapTuple tp;
3037 {
3039 Oid result;
3044 }
3045 else
3047 }
3050 /*
3051 * get_typcollation
3052 *
3053 * Given the type OID, return the type's typcollation attribute.
3054 */
3055 Oid
3057 {
3058 HeapTuple tp;
3062 {
3064 Oid result;
3069 }
3070 else
3072 }
3075 /*
3076 * type_is_collatable
3077 *
3078 * Return whether the type cares about collations
3079 */
3080 bool
3082 {
3084 }
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 */
3096 RegProcedure
3098 {
3099 HeapTuple tp;
3103 {
3111 }
3112 else
3113 {
3117 }
3118 }
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 */
3131 {
3139 }
3142 /* ---------- STATISTICS CACHE ---------- */
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 */
3157 int32
3159 {
3160 HeapTuple tp;
3161 int32 stawidth;
3164 {
3168 }
3174 {
3179 }
3181 }
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 */
3233 bool
3236 {
3239 Datum val;
3241 Oid arrayelemtype;
3243 HeapTuple typeTuple;
3244 Form_pg_type typeForm;
3246 /* initialize *sslot properly */
3250 {
3254 }
3262 {
3266 /*
3267 * Detoast the array if needed, and in any case make a copy that's
3268 * under control of this AttStatsSlot.
3269 */
3272 /*
3273 * Extract the actual array element type, and pass it back in case the
3274 * caller needs it.
3275 */
3278 /* Need info about element type */
3284 /* Deconstruct array into Datum elements; NULLs not expected */
3286 arrayelemtype,
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 */
3300 else
3304 }
3307 {
3311 /*
3312 * Detoast the array if needed, and in any case make a copy that's
3313 * under control of this AttStatsSlot.
3314 */
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 */
3328 /* Give caller a pointer directly into the statarray */
3332 /* We'll free the statarray in free_attstatsslot */
3334 }
3337 }
3339 /*
3340 * free_attstatsslot
3341 * Free data allocated by get_attstatsslot
3342 */
3343 void
3345 {
3346 /* The values[] array was separately palloc'd by deconstruct_array */
3349 /* The numbers[] array points into numbers_arr, do not pfree it */
3350 /* Free the detoasted array objects, if any */
3355 }
3357 /* ---------- PG_NAMESPACE CACHE ---------- */
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 */
3367 {
3368 HeapTuple tp;
3372 {
3379 }
3380 else
3382 }
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 */
3391 {
3394 else
3396 }
3398 /* ---------- PG_RANGE CACHES ---------- */
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 */
3406 Oid
3408 {
3409 HeapTuple tp;
3413 {
3415 Oid result;
3420 }
3421 else
3423 }
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 */
3432 Oid
3434 {
3435 HeapTuple tp;
3439 {
3441 Oid result;
3446 }
3447 else
3449 }
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 */
3457 Oid
3459 {
3460 HeapTuple tp;
3464 {
3466 Oid result;
3471 }
3472 else
3474 }
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 */
3482 Oid
3484 {
3485 HeapTuple tp;
3489 {
3491 Oid result;
3496 }
3497 else
3499 }
3501 /* ---------- PG_INDEX CACHE ---------- */
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 */
3511 Oid
3513 {
3514 HeapTuple tuple;
3515 Form_pg_index rd_index;
3516 Datum datum;
3518 Oid opclass;
3520 /* First we need to know the column's opclass. */
3528 /* caller is supposed to guarantee this */
3531 /* Non-key attributes don't have an opclass */
3533 {
3536 }
3547 }
3549 /*
3550 * get_index_isreplident
3551 *
3552 * Given the index OID, return pg_index.indisreplident.
3553 */
3554 bool
3556 {
3557 HeapTuple tuple;
3558 Form_pg_index rd_index;
3570 }
3572 /*
3573 * get_index_isvalid
3574 *
3575 * Given the index OID, return pg_index.indisvalid.
3576 */
3577 bool
3579 {
3581 HeapTuple tuple;
3582 Form_pg_index rd_index;
3593 }
3595 /*
3596 * get_index_isclustered
3597 *
3598 * Given the index OID, return pg_index.indisclustered.
3599 */
3600 bool
3602 {
3604 HeapTuple tuple;
3605 Form_pg_index rd_index;
3616 }
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 */
3624 Oid
3626 {
3627 Oid oid;
3636 }
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 */
3646 {
3647 HeapTuple tup;
3649 Form_pg_publication pubform;
3654 {
3658 }
3666 }
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 */
3674 Oid
3676 {
3677 Oid oid;
3686 }
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 */
3696 {
3697 HeapTuple tup;
3699 Form_pg_subscription subform;
3704 {
3708 }
3716 }