PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
gistvalidate.c File Reference
#include "postgres.h"
#include "access/amvalidate.h"
#include "access/gist_private.h"
#include "access/htup_details.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_type.h"
#include "utils/lsyscache.h"
#include "utils/regproc.h"
#include "utils/syscache.h"
Include dependency graph for gistvalidate.c:

Go to the source code of this file.

Functions

bool gistvalidate (Oid opclassoid)
 
void gistadjustmembers (Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)
 

Function Documentation

◆ gistadjustmembers()

void gistadjustmembers ( Oid  opfamilyoid,
Oid  opclassoid,
List operators,
List functions 
)

Definition at line 295 of file gistvalidate.c.

299{
300 ListCell *lc;
301
302 /*
303 * Operator members of a GiST opfamily should never have hard
304 * dependencies, since their connection to the opfamily depends only on
305 * what the support functions think, and that can be altered. For
306 * consistency, we make all soft dependencies point to the opfamily,
307 * though a soft dependency on the opclass would work as well in the
308 * CREATE OPERATOR CLASS case.
309 */
310 foreach(lc, operators)
311 {
313
314 op->ref_is_hard = false;
315 op->ref_is_family = true;
316 op->refobjid = opfamilyoid;
317 }
318
319 /*
320 * Required support functions should have hard dependencies. Preferably
321 * those are just dependencies on the opclass, but if we're in ALTER
322 * OPERATOR FAMILY, we leave the dependency pointing at the whole
323 * opfamily. (Given that GiST opclasses generally don't share opfamilies,
324 * it seems unlikely to be worth working harder.)
325 */
326 foreach(lc, functions)
327 {
329
330 switch (op->number)
331 {
333 case GIST_UNION_PROC:
336 case GIST_EQUAL_PROC:
337 /* Required support function */
338 op->ref_is_hard = true;
339 break;
343 case GIST_FETCH_PROC:
347 /* Optional, so force it to be a soft family dependency */
348 op->ref_is_hard = false;
349 op->ref_is_family = true;
350 op->refobjid = opfamilyoid;
351 break;
352 default:
354 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
355 errmsg("support function number %d is invalid for access method %s",
356 op->number, "gist")));
357 break;
358 }
359 }
360}
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
#define GIST_STRATNUM_PROC
Definition: gist.h:43
#define GIST_DECOMPRESS_PROC
Definition: gist.h:35
#define GIST_PICKSPLIT_PROC
Definition: gist.h:37
#define GIST_CONSISTENT_PROC
Definition: gist.h:32
#define GIST_UNION_PROC
Definition: gist.h:33
#define GIST_FETCH_PROC
Definition: gist.h:40
#define GIST_SORTSUPPORT_PROC
Definition: gist.h:42
#define GIST_COMPRESS_PROC
Definition: gist.h:34
#define GIST_PENALTY_PROC
Definition: gist.h:36
#define GIST_OPTIONS_PROC
Definition: gist.h:41
#define GIST_DISTANCE_PROC
Definition: gist.h:39
#define GIST_EQUAL_PROC
Definition: gist.h:38
#define lfirst(lc)
Definition: pg_list.h:172
static const struct fns functions
Definition: regcomp.c:358
Oid refobjid
Definition: amapi.h:94
bool ref_is_family
Definition: amapi.h:93
int number
Definition: amapi.h:88
bool ref_is_hard
Definition: amapi.h:92

References ereport, errcode(), errmsg(), ERROR, functions, GIST_COMPRESS_PROC, GIST_CONSISTENT_PROC, GIST_DECOMPRESS_PROC, GIST_DISTANCE_PROC, GIST_EQUAL_PROC, GIST_FETCH_PROC, GIST_OPTIONS_PROC, GIST_PENALTY_PROC, GIST_PICKSPLIT_PROC, GIST_SORTSUPPORT_PROC, GIST_STRATNUM_PROC, GIST_UNION_PROC, lfirst, OpFamilyMember::number, OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, and OpFamilyMember::refobjid.

Referenced by gisthandler().

◆ gistvalidate()

bool gistvalidate ( Oid  opclassoid)

Definition at line 33 of file gistvalidate.c.

