Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * nbtvalidate.c
4 : : * Opclass validator for btree.
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : * IDENTIFICATION
10 : : * src/backend/access/nbtree/nbtvalidate.c
11 : : *
12 : : *-------------------------------------------------------------------------
13 : : */
14 : : #include "postgres.h"
15 : :
16 : : #include "access/amvalidate.h"
17 : : #include "access/htup_details.h"
18 : : #include "access/nbtree.h"
19 : : #include "access/xact.h"
20 : : #include "catalog/pg_am.h"
21 : : #include "catalog/pg_amop.h"
22 : : #include "catalog/pg_amproc.h"
23 : : #include "catalog/pg_opclass.h"
24 : : #include "catalog/pg_type.h"
25 : : #include "utils/builtins.h"
26 : : #include "utils/lsyscache.h"
27 : : #include "utils/regproc.h"
28 : : #include "utils/syscache.h"
29 : :
30 : :
31 : : /*
32 : : * Validator for a btree opclass.
33 : : *
34 : : * Some of the checks done here cover the whole opfamily, and therefore are
35 : : * redundant when checking each opclass in a family. But they don't run long
36 : : * enough to be much of a problem, so we accept the duplication rather than
37 : : * complicate the amvalidate API.
38 : : */
39 : : bool
40 : 45 : btvalidate(Oid opclassoid)
41 : : {
42 : 45 : bool result = true;
43 : 45 : HeapTuple classtup;
44 : 45 : Form_pg_opclass classform;
45 : 45 : Oid opfamilyoid;
46 : 45 : Oid opcintype;
47 : 45 : char *opclassname;
48 : 45 : char *opfamilyname;
49 : 45 : CatCList *proclist,
50 : : *oprlist;
51 : 45 : List *grouplist;
52 : 45 : OpFamilyOpFuncGroup *opclassgroup;
53 : 45 : List *familytypes;
54 : 45 : int usefulgroups;
55 : 45 : int i;
56 : 45 : ListCell *lc;
57 : :
58 : : /* Fetch opclass information */
59 : 45 : classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
60 [ + - ]: 45 : if (!HeapTupleIsValid(classtup))
61 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
62 : 45 : classform = (Form_pg_opclass) GETSTRUCT(classtup);
63 : :
64 : 45 : opfamilyoid = classform->opcfamily;
65 : 45 : opcintype = classform->opcintype;
66 : 45 : opclassname = NameStr(classform->opcname);
67 : :
68 : : /* Fetch opfamily information */
69 : 45 : opfamilyname = get_opfamily_name(opfamilyoid, false);
70 : :
71 : : /* Fetch all operators and support functions of the opfamily */
72 : 45 : oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
73 : 45 : proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
74 : :
75 : : /* Check individual support functions */
76 [ + + ]: 303 : for (i = 0; i < proclist->n_members; i++)
77 : : {
78 : 258 : HeapTuple proctup = &proclist->members[i]->tuple;
79 : 258 : Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
80 : 258 : bool ok;
81 : :
82 : : /* Check procedure numbers and function signatures */
83 [ + + + + : 258 : switch (procform->amprocnum)
- - + ]
84 : : {
85 : : case BTORDER_PROC:
86 : 216 : ok = check_amproc_signature(procform->amproc, INT4OID, true,
87 : 108 : 2, 2, procform->amproclefttype,
88 : 108 : procform->amprocrighttype);
89 : 108 : break;
90 : : case BTSORTSUPPORT_PROC:
91 : 41 : ok = check_amproc_signature(procform->amproc, VOIDOID, true,
92 : : 1, 1, INTERNALOID);
93 : 41 : break;
94 : : case BTINRANGE_PROC:
95 : 76 : ok = check_amproc_signature(procform->amproc, BOOLOID, true,
96 : : 5, 5,
97 : 38 : procform->amproclefttype,
98 : 38 : procform->amproclefttype,
99 : 38 : procform->amprocrighttype,
100 : : BOOLOID, BOOLOID);
101 : 38 : break;
102 : : case BTEQUALIMAGE_PROC:
103 : 48 : ok = check_amproc_signature(procform->amproc, BOOLOID, true,
104 : : 1, 1, OIDOID);
105 : 48 : break;
106 : : case BTOPTIONS_PROC:
107 : 0 : ok = check_amoptsproc_signature(procform->amproc);
108 : 0 : break;
109 : : case BTSKIPSUPPORT_PROC:
110 : 23 : ok = check_amproc_signature(procform->amproc, VOIDOID, true,
111 : : 1, 1, INTERNALOID);
112 : 23 : break;
113 : : default:
114 [ # # # # ]: 0 : ereport(INFO,
115 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
116 : : errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
117 : : opfamilyname, "btree",
118 : : format_procedure(procform->amproc),
119 : : procform->amprocnum)));
120 : 0 : result = false;
121 : 0 : continue; /* don't want additional message */
122 : : }
123 : :
124 [ + - ]: 258 : if (!ok)
125 : : {
126 [ # # # # ]: 0 : ereport(INFO,
127 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
128 : : errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
129 : : opfamilyname, "btree",
130 : : format_procedure(procform->amproc),
131 : : procform->amprocnum)));
132 : 0 : result = false;
133 : 0 : }
134 [ - + ]: 258 : }
135 : :
136 : : /* Check individual operators */
137 [ + + ]: 585 : for (i = 0; i < oprlist->n_members; i++)
138 : : {
139 : 540 : HeapTuple oprtup = &oprlist->members[i]->tuple;
140 : 540 : Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
141 : :
142 : : /* Check that only allowed strategy numbers exist */
143 [ + - - + ]: 540 : if (oprform->amopstrategy < 1 ||
144 : 540 : oprform->amopstrategy > BTMaxStrategyNumber)
145 : : {
146 [ # # # # ]: 0 : ereport(INFO,
147 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
148 : : errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
149 : : opfamilyname, "btree",
150 : : format_operator(oprform->amopopr),
151 : : oprform->amopstrategy)));
152 : 0 : result = false;
153 : 0 : }
154 : :
155 : : /* btree doesn't support ORDER BY operators */
156 [ + - - + ]: 540 : if (oprform->amoppurpose != AMOP_SEARCH ||
157 : 540 : OidIsValid(oprform->amopsortfamily))
158 : : {
159 [ # # # # ]: 0 : ereport(INFO,
160 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
161 : : errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
162 : : opfamilyname, "btree",
163 : : format_operator(oprform->amopopr))));
164 : 0 : result = false;
165 : 0 : }
166 : :
167 : : /* Check operator signature --- same for all btree strategies */
168 [ + - + - ]: 1080 : if (!check_amop_signature(oprform->amopopr, BOOLOID,
169 : 540 : oprform->amoplefttype,
170 : 540 : oprform->amoprighttype))
171 : : {
172 [ # # # # ]: 0 : ereport(INFO,
173 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
174 : : errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
175 : : opfamilyname, "btree",
176 : : format_operator(oprform->amopopr))));
177 : 0 : result = false;
178 : 0 : }
179 : 540 : }
180 : :
181 : : /* Now check for inconsistent groups of operators/functions */
182 : 45 : grouplist = identify_opfamily_groups(oprlist, proclist);
183 : 45 : usefulgroups = 0;
184 : 45 : opclassgroup = NULL;
185 : 45 : familytypes = NIL;
186 [ + - + + : 164 : foreach(lc, grouplist)
+ + ]
187 : : {
188 : 119 : OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
189 : :
190 : : /*
191 : : * It is possible for an in_range support function to have a RHS type
192 : : * that is otherwise irrelevant to the opfamily --- for instance, SQL
193 : : * requires the datetime_ops opclass to have range support with an
194 : : * interval offset. So, if this group appears to contain only an
195 : : * in_range function, ignore it: it doesn't represent a pair of
196 : : * supported types.
197 : : */
198 [ + + - + ]: 119 : if (thisgroup->operatorset == 0 &&
199 : 11 : thisgroup->functionset == (1 << BTINRANGE_PROC))
200 : 11 : continue;
201 : :
202 : : /* Else count it as a relevant group */
203 : 108 : usefulgroups++;
204 : :
205 : : /* Remember the group exactly matching the test opclass */
206 [ + + + + ]: 108 : if (thisgroup->lefttype == opcintype &&
207 : 62 : thisgroup->righttype == opcintype)
208 : 45 : opclassgroup = thisgroup;
209 : :
210 : : /*
211 : : * Identify all distinct data types handled in this opfamily. This
212 : : * implementation is O(N^2), but there aren't likely to be enough
213 : : * types in the family for it to matter.
214 : : */
215 : 108 : familytypes = list_append_unique_oid(familytypes, thisgroup->lefttype);
216 : 108 : familytypes = list_append_unique_oid(familytypes, thisgroup->righttype);
217 : :
218 : : /*
219 : : * Complain if there seems to be an incomplete set of either operators
220 : : * or support functions for this datatype pair. The sortsupport,
221 : : * in_range, and equalimage functions are considered optional.
222 : : */
223 [ + - ]: 108 : if (thisgroup->operatorset !=
224 : : ((1 << BTLessStrategyNumber) |
225 : : (1 << BTLessEqualStrategyNumber) |
226 : : (1 << BTEqualStrategyNumber) |
227 : : (1 << BTGreaterEqualStrategyNumber) |
228 : : (1 << BTGreaterStrategyNumber)))
229 : : {
230 [ # # # # ]: 0 : ereport(INFO,
231 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
232 : : errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
233 : : opfamilyname, "btree",
234 : : format_type_be(thisgroup->lefttype),
235 : : format_type_be(thisgroup->righttype))));
236 : 0 : result = false;
237 : 0 : }
238 [ + - ]: 108 : if ((thisgroup->functionset & (1 << BTORDER_PROC)) == 0)
239 : : {
240 [ # # # # ]: 0 : ereport(INFO,
241 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
242 : : errmsg("operator family \"%s\" of access method %s is missing support function for types %s and %s",
243 : : opfamilyname, "btree",
244 : : format_type_be(thisgroup->lefttype),
245 : : format_type_be(thisgroup->righttype))));
246 : 0 : result = false;
247 : 0 : }
248 [ + + ]: 119 : }
249 : :
250 : : /* Check that the originally-named opclass is supported */
251 : : /* (if group is there, we already checked it adequately above) */
252 [ + - ]: 45 : if (!opclassgroup)
253 : : {
254 [ # # # # ]: 0 : ereport(INFO,
255 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
256 : : errmsg("operator class \"%s\" of access method %s is missing operator(s)",
257 : : opclassname, "btree")));
258 : 0 : result = false;
259 : 0 : }
260 : :
261 : : /*
262 : : * Complain if the opfamily doesn't have entries for all possible
263 : : * combinations of its supported datatypes. While missing cross-type
264 : : * operators are not fatal, they do limit the planner's ability to derive
265 : : * additional qual clauses from equivalence classes, so it seems
266 : : * reasonable to insist that all built-in btree opfamilies be complete.
267 : : */
268 [ + - ]: 45 : if (usefulgroups != (list_length(familytypes) * list_length(familytypes)))
269 : : {
270 [ # # # # ]: 0 : ereport(INFO,
271 : : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
272 : : errmsg("operator family \"%s\" of access method %s is missing cross-type operator(s)",
273 : : opfamilyname, "btree")));
274 : 0 : result = false;
275 : 0 : }
276 : :
277 : 45 : ReleaseCatCacheList(proclist);
278 : 45 : ReleaseCatCacheList(oprlist);
279 : 45 : ReleaseSysCache(classtup);
280 : :
281 : 90 : return result;
282 : 45 : }
283 : :
284 : : /*
285 : : * Prechecking function for adding operators/functions to a btree opfamily.
286 : : */
287 : : void
288 : 19 : btadjustmembers(Oid opfamilyoid,
289 : : Oid opclassoid,
290 : : List *operators,
291 : : List *functions)
292 : : {
293 : 19 : Oid opcintype;
294 : 19 : ListCell *lc;
295 : :
296 : : /*
297 : : * Btree operators and comparison support functions are always "loose"
298 : : * members of the opfamily if they are cross-type. If they are not
299 : : * cross-type, we prefer to tie them to the appropriate opclass ... but if
300 : : * the user hasn't created one, we can't do that, and must fall back to
301 : : * using the opfamily dependency. (We mustn't force creation of an
302 : : * opclass in such a case, as leaving an incomplete opclass laying about
303 : : * would be bad. Throwing an error is another undesirable alternative.)
304 : : *
305 : : * This behavior results in a bit of a dump/reload hazard, in that the
306 : : * order of restoring objects could affect what dependencies we end up
307 : : * with. pg_dump's existing behavior will preserve the dependency choices
308 : : * in most cases, but not if a cross-type operator has been bound tightly
309 : : * into an opclass. That's a mistake anyway, so silently "fixing" it
310 : : * isn't awful.
311 : : *
312 : : * Optional support functions are always "loose" family members.
313 : : *
314 : : * To avoid repeated lookups, we remember the most recently used opclass's
315 : : * input type.
316 : : */
317 [ + + ]: 19 : if (OidIsValid(opclassoid))
318 : : {
319 : : /* During CREATE OPERATOR CLASS, need CCI to see the pg_opclass row */
320 : 4 : CommandCounterIncrement();
321 : 4 : opcintype = get_opclass_input_type(opclassoid);
322 : 4 : }
323 : : else
324 : 15 : opcintype = InvalidOid;
325 : :
326 : : /*
327 : : * We handle operators and support functions almost identically, so rather
328 : : * than duplicate this code block, just join the lists.
329 : : */
330 [ + + + + : 72 : foreach(lc, list_concat_copy(operators, functions))
+ + ]
331 : : {
332 : 53 : OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
333 : :
334 [ + + + + ]: 53 : if (op->is_func && op->number != BTORDER_PROC)
335 : : {
336 : : /* Optional support proc, so always a soft family dependency */
337 : 1 : op->ref_is_hard = false;
338 : 1 : op->ref_is_family = true;
339 : 1 : op->refobjid = opfamilyoid;
340 : 1 : }
341 [ + + ]: 52 : else if (op->lefttype != op->righttype)
342 : : {
343 : : /* Cross-type, so always a soft family dependency */
344 : 28 : op->ref_is_hard = false;
345 : 28 : op->ref_is_family = true;
346 : 28 : op->refobjid = opfamilyoid;
347 : 28 : }
348 : : else
349 : : {
350 : : /* Not cross-type; is there a suitable opclass? */
351 [ + + ]: 24 : if (op->lefttype != opcintype)
352 : : {
353 : : /* Avoid repeating this expensive lookup, even if it fails */
354 : 6 : opcintype = op->lefttype;
355 : 6 : opclassoid = opclass_for_family_datatype(BTREE_AM_OID,
356 : 6 : opfamilyoid,
357 : 6 : opcintype);
358 : 6 : }
359 [ + + ]: 24 : if (OidIsValid(opclassoid))
360 : : {
361 : : /* Hard dependency on opclass */
362 : 18 : op->ref_is_hard = true;
363 : 18 : op->ref_is_family = false;
364 : 18 : op->refobjid = opclassoid;
365 : 18 : }
366 : : else
367 : : {
368 : : /* We're stuck, so make a soft dependency on the opfamily */
369 : 6 : op->ref_is_hard = false;
370 : 6 : op->ref_is_family = true;
371 : 6 : op->refobjid = opfamilyoid;
372 : : }
373 : : }
374 : 53 : }
375 : 19 : }
|
