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...
19 -- Helper functions to deal with cases where binary-coercible matches are
22 -- This should match IsBinaryCoercible() in parse_coerce.c.
23 create function binary_coercible(oid, oid) returns bool as
25 EXISTS(select 1 from pg_cast where
26 castsource = $1 and casttarget = $2 and
27 castfunc = 0 and castcontext = ''i'')'
30 -- This one ignores castcontext, so it considers only physical equivalence
31 -- and not whether the coercion can be invoked implicitly.
32 create function physically_coercible(oid, oid) returns bool as
34 EXISTS(select 1 from pg_cast where
35 castsource = $1 and casttarget = $2 and
39 -- **************** pg_proc ****************
41 -- Look for illegal values in pg_proc fields.
43 SELECT p1.oid, p1.proname
45 WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
47 array_lower(p1.proargtypes, 1) != 0 OR
48 array_upper(p1.proargtypes, 1) != p1.pronargs-1 OR
49 0::oid = ANY (p1.proargtypes);
51 -- Look for conflicting proc definitions (same names and input datatypes).
52 -- (This test should be dead code now that we have the unique index
53 -- pg_proc_proname_narg_type_index, but I'll leave it in anyway.)
55 SELECT p1.oid, p1.proname, p2.oid, p2.proname
56 FROM pg_proc AS p1, pg_proc AS p2
57 WHERE p1.oid != p2.oid AND
58 p1.proname = p2.proname AND
59 p1.pronargs = p2.pronargs AND
60 p1.proargtypes = p2.proargtypes;
62 -- Considering only built-in procs (prolang = 12), look for multiple uses
63 -- of the same internal function (ie, matching prosrc fields). It's OK to
64 -- have several entries with different pronames for the same internal function,
65 -- but conflicts in the number of arguments and other critical items should
68 SELECT p1.oid, p1.proname, p2.oid, p2.proname
69 FROM pg_proc AS p1, pg_proc AS p2
70 WHERE p1.oid != p2.oid AND
71 p1.prosrc = p2.prosrc AND
72 p1.prolang = 12 AND p2.prolang = 12 AND
73 (p1.prolang != p2.prolang OR
74 p1.proisagg != p2.proisagg OR
75 p1.prosecdef != p2.prosecdef OR
76 p1.proisstrict != p2.proisstrict OR
77 p1.proretset != p2.proretset OR
78 p1.provolatile != p2.provolatile OR
79 p1.pronargs != p2.pronargs);
81 -- Look for uses of different type OIDs in the argument/result type fields
82 -- for different aliases of the same built-in function.
83 -- This indicates that the types are being presumed to be binary-equivalent,
84 -- or that the built-in function is prepared to deal with different types.
85 -- That's not wrong, necessarily, but we make lists of all the types being
86 -- so treated. Note that the expected output of this part of the test will
87 -- need to be modified whenever new pairs of types are made binary-equivalent,
88 -- or when new polymorphic built-in functions are added!
89 -- Note: ignore aggregate functions here, since they all point to the same
90 -- dummy built-in function.
92 SELECT DISTINCT p1.prorettype, p2.prorettype
93 FROM pg_proc AS p1, pg_proc AS p2
94 WHERE p1.oid != p2.oid AND
95 p1.prosrc = p2.prosrc AND
96 p1.prolang = 12 AND p2.prolang = 12 AND
97 NOT p1.proisagg AND NOT p2.proisagg AND
98 (p1.prorettype < p2.prorettype);
100 SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
101 FROM pg_proc AS p1, pg_proc AS p2
102 WHERE p1.oid != p2.oid AND
103 p1.prosrc = p2.prosrc AND
104 p1.prolang = 12 AND p2.prolang = 12 AND
105 NOT p1.proisagg AND NOT p2.proisagg AND
106 (p1.proargtypes[0] < p2.proargtypes[0]);
108 SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
109 FROM pg_proc AS p1, pg_proc AS p2
110 WHERE p1.oid != p2.oid AND
111 p1.prosrc = p2.prosrc AND
112 p1.prolang = 12 AND p2.prolang = 12 AND
113 NOT p1.proisagg AND NOT p2.proisagg AND
114 (p1.proargtypes[1] < p2.proargtypes[1]);
116 SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
117 FROM pg_proc AS p1, pg_proc AS p2
118 WHERE p1.oid != p2.oid AND
119 p1.prosrc = p2.prosrc AND
120 p1.prolang = 12 AND p2.prolang = 12 AND
121 NOT p1.proisagg AND NOT p2.proisagg AND
122 (p1.proargtypes[2] < p2.proargtypes[2]);
124 SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
125 FROM pg_proc AS p1, pg_proc AS p2
126 WHERE p1.oid != p2.oid AND
127 p1.prosrc = p2.prosrc AND
128 p1.prolang = 12 AND p2.prolang = 12 AND
129 NOT p1.proisagg AND NOT p2.proisagg AND
130 (p1.proargtypes[3] < p2.proargtypes[3]);
132 SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
133 FROM pg_proc AS p1, pg_proc AS p2
134 WHERE p1.oid != p2.oid AND
135 p1.prosrc = p2.prosrc AND
136 p1.prolang = 12 AND p2.prolang = 12 AND
137 NOT p1.proisagg AND NOT p2.proisagg AND
138 (p1.proargtypes[4] < p2.proargtypes[4]);
140 SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
141 FROM pg_proc AS p1, pg_proc AS p2
142 WHERE p1.oid != p2.oid AND
143 p1.prosrc = p2.prosrc AND
144 p1.prolang = 12 AND p2.prolang = 12 AND
145 NOT p1.proisagg AND NOT p2.proisagg AND
146 (p1.proargtypes[5] < p2.proargtypes[5]);
148 SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
149 FROM pg_proc AS p1, pg_proc AS p2
150 WHERE p1.oid != p2.oid AND
151 p1.prosrc = p2.prosrc AND
152 p1.prolang = 12 AND p2.prolang = 12 AND
153 NOT p1.proisagg AND NOT p2.proisagg AND
154 (p1.proargtypes[6] < p2.proargtypes[6]);
156 SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
157 FROM pg_proc AS p1, pg_proc AS p2
158 WHERE p1.oid != p2.oid AND
159 p1.prosrc = p2.prosrc AND
160 p1.prolang = 12 AND p2.prolang = 12 AND
161 NOT p1.proisagg AND NOT p2.proisagg AND
162 (p1.proargtypes[7] < p2.proargtypes[7]);
164 -- Look for functions that return type "internal" and do not have any
165 -- "internal" argument. Such a function would be a security hole since
166 -- it might be used to call an internal function from an SQL command.
167 -- As of 7.3 this query should find only internal_in.
169 SELECT p1.oid, p1.proname
171 WHERE p1.prorettype = 'internal'::regtype AND NOT
172 'internal'::regtype = ANY (p1.proargtypes);
175 -- **************** pg_cast ****************
177 -- Catch bogus values in pg_cast columns (other than cases detected by
182 WHERE castsource = 0 OR casttarget = 0 OR castcontext NOT IN ('e', 'a', 'i');
184 -- Look for casts to/from the same type that aren't length coercion functions.
185 -- (We assume they are length coercions if they take multiple arguments.)
186 -- Such entries are not necessarily harmful, but they are useless.
190 WHERE castsource = casttarget AND castfunc = 0;
193 FROM pg_cast c, pg_proc p
194 WHERE c.castfunc = p.oid AND p.pronargs < 2 AND castsource = casttarget;
196 -- Look for cast functions that don't have the right signature. The
197 -- argument and result types in pg_proc must be the same as, or binary
198 -- compatible with, what it says in pg_cast.
199 -- As a special case, we allow casts from CHAR(n) that use functions
200 -- declared to take TEXT. This does not pass the binary-coercibility test
201 -- because CHAR(n)-to-TEXT normally invokes rtrim(). However, the results
202 -- are the same, so long as the function is one that ignores trailing blanks.
205 FROM pg_cast c, pg_proc p
206 WHERE c.castfunc = p.oid AND
207 (p.pronargs < 1 OR p.pronargs > 3
208 OR NOT (binary_coercible(c.castsource, p.proargtypes[0])
209 OR (c.castsource = 'character'::regtype AND
210 p.proargtypes[0] = 'text'::regtype))
211 OR NOT binary_coercible(p.prorettype, c.casttarget));
214 FROM pg_cast c, pg_proc p
215 WHERE c.castfunc = p.oid AND
216 ((p.pronargs > 1 AND p.proargtypes[1] != 'int4'::regtype) OR
217 (p.pronargs > 2 AND p.proargtypes[2] != 'bool'::regtype));
219 -- Look for binary compatible casts that do not have the reverse
220 -- direction registered as well, or where the reverse direction is not
221 -- also binary compatible. This is legal, but usually not intended.
223 -- As of 7.4, this finds the casts from text and varchar to bpchar, because
224 -- those are binary-compatible while the reverse way goes through rtrim().
228 WHERE c.castfunc = 0 AND
229 NOT EXISTS (SELECT 1 FROM pg_cast k
230 WHERE k.castfunc = 0 AND
231 k.castsource = c.casttarget AND
232 k.casttarget = c.castsource);
234 -- **************** pg_operator ****************
236 -- Look for illegal values in pg_operator fields.
238 SELECT p1.oid, p1.oprname
239 FROM pg_operator as p1
240 WHERE (p1.oprkind != 'b' AND p1.oprkind != 'l' AND p1.oprkind != 'r') OR
241 p1.oprresult = 0 OR p1.oprcode = 0;
243 -- Look for missing or unwanted operand types
245 SELECT p1.oid, p1.oprname
246 FROM pg_operator as p1
247 WHERE (p1.oprleft = 0 and p1.oprkind != 'l') OR
248 (p1.oprleft != 0 and p1.oprkind = 'l') OR
249 (p1.oprright = 0 and p1.oprkind != 'r') OR
250 (p1.oprright != 0 and p1.oprkind = 'r');
252 -- Look for conflicting operator definitions (same names and input datatypes).
254 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
255 FROM pg_operator AS p1, pg_operator AS p2
256 WHERE p1.oid != p2.oid AND
257 p1.oprname = p2.oprname AND
258 p1.oprkind = p2.oprkind AND
259 p1.oprleft = p2.oprleft AND
260 p1.oprright = p2.oprright;
262 -- Look for commutative operators that don't commute.
263 -- DEFINITIONAL NOTE: If A.oprcom = B, then x A y has the same result as y B x.
264 -- We expect that B will always say that B.oprcom = A as well; that's not
265 -- inherently essential, but it would be inefficient not to mark it so.
267 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
268 FROM pg_operator AS p1, pg_operator AS p2
269 WHERE p1.oprcom = p2.oid AND
270 (p1.oprkind != 'b' OR
271 p1.oprleft != p2.oprright OR
272 p1.oprright != p2.oprleft OR
273 p1.oprresult != p2.oprresult OR
274 p1.oid != p2.oprcom);
276 -- Look for negatory operators that don't agree.
277 -- DEFINITIONAL NOTE: If A.oprnegate = B, then both A and B must yield
278 -- boolean results, and (x A y) == ! (x B y), or the equivalent for
279 -- single-operand operators.
280 -- We expect that B will always say that B.oprnegate = A as well; that's not
281 -- inherently essential, but it would be inefficient not to mark it so.
282 -- Also, A and B had better not be the same operator.
284 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
285 FROM pg_operator AS p1, pg_operator AS p2
286 WHERE p1.oprnegate = p2.oid AND
287 (p1.oprkind != p2.oprkind OR
288 p1.oprleft != p2.oprleft OR
289 p1.oprright != p2.oprright OR
290 p1.oprresult != 'bool'::regtype OR
291 p2.oprresult != 'bool'::regtype OR
292 p1.oid != p2.oprnegate OR
295 -- Look for mergejoin operators that don't match their links.
296 -- An lsortop/rsortop link leads from an '=' operator to the
297 -- sort operator ('<' operator) that's appropriate for
298 -- its left-side or right-side data type.
299 -- An ltcmpop/gtcmpop link leads from an '=' operator to the
300 -- '<' or '>' operator of the same input datatypes.
301 -- (If the '=' operator has identical L and R input datatypes,
302 -- then lsortop, rsortop, and ltcmpop are all the same operator.)
304 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
305 FROM pg_operator AS p1, pg_operator AS p2
306 WHERE p1.oprlsortop = p2.oid AND
307 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
308 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
309 p1.oprleft != p2.oprleft OR
310 p1.oprleft != p2.oprright OR
311 p1.oprresult != 'bool'::regtype OR
312 p2.oprresult != 'bool'::regtype);
314 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
315 FROM pg_operator AS p1, pg_operator AS p2
316 WHERE p1.oprrsortop = p2.oid AND
317 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
318 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
319 p1.oprright != p2.oprleft OR
320 p1.oprright != p2.oprright OR
321 p1.oprresult != 'bool'::regtype OR
322 p2.oprresult != 'bool'::regtype);
324 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
325 FROM pg_operator AS p1, pg_operator AS p2
326 WHERE p1.oprltcmpop = p2.oid AND
327 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
328 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
329 p1.oprleft != p2.oprleft OR
330 p1.oprright != p2.oprright OR
331 p1.oprresult != 'bool'::regtype OR
332 p2.oprresult != 'bool'::regtype);
334 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
335 FROM pg_operator AS p1, pg_operator AS p2
336 WHERE p1.oprgtcmpop = p2.oid AND
337 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('>', '~>~') OR
338 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
339 p1.oprleft != p2.oprleft OR
340 p1.oprright != p2.oprright OR
341 p1.oprresult != 'bool'::regtype OR
342 p2.oprresult != 'bool'::regtype);
344 -- Make sure all four links are specified if any are.
346 SELECT p1.oid, p1.oprcode
347 FROM pg_operator AS p1
348 WHERE NOT ((oprlsortop = 0 AND oprrsortop = 0 AND
349 oprltcmpop = 0 AND oprgtcmpop = 0) OR
350 (oprlsortop != 0 AND oprrsortop != 0 AND
351 oprltcmpop != 0 AND oprgtcmpop != 0));
353 -- A mergejoinable = operator must have a commutator (usually itself).
355 SELECT p1.oid, p1.oprname FROM pg_operator AS p1
356 WHERE p1.oprlsortop != 0 AND
359 -- Mergejoinable operators across datatypes must come in closed sets, that
360 -- is if you provide int2 = int4 and int4 = int8 then you must also provide
361 -- int2 = int8 (and commutators of all these). This is necessary because
362 -- the planner tries to deduce additional qual clauses from transitivity
363 -- of mergejoinable operators. If there are clauses int2var = int4var and
364 -- int4var = int8var, the planner will deduce int2var = int8var ... and it
365 -- had better have a way to represent it.
367 SELECT p1.oid, p2.oid FROM pg_operator AS p1, pg_operator AS p2
368 WHERE p1.oprlsortop != p1.oprrsortop AND
369 p1.oprrsortop = p2.oprlsortop AND
370 p2.oprlsortop != p2.oprrsortop AND
371 NOT EXISTS (SELECT 1 FROM pg_operator p3 WHERE
372 p3.oprlsortop = p1.oprlsortop AND p3.oprrsortop = p2.oprrsortop);
375 -- Hashing only works on simple equality operators "type = sametype",
376 -- since the hash itself depends on the bitwise representation of the type.
377 -- Check that allegedly hashable operators look like they might be "=".
379 SELECT p1.oid, p1.oprname
380 FROM pg_operator AS p1
381 WHERE p1.oprcanhash AND NOT
382 (p1.oprkind = 'b' AND p1.oprresult = 'bool'::regtype AND
383 p1.oprleft = p1.oprright AND p1.oprname IN ('=', '~=~') AND
386 -- In 6.5 we accepted hashable array equality operators when the array element
387 -- type is hashable. However, what we actually need to make hashjoin work on
388 -- an array is a hashable element type *and* no padding between elements in
389 -- the array storage (or, perhaps, guaranteed-zero padding). Currently,
390 -- since the padding code in arrayfuncs.c is pretty bogus, it seems safest
391 -- to just forbid hashjoin on array equality ops.
392 -- This should be reconsidered someday.
394 -- -- Look for array equality operators that are hashable when the underlying
395 -- -- type is not, or vice versa. This is presumably bogus.
397 -- SELECT p1.oid, p1.oprcanhash, p2.oid, p2.oprcanhash, t1.typname, t2.typname
398 -- FROM pg_operator AS p1, pg_operator AS p2, pg_type AS t1, pg_type AS t2
399 -- WHERE p1.oprname = '=' AND p1.oprleft = p1.oprright AND
400 -- p2.oprname = '=' AND p2.oprleft = p2.oprright AND
401 -- p1.oprleft = t1.oid AND p2.oprleft = t2.oid AND t1.typelem = t2.oid AND
402 -- p1.oprcanhash != p2.oprcanhash;
404 -- Substitute check: forbid hashable array ops, period.
405 SELECT p1.oid, p1.oprname
406 FROM pg_operator AS p1, pg_proc AS p2
407 WHERE p1.oprcanhash AND p1.oprcode = p2.oid AND p2.proname = 'array_eq';
409 -- Hashable operators should appear as members of hash index opclasses.
411 SELECT p1.oid, p1.oprname
412 FROM pg_operator AS p1
413 WHERE p1.oprcanhash AND NOT EXISTS
414 (SELECT 1 FROM pg_opclass op JOIN pg_amop p ON op.oid = amopclaid
415 WHERE opcamid = (SELECT oid FROM pg_am WHERE amname = 'hash') AND
420 SELECT p1.oid, p1.oprname, op.opcname
421 FROM pg_operator AS p1, pg_opclass op, pg_amop p
422 WHERE amopopr = p1.oid AND amopclaid = op.oid
423 AND opcamid = (SELECT oid FROM pg_am WHERE amname = 'hash')
424 AND NOT p1.oprcanhash;
426 -- Check that each operator defined in pg_operator matches its oprcode entry
427 -- in pg_proc. Easiest to do this separately for each oprkind.
429 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
430 FROM pg_operator AS p1, pg_proc AS p2
431 WHERE p1.oprcode = p2.oid AND
434 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
435 OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
436 OR NOT binary_coercible(p1.oprright, p2.proargtypes[1]));
438 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
439 FROM pg_operator AS p1, pg_proc AS p2
440 WHERE p1.oprcode = p2.oid AND
443 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
444 OR NOT binary_coercible(p1.oprright, p2.proargtypes[0])
447 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
448 FROM pg_operator AS p1, pg_proc AS p2
449 WHERE p1.oprcode = p2.oid AND
452 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
453 OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
454 OR p1.oprright != 0);
456 -- If the operator is mergejoinable or hashjoinable, its underlying function
457 -- should not be volatile.
459 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
460 FROM pg_operator AS p1, pg_proc AS p2
461 WHERE p1.oprcode = p2.oid AND
462 (p1.oprlsortop != 0 OR p1.oprcanhash) AND
463 p2.provolatile = 'v';
465 -- If oprrest is set, the operator must return boolean,
466 -- and it must link to a proc with the right signature
467 -- to be a restriction selectivity estimator.
468 -- The proc signature we want is: float8 proc(internal, oid, internal, int4)
470 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
471 FROM pg_operator AS p1, pg_proc AS p2
472 WHERE p1.oprrest = p2.oid AND
473 (p1.oprresult != 'bool'::regtype OR
474 p2.prorettype != 'float8'::regtype OR p2.proretset OR
476 p2.proargtypes[0] != 'internal'::regtype OR
477 p2.proargtypes[1] != 'oid'::regtype OR
478 p2.proargtypes[2] != 'internal'::regtype OR
479 p2.proargtypes[3] != 'int4'::regtype);
481 -- If oprjoin is set, the operator must be a binary boolean op,
482 -- and it must link to a proc with the right signature
483 -- to be a join selectivity estimator.
484 -- The proc signature we want is: float8 proc(internal, oid, internal, int2)
486 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
487 FROM pg_operator AS p1, pg_proc AS p2
488 WHERE p1.oprjoin = p2.oid AND
489 (p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
490 p2.prorettype != 'float8'::regtype OR p2.proretset OR
492 p2.proargtypes[0] != 'internal'::regtype OR
493 p2.proargtypes[1] != 'oid'::regtype OR
494 p2.proargtypes[2] != 'internal'::regtype OR
495 p2.proargtypes[3] != 'int2'::regtype);
497 -- **************** pg_aggregate ****************
499 -- Look for illegal values in pg_aggregate fields.
501 SELECT ctid, aggfnoid::oid
502 FROM pg_aggregate as p1
503 WHERE aggfnoid = 0 OR aggtransfn = 0 OR aggtranstype = 0;
505 -- Make sure the matching pg_proc entry is sensible, too.
507 SELECT a.aggfnoid::oid, p.proname
508 FROM pg_aggregate as a, pg_proc as p
509 WHERE a.aggfnoid = p.oid AND
510 (NOT p.proisagg OR p.pronargs != 1 OR p.proretset);
512 -- Make sure there are no proisagg pg_proc entries without matches.
517 NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid);
519 -- If there is no finalfn then the output type must be the transtype.
521 SELECT a.aggfnoid::oid, p.proname
522 FROM pg_aggregate as a, pg_proc as p
523 WHERE a.aggfnoid = p.oid AND
524 a.aggfinalfn = 0 AND p.prorettype != a.aggtranstype;
526 -- Cross-check transfn against its entry in pg_proc.
527 -- NOTE: use physically_coercible here, not binary_coercible, because
528 -- max and min on abstime are implemented using int4larger/int4smaller.
529 SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
530 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
531 WHERE a.aggfnoid = p.oid AND
532 a.aggtransfn = ptr.oid AND
534 OR NOT physically_coercible(ptr.prorettype, a.aggtranstype)
535 OR NOT physically_coercible(a.aggtranstype, ptr.proargtypes[0])
536 OR NOT ((ptr.pronargs = 2 AND
537 physically_coercible(p.proargtypes[0], ptr.proargtypes[1]))
539 (ptr.pronargs = 1 AND
540 p.proargtypes[0] = '"any"'::regtype)));
542 -- Cross-check finalfn (if present) against its entry in pg_proc.
544 SELECT a.aggfnoid::oid, p.proname, pfn.oid, pfn.proname
545 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS pfn
546 WHERE a.aggfnoid = p.oid AND
547 a.aggfinalfn = pfn.oid AND
549 OR NOT binary_coercible(pfn.prorettype, p.prorettype)
551 OR NOT binary_coercible(a.aggtranstype, pfn.proargtypes[0]));
553 -- If transfn is strict then either initval should be non-NULL, or
554 -- input type should match transtype so that the first non-null input
555 -- can be assigned as the state value.
557 SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
558 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
559 WHERE a.aggfnoid = p.oid AND
560 a.aggtransfn = ptr.oid AND ptr.proisstrict AND
561 a.agginitval IS NULL AND
562 NOT binary_coercible(p.proargtypes[0], a.aggtranstype);
564 -- **************** pg_opclass ****************
566 -- Look for illegal values in pg_opclass fields
569 FROM pg_opclass as p1
570 WHERE p1.opcamid = 0 OR p1.opcintype = 0;
572 -- There should not be multiple entries in pg_opclass with opcdefault true
573 -- and the same opcamid/opcintype combination.
575 SELECT p1.oid, p2.oid
576 FROM pg_opclass AS p1, pg_opclass AS p2
577 WHERE p1.oid != p2.oid AND
578 p1.opcamid = p2.opcamid AND p1.opcintype = p2.opcintype AND
579 p1.opcdefault AND p2.opcdefault;
581 -- **************** pg_amop ****************
583 -- Look for illegal values in pg_amop fields
585 SELECT p1.amopclaid, p1.amopstrategy
587 WHERE p1.amopclaid = 0 OR p1.amopstrategy <= 0 OR p1.amopopr = 0;
589 -- Cross-check amopstrategy index against parent AM
591 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.amname
592 FROM pg_amop AS p1, pg_am AS p2, pg_opclass AS p3
593 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
594 p1.amopstrategy > p2.amstrategies;
596 -- Detect missing pg_amop entries: should have as many strategy operators
597 -- as AM expects for each opclass for the AM. When nondefault subtypes are
598 -- present, enforce condition separately for each subtype.
600 SELECT p1.oid, p1.amname, p2.oid, p2.opcname, p3.amopsubtype
601 FROM pg_am AS p1, pg_opclass AS p2, pg_amop AS p3
602 WHERE p2.opcamid = p1.oid AND p3.amopclaid = p2.oid AND
603 p1.amstrategies != (SELECT count(*) FROM pg_amop AS p4
604 WHERE p4.amopclaid = p2.oid AND
605 p4.amopsubtype = p3.amopsubtype);
607 -- Check that amopopr points at a reasonable-looking operator, ie a binary
608 -- operator yielding boolean.
610 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
611 FROM pg_amop AS p1, pg_operator AS p2
612 WHERE p1.amopopr = p2.oid AND
613 (p2.oprkind != 'b' OR p2.oprresult != 'bool'::regtype);
615 -- Make a list of all the distinct operator names being used in particular
616 -- strategy slots. This is a bit hokey, since the list might need to change
617 -- in future releases, but it's an effective way of spotting mistakes such as
618 -- swapping two operators within a class.
620 SELECT DISTINCT opcamid, amopstrategy, oprname
621 FROM pg_amop p1 LEFT JOIN pg_opclass p2 ON amopclaid = p2.oid
622 LEFT JOIN pg_operator p3 ON amopopr = p3.oid
625 -- Check that all operators linked to by opclass entries have selectivity
626 -- estimators. This is not absolutely required, but it seems a reasonable
627 -- thing to insist on for all standard datatypes.
629 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
630 FROM pg_amop AS p1, pg_operator AS p2
631 WHERE p1.amopopr = p2.oid AND
632 (p2.oprrest = 0 OR p2.oprjoin = 0);
634 -- Check that operator input types match the opclass
635 -- For 8.0, we require that oprleft match opcintype (possibly by coercion).
636 -- When amopsubtype is zero (default), oprright must equal oprleft;
637 -- when amopsubtype is not zero, oprright must equal amopsubtype.
639 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
640 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
641 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
642 NOT binary_coercible(p3.opcintype, p2.oprleft);
644 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
645 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
646 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
647 p1.amopsubtype = 0 AND
648 p2.oprleft != p2.oprright;
650 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
651 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
652 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
653 p1.amopsubtype != 0 AND
654 p1.amopsubtype != p2.oprright;
656 -- Operators that are primary members of opclasses must be immutable (else
657 -- it suggests that the index ordering isn't fixed). Operators that are
658 -- cross-type members need only be stable, since they are just shorthands
659 -- for index probe queries.
661 SELECT p1.amopclaid, p1.amopopr, p2.oprname, p3.prosrc
662 FROM pg_amop AS p1, pg_operator AS p2, pg_proc AS p3
663 WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND
664 p1.amopsubtype = 0 AND
665 p3.provolatile != 'i';
667 SELECT p1.amopclaid, p1.amopopr, p2.oprname, p3.prosrc
668 FROM pg_amop AS p1, pg_operator AS p2, pg_proc AS p3
669 WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND
670 p1.amopsubtype != 0 AND
671 p3.provolatile = 'v';
673 -- **************** pg_amproc ****************
675 -- Look for illegal values in pg_amproc fields
677 SELECT p1.amopclaid, p1.amprocnum
679 WHERE p1.amopclaid = 0 OR p1.amprocnum <= 0 OR p1.amproc = 0;
681 -- Cross-check amprocnum index against parent AM
683 SELECT p1.amopclaid, p1.amprocnum, p2.oid, p2.amname
684 FROM pg_amproc AS p1, pg_am AS p2, pg_opclass AS p3
685 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
686 p1.amprocnum > p2.amsupport;
688 -- Detect missing pg_amproc entries: should have as many support functions
689 -- as AM expects for each opclass for the AM. When nondefault subtypes are
690 -- present, enforce condition separately for each subtype.
692 SELECT p1.oid, p1.amname, p2.oid, p2.opcname, p3.amprocsubtype
693 FROM pg_am AS p1, pg_opclass AS p2, pg_amproc AS p3
694 WHERE p2.opcamid = p1.oid AND p3.amopclaid = p2.oid AND
695 p1.amsupport != (SELECT count(*) FROM pg_amproc AS p4
696 WHERE p4.amopclaid = p2.oid AND
697 p4.amprocsubtype = p3.amprocsubtype);
699 -- Unfortunately, we can't check the amproc link very well because the
700 -- signature of the function may be different for different support routines
701 -- or different base data types.
702 -- We can check that all the referenced instances of the same support
703 -- routine number take the same number of parameters, but that's about it
704 -- for a general check...
706 SELECT p1.amopclaid, p1.amprocnum,
709 p4.amopclaid, p4.amprocnum,
712 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3,
713 pg_amproc AS p4, pg_proc AS p5, pg_opclass AS p6
714 WHERE p1.amopclaid = p3.oid AND p4.amopclaid = p6.oid AND
715 p3.opcamid = p6.opcamid AND p1.amprocnum = p4.amprocnum AND
716 p1.amproc = p2.oid AND p4.amproc = p5.oid AND
717 (p2.proretset OR p5.proretset OR p2.pronargs != p5.pronargs);
719 -- For btree, though, we can do better since we know the support routines
720 -- must be of the form cmp(input, input) returns int4 in the default case
721 -- (subtype = 0), and cmp(input, subtype) returns int4 when subtype != 0.
723 SELECT p1.amopclaid, p1.amprocnum,
726 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
727 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'btree')
728 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
729 amprocsubtype = 0 AND
735 OR NOT binary_coercible(opcintype, proargtypes[0])
736 OR proargtypes[0] != proargtypes[1]);
738 SELECT p1.amopclaid, p1.amprocnum,
741 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
742 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'btree')
743 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
744 amprocsubtype != 0 AND
750 OR NOT binary_coercible(opcintype, proargtypes[0])
751 OR proargtypes[1] != amprocsubtype);
753 -- For hash we can also do a little better: the support routines must be
754 -- of the form hash(something) returns int4. Ideally we'd check that the
755 -- opcintype is binary-coercible to the function's input, but there are
756 -- enough cases where that fails that I'll just leave out the check for now.
758 SELECT p1.amopclaid, p1.amprocnum,
761 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
762 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'hash')
763 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
769 -- OR NOT physically_coercible(opcintype, proargtypes[0])
772 -- Support routines that are primary members of opclasses must be immutable
773 -- (else it suggests that the index ordering isn't fixed). But cross-type
774 -- members need only be stable, since they are just shorthands
775 -- for index probe queries.
777 SELECT p1.amopclaid, p1.amproc, p2.prosrc
778 FROM pg_amproc AS p1, pg_proc AS p2
779 WHERE p1.amproc = p2.oid AND
780 p1.amprocsubtype = 0 AND
781 p2.provolatile != 'i';
783 SELECT p1.amopclaid, p1.amproc, p2.prosrc
784 FROM pg_amproc AS p1, pg_proc AS p2
785 WHERE p1.amproc = p2.oid AND
786 p1.amprocsubtype != 0 AND
787 p2.provolatile = 'v';