← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/postgresql-9.1/oneiric-security

« back to all changes in this revision

Viewing changes to src/test/regress/expected/type_sanity.out

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/regress/expected/type_sanity.out
 
1
--
 
2
-- TYPE_SANITY
 
3
-- Sanity checks for common errors in making type-related system tables:
 
4
-- pg_type, pg_class, pg_attribute.
 
5
--
 
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.
 
9
--
 
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.
 
14
-- **************** pg_type ****************
 
15
-- Look for illegal values in pg_type fields.
 
16
SELECT p1.oid, p1.typname
 
17
FROM pg_type as p1
 
18
WHERE p1.typnamespace = 0 OR
 
19
    (p1.typlen <= 0 AND p1.typlen != -1 AND p1.typlen != -2) OR
 
20
    (p1.typtype not in ('b', 'c', 'd', 'e', 'p')) OR
 
21
    NOT p1.typisdefined OR
 
22
    (p1.typalign not in ('c', 's', 'i', 'd')) OR
 
23
    (p1.typstorage not in ('p', 'x', 'e', 'm'));
 
24
 oid | typname 
 
25
-----+---------
 
26
(0 rows)
 
27
 
 
28
-- Look for "pass by value" types that can't be passed by value.
 
29
SELECT p1.oid, p1.typname
 
30
FROM pg_type as p1
 
31
WHERE p1.typbyval AND
 
32
    (p1.typlen != 1 OR p1.typalign != 'c') AND
 
33
    (p1.typlen != 2 OR p1.typalign != 's') AND
 
34
    (p1.typlen != 4 OR p1.typalign != 'i') AND
 
35
    (p1.typlen != 8 OR p1.typalign != 'd');
 
36
 oid | typname 
 
37
-----+---------
 
38
(0 rows)
 
39
 
 
40
-- Look for "toastable" types that aren't varlena.
 
41
SELECT p1.oid, p1.typname
 
42
FROM pg_type as p1
 
43
WHERE p1.typstorage != 'p' AND
 
44
    (p1.typbyval OR p1.typlen != -1);
 
45
 oid | typname 
 
46
-----+---------
 
47
(0 rows)
 
48
 
 
49
-- Look for complex types that do not have a typrelid entry,
 
50
-- or basic types that do.
 
51
SELECT p1.oid, p1.typname
 
52
FROM pg_type as p1
 
53
WHERE (p1.typtype = 'c' AND p1.typrelid = 0) OR
 
54
    (p1.typtype != 'c' AND p1.typrelid != 0);
 
55
 oid | typname 
 
56
-----+---------
 
57
(0 rows)
 
58
 
 
59
-- Look for basic or enum types that don't have an array type.
 
60
-- NOTE: as of 9.1, this check finds pg_node_tree, smgr, and unknown.
 
61
SELECT p1.oid, p1.typname
 
62
FROM pg_type as p1
 
63
WHERE p1.typtype in ('b','e') AND p1.typname NOT LIKE E'\\_%' AND NOT EXISTS
 
64
    (SELECT 1 FROM pg_type as p2
 
65
     WHERE p2.typname = ('_' || p1.typname)::name AND
 
66
           p2.typelem = p1.oid and p1.typarray = p2.oid);
 
67
 oid |   typname    
 
68
-----+--------------
 
69
 194 | pg_node_tree
 
70
 210 | smgr
 
71
 705 | unknown
 
72
(3 rows)
 
73
 
 
74
-- Make sure typarray points to a varlena array type of our own base
 
75
SELECT p1.oid, p1.typname as basetype, p2.typname as arraytype,
 
76
       p2.typelem, p2.typlen
 
77
FROM   pg_type p1 LEFT JOIN pg_type p2 ON (p1.typarray = p2.oid)
 
78
WHERE  p1.typarray <> 0 AND
 
79
       (p2.oid IS NULL OR p2.typelem <> p1.oid OR p2.typlen <> -1);
 
80
 oid | basetype | arraytype | typelem | typlen 
 
81
-----+----------+-----------+---------+--------
 
82
(0 rows)
 
83
 
 
84
-- Text conversion routines must be provided.
 
85
SELECT p1.oid, p1.typname
 
86
FROM pg_type as p1
 