34{
35 bool result = true;
36 HeapTuple classtup;
37 Form_pg_opclass classform;
38 Oid opfamilyoid;
39 Oid opcintype;
40 Oid opckeytype;
41 char *opclassname;
42 HeapTuple familytup;
43 Form_pg_opfamily familyform;
44 char *opfamilyname;
45 CatCList *proclist,
46 *oprlist;
47 List *grouplist;
48 OpFamilyOpFuncGroup *opclassgroup;
49 int i;
50 ListCell *lc;
51
52 /* Fetch opclass information */
53 classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
54 if (!HeapTupleIsValid(classtup))
55 elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
56 classform = (Form_pg_opclass) GETSTRUCT(classtup);
57
58 opfamilyoid = classform->opcfamily;
59 opcintype = classform->opcintype;
60 opckeytype = classform->opckeytype;
61 if (!OidIsValid(opckeytype))
62 opckeytype = opcintype;
63 opclassname = NameStr(classform->opcname);
64
65 /* Fetch opfamily information */
66 familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
67 if (!HeapTupleIsValid(familytup))
68 elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
69 familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
70
71 opfamilyname = NameStr(familyform->opfname);
72
73 /* Fetch all operators and support functions of the opfamily */
74 oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
75 proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
76
77 /* Check individual support functions */
78 for (i = 0; i < proclist->n_members; i++)
79 {
80 HeapTuple proctup = &proclist->members[i]->tuple;
81 Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
82 bool ok;
83
84 /*
85 * All GiST support functions should be registered with matching
86 * left/right types
87 */
88 if (procform->amproclefttype != procform->amprocrighttype)
89 {
91 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
92 errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
93 opfamilyname, "gist",
94 format_procedure(procform->amproc))));
95 result = false;
96 }
97
98 /*
99 * We can't check signatures except within the specific opclass, since
100 * we need to know the associated opckeytype in many cases.
101 */
102 if (procform->amproclefttype != opcintype)
103 continue;
104
105 /* Check procedure numbers and function signatures */
106 switch (procform->amprocnum)
107 {
109 ok = check_amproc_signature(procform->amproc, BOOLOID, false,
110 5, 5, INTERNALOID, opcintype,
111 INT2OID, OIDOID, INTERNALOID);
112 break;
113 case GIST_UNION_PROC:
114 ok = check_amproc_signature(procform->amproc, opckeytype, false,
115 2, 2, INTERNALOID, INTERNALOID);
116 break;
119 case GIST_FETCH_PROC:
120 ok = check_amproc_signature(procform->amproc, INTERNALOID, true,
121 1, 1, INTERNALOID);
122 break;
124 ok = check_amproc_signature(procform->amproc, INTERNALOID, true,
125 3, 3, INTERNALOID,
126 INTERNALOID, INTERNALOID);
127 break;
129 ok = check_amproc_signature(procform->amproc, INTERNALOID, true,
130 2, 2, INTERNALOID, INTERNALOID);
131 break;
132 case GIST_EQUAL_PROC:
133 ok = check_amproc_signature(procform->amproc, INTERNALOID, false,
134 3, 3, opckeytype, opckeytype,
135 INTERNALOID);
136 break;
138 ok = check_amproc_signature(procform->amproc, FLOAT8OID, false,
139 5, 5, INTERNALOID, opcintype,
140 INT2OID, OIDOID, INTERNALOID);
141 break;
143 ok = check_amoptsproc_signature(procform->amproc);
144 break;
146 ok = check_amproc_signature(procform->amproc, VOIDOID, true,
147 1, 1, INTERNALOID);
148 break;
150 ok = check_amproc_signature(procform->amproc, INT2OID, true,
151 1, 1, INT4OID);
152 break;
153 default:
155 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
156 errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
157 opfamilyname, "gist",
158 format_procedure(procform->amproc),
159 procform->amprocnum)));
160 result = false;
161 continue; /* don't want additional message */
162 }
163
164 if (!ok)
165 {
167 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
168 errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
169 opfamilyname, "gist",
170 format_procedure(procform->amproc),
171 procform->amprocnum)));
172 result = false;
173 }
174 }
175
176 /* Check individual operators */
177 for (i = 0; i < oprlist->n_members; i++)
178 {
179 HeapTuple oprtup = &oprlist->members[i]->tuple;
180 Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
181 Oid op_rettype;
182
183 /* TODO: Check that only allowed strategy numbers exist */
184 if (oprform->amopstrategy < 1)
185 {
187 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
188 errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
189 opfamilyname, "gist",
190 format_operator(oprform->amopopr),
191 oprform->amopstrategy)));
192 result = false;
193 }
194
195 /* GiST supports ORDER BY operators */
196 if (oprform->amoppurpose != AMOP_SEARCH)
197 {
198 /* ... but must have matching distance proc */
199 if (!OidIsValid(get_opfamily_proc(opfamilyoid,
200 oprform->amoplefttype,
201 oprform->amoplefttype,
203 {
205 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
206 errmsg("operator family \"%s\" of access method %s contains unsupported ORDER BY specification for operator %s",
207 opfamilyname, "gist",
208 format_operator(oprform->amopopr))));
209 result = false;
210 }
211 /* ... and operator result must match the claimed btree opfamily */
212 op_rettype = get_op_rettype(oprform->amopopr);
213 if (!opfamily_can_sort_type(oprform->amopsortfamily, op_rettype))
214 {
216 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
217 errmsg("operator family \"%s\" of access method %s contains incorrect ORDER BY opfamily specification for operator %s",
218 opfamilyname, "gist",
219 format_operator(oprform->amopopr))));
220 result = false;
221 }
222 }
223 else
224 {
225 /* Search operators must always return bool */
226 op_rettype = BOOLOID;
227 }
228
229 /* Check operator signature */
230 if (!check_amop_signature(oprform->amopopr, op_rettype,
231 oprform->amoplefttype,
232 oprform->amoprighttype))
233 {
235 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
236 errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
237 opfamilyname, "gist",
238 format_operator(oprform->amopopr))));
239 result = false;
240 }
241 }
242
243 /* Now check for inconsistent groups of operators/functions */
244 grouplist = identify_opfamily_groups(oprlist, proclist);
245 opclassgroup = NULL;
246 foreach(lc, grouplist)
247 {
249
250 /* Remember the group exactly matching the test opclass */
251 if (thisgroup->lefttype == opcintype &&
252 thisgroup->righttype == opcintype)
253 opclassgroup = thisgroup;
254
255 /*
256 * There is not a lot we can do to check the operator sets, since each
257 * GiST opclass is more or less a law unto itself, and some contain
258 * only operators that are binary-compatible with the opclass datatype
259 * (meaning that empty operator sets can be OK). That case also means
260 * that we shouldn't insist on nonempty function sets except for the
261 * opclass's own group.
262 */
263 }
264
265 /* Check that the originally-named opclass is complete */
266 for (i = 1; i <= GISTNProcs; i++)
267 {
268 if (opclassgroup &&
269 (opclassgroup->functionset & (((uint64) 1) << i)) != 0)
270 continue; /* got it */
271 if (i == GIST_DISTANCE_PROC || i == GIST_FETCH_PROC ||
275 continue; /* optional methods */
277 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
278 errmsg("operator class \"%s\" of access method %s is missing support function %d",
279 opclassname, "gist", i)));
280 result = false;
281 }
282
283 ReleaseCatCacheList(proclist);
284 ReleaseCatCacheList(oprlist);
285 ReleaseSysCache(familytup);
286 ReleaseSysCache(classtup);
287
288 return result;
289}
bool check_amproc_signature(Oid funcid, Oid restype, bool exact, int minargs, int maxargs,...)
Definition: amvalidate.c:152
bool check_amop_signature(Oid opno, Oid restype, Oid lefttype, Oid righttype)
Definition: amvalidate.c:206
List * identify_opfamily_groups(CatCList *oprlist, CatCList *proclist)
Definition: amvalidate.c:43
bool opfamily_can_sort_type(Oid opfamilyoid, Oid datatypeoid)
Definition: amvalidate.c:271
bool check_amoptsproc_signature(Oid funcid)
Definition: amvalidate.c:192
#define NameStr(name)
Definition: c.h:703
uint64_t uint64
Definition: c.h:489
#define OidIsValid(objectId)
Definition: c.h:732
void ReleaseCatCacheList(CatCList *list)
Definition: catcache.c:2071
#define elog(elevel,...)
Definition: elog.h:225
#define INFO
Definition: elog.h:34
#define GISTNProcs
Definition: gist.h:44
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
int i
Definition: isn.c:72
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition: lsyscache.c:796
Oid get_op_rettype(Oid opno)
Definition: lsyscache.c:1333
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
FormData_pg_amproc * Form_pg_amproc
Definition: pg_amproc.h:68
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
FormData_pg_opfamily * Form_pg_opfamily
Definition: pg_opfamily.h:51
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:257
unsigned int Oid
Definition: postgres_ext.h:32
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:299
char * format_operator(Oid operator_oid)
Definition: regproc.c:793
Definition: pg_list.h:54
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:180
int n_members
Definition: catcache.h:178
HeapTupleData tuple
Definition: catcache.h:123
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:269
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:221
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:127

References check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), elog, ereport, errcode(), errmsg(), ERROR, format_operator(), format_procedure(), OpFamilyOpFuncGroup::functionset, get_op_rettype(), get_opfamily_proc(), GETSTRUCT, GIST_COMPRESS_PROC, GIST_CONSISTENT_PROC, GIST_DECOMPRESS_PROC, GIST_DISTANCE_PROC, GIST_EQUAL_PROC, GIST_FETCH_PROC, GIST_OPTIONS_PROC, GIST_PENALTY_PROC, GIST_PICKSPLIT_PROC, GIST_SORTSUPPORT_PROC, GIST_STRATNUM_PROC, GIST_UNION_PROC, GISTNProcs, HeapTupleIsValid, i, identify_opfamily_groups(), INFO, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, ObjectIdGetDatum(), OidIsValid, opfamily_can_sort_type(), ReleaseCatCacheList(), ReleaseSysCache(), OpFamilyOpFuncGroup::righttype, SearchSysCache1(), SearchSysCacheList1, and catctup::tuple.

Referenced by gisthandler().