1998-10-29 05:25:23 +01:00
|
|
|
--
|
2000-01-05 07:07:58 +01:00
|
|
|
-- OPR_SANITY
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Sanity checks for common errors in making operator/procedure system tables:
|
2006-12-23 01:43:13 +01:00
|
|
|
-- pg_operator, pg_proc, pg_cast, pg_aggregate, pg_am,
|
|
|
|
-- pg_amop, pg_amproc, pg_opclass, pg_opfamily.
|
1999-03-28 04:07:58 +02:00
|
|
|
--
|
1998-10-29 05:25:23 +01:00
|
|
|
-- None of the SELECTs here should ever find any matching entries,
|
|
|
|
-- so the expected output is easy to maintain ;-).
|
1999-03-28 04:07:58 +02:00
|
|
|
-- A test failure indicates someone messed up an entry in the system tables.
|
|
|
|
--
|
|
|
|
-- NB: we assume the oidjoins test will have caught any dangling links,
|
|
|
|
-- that is OID or REGPROC fields that are not zero and do not match some
|
|
|
|
-- row in the linked-to table. However, if we want to enforce that a link
|
|
|
|
-- field can't be 0, we have to check it here.
|
1998-10-29 05:25:23 +01:00
|
|
|
--
|
|
|
|
-- NB: run this test earlier than the create_operator test, because
|
|
|
|
-- that test creates some bogus operators...
|
|
|
|
|
2003-05-26 02:11:29 +02:00
|
|
|
|
|
|
|
-- Helper functions to deal with cases where binary-coercible matches are
|
|
|
|
-- allowed.
|
|
|
|
|
|
|
|
-- This should match IsBinaryCoercible() in parse_coerce.c.
|
2006-09-10 02:29:35 +02:00
|
|
|
create function binary_coercible(oid, oid) returns bool as $$
|
|
|
|
SELECT ($1 = $2) OR
|
|
|
|
EXISTS(select 1 from pg_catalog.pg_cast where
|
2003-05-26 02:11:29 +02:00
|
|
|
castsource = $1 and casttarget = $2 and
|
2008-10-31 09:39:22 +01:00
|
|
|
castmethod = 'b' and castcontext = 'i') OR
|
2006-09-10 02:29:35 +02:00
|
|
|
($2 = 'pg_catalog.anyarray'::pg_catalog.regtype AND
|
|
|
|
EXISTS(select 1 from pg_catalog.pg_type where
|
|
|
|
oid = $1 and typelem != 0 and typlen = -1))
|
|
|
|
$$ language sql strict stable;
|
2003-05-26 02:11:29 +02:00
|
|
|
|
|
|
|
-- This one ignores castcontext, so it considers only physical equivalence
|
|
|
|
-- and not whether the coercion can be invoked implicitly.
|
2006-09-10 02:29:35 +02:00
|
|
|
create function physically_coercible(oid, oid) returns bool as $$
|
|
|
|
SELECT ($1 = $2) OR
|
|
|
|
EXISTS(select 1 from pg_catalog.pg_cast where
|
2003-05-26 02:11:29 +02:00
|
|
|
castsource = $1 and casttarget = $2 and
|
2008-10-31 09:39:22 +01:00
|
|
|
castmethod = 'b') OR
|
2006-09-10 02:29:35 +02:00
|
|
|
($2 = 'pg_catalog.anyarray'::pg_catalog.regtype AND
|
|
|
|
EXISTS(select 1 from pg_catalog.pg_type where
|
|
|
|
oid = $1 and typelem != 0 and typlen = -1))
|
|
|
|
$$ language sql strict stable;
|
2003-05-26 02:11:29 +02:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- **************** pg_proc ****************
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Look for illegal values in pg_proc fields.
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
2002-08-22 02:01:51 +02:00
|
|
|
WHERE p1.prolang = 0 OR p1.prorettype = 0 OR
|
2005-03-29 02:17:27 +02:00
|
|
|
p1.pronargs < 0 OR
|
2008-12-18 19:20:35 +01:00
|
|
|
p1.pronargdefaults < 0 OR
|
|
|
|
p1.pronargdefaults > p1.pronargs OR
|
2005-03-29 02:17:27 +02:00
|
|
|
array_lower(p1.proargtypes, 1) != 0 OR
|
|
|
|
array_upper(p1.proargtypes, 1) != p1.pronargs-1 OR
|
2007-01-22 02:35:23 +01:00
|
|
|
0::oid = ANY (p1.proargtypes) OR
|
|
|
|
procost <= 0 OR
|
|
|
|
CASE WHEN proretset THEN prorows <= 0 ELSE prorows != 0 END;
|
1998-10-29 05:25:23 +01:00
|
|
|
|
2008-07-16 18:55:24 +02:00
|
|
|
-- prosrc should never be null or empty
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE prosrc IS NULL OR prosrc = '' OR prosrc = '-';
|
|
|
|
|
2008-12-19 19:25:20 +01:00
|
|
|
-- proiswindow shouldn't be set together with proisagg or proretset
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc AS p1
|
|
|
|
WHERE proiswindow AND (proisagg OR proretset);
|
|
|
|
|
2008-12-04 18:51:28 +01:00
|
|
|
-- pronargdefaults should be 0 iff proargdefaults is null
|
2008-12-18 19:20:35 +01:00
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc AS p1
|
|
|
|
WHERE (pronargdefaults <> 0) != (proargdefaults IS NOT NULL);
|
2008-12-04 18:51:28 +01:00
|
|
|
|
2008-07-16 18:55:24 +02:00
|
|
|
-- probin should be non-empty for C functions, null everywhere else
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE prolang = 13 AND (probin IS NULL OR probin = '' OR probin = '-');
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE prolang != 13 AND probin IS NOT NULL;
|
|
|
|
|
1999-03-29 03:30:45 +02:00
|
|
|
-- Look for conflicting proc definitions (same names and input datatypes).
|
2000-06-19 05:55:01 +02:00
|
|
|
-- (This test should be dead code now that we have the unique index
|
2006-07-27 21:52:07 +02:00
|
|
|
-- pg_proc_proname_args_nsp_index, but I'll leave it in anyway.)
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname, p2.oid, p2.proname
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
|
|
|
p1.proname = p2.proname AND
|
|
|
|
p1.pronargs = p2.pronargs AND
|
|
|
|
p1.proargtypes = p2.proargtypes;
|
|
|
|
|
2002-04-11 22:00:18 +02:00
|
|
|
-- Considering only built-in procs (prolang = 12), look for multiple uses
|
1999-03-29 03:30:45 +02:00
|
|
|
-- of the same internal function (ie, matching prosrc fields). It's OK to
|
|
|
|
-- have several entries with different pronames for the same internal function,
|
|
|
|
-- but conflicts in the number of arguments and other critical items should
|
2006-07-28 20:33:04 +02:00
|
|
|
-- be complained of. (We don't check data types here; see next query.)
|
|
|
|
-- Note: ignore aggregate functions here, since they all point to the same
|
|
|
|
-- dummy built-in function.
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname, p2.oid, p2.proname
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
2006-07-27 21:52:07 +02:00
|
|
|
WHERE p1.oid < p2.oid AND
|
2006-12-24 01:29:20 +01:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
2006-07-28 20:33:04 +02:00
|
|
|
(p1.proisagg = false OR p2.proisagg = false) AND
|
2000-06-19 05:55:01 +02:00
|
|
|
(p1.prolang != p2.prolang OR
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.proisagg != p2.proisagg OR
|
2002-05-18 15:48:01 +02:00
|
|
|
p1.prosecdef != p2.prosecdef OR
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.proisstrict != p2.proisstrict OR
|
|
|
|
p1.proretset != p2.proretset OR
|
2002-04-05 02:31:36 +02:00
|
|
|
p1.provolatile != p2.provolatile OR
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.pronargs != p2.pronargs);
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
-- Look for uses of different type OIDs in the argument/result type fields
|
|
|
|
-- for different aliases of the same built-in function.
|
2003-04-09 01:20:04 +02:00
|
|
|
-- This indicates that the types are being presumed to be binary-equivalent,
|
|
|
|
-- or that the built-in function is prepared to deal with different types.
|
1999-03-29 03:30:45 +02:00
|
|
|
-- That's not wrong, necessarily, but we make lists of all the types being
|
|
|
|
-- so treated. Note that the expected output of this part of the test will
|
2003-04-09 01:20:04 +02:00
|
|
|
-- need to be modified whenever new pairs of types are made binary-equivalent,
|
|
|
|
-- or when new polymorphic built-in functions are added!
|
2002-04-11 22:00:18 +02:00
|
|
|
-- Note: ignore aggregate functions here, since they all point to the same
|
2011-11-21 22:19:53 +01:00
|
|
|
-- dummy built-in function. Likewise, ignore range constructor functions.
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.prorettype, p2.prorettype
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2011-11-21 22:19:53 +01:00
|
|
|
p1.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
p2.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
(p1.prorettype < p2.prorettype)
|
2008-08-05 04:43:18 +02:00
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2011-11-21 22:19:53 +01:00
|
|
|
p1.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
p2.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
(p1.proargtypes[0] < p2.proargtypes[0])
|
2008-08-05 04:43:18 +02:00
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2011-11-21 22:19:53 +01:00
|
|
|
p1.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
p2.prosrc NOT LIKE E'range\\_constructor_' AND
|
|
|
|
(p1.proargtypes[1] < p2.proargtypes[1])
|
2008-08-05 04:43:18 +02:00
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[2] < p2.proargtypes[2])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[3] < p2.proargtypes[3])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[4] < p2.proargtypes[4])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[5] < p2.proargtypes[5])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[6] < p2.proargtypes[6])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
|
|
|
SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7]
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2000-06-05 09:29:25 +02:00
|
|
|
p1.prosrc = p2.prosrc AND
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.prolang = 12 AND p2.prolang = 12 AND
|
|
|
|
NOT p1.proisagg AND NOT p2.proisagg AND
|
2008-08-05 04:43:18 +02:00
|
|
|
(p1.proargtypes[7] < p2.proargtypes[7])
|
|
|
|
ORDER BY 1, 2;
|
1999-03-29 03:30:45 +02:00
|
|
|
|
2002-08-23 18:41:38 +02:00
|
|
|
-- Look for functions that return type "internal" and do not have any
|
|
|
|
-- "internal" argument. Such a function would be a security hole since
|
|
|
|
-- it might be used to call an internal function from an SQL command.
|
|
|
|
-- As of 7.3 this query should find only internal_in.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE p1.prorettype = 'internal'::regtype AND NOT
|
2005-03-29 02:17:27 +02:00
|
|
|
'internal'::regtype = ANY (p1.proargtypes);
|
2002-08-23 18:41:38 +02:00
|
|
|
|
2009-11-29 19:53:54 +01:00
|
|
|
-- Check for length inconsistencies between the various argument-info arrays.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proallargtypes IS NOT NULL AND
|
|
|
|
array_length(proallargtypes,1) < array_length(proargtypes,1);
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proargmodes IS NOT NULL AND
|
|
|
|
array_length(proargmodes,1) < array_length(proargtypes,1);
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proargnames IS NOT NULL AND
|
|
|
|
array_length(proargnames,1) < array_length(proargtypes,1);
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proallargtypes IS NOT NULL AND proargmodes IS NOT NULL AND
|
|
|
|
array_length(proallargtypes,1) <> array_length(proargmodes,1);
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proallargtypes IS NOT NULL AND proargnames IS NOT NULL AND
|
|
|
|
array_length(proallargtypes,1) <> array_length(proargnames,1);
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1
|
|
|
|
WHERE proargmodes IS NOT NULL AND proargnames IS NOT NULL AND
|
|
|
|
array_length(proargmodes,1) <> array_length(proargnames,1);
|
|
|
|
|
2011-03-03 07:33:19 +01:00
|
|
|
-- Insist that all built-in pg_proc entries have descriptions
|
|
|
|
SELECT p1.oid, p1.proname
|
|
|
|
FROM pg_proc as p1 LEFT JOIN pg_description as d
|
|
|
|
ON p1.tableoid = d.classoid and p1.oid = d.objoid and d.objsubid = 0
|
|
|
|
WHERE d.classoid IS NULL AND p1.oid <= 9999;
|
|
|
|
|
2002-08-23 18:41:38 +02:00
|
|
|
|
2002-07-19 01:11:32 +02:00
|
|
|
-- **************** pg_cast ****************
|
2002-04-11 22:00:18 +02:00
|
|
|
|
2004-06-16 03:27:00 +02:00
|
|
|
-- Catch bogus values in pg_cast columns (other than cases detected by
|
|
|
|
-- oidjoins test).
|
2002-07-19 01:11:32 +02:00
|
|
|
|
|
|
|
SELECT *
|
|
|
|
FROM pg_cast c
|
2008-10-31 09:39:22 +01:00
|
|
|
WHERE castsource = 0 OR casttarget = 0 OR castcontext NOT IN ('e', 'a', 'i')
|
|
|
|
OR castmethod NOT IN ('f', 'b' ,'i');
|
|
|
|
|
|
|
|
-- Check that castfunc is nonzero only for cast methods that need a function,
|
|
|
|
-- and zero otherwise
|
|
|
|
|
|
|
|
SELECT *
|
|
|
|
FROM pg_cast c
|
|
|
|
WHERE (castmethod = 'f' AND castfunc = 0)
|
|
|
|
OR (castmethod IN ('b', 'i') AND castfunc <> 0);
|
2004-06-16 03:27:00 +02:00
|
|
|
|
|
|
|
-- Look for casts to/from the same type that aren't length coercion functions.
|
|
|
|
-- (We assume they are length coercions if they take multiple arguments.)
|
|
|
|
-- Such entries are not necessarily harmful, but they are useless.
|
|
|
|
|
|
|
|
SELECT *
|
|
|
|
FROM pg_cast c
|
|
|
|
WHERE castsource = casttarget AND castfunc = 0;
|
|
|
|
|
|
|
|
SELECT c.*
|
|
|
|
FROM pg_cast c, pg_proc p
|
|
|
|
WHERE c.castfunc = p.oid AND p.pronargs < 2 AND castsource = casttarget;
|
2002-07-19 01:11:32 +02:00
|
|
|
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
-- Look for cast functions that don't have the right signature. The
|
|
|
|
-- argument and result types in pg_proc must be the same as, or binary
|
|
|
|
-- compatible with, what it says in pg_cast.
|
2004-03-15 02:13:41 +01:00
|
|
|
-- As a special case, we allow casts from CHAR(n) that use functions
|
|
|
|
-- declared to take TEXT. This does not pass the binary-coercibility test
|
|
|
|
-- because CHAR(n)-to-TEXT normally invokes rtrim(). However, the results
|
|
|
|
-- are the same, so long as the function is one that ignores trailing blanks.
|
2002-07-19 01:11:32 +02:00
|
|
|
|
|
|
|
SELECT c.*
|
|
|
|
FROM pg_cast c, pg_proc p
|
|
|
|
WHERE c.castfunc = p.oid AND
|
2004-06-16 03:27:00 +02:00
|
|
|
(p.pronargs < 1 OR p.pronargs > 3
|
2004-03-15 02:13:41 +01:00
|
|
|
OR NOT (binary_coercible(c.castsource, p.proargtypes[0])
|
|
|
|
OR (c.castsource = 'character'::regtype AND
|
|
|
|
p.proargtypes[0] = 'text'::regtype))
|
2003-05-26 02:11:29 +02:00
|
|
|
OR NOT binary_coercible(p.prorettype, c.casttarget));
|
2002-07-19 01:11:32 +02:00
|
|
|
|
2004-06-16 03:27:00 +02:00
|
|
|
SELECT c.*
|
|
|
|
FROM pg_cast c, pg_proc p
|
|
|
|
WHERE c.castfunc = p.oid AND
|
|
|
|
((p.pronargs > 1 AND p.proargtypes[1] != 'int4'::regtype) OR
|
|
|
|
(p.pronargs > 2 AND p.proargtypes[2] != 'bool'::regtype));
|
|
|
|
|
2002-07-19 01:11:32 +02:00
|
|
|
-- Look for binary compatible casts that do not have the reverse
|
|
|
|
-- direction registered as well, or where the reverse direction is not
|
2003-05-26 02:11:29 +02:00
|
|
|
-- also binary compatible. This is legal, but usually not intended.
|
|
|
|
|
|
|
|
-- As of 7.4, this finds the casts from text and varchar to bpchar, because
|
|
|
|
-- those are binary-compatible while the reverse way goes through rtrim().
|
2002-07-19 01:11:32 +02:00
|
|
|
|
2006-01-26 03:35:51 +01:00
|
|
|
-- As of 8.2, this finds the cast from cidr to inet, because that is a
|
|
|
|
-- trivial binary coercion while the other way goes through inet_to_cidr().
|
|
|
|
|
2007-11-27 13:21:05 +01:00
|
|
|
-- As of 8.3, this finds the casts from xml to text, varchar, and bpchar,
|
|
|
|
-- because those are binary-compatible while the reverse goes through
|
|
|
|
-- texttoxml(), which does an XML syntax check.
|
|
|
|
|
2010-09-03 03:34:55 +02:00
|
|
|
-- As of 9.1, this finds the cast from pg_node_tree to text, which we
|
|
|
|
-- intentionally do not provide a reverse pathway for.
|
|
|
|
|
|
|
|
SELECT castsource::regtype, casttarget::regtype, castfunc, castcontext
|
2002-07-19 01:11:32 +02:00
|
|
|
FROM pg_cast c
|
2008-10-31 09:39:22 +01:00
|
|
|
WHERE c.castmethod = 'b' AND
|
2002-08-22 02:01:51 +02:00
|
|
|
NOT EXISTS (SELECT 1 FROM pg_cast k
|
2008-10-31 09:39:22 +01:00
|
|
|
WHERE k.castmethod = 'b' AND
|
2002-07-19 01:11:32 +02:00
|
|
|
k.castsource = c.casttarget AND
|
|
|
|
k.casttarget = c.castsource);
|
2002-04-11 22:00:18 +02:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- **************** pg_operator ****************
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Look for illegal values in pg_operator fields.
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
SELECT p1.oid, p1.oprname
|
|
|
|
FROM pg_operator as p1
|
|
|
|
WHERE (p1.oprkind != 'b' AND p1.oprkind != 'l' AND p1.oprkind != 'r') OR
|
|
|
|
p1.oprresult = 0 OR p1.oprcode = 0;
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Look for missing or unwanted operand types
|
1998-10-29 05:25:23 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
SELECT p1.oid, p1.oprname
|
|
|
|
FROM pg_operator as p1
|
|
|
|
WHERE (p1.oprleft = 0 and p1.oprkind != 'l') OR
|
|
|
|
(p1.oprleft != 0 and p1.oprkind = 'l') OR
|
|
|
|
(p1.oprright = 0 and p1.oprkind != 'r') OR
|
|
|
|
(p1.oprright != 0 and p1.oprkind = 'r');
|
1998-10-29 05:25:23 +01:00
|
|
|
|
|
|
|
-- Look for conflicting operator definitions (same names and input datatypes).
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
|
|
|
|
FROM pg_operator AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
|
|
|
p1.oprname = p2.oprname AND
|
|
|
|
p1.oprkind = p2.oprkind AND
|
|
|
|
p1.oprleft = p2.oprleft AND
|
|
|
|
p1.oprright = p2.oprright;
|
|
|
|
|
|
|
|
-- Look for commutative operators that don't commute.
|
|
|
|
-- DEFINITIONAL NOTE: If A.oprcom = B, then x A y has the same result as y B x.
|
|
|
|
-- We expect that B will always say that B.oprcom = A as well; that's not
|
|
|
|
-- inherently essential, but it would be inefficient not to mark it so.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
|
|
|
|
FROM pg_operator AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.oprcom = p2.oid AND
|
|
|
|
(p1.oprkind != 'b' OR
|
|
|
|
p1.oprleft != p2.oprright OR
|
|
|
|
p1.oprright != p2.oprleft OR
|
|
|
|
p1.oprresult != p2.oprresult OR
|
|
|
|
p1.oid != p2.oprcom);
|
|
|
|
|
|
|
|
-- Look for negatory operators that don't agree.
|
|
|
|
-- DEFINITIONAL NOTE: If A.oprnegate = B, then both A and B must yield
|
|
|
|
-- boolean results, and (x A y) == ! (x B y), or the equivalent for
|
|
|
|
-- single-operand operators.
|
|
|
|
-- We expect that B will always say that B.oprnegate = A as well; that's not
|
|
|
|
-- inherently essential, but it would be inefficient not to mark it so.
|
2002-04-11 22:00:18 +02:00
|
|
|
-- Also, A and B had better not be the same operator.
|
1998-10-29 05:25:23 +01:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprcode, p2.oid, p2.oprcode
|
|
|
|
FROM pg_operator AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.oprnegate = p2.oid AND
|
|
|
|
(p1.oprkind != p2.oprkind OR
|
|
|
|
p1.oprleft != p2.oprleft OR
|
|
|
|
p1.oprright != p2.oprright OR
|
2002-04-25 04:56:56 +02:00
|
|
|
p1.oprresult != 'bool'::regtype OR
|
|
|
|
p2.oprresult != 'bool'::regtype OR
|
2002-04-11 22:00:18 +02:00
|
|
|
p1.oid != p2.oprnegate OR
|
|
|
|
p1.oid = p2.oid);
|
1998-10-29 05:25:23 +01:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- A mergejoinable or hashjoinable operator must be binary, must return
|
|
|
|
-- boolean, and must have a commutator (itself, unless it's a cross-type
|
|
|
|
-- operator).
|
1999-03-01 01:10:44 +01:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
SELECT p1.oid, p1.oprname FROM pg_operator AS p1
|
2006-12-23 01:43:13 +01:00
|
|
|
WHERE (p1.oprcanmerge OR p1.oprcanhash) AND NOT
|
|
|
|
(p1.oprkind = 'b' AND p1.oprresult = 'bool'::regtype AND p1.oprcom != 0);
|
2000-07-28 07:07:49 +02:00
|
|
|
|
2007-02-06 04:52:59 +01:00
|
|
|
-- What's more, the commutator had better be mergejoinable/hashjoinable too.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.oprname
|
|
|
|
FROM pg_operator AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.oprcom = p2.oid AND
|
|
|
|
(p1.oprcanmerge != p2.oprcanmerge OR
|
|
|
|
p1.oprcanhash != p2.oprcanhash);
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- Mergejoinable operators should appear as equality members of btree index
|
|
|
|
-- opfamilies.
|
2003-05-26 02:11:29 +02:00
|
|
|
|
1999-04-08 01:33:33 +02:00
|
|
|
SELECT p1.oid, p1.oprname
|
|
|
|
FROM pg_operator AS p1
|
2006-12-23 01:43:13 +01:00
|
|
|
WHERE p1.oprcanmerge AND NOT EXISTS
|
|
|
|
(SELECT 1 FROM pg_amop
|
|
|
|
WHERE amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree') AND
|
|
|
|
amopopr = p1.oid AND amopstrategy = 3);
|
1999-04-08 01:33:33 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- And the converse.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p.amopfamily
|
|
|
|
FROM pg_operator AS p1, pg_amop p
|
|
|
|
WHERE amopopr = p1.oid
|
|
|
|
AND amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree')
|
|
|
|
AND amopstrategy = 3
|
|
|
|
AND NOT p1.oprcanmerge;
|
|
|
|
|
|
|
|
-- Hashable operators should appear as members of hash index opfamilies.
|
2003-06-23 00:04:55 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname
|
|
|
|
FROM pg_operator AS p1
|
|
|
|
WHERE p1.oprcanhash AND NOT EXISTS
|
2006-12-23 01:43:13 +01:00
|
|
|
(SELECT 1 FROM pg_amop
|
|
|
|
WHERE amopmethod = (SELECT oid FROM pg_am WHERE amname = 'hash') AND
|
|
|
|
amopopr = p1.oid AND amopstrategy = 1);
|
2003-06-23 00:04:55 +02:00
|
|
|
|
2004-06-13 23:57:28 +02:00
|
|
|
-- And the converse.
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.oid, p1.oprname, p.amopfamily
|
|
|
|
FROM pg_operator AS p1, pg_amop p
|
|
|
|
WHERE amopopr = p1.oid
|
|
|
|
AND amopmethod = (SELECT oid FROM pg_am WHERE amname = 'hash')
|
2004-06-13 23:57:28 +02:00
|
|
|
AND NOT p1.oprcanhash;
|
2003-06-23 00:04:55 +02:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Check that each operator defined in pg_operator matches its oprcode entry
|
|
|
|
-- in pg_proc. Easiest to do this separately for each oprkind.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprcode = p2.oid AND
|
|
|
|
p1.oprkind = 'b' AND
|
|
|
|
(p2.pronargs != 2
|
2003-05-26 02:11:29 +02:00
|
|
|
OR NOT binary_coercible(p2.prorettype, p1.oprresult)
|
|
|
|
OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
|
|
|
|
OR NOT binary_coercible(p1.oprright, p2.proargtypes[1]));
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprcode = p2.oid AND
|
|
|
|
p1.oprkind = 'l' AND
|
2003-05-26 02:11:29 +02:00
|
|
|
(p2.pronargs != 1
|
|
|
|
OR NOT binary_coercible(p2.prorettype, p1.oprresult)
|
|
|
|
OR NOT binary_coercible(p1.oprright, p2.proargtypes[0])
|
|
|
|
OR p1.oprleft != 0);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprcode = p2.oid AND
|
|
|
|
p1.oprkind = 'r' AND
|
2003-05-26 02:11:29 +02:00
|
|
|
(p2.pronargs != 1
|
|
|
|
OR NOT binary_coercible(p2.prorettype, p1.oprresult)
|
|
|
|
OR NOT binary_coercible(p1.oprleft, p2.proargtypes[0])
|
|
|
|
OR p1.oprright != 0);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2003-01-15 20:35:48 +01:00
|
|
|
-- If the operator is mergejoinable or hashjoinable, its underlying function
|
|
|
|
-- should not be volatile.
|
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprcode = p2.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
(p1.oprcanmerge OR p1.oprcanhash) AND
|
2003-01-15 20:35:48 +01:00
|
|
|
p2.provolatile = 'v';
|
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- If oprrest is set, the operator must return boolean,
|
|
|
|
-- and it must link to a proc with the right signature
|
|
|
|
-- to be a restriction selectivity estimator.
|
2002-08-22 02:01:51 +02:00
|
|
|
-- The proc signature we want is: float8 proc(internal, oid, internal, int4)
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprrest = p2.oid AND
|
2002-04-25 04:56:56 +02:00
|
|
|
(p1.oprresult != 'bool'::regtype OR
|
|
|
|
p2.prorettype != 'float8'::regtype OR p2.proretset OR
|
2001-05-20 22:28:20 +02:00
|
|
|
p2.pronargs != 4 OR
|
2002-08-22 02:01:51 +02:00
|
|
|
p2.proargtypes[0] != 'internal'::regtype OR
|
|
|
|
p2.proargtypes[1] != 'oid'::regtype OR
|
|
|
|
p2.proargtypes[2] != 'internal'::regtype OR
|
|
|
|
p2.proargtypes[3] != 'int4'::regtype);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
-- If oprjoin is set, the operator must be a binary boolean op,
|
|
|
|
-- and it must link to a proc with the right signature
|
|
|
|
-- to be a join selectivity estimator.
|
2008-08-16 02:01:38 +02:00
|
|
|
-- The proc signature we want is: float8 proc(internal, oid, internal, int2, internal)
|
|
|
|
-- (Note: the old signature with only 4 args is still allowed, but no core
|
|
|
|
-- estimator should be using it.)
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p1.oprname, p2.oid, p2.proname
|
|
|
|
FROM pg_operator AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oprjoin = p2.oid AND
|
2002-04-25 04:56:56 +02:00
|
|
|
(p1.oprkind != 'b' OR p1.oprresult != 'bool'::regtype OR
|
|
|
|
p2.prorettype != 'float8'::regtype OR p2.proretset OR
|
2008-08-16 02:01:38 +02:00
|
|
|
p2.pronargs != 5 OR
|
2002-08-22 02:01:51 +02:00
|
|
|
p2.proargtypes[0] != 'internal'::regtype OR
|
|
|
|
p2.proargtypes[1] != 'oid'::regtype OR
|
2003-01-28 23:13:41 +01:00
|
|
|
p2.proargtypes[2] != 'internal'::regtype OR
|
2008-08-16 02:01:38 +02:00
|
|
|
p2.proargtypes[3] != 'int2'::regtype OR
|
|
|
|
p2.proargtypes[4] != 'internal'::regtype);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2011-03-03 07:33:19 +01:00
|
|
|
-- Insist that all built-in pg_operator entries have descriptions
|
|
|
|
SELECT p1.oid, p1.oprname
|
|
|
|
FROM pg_operator as p1 LEFT JOIN pg_description as d
|
|
|
|
ON p1.tableoid = d.classoid and p1.oid = d.objoid and d.objsubid = 0
|
|
|
|
WHERE d.classoid IS NULL AND p1.oid <= 9999;
|
|
|
|
|
|
|
|
-- Check that operators' underlying functions have suitable comments,
|
2011-03-03 21:55:47 +01:00
|
|
|
-- namely 'implementation of XXX operator'. In some cases involving legacy
|
|
|
|
-- names for operators, there are multiple operators referencing the same
|
|
|
|
-- pg_proc entry, so ignore operators whose comments say they are deprecated.
|
|
|
|
-- We also have a few functions that are both operator support and meant to
|
|
|
|
-- be called directly; those should have comments matching their operator.
|
2011-03-03 07:33:19 +01:00
|
|
|
WITH funcdescs AS (
|
2011-03-03 21:55:47 +01:00
|
|
|
SELECT p.oid as p_oid, proname, o.oid as o_oid,
|
2011-03-03 07:33:19 +01:00
|
|
|
obj_description(p.oid, 'pg_proc') as prodesc,
|
|
|
|
'implementation of ' || oprname || ' operator' as expecteddesc,
|
|
|
|
obj_description(o.oid, 'pg_operator') as oprdesc
|
|
|
|
FROM pg_proc p JOIN pg_operator o ON oprcode = p.oid
|
|
|
|
WHERE o.oid <= 9999
|
|
|
|
)
|
2011-03-03 21:55:47 +01:00
|
|
|
SELECT * FROM funcdescs
|
2011-03-03 07:33:19 +01:00
|
|
|
WHERE prodesc IS DISTINCT FROM expecteddesc
|
2011-03-03 21:55:47 +01:00
|
|
|
AND oprdesc NOT LIKE 'deprecated%'
|
|
|
|
AND prodesc IS DISTINCT FROM oprdesc;
|
2011-03-03 07:33:19 +01:00
|
|
|
|
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- **************** pg_aggregate ****************
|
|
|
|
|
|
|
|
-- Look for illegal values in pg_aggregate fields.
|
|
|
|
|
2002-04-11 22:00:18 +02:00
|
|
|
SELECT ctid, aggfnoid::oid
|
1999-03-28 04:07:58 +02:00
|
|
|
FROM pg_aggregate as p1
|
2002-04-11 22:00:18 +02:00
|
|
|
WHERE aggfnoid = 0 OR aggtransfn = 0 OR aggtranstype = 0;
|
|
|
|
|
|
|
|
-- Make sure the matching pg_proc entry is sensible, too.
|
|
|
|
|
|
|
|
SELECT a.aggfnoid::oid, p.proname
|
|
|
|
FROM pg_aggregate as a, pg_proc as p
|
|
|
|
WHERE a.aggfnoid = p.oid AND
|
2006-07-27 21:52:07 +02:00
|
|
|
(NOT p.proisagg OR p.proretset);
|
2002-04-11 22:00:18 +02:00
|
|
|
|
|
|
|
-- Make sure there are no proisagg pg_proc entries without matches.
|
|
|
|
|
|
|
|
SELECT oid, proname
|
|
|
|
FROM pg_proc as p
|
|
|
|
WHERE p.proisagg AND
|
|
|
|
NOT EXISTS (SELECT 1 FROM pg_aggregate a WHERE a.aggfnoid = p.oid);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2000-07-17 05:05:41 +02:00
|
|
|
-- If there is no finalfn then the output type must be the transtype.
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2002-04-11 22:00:18 +02:00
|
|
|
SELECT a.aggfnoid::oid, p.proname
|
|
|
|
FROM pg_aggregate as a, pg_proc as p
|
|
|
|
WHERE a.aggfnoid = p.oid AND
|
|
|
|
a.aggfinalfn = 0 AND p.prorettype != a.aggtranstype;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2000-07-17 05:05:41 +02:00
|
|
|
-- Cross-check transfn against its entry in pg_proc.
|
2003-05-26 02:11:29 +02:00
|
|
|
-- NOTE: use physically_coercible here, not binary_coercible, because
|
|
|
|
-- max and min on abstime are implemented using int4larger/int4smaller.
|
|
|
|
SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
|
|
|
|
FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
|
2002-04-11 22:00:18 +02:00
|
|
|
WHERE a.aggfnoid = p.oid AND
|
2003-05-26 02:11:29 +02:00
|
|
|
a.aggtransfn = ptr.oid AND
|
|
|
|
(ptr.proretset
|
2006-07-27 21:52:07 +02:00
|
|
|
OR NOT (ptr.pronargs = p.pronargs + 1)
|
2003-05-26 02:11:29 +02:00
|
|
|
OR NOT physically_coercible(ptr.prorettype, a.aggtranstype)
|
|
|
|
OR NOT physically_coercible(a.aggtranstype, ptr.proargtypes[0])
|
2006-07-27 21:52:07 +02:00
|
|
|
OR (p.pronargs > 0 AND
|
|
|
|
NOT physically_coercible(p.proargtypes[0], ptr.proargtypes[1]))
|
|
|
|
OR (p.pronargs > 1 AND
|
|
|
|
NOT physically_coercible(p.proargtypes[1], ptr.proargtypes[2]))
|
|
|
|
OR (p.pronargs > 2 AND
|
|
|
|
NOT physically_coercible(p.proargtypes[2], ptr.proargtypes[3]))
|
|
|
|
-- we could carry the check further, but that's enough for now
|
|
|
|
);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
-- Cross-check finalfn (if present) against its entry in pg_proc.
|
|
|
|
|
2003-05-26 02:11:29 +02:00
|
|
|
SELECT a.aggfnoid::oid, p.proname, pfn.oid, pfn.proname
|
|
|
|
FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS pfn
|
2002-04-11 22:00:18 +02:00
|
|
|
WHERE a.aggfnoid = p.oid AND
|
2003-05-26 02:11:29 +02:00
|
|
|
a.aggfinalfn = pfn.oid AND
|
|
|
|
(pfn.proretset
|
|
|
|
OR NOT binary_coercible(pfn.prorettype, p.prorettype)
|
|
|
|
OR pfn.pronargs != 1
|
|
|
|
OR NOT binary_coercible(a.aggtranstype, pfn.proargtypes[0]));
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2000-07-18 07:02:19 +02:00
|
|
|
-- If transfn is strict then either initval should be non-NULL, or
|
2003-05-26 02:11:29 +02:00
|
|
|
-- input type should match transtype so that the first non-null input
|
2000-07-18 07:02:19 +02:00
|
|
|
-- can be assigned as the state value.
|
|
|
|
|
2003-05-26 02:11:29 +02:00
|
|
|
SELECT a.aggfnoid::oid, p.proname, ptr.oid, ptr.proname
|
|
|
|
FROM pg_aggregate AS a, pg_proc AS p, pg_proc AS ptr
|
2002-04-11 22:00:18 +02:00
|
|
|
WHERE a.aggfnoid = p.oid AND
|
2003-05-26 02:11:29 +02:00
|
|
|
a.aggtransfn = ptr.oid AND ptr.proisstrict AND
|
|
|
|
a.agginitval IS NULL AND
|
|
|
|
NOT binary_coercible(p.proargtypes[0], a.aggtranstype);
|
2000-07-18 07:02:19 +02:00
|
|
|
|
2005-04-12 06:26:34 +02:00
|
|
|
-- Cross-check aggsortop (if present) against pg_operator.
|
|
|
|
-- We expect to find only "<" for "min" and ">" for "max".
|
|
|
|
|
|
|
|
SELECT DISTINCT proname, oprname
|
|
|
|
FROM pg_operator AS o, pg_aggregate AS a, pg_proc AS p
|
|
|
|
WHERE a.aggfnoid = p.oid AND a.aggsortop = o.oid
|
|
|
|
ORDER BY 1;
|
|
|
|
|
|
|
|
-- Check datatypes match
|
|
|
|
|
|
|
|
SELECT a.aggfnoid::oid, o.oid
|
|
|
|
FROM pg_operator AS o, pg_aggregate AS a, pg_proc AS p
|
|
|
|
WHERE a.aggfnoid = p.oid AND a.aggsortop = o.oid AND
|
|
|
|
(oprkind != 'b' OR oprresult != 'boolean'::regtype
|
|
|
|
OR oprleft != p.proargtypes[0] OR oprright != p.proargtypes[0]);
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- Check operator is a suitable btree opfamily member
|
2005-04-12 06:26:34 +02:00
|
|
|
|
|
|
|
SELECT a.aggfnoid::oid, o.oid
|
|
|
|
FROM pg_operator AS o, pg_aggregate AS a, pg_proc AS p
|
|
|
|
WHERE a.aggfnoid = p.oid AND a.aggsortop = o.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
NOT EXISTS(SELECT 1 FROM pg_amop
|
|
|
|
WHERE amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree')
|
|
|
|
AND amopopr = o.oid
|
|
|
|
AND amoplefttype = o.oprleft
|
|
|
|
AND amoprighttype = o.oprright);
|
2005-04-12 06:26:34 +02:00
|
|
|
|
|
|
|
-- Check correspondence of btree strategies and names
|
|
|
|
|
|
|
|
SELECT DISTINCT proname, oprname, amopstrategy
|
|
|
|
FROM pg_operator AS o, pg_aggregate AS a, pg_proc AS p,
|
2006-12-23 01:43:13 +01:00
|
|
|
pg_amop as ao
|
2005-04-12 06:26:34 +02:00
|
|
|
WHERE a.aggfnoid = p.oid AND a.aggsortop = o.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
amopopr = o.oid AND
|
|
|
|
amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree')
|
|
|
|
ORDER BY 1, 2;
|
|
|
|
|
2010-08-05 20:21:19 +02:00
|
|
|
-- Check that there are not aggregates with the same name and different
|
|
|
|
-- numbers of arguments. While not technically wrong, we have a project policy
|
|
|
|
-- to avoid this because it opens the door for confusion in connection with
|
|
|
|
-- ORDER BY: novices frequently put the ORDER BY in the wrong place.
|
|
|
|
-- See the fate of the single-argument form of string_agg() for history.
|
|
|
|
-- The only aggregates that should show up here are count(x) and count(*).
|
|
|
|
|
|
|
|
SELECT p1.oid::regprocedure, p2.oid::regprocedure
|
|
|
|
FROM pg_proc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.oid < p2.oid AND p1.proname = p2.proname AND
|
|
|
|
p1.proisagg AND p2.proisagg AND
|
|
|
|
array_dims(p1.proargtypes) != array_dims(p2.proargtypes)
|
|
|
|
ORDER BY 1;
|
|
|
|
|
|
|
|
-- For the same reason, aggregates with default arguments are no good.
|
|
|
|
|
|
|
|
SELECT oid, proname
|
|
|
|
FROM pg_proc AS p
|
|
|
|
WHERE proisagg AND proargdefaults IS NOT NULL;
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- **************** pg_opfamily ****************
|
|
|
|
|
|
|
|
-- Look for illegal values in pg_opfamily fields
|
|
|
|
|
|
|
|
SELECT p1.oid
|
|
|
|
FROM pg_opfamily as p1
|
|
|
|
WHERE p1.opfmethod = 0 OR p1.opfnamespace = 0;
|
2005-04-12 06:26:34 +02:00
|
|
|
|
2000-06-19 05:55:01 +02:00
|
|
|
-- **************** pg_opclass ****************
|
|
|
|
|
2001-08-21 18:36:06 +02:00
|
|
|
-- Look for illegal values in pg_opclass fields
|
|
|
|
|
|
|
|
SELECT p1.oid
|
2006-12-23 01:43:13 +01:00
|
|
|
FROM pg_opclass AS p1
|
|
|
|
WHERE p1.opcmethod = 0 OR p1.opcnamespace = 0 OR p1.opcfamily = 0
|
|
|
|
OR p1.opcintype = 0;
|
|
|
|
|
|
|
|
-- opcmethod must match owning opfamily's opfmethod
|
|
|
|
|
|
|
|
SELECT p1.oid, p2.oid
|
|
|
|
FROM pg_opclass AS p1, pg_opfamily AS p2
|
|
|
|
WHERE p1.opcfamily = p2.oid AND p1.opcmethod != p2.opfmethod;
|
2001-08-21 18:36:06 +02:00
|
|
|
|
|
|
|
-- There should not be multiple entries in pg_opclass with opcdefault true
|
2006-12-23 01:43:13 +01:00
|
|
|
-- and the same opcmethod/opcintype combination.
|
2000-06-19 05:55:01 +02:00
|
|
|
|
|
|
|
SELECT p1.oid, p2.oid
|
|
|
|
FROM pg_opclass AS p1, pg_opclass AS p2
|
|
|
|
WHERE p1.oid != p2.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.opcmethod = p2.opcmethod AND p1.opcintype = p2.opcintype AND
|
2001-08-21 18:36:06 +02:00
|
|
|
p1.opcdefault AND p2.opcdefault;
|
2000-06-19 05:55:01 +02:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- **************** pg_amop ****************
|
|
|
|
|
|
|
|
-- Look for illegal values in pg_amop fields
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopstrategy
|
1999-03-28 04:07:58 +02:00
|
|
|
FROM pg_amop as p1
|
2006-12-23 01:43:13 +01:00
|
|
|
WHERE p1.amopfamily = 0 OR p1.amoplefttype = 0 OR p1.amoprighttype = 0
|
|
|
|
OR p1.amopopr = 0 OR p1.amopmethod = 0 OR p1.amopstrategy < 1;
|
|
|
|
|
2010-11-24 20:20:39 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopstrategy
|
|
|
|
FROM pg_amop as p1
|
|
|
|
WHERE NOT ((p1.amoppurpose = 's' AND p1.amopsortfamily = 0) OR
|
|
|
|
(p1.amoppurpose = 'o' AND p1.amopsortfamily <> 0));
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- amoplefttype/amoprighttype must match the operator
|
|
|
|
|
|
|
|
SELECT p1.oid, p2.oid
|
|
|
|
FROM pg_amop AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.amopopr = p2.oid AND NOT
|
|
|
|
(p1.amoplefttype = p2.oprleft AND p1.amoprighttype = p2.oprright);
|
|
|
|
|
|
|
|
-- amopmethod must match owning opfamily's opfmethod
|
|
|
|
|
|
|
|
SELECT p1.oid, p2.oid
|
|
|
|
FROM pg_amop AS p1, pg_opfamily AS p2
|
|
|
|
WHERE p1.amopfamily = p2.oid AND p1.amopmethod != p2.opfmethod;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2010-11-24 20:20:39 +01:00
|
|
|
-- amopsortfamily, if present, must reference a btree family
|
|
|
|
|
|
|
|
SELECT p1.amopfamily, p1.amopstrategy
|
|
|
|
FROM pg_amop AS p1
|
|
|
|
WHERE p1.amopsortfamily <> 0 AND NOT EXISTS
|
|
|
|
(SELECT 1 from pg_opfamily op WHERE op.oid = p1.amopsortfamily
|
|
|
|
AND op.opfmethod = (SELECT oid FROM pg_am WHERE amname = 'btree'));
|
|
|
|
|
|
|
|
-- check for ordering operators not supported by parent AM
|
|
|
|
|
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.amname
|
|
|
|
FROM pg_amop AS p1, pg_am AS p2
|
|
|
|
WHERE p1.amopmethod = p2.oid AND
|
|
|
|
p1.amoppurpose = 'o' AND NOT p2.amcanorderbyop;
|
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Cross-check amopstrategy index against parent AM
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.amname
|
|
|
|
FROM pg_amop AS p1, pg_am AS p2
|
|
|
|
WHERE p1.amopmethod = p2.oid AND
|
2006-12-18 19:56:29 +01:00
|
|
|
p1.amopstrategy > p2.amstrategies AND p2.amstrategies <> 0;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2003-11-12 22:15:59 +01:00
|
|
|
-- Detect missing pg_amop entries: should have as many strategy operators
|
2006-12-23 01:43:13 +01:00
|
|
|
-- as AM expects for each datatype combination supported by the opfamily.
|
2006-12-18 19:56:29 +01:00
|
|
|
-- We can't check this for AMs with variable strategy sets.
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amname, p2.amoplefttype, p2.amoprighttype
|
|
|
|
FROM pg_am AS p1, pg_amop AS p2
|
|
|
|
WHERE p2.amopmethod = p1.oid AND
|
2006-12-18 19:56:29 +01:00
|
|
|
p1.amstrategies <> 0 AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.amstrategies != (SELECT count(*) FROM pg_amop AS p3
|
|
|
|
WHERE p3.amopfamily = p2.amopfamily AND
|
|
|
|
p3.amoplefttype = p2.amoplefttype AND
|
2010-11-24 20:20:39 +01:00
|
|
|
p3.amoprighttype = p2.amoprighttype AND
|
|
|
|
p3.amoppurpose = 's');
|
|
|
|
|
|
|
|
-- Currently, none of the AMs with fixed strategy sets support ordering ops.
|
|
|
|
|
|
|
|
SELECT p1.amname, p2.amopfamily, p2.amopstrategy
|
|
|
|
FROM pg_am AS p1, pg_amop AS p2
|
|
|
|
WHERE p2.amopmethod = p1.oid AND
|
|
|
|
p1.amstrategies <> 0 AND p2.amoppurpose <> 's';
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2000-06-19 05:55:01 +02:00
|
|
|
-- Check that amopopr points at a reasonable-looking operator, ie a binary
|
2010-11-24 20:20:39 +01:00
|
|
|
-- operator. If it's a search operator it had better yield boolean,
|
|
|
|
-- otherwise an input type of its sort opfamily.
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.oprname
|
1999-03-28 04:07:58 +02:00
|
|
|
FROM pg_amop AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.amopopr = p2.oid AND
|
2010-11-24 20:20:39 +01:00
|
|
|
p2.oprkind != 'b';
|
|
|
|
|
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.oprname
|
|
|
|
FROM pg_amop AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.amopopr = p2.oid AND p1.amoppurpose = 's' AND
|
|
|
|
p2.oprresult != 'bool'::regtype;
|
|
|
|
|
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.oprname
|
|
|
|
FROM pg_amop AS p1, pg_operator AS p2
|
|
|
|
WHERE p1.amopopr = p2.oid AND p1.amoppurpose = 'o' AND NOT EXISTS
|
|
|
|
(SELECT 1 FROM pg_opclass op
|
|
|
|
WHERE opcfamily = p1.amopsortfamily AND opcintype = p2.oprresult);
|
2003-11-12 22:15:59 +01:00
|
|
|
|
|
|
|
-- Make a list of all the distinct operator names being used in particular
|
|
|
|
-- strategy slots. This is a bit hokey, since the list might need to change
|
|
|
|
-- in future releases, but it's an effective way of spotting mistakes such as
|
2006-12-23 01:43:13 +01:00
|
|
|
-- swapping two operators within a family.
|
2003-11-12 22:15:59 +01:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT DISTINCT amopmethod, amopstrategy, oprname
|
|
|
|
FROM pg_amop p1 LEFT JOIN pg_operator p2 ON amopopr = p2.oid
|
2003-11-12 22:15:59 +01:00
|
|
|
ORDER BY 1, 2, 3;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2010-11-24 20:20:39 +01:00
|
|
|
-- Check that all opclass search operators have selectivity estimators.
|
|
|
|
-- This is not absolutely required, but it seems a reasonable thing
|
|
|
|
-- to insist on for all standard datatypes.
|
2002-04-11 22:00:18 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oid, p2.oprname
|
2002-04-11 22:00:18 +02:00
|
|
|
FROM pg_amop AS p1, pg_operator AS p2
|
2010-11-24 20:20:39 +01:00
|
|
|
WHERE p1.amopopr = p2.oid AND p1.amoppurpose = 's' AND
|
2002-04-11 22:00:18 +02:00
|
|
|
(p2.oprrest = 0 OR p2.oprjoin = 0);
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- Check that each opclass in an opfamily has associated operators, that is
|
|
|
|
-- ones whose oprleft matches opcintype (possibly by coercion).
|
2003-11-12 22:15:59 +01:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.opcname, p1.opcfamily
|
|
|
|
FROM pg_opclass AS p1
|
|
|
|
WHERE NOT EXISTS(SELECT 1 FROM pg_amop AS p2
|
|
|
|
WHERE p2.amopfamily = p1.opcfamily
|
|
|
|
AND binary_coercible(p1.opcintype, p2.amoplefttype));
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2004-03-22 02:38:18 +01:00
|
|
|
-- Operators that are primary members of opclasses must be immutable (else
|
|
|
|
-- it suggests that the index ordering isn't fixed). Operators that are
|
|
|
|
-- cross-type members need only be stable, since they are just shorthands
|
|
|
|
-- for index probe queries.
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oprname, p3.prosrc
|
2004-03-22 02:38:18 +01:00
|
|
|
FROM pg_amop AS p1, pg_operator AS p2, pg_proc AS p3
|
|
|
|
WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.amoplefttype = p1.amoprighttype AND
|
2004-03-22 02:38:18 +01:00
|
|
|
p3.provolatile != 'i';
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amopfamily, p1.amopopr, p2.oprname, p3.prosrc
|
2004-03-22 02:38:18 +01:00
|
|
|
FROM pg_amop AS p1, pg_operator AS p2, pg_proc AS p3
|
|
|
|
WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.amoplefttype != p1.amoprighttype AND
|
2004-03-22 02:38:18 +01:00
|
|
|
p3.provolatile = 'v';
|
|
|
|
|
2007-02-06 03:59:15 +01:00
|
|
|
-- Multiple-datatype btree opfamilies should provide closed sets of equality
|
2006-12-23 01:43:13 +01:00
|
|
|
-- operators; that is if you provide int2 = int4 and int4 = int8 then you
|
2007-02-06 03:59:15 +01:00
|
|
|
-- should also provide int2 = int8 (and commutators of all these). This is
|
|
|
|
-- important because the planner tries to deduce additional qual clauses from
|
2006-12-23 01:43:13 +01:00
|
|
|
-- transitivity of mergejoinable operators. If there are clauses
|
2007-02-06 03:59:15 +01:00
|
|
|
-- int2var = int4var and int4var = int8var, the planner will want to deduce
|
|
|
|
-- int2var = int8var ... so there should be a way to represent that. While
|
|
|
|
-- a missing cross-type operator is now only an efficiency loss rather than
|
|
|
|
-- an error condition, it still seems reasonable to insist that all built-in
|
|
|
|
-- opfamilies be complete.
|
2006-12-23 01:43:13 +01:00
|
|
|
|
|
|
|
-- check commutative closure
|
|
|
|
SELECT p1.amoplefttype, p1.amoprighttype
|
|
|
|
FROM pg_amop AS p1
|
|
|
|
WHERE p1.amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree') AND
|
|
|
|
p1.amopstrategy = 3 AND
|
|
|
|
p1.amoplefttype != p1.amoprighttype AND
|
|
|
|
NOT EXISTS(SELECT 1 FROM pg_amop p2 WHERE
|
|
|
|
p2.amopfamily = p1.amopfamily AND
|
|
|
|
p2.amoplefttype = p1.amoprighttype AND
|
|
|
|
p2.amoprighttype = p1.amoplefttype AND
|
|
|
|
p2.amopstrategy = 3);
|
|
|
|
|
|
|
|
-- check transitive closure
|
|
|
|
SELECT p1.amoplefttype, p1.amoprighttype, p2.amoprighttype
|
|
|
|
FROM pg_amop AS p1, pg_amop AS p2
|
|
|
|
WHERE p1.amopfamily = p2.amopfamily AND
|
|
|
|
p1.amoprighttype = p2.amoplefttype AND
|
|
|
|
p1.amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree') AND
|
|
|
|
p2.amopmethod = (SELECT oid FROM pg_am WHERE amname = 'btree') AND
|
|
|
|
p1.amopstrategy = 3 AND p2.amopstrategy = 3 AND
|
|
|
|
p1.amoplefttype != p1.amoprighttype AND
|
|
|
|
p2.amoplefttype != p2.amoprighttype AND
|
|
|
|
NOT EXISTS(SELECT 1 FROM pg_amop p3 WHERE
|
|
|
|
p3.amopfamily = p1.amopfamily AND
|
|
|
|
p3.amoplefttype = p1.amoplefttype AND
|
|
|
|
p3.amoprighttype = p2.amoprighttype AND
|
|
|
|
p3.amopstrategy = 3);
|
|
|
|
|
2007-02-06 03:59:15 +01:00
|
|
|
-- We also expect that built-in multiple-datatype hash opfamilies provide
|
|
|
|
-- complete sets of cross-type operators. Again, this isn't required, but
|
|
|
|
-- it is reasonable to expect it for built-in opfamilies.
|
|
|
|
|
|
|
|
-- if same family has x=x and y=y, it should have x=y
|
|
|
|
SELECT p1.amoplefttype, p2.amoplefttype
|
|
|
|
FROM pg_amop AS p1, pg_amop AS p2
|
|
|
|
WHERE p1.amopfamily = p2.amopfamily AND
|
|
|
|
p1.amoplefttype = p1.amoprighttype AND
|
|
|
|
p2.amoplefttype = p2.amoprighttype AND
|
|
|
|
p1.amopmethod = (SELECT oid FROM pg_am WHERE amname = 'hash') AND
|
|
|
|
p2.amopmethod = (SELECT oid FROM pg_am WHERE amname = 'hash') AND
|
|
|
|
p1.amopstrategy = 1 AND p2.amopstrategy = 1 AND
|
|
|
|
p1.amoplefttype != p2.amoplefttype AND
|
|
|
|
NOT EXISTS(SELECT 1 FROM pg_amop p3 WHERE
|
|
|
|
p3.amopfamily = p1.amopfamily AND
|
|
|
|
p3.amoplefttype = p1.amoplefttype AND
|
|
|
|
p3.amoprighttype = p2.amoplefttype AND
|
|
|
|
p3.amopstrategy = 1);
|
|
|
|
|
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- **************** pg_amproc ****************
|
|
|
|
|
|
|
|
-- Look for illegal values in pg_amproc fields
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amprocnum
|
1999-03-28 04:07:58 +02:00
|
|
|
FROM pg_amproc as p1
|
2006-12-23 01:43:13 +01:00
|
|
|
WHERE p1.amprocfamily = 0 OR p1.amproclefttype = 0 OR p1.amprocrighttype = 0
|
|
|
|
OR p1.amprocnum < 1 OR p1.amproc = 0;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
-- Cross-check amprocnum index against parent AM
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amprocnum, p2.oid, p2.amname
|
|
|
|
FROM pg_amproc AS p1, pg_am AS p2, pg_opfamily AS p3
|
|
|
|
WHERE p1.amprocfamily = p3.oid AND p3.opfmethod = p2.oid AND
|
2001-08-21 18:36:06 +02:00
|
|
|
p1.amprocnum > p2.amsupport;
|
1999-03-28 04:07:58 +02:00
|
|
|
|
|
|
|
-- Detect missing pg_amproc entries: should have as many support functions
|
2006-12-23 01:43:13 +01:00
|
|
|
-- as AM expects for each datatype combination supported by the opfamily.
|
2011-05-19 00:14:45 +02:00
|
|
|
-- GiST/GIN are special cases because each has an optional support function.
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amname, p2.opfname, p3.amproclefttype, p3.amprocrighttype
|
|
|
|
FROM pg_am AS p1, pg_opfamily AS p2, pg_amproc AS p3
|
|
|
|
WHERE p2.opfmethod = p1.oid AND p3.amprocfamily = p2.oid AND
|
2010-12-04 02:52:18 +01:00
|
|
|
p1.amname <> 'gist' AND p1.amname <> 'gin' AND
|
2003-11-12 22:15:59 +01:00
|
|
|
p1.amsupport != (SELECT count(*) FROM pg_amproc AS p4
|
2006-12-23 01:43:13 +01:00
|
|
|
WHERE p4.amprocfamily = p2.oid AND
|
|
|
|
p4.amproclefttype = p3.amproclefttype AND
|
|
|
|
p4.amprocrighttype = p3.amprocrighttype);
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2011-05-19 00:14:45 +02:00
|
|
|
-- Similar check for GiST/GIN, allowing one optional proc
|
2008-05-16 18:31:02 +02:00
|
|
|
|
|
|
|
SELECT p1.amname, p2.opfname, p3.amproclefttype, p3.amprocrighttype
|
|
|
|
FROM pg_am AS p1, pg_opfamily AS p2, pg_amproc AS p3
|
|
|
|
WHERE p2.opfmethod = p1.oid AND p3.amprocfamily = p2.oid AND
|
2010-12-04 02:52:18 +01:00
|
|
|
(p1.amname = 'gist' OR p1.amname = 'gin') AND
|
|
|
|
(SELECT count(*) FROM pg_amproc AS p4
|
|
|
|
WHERE p4.amprocfamily = p2.oid AND
|
|
|
|
p4.amproclefttype = p3.amproclefttype AND
|
|
|
|
p4.amprocrighttype = p3.amprocrighttype)
|
|
|
|
NOT IN (p1.amsupport, p1.amsupport - 1);
|
2008-05-16 18:31:02 +02:00
|
|
|
|
2007-09-03 03:18:33 +02:00
|
|
|
-- Also, check if there are any pg_opclass entries that don't seem to have
|
2011-05-19 00:14:45 +02:00
|
|
|
-- pg_amproc support. Again, GiST/GIN have to be checked specially.
|
2007-09-03 03:18:33 +02:00
|
|
|
|
|
|
|
SELECT amname, opcname, count(*)
|
|
|
|
FROM pg_am am JOIN pg_opclass op ON opcmethod = am.oid
|
|
|
|
LEFT JOIN pg_amproc p ON amprocfamily = opcfamily AND
|
|
|
|
amproclefttype = amprocrighttype AND amproclefttype = opcintype
|
2010-12-04 02:52:18 +01:00
|
|
|
WHERE am.amname <> 'gist' AND am.amname <> 'gin'
|
2007-09-03 03:18:33 +02:00
|
|
|
GROUP BY amname, amsupport, opcname, amprocfamily
|
|
|
|
HAVING count(*) != amsupport OR amprocfamily IS NULL;
|
|
|
|
|
2008-05-16 18:31:02 +02:00
|
|
|
SELECT amname, opcname, count(*)
|
|
|
|
FROM pg_am am JOIN pg_opclass op ON opcmethod = am.oid
|
|
|
|
LEFT JOIN pg_amproc p ON amprocfamily = opcfamily AND
|
|
|
|
amproclefttype = amprocrighttype AND amproclefttype = opcintype
|
2010-12-04 02:52:18 +01:00
|
|
|
WHERE am.amname = 'gist' OR am.amname = 'gin'
|
2008-05-16 18:31:02 +02:00
|
|
|
GROUP BY amname, amsupport, opcname, amprocfamily
|
2010-12-04 02:52:18 +01:00
|
|
|
HAVING (count(*) != amsupport AND count(*) != amsupport - 1)
|
|
|
|
OR amprocfamily IS NULL;
|
2008-05-16 18:31:02 +02:00
|
|
|
|
1999-03-28 04:07:58 +02:00
|
|
|
-- Unfortunately, we can't check the amproc link very well because the
|
|
|
|
-- signature of the function may be different for different support routines
|
|
|
|
-- or different base data types.
|
|
|
|
-- We can check that all the referenced instances of the same support
|
2003-05-26 02:11:29 +02:00
|
|
|
-- routine number take the same number of parameters, but that's about it
|
|
|
|
-- for a general check...
|
1999-03-28 04:07:58 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amprocnum,
|
2001-08-10 20:57:42 +02:00
|
|
|
p2.oid, p2.proname,
|
2006-12-23 01:43:13 +01:00
|
|
|
p3.opfname,
|
|
|
|
p4.amprocfamily, p4.amprocnum,
|
2001-08-21 18:36:06 +02:00
|
|
|
p5.oid, p5.proname,
|
2006-12-23 01:43:13 +01:00
|
|
|
p6.opfname
|
|
|
|
FROM pg_amproc AS p1, pg_proc AS p2, pg_opfamily AS p3,
|
|
|
|
pg_amproc AS p4, pg_proc AS p5, pg_opfamily AS p6
|
|
|
|
WHERE p1.amprocfamily = p3.oid AND p4.amprocfamily = p6.oid AND
|
|
|
|
p3.opfmethod = p6.opfmethod AND p1.amprocnum = p4.amprocnum AND
|
2001-08-21 18:36:06 +02:00
|
|
|
p1.amproc = p2.oid AND p4.amproc = p5.oid AND
|
|
|
|
(p2.proretset OR p5.proretset OR p2.pronargs != p5.pronargs);
|
2003-05-26 02:11:29 +02:00
|
|
|
|
|
|
|
-- For btree, though, we can do better since we know the support routines
|
2006-12-23 01:43:13 +01:00
|
|
|
-- must be of the form cmp(lefttype, righttype) returns int4.
|
2003-06-23 00:04:55 +02:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amprocnum,
|
2003-11-12 22:15:59 +01:00
|
|
|
p2.oid, p2.proname,
|
2006-12-23 01:43:13 +01:00
|
|
|
p3.opfname
|
|
|
|
FROM pg_amproc AS p1, pg_proc AS p2, pg_opfamily AS p3
|
|
|
|
WHERE p3.opfmethod = (SELECT oid FROM pg_am WHERE amname = 'btree')
|
|
|
|
AND p1.amprocfamily = p3.oid AND p1.amproc = p2.oid AND
|
|
|
|
(amprocnum != 1
|
2003-11-12 22:15:59 +01:00
|
|
|
OR proretset
|
2006-12-23 01:43:13 +01:00
|
|
|
OR prorettype != 'int4'::regtype
|
2003-11-12 22:15:59 +01:00
|
|
|
OR pronargs != 2
|
2006-12-23 01:43:13 +01:00
|
|
|
OR proargtypes[0] != amproclefttype
|
|
|
|
OR proargtypes[1] != amprocrighttype);
|
2003-11-12 22:15:59 +01:00
|
|
|
|
2003-06-23 00:04:55 +02:00
|
|
|
-- For hash we can also do a little better: the support routines must be
|
2006-12-23 01:43:13 +01:00
|
|
|
-- of the form hash(lefttype) returns int4. There are several cases where
|
|
|
|
-- we cheat and use a hash function that is physically compatible with the
|
2007-07-06 06:16:00 +02:00
|
|
|
-- datatype even though there's no cast, so this check does find a small
|
|
|
|
-- number of entries.
|
2003-06-23 00:04:55 +02:00
|
|
|
|
2007-07-06 06:16:00 +02:00
|
|
|
SELECT p1.amprocfamily, p1.amprocnum, p2.proname, p3.opfname
|
2006-12-23 01:43:13 +01:00
|
|
|
FROM pg_amproc AS p1, pg_proc AS p2, pg_opfamily AS p3
|
|
|
|
WHERE p3.opfmethod = (SELECT oid FROM pg_am WHERE amname = 'hash')
|
|
|
|
AND p1.amprocfamily = p3.oid AND p1.amproc = p2.oid AND
|
|
|
|
(amprocnum != 1
|
2003-06-23 00:04:55 +02:00
|
|
|
OR proretset
|
2006-12-23 01:43:13 +01:00
|
|
|
OR prorettype != 'int4'::regtype
|
2003-06-23 00:04:55 +02:00
|
|
|
OR pronargs != 1
|
2007-07-06 06:16:00 +02:00
|
|
|
OR NOT physically_coercible(amproclefttype, proargtypes[0])
|
|
|
|
OR amproclefttype != amprocrighttype)
|
|
|
|
ORDER BY 1;
|
2004-03-22 02:38:18 +01:00
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
-- Support routines that are primary members of opfamilies must be immutable
|
2004-03-22 02:38:18 +01:00
|
|
|
-- (else it suggests that the index ordering isn't fixed). But cross-type
|
|
|
|
-- members need only be stable, since they are just shorthands
|
|
|
|
-- for index probe queries.
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amproc, p2.prosrc
|
2004-03-22 02:38:18 +01:00
|
|
|
FROM pg_amproc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.amproc = p2.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.amproclefttype = p1.amprocrighttype AND
|
2004-03-22 02:38:18 +01:00
|
|
|
p2.provolatile != 'i';
|
|
|
|
|
2006-12-23 01:43:13 +01:00
|
|
|
SELECT p1.amprocfamily, p1.amproc, p2.prosrc
|
2004-03-22 02:38:18 +01:00
|
|
|
FROM pg_amproc AS p1, pg_proc AS p2
|
|
|
|
WHERE p1.amproc = p2.oid AND
|
2006-12-23 01:43:13 +01:00
|
|
|
p1.amproclefttype != p1.amprocrighttype AND
|
2004-03-22 02:38:18 +01:00
|
|
|
p2.provolatile = 'v';
|