87
WHERE (p1.typinput = 0 OR p1.typoutput = 0);
 
88
 oid | typname 
 
89
-----+---------
 
90
(0 rows)
 
91
 
 
92
-- Check for bogus typinput routines
 
93
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
94
FROM pg_type AS p1, pg_proc AS p2
 
95
WHERE p1.typinput = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
96
    ((p2.pronargs = 1 AND p2.proargtypes[0] = 'cstring'::regtype) OR
 
97
     (p2.pronargs = 3 AND p2.proargtypes[0] = 'cstring'::regtype AND
 
98
      p2.proargtypes[1] = 'oid'::regtype AND
 
99
      p2.proargtypes[2] = 'int4'::regtype));
 
100
 oid | typname | oid | proname 
 
101
-----+---------+-----+---------
 
102
(0 rows)
 
103
 
 
104
-- As of 8.0, this check finds refcursor, which is borrowing
 
105
-- other types' I/O routines
 
106
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
107
FROM pg_type AS p1, pg_proc AS p2
 
108
WHERE p1.typinput = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
109
    (p1.typelem != 0 AND p1.typlen < 0) AND NOT
 
110
    (p2.prorettype = p1.oid AND NOT p2.proretset)
 
111
ORDER BY 1;
 
112
 oid  |  typname  | oid | proname 
 
113
------+-----------+-----+---------
 
114
 1790 | refcursor |  46 | textin
 
115
(1 row)
 
116
 
 
117
-- Varlena array types will point to array_in
 
118
-- Exception as of 8.1: int2vector and oidvector have their own I/O routines
 
119
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
120
FROM pg_type AS p1, pg_proc AS p2
 
121
WHERE p1.typinput = p2.oid AND p1.typtype in ('b', 'p') AND
 
122
    (p1.typelem != 0 AND p1.typlen < 0) AND NOT
 
123
    (p2.oid = 'array_in'::regproc)
 
124
ORDER BY 1;
 
125
 oid |  typname   | oid |   proname    
 
126
-----+------------+-----+--------------
 
127
  22 | int2vector |  40 | int2vectorin
 
128
  30 | oidvector  |  54 | oidvectorin
 
129
(2 rows)
 
130
 
 
131
-- Check for bogus typoutput routines
 
132
-- As of 8.0, this check finds refcursor, which is borrowing
 
133
-- other types' I/O routines
 
134
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
135
FROM pg_type AS p1, pg_proc AS p2
 
136
WHERE p1.typoutput = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
137
    (p2.pronargs = 1 AND
 
138
     (p2.proargtypes[0] = p1.oid OR
 
139
      (p2.oid = 'array_out'::regproc AND
 
140
       p1.typelem != 0 AND p1.typlen = -1)))
 
141
ORDER BY 1;
 
142
 oid  |  typname  | oid | proname 
 
143
------+-----------+-----+---------
 
144
 1790 | refcursor |  47 | textout
 
145
(1 row)
 
146
 
 
147
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
148
FROM pg_type AS p1, pg_proc AS p2
 
149
WHERE p1.typoutput = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
150
    (p2.prorettype = 'cstring'::regtype AND NOT p2.proretset);
 
151
 oid | typname | oid | proname 
 
152
-----+---------+-----+---------
 
153
(0 rows)
 
154
 
 
155
-- Check for bogus typreceive routines
 
156
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
157
FROM pg_type AS p1, pg_proc AS p2
 
158
WHERE p1.typreceive = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
159
    ((p2.pronargs = 1 AND p2.proargtypes[0] = 'internal'::regtype) OR
 
160
     (p2.pronargs = 3 AND p2.proargtypes[0] = 'internal'::regtype AND
 
161
      p2.proargtypes[1] = 'oid'::regtype AND
 
162
      p2.proargtypes[2] = 'int4'::regtype));
 
163
 oid | typname | oid | proname 
 
164
-----+---------+-----+---------
 
165
(0 rows)
 
166
 
 
167
-- As of 7.4, this check finds refcursor, which is borrowing
 
168
-- other types' I/O routines
 
169
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
170
FROM pg_type AS p1, pg_proc AS p2
 
171
WHERE p1.typreceive = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
172
    (p1.typelem != 0 AND p1.typlen < 0) AND NOT
 
