3 -- Sanity checks for common errors in making operator/procedure system tables:
4 -- pg_operator, pg_proc, pg_cast, pg_aggregate, pg_am, pg_amop, pg_amproc, pg_opclass.
6 -- None of the SELECTs here should ever find any matching entries,
7 -- so the expected output is easy to maintain ;-).
8 -- A test failure indicates someone messed up an entry in the system tables.
10 -- NB: we assume the oidjoins test will have caught any dangling links,
11 -- that is OID or REGPROC fields that are not zero and do not match some
12 -- row in the linked-to table. However, if we want to enforce that a link
13 -- field can't be 0, we have to check it here.
15 -- NB: run this test earlier than the create_operator test, because
16 -- that test creates some bogus operators...
18 -- **************** pg_proc ****************
20 -- Look for illegal values in pg_proc fields.
21 -- NOTE: in reality pronargs could be more than 10, but I'm too lazy to put
22 -- a larger number of proargtypes check clauses in here. If we ever have
23 -- more-than-10-arg functions in the standard catalogs, extend this query.
25 SELECT p1.oid, p1.proname
27 WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
28 p1.pronargs < 0 OR p1.pronargs > 10 OR
29 (p1.proargtypes[0] = 0 AND p1.pronargs > 0) OR
30 (p1.proargtypes[1] = 0 AND p1.pronargs > 1) OR
31 (p1.proargtypes[2] = 0 AND p1.pronargs > 2) OR
32 (p1.proargtypes[3] = 0 AND p1.pronargs > 3) OR
33 (p1.proargtypes[4] = 0 AND p1.pronargs > 4) OR
34 (p1.proargtypes[5] = 0 AND p1.pronargs > 5) OR
35 (p1.proargtypes[6] = 0 AND p1.pronargs > 6) OR
36 (p1.proargtypes[7] = 0 AND p1.pronargs > 7) OR
37 (p1.proargtypes[8] = 0 AND p1.pronargs > 8) OR
38 (p1.proargtypes[9] = 0 AND p1.pronargs > 9);
40 -- Look for conflicting proc definitions (same names and input datatypes).
41 -- (This test should be dead code now that we have the unique index
42 -- pg_proc_proname_narg_type_index, but I'll leave it in anyway.)
44 SELECT p1.oid, p1.proname, p2.oid, p2.proname
45 FROM pg_proc AS p1, pg_proc AS p2
46 WHERE p1.oid != p2.oid AND
47 p1.proname = p2.proname AND
48 p1.pronargs = p2.pronargs AND
49 p1.proargtypes = p2.proargtypes;
51 -- Considering only built-in procs (prolang = 12), look for multiple uses
52 -- of the same internal function (ie, matching prosrc fields). It's OK to
53 -- have several entries with different pronames for the same internal function,
54 -- but conflicts in the number of arguments and other critical items should
57 SELECT p1.oid, p1.proname, p2.oid, p2.proname
58 FROM pg_proc AS p1, pg_proc AS p2
59 WHERE p1.oid != p2.oid AND
60 p1.prosrc = p2.prosrc AND
61 p1.prolang = 12 AND p2.prolang = 12 AND
62 (p1.prolang != p2.prolang OR
63 p1.proisagg != p2.proisagg OR
64 p1.prosecdef != p2.prosecdef OR
65 p1.proisstrict != p2.proisstrict OR
66 p1.proretset != p2.proretset OR
67 p1.provolatile != p2.provolatile OR
68 p1.pronargs != p2.pronargs);
70 -- Look for uses of different type OIDs in the argument/result type fields
71 -- for different aliases of the same built-in function.
72 -- This indicates that the types are being presumed to be binary-equivalent,
73 -- or that the built-in function is prepared to deal with different types.
74 -- That's not wrong, necessarily, but we make lists of all the types being
75 -- so treated. Note that the expected output of this part of the test will
76 -- need to be modified whenever new pairs of types are made binary-equivalent,
77 -- or when new polymorphic built-in functions are added!
78 -- Note: ignore aggregate functions here, since they all point to the same
79 -- dummy built-in function.
81 SELECT DISTINCT p1.prorettype, p2.prorettype
82 FROM pg_proc AS p1, pg_proc AS p2
83 WHERE p1.oid != p2.oid AND
84 p1.prosrc = p2.prosrc AND
85 p1.prolang = 12 AND p2.prolang = 12 AND
86 NOT p1.proisagg AND NOT p2.proisagg AND
87 (p1.prorettype < p2.prorettype);
89 SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
90 FROM pg_proc AS p1, pg_proc AS p2
91 WHERE p1.oid != p2.oid AND
92 p1.prosrc = p2.prosrc AND
93 p1.prolang = 12 AND p2.prolang = 12 AND
94 NOT p1.proisagg AND NOT p2.proisagg AND
95 (p1.proargtypes[0] < p2.proargtypes[0]);
97 SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
98 FROM pg_proc AS p1, pg_proc AS p2
99 WHERE p1.oid != p2.oid AND
100 p1.prosrc = p2.prosrc AND
101 p1.prolang = 12 AND p2.prolang = 12 AND
102 NOT p1.proisagg AND NOT p2.proisagg AND
103 (p1.proargtypes[1] < p2.proargtypes[1]);
105 SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
106 FROM pg_proc AS p1, pg_proc AS p2
107 WHERE p1.oid != p2.oid AND
108 p1.prosrc = p2.prosrc AND
109 p1.prolang = 12 AND p2.prolang = 12 AND
110 NOT p1.proisagg AND NOT p2.proisagg AND
111 (p1.proargtypes[2] < p2.proargtypes[2]);
113 SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
114 FROM pg_proc AS p1, pg_proc AS p2
115 WHERE p1.oid != p2.oid AND
116 p1.prosrc = p2.prosrc AND
117 p1.prolang = 12 AND p2.prolang = 12 AND
118 NOT p1.proisagg AND NOT p2.proisagg AND
119 (p1.proargtypes[3] < p2.proargtypes[3]);
121 SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
122 FROM pg_proc AS p1, pg_proc AS p2
123 WHERE p1.oid != p2.oid AND
124 p1.prosrc = p2.prosrc AND
125 p1.prolang = 12 AND p2.prolang = 12 AND
126 NOT p1.proisagg AND NOT p2.proisagg AND
127 (p1.proargtypes[4] < p2.proargtypes[4]);
129 SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
130 FROM pg_proc AS p1, pg_proc AS p2
131 WHERE p1.oid != p2.oid AND
132 p1.prosrc = p2.prosrc AND
133 p1.prolang = 12 AND p2.prolang = 12 AND
134 NOT p1.proisagg AND NOT p2.proisagg AND
135 (p1.proargtypes[5] < p2.proargtypes[5]);
137 SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
138 FROM pg_proc AS p1, pg_proc AS p2
139 WHERE p1.oid != p2.oid AND
140 p1.prosrc = p2.prosrc AND
141 p1.prolang = 12 AND p2.prolang = 12 AND
142 NOT p1.proisagg AND NOT p2.proisagg AND
143 (p1.proargtypes[6] < p2.proargtypes[6]);
145 SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
146 FROM pg_proc AS p1, pg_proc AS p2
147 WHERE p1.oid != p2.oid AND
148 p1.prosrc = p2.prosrc AND
149 p1.prolang = 12 AND p2.prolang = 12 AND
150 NOT p1.proisagg AND NOT p2.proisagg AND
151 (p1.proargtypes[7] < p2.proargtypes[7]);
153 -- Look for functions that return type "internal" and do not have any
154 -- "internal" argument. Such a function would be a security hole since
155 -- it might be used to call an internal function from an SQL command.
156 -- As of 7.3 this query should find only internal_in.
158 SELECT p1.oid, p1.proname
160 WHERE p1.prorettype = 'internal'::regtype AND NOT
161 ('(' || oidvectortypes(p1.proargtypes) || ')') ~ '[^a-z0-9_]internal[^a-z0-9_]';
164 -- **************** pg_cast ****************
166 -- Look for casts from and to the same type. This is not harmful, but
167 -- useless. Also catch bogus values in pg_cast columns (other than
168 -- cases detected by oidjoins test).
172 WHERE castsource = casttarget OR castsource = 0 OR casttarget = 0
173 OR castcontext NOT IN ('e', 'a', 'i');
175 -- Look for cast functions that don't have the right signature. The
176 -- argument and result types in pg_proc must be the same as, or binary
177 -- compatible with, what it says in pg_cast.
180 FROM pg_cast c, pg_proc p
181 WHERE c.castfunc = p.oid AND
183 OR NOT (c.castsource = p.proargtypes[0] OR
184 EXISTS (SELECT 1 FROM pg_cast k
185 WHERE k.castfunc = 0 AND
186 k.castsource = c.castsource AND
187 k.casttarget = p.proargtypes[0]))
188 OR NOT (p.prorettype = c.casttarget OR
189 EXISTS (SELECT 1 FROM pg_cast k
190 WHERE k.castfunc = 0 AND
191 k.castsource = p.prorettype AND
192 k.casttarget = c.casttarget)));
194 -- Look for binary compatible casts that do not have the reverse
195 -- direction registered as well, or where the reverse direction is not
196 -- also binary compatible. This is legal, but probably not intended.
200 WHERE c.castfunc = 0 AND
201 NOT EXISTS (SELECT 1 FROM pg_cast k
202 WHERE k.castfunc = 0 AND
203 k.castsource = c.casttarget AND
204 k.casttarget = c.castsource);
206 -- **************** pg_operator ****************
208 -- Look for illegal values in pg_operator fields.
210 SELECT p1.oid, p1.oprname
211 FROM pg_operator as p1
212 WHERE (p1.oprkind != 'b' AND p1.oprkind != 'l' AND p1.oprkind != 'r') OR
213 p1.oprresult = 0 OR p1.oprcode = 0;
215 -- Look for missing or unwanted operand types
217 SELECT p1.oid, p1.oprname
218 FROM pg_operator as p1
219 WHERE (p1.oprleft = 0 and p1.oprkind != 'l') OR
220 (p1.oprleft != 0 and p1.oprkind = 'l') OR
221 (p1.oprright = 0 and p1.oprkind != 'r') OR
222 (p1.oprright != 0 and p1.oprkind = 'r');
224 -- Look for conflicting operator definitions (same names and input datatypes).
226 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
227 FROM pg_operator AS p1, pg_operator AS p2
228 WHERE p1.oid != p2.oid AND
229 p1.oprname = p2.oprname AND
230 p1.oprkind = p2.oprkind AND
231 p1.oprleft = p2.oprleft AND
232 p1.oprright = p2.oprright;
234 -- Look for commutative operators that don't commute.
235 -- DEFINITIONAL NOTE: If A.oprcom = B, then x A y has the same result as y B x.
236 -- We expect that B will always say that B.oprcom = A as well; that's not
237 -- inherently essential, but it would be inefficient not to mark it so.
239 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
240 FROM pg_operator AS p1, pg_operator AS p2
241 WHERE p1.oprcom = p2.oid AND
242 (p1.oprkind != 'b' OR
243 p1.oprleft != p2.oprright OR
244 p1.oprright != p2.oprleft OR
245 p1.oprresult != p2.oprresult OR
246 p1.oid != p2.oprcom);
248 -- Look for negatory operators that don't agree.
249 -- DEFINITIONAL NOTE: If A.oprnegate = B, then both A and B must yield
250 -- boolean results, and (x A y) == ! (x B y), or the equivalent for
251 -- single-operand operators.
252 -- We expect that B will always say that B.oprnegate = A as well; that's not
253 -- inherently essential, but it would be inefficient not to mark it so.
254 -- Also, A and B had better not be the same operator.
256 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
257 FROM pg_operator AS p1, pg_operator AS p2
258 WHERE p1.oprnegate = p2.oid AND
259 (p1.oprkind != p2.oprkind OR
260 p1.oprleft != p2.oprleft OR
261 p1.oprright != p2.oprright OR
262 p1.oprresult != 'bool'::regtype OR
263 p2.oprresult != 'bool'::regtype OR
264 p1.oid != p2.oprnegate OR
267 -- Look for mergejoin operators that don't match their links.
268 -- An lsortop/rsortop link leads from an '=' operator to the
269 -- sort operator ('<' operator) that's appropriate for
270 -- its left-side or right-side data type.
271 -- An ltcmpop/gtcmpop link leads from an '=' operator to the
272 -- '<' or '>' operator of the same input datatypes.
273 -- (If the '=' operator has identical L and R input datatypes,
274 -- then lsortop, rsortop, and ltcmpop are all the same operator.)
276 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
277 FROM pg_operator AS p1, pg_operator AS p2
278 WHERE p1.oprlsortop = p2.oid AND
279 (p1.oprname != '=' OR p2.oprname != '<' OR
280 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
281 p1.oprleft != p2.oprleft OR
282 p1.oprleft != p2.oprright OR
283 p1.oprresult != 'bool'::regtype OR
284 p2.oprresult != 'bool'::regtype);
286 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
287 FROM pg_operator AS p1, pg_operator AS p2
288 WHERE p1.oprrsortop = p2.oid AND
289 (p1.oprname != '=' OR p2.oprname != '<' OR
290 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
291 p1.oprright != p2.oprleft OR
292 p1.oprright != p2.oprright OR
293 p1.oprresult != 'bool'::regtype OR
294 p2.oprresult != 'bool'::regtype);
296 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
297 FROM pg_operator AS p1, pg_operator AS p2
298 WHERE p1.oprltcmpop = p2.oid AND
299 (p1.oprname != '=' OR p2.oprname != '<' OR
300 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
301 p1.oprleft != p2.oprleft OR
302 p1.oprright != p2.oprright OR
303 p1.oprresult != 'bool'::regtype OR
304 p2.oprresult != 'bool'::regtype);
306 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
307 FROM pg_operator AS p1, pg_operator AS p2
308 WHERE p1.oprgtcmpop = p2.oid AND
309 (p1.oprname != '=' OR p2.oprname != '>' OR
310 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
311 p1.oprleft != p2.oprleft OR
312 p1.oprright != p2.oprright OR
313 p1.oprresult != 'bool'::regtype OR
314 p2.oprresult != 'bool'::regtype);
316 -- Make sure all four links are specified if any are.
318 SELECT p1.oid, p1.oprcode
319 FROM pg_operator AS p1
320 WHERE NOT ((oprlsortop = 0 AND oprrsortop = 0 AND
321 oprltcmpop = 0 AND oprgtcmpop = 0) OR
322 (oprlsortop != 0 AND oprrsortop != 0 AND
323 oprltcmpop != 0 AND oprgtcmpop != 0));
325 -- A mergejoinable = operator must have a commutator (usually itself).
327 SELECT p1.oid, p1.oprname FROM pg_operator AS p1
328 WHERE p1.oprlsortop != 0 AND
331 -- Mergejoinable operators across datatypes must come in closed sets, that
332 -- is if you provide int2 = int4 and int4 = int8 then you must also provide
333 -- int2 = int8 (and commutators of all these). This is necessary because
334 -- the planner tries to deduce additional qual clauses from transitivity
335 -- of mergejoinable operators. If there are clauses int2var = int4var and
336 -- int4var = int8var, the planner will deduce int2var = int8var ... and it
337 -- had better have a way to represent it.
339 SELECT p1.oid, p2.oid FROM pg_operator AS p1, pg_operator AS p2
340 WHERE p1.oprlsortop != p1.oprrsortop AND
341 p1.oprrsortop = p2.oprlsortop AND
342 p2.oprlsortop != p2.oprrsortop AND
343 NOT EXISTS (SELECT 1 FROM pg_operator p3 WHERE
344 p3.oprlsortop = p1.oprlsortop AND p3.oprrsortop = p2.oprrsortop);
347 -- Hashing only works on simple equality operators "type = sametype",
348 -- since the hash itself depends on the bitwise representation of the type.
349 -- Check that allegedly hashable operators look like they might be "=".
350 -- NOTE: in 7.3, this search finds xideqint4.
351 -- Until we have some cleaner way of dealing with binary-equivalent types,
352 -- just leave that tuple in the expected output.
354 SELECT p1.oid, p1.oprname
355 FROM pg_operator AS p1
356 WHERE p1.oprcanhash AND NOT
357 (p1.oprkind = 'b' AND p1.oprresult = 'bool'::regtype AND
358 p1.oprleft = p1.oprright AND p1.oprname = '=' AND p1.oprcom = p1.oid);
360 -- In 6.5 we accepted hashable array equality operators when the array element
361 -- type is hashable. However, what we actually need to make hashjoin work on
362 -- an array is a hashable element type *and* no padding between elements in
363 -- the array storage (or, perhaps, guaranteed-zero padding). Currently,
364 -- since the padding code in arrayfuncs.c is pretty bogus, it seems safest
365 -- to just forbid hashjoin on array equality ops.
366 -- This should be reconsidered someday.
368 -- -- Look for array equality operators that are hashable when the underlying
369 -- -- type is not, or vice versa. This is presumably bogus.
371 -- SELECT p1.oid, p1.oprcanhash, p2.oid, p2.oprcanhash, t1.typname, t2.typname
372 -- FROM pg_operator AS p1, pg_operator AS p2, pg_type AS t1, pg_type AS t2
373 -- WHERE p1.oprname = '=' AND p1.oprleft = p1.oprright AND
374 -- p2.oprname = '=' AND p2.oprleft = p2.oprright AND
375 -- p1.oprleft = t1.oid AND p2.oprleft = t2.oid AND t1.typelem = t2.oid AND
376 -- p1.oprcanhash != p2.oprcanhash;
378 -- Substitute check: forbid hashable array ops, period.
379 SELECT p1.oid, p1.oprname
380 FROM pg_operator AS p1, pg_proc AS p2
381 WHERE p1.oprcanhash AND p1.oprcode = p2.oid AND p2.proname = 'array_eq';
383 -- Check that each operator defined in pg_operator matches its oprcode entry
384 -- in pg_proc. Easiest to do this separately for each oprkind.
385 -- FIXME: want to check that argument/result types match, but how to do that
386 -- in the face of binary-compatible types?
388 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
389 FROM pg_operator AS p1, pg_proc AS p2
390 WHERE p1.oprcode = p2.oid AND
393 -- diked out until we find a way of marking binary-compatible types
395 -- p1.oprresult != p2.prorettype OR
396 -- (p1.oprleft != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
397 -- (p1.oprright != p2.proargtypes[1] AND p2.proargtypes[1] != 0)
400 -- These two selects can be left as-is because there are no binary-compatible
401 -- cases that they trip over, at least in 6.5:
403 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
404 FROM pg_operator AS p1, pg_proc AS p2
405 WHERE p1.oprcode = p2.oid AND
408 p1.oprresult != p2.prorettype OR
409 (p1.oprright != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
412 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
413 FROM pg_operator AS p1, pg_proc AS p2
414 WHERE p1.oprcode = p2.oid AND
417 p1.oprresult != p2.prorettype OR
418 (p1.oprleft != p2.proargtypes[0] AND p2.proargtypes[0] != 0) OR
421 -- If the operator is mergejoinable or hashjoinable, its underlying function
422 -- should not be volatile.
424 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
425 FROM pg_operator AS p1, pg_proc AS p2
426 WHERE p1.oprcode = p2.oid AND
427 (p1.oprlsortop != 0 OR p1.oprcanhash) AND
428 p2.provolatile = 'v';
430 -- If oprrest is set, the operator must return boolean,
431 -- and it must link to a proc with the right signature
432 -- to be a restriction selectivity estimator.
433 -- The proc signature we want is: float8 proc(internal, oid, internal, int4)
435 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
436 FROM pg_operator AS p1, pg_proc AS p2
437 WHERE p1.oprrest = p2.oid AND
438 (p1.oprresult != 'bool'::regtype OR
439 p2.prorettype != 'float8'::regtype OR p2.proretset OR
441 p2.proargtypes[0] != 'internal'::regtype OR
442 p2.proargtypes[1] != 'oid'::regtype OR
443 p2.proargtypes[2] != 'internal'::regtype OR
444 p2.proargtypes[3] != 'int4'::regtype);
446 -- If oprjoin is set, the operator must be a binary boolean op,
447 -- and it must link to a proc with the right signature
448 -- to be a join selectivity estimator.
449 -- The proc signature we want is: float8 proc(internal, oid, internal, int2)
451 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
452 FROM pg_operator AS p1, pg_proc AS p2
453 WHERE p1.oprjoin = p2.oid AND
454 (p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
455 p2.prorettype != 'float8'::regtype OR p2.proretset OR
457 p2.proargtypes[0] != 'internal'::regtype OR
458 p2.proargtypes[1] != 'oid'::regtype OR
459 p2.proargtypes[2] != 'internal'::regtype OR
460 p2.proargtypes[3] != 'int2'::regtype);
462 -- **************** pg_aggregate ****************
464 -- Look for illegal values in pg_aggregate fields.
466 SELECT ctid, aggfnoid::oid
467 FROM pg_aggregate as p1
468 WHERE aggfnoid = 0 OR aggtransfn = 0 OR aggtranstype = 0;
470 -- Make sure the matching pg_proc entry is sensible, too.
472 SELECT a.aggfnoid::oid, p.proname
473 FROM pg_aggregate as a, pg_proc as p
474 WHERE a.aggfnoid = p.oid AND
475 (NOT p.proisagg OR p.pronargs != 1 OR p.proretset);
477 -- Make sure there are no proisagg pg_proc entries without matches.
482 NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid);
484 -- If there is no finalfn then the output type must be the transtype.
486 SELECT a.aggfnoid::oid, p.proname
487 FROM pg_aggregate as a, pg_proc as p
488 WHERE a.aggfnoid = p.oid AND
489 a.aggfinalfn = 0 AND p.prorettype != a.aggtranstype;
491 -- Cross-check transfn against its entry in pg_proc.
492 -- FIXME: what about binary-compatible types?
493 -- NOTE: in 7.1, this search finds max and min on abstime, which are
494 -- implemented using int4larger/int4smaller. Until we have
495 -- some cleaner way of dealing with binary-equivalent types, just leave
496 -- those two tuples in the expected output.
497 SELECT a.aggfnoid::oid, p.proname, p2.oid, p2.proname
498 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS p2
499 WHERE a.aggfnoid = p.oid AND
500 a.aggtransfn = p2.oid AND
502 a.aggtranstype != p2.prorettype OR
503 a.aggtranstype != p2.proargtypes[0] OR
504 NOT ((p2.pronargs = 2 AND p.proargtypes[0] = p2.proargtypes[1]) OR
505 (p2.pronargs = 1 AND p.proargtypes[0] = '"any"'::regtype)))
508 -- Cross-check finalfn (if present) against its entry in pg_proc.
509 -- FIXME: what about binary-compatible types?
511 SELECT a.aggfnoid::oid, p.proname, p2.oid, p2.proname
512 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS p2
513 WHERE a.aggfnoid = p.oid AND
514 a.aggfinalfn = p2.oid AND
515 (p2.proretset OR p.prorettype != p2.prorettype OR
517 a.aggtranstype != p2.proargtypes[0]);
519 -- If transfn is strict then either initval should be non-NULL, or
520 -- input type should equal transtype so that the first non-null input
521 -- can be assigned as the state value.
523 SELECT a.aggfnoid::oid, p.proname, p2.oid, p2.proname
524 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS p2
525 WHERE a.aggfnoid = p.oid AND
526 a.aggtransfn = p2.oid AND p2.proisstrict AND
527 a.agginitval IS NULL AND p.proargtypes[0] != a.aggtranstype;
529 -- **************** pg_opclass ****************
531 -- Look for illegal values in pg_opclass fields
534 FROM pg_opclass as p1
535 WHERE p1.opcamid = 0 OR p1.opcintype = 0;
537 -- There should not be multiple entries in pg_opclass with opcdefault true
538 -- and the same opcamid/opcintype combination.
540 SELECT p1.oid, p2.oid
541 FROM pg_opclass AS p1, pg_opclass AS p2
542 WHERE p1.oid != p2.oid AND
543 p1.opcamid = p2.opcamid AND p1.opcintype = p2.opcintype AND
544 p1.opcdefault AND p2.opcdefault;
546 -- **************** pg_amop ****************
548 -- Look for illegal values in pg_amop fields
550 SELECT p1.amopclaid, p1.amopstrategy
552 WHERE p1.amopclaid = 0 OR p1.amopstrategy <= 0 OR p1.amopopr = 0;
554 -- Cross-check amopstrategy index against parent AM
556 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.amname
557 FROM pg_amop AS p1, pg_am AS p2, pg_opclass AS p3
558 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
559 p1.amopstrategy > p2.amstrategies;
561 -- Detect missing pg_amop entries: should have as many strategy functions
562 -- as AM expects for each opclass for the AM
564 SELECT p1.oid, p1.amname, p2.oid, p2.opcname
565 FROM pg_am AS p1, pg_opclass AS p2
566 WHERE p2.opcamid = p1.oid AND
567 p1.amstrategies != (SELECT count(*) FROM pg_amop AS p3
568 WHERE p3.amopclaid = p2.oid);
570 -- Check that amopopr points at a reasonable-looking operator, ie a binary
571 -- operator yielding boolean.
572 -- NOTE: for 7.1, add restriction that operator inputs are of same type.
573 -- We used to have opclasses like "int24_ops" but these were broken.
575 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
576 FROM pg_amop AS p1, pg_operator AS p2
577 WHERE p1.amopopr = p2.oid AND
578 (p2.oprkind != 'b' OR p2.oprresult != 'bool'::regtype OR
579 p2.oprleft != p2.oprright);
581 -- Check that all operators linked to by opclass entries have selectivity
582 -- estimators. This is not absolutely required, but it seems a reasonable
583 -- thing to insist on for all standard datatypes.
585 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
586 FROM pg_amop AS p1, pg_operator AS p2
587 WHERE p1.amopopr = p2.oid AND
588 (p2.oprrest = 0 OR p2.oprjoin = 0);
590 -- Check that operator input types match the opclass
592 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
593 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
594 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
595 (p3.opcintype != p2.oprleft OR p3.opcintype != p2.oprright);
597 -- **************** pg_amproc ****************
599 -- Look for illegal values in pg_amproc fields
601 SELECT p1.amopclaid, p1.amprocnum
603 WHERE p1.amopclaid = 0 OR p1.amprocnum <= 0 OR p1.amproc = 0;
605 -- Cross-check amprocnum index against parent AM
607 SELECT p1.amopclaid, p1.amprocnum, p2.oid, p2.amname
608 FROM pg_amproc AS p1, pg_am AS p2, pg_opclass AS p3
609 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
610 p1.amprocnum > p2.amsupport;
612 -- Detect missing pg_amproc entries: should have as many support functions
613 -- as AM expects for each opclass for the AM
615 SELECT p1.oid, p1.amname, p2.oid, p2.opcname
616 FROM pg_am AS p1, pg_opclass AS p2
617 WHERE p2.opcamid = p1.oid AND
618 p1.amsupport != (SELECT count(*) FROM pg_amproc AS p3
619 WHERE p3.amopclaid = p2.oid);
621 -- Unfortunately, we can't check the amproc link very well because the
622 -- signature of the function may be different for different support routines
623 -- or different base data types.
624 -- We can check that all the referenced instances of the same support
625 -- routine number take the same number of parameters, but that's about it...
627 SELECT p1.amopclaid, p1.amprocnum,
630 p4.amopclaid, p4.amprocnum,
633 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3,
634 pg_amproc AS p4, pg_proc AS p5, pg_opclass AS p6
635 WHERE p1.amopclaid = p3.oid AND p4.amopclaid = p6.oid AND
636 p3.opcamid = p6.opcamid AND p1.amprocnum = p4.amprocnum AND
637 p1.amproc = p2.oid AND p4.amproc = p5.oid AND
638 (p2.proretset OR p5.proretset OR p2.pronargs != p5.pronargs);