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 149 : btvalidate(Oid opclassoid)
41 : {
42 149 : bool result = true;
43 : HeapTuple classtup;
44 : Form_pg_opclass classform;
45 : Oid opfamilyoid;
46 : Oid opcintype;
47 : char *opclassname;
48 : char *opfamilyname;
49 : CatCList *proclist,
50 : *oprlist;
51 : List *grouplist;
52 : OpFamilyOpFuncGroup *opclassgroup;
53 : List *familytypes;
54 : int usefulgroups;
55 : int i;
56 : ListCell *lc;
57 :
58 : /* Fetch opclass information */
59 149 : classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
60 149 : if (!HeapTupleIsValid(classtup))
61 0 : elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
62 149 : classform = (Form_pg_opclass) GETSTRUCT(classtup);
63 :
64 149 : opfamilyoid = classform->opcfamily;
65 149 : opcintype = classform->opcintype;
66 149 : opclassname = NameStr(classform->opcname);
67 :
68 : /* Fetch opfamily information */
69 149 : opfamilyname = get_opfamily_name(opfamilyoid, false);
70 :
71 : /* Fetch all operators and support functions of the opfamily */
72 149 : oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
73 149 : proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
74 :
75 : /* Check individual support functions */
76 1153 : for (i = 0; i < proclist->n_members; i++)
77 : {
78 1004 : HeapTuple proctup = &proclist->members[i]->tuple;
79 1004 : Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
80 : bool ok;
81 :
82 : /* Check procedure numbers and function signatures */
83 1004 : switch (procform->amprocnum)
84 : {
85 554 : case BTORDER_PROC:
86 554 : ok = check_amproc_signature(procform->amproc, INT4OID, true,
87 : 2, 2, procform->amproclefttype,
88 : procform->amprocrighttype);
89 554 : break;
90 123 : case BTSORTSUPPORT_PROC:
91 123 : ok = check_amproc_signature(procform->amproc, VOIDOID, true,
92 : 1, 1, INTERNALOID);
93 123 : break;
94 114 : case BTINRANGE_PROC:
95 114 : ok = check_amproc_signature(procform->amproc, BOOLOID, true,
96 : 5, 5,
97 : procform->amproclefttype,
98 : procform->amproclefttype,
99 : procform->amprocrighttype,
100 : BOOLOID, BOOLOID);
101 114 : break;
102 144 : case BTEQUALIMAGE_PROC:
103 144 : ok = check_amproc_signature(procform->amproc, BOOLOID, true,
104 : 1, 1, OIDOID);
105 144 : break;
106 0 : case BTOPTIONS_PROC:
107 0 : ok = check_amoptsproc_signature(procform->amproc);
108 0 : break;
109 69 : case BTSKIPSUPPORT_PROC:
110 69 : ok = check_amproc_signature(procform->amproc, VOIDOID, true,
111 : 1, 1, INTERNALOID);
112 69 : break;
113 0 : 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 1004 : 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 : }
134 : }
135 :
136 : /* Check individual operators */
137 2919 : for (i = 0; i < oprlist->n_members; i++)
138 : {
139 2770 : HeapTuple oprtup = &oprlist->members[i]->tuple;
140 2770 : Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
141 :
142 : /* Check that only allowed strategy numbers exist */
143 2770 : if (oprform->amopstrategy < 1 ||
144 2770 : 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 : }
154 :
155 : /* btree doesn't support ORDER BY operators */
156 2770 : if (oprform->amoppurpose != AMOP_SEARCH ||
157 2770 : 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 : }
166 :
167 : /* Check operator signature --- same for all btree strategies */
168 2770 : if (!check_amop_signature(oprform->amopopr, BOOLOID,
169 : oprform->amoplefttype,
170 : 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 : }
179 : }
180 :
181 : /* Now check for inconsistent groups of operators/functions */
182 149 : grouplist = identify_opfamily_groups(oprlist, proclist);
183 149 : usefulgroups = 0;
184 149 : opclassgroup = NULL;
185 149 : familytypes = NIL;
186 736 : foreach(lc, grouplist)
187 : {
188 587 : 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 587 : if (thisgroup->operatorset == 0 &&
199 33 : thisgroup->functionset == (1 << BTINRANGE_PROC))
200 33 : continue;
201 :
202 : /* Else count it as a relevant group */
203 554 : usefulgroups++;
204 :
205 : /* Remember the group exactly matching the test opclass */
206 554 : if (thisgroup->lefttype == opcintype &&
207 220 : thisgroup->righttype == opcintype)
208 149 : 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 554 : familytypes = list_append_unique_oid(familytypes, thisgroup->lefttype);
216 554 : 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 554 : 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 : }
238 554 : 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 : }
248 : }
249 :
250 : /* Check that the originally-named opclass is supported */
251 : /* (if group is there, we already checked it adequately above) */
252 149 : 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 : }
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 149 : if (usefulgroups != (list_length(familytypes) * list_length(familytypes)))
269 : {
270 8 : 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 8 : result = false;
275 : }
276 :
277 149 : ReleaseCatCacheList(proclist);
278 149 : ReleaseCatCacheList(oprlist);
279 149 : ReleaseSysCache(classtup);
280 :
281 149 : return result;
282 : }
283 :
284 : /*
285 : * Prechecking function for adding operators/functions to a btree opfamily.
286 : */
287 : void
288 104 : btadjustmembers(Oid opfamilyoid,
289 : Oid opclassoid,
290 : List *operators,
291 : List *functions)
292 : {
293 : Oid opcintype;
294 : 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 104 : if (OidIsValid(opclassoid))
318 : {
319 : /* During CREATE OPERATOR CLASS, need CCI to see the pg_opclass row */
320 49 : CommandCounterIncrement();
321 49 : opcintype = get_opclass_input_type(opclassoid);
322 : }
323 : else
324 55 : 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 597 : foreach(lc, list_concat_copy(operators, functions))
331 : {
332 493 : OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
333 :
334 493 : if (op->is_func && op->number != BTORDER_PROC)
335 : {
336 : /* Optional support proc, so always a soft family dependency */
337 7 : op->ref_is_hard = false;
338 7 : op->ref_is_family = true;
339 7 : op->refobjid = opfamilyoid;
340 : }
341 486 : else if (op->lefttype != op->righttype)
342 : {
343 : /* Cross-type, so always a soft family dependency */
344 209 : op->ref_is_hard = false;
345 209 : op->ref_is_family = true;
346 209 : op->refobjid = opfamilyoid;
347 : }
348 : else
349 : {
350 : /* Not cross-type; is there a suitable opclass? */
351 277 : if (op->lefttype != opcintype)
352 : {
353 : /* Avoid repeating this expensive lookup, even if it fails */
354 20 : opcintype = op->lefttype;
355 20 : opclassoid = opclass_for_family_datatype(BTREE_AM_OID,
356 : opfamilyoid,
357 : opcintype);
358 : }
359 277 : if (OidIsValid(opclassoid))
360 : {
361 : /* Hard dependency on opclass */
362 257 : op->ref_is_hard = true;
363 257 : op->ref_is_family = false;
364 257 : op->refobjid = opclassoid;
365 : }
366 : else
367 : {
368 : /* We're stuck, so make a soft dependency on the opfamily */
369 20 : op->ref_is_hard = false;
370 20 : op->ref_is_family = true;
371 20 : op->refobjid = opfamilyoid;
372 : }
373 : }
374 : }
375 104 : }
|