173
    (p2.prorettype = p1.oid AND NOT p2.proretset)
 
174
ORDER BY 1;
 
175
 oid  |  typname  | oid  | proname  
 
176
------+-----------+------+----------
 
177
 1790 | refcursor | 2414 | textrecv
 
178
(1 row)
 
179
 
 
180
-- Varlena array types will point to array_recv
 
181
-- Exception as of 8.1: int2vector and oidvector have their own I/O routines
 
182
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
183
FROM pg_type AS p1, pg_proc AS p2
 
184
WHERE p1.typreceive = p2.oid AND p1.typtype in ('b', 'p') AND
 
185
    (p1.typelem != 0 AND p1.typlen < 0) AND NOT
 
186
    (p2.oid = 'array_recv'::regproc)
 
187
ORDER BY 1;
 
188
 oid |  typname   | oid  |    proname     
 
189
-----+------------+------+----------------
 
190
  22 | int2vector | 2410 | int2vectorrecv
 
191
  30 | oidvector  | 2420 | oidvectorrecv
 
192
(2 rows)
 
193
 
 
194
-- Suspicious if typreceive doesn't take same number of args as typinput
 
195
SELECT p1.oid, p1.typname, p2.oid, p2.proname, p3.oid, p3.proname
 
196
FROM pg_type AS p1, pg_proc AS p2, pg_proc AS p3
 
197
WHERE p1.typinput = p2.oid AND p1.typreceive = p3.oid AND
 
198
    p2.pronargs != p3.pronargs;
 
199
 oid | typname | oid | proname | oid | proname 
 
200
-----+---------+-----+---------+-----+---------
 
201
(0 rows)
 
202
 
 
203
-- Check for bogus typsend routines
 
204
-- As of 7.4, this check finds refcursor, which is borrowing
 
205
-- other types' I/O routines
 
206
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
207
FROM pg_type AS p1, pg_proc AS p2
 
208
WHERE p1.typsend = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
209
    (p2.pronargs = 1 AND
 
210
     (p2.proargtypes[0] = p1.oid OR
 
211
      (p2.oid = 'array_send'::regproc AND
 
212
       p1.typelem != 0 AND p1.typlen = -1)))
 
213
ORDER BY 1;
 
214
 oid  |  typname  | oid  | proname  
 
215
------+-----------+------+----------
 
216
 1790 | refcursor | 2415 | textsend
 
217
(1 row)
 
218
 
 
219
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
220
FROM pg_type AS p1, pg_proc AS p2
 
221
WHERE p1.typsend = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
222
    (p2.prorettype = 'bytea'::regtype AND NOT p2.proretset);
 
223
 oid | typname | oid | proname 
 
224
-----+---------+-----+---------
 
225
(0 rows)
 
226
 
 
227
-- Check for bogus typmodin routines
 
228
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
229
FROM pg_type AS p1, pg_proc AS p2
 
230
WHERE p1.typmodin = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
231
    (p2.pronargs = 1 AND
 
232
     p2.proargtypes[0] = 'cstring[]'::regtype AND
 
233
     p2.prorettype = 'int4'::regtype AND NOT p2.proretset);
 
234
 oid | typname | oid | proname 
 
235
-----+---------+-----+---------
 
236
(0 rows)
 
237
 
 
238
-- Check for bogus typmodout routines
 
239
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
240
FROM pg_type AS p1, pg_proc AS p2
 
241
WHERE p1.typmodout = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
242
    (p2.pronargs = 1 AND
 
243
     p2.proargtypes[0] = 'int4'::regtype AND
 
244
     p2.prorettype = 'cstring'::regtype AND NOT p2.proretset);
 
245
 oid | typname | oid | proname 
 
246
-----+---------+-----+---------
 
247
(0 rows)
 
248
 
 
249
-- Array types should have same typmodin/out as their element types
 
250
SELECT p1.oid, p1.typname, p2.oid, p2.typname
 
251
FROM pg_type AS p1, pg_type AS p2
 
252
WHERE p1.typelem = p2.oid AND NOT
 
253
    (p1.typmodin = p2.typmodin AND p1.typmodout = p2.typmodout);
 
254
 oid | typname | oid | typname 
 
255
-----+---------+-----+---------
 
