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.
42 -- NOTE: in reality pronargs could be more than 10, but I'm too lazy to put
43 -- a larger number of proargtypes check clauses in here. If we ever have
44 -- more-than-10-arg functions in the standard catalogs, extend this query.
46 SELECT p1.oid, p1.proname
48 WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
49 p1.pronargs < 0 OR p1.pronargs > 10 OR
50 (p1.proargtypes[0] = 0 AND p1.pronargs > 0) OR
51 (p1.proargtypes[1] = 0 AND p1.pronargs > 1) OR
52 (p1.proargtypes[2] = 0 AND p1.pronargs > 2) OR
53 (p1.proargtypes[3] = 0 AND p1.pronargs > 3) OR
54 (p1.proargtypes[4] = 0 AND p1.pronargs > 4) OR
55 (p1.proargtypes[5] = 0 AND p1.pronargs > 5) OR
56 (p1.proargtypes[6] = 0 AND p1.pronargs > 6) OR
57 (p1.proargtypes[7] = 0 AND p1.pronargs > 7) OR
58 (p1.proargtypes[8] = 0 AND p1.pronargs > 8) OR
59 (p1.proargtypes[9] = 0 AND p1.pronargs > 9);
61 -- Look for conflicting proc definitions (same names and input datatypes).
62 -- (This test should be dead code now that we have the unique index
63 -- pg_proc_proname_narg_type_index, but I'll leave it in anyway.)
65 SELECT p1.oid, p1.proname, p2.oid, p2.proname
66 FROM pg_proc AS p1, pg_proc AS p2
67 WHERE p1.oid != p2.oid AND
68 p1.proname = p2.proname AND
69 p1.pronargs = p2.pronargs AND
70 p1.proargtypes = p2.proargtypes;
72 -- Considering only built-in procs (prolang = 12), look for multiple uses
73 -- of the same internal function (ie, matching prosrc fields). It's OK to
74 -- have several entries with different pronames for the same internal function,
75 -- but conflicts in the number of arguments and other critical items should
78 SELECT p1.oid, p1.proname, p2.oid, p2.proname
79 FROM pg_proc AS p1, pg_proc AS p2
80 WHERE p1.oid != p2.oid AND
81 p1.prosrc = p2.prosrc AND
82 p1.prolang = 12 AND p2.prolang = 12 AND
83 (p1.prolang != p2.prolang OR
84 p1.proisagg != p2.proisagg OR
85 p1.prosecdef != p2.prosecdef OR
86 p1.proisstrict != p2.proisstrict OR
87 p1.proretset != p2.proretset OR
88 p1.provolatile != p2.provolatile OR
89 p1.pronargs != p2.pronargs);
91 -- Look for uses of different type OIDs in the argument/result type fields
92 -- for different aliases of the same built-in function.
93 -- This indicates that the types are being presumed to be binary-equivalent,
94 -- or that the built-in function is prepared to deal with different types.
95 -- That's not wrong, necessarily, but we make lists of all the types being
96 -- so treated. Note that the expected output of this part of the test will
97 -- need to be modified whenever new pairs of types are made binary-equivalent,
98 -- or when new polymorphic built-in functions are added!
99 -- Note: ignore aggregate functions here, since they all point to the same
100 -- dummy built-in function.
102 SELECT DISTINCT p1.prorettype, p2.prorettype
103 FROM pg_proc AS p1, pg_proc AS p2
104 WHERE p1.oid != p2.oid AND
105 p1.prosrc = p2.prosrc AND
106 p1.prolang = 12 AND p2.prolang = 12 AND
107 NOT p1.proisagg AND NOT p2.proisagg AND
108 (p1.prorettype < p2.prorettype);
110 SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
111 FROM pg_proc AS p1, pg_proc AS p2
112 WHERE p1.oid != p2.oid AND
113 p1.prosrc = p2.prosrc AND
114 p1.prolang = 12 AND p2.prolang = 12 AND
115 NOT p1.proisagg AND NOT p2.proisagg AND
116 (p1.proargtypes[0] < p2.proargtypes[0]);
118 SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
119 FROM pg_proc AS p1, pg_proc AS p2
120 WHERE p1.oid != p2.oid AND
121 p1.prosrc = p2.prosrc AND
122 p1.prolang = 12 AND p2.prolang = 12 AND
123 NOT p1.proisagg AND NOT p2.proisagg AND
124 (p1.proargtypes[1] < p2.proargtypes[1]);
126 SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
127 FROM pg_proc AS p1, pg_proc AS p2
128 WHERE p1.oid != p2.oid AND
129 p1.prosrc = p2.prosrc AND
130 p1.prolang = 12 AND p2.prolang = 12 AND
131 NOT p1.proisagg AND NOT p2.proisagg AND
132 (p1.proargtypes[2] < p2.proargtypes[2]);
134 SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
135 FROM pg_proc AS p1, pg_proc AS p2
136 WHERE p1.oid != p2.oid AND
137 p1.prosrc = p2.prosrc AND
138 p1.prolang = 12 AND p2.prolang = 12 AND
139 NOT p1.proisagg AND NOT p2.proisagg AND
140 (p1.proargtypes[3] < p2.proargtypes[3]);
142 SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
143 FROM pg_proc AS p1, pg_proc AS p2
144 WHERE p1.oid != p2.oid AND
145 p1.prosrc = p2.prosrc AND
146 p1.prolang = 12 AND p2.prolang = 12 AND
147 NOT p1.proisagg AND NOT p2.proisagg AND
148 (p1.proargtypes[4] < p2.proargtypes[4]);
150 SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
151 FROM pg_proc AS p1, pg_proc AS p2
152 WHERE p1.oid != p2.oid AND
153 p1.prosrc = p2.prosrc AND
154 p1.prolang = 12 AND p2.prolang = 12 AND
155 NOT p1.proisagg AND NOT p2.proisagg AND
156 (p1.proargtypes[5] < p2.proargtypes[5]);
158 SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
159 FROM pg_proc AS p1, pg_proc AS p2
160 WHERE p1.oid != p2.oid AND
161 p1.prosrc = p2.prosrc AND
162 p1.prolang = 12 AND p2.prolang = 12 AND
163 NOT p1.proisagg AND NOT p2.proisagg AND
164 (p1.proargtypes[6] < p2.proargtypes[6]);
166 SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
167 FROM pg_proc AS p1, pg_proc AS p2
168 WHERE p1.oid != p2.oid AND
169 p1.prosrc = p2.prosrc AND
170 p1.prolang = 12 AND p2.prolang = 12 AND
171 NOT p1.proisagg AND NOT p2.proisagg AND
172 (p1.proargtypes[7] < p2.proargtypes[7]);
174 -- Look for functions that return type "internal" and do not have any
175 -- "internal" argument. Such a function would be a security hole since
176 -- it might be used to call an internal function from an SQL command.
177 -- As of 7.3 this query should find only internal_in.
179 SELECT p1.oid, p1.proname
181 WHERE p1.prorettype = 'internal'::regtype AND NOT
182 ('(' || oidvectortypes(p1.proargtypes) || ')') ~ '[^a-z0-9_]internal[^a-z0-9_]';
185 -- **************** pg_cast ****************
187 -- Look for casts from and to the same type. This is not harmful, but
188 -- useless. Also catch bogus values in pg_cast columns (other than
189 -- cases detected by oidjoins test).
193 WHERE castsource = casttarget OR castsource = 0 OR casttarget = 0
194 OR castcontext NOT IN ('e', 'a', 'i');
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
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));
213 -- Look for binary compatible casts that do not have the reverse
214 -- direction registered as well, or where the reverse direction is not
215 -- also binary compatible. This is legal, but usually not intended.
217 -- As of 7.4, this finds the casts from text and varchar to bpchar, because
218 -- those are binary-compatible while the reverse way goes through rtrim().
222 WHERE c.castfunc = 0 AND
223 NOT EXISTS (SELECT 1 FROM pg_cast k
224 WHERE k.castfunc = 0 AND
225 k.castsource = c.casttarget AND
226 k.casttarget = c.castsource);
228 -- **************** pg_operator ****************
230 -- Look for illegal values in pg_operator fields.
232 SELECT p1.oid, p1.oprname
233 FROM pg_operator as p1
234 WHERE (p1.oprkind != 'b' AND p1.oprkind != 'l' AND p1.oprkind != 'r') OR
235 p1.oprresult = 0 OR p1.oprcode = 0;
237 -- Look for missing or unwanted operand types
239 SELECT p1.oid, p1.oprname
240 FROM pg_operator as p1
241 WHERE (p1.oprleft = 0 and p1.oprkind != 'l') OR
242 (p1.oprleft != 0 and p1.oprkind = 'l') OR
243 (p1.oprright = 0 and p1.oprkind != 'r') OR
244 (p1.oprright != 0 and p1.oprkind = 'r');
246 -- Look for conflicting operator definitions (same names and input datatypes).
248 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
249 FROM pg_operator AS p1, pg_operator AS p2
250 WHERE p1.oid != p2.oid AND
251 p1.oprname = p2.oprname AND
252 p1.oprkind = p2.oprkind AND
253 p1.oprleft = p2.oprleft AND
254 p1.oprright = p2.oprright;
256 -- Look for commutative operators that don't commute.
257 -- DEFINITIONAL NOTE: If A.oprcom = B, then x A y has the same result as y B x.
258 -- We expect that B will always say that B.oprcom = A as well; that's not
259 -- inherently essential, but it would be inefficient not to mark it so.
261 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
262 FROM pg_operator AS p1, pg_operator AS p2
263 WHERE p1.oprcom = p2.oid AND
264 (p1.oprkind != 'b' OR
265 p1.oprleft != p2.oprright OR
266 p1.oprright != p2.oprleft OR
267 p1.oprresult != p2.oprresult OR
268 p1.oid != p2.oprcom);
270 -- Look for negatory operators that don't agree.
271 -- DEFINITIONAL NOTE: If A.oprnegate = B, then both A and B must yield
272 -- boolean results, and (x A y) == ! (x B y), or the equivalent for
273 -- single-operand operators.
274 -- We expect that B will always say that B.oprnegate = A as well; that's not
275 -- inherently essential, but it would be inefficient not to mark it so.
276 -- Also, A and B had better not be the same operator.
278 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
279 FROM pg_operator AS p1, pg_operator AS p2
280 WHERE p1.oprnegate = p2.oid AND
281 (p1.oprkind != p2.oprkind OR
282 p1.oprleft != p2.oprleft OR
283 p1.oprright != p2.oprright OR
284 p1.oprresult != 'bool'::regtype OR
285 p2.oprresult != 'bool'::regtype OR
286 p1.oid != p2.oprnegate OR
289 -- Look for mergejoin operators that don't match their links.
290 -- An lsortop/rsortop link leads from an '=' operator to the
291 -- sort operator ('<' operator) that's appropriate for
292 -- its left-side or right-side data type.
293 -- An ltcmpop/gtcmpop link leads from an '=' operator to the
294 -- '<' or '>' operator of the same input datatypes.
295 -- (If the '=' operator has identical L and R input datatypes,
296 -- then lsortop, rsortop, and ltcmpop are all the same operator.)
298 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
299 FROM pg_operator AS p1, pg_operator AS p2
300 WHERE p1.oprlsortop = p2.oid AND
301 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
302 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
303 p1.oprleft != p2.oprleft OR
304 p1.oprleft != p2.oprright OR
305 p1.oprresult != 'bool'::regtype OR
306 p2.oprresult != 'bool'::regtype);
308 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
309 FROM pg_operator AS p1, pg_operator AS p2
310 WHERE p1.oprrsortop = p2.oid AND
311 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
312 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
313 p1.oprright != p2.oprleft OR
314 p1.oprright != p2.oprright OR
315 p1.oprresult != 'bool'::regtype OR
316 p2.oprresult != 'bool'::regtype);
318 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
319 FROM pg_operator AS p1, pg_operator AS p2
320 WHERE p1.oprltcmpop = p2.oid AND
321 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('<', '~<~') OR
322 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
323 p1.oprleft != p2.oprleft OR
324 p1.oprright != p2.oprright OR
325 p1.oprresult != 'bool'::regtype OR
326 p2.oprresult != 'bool'::regtype);
328 SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
329 FROM pg_operator AS p1, pg_operator AS p2
330 WHERE p1.oprgtcmpop = p2.oid AND
331 (p1.oprname NOT IN ('=', '~=~') OR p2.oprname NOT IN ('>', '~>~') OR
332 p1.oprkind != 'b' OR p2.oprkind != 'b' OR
333 p1.oprleft != p2.oprleft OR
334 p1.oprright != p2.oprright OR
335 p1.oprresult != 'bool'::regtype OR
336 p2.oprresult != 'bool'::regtype);
338 -- Make sure all four links are specified if any are.
340 SELECT p1.oid, p1.oprcode
341 FROM pg_operator AS p1
342 WHERE NOT ((oprlsortop = 0 AND oprrsortop = 0 AND
343 oprltcmpop = 0 AND oprgtcmpop = 0) OR
344 (oprlsortop != 0 AND oprrsortop != 0 AND
345 oprltcmpop != 0 AND oprgtcmpop != 0));
347 -- A mergejoinable = operator must have a commutator (usually itself).
349 SELECT p1.oid, p1.oprname FROM pg_operator AS p1
350 WHERE p1.oprlsortop != 0 AND
353 -- Mergejoinable operators across datatypes must come in closed sets, that
354 -- is if you provide int2 = int4 and int4 = int8 then you must also provide
355 -- int2 = int8 (and commutators of all these). This is necessary because
356 -- the planner tries to deduce additional qual clauses from transitivity
357 -- of mergejoinable operators. If there are clauses int2var = int4var and
358 -- int4var = int8var, the planner will deduce int2var = int8var ... and it
359 -- had better have a way to represent it.
361 SELECT p1.oid, p2.oid FROM pg_operator AS p1, pg_operator AS p2
362 WHERE p1.oprlsortop != p1.oprrsortop AND
363 p1.oprrsortop = p2.oprlsortop AND
364 p2.oprlsortop != p2.oprrsortop AND
365 NOT EXISTS (SELECT 1 FROM pg_operator p3 WHERE
366 p3.oprlsortop = p1.oprlsortop AND p3.oprrsortop = p2.oprrsortop);
369 -- Hashing only works on simple equality operators "type = sametype",
370 -- since the hash itself depends on the bitwise representation of the type.
371 -- Check that allegedly hashable operators look like they might be "=".
373 SELECT p1.oid, p1.oprname
374 FROM pg_operator AS p1
375 WHERE p1.oprcanhash AND NOT
376 (p1.oprkind = 'b' AND p1.oprresult = 'bool'::regtype AND
377 p1.oprleft = p1.oprright AND p1.oprname IN ('=', '~=~') AND
380 -- In 6.5 we accepted hashable array equality operators when the array element
381 -- type is hashable. However, what we actually need to make hashjoin work on
382 -- an array is a hashable element type *and* no padding between elements in
383 -- the array storage (or, perhaps, guaranteed-zero padding). Currently,
384 -- since the padding code in arrayfuncs.c is pretty bogus, it seems safest
385 -- to just forbid hashjoin on array equality ops.
386 -- This should be reconsidered someday.
388 -- -- Look for array equality operators that are hashable when the underlying
389 -- -- type is not, or vice versa. This is presumably bogus.
391 -- SELECT p1.oid, p1.oprcanhash, p2.oid, p2.oprcanhash, t1.typname, t2.typname
392 -- FROM pg_operator AS p1, pg_operator AS p2, pg_type AS t1, pg_type AS t2
393 -- WHERE p1.oprname = '=' AND p1.oprleft = p1.oprright AND
394 -- p2.oprname = '=' AND p2.oprleft = p2.oprright AND
395 -- p1.oprleft = t1.oid AND p2.oprleft = t2.oid AND t1.typelem = t2.oid AND
396 -- p1.oprcanhash != p2.oprcanhash;
398 -- Substitute check: forbid hashable array ops, period.
399 SELECT p1.oid, p1.oprname
400 FROM pg_operator AS p1, pg_proc AS p2
401 WHERE p1.oprcanhash AND p1.oprcode = p2.oid AND p2.proname = 'array_eq';
403 -- Hashable operators should appear as members of hash index opclasses.
405 SELECT p1.oid, p1.oprname
406 FROM pg_operator AS p1
407 WHERE p1.oprcanhash AND NOT EXISTS
408 (SELECT 1 FROM pg_opclass op JOIN pg_amop p ON op.oid = amopclaid
409 WHERE opcamid = (SELECT oid FROM pg_am WHERE amname = 'hash') AND
413 -- Check that each operator defined in pg_operator matches its oprcode entry
414 -- in pg_proc. Easiest to do this separately for each oprkind.
416 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
417 FROM pg_operator AS p1, pg_proc AS p2
418 WHERE p1.oprcode = p2.oid AND
421 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
422 OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
423 OR NOT binary_coercible(p1.oprright, p2.proargtypes[1]));
425 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
426 FROM pg_operator AS p1, pg_proc AS p2
427 WHERE p1.oprcode = p2.oid AND
430 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
431 OR NOT binary_coercible(p1.oprright, p2.proargtypes[0])
434 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
435 FROM pg_operator AS p1, pg_proc AS p2
436 WHERE p1.oprcode = p2.oid AND
439 OR NOT binary_coercible(p2.prorettype, p1.oprresult)
440 OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
441 OR p1.oprright != 0);
443 -- If the operator is mergejoinable or hashjoinable, its underlying function
444 -- should not be volatile.
446 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
447 FROM pg_operator AS p1, pg_proc AS p2
448 WHERE p1.oprcode = p2.oid AND
449 (p1.oprlsortop != 0 OR p1.oprcanhash) AND
450 p2.provolatile = 'v';
452 -- If oprrest is set, the operator must return boolean,
453 -- and it must link to a proc with the right signature
454 -- to be a restriction selectivity estimator.
455 -- The proc signature we want is: float8 proc(internal, oid, internal, int4)
457 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
458 FROM pg_operator AS p1, pg_proc AS p2
459 WHERE p1.oprrest = p2.oid AND
460 (p1.oprresult != 'bool'::regtype OR
461 p2.prorettype != 'float8'::regtype OR p2.proretset OR
463 p2.proargtypes[0] != 'internal'::regtype OR
464 p2.proargtypes[1] != 'oid'::regtype OR
465 p2.proargtypes[2] != 'internal'::regtype OR
466 p2.proargtypes[3] != 'int4'::regtype);
468 -- If oprjoin is set, the operator must be a binary boolean op,
469 -- and it must link to a proc with the right signature
470 -- to be a join selectivity estimator.
471 -- The proc signature we want is: float8 proc(internal, oid, internal, int2)
473 SELECT p1.oid, p1.oprname, p2.oid, p2.proname
474 FROM pg_operator AS p1, pg_proc AS p2
475 WHERE p1.oprjoin = p2.oid AND
476 (p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
477 p2.prorettype != 'float8'::regtype OR p2.proretset OR
479 p2.proargtypes[0] != 'internal'::regtype OR
480 p2.proargtypes[1] != 'oid'::regtype OR
481 p2.proargtypes[2] != 'internal'::regtype OR
482 p2.proargtypes[3] != 'int2'::regtype);
484 -- **************** pg_aggregate ****************
486 -- Look for illegal values in pg_aggregate fields.
488 SELECT ctid, aggfnoid::oid
489 FROM pg_aggregate as p1
490 WHERE aggfnoid = 0 OR aggtransfn = 0 OR aggtranstype = 0;
492 -- Make sure the matching pg_proc entry is sensible, too.
494 SELECT a.aggfnoid::oid, p.proname
495 FROM pg_aggregate as a, pg_proc as p
496 WHERE a.aggfnoid = p.oid AND
497 (NOT p.proisagg OR p.pronargs != 1 OR p.proretset);
499 -- Make sure there are no proisagg pg_proc entries without matches.
504 NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid);
506 -- If there is no finalfn then the output type must be the transtype.
508 SELECT a.aggfnoid::oid, p.proname
509 FROM pg_aggregate as a, pg_proc as p
510 WHERE a.aggfnoid = p.oid AND
511 a.aggfinalfn = 0 AND p.prorettype != a.aggtranstype;
513 -- Cross-check transfn against its entry in pg_proc.
514 -- NOTE: use physically_coercible here, not binary_coercible, because
515 -- max and min on abstime are implemented using int4larger/int4smaller.
516 SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
517 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
518 WHERE a.aggfnoid = p.oid AND
519 a.aggtransfn = ptr.oid AND
521 OR NOT physically_coercible(ptr.prorettype, a.aggtranstype)
522 OR NOT physically_coercible(a.aggtranstype, ptr.proargtypes[0])
523 OR NOT ((ptr.pronargs = 2 AND
524 physically_coercible(p.proargtypes[0], ptr.proargtypes[1]))
526 (ptr.pronargs = 1 AND
527 p.proargtypes[0] = '"any"'::regtype)));
529 -- Cross-check finalfn (if present) against its entry in pg_proc.
531 SELECT a.aggfnoid::oid, p.proname, pfn.oid, pfn.proname
532 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS pfn
533 WHERE a.aggfnoid = p.oid AND
534 a.aggfinalfn = pfn.oid AND
536 OR NOT binary_coercible(pfn.prorettype, p.prorettype)
538 OR NOT binary_coercible(a.aggtranstype, pfn.proargtypes[0]));
540 -- If transfn is strict then either initval should be non-NULL, or
541 -- input type should match transtype so that the first non-null input
542 -- can be assigned as the state value.
544 SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
545 FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
546 WHERE a.aggfnoid = p.oid AND
547 a.aggtransfn = ptr.oid AND ptr.proisstrict AND
548 a.agginitval IS NULL AND
549 NOT binary_coercible(p.proargtypes[0], a.aggtranstype);
551 -- **************** pg_opclass ****************
553 -- Look for illegal values in pg_opclass fields
556 FROM pg_opclass as p1
557 WHERE p1.opcamid = 0 OR p1.opcintype = 0;
559 -- There should not be multiple entries in pg_opclass with opcdefault true
560 -- and the same opcamid/opcintype combination.
562 SELECT p1.oid, p2.oid
563 FROM pg_opclass AS p1, pg_opclass AS p2
564 WHERE p1.oid != p2.oid AND
565 p1.opcamid = p2.opcamid AND p1.opcintype = p2.opcintype AND
566 p1.opcdefault AND p2.opcdefault;
568 -- **************** pg_amop ****************
570 -- Look for illegal values in pg_amop fields
572 SELECT p1.amopclaid, p1.amopstrategy
574 WHERE p1.amopclaid = 0 OR p1.amopstrategy <= 0 OR p1.amopopr = 0;
576 -- Cross-check amopstrategy index against parent AM
578 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.amname
579 FROM pg_amop AS p1, pg_am AS p2, pg_opclass AS p3
580 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
581 p1.amopstrategy > p2.amstrategies;
583 -- Detect missing pg_amop entries: should have as many strategy operators
584 -- as AM expects for each opclass for the AM. When nondefault subtypes are
585 -- present, enforce condition separately for each subtype.
587 SELECT p1.oid, p1.amname, p2.oid, p2.opcname, p3.amopsubtype
588 FROM pg_am AS p1, pg_opclass AS p2, pg_amop AS p3
589 WHERE p2.opcamid = p1.oid AND p3.amopclaid = p2.oid AND
590 p1.amstrategies != (SELECT count(*) FROM pg_amop AS p4
591 WHERE p4.amopclaid = p2.oid AND
592 p4.amopsubtype = p3.amopsubtype);
594 -- Check that amopopr points at a reasonable-looking operator, ie a binary
595 -- operator yielding boolean.
597 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
598 FROM pg_amop AS p1, pg_operator AS p2
599 WHERE p1.amopopr = p2.oid AND
600 (p2.oprkind != 'b' OR p2.oprresult != 'bool'::regtype);
602 -- Make a list of all the distinct operator names being used in particular
603 -- strategy slots. This is a bit hokey, since the list might need to change
604 -- in future releases, but it's an effective way of spotting mistakes such as
605 -- swapping two operators within a class.
607 SELECT DISTINCT opcamid, amopstrategy, oprname
608 FROM pg_amop p1 LEFT JOIN pg_opclass p2 ON amopclaid = p2.oid
609 LEFT JOIN pg_operator p3 ON amopopr = p3.oid
612 -- Check that all operators linked to by opclass entries have selectivity
613 -- estimators. This is not absolutely required, but it seems a reasonable
614 -- thing to insist on for all standard datatypes.
616 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname
617 FROM pg_amop AS p1, pg_operator AS p2
618 WHERE p1.amopopr = p2.oid AND
619 (p2.oprrest = 0 OR p2.oprjoin = 0);
621 -- Check that operator input types match the opclass
622 -- For 7.5, we require that oprleft match opcintype (possibly by coercion).
623 -- When amopsubtype is zero (default), oprright must equal oprleft;
624 -- when amopsubtype is not zero, oprright must equal amopsubtype.
626 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
627 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
628 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
629 NOT binary_coercible(p3.opcintype, p2.oprleft);
631 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
632 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
633 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
634 p1.amopsubtype = 0 AND
635 p2.oprleft != p2.oprright;
637 SELECT p1.amopclaid, p1.amopopr, p2.oid, p2.oprname, p3.opcname
638 FROM pg_amop AS p1, pg_operator AS p2, pg_opclass AS p3
639 WHERE p1.amopopr = p2.oid AND p1.amopclaid = p3.oid AND
640 p1.amopsubtype != 0 AND
641 p1.amopsubtype != p2.oprright;
643 -- **************** pg_amproc ****************
645 -- Look for illegal values in pg_amproc fields
647 SELECT p1.amopclaid, p1.amprocnum
649 WHERE p1.amopclaid = 0 OR p1.amprocnum <= 0 OR p1.amproc = 0;
651 -- Cross-check amprocnum index against parent AM
653 SELECT p1.amopclaid, p1.amprocnum, p2.oid, p2.amname
654 FROM pg_amproc AS p1, pg_am AS p2, pg_opclass AS p3
655 WHERE p1.amopclaid = p3.oid AND p3.opcamid = p2.oid AND
656 p1.amprocnum > p2.amsupport;
658 -- Detect missing pg_amproc entries: should have as many support functions
659 -- as AM expects for each opclass for the AM. When nondefault subtypes are
660 -- present, enforce condition separately for each subtype.
662 SELECT p1.oid, p1.amname, p2.oid, p2.opcname, p3.amprocsubtype
663 FROM pg_am AS p1, pg_opclass AS p2, pg_amproc AS p3
664 WHERE p2.opcamid = p1.oid AND p3.amopclaid = p2.oid AND
665 p1.amsupport != (SELECT count(*) FROM pg_amproc AS p4
666 WHERE p4.amopclaid = p2.oid AND
667 p4.amprocsubtype = p3.amprocsubtype);
669 -- Unfortunately, we can't check the amproc link very well because the
670 -- signature of the function may be different for different support routines
671 -- or different base data types.
672 -- We can check that all the referenced instances of the same support
673 -- routine number take the same number of parameters, but that's about it
674 -- for a general check...
676 SELECT p1.amopclaid, p1.amprocnum,
679 p4.amopclaid, p4.amprocnum,
682 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3,
683 pg_amproc AS p4, pg_proc AS p5, pg_opclass AS p6
684 WHERE p1.amopclaid = p3.oid AND p4.amopclaid = p6.oid AND
685 p3.opcamid = p6.opcamid AND p1.amprocnum = p4.amprocnum AND
686 p1.amproc = p2.oid AND p4.amproc = p5.oid AND
687 (p2.proretset OR p5.proretset OR p2.pronargs != p5.pronargs);
689 -- For btree, though, we can do better since we know the support routines
690 -- must be of the form cmp(input, input) returns int4 in the default case
691 -- (subtype = 0), and cmp(input, subtype) returns int4 when subtype != 0.
693 SELECT p1.amopclaid, p1.amprocnum,
696 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
697 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'btree')
698 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
699 amprocsubtype = 0 AND
705 OR NOT binary_coercible(opcintype, proargtypes[0])
706 OR proargtypes[0] != proargtypes[1]);
708 SELECT p1.amopclaid, p1.amprocnum,
711 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
712 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'btree')
713 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
714 amprocsubtype != 0 AND
720 OR NOT binary_coercible(opcintype, proargtypes[0])
721 OR proargtypes[1] != amprocsubtype);
723 -- For hash we can also do a little better: the support routines must be
724 -- of the form hash(something) returns int4. Ideally we'd check that the
725 -- opcintype is binary-coercible to the function's input, but there are
726 -- enough cases where that fails that I'll just leave out the check for now.
728 SELECT p1.amopclaid, p1.amprocnum,
731 FROM pg_amproc AS p1, pg_proc AS p2, pg_opclass AS p3
732 WHERE p3.opcamid = (SELECT oid FROM pg_am WHERE amname = 'hash')
733 AND p1.amopclaid = p3.oid AND p1.amproc = p2.oid AND
739 -- OR NOT physically_coercible(opcintype, proargtypes[0])