256
(0 rows)
 
257
 
 
258
-- Array types should have same typdelim as their element types
 
259
SELECT p1.oid, p1.typname, p2.oid, p2.typname
 
260
FROM pg_type AS p1, pg_type AS p2
 
261
WHERE p1.typarray = p2.oid AND NOT (p1.typdelim = p2.typdelim);
 
262
 oid | typname | oid | typname 
 
263
-----+---------+-----+---------
 
264
(0 rows)
 
265
 
 
266
-- Check for bogus typanalyze routines
 
267
SELECT p1.oid, p1.typname, p2.oid, p2.proname
 
268
FROM pg_type AS p1, pg_proc AS p2
 
269
WHERE p1.typanalyze = p2.oid AND p1.typtype in ('b', 'p') AND NOT
 
270
    (p2.pronargs = 1 AND
 
271
     p2.proargtypes[0] = 'internal'::regtype AND
 
272
     p2.prorettype = 'bool'::regtype AND NOT p2.proretset);
 
273
 oid | typname | oid | proname 
 
274
-----+---------+-----+---------
 
275
(0 rows)
 
276
 
 
277
-- **************** pg_class ****************
 
278
-- Look for illegal values in pg_class fields
 
279
SELECT p1.oid, p1.relname
 
280
FROM pg_class as p1
 
281
WHERE p1.relkind NOT IN ('r', 'i', 's', 'S', 'c', 't', 'v', 'f');
 
282
 oid | relname 
 
283
-----+---------
 
284
(0 rows)
 
285
 
 
286
-- Indexes should have an access method, others not.
 
287
SELECT p1.oid, p1.relname
 
288
FROM pg_class as p1
 
289
WHERE (p1.relkind = 'i' AND p1.relam = 0) OR
 
290
    (p1.relkind != 'i' AND p1.relam != 0);
 
291
 oid | relname 
 
292
-----+---------
 
293
(0 rows)
 
294
 
 
295
-- **************** pg_attribute ****************
 
296
-- Look for illegal values in pg_attribute fields
 
297
SELECT p1.attrelid, p1.attname
 
298
FROM pg_attribute as p1
 
299
WHERE p1.attrelid = 0 OR p1.atttypid = 0 OR p1.attnum = 0 OR
 
300
    p1.attcacheoff != -1 OR p1.attinhcount < 0 OR
 
301
    (p1.attinhcount = 0 AND NOT p1.attislocal);
 
302
 attrelid | attname 
 
303
----------+---------
 
304
(0 rows)
 
305
 
 
306
-- Cross-check attnum against parent relation
 
307
SELECT p1.attrelid, p1.attname, p2.oid, p2.relname
 
308
FROM pg_attribute AS p1, pg_class AS p2
 
309
WHERE p1.attrelid = p2.oid AND p1.attnum > p2.relnatts;
 
310
 attrelid | attname | oid | relname 
 
311
----------+---------+-----+---------
 
312
(0 rows)
 
313
 
 
314
-- Detect missing pg_attribute entries: should have as many non-system
 
315
-- attributes as parent relation expects
 
316
SELECT p1.oid, p1.relname
 
317
FROM pg_class AS p1
 
318
WHERE p1.relnatts != (SELECT count(*) FROM pg_attribute AS p2
 
319
                      WHERE p2.attrelid = p1.oid AND p2.attnum > 0);
 
320
 oid | relname 
 
321
-----+---------
 
322
(0 rows)
 
323
 
 
324
-- Cross-check against pg_type entry
 
325
-- NOTE: we allow attstorage to be 'plain' even when typstorage is not;
 
326
-- this is mainly for toast tables.
 
327
SELECT p1.attrelid, p1.attname, p2.oid, p2.typname
 
328
FROM pg_attribute AS p1, pg_type AS p2
 
329
WHERE p1.atttypid = p2.oid AND
 
330
    (p1.attlen != p2.typlen OR
 
331
     p1.attalign != p2.typalign OR
 
332
     p1.attbyval != p2.typbyval OR
 
333
     (p1.attstorage != p2.typstorage AND p1.attstorage != 'p'));
 
334
 attrelid | attname | oid | typname 
 
335
----------+---------+-----+---------
 
336
(0 rows)
 
337